1adrianb / binary-networks-pytorch Goto Github PK

        self.act1 = activation(inpace=True) if activation == nn.ReLU else activation(num_parameters=planes)
        self.act2 = activation(inpace=True) if activation == nn.ReLU else activation(num_parameters=planes)

        self.act1 = activation(inplace=True) if activation == nn.ReLU else activation(num_parameters=planes)
        self.act2 = activation(inplace=True) if activation == nn.ReLU else activation(num_parameters=planes)

    An attempt has been made to start a new process before
    the current process has finished its bootstrapping phase.

    This probably means that you are not using fork to start your
    child processes and you have forgotten to use the proper idiom
    in the main module:

        if __name__ == '__main__':
            freeze_support()
            ...

    The "freeze_support()" line can be omitted if the program
    is not going to be frozen to produce an executable.
ForkingPickler(file, protocol).dump(obj)
BrokenPipeError: [Errno 32] Broken pipe

self.activation_post_process(
            self._conv_forward(input_proc, self.weight_pre_process(self.weight), bias=self.bias),
            input
        )

Train Epoch: 0
/home/pgay/miniconda3/lib/python3.7/site-packages/torch/nn/functional.py:718: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at  /pytorch/c10/core/TensorImpl.h:1156.)
  return torch.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)
Traceback (most recent call last):
  File "examples/cifar10.py", line 171, in <module>
    train(epoch)
  File "examples/cifar10.py", line 109, in train
    outputs = net(inputs)
  File "/home/pgay/miniconda3/lib/python3.7/site-packages/torch/nn/modules/module.py", line 1051, in _call_impl
    return forward_call(*input, **kwargs)
  File "/home/pgay/miniconda3/lib/python3.7/site-packages/torch/nn/parallel/data_parallel.py", line 166, in forward
    return self.module(*inputs[0], **kwargs[0])
  File "/home/pgay/miniconda3/lib/python3.7/site-packages/torch/nn/modules/module.py", line 1051, in _call_impl
    return forward_call(*input, **kwargs)
  File "/home/pgay/miniconda3/lib/python3.7/site-packages/bnn/models/resnet.py", line 167, in forward
    return self._forward_impl(x)
  File "/home/pgay/miniconda3/lib/python3.7/site-packages/bnn/models/resnet.py", line 155, in _forward_impl
    x = self.layer1(x)
  File "/home/pgay/miniconda3/lib/python3.7/site-packages/torch/nn/modules/module.py", line 1051, in _call_impl
    return forward_call(*input, **kwargs)
  File "/home/pgay/miniconda3/lib/python3.7/site-packages/torch/nn/modules/container.py", line 139, in forward
    input = module(input)
  File "/home/pgay/miniconda3/lib/python3.7/site-packages/torch/nn/modules/module.py", line 1051, in _call_impl
    return forward_call(*input, **kwargs)
  File "/home/pgay/miniconda3/lib/python3.7/site-packages/bnn/models/layers/res_block.py", line 43, in forward
    out = self.conv1(x)
  File "/home/pgay/miniconda3/lib/python3.7/site-packages/torch/nn/modules/module.py", line 1051, in _call_impl
    return forward_call(*input, **kwargs)
  File "/home/pgay/miniconda3/lib/python3.7/site-packages/bnn/layers/conv.py", line 92, in forward
    input
  File "/home/pgay/miniconda3/lib/python3.7/site-packages/torch/nn/modules/module.py", line 1051, in _call_impl
    return forward_call(*input, **kwargs)
TypeError: forward() takes 2 positional arguments but 3 were given

import torch
import torchvision
import torchvision.models as models
import torchvision.transforms as transforms

import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

model = models.vgg19()

from bnn import BConfig, prepare_binary_model
# Import a few examples of quantizers
from bnn.ops import *

# Define the binarization configuration and assign it to the model
bconfig = BConfig(
    activation_pre_process = BasicInputBinarizer,
    activation_post_process = BasicScaleBinarizer,
    # optionally, one can pass certain custom variables
    weight_pre_process = XNORWeightBinarizer.with_args(center_weights=True)
)
# Convert the model appropiately, propagating the changes from parent node to leafs
# The custom_config_layers_name syntax will perform a match based on the layer name, setting a custom quantization function.
bmodel = prepare_binary_model(model, bconfig, custom_config_layers_name=[{'conv1' : BConfig()}])

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(bmodel.parameters(), lr=0.001, momentum=0.9)

print("Training begin!")
# Select GPU 4 as execution device
device = torch.device("cuda:4" if torch.cuda.is_available() else "cpu")

print("The model will be running on", device, "device")
# Convert model parameters and buffers to CPU or Cuda
bmodel.to(device)

save_path = './models/vgg19.pth'

bestaccuracy = 0.0
#break_epoch = 0

t_begin = time()
for epoch in range(50):  # loop over the dataset multiple times

    running_loss = 0.0
    break_epoch = epoch + 1
    
    correct = 0
    total = 0
    for i, data in enumerate(trainloader, 0):
        # get the inputs; data is a list of [inputs, labels]
        inputs, labels = data
        inputs, labels = inputs.cuda(), labels.cuda()
        # zero the parameter gradients
        optimizer.zero_grad()
        
        #print(inputs.size(1))
        
        # forward + backward + optimize
        outputs = bmodel(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        
        # check for correct answer
        _, predictions = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predictions == labels).sum().item()

        # print statistics
        running_loss += loss.item()
        

        if i % 50 == 49:    # print every 50 mini-batches
            print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 50:.3f}')
            running_loss = 0.0
    
    #calculate accurary of epoch
    accuracy = 100 * correct / total
    print(f'Epoch {epoch + 1} accuracy: {accuracy:.3f}')
    
    #If accuracy is better than the last, save the model
    if accuracy > bestaccuracy:
        torch.save(bmodel.state_dict(), save_path)
        bestaccuracy = accuracy
        

time_taken = int(time()-t_begin)
time_min = int(time_taken/60)
time_sec = time_taken - (time_min*60)
print(f'Finished Training! Best accuracy: {bestaccuracy:.3f} - Training time (mm:ss): {time_min}:{time_sec}')