TP_Classification.md

      # voir le code de départ : https://github.com/ucacaxm/DeepLearning_Vision_SimpleExamples/blob/master/src/classifier/classifier_pointcloud_empty.py

        ########################################################################################"
        # Copier/coller juste avant main
        class Net(nn.Module):
           def __init__(self):
               super(Net, self).__init__()
               self.fc1 = nn.Linear(2, 64)
               self.fc2 = nn.Linear(64, 2)

           def forward(self, x):
              x = F.relu(self.fc1(x))
              x = self.fc2(x)
              return x


        ########################################################################################"
        ############# NETWORK definition/configuration => à copier/coller dans le main
        net = Net()
        print(net)

        ############# SGD config: Stochastic Gradient Descent Config
        criterion = nn.CrossEntropyLoss()
        optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

        ############ TRAINNING
        for epoch in range(5):  # loop over the dataset multiple times
            running_loss = 0.0
            for i in range(1000):         # iterate on mini batches. mani-batch = a subset of the database
                inputs, labels = next_batch(128)
                inputs = torch.from_numpy(inputs)
                labels = torch.from_numpy(labels).long()

                # zero the parameter gradients
                optimizer.zero_grad()

                # forward + backward + optimize
                outputs = net(inputs)
                loss = criterion(outputs, torch.max(labels, 1)[1] )
                loss.backward()
                optimizer.step()

                # print statistics
                running_loss += loss.item()
                if i % 100 == 99:    # print every 2000 mini-batches
                    print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 100))
                    running_loss = 0.0


        ############ EVALUATION
        TODO

        ############ DRAWING POINT CLOUD WITH ERROR
        TODO
    x = np.array( [ 2.0*3.141592*np.random.ranf(), 2.0*np.random.ranf()-1 ])
    devient
    x = np.array( [ 4.0*3.141592*np.random.ranf(), 2.0*np.random.ranf()-1 ])
    from torchvision import datasets, transforms
    from torch.autograd import Variable
    import torchvision
    from torchvision.datasets import ImageFolder
    from torch.utils.data import DataLoader
    from torchvision.transforms import ToTensor
    from torch.utils.data.sampler import SubsetRandomSampler


    class MyTransform(object):    # Votre propre fonction de transfo d'images utilisée en preprocessing (si besoin)
        def __call__(self, x):
            y = preprocess(x)
            return y


    def imshow(img):              # Pour afficher une image
        plt.figure(1)
        img = img / 2.0 + 0.5     # unnormalize
        npimg = img.numpy()
        plt.imshow(np.transpose(npimg, (1, 2, 0)))
        #plt.imshow(npimg)
        plt.show()


        transform_img = transforms.Compose([
                MyTransform(),    # Votre propre fonction de transfo d'images utilisée en preprocessing
                transforms.Resize(16),
                #transforms.CenterCrop(256),
                transforms.ToTensor(),
                transforms.Normalize(mean=[0., 0., 0.],
                                     std=[0.5, 0.5, 0.5] )
                ])
        mydata = ImageFolder(root="../data/shapes5_preprocessed", transform=transform_img)
        loader = DataLoader(mydata, batch_size=32, shuffle=True, num_workers=1)

class Classifier(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        nc = 3          # 3 channels RGB
        self.model = nn.Sequential(
            nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 2),
            nn.LeakyReLU(0.2, inplace=True),
            ... # a completer
            nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
            nn.Sigmoid()
        ).to( torch.float32)
        print(self.model)

    def forward(self, input):
        return self.model(input)