diff --git a/.github/workflows/testing_pr.yml b/.github/workflows/testing_pr.yml index c0b63f3..0e739b5 100644 --- a/.github/workflows/testing_pr.yml +++ b/.github/workflows/testing_pr.yml @@ -27,7 +27,7 @@ jobs: - name: Install Python dependencies run: | python3 -m pip install --upgrade pip - python3 -m pip install .[test,vtk] + python3 -m pip install .[test,vtk,ml] - name: Test with pytest run: | diff --git a/setup.py b/setup.py index 0f6045e..e2e703f 100644 --- a/setup.py +++ b/setup.py @@ -23,6 +23,7 @@ EXTRAS = { 'docs': ['Sphinx', 'sphinx_rtd_theme'], 'vtk': ['vtk'], + 'ml': ['torch', 'torchvision', 'scikit-learn', 'tqdm'], 'test': ['pytest', 'pytest-cov'], } diff --git a/smithers/ml/dataset/__init__.py b/smithers/ml/dataset/__init__.py new file mode 100644 index 0000000..e1dba94 --- /dev/null +++ b/smithers/ml/dataset/__init__.py @@ -0,0 +1,11 @@ +''' +Dataset Preparation init +''' +__project__ = 'Object_Detector' +__title__ = 'object_detector' +__author__ = 'Laura Meneghetti, Nicola Demo' +__maintainer__ = __author__ + +#from smithers.ml.dataset.create_json import * +from smithers.ml.dataset.imagerec_dataset import Imagerec_Dataset +from smithers.ml.dataset.pascalvoc_dataset import PascalVOCDataset diff --git a/smithers/ml/dataset/change_xml.py b/smithers/ml/dataset/change_xml.py new file mode 100644 index 0000000..927ed6e --- /dev/null +++ b/smithers/ml/dataset/change_xml.py @@ -0,0 +1,105 @@ +''' +Utilities to perform changes inside xml files. +''' + +from __future__ import print_function +from os import listdir, path +import re + + +WIDTH_NEW = 800 +HEIGHT_NEW = 600 + +DIMLINE_MASK = r'<(?Pwidth|height)>(?P\d+)width|height)>' +BBLINE_MASK = r'<(?Pxmin|xmax|ymin|ymax)>(?P\d+)xmin|xmax|ymin|ymax)>' +NAMELINE_MASK = r'<(?Pfilename)>(?P\S+)filename)>' +PATHLINE_MASK = r'<(?Ppath)>(?P.+)path)>' +#regular expression + +def resize_file(file_lines): + ''' + Function performing the requested changes on the xml file, like changing + th coordinates x and y of the boxes and the height and width accordingly. + + :param list file_lines: list containing the lines of the file under + consideration. + ''' + new_lines = [] + for line in file_lines: + match = re.search(DIMLINE_MASK, line) or re.search(BBLINE_MASK, line) + print(match) + if match is not None: + size = match.group('size') + type1 = match.group('type1') + type2 = match.group('type2') + print(size) + print(type1) + print(type2) + if type1 != type2: + raise ValueError('Malformed line: {}'.format(line)) + + if type1.startswith('f'): + print('f') + if type1.startswith('x'): + size = int(size) + new_size = int(round(size * WIDTH_NEW / width_old)) + new_line = '\t\t\t<{}>{}\n'.format(type1, new_size, type1) + elif type1.startswith('y'): + size = int(size) + new_size = int(round(size * HEIGHT_NEW / height_old)) + new_line = '\t\t\t<{}>{}\n'.format(type1, new_size, type1) + elif type1.startswith('w'): + size = int(size) + width_old = size + new_size = int(WIDTH_NEW) + new_line = '\t\t<{}>{}\n'.format(type1, new_size, type1) + elif type1.startswith('h'): + size = int(size) + height_old = size + new_size = int(HEIGHT_NEW) + new_line = '\t\t<{}>{}\n'.format(type1, new_size, type1) + else: + raise ValueError('Unknown type: {}'.format(type1)) + #new_line = '\t\t\t<{}>{}\n'.format(type1, new_size, type1) + new_lines.append(new_line) + else: + new_lines.append(line) + + return ''.join(new_lines) + + +def change_xml(nome_file): + ''' + Function that chnages an xml file. + + :param str nome_file: path where the xml files are + contained (if it is a directory) or path of an xml file, + ''' + if len(nome_file) < 1: + raise ValueError('No file submitted') + + if path.isdir(nome_file): + # the argument is a directory + files = listdir(nome_file) + for file in files: + file_path = path.join(nome_file, file) + _, file_ext = path.splitext(file) + if file_ext.lower() == '.xml': + with open(file_path, 'r') as f: + rows = f.readlines() + + new_file = resize_file(rows) + with open(file_path, 'w') as f: + f.write(new_file) + else: + # otherwise i have a file (hopefully) + with open(nome_file, 'r') as f: + rows = f.readlines() + + new_file = resize_file(rows) + with open(nome_file, 'w') as f: + f.write(new_file) + +#insert name of the xml file or directory that contains them +xml_file = 'voc_dir/VOC_cow/Annotations' +change_xml(xml_file) diff --git a/smithers/ml/dataset/create_json.py b/smithers/ml/dataset/create_json.py new file mode 100644 index 0000000..3aace36 --- /dev/null +++ b/smithers/ml/dataset/create_json.py @@ -0,0 +1,151 @@ +''' +Utilities to perform the creation of JSON files starting from the xml files. +''' +import json +import xml.etree.ElementTree as ET +import argparse +import os + +parser = argparse.ArgumentParser() +parser.add_argument("voc07_path", help="Path to VOC2007 folder", type=str) +parser.add_argument("voc12_path", help="Path to VOC2012 folder") +parser.add_argument("output_folder", help="Path to JSON output folder", + type=str) +args = parser.parse_args() + +voc07_path = args.voc07_path +voc12_path = args.voc12_path +output_folder = args.output_folder + +# Label map +# NOTE: The labels have to be written using lower case, since in the function +# parse_annotation the label is transformed in the lower_case mode in order to +# avoid problems if in the labeling phase a label was written in a wrong way. +labels_list = ('aeroplane', 'bicycle', 'bird', 'boat', + 'bottle', 'bus', 'car', 'cat', 'chair', + 'cow', 'diningtable', 'dog', 'horse', + 'motorbike', 'person', 'pottedplant', + 'sheep', 'sofa', 'train', 'tvmonitor') +#labels_list = ('cat', 'dog') +label_map = {k: v + 1 for v, k in enumerate(labels_list)} +label_map['background'] = 0 +rev_label_map = {v: k for k, v in label_map.items()} # Inverse mapping + + +def parse_annotation(annotation_path): + ''' + :param string annotation_path: string for the path to Annotations + return dict: dictionary containing boxes, labels, difficulties for the + different objects in a picture + ''' + tree = ET.parse(annotation_path) + root = tree.getroot() + + boxes = list() + labels = list() + difficulties = list() + for obj in root.iter('object'): + + difficult = int(obj.find('difficult').text == '1') + label = obj.find('name').text.lower().strip() + if label not in label_map: + continue + + bbox = obj.find('bndbox') + xmin = int(bbox.find('xmin').text)# - 1 + ymin = int(bbox.find('ymin').text)# - 1 + xmax = int(bbox.find('xmax').text)# - 1 + ymax = int(bbox.find('ymax').text)# - 1 + boxes.append([xmin, ymin, xmax, ymax]) + labels.append(label_map[label]) + difficulties.append(difficult) + return {'boxes': boxes, 'labels': labels, 'difficulties': difficulties} + + +def create_data_lists(voc07_path, voc12_path, out_folder): + """ + Create lists of images, the bounding boxes and labels of the objects + in these images, and save these to file. + + :param string voc07_path: path to the 'VOC2007' folder + :param string voc12_path: path to the 'VOC2012' folder + :param string out_folder: folder where the JSONs must be saved + :output json files: saved json files obtained from our dataset + (images + xml files) saved in the output folder chosen + """ + voc07_path = os.path.abspath(voc07_path) + voc12_path = os.path.abspath(voc12_path) + print(voc07_path) + + train_images = list() + train_objects = list() + n_objects = 0 + + # Training data + for path in [voc07_path, voc12_path]: + if not path.endswith('/None'): + # Find IDs of images in training data + print(path) + with open(os.path.join(path, 'ImageSets/Main/trainval.txt')) as f: + ids = f.read().splitlines() + for ID in ids: + # Parse annotation's XML file + objects = parse_annotation( + os.path.join(path, 'Annotations', ID + '.xml')) + if len(objects) == 0: + continue + n_objects += len(objects) + train_objects.append(objects) + train_images.append(os.path.join(path, 'JPEGImages', ID + + '.jpg')) + + assert len(train_objects) == len(train_images) + + # Save to file + with open(os.path.join(out_folder, 'TRAIN_images.json'), 'w') as j: + json.dump(train_images, j) + with open(os.path.join(out_folder, 'TRAIN_objects.json'), 'w') as j: + json.dump(train_objects, j) + with open(os.path.join(out_folder, 'label_map.json'), 'w') as j: + json.dump(label_map, j) # save label map too + + print( + '\nThere are %d training images containing a total of %d \ + objects. Files have been saved to %s.' + %(len(train_images), n_objects, os.path.abspath(out_folder))) + + # Test data + test_images = list() + test_objects = list() + n_objects = 0 + + # Find IDs of images in the test data + with open(os.path.join(voc07_path, 'ImageSets/Main/test.txt')) as f: + ids = f.read().splitlines() + + for ID in ids: + # Parse annotation's XML file + ID = ID[0:6] + objects = parse_annotation( + os.path.join(voc07_path, 'Annotations', ID + '.xml')) + if len(objects) == 0: + continue + test_objects.append(objects) + n_objects += len(objects) + test_images.append(os.path.join(voc07_path, 'JPEGImages', ID + '.jpg')) + + assert len(test_objects) == len(test_images) + + # Save to file + with open(os.path.join(out_folder, 'TEST_images.json'), 'w') as j: + json.dump(test_images, j) + with open(os.path.join(out_folder, 'TEST_objects.json'), 'w') as j: + json.dump(test_objects, j) + + print( + '\nThere are %d test images containing a total of %d \ + objects. Files have been saved to %s.' + % (len(test_images), n_objects, os.path.abspath(out_folder))) + + +create_data_lists(voc07_path, voc12_path, output_folder) diff --git a/smithers/ml/dataset/imagerec_dataset.py b/smithers/ml/dataset/imagerec_dataset.py new file mode 100644 index 0000000..bd962f3 --- /dev/null +++ b/smithers/ml/dataset/imagerec_dataset.py @@ -0,0 +1,74 @@ +''' +Module focused on the creation of a custom dataset class in order +to use our custom dataset for the problem of image recognition +and thus classification. +''' +import os +import torch +from torch.utils.data import Dataset +from PIL import Image +from torchvision import transforms + + +# CUSTOM DATASET CLASS +class Imagerec_Dataset(Dataset): + ''' + Class that handles the creation of a custom dataset class to + be used by data loader. + :param pandas.DataFrame img_data: tabular containing all the + relations (image, label) + :param str img_path: path to the directiory containing all the + images + :param transform_obj transform: list of transoforms to apply to + images. Defaul value set to None. + :param list resize_dim: list of integers corresponding to the + size to which we want to resize the images + ''' + def __init__(self, img_data, img_path, resize_dim, transform=None): + self.img_data = img_data + self.img_path = img_path + self.resize_dim = resize_dim + self.transform = transform + self.targets = self.img_data['encoded_labels'] + + def __len__(self): + ''' + Function that returns the number of images in the dataset + :return int: integer number representing the number of + images in the dataset + ''' + return len(self.img_data) + + def __getitem__(self, index): + ''' + Function that returns the data and labels + :param int index: number representing a specific image in the + dataset + :return tensor image, label: image and label associated + with the index given as input + ''' + img_name = os.path.join(self.img_path, + self.img_data.loc[index, 'labels'], + self.img_data.loc[index, 'Images']) + image = Image.open(img_name) + image = image.resize((self.resize_dim[0], self.resize_dim[1])) + label = torch.tensor(self.img_data.loc[index, 'encoded_labels']) + if self.transform is not None: + image = self.transform(image) + else: + image = transforms.ToTensor()(image) + return image, label + + def getdata(self, index): + ''' + Function that returns a subset of the dataset + :param list index: number representing a specific image in the + dataset + :return: subset of the dataset composed by obs of type (img, label) + :rtype: list + ''' + output = [] + for idx in index: + image, label = self.__getitem__(idx) + output.append([image, label]) + return output diff --git a/smithers/ml/dataset/pascalvoc_dataset.py b/smithers/ml/dataset/pascalvoc_dataset.py new file mode 100644 index 0000000..d4f2d0f --- /dev/null +++ b/smithers/ml/dataset/pascalvoc_dataset.py @@ -0,0 +1,110 @@ +''' +Module focused on the preparation of the dataset for the training +and testing phases for the problem of object detection using +the PascalVOC notation. +''' +import os +import json +import torch +from torch.utils.data import Dataset +from PIL import Image +from smithers.ml.utils_objdet import transform + + +class PascalVOCDataset(Dataset): + """ + A PyTorch Dataset class to be used in a PyTorch DataLoader to create + batches. + """ + def __init__(self, data_folder, split, keep_difficult=False): + """ + :param string data_folder: folder where json data files are stored + :param string split: string that define the type of split in + consideration, values accepted are 'TRAIN' or 'TEST' + :param bool keep_difficult: Boolean value to determine the difficult of + objects. If True, objects that are considered difficult to detect + are kept, otherwise if False they are discarded. + """ + self.split = split.upper() + assert self.split in {'TRAIN', 'TEST'} + + self.data_folder = data_folder + self.keep_difficult = keep_difficult + + # Read data files + with open(os.path.join(data_folder, self.split + '_images.json'), + 'r') as j: + self.images = json.load(j) + with open(os.path.join(data_folder, self.split + '_objects.json'), + 'r') as j: + self.objects = json.load(j) + + assert len(self.images) == len(self.objects) + + def __getitem__(self, i): + ''' + :param int i: integer number indicating the image we are taking into + consideration + :return: 4 tensors: image, boxes, labels and difficulties + ''' + # Read image + image = Image.open(self.images[i], mode='r') + image = image.convert('RGB') + + # Read objects in this image (bounding boxes, labels, difficulties) + objects = self.objects[i] + boxes = torch.FloatTensor(objects['boxes']) # (n_objects, 4) + labels = torch.LongTensor(objects['labels']) # (n_objects) + difficulties = torch.BoolTensor(objects['difficulties']) # (n_objects) + + # Discard difficult objects, if desired + if not self.keep_difficult: + boxes = boxes[~difficulties] + labels = labels[~difficulties] + difficulties = difficulties[~difficulties] + + # Apply transformations + image, boxes, labels, difficulties = transform(image, + boxes, + labels, + difficulties, + split=self.split) + + return image, boxes, labels, difficulties + + def __len__(self): + ''' + :return: an integer that stand for the number of images in the + considered split + ''' + return len(self.images) + + def collate_fn(self, batch): + """ + Since each image may have a different number of objects, we need a + collate function (to be passed to the DataLoader). + This describes how to combine these tensors of different sizes. We + use lists. + + Note: this need not be defined in this Class, can be standalone. + + :param iterable batch: an iterable of N sets from __getitem__() + :return: a tensor of images, lists of varying-size tensors of bounding + boxes, labels, and difficulties + """ + + images = list() + boxes = list() + labels = list() + difficulties = list() + + for b in batch: + images.append(b[0]) + boxes.append(b[1]) + labels.append(b[2]) + difficulties.append(b[3]) + + images = torch.stack(images, dim=0) + + return images, boxes, labels, difficulties + # tensor (N, 3, 300, 300), 3 lists of N tensors each diff --git a/smithers/ml/dataset/sample_dataset.py b/smithers/ml/dataset/sample_dataset.py new file mode 100755 index 0000000..04c6c30 --- /dev/null +++ b/smithers/ml/dataset/sample_dataset.py @@ -0,0 +1,90 @@ +''' +Utilities to extract datasets of N images divided in M classes +from a whole dataset. +''' + +import os +import shutil + + +from xml.dom import minidom + + +def select_indeces(valid_classes, max_imgs, xmlfolder): + ''' + Function that selects the indexes of the images of a + specific class contained in the source dataset. + + :param list(str) valid_classes: list of strings defining + the selected categories. + :param int max_imgs: maximum number of images to consider. + :param str xmlfolder: relative path to the folder + containing the annotations (xml files). + :return: valid_ids, list containg the selected indexes. + :rtype: list + ''' + valid_ids = [] + file = 'dataset.txt' + out_file = open(file, 'w') + + for id_ in range(1, 10000): + id_ = '00{:04d}'.format(id_) + xml_ = os.path.join(xmlfolder, '{}.xml'.format(id_)) + file_ = minidom.parse(xml_) + classes = file_.getElementsByTagName('object') + classes = [class_.getElementsByTagName('name')[0] for class_ in classes] + classes = [class_.firstChild.nodeValue for class_ in classes] + + if all([class_ in valid_classes for class_ in classes]): + valid_ids.append(id_) + out_file.write(id_ + '\n') + + if len(valid_ids) >= max_imgs: + break + out_file.close() + return valid_ids + +def copy_imgs(ids, src, dst, folder='JPEGImages'): + ''' + Function copying selected images from a directory. + ''' + + os.mkdir(os.path.join(dst, folder)) + + for id_ in ids: + src_ = os.path.join(src, folder, '{}.jpg'.format(id_)) + dst_ = os.path.join(dst, folder, '{}.jpg'.format(id_)) + shutil.copyfile(src_, dst_) + +def copy_xmls(ids, src, dst, folder='Annotations'): + ''' + Function copying selected xml files from a directory. + ''' + + os.mkdir(os.path.join(dst, folder)) + + for id_ in ids: + src_ = os.path.join(src, folder, '{}.xml'.format(id_)) + dst_ = os.path.join(dst, folder, '{}.xml'.format(id_)) + shutil.copyfile(src_, dst_) + +def sample_dataset(src_dataset, dst_dataset): + ''' + Function that performs the sampling of the dataset. + + :param str src_dataset: path to the source dataset. + :param str dst_dataset: path to the output dataset. + ''' + os.mkdir(dst_dataset) + + ids = select_indeces(['dog', 'cat'], 300, + os.path.join(src_dataset, 'Annotations')) + + copy_imgs(ids, src_dataset, dst_dataset) + copy_xmls(ids, src_dataset, dst_dataset) + + + +if __name__ == '__main__': + + sample_dataset('../VOCdevkit/VOC2007', 'VOC_dog_cat') diff --git a/smithers/ml/layers/ahosvd.py b/smithers/ml/layers/ahosvd.py new file mode 100644 index 0000000..5562d6b --- /dev/null +++ b/smithers/ml/layers/ahosvd.py @@ -0,0 +1,106 @@ +''' +Module focused on the implementation of Averaged Higher Order SVD +(AHOSVD) technique. +''' + +import torch +import numpy as np + +from smithers.ml.layers.hosvd import HOSVD + +class AHOSVD(): + """ + Class that handles the construction of the functions needed + to perform the dimensionality reduction of a given tensor, + which has exactly one dimension (the first one) that is too large, + thus preventing standard HOSVD to run on current architectures. + + This new technique is called Averaged Higher Order Singular + Value Decomposition (AHOSVD). Basically, HOSVD is performed on + batches of the outputs of the premodel, then the U matrices + resulting from HOSVD relative to the same unfolding direction + are averaged in order to keep the computing requirements (mainly + GPU storage) accessible. + + :param torch.Tensor tensor: snapshots tensor of dimensions + (n,d_1,...,d_n) + :param list[int] mode_number: list of integers representing the + target reduced dimensions; (d_1,...,d_n) will be reduced + :param int batch_len: number of element of the snapshot to process + together + """ + def __init__(self, tensor, red_dims, batch_len): + + self.tensor = tensor + self.red_dims = red_dims + if batch_len > tensor.size()[0] > 0: + raise ValueError('The batch for AHOSVD must be smaller than the' + + ' batch size of the data loader.') + self.batch_len = batch_len + self.u_matrices = [] + self.proj_matrices = [] + + def incremental_average(self, current_list, new_list, index): + """ + Auxiliary function used to compute the incremental step for a list + containing already computed + averages when another list of new values is given + :param list current_list: list containing the current averages + :param list new_list: list of the new values + :param int index: defines the number of elements the current average is taken over + :return: the updated list of averages + :rtype: list + """ + matrices_list = [] + if index == 0: + return new_list + elif index > 0: + for i, _ in enumerate(current_list): + matrices_list.append((index / (index + 1)) * current_list[i] + + (1/(index + 1)) * new_list[i]) + return matrices_list + elif index < 0: + raise ValueError('Index variable must be greater or equal to 0.') + + def _partial_hosvd(self, batch_from_tensor): + """ + Computes the partial HOSVD from a restricted sample of the snapshots tensor + + :param torch.Tensor batch_from_tensor: the batch given + :return: list of U matrices coming from the modal SVDs + :rtype: list[torch.Tensor] + """ + hosvd = HOSVD(batch_from_tensor.shape) + hosvd.fit(batch_from_tensor, return_S_tensor=False, for_AHOSVD=True) + return hosvd.modes_matrices + + + def compute_u_matrices(self): + """ + This function updates the current U matrices with their new values + from a never-seen batch of examples. + """ + for idx_ in range(int(np.floor(self.tensor.shape[0]/self.batch_len))): + p_hosvd = self._partial_hosvd(self.tensor[idx_ * self.batch_len : (idx_+1) * self.batch_len]) + self.u_matrices = self.incremental_average(self.u_matrices, p_hosvd, idx_) + + def compute_proj_matrices(self): + """ + This function sets the attribute proj_matrices with the transposes of + the matrices obtained from the numbers given in self.red_dims + of columns of the U matrices previously computed + """ + for i in range(len(self.u_matrices)): + self.proj_matrices.append(self.u_matrices[i][ :, : self.red_dims[i]].t().conj()) + +# example +if __name__ == '__main__': + import time + tensor1 = torch.randn(50000, 4, 4, 256).to('cuda') + start = time.time() + ahosvd = AHOSVD(tensor1, [3, 3, 50], 20) + ahosvd.compute_u_matrices() + print(f"The U matrices' dimensions are {[ahosvd.u_matrices[i].shape for i in range(len(ahosvd.u_matrices))]}") + ahosvd.compute_proj_matrices() + end = time.time() + print(f'time needed: {end-start} seconds') diff --git a/smithers/ml/layers/aux_conv.py b/smithers/ml/layers/aux_conv.py new file mode 100644 index 0000000..af3a206 --- /dev/null +++ b/smithers/ml/layers/aux_conv.py @@ -0,0 +1,102 @@ +''' +Module focused on the implementation of Auxiliary Convolutional Layers +''' +import torch.nn as nn +import torch.nn.functional as F + + +class AuxiliaryConvolutions(nn.Module): + """ + Additional convolutions to produce higher-level feature maps. + see the original paper where SSD300 is implemented for further + details: 'SSD: Single Shot Multibox Detector' by + Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, + Scott Reed, Cheng-Yang Fu, Alexander C. Berg + https://arxiv.org/abs/1512.02325 + DOI:10.1007/978-3-319-46448-0_2 + """ + def __init__(self, layers=None): + """ + :param list layers: If None, returns the configuration used in the + original SSD300 paper, mentioned before. Otherwise a list where + every element is a list of numbers representing the number of + filters for that convolutional layer + """ + super(AuxiliaryConvolutions, self).__init__() + + if layers is None: + layers = [[256, 512], [128, 256], [128, 256], [128, 256]] + self.layers = layers + self.features = self.make_auxlayers() + #Inizialize convolutions' parameters + self.init_conv2d() + + def make_auxlayers(self): + """ + # Auxiliary/additional convolutions on top of the VGG base + :param list cfg: configuration of the auxiliary layer for our CNN + (number of filters applied in that layers (thus the features + extracted)) + """ + layers = [] + in_channels = 1024 + #1280 number to be changed, put as param function + for k in range(len(self.layers)): + layers += [ + nn.Conv2d(in_channels, + self.layers[k][0], + kernel_size=1, + padding=0) + ] #stride=1 by default + if k < 2: + layers += [ + nn.Conv2d(self.layers[k][0], + self.layers[k][1], + kernel_size=3, + stride=2, + padding=1) + ] + # dim. reduction because stride > 1 + else: + layers += [ + nn.Conv2d(self.layers[k][0], + self.layers[k][1], + kernel_size=3, #1 change + padding=0) + ] + # dim. reduction because padding=0 + in_channels = self.layers[k][1] + + return nn.Sequential(*layers) + + def init_conv2d(self): + """ + Initialize convolution parameters + """ + for c in self.children(): + if isinstance(c, nn.Conv2d): + nn.init.xavier_uniform_(c.weight) + nn.init.constant_(c.bias, 0.) + + def forward(self, conv7_feats): + """ + Forward propagation. + :param Tensor conv7_feats: output of last classification layer + base network, lower-level conv7 feature map, a tensor of + dimensions (N, 1024, 19, 19) in the case of VGG16 + Note: Since these layers are thought as additional layers to be placed + after a base network, pay attention that the dimensions of conv7_feats + have to be consistent with that of the first layer of this structure. + :return list out_conv2: list containing higher-level feature maps + conv8_2, conv9_2, conv10_2, and conv11_2 + """ + out_in = conv7_feats + out_conv2 = [] + for conv in self.features: + out = F.relu(conv(out_in)) + out_conv2.append(out) + out_in = out + + # Higher-level feature maps, only the elements on odd position + # thus the features conv_2 + return out_conv2[1::2] diff --git a/smithers/ml/layers/hosvd.py b/smithers/ml/layers/hosvd.py new file mode 100644 index 0000000..23591a4 --- /dev/null +++ b/smithers/ml/layers/hosvd.py @@ -0,0 +1,215 @@ +''' +Module focused on the implementation of Higher Order SVD +(HOSVD) technique. +''' + +import torch +import numpy as np + +class HOSVD(): + def __init__(self, mode_number_list): + """ + Class that handles Higher Order SVD. + Use the tensor of interest shape as parameter, if all the hosvd modes + are required in the reduction. + + :param list[int] mode_number_list: list containing the number of modes + considered for each dimension + + :Example: + >>> HOSVD = HOSVD() + >>> random_tensor = torch.randn(101,102,103) + >>> HOSVD.fit(random_tensor) + >>> transformed = HOSVD.transform(random_tensor) + >>> inverted = HOSVD.inverse_transform(transformed) + >>> random_test_tensor = torch.randn(101,102,103) + >>> relative_error = torch.linalg.norm(HOSVD.inverse_transform( + HOSVD.transform(random_test_tensor))- + random_test_tensor)/torch.linalg.norm(random_test_tensor) + >>> print('''The input tensor's shape is {} + The projected tensor's shape {} + The output tensor's shape is {} + The relative error on the test tensor is {:.4}'''.format( + random_tensor.shape, transformed.shape, inverted.shape, relative_error)) + """ + self.modes_matrices = None + self.singular_values = None + self.modal_singular_values = [] + self.mode_number_list = list(mode_number_list) + + def unfolding(self, inputs, n): + """ + Method that handles the unfolding of a tensor as a matrix + + :param torch.Tensor inputs: the input tensor + :param int n: the dimension along which the unfolding is done + :return: unfolded tensor inputs along n-th direction + :rtype: torch.Tensor + """ + shape = inputs.shape + tensor_dimensions = len(shape) + size = np.prod(shape) + size_list = list(range(tensor_dimensions)) + size_list[n] = 0 + size_list[0] = n + n_rows = int(shape[n]) + n_columns = int(size / n_rows) + return inputs.permute(size_list).reshape(n_rows, n_columns) + + def modalsvd(self, inputs, n): + """ + Method that performs the standard SVD of an unfolded matrix defined from an input tensor + along a given dimension + + :param torch.Tensor inputs: the input tensor + :param int n: the index of the unfolding matrix being decomposed + :return: three SVD matrices of the n-th unfolding of tensor inputs + :rtype: torch.Tensors + """ + return torch.linalg.svd(self.unfolding(inputs, n), full_matrices=True) + + def higherorderSVD_noS(self, inputs, for_AHOSVD=False): + """ + Mathod that performs the Higher Order SVD on a given tensor. + This method DOES NOT return the singular value tensor S + + :param torch.Tensor inputs: the input tensor + :param bool for_AHOSVD: if True, the function only computes the necessary modal + SVDs for the AHOSVD technique + :return: list containing the U matrices from all the modal SVDs of tensor A + :rtype: list[torch.Tensor] + """ + U_matrices = [] + if not for_AHOSVD: + for i in range(len(inputs.shape)): + u, sigma, _ = self.modalsvd(inputs, i) + self.modal_singular_values.append(sigma/sigma[0]) + U_matrices.append(u) + elif for_AHOSVD: + for i in range(1, len(inputs.shape)): + u, sigma, _ = self.modalsvd(inputs, i) + self.modal_singular_values.append(sigma/sigma[0]) + U_matrices.append(u) + return U_matrices + + def higherorderSVD_withS(self, inputs): + """ + Mathod that performs the Higher Order SVD on a given tensor. + This method DOES return the singular value tensor S + + :param torch.Tensor A: the input tensor + """ + U_matrices = [] + S = inputs.clone() + for i in range(len(inputs.shape)): + u, sigma, _ = self.modalsvd(inputs, i) + self.modal_singular_values.append(sigma/sigma[0]) + U_matrices.append(u) + S = torch.tensordot(S, u, dims=([0], [0])) + return U_matrices, S + + def fit(self, inputs, return_S_tensor=False, for_AHOSVD=False): + """ + Create the reduced space for the given snapshots A using HOSVD + + :param torch.Tensor inputs: the input tensor + :param bool return_S_tensor: state whether or not you are interested in the singular + value tensor (requires more computations) + """ + if not return_S_tensor: + self.modes_matrices = self.higherorderSVD_noS(inputs, for_AHOSVD=for_AHOSVD) + else: + self.modes_matrices, self.singular_values = self.higherorderSVD_withS(inputs) + + + def tensor_reverse(self, inputs): + """ + Function that reverses the directions of a tensor + + :param torch.Tensor inputs: the input tensor with dimensions (d_1,d_2,...,d_n) + :return: input tensor with reversed dimensions (d_n,...,d_2,d_1) + :rtype: torch.Tensor + """ + incr_list = [i for i in range(len(inputs.shape))] + incr_list.reverse() + return torch.permute(inputs, tuple(incr_list)) + + def transform(self, inputs): + """ + Reduces the given snapshots tensor + + :param torch.Tensor inputs: the input tensor + :return: the reduced version of the input tensor via the reduction matrices + computed with HOSVD + :rtype: torch.Tensor + """ + for i, _ in enumerate(inputs.shape): + inputs = torch.tensordot(self.modes_matrices[i][:, :self.mode_number_list[i]].t().conj(), inputs, ([1], [i])) + return self.tensor_reverse(inputs) + + def inverse_transform(self, inputs): + """ + Reconstruct the full order solution from the projected one + + :param torch.Tensor inputs: the input tensor + :return: the reconstructed solution + :rtype: torch.Tensor + """ + for i, _ in enumerate(inputs.shape): + inputs = torch.tensordot(self.modes_matrices[i][:, :self.mode_number_list[i]], inputs, ([1], [i])) + return self.tensor_reverse(inputs) + + def reduce(self, inputs): + """ + Reduces the given snapshots tensor + + :param torch.Tensor inputs: the input tensor + :return: the reduced version of the input tensor via the reduction matrices computed with HOSVD + :rtype: torch.Tensor + + .. note:: + Same as `transform`. Kept for backward compatibility. + """ + return self.transform(inputs) + + def expand(self, inputs): + """ + Reconstruct the full order solution from the projected one + + :param torch.Tensor inputs: the input tensor + :return: the reconstructed solution + :rtype: torch.Tensor + + .. note:: + Same as `inverse_transform`. Kept for backward compatibility. + """ + return self.inverse_transform(inputs) + + +def test_accuracy(tensor, ranks): + """ + Given a tensor, this function returns the relative error derived from projecting such + tensor using HOSVD and then going back to the reconstructed original tensor via + the inverse projection. + :param torch.Tensor tensor: the input tensor to be tested on + :param list[int] ranks: list of the ranks of the individual directional projections + (len(ranks) must be equal to len(tensor.shape)) + :return: relative error of the method and list of the singular values of each unfolding + :rtype: float, list[torch.Tensor] + """ + HOSVD = hosvd(ranks) + HOSVD.fit(tensor, return_S_tensor=True) + red_tensor = HOSVD.transform(tensor) + reconstruct_tensor = HOSVD.inverse_transform(red_tensor) + error = torch.linalg.norm(reconstruct_tensor - tensor) + relative_error = error / np.linalg.norm(tensor) + return relative_error, HOSVD.modal_singular_values + +# example +if __name__ == '__main__': + tensor1 = torch.zeros(100, 100, 100) + for idx_ in range(100): + tensor1[idx_, :, :] += idx_ + err, sing_vals = test_accuracy(tensor1, [1, 1, 1]) + print(f'relative error: {err}') + #print(sing_vals) diff --git a/smithers/ml/layers/pcemodel.py b/smithers/ml/layers/pcemodel.py new file mode 100644 index 0000000..c211697 --- /dev/null +++ b/smithers/ml/layers/pcemodel.py @@ -0,0 +1,185 @@ +''' +Module focused on the implementation of the Polunomial Chaos +Expansion Layer (PCE). +''' + +import torch +import torch.nn as nn +import scipy.misc +from sklearn.linear_model import LinearRegression +import numpy as np + + +class PCEModel(nn.Module): + ''' + Class that handles the implementation of the PCE layer as given + in step 2 of Algorithm 3.1 in the paper: + - Chunfeng Cui, Kaiqi Zhang, Talgat Daulbaev, Julia Gusak, + Ivan Oseledets, and Zheng Zhang. "Active Subspace of Neural + Networks: Structural Analysis and Universal Attacks". + accepted by SIAM Journal on Mathematics of Data Science (SIMODS) + + :param torch.tensor mean: tensor containing the mean value of all + elements in the input tensor (output AS layer) + :param torch.tensor var: tensor containing the variance of all + elements in the input tensor (output AS layer) + :param int d: If is not specified, its value is set to the default + one, that is 50. + :param int p: If is not specified, its value is set to the default + value 2. + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. If None, the device + in use is the cpu. + ''' + def __init__(self, mean, var, d=50, p=2, device=None): + super(PCEModel, self).__init__() + self.d = d + self.p = p + self.mean = mean + self.var = var + # scipy.special.comb(N,k):The number of combinations of N + # things taken k at a time. + self.nbasis = scipy.special.comb(d + p, p).astype(int) + if device is None: + self.device = 'cpu' + else: + self.device = device + self.oneDbasis = self.NormalBasis() + self.idxset = indexset(d, 0) + for i in range(1, p + 1): + self.idxset = torch.cat((self.idxset, indexset(d, i)), dim=0) + + self.mean = nn.Parameter(self.mean, requires_grad=False) + self.var = nn.Parameter(self.var, requires_grad=False) + self.oneDbasis = nn.Parameter(self.oneDbasis, requires_grad=False) + self.idxset = nn.Parameter(self.idxset, requires_grad=False) + + def NormalBasis(self): + ''' + Basis Functions for normal distribution + :return: matrix containing the basis functions for normal + distribution. + :rtype: torch.tensor + ''' + B = torch.zeros([self.p + 1, self.p + 1]) + B[0, 0] = 1 # 0nd order + if self.p >= 1: + B[1, 1] = 2 # 1st order + for i in range(1, self.p): # i-th order + B[i + 1, 1:i + 2] = 2 * B[i, :i + 1] + B[i + 1, :i] -= 2 * i * B[i - 1, :i] + return B + + def PolyVal(self, x): + ''' + Functions that handles the evaluation of the basis function at the + input vector + :param torch.tensor x: input tensor where we evaluate the functions at + :return: tensor containing the basis functions evaluated at x + :rtype: torch.tensor + ''' + [n, m] = x.shape + x_pows = torch.zeros((n, m, self.p + 1), dtype=torch.float32) + for i in range(self.p + 1): + x_pows[:, :, i] = x**i + + polyval = torch.zeros((n, m, self.p + 1), dtype=torch.float32) + for ip in range(self.p + 1): + for i in range(ip + 1): + if self.oneDbasis[ip, i] != 0: + polyval[:, :, ip] += self.oneDbasis[ip, i] * x_pows[:, :, i] + return polyval.to(self.device) + + def forward(self, x): + ''' + Function that handles the evaluation of the basis functions + at input x scaled with mean and variance and creation of the + related matrix + :param torch.tensor x: tensor where we compute the basis functions + (input of that layer, e.g. output reduction layer) + :return: matrix containing the basis functions evaluated at x + :rtype: torch.tensor + ''' + k = len(self.mean) + assert len(self.var) == k + for i in range(k): + x[:, i] = (x[:, i] - self.mean[i]) / self.var[i] + + oneDpolyval = self.PolyVal(x) + + Phi = torch.ones([x.shape[0], self.nbasis], + dtype=torch.float32).to(self.device) + for j in range(k): + Phi *= oneDpolyval[:, j, self.idxset[:, j]] + return Phi + + def Training(self, x, y, label): + ''' + Function that implements the training procedure of the PCEmodel + :param torch.tensor x: tensor representing the output of the + reduction layer + :param torch.tensor y: tensor representing the total output of the + net + :param torch.tensor label: tensor representing the labels associated + to each image in the train dataset + :return: coefficients of the linear combination of the basis + functions, coefficient of determination R^2 of the prediction, + scores for each image + :rtype: np.ndarray, float, float + ''' + Phi = self.forward(x) + + if not isinstance(Phi, np.ndarray): + Phi = Phi.cpu().detach().numpy() + if not isinstance(y, np.ndarray): + y = y.cpu().detach().numpy() + if not isinstance(label, np.ndarray): + label = label.cpu().numpy() + + LR = LinearRegression(fit_intercept=False).fit(Phi, y) + + # Return the coefficient of determination R^2 of the prediction (float) + score_approx = LR.score(Phi, y) + coeff = LR.coef_.transpose() + y_PCE = Phi @ coeff + score_label = (label == np.argmax(y_PCE, axis=1)).mean() + return coeff, score_approx, score_label + + def Inference(self, x, coeff): + ''' + Inference function + :param torch.tensor x: input tensor + :param torch.tensor coeff: coefficient tensor + :return: inference matrix + :rtype: torch.tensor + ''' + Phi = self.forward(x) + if Phi.shape[1] == coeff.shape[0]: + y = Phi @ coeff.to(self.device) + else: + y = Phi.t() @ coeff.t().to(self.device) + return y + + +def indexset(d, p): + ''' + :param int d + :param int p + :return: tensor IdxMat + :rtype: torch.tensor + ''' + if d == 1: + IdxMat = p * torch.ones((1, 1), dtype=torch.int64) + else: + for i in range(p + 1): + Idx_tmp = indexset(d - 1, p - i) + sz = Idx_tmp.shape[0] + Idx_tmp = torch.cat((i * torch.ones( + (sz, 1), dtype=torch.int64), Idx_tmp), + dim=1) + if i == 0: + IdxMat = Idx_tmp + else: + IdxMat = torch.cat((IdxMat, Idx_tmp), dim=0) + + return IdxMat diff --git a/smithers/ml/layers/predictor.py b/smithers/ml/layers/predictor.py new file mode 100644 index 0000000..ed18e09 --- /dev/null +++ b/smithers/ml/layers/predictor.py @@ -0,0 +1,170 @@ +''' +Module focused on the implementation of Prediction Convolutional Layers +''' +import torch +import torch.nn as nn + + +class PredictionConvolutions(nn.Module): + ''' + Convolutions to predict class scores and bounding boxes using lower and + higher-level feature maps. + + The bounding boxes (locations) are predicted as encoded offsets w.r.t + each of the 8732 prior (default) boxes. The Encode bounding boxes + (that are in center-size form) w.r.t. the corresponding prior boxes + (that are in center-size form). + + The class scores represent the scores of each object class in each of the + 8732 bounding boxes located. A high score for 'background' = no object. + + See the original paper where SSD300 is implemented for further + details: 'SSD: Single Shot Multibox Detector' by + Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, + Scott Reed, Cheng-Yang Fu, Alexander C. Berg + https://arxiv.org/abs/1512.02325 + DOI:10.1007/978-3-319-46448-0_2 + + :param int n_classes: number of different types of objects + :param list cfg_tot: If None, it returns the configuration used in the + original SSD300 paper, mentioned before. Otherwise a list where + every element is a number representing all the filters applied in + that convolutional layer. + NOTE: These layers are exactly the layers selected in low_feats and + aux_conv_feats, thus the dimensions in this list have to be consistent + with that of those convolutional layers. + :param list n_boxes: If None, returns the number of prior-boxes for each + feature map as described in the original paper for SSD300, i.e. + {'conv4_3': 4, 'conv7': 6, 'conv8_2': 6, 'conv9_2': 6,'conv10_2': 4, + 'conv11_2': 4}, where 4 prior-boxes implies we use 4 different + aspect ratios, etc. Otherwise you need to provide a list containing + the number of prior boxes associated to every feature map + ''' + def __init__(self, n_classes, cfg_tot=None, n_boxes=None): + super(PredictionConvolutions, self).__init__() + + self.n_classes = n_classes + + if cfg_tot is None: + cfg_tot = [512, 1024, 512, 256, 256, 256] + self.cfg_tot = cfg_tot + + if n_boxes is None: + n_boxes = [4, 6, 6, 6, 4, 4] + self.n_boxes = n_boxes + + # Localization prediction convolutions (predict offsets w.r.t + # prior-boxes) + self.features_loc = self.make_predlayers('loc') + # Class prediction convolutions (predict classes in + # localization boxes) + self.features_cl = self.make_predlayers('cl') + # Initialize convolutions' parameters + self.init_conv2d() + + def make_predlayers(self, task): + ''' + Construct the structure of the net starting from the configuration + given in input. + + :param str task: a string that describes the task you are requiring, + i.e. localization (for the definition of the correct bounding + box) or classification (of the object in the picture) + :return: sequential object containing the structure of the net + :rtype: nn.Sequential + ''' + layers = [] + for l in range(len(self.cfg_tot)): + if task == 'loc': + layers += [ + nn.Conv2d(self.cfg_tot[l], + self.n_boxes[l] * 4, + kernel_size=3, + padding=1) + ] + elif task == 'cl': + layers += [ + nn.Conv2d(self.cfg_tot[l], + self.n_boxes[l] * self.n_classes, + kernel_size=3, + padding=1) + ] + else: + raise RuntimeError( + 'The task assigned is not recognized by the network.') + + return nn.Sequential(*layers) + + def init_conv2d(self): + ''' + Initialize convolutional parameters + ''' + for c in self.children(): + if isinstance(c, nn.Conv2d): + nn.init.xavier_uniform_(c.weight) + + def forward(self, low_feats, auxconv_feats): + ''' + Forward propagation. + + :param list of tensors low_feats: list representing the output of + VGG.forward(), thus containing the low-level features map. + For example in the case of SSD300, they are represented by + conv4_3 and conv7: + - conv4_3_feats: conv4_3 feature map, a tensor of dimensions + (N, 512, 38, 38) + - conv7_feats: conv7 feature map, a tensor of dimensions + (N, 1024, 19, 19) + :param list of tensors auxconv_feats: list representing the output of + AuxiliaryConvolutions.forward(), thus containing the auxiliary + convolution feature maps. + For example, in the case of SSD300, they are: + - conv8_2_feats: conv8_2 feature map, a tensor of dimensions + (N, 512, 10, 10) + - conv9_2_feats: conv9_2 feature map, a tensor of dimensions + (N, 256, 5, 5) + - conv10_2_feats: conv10_2 feature map, a tensor of dimensions + (N, 256, 3, 3) + - conv11_2_feats: conv11_2 feature map, a tensor of dimensions + (N, 256, 1, 1) + :return: total_numberpriors locations and class scores for each image. + In the case of SSD it will returns 8732 locations and class scores + (i.e. w.r.t each prior box) for each image + :rtype: torch.Tensor, torch.Tensor + ''' + #batch_size: the total number of images we are using + #in our setting this is represented by the first number in the shape of + # all the features map (this number is equal in all of them) + batch_size = low_feats[0].size(0) + conv_feats = low_feats + auxconv_feats + + + locs = [] + classes_scores = [] + + for k in range(len(conv_feats)): + # Predict localization boxes' bounds (as offsets w.r.t prior-boxes) + loc_conv = self.features_loc[k](conv_feats[k]) + loc_conv = loc_conv.permute(0, 2, 3, 1).contiguous() + # to match prior-box order (after .view()) + # (.contiguous() ensures it is stored in a contiguous chunk + # of memory, needed for .view() below) + loc_conv = loc_conv.view(batch_size, -1, 4) + locs.append(loc_conv) + + # Predict classes in localization boxes + cl_conv = self.features_cl[k](conv_feats[k]) + cl_conv = cl_conv.permute(0, 2, 3, 1).contiguous() + # to match prior-box order (after .view()) + # (.contiguous() ensures it is stored in a contiguous chunk + # of memory, needed for .view() below) + cl_conv = cl_conv.view(batch_size, -1, self.n_classes) + classes_scores.append(cl_conv) + + # A total of 8732 boxes + # Concatenate in this specific order (i.e. must match the order of + # the prior-boxes) + locs = torch.cat(locs, dim=1) + classes_scores = torch.cat(classes_scores, dim=1) + + return locs, classes_scores diff --git a/smithers/ml/layers/tensor_product_layer.py b/smithers/ml/layers/tensor_product_layer.py new file mode 100644 index 0000000..e20d960 --- /dev/null +++ b/smithers/ml/layers/tensor_product_layer.py @@ -0,0 +1,60 @@ +''' +Module handling the creation of a layer for the projection of a tensorial +object (case 1D it corresponds to nn.Linear. +''' + +import torch +import torch.nn as nn +from torch.nn.parameter import Parameter + +from smithers.ml.utils_rednet import tensor_reverse + +class tensor_product_layer(nn.Module): + """ + Class that handles the definition of a PyTorch layer created to + compute several specific tensor products: given a list of matrices and a tensor, + its job is to multiply the i-th one dimensional sections of the tensor by the i-th + matrix of the list. + + """ + def __init__(self, list_of_matrices): + """ + :param list[torch.Tensor] list_of_matrices: list of the matrices that will multiply the one dimensional sections of a given tensor + """ + super(tensor_product_layer, self).__init__() + self.list_of_matrices = list_of_matrices + self.param0 = Parameter(list_of_matrices[0]) + self.param1 = Parameter(list_of_matrices[1]) + self.param2 = Parameter(list_of_matrices[2]) + + def forward(self, input_tensor): + """ + Forward function of the layer. The if clause concern tha case in which a single tensor + needs to be projected, the else clause deals with the possibility of multiple tensors being provided + + :param torch.Tensor input_tensor: the input tensor (either single tensor or tensor as a collection of tensors + :return: the projected tensor (either full or its "components") + :rtype: torch.Tensor + """ + if len(input_tensor.shape) == len(self.list_of_matrices): + for i, _ in enumerate(input_tensor.shape): + input_tensor = torch.tensordot(self.list_of_matrices[i], input_tensor, ([1],[i])) + return tensor_reverse(input_tensor) + elif len(input_tensor.shape) == len(self.list_of_matrices) + 1: + for i in range(len(self.list_of_matrices)): + input_tensor = torch.tensordot(self.list_of_matrices[i], input_tensor, ([1],[i+1])) + return tensor_reverse(input_tensor) + + def extra_repr(self): + return 'in_dimensions={}, out_dimensions={}'.format([self.list_of_matrices[i].shape[1] for i in range(len(self.list_of_matrices))], [self.list_of_matrices[i].shape[0] for i in range(len(self.list_of_matrices))]) + +if __name__ == '__main__': + from smithers.ml.AHOSVD import AHOSVD + tensor_batch = torch.randn(100, 256, 4, 4).to('cuda') + tensor_image = torch.randn(256, 4, 4).to('cuda') + ahosvd = AHOSVD(tensor_batch, [25, 50, 3, 3], 25) + ahosvd.compute_u_matrices() + ahosvd.compute_proj_matrices() + my_layer = tensor_product_layer(ahosvd.proj_matrices) + projected_obs = my_layer.forward(tensor_image) + print(projected_obs.shape) diff --git a/smithers/ml/loss/multibox_loss.py b/smithers/ml/loss/multibox_loss.py new file mode 100644 index 0000000..410e754 --- /dev/null +++ b/smithers/ml/loss/multibox_loss.py @@ -0,0 +1,212 @@ +''' +Module focused on the implementation of the MultiBox Loss Function. +''' +import torch +import torch.nn as nn +import numpy as np + +from smithers.ml.utils_objdet import cxcy_to_xy, find_jaccard_overlap, cxcy_to_gcxgcy, xy_to_cxcy + +device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + + +class MultiBoxLoss(nn.Module): + """ + The MultiBox loss, a loss function for object detection. + As described in the SSD original paper: + 'SSD: Single Shot Multibox Detector' by + Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, + Scott Reed, Cheng-Yang Fu, Alexander C. Berg + https://arxiv.org/abs/1512.02325 + DOI: 10.1007/978-3-319-46448-0_2 + + This is a combination of: + (1) a localization loss for the predicted locations of the boxes, and + (2) a confidence loss for the predicted class scores. + """ + def __init__( + self, + priors_cxcy, + threshold=0.5, + neg_pos_ratio=3, + alpha=1., + #size_average=None, + #reduce=None, + #reduction='mean'): + reduction='None'): + ''' + :param tensor priors_cxcy: priors (default bounding boxes) in center-size + coordinates, a tensor of size (n_boxes, 4) + :param float threshold: Threshold for the Jaccard overlap. If it is greater + than the threshold value, the box is said to "contain" the object. + Thu we have a positive match. Otherwise, it does not contain it and + we have a negative match and it is labeled as background. + :param int neg_pos_ratio: ratio that connected the number of positive matches + (N_p) with the hard negatives (N_hn). Usually they are a fixed + multiple of the number of positive matches for an image: + N_hn = neg_pos_ratio * N_p + :param int alpha: ratio of combination between the two different losses + (localization and confidence) It can be a learnable parameter or + fixed, as in the case of SSD300 where the authors decided to use + alpha=1.(default value) + :param string reduction: Specifies the reduction to apply to the output: + 'None', 'mean' or 'sum'. + - If None, no reduction will be applied. + - If mean, the sum of the output will be divided by the number of + elements in the output. + - If sum, the output will be summed. + ''' + super(MultiBoxLoss, self).__init__() + self.priors_cxcy = priors_cxcy + #convert bounding boxes from center-size coordinates (c_x, c_y, w, h) to + #boundary coordinates (x_min, y_min, x_max, y_max) + self.priors_xy = cxcy_to_xy(priors_cxcy) + self.threshold = threshold + self.neg_pos_ratio = neg_pos_ratio + self.alpha = alpha + + self.smooth_l1 = nn.L1Loss() + #self.cross_entropy = nn.CrossEntropyLoss(reduce=False) + self.cross_entropy = nn.CrossEntropyLoss(reduction='none') + + def forward(self, predicted_locs, predicted_scores, boxes, labels): + """ + Forward propagation. + + :param predicted_locs: predicted locations/boxes w.r.t the 8732 prior + boxes, a tensor of dimensions (N, 8732, 4). Thus, one of the + outputs of PredictionConvolutions.forward(). + :param predicted_scores: class scores for each of the encoded + locations/boxes, a tensor of dimensions (N, 8732, n_classes). Thus, + the other output of PredictionConvolutions.forward(). + :param boxes: true object bounding boxes (ground-truth) in boundary + coordinates, a list of N tensors, where N is the total number of + pictures. (for each image I have a n_objects boxes, where + n_objects is the number of objects contained in that image) + :param labels: true object labels, a list of N tensors, where each + tensor has dimensions n_objects(for that image). + :return: multibox loss, a zero dimensional tensor (NOT a scalar!) + """ + batch_size = predicted_locs.size(0) + n_priors = self.priors_cxcy.size(0) + n_classes = predicted_scores.size(2) + + assert n_priors == predicted_locs.size(1) == predicted_scores.size(1) + + true_locs = torch.zeros((batch_size, n_priors, 4), + dtype=torch.float).to(device) # (N, 8732, 4) + true_classes = torch.zeros((batch_size, n_priors), + dtype=torch.long).to(device) # (N, 8732) + + # For each image + for i in range(batch_size): + n_objects = boxes[i].size(0) + + overlap = find_jaccard_overlap(boxes[i], + self.priors_xy) # (n_objects, 8732) + + # For each prior, find the object that has the maximum overlap + overlap_for_each_prior, object_for_each_prior = overlap.max( + dim=0) # (8732) + + # We don't want a situation where an object is not represented in + # our positive (non-background) priors - + # 1. An object might not be the best object for all priors, and is + # therefore not in object_for_each_prior. + # 2. All priors with the object may be assigned as background based + # on the threshold (0.5). + # To remedy: First, find the prior that has the maximum overlap for + # each object. + _, prior_for_each_object = overlap.max(dim=1) # (N_o) + + # Then, assign each object to the corresponding + # maximum-overlap-prior. + # This fixes 1. : in this way all the objects are considered. + object_for_each_prior[prior_for_each_object] = torch.LongTensor( + range(n_objects)).to(device) + + # To ensure these priors qualify, artificially give them an overlap + # of greater than 0.5. This fixes 2.: the objects that previously + # where not considered may have an overlap lower than the + # threshold. Thus in order to avoid this, we give them a + # value of 1. + overlap_for_each_prior[prior_for_each_object] = 1. + + # Labels for each prior + label_for_each_prior = labels[i][object_for_each_prior] # (8732) + # Set priors whose overlaps with objects are less than + # the threshold to be background (no object) + label_for_each_prior[ + overlap_for_each_prior < self.threshold] = 0 # (8732) + + # Store classes and localizations + true_classes[i] = label_for_each_prior + + # Encode center-size object coordinates into the form we regressed + # predicted boxes to + true_locs[i] = cxcy_to_gcxgcy( + xy_to_cxcy(boxes[i][object_for_each_prior]), + self.priors_cxcy) # (8732, 4) + + # Identify priors that are positive (object/non-background) + positive_priors = true_classes != 0 # (N, 8732) boolean values + + # LOCALIZATION LOSS + # Localization loss is computed only over positive (non-background) + # priors + loc_loss = self.smooth_l1(predicted_locs[positive_priors], + true_locs[positive_priors]) # (), scalar + + # Note: indexing with a torch.uint8 (byte) tensor flattens the tensor + # when indexing is across multiple dimensions (N & 8732) + # So, if predicted_locs has the shape (N, 8732, 4), + # predicted_locs[positive_priors] will have (total positives, 4) + + # CONFIDENCE LOSS + # Confidence loss is computed over positive priors and the most + # difficult (hardest) negative priors in each image + # That is, FOR EACH IMAGE, we will take the hardest + # (neg_pos_ratio * n_positives) negative priors, i.e where there is + # maximum loss. This is called Hard Negative Mining - it concentrates on + # hardest negatives in each image, and also minimizes pos/neg imbalance + + # Number of positive and hard-negative priors per image + n_positives = positive_priors.sum(dim=1) # (N) + n_hard_negatives = self.neg_pos_ratio * n_positives # (N) + + # First, find the loss for all priors + # we flatten the tensor predicted_scores from + # (num_img, num_priors, n_classes) to (num_img * num_priors, n_classes) + conf_loss_all = self.cross_entropy(predicted_scores.view(-1, n_classes), + true_classes.view(-1)) # (N * 8732) + + conf_loss_all = conf_loss_all.view(batch_size, n_priors) # (N, 8732) + + # We already know which priors are positive + conf_loss_pos = conf_loss_all[positive_priors] # (sum(n_positives)) + + # Next, find which priors are hard-negative + # To do this, sort ONLY negative priors in each image in order of + # decreasing loss and take top n_hard_negatives + conf_loss_neg = conf_loss_all.clone() # (N, 8732) + conf_loss_neg[positive_priors] = 0. + # (N, 8732), positive priors are ignored (never in top n_hard_negatives) + conf_loss_neg, _ = conf_loss_neg.sort( + dim=1, descending=True) # (N, 8732), sorted by decreasing hardness + # expand_as: used to give the same dimension of a tensor1 to a tensor2 + # which shape differs from those of tensor1 in a dimension (the value + # associated for this dimension in tensor2 has to be less than its value + # for tensor1) + hardness_ranks = torch.LongTensor( + range(n_priors)).unsqueeze(0).expand_as(conf_loss_neg).to( + device) # (N, 8732) + hard_negatives = hardness_ranks < n_hard_negatives.unsqueeze( + 1) # (N, 8732) + conf_loss_hard_neg = conf_loss_neg[ + hard_negatives] # (sum(n_hard_negatives)) 1d tensor + # As in the paper, averaged over positive priors only, although computed + # over both positive and hard-negative priors + conf_loss = (conf_loss_hard_neg.sum() + conf_loss_pos.sum() + ) / n_positives.sum().float() # (), scalar + # TOTAL LOSS + return conf_loss + self.alpha * loc_loss diff --git a/smithers/ml/models/detector.py b/smithers/ml/models/detector.py new file mode 100644 index 0000000..571f0d3 --- /dev/null +++ b/smithers/ml/models/detector.py @@ -0,0 +1,592 @@ +''' +Module focused on the creation of the object detector and implementaion of the +training and testing phases. +''' +from functools import reduce +from pprint import PrettyPrinter +import time +import torch +import torch.nn as nn +import numpy as np +from torchvision import transforms +from tqdm import tqdm +from PIL import ImageDraw, ImageFont +import copy + +from smithers.ml.loss.multibox_loss import MultiBoxLoss +from smithers.ml.utils_objdet import AverageMeter, clip_gradient, adjust_learning_rate, detect_objects, calculate_mAP, save_checkpoint_objdet + +device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + + +class Detector(nn.Module): + ''' + Class that handles the creation of the Object Detector and its training and + testing phases. + ''' + def __init__(self, network, checkpoint, priors_cxcy, n_classes, epochs, + batch_size, print_freq, lr, decay_lr_at, decay_lr_to, momentum, + weight_decay, grad_clip, train_loader, test_loader, optim_str): + ''' + :param list network: list of the different parts that compose the network + For each element you need to construct it using the class related. + :param path_file checkpoint: If None, you will need to initialize the + model and optimizer from zero, otherwise you will load them from + the checkpoint file given in input. + :param tensor priors_cxcy: priors (default bounding boxes) in + center-size coordinates, a tensor of size (n_boxes, 4) + :param scalar n_classes: number of different type of objects in your + dataset + :param scalar epochs: number of epochs to run without early-stopping + :param scalar batch_size: batch size + :param int print_freq: print training status every __ batches + :param scalar lr: learning rate + :param list decay_lr_at: decay learning rate after these many iterations + :param float decay_lr_to: decay learnign rate to this fraction of the + existing learning rate + :param scalar momentum: momentum rate + :param scalar weight_decay: weight decay + :param bool grad_clip: clip if gradients are exploding, which may happen + at larger batch sizes (sometimes at 32) - you will recognize it by a + sorting error in the MultiBox loss calculation + :param iterable train_loader: iterable object, it loads the dataset for + training. It iterates over the given dataset, obtained combining a + dataset(images, boxes and labels) and a sampler. + :param iterable test_loader: iterable object, it loads the dataset for + testing. It iterates over the given dataset, obtained combining a + dataset(images, boxes and labels) and a sampler. + :param str optim_str: string idetifying the optimzer to use, as 'Adam' + or 'SGD'. + ''' + super(Detector, self).__init__() + + self.priors = priors_cxcy.to(device) + self.n_classes = n_classes + self.batch_size = batch_size + self.print_freq = print_freq + self.lr = lr + self.decay_lr_at = decay_lr_at + self.decay_lr_to = decay_lr_to + self.momentum = momentum + self.weight_decay = weight_decay + self.grad_clip = grad_clip + self.criterion = MultiBoxLoss(self.priors).to(device) + #Stocastic gradient descent + self.train_loader = train_loader + self.test_loader = test_loader + self.optim_str = optim_str + self.start_epoch, self.model, self.optimizer = self.load_network( + network, checkpoint) + # Since lower level features (conv4_3_feats) have considerably larger + # scales, we take the L2 norm and rescale. Rescale factor is initially + # set at 20, but is learned for each channel during back-prop + self.rescale_factors = nn.Parameter(torch.FloatTensor( + 1, 512, 1, 1)).to(device) # there are 512 channels in conv4_3_feats + nn.init.constant_(self.rescale_factors, 20) + self.epochs = self.start_epoch + epochs + + def load_network(self, network, checkpoint): + ''' + Initialize model or load checkpoint + If checkpoint is None, initialize the model and optimizer + otherwise load checkpoint, coming from a previous training + and load the model and optimizer from here + :param list network: if is not None, it corresponds to a list + containing the different structures that compose your net. + Otherwise, if None, it means that we are loading the model from + a checkpoint + :param path_file checkpoint: If None, initialize the model and optimizer, + otherwise load them from the checkpoint file given in input. + ''' + + if checkpoint is None: + start_epoch = 0 + model = [network[i].to(device) for i in range(len(network))] + optimizer = self.init_optimizer(model) + else: + checkpoint = torch.load(checkpoint) + if isinstance(checkpoint, dict): + start_epoch = checkpoint['epoch'] + 1 + print('\nLoaded checkpoint from epoch %d.\n' % start_epoch) + net = checkpoint['model'] + model = [net[i].to(device) for i in range(len(net))] + optimizer = checkpoint['optimizer'] + else: + model = [checkpoint[i].to(device) for i in range(len(checkpoint))] + start_epoch = 0 + optimizer = self.init_optimizer(model) + return start_epoch, model, optimizer + + def init_optimizer(self, model): + ''' + Initialize the optimizer, with twice the default learning rate for + biases, as in the original Caffe repo + :param list model: list of the different parts that compose the network + For each element you need to construct it using the class related. + :return optimizer: optimizer object chosen + ''' + biases = list() + not_biases = list() + model_params = [model[i].named_parameters() for i in range(len(model)) + ] + for i in range(len(model_params)): + for param_name, param in model_params[i]: + if param.requires_grad: + if param_name.endswith('.bias'): + biases.append(param) + else: + not_biases.append(param) + if self.optim_str=='Adam': + optimizer = torch.optim.Adam(params=[{ + 'params': biases, + 'lr': self.lr + }, { + 'params': not_biases + }], + lr=self.lr, + weight_decay=self.weight_decay) + elif self.optim_str=='SGD': + optimizer = torch.optim.SGD(params=[{ + 'params': biases, + 'lr': 2 * self.lr + }, { + 'params': not_biases + }], + lr=self.lr, + momentum=self.momentum, + weight_decay=self.weight_decay) + else: + raise RuntimeError( + 'Invalid choice for the optimizer.') + + return optimizer + + def forward(self, images): + ''' + Forward propagation of the entire network. + + :param tensor images: batch of images. + :return: predicted localizations and classes scores (tensors) for + each image + :rtype: torch.Tensor + ''' + images = images.to(device) #dtype = torch.Tensor + # Run VGG base network convolutions (lower level feature map generators) + conv4_3, conv7 = self.model[0](images) + output_basenet = [conv4_3.to(device), conv7.to(device)] + + # Run auxiliary convolutions (higher level feature map generators) + output_auxconv = self.model[1](conv7) + + # Run prediction convolutions (predict offsets w.r.t prior-boxes and + # classes in each resulting localization box) + locs, classes_scores = self.model[2](output_basenet, output_auxconv) + + return locs.to(device), classes_scores.to(device) + + + def train_epoch(self, epoch): + """ + One epoch's training. + :param train_loader: an iterable over the given dataset, obtained + combining a dataset(images, boxes and labels) and a sampler. + :param epoch: epoch number + """ + for i in range(len(self.model) - 1): + self.model[i].train() +# self.model[i].features.train() + self.model[-1].features_loc.train() + self.model[-1].features_cl.train() + #training mode enables dropout + + batch_time = AverageMeter() # forward prop. + back prop. time + data_time = AverageMeter() # data loading time + losses = AverageMeter() # loss + + start = time.time() + + # Batches + for i, (images, boxes, labels, _) in enumerate(self.train_loader): + data_time.update(time.time() - start) + + # Move to default device + images = images.to(device) # (batch_size (N), 3, 300, 300) + boxes = [b.to(device) for b in boxes] + labels = [l.to(device) for l in labels] + + # Forward prop. + predicted_locs, predicted_scores = self.forward(images) + # (N, 8732, 4), (N, 8732, n_classes) + + # Loss + loss = self.criterion(predicted_locs, predicted_scores, boxes, + labels) # scalar + + # Backward prop. + self.optimizer.zero_grad() + #model.cleargrads() + loss.backward() + + # Clip gradients, if necessary + if self.grad_clip is not None: + clip_gradient(self.optimizer, self.grad_clip) + + # Update model + self.optimizer.step() + + losses.update(loss.item(), images.size(0)) + batch_time.update(time.time() - start) + + start = time.time() + + # Print status + if i % self.print_freq == 0: + print('Epoch: [{0}][{1}/{2}]\t' + 'Batch Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' + 'Data Time {data_time.val:.3f} ({data_time.avg:.3f})\t' + 'Loss val (average) {loss.val:.4f} ({loss.avg:.4f})\t'.format( + epoch, + i, + len(self.train_loader), + batch_time=batch_time, + data_time=data_time, + loss=losses)) + del predicted_locs, predicted_scores, images, boxes, labels + # free some memory since their histories may be stored + return losses.avg #loss.item() + + def train_detector(self, label_map=None): + ''' + Total training of the detector for all the epochs. + + :param dict label_map: dictionary for the label map, where the keys are + the labels of the objects(the classes) and their values the number + of the classes to which they belong (0 for the background). Thus the + length of this dict will be the number of the classes of the + dataset. + :return: checkpoint file containing the status of the net at the end of the + training (check_objdet) and a list with the value of the loss over time + (loss_values). + :rtype: str, list + ''' + # Epochs + loss_values = [] + mAP_values = [] + for epoch in range(self.start_epoch, self.epochs): + + # Decay learning rate at particular epochs + if epoch in self.decay_lr_at: + adjust_learning_rate(self.optimizer, self.decay_lr_to) + + # One epoch's training + loss_val = self.train_epoch(epoch=epoch) + loss_values.extend([loss_val]) + if label_map is not None: + mAP_val = self.eval_detector(label_map) + mAP_values.extend([mAP_val]) + + # Save checkpoint + check_objdet = 'checkpoint_objdet.pth' + torch.save(copy.deepcopy(self.model), check_objdet) + # If a more complete checkpoint is needed uncomment the following line. + check_objdet_full = 'checkpoint_objdet_full.pth.tar' + check_objdet_full = save_checkpoint_objdet(self.epochs, self.model, self.optimizer, check_objdet_full) + return check_objdet, loss_values + + + def eval_detector(self, label_map): + ''' + Evaluation/Testing Phase + + :param dict label_map: dictionary for the label map, where the keys are + the labels of the objects(the classes) and their values the number + of the classes to which they belong (0 for the background). Thus the + length of this dict will be the number of the classes of the + dataset. + ''' + # set the network(all classes derived from nn.module) in evaluation mode + for i in range(len(self.model) - 1): + self.model[i].eval() + #model[i].features.eval() + self.model[-1].features_loc.eval() + self.model[-1].features_cl.eval() + # Lists to store detected and true boxes, labels, scores + det_boxes = list() + det_labels = list() + det_scores = list() + true_boxes = list() + true_labels = list() + true_difficulties = list() + + # Good formatting when printing the APs for each class and mAP + pp = PrettyPrinter() + + #torch.no_grad() impacts the autograd engine and deactivate it. + #It will reduce memory usage and speed up computations but you + #would not be able to backprop (which you do not want in an eval + #script). + with torch.no_grad(): + # Batches + for i, (images, boxes, labels, difficulties) in enumerate( + tqdm(self.test_loader, desc='Evaluating')): + images = images.to(device) # (N, 3, 300, 300) + + # Forward prop. + predicted_locs, predicted_scores = self.forward(images) + + # Detect objects in SSD output + det_boxes_batch, det_labels_batch, det_scores_batch = detect_objects( + self.priors, + predicted_locs, + predicted_scores, + self.n_classes, + min_score=0.01, + max_overlap=0.45, + top_k=20) + # Evaluation MUST be at min_score=0.01, max_overlap=0.45, + # top_k=200 for fair comparision with the paper's results + # and other repos + + # Store this batch's results for mAP calculation + boxes = [b.to(device) for b in boxes] + labels = [l.to(device) for l in labels] + difficulties = [d.to(device) for d in difficulties] + + det_boxes.extend(det_boxes_batch) + det_labels.extend(det_labels_batch) + det_scores.extend(det_scores_batch) + true_boxes.extend(boxes) + true_labels.extend(labels) + true_difficulties.extend(difficulties) + + # Calculate mAP + APs, mAP = calculate_mAP(det_boxes, det_labels, det_scores, + true_boxes, true_labels, true_difficulties, + label_map) + print(APs) + # Print AP for each class + pp.pprint(APs) + + print('\nMean Average Precision (mAP): %.3f' % mAP) + return mAP + + + def detect(self, + original_image, + label_map, + min_score, + max_overlap, + top_k, + suppress=None): + """ + Detect objects in an image with a trained SSD300, and visualize + the results. + + :param PIL Imagw original_image: image, a PIL Image + :param dict label_map: dictionary for the label map, where the keys are + the labels of the objects(the classes) and their values the number + of the classes to which they belong (0 for the background). Thus the + length of this dict will be the number of the classes of the + dataset. + :param float min_score: minimum threshold for a detected box to + be considered a match for a certain class + :param float max_overlap: maximum overlap two boxes can have so + that the one with the lower score is not suppressed via + Non-Maximum Suppression (NMS) + :param int top_k: if there are a lot of resulting detection across + all classes, keep only the top 'k' + :param list suppress:a list of classes that you know for sure cannot be + in the image or you do not want in the image. If None, it does not + suppress anything. + :return: annotated image, a PIL Image + """ + + # set the network(all classes derived from nn.module) in evaluation mode + for i in range(len(self.model) - 1): + self.model[i].eval() +# model[i].features.eval() + self.model[-1].features_loc.eval() + self.model[-1].features_cl.eval() + + # Color map for bounding boxes of detected objects from + # https://sashat.me/2017/01/11/list-of-20-simple-distinct-colors/ + distinct_colors = [ + '#e6194b', '#3cb44b', '#ffe119', '#0082c8', '#f58231', '#911eb4', + '#46f0f0', '#f032e6', '#d2f53c', '#fabebe', '#008080', '#000080', + '#aa6e28', '#fffac8', '#800000', '#aaffc3', '#808000', '#ffd8b1', + '#e6beff', '#808080', '#FFFFFF' + ] + label_color_map = { + k: distinct_colors[i] + for i, k in enumerate(label_map.keys()) + } + + # Transforms + resize = transforms.Resize((300, 300)) + to_tensor = transforms.ToTensor() + normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], + std=[0.229, 0.224, 0.225]) + image = normalize(to_tensor(resize(original_image))) + + # Move to default device + image = image.to(device) + + # Forward prop. + predicted_locs, predicted_scores = self.forward(image.unsqueeze(0)) + + # Detect objects in SSD output + det_boxes, det_labels, det_scores = detect_objects( + self.priors, + predicted_locs, + predicted_scores, + self.n_classes, + min_score=min_score, + max_overlap=max_overlap, + top_k=top_k) + + # Move detections to the CPU + det_boxes = det_boxes[0].to(device) + + # Transform to original image dimensions + original_dims = torch.FloatTensor([ + original_image.width, original_image.height, original_image.width, + original_image.height + ]).unsqueeze(0).to(device) + det_boxes = det_boxes * original_dims + + rev_label_map = {v: k for k, v in label_map.items()} # Inverse mapping + # Decode class integer labels + det_labels = [ + rev_label_map[l] for l in det_labels[0].to(device).tolist() + ] + + # If no objects found, the detected labels will be set to ['0.'], i.e. + # ['background'] in detect_objects() in util.py + if det_labels == ['background']: + # Just return original image + return original_image + + # Annotate + annotated_image = original_image + # Create an object that can be used to draw in the given image. + draw = ImageDraw.Draw(annotated_image) + #font = ImageFont.truetype("./calibril.ttf", 15) + # this line does not work for me, try to fix in case, use dafault font + font = ImageFont.load_default() + + # Suppress specific classes, if needed + for i in range(det_boxes.size(0)): + if suppress is not None: + if det_labels[i] in suppress: + continue + + # Boxes + box_location = det_boxes[i].tolist() + draw.rectangle(xy=box_location, + outline=label_color_map[det_labels[i]]) + draw.rectangle(xy=[l + 1. for l in box_location], + outline=label_color_map[det_labels[i]]) + # a second rectangle at an offset of 1 pixel to increase line + # thickness + # draw.rectangle(xy=[l + 2. for l in box_location], + # outline=label_color_map[det_labels[i]]) + # a third rectangle at an offset of 1 pixel to increase line + # thickness + # draw.rectangle(xy=[l + 3. for l in box_location], + # outline=label_color_map[det_labels[i]]) + # a fourth rectangle at an offset of 1 pixel to increase line + # thickness + + # Text + text_size = font.getsize(det_labels[i].upper()) + text_location = [ + box_location[0] + 2., box_location[1] - text_size[1] + ] + textbox_location = [ + box_location[0], box_location[1] - text_size[1], + box_location[0] + text_size[0] + 4., box_location[1] + ] + draw.rectangle(xy=textbox_location, + fill=label_color_map[det_labels[i]]) + draw.text(xy=text_location, + text=det_labels[i].upper(), + fill='white', + font=font) + img_final = annotated_image.save('out.jpg') + del draw + + return annotated_image + + +class Reduced_Detector(Detector): + ''' + Class that handles the creation of the Reduced Object Detector and its training and + testing phases. This class extends the Detector class. + ''' + + def __init__(self, network, checkpoint, priors_cxcy, n_classes, epochs, + batch_size, print_freq, lr, decay_lr_at, decay_lr_to, momentum, + weight_decay, grad_clip, train_loader, test_loader, optim_str, red_method): + ''' + :param list network: list of the different parts that compose the network + For each element you need to construct it using the class related. + :param path_file checkpoint: If None, you will need to initialize the + model and optimizer from zero, otherwise you will load them from + the checkpoint file given in input. + :param tensor priors_cxcy: priors (default bounding boxes) in + center-size coordinates, a tensor of size (n_boxes, 4) + :param scalar n_classes: number of different type of objects in your + dataset + :param scalar epochs: number of epochs to run without early-stopping + :param scalar batch_size: batch size + :param int print_freq: print training status every __ batches + :param scalar lr: learning rate + :param list decay_lr_at: decay learning rate after these many iterations + :param float decay_lr_to: decay learnign rate to this fraction of the + existing learning rate + :param scalar momentum: momentum rate + :param scalar weight_decay: weight decay + :param bool grad_clip: clip if gradients are exploding, which may happen + at larger batch sizes (sometimes at 32) - you will recognize it by a + sorting error in the MultiBox loss calculation + :param iterable train_loader: iterable object, it loads the dataset for + training. It iterates over the given dataset, obtained combining a + dataset(images, boxes and labels) and a sampler. + :param iterable test_loader: iterable object, it loads the dataset for + testing. It iterates over the given dataset, obtained combining a + dataset(images, boxes and labels) and a sampler. + :param str optim_str: string idetifying the optimzer to use, as 'Adam' + or 'SGD'. + :param str red_method: reduction method to used, e.g. 'POD', 'HOSVD'. + ''' + super().__init__(network, checkpoint, priors_cxcy, n_classes, epochs, + batch_size, print_freq, lr, decay_lr_at, decay_lr_to, momentum, + weight_decay, grad_clip, train_loader, test_loader, optim_str) + self.red_method = red_method + + def forward(self, images): + ''' + Forward propagation of the entire network + :param tensor images: dataset of images used + :return: predicted localizations and classes scores (tensors) for + each image + ''' + images = images.to(device) #dtype = torch.Tensor + # Run VGG base network convolutions (lower level feature map generators) + out_vgg = self.model[0](images) + output_basenet = [out_vgg] + + # Run auxiliary convolutions (higher level feature map generators) + if self.red_method=='HOSVD': + output_auxconv = self.model[1](out_vgg) + elif self.red_method=='POD': + output_auxconv = self.model[1](out_vgg.view(out_vgg.size(0), -1)) + output_auxconv = torch.unsqueeze(torch.unsqueeze(output_auxconv, dim=-1), dim=-1) + else: + raise ValueError('Wrong choice of the reduction method used.') + + # Run prediction convolutions (predict offsets w.r.t prior-boxes and + # classes in each resulting localization box) + locs, classes_scores = self.model[2](output_basenet, [output_auxconv]) + + return locs.to(device), classes_scores.to(device) diff --git a/smithers/ml/models/fnn.py b/smithers/ml/models/fnn.py new file mode 100644 index 0000000..53ffba7 --- /dev/null +++ b/smithers/ml/models/fnn.py @@ -0,0 +1,135 @@ +''' +Class that handles the creation of a Feedforward Neural +Network (FNN). +''' + +from numpy import real +import torch +import torch.nn as nn +import torch.optim as optim +import os + +if torch.cuda.is_available(): + device = torch.device('cuda') +else: + device = torch.device('cpu') + +class FNN(nn.Module): + def __init__(self, n_input, n_output, inner_size=20, + n_layers=1, func=nn.Softplus, layers=None): + ''' + Construction of a Feedforward Neural Network (FNN) with + given a number of input and output neurons, one hidden + layer with a number n_hid of neurons. + + :param int n_input: number of input neurons + :param int n_output: number of output neurons that corresponds + to the number of classes that compose the dataset + :param int inner_size: number of hidden neurons + :param int n_layers: number of hidden layers + :param nn.Module func: activation function. Default + function: nn.Softplus + :param list layers: list where each component represents the + number of hidden layers for the corresponding layer + :param bool cifar: boolean to identify if we are using as dataset + the cifar one + ''' + super(FNN, self).__init__() + + self.n_input = n_input + self.n_output = n_output + + if layers is None: + layers = [inner_size] * n_layers + + tmp_layers = layers.copy() + tmp_layers.insert(0, self.n_input) + tmp_layers.append(self.n_output) + #tmp_layers[0] = self.n_input + + + self.layers = [] + for i in range(len(tmp_layers)-1): + self.layers.append(nn.Linear(tmp_layers[i], tmp_layers[i+1])) + + if isinstance(func, list): + self.functions = func + else: + self.functions = [func for _ in range(len(self.layers)-1)] + + if len(self.layers) != len(self.functions) + 1: + raise RuntimeError('uncosistent number of layers and functions') + + + unique_list = [] + for layer, func in zip(self.layers[:-1], self.functions): + unique_list.append(layer) + if func is not None: + unique_list.append(func()) + unique_list.append(self.layers[-1]) + + self.model = nn.Sequential(*unique_list) + + + def forward(self, x): + ''' + Forward Phase. + + :param tensor x: input of the network with dimensions + n_images x n_input + :return: output of the FNN n_images x n_output + :rtype: tensor + ''' + return self.model(x) + + + + + +def training_fnn(fnn_net, epochs, inputs_net, real_out): + ''' + Training phase for a Feed Forward Neural Network (FNN). + + :param nn.Module fnn_net: FNN model + :param int epochs: epochs for the training phase. + :param tensor inputs_net: matrix of inputs for the network + with dimensions n_input x n_images. + :param tensor real_out: tensor representing the real output + of the network. + ''' + criterion = nn.CrossEntropyLoss().to(device) + optimizer = optim.Adam(fnn_net.parameters(), lr=0.0001) + correct = 0 + total = 0 + + fnn_net = fnn_net.to(device) + inputs_net = inputs_net.to(device) + for i in range(len(real_out)): + real_out[i] = real_out[i].to(device) + + final_loss = [] + batch_size = 128 + print('FNN training initialized') + for epoch in range(epochs): # loop over the dataset multiple times + for i in range(inputs_net.size()[0] // batch_size): + # zero the parameter gradients + optimizer.zero_grad() + + # forward + backward + optimize + outputs = fnn_net((inputs_net[i * batch_size:(i + 1) * + batch_size, :]).to(device)) + loss = criterion( + outputs, + torch.LongTensor(real_out[i * batch_size:(i + 1) * + batch_size]).to(device)) + loss.backward(retain_graph=True) + optimizer.step() + + + _, predicted = torch.max(outputs.data, 1) + labels = torch.LongTensor(real_out[i * batch_size:(i + 1) * + batch_size]).to(device) + total += labels.size(0) + + correct += (predicted == labels).sum().item() + print('FNN training completed', flush = True) diff --git a/smithers/ml/models/netadapter.py b/smithers/ml/models/netadapter.py new file mode 100644 index 0000000..b381ac7 --- /dev/null +++ b/smithers/ml/models/netadapter.py @@ -0,0 +1,317 @@ +''' +Module focused on the reduction of the ANN and implementation of the +training and testing phases. +''' + +import torch +import torch.nn as nn +import numpy as np + +from smithers.ml.models.rednet import RedNet +from smithers.ml.models.fnn import FNN, training_fnn +from smithers.ml.utils_rednet import PossibleCutIdx, spatial_gradients, forward_dataset, projection, tensor_projection, randomized_svd +from smithers.ml.layers.ahosvd import AHOSVD +from smithers.ml.layers.pcemodel import PCEModel + +#from ATHENA.athena.active import ActiveSubspaces + +if torch.cuda.is_available(): + device = torch.device('cuda') +else: + device = torch.device('cpu') + +class NetAdapter(): + ''' + Class that handles the reduction of a pretrained ANN and implementation + of the training and testing phases. + ''' + def __init__(self, cutoff_idx, red_dim, red_method, inout_method): + ''' + :param int cutoff_idx: value that identifies the cut-off layer + :param int/list red_dim: dimension of the reduced space onto which we + project the high-dimensional vectors or list of the reduced + dimensions for each direction in the tensorial space under + consideration. + :param str red_method: string that identifies the reduced method to + use, e.g. 'AS', 'POD'. 'AHOSVD'. + :param str inout_method: string the represents the technique to use for + the identification of the input-output map, e.g. 'PCE', 'FNN'. + + :Example: + + >>> from smithers.ml.netadapter import NetAdapter + >>> netadapter = NetAdapter(6, 50, 'POD', 'FNN') + >>> original_network = import_net() # user defined method to load/build the original model + >>> train_data = construct_dataset(path_to_dataset) + >>> train_loader = load_dataset(train_data) + >>> train_labels = train_data.targets + >>> n_class = 10 + >>> red_model = netadapter.reduce_net(original_network, train_data, train_labels, train_loader, n_class) + ''' + + self.cutoff_idx = cutoff_idx + if isinstance(red_dim, list): + self.red_dim_list = red_dim + self.red_dim = np.prod(red_dim) + else: + self.red_dim = red_dim + self.red_method = red_method + self.inout_method = inout_method + + def _reduce_AS(self, pre_model, post_model, train_dataset): + ''' + Function that performs the reduction using Active Subspaces (AS) + :param nn.Sequential pre_model: sequential model representing + the pre-model. + :param nn.Sequential post_model: sequential model representing + the pre-model. + :param Dataset train_dataset: dataset containing the training + images. + :returns: tensor proj_mat representing the projection matrix + for AS (n_feat x red_dim) + :rtype: torch.Tensor + ''' + input_type = train_dataset.__getitem__(0)[0].dtype + grad = spatial_gradients(train_dataset, pre_model, post_model) + asub = ActiveSubspaces(dim=self.red_dim, method='exact').to(device) + asub.fit(gradients=grad) + proj_mat = torch.tensor(asub.evects, dtype=input_type) + + return proj_mat + + def _reduce_POD(self, matrix_features): + ''' + Function that performs the reduction using the Proper Orthogonal + Decomposition (POD). + :param torch.Tensor matrix_features: (n_images x n_feat) matrix + containing the output of the pre-model that needs to be reduced. + :returns: tensor proj_mat representing the projection matrix + for POD (n_feat x red_dim). + :rtype: torch.Tensor + ''' + u = torch.svd(torch.transpose(matrix_features, 0, 1))[0] + proj_mat = u[:, :self.red_dim] + + return proj_mat + + def _reduce_RandSVD(self, matrix_features): + ''' + Function that performs the reduction using the Randomized SVD (RandSVD). + :param torch.Tensor matrix_features: (n_images x n_feat) matrix + containing the output of the pre-model that needs to be reduced. + :returns: tensor proj_mat representing the projection matrix + obtained via RandSVD (n_feat x red_dim). + :rtype: torch.Tensor + ''' + matrix_features = matrix_features.to('cpu') + u, _, _ = randomized_svd(torch.transpose(matrix_features, 0, 1), self.red_dim) + return u + + def _reduce_HOSVD(self, model, data_loader, device): + ''' + Function that performs the reduction using the Higher + order SVD (HOSVD) and in particular its averaged version (AHOSVD). + + :param nn.Module/torch.Tensor model: model under consideration for + computing its outputs (that has to be reduced) or + (n_images x n_channel x H x W) tensor containing the output of + the pre-model (in its tensorial version) that needs to be reduced. + :param torch.device device: device used to allocate the variables for + the function. + :returns: list containing the projection matrices obtained via HOSVD + for each dimension of the tensor (excluded the one related to the + batch of images). + :rtype: list + ''' + batch_hosvd = 1 + batch_old = 0 + ahosvd = AHOSVD(torch.zeros(0), self.red_dim_list, batch_hosvd) + for idx_, batch in enumerate(data_loader): + images = batch[0].to(device) + + with torch.no_grad(): + if torch.is_tensor(model): + outputs = out[batch_old : batch_old + images.size()[0], : ] + batch_old = images.size()[0] + else: + outputs = model(images).to(device) + ahosvd_temp = AHOSVD(outputs, self.red_dim_list, batch_hosvd) + ahosvd_temp.compute_u_matrices() + ahosvd_temp.compute_proj_matrices() + + ahosvd.proj_matrices = ahosvd.incremental_average(ahosvd.proj_matrices, + ahosvd_temp.proj_matrices, + idx_) + del ahosvd_temp + del outputs + #torch.cuda.empty_cache() + return ahosvd.proj_matrices + + + def _reduce(self, pre_model, post_model, train_dataset, train_loader, device = device): + ''' + Function that performs the reduction of the high dimensional + output of the pre-model. + :param nn.Sequential pre_model: sequential model representing + the pre-model. + :param nn.Sequential post_model: sequential model representing + the pre-model. + :param Dataset train_dataset: dataset containing the training + images. + :param iterable train_loader: iterable object for loading the dataset. + It iterates over the given dataset, obtained combining a + dataset(images and labels) and a sampler. + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + :returns: tensors matrix_red and proj_mat containing the reduced output + of the pre-model (n_images x red_dim) and the projection matrix + (n_feat x red_dim) respectively. + :rtype: torch.tensor + ''' + + if self.red_method == 'AS': + #code for AS + matrix_features = forward_dataset(pre_model, train_loader).to(device) + proj_mat = self._reduce_AS(pre_model, post_model, train_dataset) + matrix_red = projection(proj_mat, train_loader, matrix_features) + + elif self.red_method == 'POD': + #code for POD + matrix_features = forward_dataset(pre_model, train_loader).to(device) + proj_mat = self._reduce_POD(matrix_features) + matrix_red = projection(proj_mat, train_loader, matrix_features) + + elif self.red_method == 'RandSVD': + #code for RandSVD + matrix_features = forward_dataset(pre_model, train_loader).to(device) + proj_mat = self._reduce_RandSVD(matrix_features) + matrix_red = projection(proj_mat, train_loader, matrix_features) + + elif self.red_method == 'HOSVD': + #code for HOSVD + #tensor_features = forward_dataset(pre_model, train_loader, flattening = False).to(device) + proj_mat = self._reduce_HOSVD(pre_model, train_loader, device) + matrix_red = tensor_projection(proj_mat, train_loader, pre_model, device) + + else: + raise ValueError + + return matrix_red, proj_mat + + def _inout_mapping_FNN(self, matrix_red, train_labels, n_class): + ''' + Function responsible for the creation of the input-output map using + a Feedfoprward Neural Network (FNN). + + :param torch.tensor matrix_red: matrix containing the reduced output + of the pre-model. + :param torch.tensor train_labels: tensor representing the labels + associated to each image in the train dataset. + :param int n _class: number of classes that composes the dataset + :return: trained model of the FNN + :rtype: nn.Module + ''' + n_neurons = 20 + targets = list(train_labels) + fnn = FNN(self.red_dim, n_class, n_neurons).to(device) + epochs = 500 + training_fnn(fnn, epochs, matrix_red.to(device), targets) + + return fnn + + def _inout_mapping_PCE(self, matrix_red, out_postmodel, train_loader, + train_labels): + ''' + Function responsible for the creation of the input-output map using + the Polynomial Chaos Expansion method (PCE). + + :param torch.tensor matrix_red: matrix containing the reduced output + of the pre-model. + :param nn.Sequential post_model: sequential model representing + the pre-model. + :param iterable train_loader: iterable object, it load the dataset for + training. It iterates over the given dataset, obtained combining a + dataset (images and labels) and a sampler. + :param torch.tensor train_labels: tensor representing the labels + associated to each image in the train dataset. + :return: trained model of PCE layer and PCE coeff + :rtype: list + ''' + mean = torch.mean(matrix_red, 0).to(device) + var = torch.std(matrix_red, 0).to(device) + + PCE_model = PCEModel(mean, var) + coeff = PCE_model.Training(matrix_red, out_postmodel, + train_labels[:matrix_red.shape[0]])[0] + PCE_coeff = torch.FloatTensor(coeff).to(device) + + return [PCE_model, PCE_coeff] + + def _inout_mapping(self, matrix_red, n_class, model, train_labels, + train_loader): + ''' + Function responsible for the creation of the input-output map. + :param tensor matrix_red: matrix containing the reduced output + of the pre-model. + :param int n _class: number of classes that composes the dataset + :param tensor train_labels: tensor representing the labels associated + to each image in the train dataset + :param nn.Sequential model: sequential model representing + :param tensor train_labels: tensor representing the labels associated + to each image in the train dataset. + :param iterable train_loader: iterable object, it load the dataset for + training. It iterates over the given dataset, obtained combining a + dataset (images and labels) and a sampler. + :return: trained model of FNN or list with the trained model of PCE and + the corresponding PCE coefficients + :rtype: nn.Module/list + ''' + if self.inout_method == 'FNN': + #code for FNN + inout_map = self._inout_mapping_FNN(matrix_red, train_labels, n_class) + + elif self.inout_method == 'PCE': + #code for PCE + out_model = forward_dataset(model, train_loader) + inout_map = self._inout_mapping_PCE(matrix_red, out_model, train_loader, train_labels) + + elif self.inout_method == None: + # In the case of object detection, we do not need this input_output part, since the + # predictor is unchanged w.r.t. the original input network. + inout_map = nn.Identity() + + else: + raise ValueError + + return inout_map + + def reduce_net(self, input_network, train_dataset, train_labels, + train_loader, n_class, device = device): + ''' + Function that performs the reduction of the network + :param nn.Sequential input_network: sequential model representing + the input network. If the sequential model is not provided, but + instead you have a nn.Module obj, see the function get_seq_model + in utils.py. + :param Dataset train_dataset: dataset containing the training + images + :param torch.Tensor train_labels: tensor representing the labels + associated to each image in the train dataset + :param iterable train_loader: iterable object for loading the dataset. + It iterates over the given dataset, obtained combining a + dataset(images and labels) and a sampler. + :param int n _class: number of classes that composes the dataset + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + :return: reduced net + :rtype: nn.Module + ''' + input_type = train_dataset.__getitem__(0)[0].dtype + possible_cut_idx = PossibleCutIdx(input_network) + cut_idxlayer = possible_cut_idx[self.cutoff_idx] + pre_model = input_network[:cut_idxlayer].to(device, dtype=input_type) + post_model = input_network[cut_idxlayer:].to(device, dtype=input_type) + snapshots_red, proj_mat = self._reduce(pre_model, post_model, train_dataset, train_loader, device) + inout_map = self._inout_mapping(snapshots_red, n_class, input_network, train_labels, train_loader) + reduced_net = RedNet(n_class, pre_model, proj_mat, inout_map) + return reduced_net.to(device) diff --git a/smithers/ml/models/rednet.py b/smithers/ml/models/rednet.py new file mode 100644 index 0000000..9b78549 --- /dev/null +++ b/smithers/ml/models/rednet.py @@ -0,0 +1,82 @@ +''' +Class that handles the construction of the reduced network composed +by the premodel, the reduction layer and the final input-output map. +''' +import copy +import torch +import torch.nn as nn +from smithers.ml.layers.tensor_product_layer import tensor_product_layer + +if torch.cuda.is_available(): + device = torch.device('cuda') +else: + device = torch.device('cpu') + +class RedNet(nn.Module): + ''' + Creation of the reduced Neural Network starting from the + different blocks that composes it: pre-model, projection + matrix proj_mat and input-output mapping inout_map. + + :param int n_classes: number of classes that composes the dataset. + :param nn.Sequential premodel: sequential model representing the pre-model. + Default value set to None. + :param torch.tensor proj_mat: projection matrix. Default value set to None. + :param nn.Module/list inout_map: input-output mapping. For example it can be + a trained model of FNN or a list with the trained model of PCE and the + corresponding PCE coefficients. Default value set to None. + :param path_file checkpoint: If None, you will use the previuos block to + initialize the reduced model, otherwise you will load them from the + checkpoint file given in input. + ''' + def __init__(self, n_classes, premodel=None, proj_mat=None, inout_map=None, + checkpoint=None): + super(RedNet, self).__init__() + if checkpoint is not None: + rednet = torch.load(checkpoint, torch.device(device)) + self.premodel = rednet['model'].premodel + self.proj_model = rednet['model'].proj_model + self.inout_map = rednet['model'].inout_map + else: + self.premodel = premodel + if isinstance(proj_mat, nn.Linear): + self.proj_model = proj_mat + elif isinstance(proj_mat, list): + self.proj_model = tensor_product_layer(proj_mat) + else: + self.proj_model = nn.Linear(proj_mat.size()[0], + proj_mat.size()[1], bias=False) + self.proj_model.weight.data = copy.deepcopy(proj_mat).t() + + if isinstance(inout_map, list): + self.inout_basis = inout_map[0] + self.inout_lay = nn.Linear(inout_map[0].nbasis, n_classes, + bias=False) + self.inout_lay.weight.data = copy.deepcopy(inout_map[1]).t() + self.inout_map = nn.Sequential(self.inout_basis, self.inout_lay) + else: + self.inout_map = inout_map + + def forward(self, x): + ''' + Forward Phase. The first clause concerns AHOSVD, the other one is a more general version. + + :param torch.tensor x: input for the reduced net with dimensions + n_images x n_input. + :return: output n_images x n_class + :rtype: torch.tensor + ''' + x = x.to(device) + x = self.premodel(x) + if isinstance(self.proj_model, tensor_product_layer): + x = self.proj_model(x) + if len(self.proj_model.list_of_matrices) == len(x.shape): + x = x.flatten() + elif len(x.shape) == len(self.proj_model.list_of_matrices) + 1: + x = x.reshape(x.shape[0], int(torch.prod(torch.tensor(x.shape[1:])))) + else: + x = x.view(x.size(0), -1) + x = self.proj_model(x) + x = self.inout_map(x) + + return x diff --git a/smithers/ml/models/vgg.py b/smithers/ml/models/vgg.py new file mode 100644 index 0000000..bad20b9 --- /dev/null +++ b/smithers/ml/models/vgg.py @@ -0,0 +1,269 @@ +''' +Module focused on the implementation of VGG. +''' +import torch +import torch.nn as nn +import torchvision + +from smithers.ml.utils_imagerec import decimate + +if torch.cuda.is_available(): + device = torch.device('cuda') +else: + device = torch.device('cpu') + + +class VGG(nn.Module): + ''' + VGG base convolutions to produce lower-level feature maps. + As a model to construct the VGG class we are considering the one + already implemented in Pytorch + (https://pytorch.org/docs/stable/_modules/torchvision/models/vgg.html#vgg16) + and the one than can be found in this Pytorch tutorial for Object Detection: + https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection. + + :param list cfg: If None, returns the configuration of VGG16. Otherwise + a list of numbers and string 'M', representing all the layers of + the net (its configuration), where the numbers represent the number + of filters for that convolutional layers(i.e. the features + extracted) and 'M' stands for the max pool layer + :param bool batch_norm: If True, perform batch normalization + :param string/sequential classifier: If is equal to the string + 'standard', build the classical VGG16 classifier layers for a VGG16 + to be trained on a dataset such as ImageNet (images 3 x 300 x 300). + If is equal to 'cifar', build the classifier for VGG16 trained on a + dataset like CIFAR is built. (N.B. here images are 3 x 32 x 32). + See for more details: + - Shuying Liu and Weihong Deng. + 'Very deep convolutional neural network based image classification + using small training sample size.' + In Pattern Recognition (ACPR),2015 3rd IAPR Asian Conference on, + pages 730–734. IEEE, 2015. + DOI: 10.1109/ACPR.2015.7486599 + - https://github.com/geifmany/cifar-vgg + - https://github.com/chengyangfu/pytorch-vgg-cifar10 + If is equal to 'ssd', build the classifier layers for the SSD300 + architecture. + Otherwise if is a sequential container, the classifier correspond + exactly to this. + :param int num_classes: number of classes in your dataset. + :param str init_weights: If 'random', the weights are inizialized + following standard random distributins. If 'imagenet', pre-trained + weights on ImageNet are loaded. + ''' + def __init__(self, + cfg=None, + classifier='standard', + batch_norm=False, + num_classes=1000, + init_weights='random'): + super(VGG, self).__init__() + + self.num_classes = num_classes + available_classifier = { + 'standard': + nn.Sequential( + nn.Linear(512 * 7 * 7, 4096), + nn.ReLU(True), + nn.Dropout(), + nn.Linear(4096, 4096), + nn.ReLU(True), + nn.Dropout(), + nn.Linear(4096, self.num_classes), + ), + 'cifar': + nn.Sequential(nn.Linear(512, self.num_classes), ), + 'ssd': + nn.Sequential( + nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6), + nn.Conv2d(1024, 1024, kernel_size=1)) + } + + if cfg is None: + configuration = [ + 64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, + 'M', 512, 512, 512, 'M' + ] + if classifier == 'ssd': + configuration[-1] = 'M3' + self.configuration = configuration + else: + self.configuration = cfg + self.features = self.make_layers(batch_norm) + self.avgpool = nn.AdaptiveAvgPool2d((7, 7)) + self.classifier_str = classifier + if isinstance(classifier, str): + self.classifier = available_classifier.get(classifier) + else: + self.classifier = classifier + if init_weights == 'random': + self._initialize_weights() + elif init_weights == 'imagenet': + self.load_pretrained_layers(cfg) + else: + raise RuntimeError( + 'Invalid choice for the initialization of the weigths.') + + def make_layers(self, batch_norm=False): + ''' + Construct the structure of the net (only the features part) + starting from the configuration given in input. + + :param bool batch_norm: If True, perform batch normalization + :return: sequential object containing the structure of the + features part of the net + :rtype: nn.Sequential + ''' + layers = [] + in_channels = 3 + for k in range(len(self.configuration)): + if self.configuration[k] == 'M': + layers += [ + nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True) + ] + elif self.configuration[k] == 'M3': + layers += [nn.MaxPool2d(kernel_size=3, stride=1, padding=1)] + else: + conv2d = nn.Conv2d(in_channels, + self.configuration[k], + kernel_size=3, + padding=1) + if batch_norm: + layers += [ + conv2d, + nn.BatchNorm2d(self.configuration[k]), + nn.ReLU(inplace=True) + ] + else: + layers += [conv2d, nn.ReLU(inplace=True)] + in_channels = self.configuration[k] + return nn.Sequential(*layers) + + def forward(self, image): + ''' + Forward propagation. + + :param torch.Tensor image: images, a tensor of dimensions + (N, 3, width, height), where N is the number of images given in + input. + :param str classifier: a string corresponding to the classifier you + are using + :return: lower-level feature maps conv4_3 and conv7 (final output + of the net, i.e. a vector with the predictions for every class) + :rtype: torch.Tensor + ''' + x = self.features[:20](image) + conv4_3 = x.clone().detach() + x = self.features[20:](x) + if self.classifier_str == 'standard': + x = self.avgpool(x) + x = torch.flatten(x, 1) + # or equivalently + # x = x.view(x.size(0), -1) + elif self.classifier_str == 'cifar': + x = torch.flatten(x, 1) + x = self.classifier(x) + if self.classifier_str == 'ssd': + return conv4_3, x + else: + return x + + def _initialize_weights(self): + ''' + Random inizialization of the weights and bias coefficients of + the network + ''' + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, + mode='fan_out', + nonlinearity='relu') + if m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.BatchNorm2d): + nn.init.constant_(m.weight, 1) + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.Linear): + nn.init.normal_(m.weight, 0, 0.01) + nn.init.constant_(m.bias, 0) + + def load_pretrained_layers(self, cfg): + ''' + Loading pre-trained Layers. + If cfg is None and we are considering the standard version of VGG16, + the state of VGG16 pretrained on Imagenet will be loaded. See + https://pytorch.org/docs/stable/torchvision/models.html#torchvision.models.vgg16 + We can also load the state of VGG16 pretrained on other datasets by + giving in input a file containing the pretrained weights + (pretrain_weights). + If we are creating a custom version of this net with n_classes!=1000 the + classifier will be changed. + If cfg is None and we are condidering SSD300, we are converting fc6 + and fc7 into convolutional layers, and subsample by decimation. See + the original paper where SSD300 is implemented for further + details: 'SSD: Single Shot Multibox Detector' by + Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, + Scott Reed, Cheng-Yang Fu, Alexander C. Berg + https://arxiv.org/abs/1512.02325 + DOI: 10.1007/978-3-319-46448-0_2 + + :param list cfg: If None, returns the configuration of VGG16. Otherwise + a list of numbers and string 'M', representing all the layers of + the net (its configuration), where the numbers represent the number + of filters for that convolutional layers(i.e. the features + extraxted) and 'M' stands for the max pool layer + :return: state_dict, a dictionary containing the state of the net + :rtype: dict + ''' + # Current state of base + state_dict = self.state_dict() + param_names = list(state_dict.keys()) + + pretrained_net = torchvision.models.vgg16(pretrained=True) + pretrained_state_dict = pretrained_net.state_dict() + pretrained_param_names = list(pretrained_state_dict.keys()) + + + if cfg is None and (self.classifier_str == 'standard' + or self.classifier_str == 'cifar'): + if self.num_classes != 1000: + pretrained_net.classifier = self.classifier + pretrained_state_dict = pretrained_net.state_dict() + state_dict = pretrained_state_dict + + elif cfg is None and self.classifier_str == 'ssd': + # Transfer conv. parameters from pretrained model to current model + for i, param in enumerate( + param_names[:-4]): # excluding conv6 and conv7 parameters + state_dict[param] = pretrained_state_dict[ + pretrained_param_names[i]] + + # Convert fc6, fc7 to convolutional layers, and subsample + # (by decimation) to sizes of conv6 and conv7 + # fc6 + conv_fc6_weight = pretrained_state_dict['classifier.0.weight'].view( + 4096, 512, 7, 7) + conv_fc6_bias = pretrained_state_dict['classifier.0.bias'] # (4096) + state_dict['classifier.0.weight'] = decimate( + conv_fc6_weight, m=[4, None, 3, 3]) # (1024, 512, 3, 3) + state_dict['classifier.0.bias'] = decimate(conv_fc6_bias, + m=[4]) # (1024) + # fc7 + conv_fc7_weight = pretrained_state_dict['classifier.3.weight'].view( + 4096, 4096, 1, 1) + conv_fc7_bias = pretrained_state_dict['classifier.3.bias'] # (4096) + state_dict['classifier.1.weight'] = decimate( + conv_fc7_weight, m=[4, 4, None, None]) # (1024, 1024, 1, 1) + state_dict['classifier.1.bias'] = decimate(conv_fc7_bias, + m=[4]) # (1024) + + else: + raise RuntimeError( + 'Invalid choice for configuration and classifier in order\ + to use the pretrained model') + + self.load_state_dict(state_dict) + + print("\nLoaded base model.\n") + + return state_dict diff --git a/smithers/ml/tutorials/customdata_imagerec.ipynb b/smithers/ml/tutorials/customdata_imagerec.ipynb new file mode 100644 index 0000000..9a58977 --- /dev/null +++ b/smithers/ml/tutorials/customdata_imagerec.ipynb @@ -0,0 +1,288 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "mFsuXpUwQn80" + }, + "source": [ + "# Custom Dataset for image classification\n", + "In this tutorial, we will describe how to create and use a custom dataset for the aim of image classification, following https://www.kaggle.com/basu369victor/pytorch-tutorial-the-classification." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "S3D2nXrfRFEj" + }, + "source": [ + "## Custom dataset\n", + "First of all, you need to collect all the images you need to create the dataset (preferably ~1000 images per category) and define the different categories in exam.\n", + "At the end the directory ***dataset*** containing all your images should have a structure like this:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](images/structure_img.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "where each image has been placed inside the subdirectory class_i corresponding to the class it belongs to." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "ftu0AINGQ67c" + }, + "outputs": [], + "source": [ + "import os\n", + "import numpy as np # linear algebra\n", + "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n", + "from sklearn.preprocessing import LabelEncoder\n", + "import torch\n", + "from torch.utils.data.sampler import SubsetRandomSampler\n", + "import torchvision.transforms as transforms\n", + "\n", + "#define the device\n", + "device = torch.device('cpu')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 130 + }, + "id": "WVm1fmhQZarc", + "outputId": "201d08fd-65db-4627-9ca1-310727696bfd" + }, + "outputs": [], + "source": [ + "image = []\n", + "labels = []\n", + "#path to the directory containing your dataset\n", + "data_path = '../dataset_imagerec/'\n", + "for file in os.listdir(data_path):\n", + " if os.path.isdir(os.path.join(data_path, file)):\n", + " for img in os.listdir(os.path.join(data_path, file)):\n", + " image.append(img)\n", + " labels.append(file)\n", + "\n", + "# Creation of a csv Data-frasmithers.me from the raw dataset. You might not have to follow\n", + "# this step if you are already provided with csv file which contains the desired \n", + "# input and target value.\n", + "data = {'Images':image, 'labels':labels} \n", + "data = pd.DataFrame(data) \n", + "data.head()\n", + "\n", + "lb = LabelEncoder()\n", + "data['encoded_labels'] = lb.fit_transform(data['labels'])\n", + "data.head()\n", + "\n", + "# save the csv file inside the dataset directory \n", + "data.to_csv('../dataset_imagerec/dataframe.csv', index=False)\n", + "#in order to import the file run this command\n", + "#data = pd.read_csv('dataset_imagerec/dataframe.csv')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sY2TmApGdycf" + }, + "source": [ + "## Splitting of the dataset\n", + "The dataset needs to be split between the train and test process. Usually you will use 80% of all the images for the training phase and the remainig 20% for the testing phase.\n", + "\n", + "There are two ways to do this: one is to do it from scratch, the other one is by using ***train_test_split*** function ***from scikit-learn*** (recommended)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "q9IhpuJvdFuR" + }, + "outputs": [], + "source": [ + "batch_size = 128\n", + "validation_split = .2\n", + "shuffle_dataset = True\n", + "random_seed= 42\n", + "\n", + "dataset_size = len(data)\n", + "indices = list(range(dataset_size))\n", + "split = int(np.floor(validation_split * dataset_size))\n", + "if shuffle_dataset :\n", + " np.random.seed(random_seed)\n", + " np.random.shuffle(indices)\n", + "train_indices, val_indices = indices[split:], indices[:split]\n", + "\n", + "# Creating PT data samplers and loaders:\n", + "train_sampler = SubsetRandomSampler(train_indices)\n", + "test_sampler = SubsetRandomSampler(val_indices)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Images Preparation\n", + "After collecting the images, it is necessary to apply them some transformations in order to be used during the training and testing phases.\n", + "\n", + "- ***Transforms*** are common image transformations, that can be chained together using ***Compose***.\n", + "- You need to convert a PIL Image or numpy.ndarray to tensor using ***transforms.ToTensor()***. It converts a PIL Image or numpy.ndarray (H x W x C) in the range [0, 255] to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0] if the PIL Image belongs to one of the modes (L, LA, P, I, F, RGB, YCbCr, RGBA, CMYK, 1) or if the numpy.ndarray has dtype = np.uint8\n", + "- The tensor images should be ***normalized*** with mean and standard deviation. Given mean: (M1,...,Mn) and std: (S1,..,Sn) for n channels, the transformation ***transforms.Normalize*** will normalize each channel of the input torch.*Tensor i.e. input[channel] = (input[channel] - mean[channel]) / std[channel].\n", + "\n", + "Here you can find an example of transormation that can be applied to the images of your dataset. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "transform = transforms.Compose(\n", + " [transforms.ToTensor(),\n", + " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create custom dataset class\n", + "You now need to create a dataset class to be used as first argument in the function ***torch.utils.data.DataLoader()***.\n", + "\n", + "The skeleton of your custom dataset class has to be as the one in the cell below. It must contain the following functions to be used by data loader later on.\n", + "- ***__init__()*** function is where the initial logic happens like reading a csv, assigning transforms, filtering data, etc.\n", + "- ***__getitem__()*** function returns the data and labels. This function is called from dataloader like this:\n", + "\n", + " img, label = MyCustomDataset.***__getitem__***(99) # For 99th item" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data.dataset import Dataset\n", + "\n", + "class MyCustomDataset(Dataset):\n", + " def __init__(self, args):\n", + " # stuff\n", + " self.args = args\n", + " \n", + " def __getitem__(self, index):\n", + " # stuff\n", + " return (img, label)\n", + "\n", + " def __len__(self):\n", + " return count # of how many examples(images) you have" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An example of how you can create this custom dataset class is the following (see also ***dataset/imagerec_dataset.py***): " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data.dataset import Dataset\n", + "class Imagerec_Dataset(Dataset):\n", + " def __init__(self, img_data, img_path, transform=None):\n", + " self.img_path = img_path\n", + " self.img_data = img_data\n", + " self.transform = transform\n", + " \n", + " def __len__(self):\n", + " return len(self.img_data)\n", + " \n", + " def __getitem__(self, index):\n", + " img_name = os.path.join(self.img_path,self.img_data.loc[index, 'labels'],\n", + " self.img_data.loc[index, 'Images'])\n", + " image = Image.open(img_name)\n", + " #image = image.convert('RGB')\n", + " image = image.resize((300,300))\n", + " label = torch.tensor(self.img_data.loc[index, 'encoded_labels'])\n", + " if self.transform is not None:\n", + " image = self.transform(image)\n", + " else:\n", + " image = transforms.ToTensor()(image)\n", + " return image, label" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After defining the class for your custom dataset, you can create it and use it inside the function ***torch.utils.data.DataLoader()*** as described in the following part." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "dataset = Imagerec_Dataset(data, data_path, transform)\n", + "train_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, \n", + " sampler=train_sampler)\n", + "test_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,\n", + " sampler=test_sampler)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "colab": { + "name": "customdata_imagerec.ipynb", + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/smithers/ml/tutorials/customdata_objdet.ipynb b/smithers/ml/tutorials/customdata_objdet.ipynb new file mode 100644 index 0000000..2c3e6cc --- /dev/null +++ b/smithers/ml/tutorials/customdata_objdet.ipynb @@ -0,0 +1,476 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# How to prepare your own dataset for training an Object Detector\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Gathering data\n", + "First of all you need data. To train a robust classifier, we need a lot of pictures which should differ a lot from each other. So they should have different backgrounds, random object, and varying lighting conditions. You can either take the pictures yourself or you can download them from the internet. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Structure of the Dataset folder - Pascal VOC notation\n", + "In order to train an object detector using our own dataset, we need to construct an internal structure for the folder that contains our images ('./data'). In order to generate this we follow the Pascal VOC notation. Pascal VOC annotations are saved as XML files, one XML file per image. Each XML file contains the path to the image in the 'path' element, the bounding box stored in an 'object' element and other features as can be seen in the example below.\n", + "\n", + "\n", + "\n", + "As you can see the bounding box is defined by two points, the upper left and bottom right corners.\n", + "\n", + "We need to construct inside the main folder 'data' another subfolder 'VOC2007', that contains three subfolders:\n", + "1. Annotations: Inside this folder we will put the Pascal VOC formatted annotation XML files, that we are going to generate below using LabelImg.\n", + "2. ImageSets: Inside this folder there is another subfolder 'Main', that contains two files 'test.txt' and 'trainval.txt'. In these two files all the images that belong to that category are listed.\n", + "3. JPEGImages: Here there are all the images, that has to be in the JPG format.\n", + "\n", + "At the end your dataset should have a structure like this:\n", + "\n", + "![](images/structure.PNG)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Labeling Data\n", + "In order to label our data, the image labeling software LabelImg was used. It is available on Github https://github.com/tzutalin/labelImg and thanks to this tool we can create easily the xml files with a similar structure to the PASCAL VOC dataset for all images in the training and testing directory.\n", + "### Instruction to install labelImg\n", + "1. git clone https://github.com/tzutalin/labelImg\n", + "2. conda install pyqt=5\n", + "3. pyrcc5 -o libs/resources.py resources.qrc\n", + "4. python labelImg.py\n", + "### Steps\n", + "1. Build and launch LabelImg using the instructions above\n", + "2. In the left column choose the saved annotation (Pascal VOC / Yolo). Make sure Pascal VOC is selected.\n", + "3. Click 'Open Dir' to open the directory that contains all your images (the folder should be found following this path \"./data/VOCdevkit/VOC2007/ImageSets\")\n", + "4. Change save directory for the XML annotation files to \"./data/VOCdevkit/VOC2007/Annotations\".\n", + "5. Click 'Create RectBox' \n", + "6. Click and release left mouse to select a region to annotate the rect box\n", + "7. You can use right mouse to drag the rect box to copy or move it\n", + "\n", + "\n", + "A txt file with the different classes used in the labeling is also created and placed in the folders you are working on. \n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Transform image resolution\n", + "Usually the images you collect will have different sizes and high resolution, since you can take them using different \n", + "photographic equipment: a mobilephone, a webcam, a reflex camera, etc. Thus, it is needed to transform all the images to a lower scale (the same for all the pictures) in order to speed up the training (e.g. 200 x 150 can be an option, but it is important to check, while changing the resolution, that you are able to distinguish and recognize the objects in the picture, otherwise it will be difficult also for the CNN to learn the main features of your objects). " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from PIL import Image\n", + "import os\n", + "\n", + "def rescale_images(directory, size):\n", + " for img in os.listdir(directory):\n", + " im = Image.open(directory + '/' + img)\n", + " im_resized = im.resize(size, Image.ANTIALIAS)\n", + " im_resized.save(directory + '/' + img)\n", + " \n", + "path_images = '../data_lab/VOC2007/JPEGImages'\n", + "WIDTH_NEW = 800\n", + "HEIGHT_NEW = 600\n", + "rescale_images(path_images, (WIDTH_NEW, HEIGHT_NEW)) " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Split of the dataset\n", + "Once we have our images, we need to split them between those we use for the train, 80% of them, and those for the test, the remaining 20%. First of all we need to create a txt file, 'datafile.txt', that contains the name of all the images in our dataset. Then, using the function sklearn.model_selection.train_test_split we can make this split of the dataset and create the two txt files to place inside the folder 'ImageSets/Main', one with the train images and one with the test images." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy\n", + "from sklearn import datasets, linear_model\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "train_file = '../data_lab/VOC2007/ImageSets/Main/trainval.txt'\n", + "test_file = '../data_lab/VOC2007/ImageSets/Main/test.txt'\n", + "with open(\"../data_lab/datafile.txt\", \"r\") as f:\n", + " # in Windows you may need to put rb instead of r mode \n", + " data = f.read().split('\\n')\n", + " data = numpy.array(data) #convert array to numpy type array\n", + "\n", + " train, test = train_test_split(data,test_size=0.2) \n", + " split = [train, test] \n", + " # the ouputs here are two lists containing train-test split of inputs.\n", + " lengths = [len(train), len(test)]\n", + " out_train = open(train_file,\"w\")\n", + " out_test = open(test_file, \"w\")\n", + " out_file = [out_train, out_test]\n", + " out = 0\n", + " for l in lengths:\n", + " for i in range(l):\n", + " name_img = split[out][i]\n", + " out_file[out].write(name_img + '\\n')\n", + " out_file[out].close() \n", + " out += 1\n", + " \n", + " \n", + "# Split into a training set and a test set using a stratified k fold\n", + "# split into a training and testing set\n", + "# y here the label associated\n", + "#X_train, X_test, y_train, y_test = train_test_split(\n", + "# X, y, test_size=0.25, random_state=42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Change xml file\n", + "Once we have labeled and created all the xml files for our images, we could want to change the resolution of our images as explained above. In order to change the xml file every time we transform image resolution, it is necessary to define a function that modify only the lines corresponding at the features of the images we are changing (i.e. the width and height, the box position and also the path where they are located)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "from sys import argv\n", + "from os import listdir, path\n", + "import re\n", + "\n", + "\n", + "WIDTH_NEW = 800\n", + "HEIGHT_NEW = 600\n", + "\n", + "DIMLINE_MASK = r'<(?Pwidth|height)>(?P\\d+)width|height)>'\n", + "BBLINE_MASK = r'<(?Pxmin|xmax|ymin|ymax)>(?P\\d+)xmin|xmax|ymin|ymax)>'\n", + "NAMELINE_MASK = r'<(?Pfilename)>(?P\\S+)filename)>'\n", + "PATHLINE_MASK = r'<(?Ppath)>(?P.+)path)>'\n", + "#regular expression\n", + "\n", + "def resize_file(file_lines):\n", + " new_lines = []\n", + " for line in file_lines:\n", + " match = re.search(DIMLINE_MASK, line) or re.search(BBLINE_MASK, line) or re.search(NAMELINE_MASK, line) or re.search(PATHLINE_MASK, line) \n", + " if match is not None:\n", + " size = match.group('size')\n", + " type1 = match.group('type1')\n", + " type2 = match.group('type2') \n", + " if type1 != type2:\n", + " raise ValueError('Malformed line: {}'.format(line))\n", + " \n", + " if type1.startswith('f'):\n", + " new_name = size[:-3] + 'jpg'\n", + " new_line = '\\t<{}>{}\\n'.format(type1, new_name, type1)\n", + " elif type1.startswith('p'):\n", + " new_size = '/scratch/lmeneghe/electrolux/Object_Detector/data_lab/VOC2007/Annotations/' + new_name\n", + " new_line = '\\t<{}>{}\\n'.format(type1, new_size, type1)\n", + " elif type1.startswith('x'):\n", + " size = int(size)\n", + " new_size = int(round(size * WIDTH_NEW / width_old))\n", + " new_line = '\\t\\t\\t<{}>{}\\n'.format(type1, new_size, type1)\n", + " elif type1.startswith('y'):\n", + " size = int(size)\n", + " new_size = int(round(size * HEIGHT_NEW / height_old))\n", + " new_line = '\\t\\t\\t<{}>{}\\n'.format(type1, new_size, type1)\n", + " elif type1.startswith('w'):\n", + " size = int(size)\n", + " width_old = size\n", + " new_size = int(WIDTH_NEW)\n", + " new_line = '\\t\\t<{}>{}\\n'.format(type1, new_size, type1)\n", + " elif type1.startswith('h'):\n", + " size = int(size)\n", + " height_old = size\n", + " new_size = int(HEIGHT_NEW)\n", + " new_line = '\\t\\t<{}>{}\\n'.format(type1, new_size, type1)\n", + " else:\n", + " raise ValueError('Unknown type: {}'.format(type1))\n", + " #new_line = '\\t\\t\\t<{}>{}\\n'.format(type1, new_size, type1)\n", + " new_lines.append(new_line)\n", + " else:\n", + " new_lines.append(line)\n", + "\n", + " return ''.join(new_lines)\n", + "\n", + "\n", + " \n", + " \n", + "def change_xml(nome_file):\n", + " if len(nome_file) < 1:\n", + " raise ValueError('No file submitted')\n", + "\n", + " if path.isdir(nome_file):\n", + " # the argument is a directory\n", + " files = listdir(nome_file)\n", + " for file in files:\n", + " file_path = path.join(nome_file, file)\n", + " file_name, file_ext = path.splitext(file)\n", + " #print(file_path, end='') # Questo non e` tanto astuto\n", + " if file_ext.lower() == '.xml':\n", + " #print(': CONVERTIMIIII!!!', end='')\n", + " with open(file_path,'r') as f:\n", + " righe = f.readlines()\n", + "\n", + " nuovo_file = resize_file(righe)\n", + " #print(nuovo_file)\n", + " with open(file_path,'w') as f:\n", + " f.write(nuovo_file)\n", + " #print()\n", + " \n", + " else:\n", + " # otherwise i have a file (hopefully)\n", + " with open(nome_file,'r') as f:\n", + " righe = f.readlines()\n", + "\n", + " nuovo_file = resize_file(righe)\n", + " #print(nuovo_file)\n", + " with open(nome_file,'w') as f:\n", + " f.write(nuovo_file) \n", + "\n", + "#insert name of the xml file or directory that contains them\n", + "xml_file = '../data_lab/VOC2007/Annotations' \n", + "change_xml(xml_file)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Optional: How to convert your dataset in the COCO notation\n", + "You are out of luck if your object detection training pipeline require COCO data format since the labeling tool we use does not support COCO annotation format. If you already have the dataset generated using Pascal VOC notation, you can then convert your annotation to COCO format.\n", + "### COCO notation\n", + "For the COCO data format, first of all, there is only a single JSON file for all the annotation in a dataset or one for each split of datasets(Train/Val/Test). The bounding box is express as the upper left starting coordinate and the box width and height, like \"bbox\" :[x,y,width,height]. Here is an example for the COCO data format JSON file which just contains one image as seen the top-level “images” element, 3 unique categories/classes in total seen in top-level “categories” element and 2 annotated bounding boxes for the image seen in top-level “annotations” element. If you want to understand better the COCO format, check the official webpage of the COCO dataset: http://cocodataset.org/#format-data.\n", + "\n", + "\n", + "\n", + "Once you have some annotated XML and images files with a folder structure similar to the one explained above, you can generate a COCO data formatted JSON file using the function voc2coco (see also https://github.com/Tony607/voc2coco).\n", + "\n", + "ATTENTION: In order to use this function the name of all the images must be numbers. So you need to rename all the images if this is not true." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of xml files: 14\n", + "Success: ./images/output.json\n" + ] + } + ], + "source": [ + "import sys\n", + "import os\n", + "import json\n", + "import xml.etree.ElementTree as ET\n", + "import glob\n", + "\n", + "START_BOUNDING_BOX_ID = 1\n", + "PRE_DEFINE_CATEGORIES = None\n", + "# If necessary, pre-define category and its id\n", + "# PRE_DEFINE_CATEGORIES = {\"aeroplane\": 1, \"bicycle\": 2, \"bird\": 3, \"boat\": 4,\n", + "# \"bottle\":5, \"bus\": 6, \"car\": 7, \"cat\": 8, \"chair\": 9,\n", + "# \"cow\": 10, \"diningtable\": 11, \"dog\": 12, \"horse\": 13,\n", + "# \"motorbike\": 14, \"person\": 15, \"pottedplant\": 16,\n", + "# \"sheep\": 17, \"sofa\": 18, \"train\": 19, \"tvmonitor\": 20}\n", + "\n", + "\n", + "def get(root, name):\n", + " vars = root.findall(name)\n", + " return vars\n", + "\n", + "\n", + "def get_and_check(root, name, length):\n", + " vars = root.findall(name)\n", + " if len(vars) == 0:\n", + " raise ValueError(\"Can not find %s in %s.\" % (name, root.tag))\n", + " if length > 0 and len(vars) != length:\n", + " raise ValueError(\n", + " \"The size of %s is supposed to be %d, but is %d.\"\n", + " % (name, length, len(vars))\n", + " )\n", + " if length == 1:\n", + " vars = vars[0]\n", + " return vars\n", + "\n", + "\n", + "def get_filename_as_int(filename):\n", + " try:\n", + " filename = filename.replace(\"\\\\\", \"/\")\n", + " filename = os.path.splitext(os.path.basename(filename))[0]\n", + " return int(filename)\n", + " except:\n", + " raise ValueError(\"Filename %s is supposed to be an integer.\" % (filename))\n", + "\n", + "\n", + "def get_categories(xml_files):\n", + " \"\"\"Generate category name to id mapping from a list of xml files.\n", + " \n", + " Arguments:\n", + " xml_files {list} -- A list of xml file paths.\n", + " \n", + " Returns:\n", + " dict -- category name to id mapping.\n", + " \"\"\"\n", + " classes_names = []\n", + " for xml_file in xml_files:\n", + " tree = ET.parse(xml_file)\n", + " root = tree.getroot()\n", + " for member in root.findall(\"object\"):\n", + " classes_names.append(member[0].text)\n", + " classes_names = list(set(classes_names))\n", + " classes_names.sort()\n", + " return {name: i for i, name in enumerate(classes_names)}\n", + "\n", + "\n", + "def convert(xml_files, json_file):\n", + " json_dict = {\"images\": [], \"type\": \"instances\", \"annotations\": [], \"categories\": []}\n", + " if PRE_DEFINE_CATEGORIES is not None:\n", + " categories = PRE_DEFINE_CATEGORIES\n", + " else:\n", + " categories = get_categories(xml_files)\n", + " bnd_id = START_BOUNDING_BOX_ID\n", + " for xml_file in xml_files:\n", + " tree = ET.parse(xml_file)\n", + " root = tree.getroot()\n", + " path = get(root, \"path\")\n", + " if len(path) == 1:\n", + " filename = os.path.basename(path[0].text)\n", + " elif len(path) == 0:\n", + " filename = get_and_check(root, \"filename\", 1).text\n", + " else:\n", + " raise ValueError(\"%d paths found in %s\" % (len(path), xml_file))\n", + " ## The filename must be a number\n", + " image_id = get_filename_as_int(filename)\n", + " size = get_and_check(root, \"size\", 1)\n", + " width = int(get_and_check(size, \"width\", 1).text)\n", + " height = int(get_and_check(size, \"height\", 1).text)\n", + " image = {\n", + " \"file_name\": filename,\n", + " \"height\": height,\n", + " \"width\": width,\n", + " \"id\": image_id,\n", + " }\n", + " json_dict[\"images\"].append(image)\n", + " ## Currently we do not support segmentation.\n", + " # segmented = get_and_check(root, 'segmented', 1).text\n", + " # assert segmented == '0'\n", + " for obj in get(root, \"object\"):\n", + " category = get_and_check(obj, \"name\", 1).text\n", + " if category not in categories:\n", + " new_id = len(categories)\n", + " categories[category] = new_id\n", + " category_id = categories[category]\n", + " bndbox = get_and_check(obj, \"bndbox\", 1)\n", + " xmin = int(get_and_check(bndbox, \"xmin\", 1).text) - 1\n", + " ymin = int(get_and_check(bndbox, \"ymin\", 1).text) - 1\n", + " xmax = int(get_and_check(bndbox, \"xmax\", 1).text)\n", + " ymax = int(get_and_check(bndbox, \"ymax\", 1).text)\n", + " assert xmax > xmin\n", + " assert ymax > ymin\n", + " o_width = abs(xmax - xmin)\n", + " o_height = abs(ymax - ymin)\n", + " ann = {\n", + " \"area\": o_width * o_height,\n", + " \"iscrowd\": 0,\n", + " \"image_id\": image_id,\n", + " \"bbox\": [xmin, ymin, o_width, o_height],\n", + " \"category_id\": category_id,\n", + " \"id\": bnd_id,\n", + " \"ignore\": 0,\n", + " \"segmentation\": [],\n", + " }\n", + " json_dict[\"annotations\"].append(ann)\n", + " bnd_id = bnd_id + 1\n", + "\n", + " for cate, cid in categories.items():\n", + " cat = {\"supercategory\": \"none\", \"id\": cid, \"name\": cate}\n", + " json_dict[\"categories\"].append(cat)\n", + "\n", + " #os.makedirs(os.path.dirname(json_file), exist_ok=True)\n", + " json_fp = open(json_file, \"w\")\n", + " json_str = json.dumps(json_dict)\n", + " json_fp.write(json_str)\n", + " json_fp.close()\n", + "\n", + "\n", + "xml_dir = './data/Annotations'\n", + "json_file = './data/output.json'\n", + "xml_files = glob.glob(os.path.join(xml_dir, \"*.xml\"))\n", + "# If you want to do train/test split, you can pass a subset of xml files to convert function.\n", + "print(\"Number of xml files: {}\".format(len(xml_files)))\n", + "convert(xml_files, json_file)\n", + "print(\"Success: {}\".format(json_file))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the COCO annotation\n", + "Once we have the JSON file, we can visualize the COCO annotation by drawing bounding box and class labels as an overlay over the image. Open the COCO_Image_Viewer.ipynb in Jupyter notebook, that can be found on the GitHub page https://github.com/Tony607/voc2coco. \n", + "http://cocodataset.org/#format-data" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "vscode": { + "interpreter": { + "hash": "8c5bf16c94eb6f9341fa612a12f652937166e39821fa969ec7095b77ab48ffd1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/smithers/ml/tutorials/images/coco.PNG b/smithers/ml/tutorials/images/coco.PNG new file mode 100644 index 0000000..f6616c3 Binary files /dev/null and b/smithers/ml/tutorials/images/coco.PNG differ diff --git a/smithers/ml/tutorials/images/labelimg.jpg b/smithers/ml/tutorials/images/labelimg.jpg new file mode 100644 index 0000000..6589533 Binary files /dev/null and b/smithers/ml/tutorials/images/labelimg.jpg differ diff --git a/smithers/ml/tutorials/images/pascalvoc.PNG b/smithers/ml/tutorials/images/pascalvoc.PNG new file mode 100644 index 0000000..866f2ec Binary files /dev/null and b/smithers/ml/tutorials/images/pascalvoc.PNG differ diff --git a/smithers/ml/tutorials/images/red_cnn.png b/smithers/ml/tutorials/images/red_cnn.png new file mode 100644 index 0000000..8d8be71 Binary files /dev/null and b/smithers/ml/tutorials/images/red_cnn.png differ diff --git a/smithers/ml/tutorials/images/red_objdet.png b/smithers/ml/tutorials/images/red_objdet.png new file mode 100644 index 0000000..efd043d Binary files /dev/null and b/smithers/ml/tutorials/images/red_objdet.png differ diff --git a/smithers/ml/tutorials/images/structure.PNG b/smithers/ml/tutorials/images/structure.PNG new file mode 100644 index 0000000..e6de9df Binary files /dev/null and b/smithers/ml/tutorials/images/structure.PNG differ diff --git a/smithers/ml/tutorials/images/structure_img.png b/smithers/ml/tutorials/images/structure_img.png new file mode 100644 index 0000000..dba166c Binary files /dev/null and b/smithers/ml/tutorials/images/structure_img.png differ diff --git a/smithers/ml/tutorials/pascalvoc_preparation.ipynb b/smithers/ml/tutorials/pascalvoc_preparation.ipynb new file mode 100644 index 0000000..680833a --- /dev/null +++ b/smithers/ml/tutorials/pascalvoc_preparation.ipynb @@ -0,0 +1,320 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# How to prepare PascalVOC Dataset to train an object detector" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gathering Data\n", + "The PascalVOC Dataset used is composed of two different datasets from the years 2007 and 2012: VOC2007 and VOC2012. First of all you need to download the datasets from the official webpages:\n", + "1. VOC2007: from http://host.robots.ox.ac.uk/pascal/VOC/voc2007/index.html#devkit select ''Download the training/validation data (450MB tar file)'' in the Development Kit section and ''Download the annotated test data (430MB tar file)'' in the Test Data section.\n", + "2. VOC2012: from http://host.robots.ox.ac.uk/pascal/VOC/voc2012/index.html select ''Download the training/validation data (2GB tar file)'' in the Development Kit section.\n", + "\n", + "\n", + "The two trainval datasets, downloaded from the Development Kit section, are to be used for training, while the VOC 2007 test, the one taken from the Test Data section, will serve as test dataset.\n", + "\n", + "ATTENTION: Both the VOC2007 trainval and VOC2007 test data has to be extracted in the same location, e.g. download the datasets and then merge them." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Structure of the Dataset folder - Pascal VOC \n", + "Once you have downloaded the aforementioned datasets, you should place them in the same folder. Hence, inside the main folder 'VOCdevkit'there should be two subfolders 'VOC2007' and 'VOC2012', where each of them contains five subfolders: \n", + "1. Annotations: Inside this folder there are the PascalVOC formatted annotation XML files, that contain relevant information for the picture under examination. Hence, there is one XML file per image. Each XML file contains the path to the image in the 'path' element, the bounding box stored in an 'object' element and other features as can be seen in the example below. You can note that the bounding box is defined by two points, the upper left and bottom right corners.\n", + "\n", + "\n", + "\n", + "2. ImageSets: Inside this folder there are three subfolders: 'Layout', 'Main' and 'Segmentation'. In particular in the subfolder 'Main' you can find the images of a specific class that belong to the test, train or trainval subdivision.\n", + "3. JPEGImages: Here there are all the images, that has to be in the JPG format.\n", + "4. and 5. SegmentationClass and SegmentationObject: folders containing the segmentation masks for some images and objects.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data pipeline\n", + "Once you have the correct structure of the dataset, you should divide data into training and test splits. Data should also be saved in JSON files in order to be used inside the PyTorch Dataset class that will be created later for this purpose.\n", + "\n", + "### Parse raw data - Creation JSON files & splitting of the dataset\n", + "Run (and see for more details) the create_json.py script you can find in the dataset folder. When running it, you need to provide the paths to the VOC2007 and VOC2012 folders, as well as to the desired output folder where the JSON files should be saved.\n", + "\n", + "This script parses the data downloaded and returns as output the following files:\n", + "1. A JSON file for each split (Train or Test) with a list of the absolute filepaths for each image in that split.\n", + "2. A JSON file for each split (train or Test) with a list of dictionaries containing ground truth objects, i.e. bounding boxes in absolute boundary coordinates, their encoded labels, and perceived detection difficulties for each image in that split. Therefore, The i-th dictionary in this list will contain the objects present in the i-th image of the split.\n", + "3. A JSON file which contains the label_map, the label-to-index dictionary with which the labels are encoded in the previous JSON file. This dictionary is also available in the script (create_json.py) and directly importable.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/scratch/lmeneghe/Smithers/smithers/ml/VOCdevkit/VOC2007\n", + "/scratch/lmeneghe/Smithers/smithers/ml/VOCdevkit/VOC2007\n", + "/scratch/lmeneghe/Smithers/smithers/ml/VOCdevkit/VOC2012\n", + "\n", + "There are 16551 training images containing a total of 49653 objects. Files have been saved to /scratch/lmeneghe/Smithers/smithers/ml/tutorials.\n", + "\n", + "There are 4952 test images containing a total of 14856 objects. Files have been saved to /scratch/lmeneghe/Smithers/smithers/ml/tutorials.\n" + ] + } + ], + "source": [ + "# %run ../dataset/create_json.py path_to_VOC2007dir path_to_VOC2012dir path_to_outputfolder\n", + "%run ../dataset/create_json.py ../VOCdevkit/VOC2007/ ../VOCdevkit/VOC2012/ ./" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining a PascalVOCDataset class\n", + "\n", + "In order to use the constructed dataset properly, we need to define a subclass of PyTorch Dataset, called PascaVOCDataset. For more details about the implementation see pascalvoc_dataset.py in the dataset folder.\n", + "\n", + "\n", + "The PascalVOCdataset class has been defined to detect your training and test datasets from the JSON files created above. It needs a __len__ method defined, which returns the size of the dataset, and a __getitem__ method which returns the i-th image, bounding boxes of the objects in this image, and labels for the objects in this image, using the JSON files we saved earlier.\n", + "\n", + "You will notice that it also returns the perceived detection difficulties of each of these objects, but these are not actually used in training the model. They are required only in the Evaluation stage for computing the Mean Average Precision (mAP) metric. We also have the option of filtering out difficult objects entirely from our data to speed up training at the cost of some accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, '/scratch/lmeneghe/Smithers/')\n", + "from smithers.ml.dataset.pascalvoc_dataset import PascalVOCDataset\n", + "\n", + "keep_difficult = True\n", + "\n", + "# data_folder corresponds to the output folder defined before, where the JSON files have been saved\n", + "data_folder = './'\n", + "#data_folder = '/u/s/szanin/Smithers/smithers/ml/tutorials/'\n", + "# Load train data\n", + "train_dataset = PascalVOCDataset(data_folder,\n", + " split='train',\n", + " keep_difficult=keep_difficult)\n", + "\n", + "# Load test data\n", + "test_dataset = PascalVOCDataset(data_folder,\n", + " split='test',\n", + " keep_difficult=keep_difficult)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extract smaller datasets\n", + "If you want to test your model against a smaller dataset than PascalVOC, you can exctract a set of images from the original PascalVOC using ***sample_dataset.py*** in the dataset folder.\n", + "\n", + "You can thus extract a dataset composed of N images divided in M classes, where N and M are less than the total number of images and classes composing the dataset under consideration. For example, we can create a dataset composed of 300 images of cats and dogs." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "%run ../dataset/sample_dataset.py" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now have to split the subdataset in the train dataset (e.g. 80% of the total) and the test dataset (e.g. the remaining 20%). To do so we use the same procedure found in the splitting section of the tutorial ***customdata_objdet***.\n", + "\n", + "We first create the directories and files needed.\n", + "\n", + "Below, after the first ``cd`` command, insert the path to the folder created using the previous cell, in my case this is\n", + "``/u/s/szanin/Smithers/smithers/ml/tutorials/VOC_dog_cat/``." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "( \n", + " cd VOC_dog_cat/;\n", + " touch datafile.txt;\n", + " mkdir JSONfiles\n", + " mkdir ImageSets;\n", + " cd ImageSets;\n", + " mkdir Main;\n", + " cd Main;\n", + " touch trainval.txt;\n", + " touch test.txt\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we populate the datafile.txt file with the names of the images we sampled.\n", + "\n", + "Beware that:\n", + "- in the ``datafiletxt_path`` variable you need to insert the string containing the path to your datafile.txt file we have just created;\n", + "- in the ``jpeg_path`` variable you need to insert the string containing the path to your JPEGImages folder of the reduced dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "datafiletxt_path = 'VOC_dog_cat/datafile.txt'\n", + "jpeg_path = 'VOC_dog_cat/JPEGImages/'\n", + "\n", + "# If you are using Python < 3.9 you need this function to remove the \n", + "# suffix jpg, otherwise you can uncomment the lines using the\n", + "# removesuffix function\n", + "def remove_suffix(input_string, suffix):\n", + " if suffix and input_string.endswith(suffix):\n", + " return input_string[:-len(suffix)]\n", + " return input_string\n", + "\n", + "with open(datafiletxt_path, 'w') as datafile:\n", + " dir_list = os.listdir(jpeg_path)\n", + " num_files = len(dir_list)\n", + " for element in dir_list[:-1]:\n", + " datafile.write('{}\\n'.format(remove_suffix(element, '.jpg')))\n", + " #datafile.write('{}\\n'.format(element.removesuffix('.jpg')))\n", + " datafile.write('{}'.format(remove_suffix(dir_list[-1],'.jpg')))\n", + " #datafile.write('{}'.format(dir_list[-1].removesuffix('.jpg'))) # the last element added does not need the new line characters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell will construct the .json files relative to the smaller dataset sampled.\n", + "\n", + "Beware that in the variables ``train_file``and ``test_file`` you need to insert your own paths as follows:\n", + "- in ``train_file`` insert the string containing the path of your trainval.txt file we created above;\n", + "- in ``test_file`` insert the string containing the path of your test.txt file we created above;" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy\n", + "from sklearn import datasets, linear_model\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "train_file = 'VOC_dog_cat/ImageSets/Main/trainval.txt'\n", + "test_file = 'VOC_dog_cat/ImageSets/Main/test.txt'\n", + "\n", + "with open(datafiletxt_path,'r') as f:\n", + " # in Windows you may need to put rb instead of r mode \n", + " data = f.read().split('\\n')\n", + " data = numpy.array(data) #convert array to numpy type array\n", + "\n", + " train ,test = train_test_split(data,test_size=0.2) \n", + " split = [train, test] \n", + " # the ouputs here are two lists containing train-test split of inputs.\n", + " lengths = [len(train), len(test)]\n", + " out_train = open(train_file,\"w\")\n", + " out_test = open(test_file, \"w\")\n", + " out_file = [out_train, out_test]\n", + " out = 0\n", + " for l in lengths:\n", + " for i in range(l):\n", + " name_img = split[out][i]\n", + " out_file[out].write(name_img + '\\n')\n", + " out_file[out].close() \n", + " out += 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will now create the .json files relative to this datasets and save them in the folder JSONfiles, inside VOC_dog_cat." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/scratch/lmeneghe/Smithers/smithers/ml/tutorials/VOC_dog_cat\n", + "/scratch/lmeneghe/Smithers/smithers/ml/tutorials/VOC_dog_cat\n", + "\n", + "There are 240 training images containing a total of 720 objects. Files have been saved to /scratch/lmeneghe/Smithers/smithers/ml/tutorials/VOC_dog_cat/JSONfiles.\n", + "\n", + "There are 60 test images containing a total of 180 objects. Files have been saved to /scratch/lmeneghe/Smithers/smithers/ml/tutorials/VOC_dog_cat/JSONfiles.\n" + ] + } + ], + "source": [ + "%run ../dataset/create_json.py ./VOC_dog_cat/ None ./VOC_dog_cat/JSONfiles" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "vscode": { + "interpreter": { + "hash": "8c5bf16c94eb6f9341fa612a12f652937166e39821fa969ec7095b77ab48ffd1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/smithers/ml/tutorials/pytorch_to_tensorflow.ipynb b/smithers/ml/tutorials/pytorch_to_tensorflow.ipynb new file mode 100644 index 0000000..ca14225 --- /dev/null +++ b/smithers/ml/tutorials/pytorch_to_tensorflow.ipynb @@ -0,0 +1,312 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "JCxgG6QoZ7qZ" + }, + "source": [ + "## How to convert a model from PyTorch to Tensorflow \n", + "In this tutorial, we will describe how to go from PyTorch to Tensorflow using ONNX, an open ecosystem for interoperable AI models (https://github.com/onnx) Thus, following the tutorials on https://github.com/onnx/tutorials we will convert our model from PyTorch to ONNX and then from ONNX to Tensorflow." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5RRClxtos8EV" + }, + "source": [ + "## **Installations**\n", + "First of all, we need to install ONNX and Tensorflow and the necessary packages.\n", + "\n", + "**To install ONNX:**\n", + "\n", + "> conda install -c conda-forge protobuf numpy \\\n", + "pip install onnx\n", + "\n", + "**To install Tensorflow:**\n", + "\n", + "> pip install tensorflow-cpu \\\n", + "(pip install tensorflow if you need also support for CUDA-enabled GPU cards)\n", + "\n", + "Next **install onnx-tensorflow** by the following commands:\n", + "\n", + "> git clone https://github.com/onnx/onnx-tensorflow.git \n", + "cd onnx-tensorflow \\\n", + "pip install -e .\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sK4wBKUsvyf-" + }, + "source": [ + "## PyTorch Model\n", + "Starting from the model you have defined in PyTorch, you need to train and test it. After this, you should save the state of your net in a file, that will be used for the conversion." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "ClsqK3ObxDMv" + }, + "outputs": [], + "source": [ + "# PyTorch Model\n", + "pytorch_model = Net() \n", + "# Train and test the model\n", + "...\n", + "# Save the trained model to a file\n", + "torch.save(pytorch_model.state_dict(), 'net_pytorch.pth')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xu5VaFvaxnRv" + }, + "source": [ + "## Export the trained model to ONNX\n", + "In order to export the model, Pytorch exporter needs to run the model once and save this resulting traced model to a ONNX file. Therefore, we need to provide an input (a random tensor with the right shape) for our model. \n", + "\n", + "In our case we consider a net that takes as inputs RGB images with shape (1, 3, 32, 32.)\n", + "\n", + "ACHTUNG: If in your net there are average pooling layers (**AdaptiveAvgPool2d()**) (e.g. in the standard VGG), pay attention that this is not supported by ONNX. Thus you need to add the following flag in **torch.onnx.export()**\n", + "> operator_export_type=torch.onnx.OperatorExportTypes.ONNX_ATEN_FALLBACK" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "h4sV1FyHxtba" + }, + "outputs": [], + "source": [ + "# Load the network\n", + "net_pytorch = Net()\n", + "net_pytorch.load_state_dict(torch.load('net_pytorch.pth'))\n", + "\n", + "# Export the trained model to ONNX\n", + "dummy_input = torch.rand(torch.randn(1, 3, 32, 32)) # random input for the model\n", + "torch.onnx.export(net_pytorch, dummy_input, \"net_onnx.onnx\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ttSacDddrLc-" + }, + "source": [ + "For a graph version of the onnx file you can use a ONNX viewer called Netron: https://github.com/lutzroeder/Netron." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lmGyuqSOrdJY" + }, + "source": [ + "## Import the ONNX model to Tensorflow\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 368 + }, + "id": "iSGl9I2Wrv-Y", + "outputId": "010b7444-0d43-4fb9-ea80-d10ddd343c38" + }, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "ignored", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0monnx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0monnx_tf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mprepare\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# Load the ONNX file\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mmodel_onnx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0monnx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'net_onnx.onnx'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'onnx'", + "", + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0;32m\nNOTE: If your import is failing due to a missing package, you can\nmanually install dependencies using either !pip or !apt.\n\nTo view examples of installing some common dependencies, click the\n\"Open Examples\" button below.\n\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n" + ] + } + ], + "source": [ + "import onnx\n", + "from onnx_tf.backend import prepare\n", + "\n", + "# Load the ONNX file\n", + "model_onnx = onnx.load('net_onnx.onnx')\n", + "\n", + "# Import the ONNX model to Tensorflow\n", + "tf_rep = prepare(model_onnx)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OZmElsMAr_Al" + }, + "source": [ + "In order to understand if we are converting correctly the model, we can explore the *tf_rep* object return from *onnx.tf.backend.prepare*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "F6fpSvFAr9wP" + }, + "outputs": [], + "source": [ + "# Input nodes to the model\n", + "print('inputs:', tf_rep.inputs)\n", + "\n", + "# Output nodes from the model\n", + "print('outputs:', tf_rep.outputs)\n", + "\n", + "# All nodes in the model\n", + "print('tensor_dict:')\n", + "print(tf_rep.tensor_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BC-DBBrfsPbz" + }, + "source": [ + "## Run the model in Tensorflow\n", + "After converting the model to Tensorflow, we can run it by taking an image with the right shape and format for our net." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "8TzPK5nbsTHl" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from IPython.display import display\n", + "from PIL import Image\n", + "\n", + "print('Image 1:')\n", + "img = Image.open('image.png').resize((32, 32))\n", + "array_img = np.array(img, dtype=np.float32)\n", + "print(array_img.shape)\n", + "array_img = array_img.reshape(1, 3, 32, 32)\n", + "print(array_img.shape)\n", + "output = tf_rep.run(array_img)\n", + "\n", + "\n", + "print('The image is classified as ', np.argmax(output))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "x24zhUP2u7Bk" + }, + "source": [ + "## Save the Tensorflow model into a file" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "k_rNJHmDu8Hk" + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'tf_rep' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtf_rep\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexport_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'net_tf.pb'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'tf_rep' is not defined" + ] + } + ], + "source": [ + "tf_rep.export_graph('net_tf.pb')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conversion into Tensorflow Lite\n", + "Conversion of the Tensorflow model to Tensorflow Lite. There exists some operations that are not supported in Tensorflow and also that are not present in Tensorflow Lite. You can find a complete lists of them at the following link:\n", + "https://www.tensorflow.org/lite/guide/ops_compatibility.\n", + "In order to overcome this difficulty (if you do not have restrictions on your running environment) you can uncomment some of the lines below to complet the conversion. You can read something more, also on how to include then these operations in your environment, here:\n", + "https://www.tensorflow.org/lite/guide/ops_select" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "converter = tf.lite.TFLiteConverter.from_saved_model('net_tf.pb')\n", + "# If some unsupported operations by Tensorflow are present, uncomment those lines.\n", + "#converter.target_spec.supported_ops = [\n", + "# tf.lite.OpsSet.TFLITE_BUILTINS, # enable TensorFlow Lite ops.\n", + "# tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.\n", + "#]\n", + "\n", + "tflite_model = converter.convert()\n", + "\n", + "# Save the model.\n", + "with open('net.tflite', 'wb') as f:\n", + " f.write(tflite_model)\n" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "colab": { + "collapsed_sections": [], + "name": "pytorch_to_tensorflow.ipynb", + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/smithers/ml/tutorials/reduction_SSD.ipynb b/smithers/ml/tutorials/reduction_SSD.ipynb new file mode 100644 index 0000000..d5b61d5 --- /dev/null +++ b/smithers/ml/tutorials/reduction_SSD.ipynb @@ -0,0 +1,829 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dimensionality Reduction of SSD300\n", + "\n", + "In this tutorial we will present how to create a reduced version of SSD300 using the techniques described in the article :\n", + "\n", + "L. Meneghetti, N. Demo and G. Rozza, \"A Proper Orthogonal Decomposition Approach for Parameters Reduction of Single Shot Detector Networks,\" 2022 IEEE International Conference on Image Processing (ICIP), 2022, pp. 2206-2210, doi: 10.1109/ICIP46576.2022.9897513.\n", + "\n", + "and in the paper ''Deep neural network compression via tensor decomposition'' by S. Zanin, L. Meneghetti, N. Demo and G. Rozza, that is currently in preparation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports\n", + "We start by importing all the necessary functions." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, '/scratch/lmeneghe/Smithers/')\n", + "import torch\n", + "from PIL import Image\n", + "from time import time\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import torchvision.transforms as transforms\n", + "from torch.utils import data\n", + "\n", + "\n", + "from smithers.ml.models.vgg import VGG\n", + "from smithers.ml.models.aux_conv import AuxiliaryConvolutions\n", + "from smithers.ml.models.predictor import PredictionConvolutions\n", + "from smithers.ml.dataset.pascalvoc_dataset import PascalVOCDataset\n", + "from smithers.ml.models.detector import Detector, Reduced_Detector\n", + "from smithers.ml.models.utils_objdet import create_prior_boxes, save_checkpoint_objdet\n", + "from smithers.ml.models.netadapter import NetAdapter\n", + "from smithers.ml.models.utils_rednet import get_seq_model, Total_param, Total_flops\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameters Initialization\n", + "We set the parameters used for the data, the detector and the learning phase." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "# Learning parameters\n", + "batch_size = 8 # batch size\n", + "workers = 4 # number of workers for loading data in the DataLoader\n", + "iterations = 120000 # number of iterations to train\n", + "print_freq = 200 # print training status every __ batches\n", + "lr = 1e-4 # learning rate\n", + "decay_lr_at = [80000, 100000] # decay learning rate after these many iterations\n", + "decay_lr_to = 0.1\n", + "# decay learning rate to this fraction of the existing learning rate\n", + "#n_classes = 6\n", + "momentum = 0.9 # momentum\n", + "weight_decay = 5e-4 # weight decay\n", + "grad_clip = None\n", + "# clip if gradients are exploding, which may happen at larger batch sizes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading of the dataset\n", + "In order to train and test our model we can use a benchmark dataset, such as PascalVOC, or a custom one. We are now going to describe our method employing a set of data extracted from PascalVOC, composed of images of only cats and dogs, but everything can be easily generalized ot the other cases. For more details on the preparation of such datsets and their use see the tutorials ***pascalvoc_preparation*** and ***customdata_objdet***.\n", + "\n", + "### Cats & Dogs Dataset\n", + "We use as training and testing dataset the cats and dogs dataset, composed of 300 images extracted from PascalVOC." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "categories: {'cat': 1, 'dog': 2, 'background': 0}\n", + "n_classes: 3\n", + "Training images: 240\n", + "Testing images: 60\n" + ] + } + ], + "source": [ + "# Data parameters\n", + "\n", + "voc_labels = ('cat', 'dog')\n", + "# Labels of the whole PascalVOC\n", + "#voc_labels = ('aeroplane', 'bicycle', 'bird', 'boat',\n", + "# 'bottle', 'bus', 'car', 'cat', 'chair',\n", + "# 'cow', 'diningtable', 'dog', 'horse',\n", + "# 'motorbike', 'person', 'pottedplant',\n", + "# 'sheep', 'sofa', 'train', 'tvmonitor')\n", + "label_map = {k: v + 1 for v, k in enumerate(voc_labels)}\n", + "label_map['background'] = 0\n", + "n_classes = len(label_map)\n", + "print('categories:',label_map)\n", + "print('n_classes:', n_classes)\n", + "\n", + "data_folder = 'VOC_dog_cat/JSONfiles' #folder with json data files\n", + "keep_difficult = True\n", + "\n", + "\n", + "train_dataset = PascalVOCDataset(data_folder,\n", + " split='train',\n", + " keep_difficult=keep_difficult)\n", + "train_loader = torch.utils.data.DataLoader(\n", + " train_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=True,\n", + " collate_fn=train_dataset.collate_fn,\n", + " num_workers=workers,\n", + " pin_memory=True)\n", + "\n", + "epochs = iterations // (len(train_dataset) // 32)\n", + "decay_lr_at = [it // (len(train_dataset) // 32) for it in decay_lr_at]\n", + "print('Training images:', len(train_dataset))\n", + "# Load test data\n", + "test_dataset = PascalVOCDataset(data_folder,\n", + " split='test',\n", + " keep_difficult=keep_difficult)\n", + "test_loader = torch.utils.data.DataLoader(test_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=False,\n", + " collate_fn=test_dataset.collate_fn,\n", + " num_workers=workers,\n", + " pin_memory=True)\n", + "print('Testing images:', len(test_dataset))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading of the model\n", + "First of all we need to load the full model we want to reduce (in this case SSD300) starting from a checkpoint file, i.e. a file containing the status of the model after a training process with a chosen dataset.\n", + "\n", + "In order to obtain a checkpoint file, the tutorial ***training_SSD*** can be followed." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Evaluating: 100%|██████████| 8/8 [00:03<00:00, 2.56it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'cat': 71.44593596458435, 'dog': 50.61103105545044}\n", + "{'cat': 71.44593596458435, 'dog': 50.61103105545044}\n", + "\n", + "Mean Average Precision (mAP): 61.028\n" + ] + }, + { + "data": { + "text/plain": [ + "61.028480529785156" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network = None\n", + "check = 'checkpoint_objdet.pth.tar'\n", + "priors_cxcy = create_prior_boxes()\n", + "detector = Detector(network, check, priors_cxcy, n_classes, epochs,\n", + " batch_size, print_freq, lr, decay_lr_at,\n", + " decay_lr_to, momentum, weight_decay, grad_clip,\n", + " train_loader, test_loader, 'Adam')\n", + "detector.eval_detector(label_map)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Memory Footprint full network" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SSD300-storage\n", + " VGG = 78.14, Aux model nnz=9.38, feature_loc nnz=2.0395, feature_cl nnz=1.5296\n", + "The total amount of space required is 91.091 MB.\n" + ] + } + ], + "source": [ + "ssd_storage = torch.zeros(4)\n", + "\n", + "ssd_storage[0], ssd_storage[1], ssd_storage[2], ssd_storage[3] = [\n", + " Total_param(detector.model[0]),\n", + " Total_param(detector.model[1].features),\n", + " Total_param(detector.model[2].features_loc),\n", + " Total_param(detector.model[2].features_cl)]\n", + "\n", + "\n", + "print('SSD300-storage')\n", + "print(\n", + " ' VGG = {:.2f}, Aux model nnz={:.2f}, feature_loc nnz={:.4f}, feature_cl nnz={:.4f}'.format(\n", + " ssd_storage[0], ssd_storage[1],\n", + " ssd_storage[2], ssd_storage[3]))\n", + "print('The total amount of space required is {:.3f} MB.'.format(ssd_storage[0]+ssd_storage[1]+ssd_storage[2]+ssd_storage[3]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reduction of SSD300\n", + "We now perform the reduction of SSD300 using the module ***NetAdapter*** to construct the pre-model and the reduction layer. Then, we construct the reduced version of the detector using hte class ***Detector*** as for the original model. The Figure below summarizes the reduction method proposed, as described in the article by L. Meneghetti, N. Demo and G. Rozza, \"A Proper Orthogonal Decomposition Approach for Parameters Reduction of Single Shot Detector Networks,\" 2022 IEEE International Conference on Image Processing (ICIP), 2022, pp. 2206-2210, doi: 10.1109/ICIP46576.2022.9897513.\n", + "\n", + "\n", + "\n", + "Hence, we are going to describe two different methods for the reduction layer: POD and HOSVD, where the latter differ from the other for its tensorial approach. The input-outpu mapping, in this case, is not changed with respect to the original SSD300 and thus corresponds to two siblings predictors, one for classification and one for localization.\n", + "\n", + "It is important to highlight that in order to reduce the model we are not starting from the model loaded before, i.e. from the status of the model after the training phase, but from its status only after initialization." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Proper Orthogonal Decomposition (POD)\n", + "The first method we propose to reduce the network is POD." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Loaded base model.\n", + "\n", + "RedNet(\n", + " (premodel): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU(inplace=True)\n", + " (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU(inplace=True)\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (6): ReLU(inplace=True)\n", + " (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (8): ReLU(inplace=True)\n", + " (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (11): ReLU(inplace=True)\n", + " (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (13): ReLU(inplace=True)\n", + " (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (15): ReLU(inplace=True)\n", + " (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " )\n", + " (proj_model): Linear(in_features=369664, out_features=50, bias=False)\n", + " (inout_map): Identity()\n", + ")\n", + "Time needed to initialize the model 5.08997368812561\n" + ] + } + ], + "source": [ + "checkpoint = None\n", + "init_time = time()\n", + "\n", + "base_net = VGG(classifier='ssd', init_weights='imagenet')\n", + "seq_model = get_seq_model(base_net)\n", + "cutoff_idx = 7\n", + "red_dim = 50\n", + "red_method = 'POD'\n", + "inout_method = None\n", + "netadapter = NetAdapter(cutoff_idx, red_dim, red_method, inout_method)\n", + "red_model = netadapter.reduce_net(seq_model, train_dataset, None, train_loader, n_classes)\n", + "print(red_model)\n", + "\n", + "base_net = red_model.premodel\n", + "aux_conv = red_model.proj_model\n", + "\n", + "# we need to modify the configuration of the predictor layers\n", + "cfg_tot = [256, red_dim]\n", + "n_boxes = [4, 6]\n", + "predictor = PredictionConvolutions(n_classes, cfg_tot, n_boxes)\n", + "network = [base_net, aux_conv, predictor]\n", + "\n", + "#create prior boxes custom for reduced net\n", + "fmaps_dims = {'premodel': 38, 'projmodel': 1} \n", + "obj_scales = {'premodel': 0.1, 'projmodel': 0.725} #0.9\n", + "aspect_ratio = {'premodel': [1., 2., 0.5], 'projmodel': [1., 2., 3., 0.5, 0.333]}\n", + "priors_cxcy = create_prior_boxes(fmaps_dims, obj_scales, aspect_ratio)\n", + "\n", + "init_end = time()\n", + "print('Time needed to initialize the model', init_end - init_time)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training Phase\n", + "Once we have defined the several pieces composing our reduced version of the detector (pre_model instead of full vgg, reduction layers instead of auxiliary layers, and the same predictor), we can train it." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: [0][0/30]\tBatch Time 0.435 (0.435)\tData Time 0.254 (0.254)\tLoss val (average) 3.4185 (3.4185)\t\n", + "Epoch: [1][0/30]\tBatch Time 0.386 (0.386)\tData Time 0.262 (0.262)\tLoss val (average) 4.0896 (4.0896)\t\n", + "Epoch: [2][0/30]\tBatch Time 0.369 (0.369)\tData Time 0.235 (0.235)\tLoss val (average) 3.8647 (3.8647)\t\n", + "Epoch: [3][0/30]\tBatch Time 0.403 (0.403)\tData Time 0.278 (0.278)\tLoss val (average) 2.3701 (2.3701)\t\n", + "Epoch: [4][0/30]\tBatch Time 0.430 (0.430)\tData Time 0.304 (0.304)\tLoss val (average) 3.9224 (3.9224)\t\n", + "Epoch: [5][0/30]\tBatch Time 0.363 (0.363)\tData Time 0.231 (0.231)\tLoss val (average) 3.1703 (3.1703)\t\n", + "Epoch: [6][0/30]\tBatch Time 0.399 (0.399)\tData Time 0.270 (0.270)\tLoss val (average) 3.5857 (3.5857)\t\n", + "Epoch: [7][0/30]\tBatch Time 0.384 (0.384)\tData Time 0.246 (0.246)\tLoss val (average) 4.0032 (4.0032)\t\n", + "Epoch: [8][0/30]\tBatch Time 0.392 (0.392)\tData Time 0.254 (0.254)\tLoss val (average) 3.6775 (3.6775)\t\n", + "Epoch: [9][0/30]\tBatch Time 0.292 (0.292)\tData Time 0.162 (0.162)\tLoss val (average) 3.5110 (3.5110)\t\n", + "Time needed for training: 41.57 seconds, i.e. 0.7 minutes\n" + ] + } + ], + "source": [ + "check = None\n", + "epochs = 10\n", + "start = time()\n", + "red_detector = Reduced_Detector(network, check, priors_cxcy, n_classes, epochs,\n", + " batch_size, print_freq, lr, decay_lr_at,\n", + " decay_lr_to, momentum, weight_decay, grad_clip,\n", + " train_loader, test_loader, 'Adam', red_method)\n", + "\n", + "start = time()\n", + "check, loss_value = red_detector.train_detector()\n", + "end = time()\n", + "print(f'Time needed for training: {round(end-start,2)} seconds, i.e. {round((end-start)/60,1)} minutes')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Accuracy of the reduced detector\n", + "We can now test the accurcay of the reduced detector against the testing dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Evaluating: 100%|██████████| 8/8 [00:12<00:00, 1.51s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'cat': 38.69142532348633, 'dog': 38.271987438201904}\n", + "{'cat': 38.69142532348633, 'dog': 38.271987438201904}\n", + "\n", + "Mean Average Precision (mAP): 38.482\n", + "Time needed for testing: 12.32 seconds, i.e. 0.2 minutes\n" + ] + } + ], + "source": [ + "start_test = time()\n", + "red_detector.eval_detector(label_map)\n", + "end_test = time()\n", + "print(f'Time needed for testing: {round(end_test-start_test,2)} seconds, i.e. {round((end_test-start_test)/60,1)} minutes')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Image Detection\n", + "By choosing a specific image from the directory used, the network is able to detect the object(s) in it and save a version of the image in which the bounding box(es) with the relative label(s) is(/are) pictured. To view this, open the file ``out.jpg``, as described below." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "img_path = 'VOC_dog_cat/JPEGImages/001825.jpg'\n", + "original_image = Image.open(img_path, mode='r')\n", + "original_image = original_image.convert('RGB')\n", + "\n", + "red_detector.detect(original_image,\n", + " label_map,\n", + " min_score=0.01,\n", + " max_overlap=0.45,\n", + " top_k=1).show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "out_img = Image.open('out.jpg')\n", + "display(out_img)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Memory Footprint reduced detector\n", + "We can print the storage needed to store our reduced detector. It can be highlight that, With respect to the full network, the space is slightly decreased, hence this type of reduction could be not the most suitable one for this kind of problems." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SSD300 reduced-storage\n", + " Pre-model = 6.62, Reduction Layer nnz=70.51, feature_loc nnz=0.1820, feature_cl nnz=0.1365\n", + "The total amount of space required is 77.447 MB.\n" + ] + } + ], + "source": [ + "rednet_storage = torch.zeros(4)\n", + "\n", + "rednet_storage[0], rednet_storage[1], rednet_storage[2], rednet_storage[3] = [\n", + " Total_param(red_detector.model[0]),\n", + " Total_param(red_detector.model[1]),\n", + " Total_param(red_detector.model[2].features_loc),\n", + " Total_param(red_detector.model[2].features_cl)]\n", + "\n", + "print('SSD300 reduced-storage')\n", + "print(\n", + " ' Pre-model = {:.2f}, Reduction Layer nnz={:.2f}, feature_loc nnz={:.4f}, feature_cl nnz={:.4f}'.format(\n", + " rednet_storage[0], rednet_storage[1],\n", + " rednet_storage[2], rednet_storage[3]))\n", + "space_rednet = (rednet_storage[0]+rednet_storage[1]+rednet_storage[2]+rednet_storage[3]).item()\n", + "print('The total amount of space required is {:.3f} MB.'.format(space_rednet))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Averaged HOSVD (AHOSVD)\n", + "We can now carry out the same reduction performed for 'POD' using 'AHOSVD'." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Loaded base model.\n", + "\n", + "RedNet(\n", + " (premodel): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU(inplace=True)\n", + " (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU(inplace=True)\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (6): ReLU(inplace=True)\n", + " (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (8): ReLU(inplace=True)\n", + " (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (11): ReLU(inplace=True)\n", + " (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (13): ReLU(inplace=True)\n", + " (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (15): ReLU(inplace=True)\n", + " (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " )\n", + " (proj_model): tensor_product_layer(in_dimensions=[256, 38, 38], out_dimensions=[35, 3, 3])\n", + " (inout_map): Identity()\n", + ")\n", + "time needed to initialize the model 10.65 seconds\n" + ] + } + ], + "source": [ + "init_time = time()\n", + "\n", + "base_net = VGG(classifier='ssd', init_weights='imagenet')\n", + "seq_model = get_seq_model(base_net)\n", + "cutoff_idx = 7\n", + "red_method = 'HOSVD'\n", + "red_dim = [35, 3, 3]\n", + "inout_method = None\n", + "netadapter = NetAdapter(cutoff_idx, red_dim, red_method, inout_method)\n", + "red_model = netadapter.reduce_net(seq_model, train_dataset, None, train_loader, n_classes)\n", + "base_net = red_model.premodel\n", + "aux_conv = red_model.proj_model\n", + "print(red_model)\n", + "\n", + "# change configuration predictor layers\n", + "#cfg_tot = [n of channels of the outputs of the pre model, n of the reduced channels]\n", + "cfg_tot = list(reversed(list(red_model.proj_model.list_of_matrices[0].shape)))\n", + "n_boxes = [4, 6]\n", + "predictor = PredictionConvolutions(n_classes, cfg_tot, n_boxes)\n", + "network = [base_net, aux_conv, predictor]\n", + "\n", + "#create prior boxes custom for reduced net\n", + "reduction_dims = list(reversed(list(red_model.proj_model.list_of_matrices[1].shape)))\n", + "#fmaps_dims = {'premodel': width=height of the output of the pre model, 'projmodel': width=height of the reduced tensors}\n", + "fmaps_dims = {'premodel': reduction_dims[0], 'projmodel': reduction_dims[1]}\n", + "obj_scales = {'premodel': 0.1, 'projmodel': 0.725} \n", + "aspect_ratio = {'premodel': [1., 2., 0.5], 'projmodel': [1., 2., 3., 0.5, 0.333]}\n", + "priors_cxcy = create_prior_boxes(fmaps_dims, obj_scales, aspect_ratio)\n", + "init_end = time()\n", + "print('time needed to initialize the model', round(init_end - init_time,2), 'seconds')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training Phase\n", + "Once we have defined the several pieces composing our reduced version of the detector (pre_model instead of full vgg, reduction layers instead of auxiliary layers, and the same predictor), we can train it." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: [0][0/30]\tBatch Time 0.409 (0.409)\tData Time 0.247 (0.247)\tLoss val (average) 5.2885 (5.2885)\t\n", + "Epoch: [1][0/30]\tBatch Time 0.511 (0.511)\tData Time 0.395 (0.395)\tLoss val (average) 5.3623 (5.3623)\t\n", + "Epoch: [2][0/30]\tBatch Time 0.282 (0.282)\tData Time 0.164 (0.164)\tLoss val (average) 5.3762 (5.3762)\t\n", + "Epoch: [3][0/30]\tBatch Time 0.332 (0.332)\tData Time 0.213 (0.213)\tLoss val (average) 5.4769 (5.4769)\t\n", + "Epoch: [4][0/30]\tBatch Time 0.389 (0.389)\tData Time 0.271 (0.271)\tLoss val (average) 5.0611 (5.0611)\t\n", + "Epoch: [5][0/30]\tBatch Time 0.429 (0.429)\tData Time 0.311 (0.311)\tLoss val (average) 5.0190 (5.0190)\t\n", + "Epoch: [6][0/30]\tBatch Time 0.324 (0.324)\tData Time 0.203 (0.203)\tLoss val (average) 5.1396 (5.1396)\t\n", + "Epoch: [7][0/30]\tBatch Time 0.402 (0.402)\tData Time 0.283 (0.283)\tLoss val (average) 5.6913 (5.6913)\t\n", + "Epoch: [8][0/30]\tBatch Time 0.355 (0.355)\tData Time 0.236 (0.236)\tLoss val (average) 5.3226 (5.3226)\t\n", + "Epoch: [9][0/30]\tBatch Time 0.358 (0.358)\tData Time 0.239 (0.239)\tLoss val (average) 4.8955 (4.8955)\t\n", + "Epoch: [10][0/30]\tBatch Time 0.313 (0.313)\tData Time 0.191 (0.191)\tLoss val (average) 4.8290 (4.8290)\t\n", + "Epoch: [11][0/30]\tBatch Time 0.470 (0.470)\tData Time 0.351 (0.351)\tLoss val (average) 4.5696 (4.5696)\t\n", + "Epoch: [12][0/30]\tBatch Time 0.448 (0.448)\tData Time 0.329 (0.329)\tLoss val (average) 4.4618 (4.4618)\t\n", + "Epoch: [13][0/30]\tBatch Time 0.394 (0.394)\tData Time 0.273 (0.273)\tLoss val (average) 5.5949 (5.5949)\t\n", + "Epoch: [14][0/30]\tBatch Time 0.429 (0.429)\tData Time 0.309 (0.309)\tLoss val (average) 4.1911 (4.1911)\t\n", + "Epoch: [15][0/30]\tBatch Time 0.321 (0.321)\tData Time 0.200 (0.200)\tLoss val (average) 4.2410 (4.2410)\t\n", + "Epoch: [16][0/30]\tBatch Time 0.322 (0.322)\tData Time 0.200 (0.200)\tLoss val (average) 4.9888 (4.9888)\t\n", + "Epoch: [17][0/30]\tBatch Time 0.359 (0.359)\tData Time 0.236 (0.236)\tLoss val (average) 4.2695 (4.2695)\t\n", + "Epoch: [18][0/30]\tBatch Time 0.350 (0.350)\tData Time 0.225 (0.225)\tLoss val (average) 4.6492 (4.6492)\t\n", + "Epoch: [19][0/30]\tBatch Time 0.360 (0.360)\tData Time 0.236 (0.236)\tLoss val (average) 4.5057 (4.5057)\t\n", + "Epoch: [20][0/30]\tBatch Time 0.350 (0.350)\tData Time 0.228 (0.228)\tLoss val (average) 4.4015 (4.4015)\t\n", + "Epoch: [21][0/30]\tBatch Time 0.358 (0.358)\tData Time 0.234 (0.234)\tLoss val (average) 4.7579 (4.7579)\t\n", + "Epoch: [22][0/30]\tBatch Time 0.396 (0.396)\tData Time 0.275 (0.275)\tLoss val (average) 4.8101 (4.8101)\t\n", + "Epoch: [23][0/30]\tBatch Time 0.453 (0.453)\tData Time 0.332 (0.332)\tLoss val (average) 4.3113 (4.3113)\t\n", + "Epoch: [24][0/30]\tBatch Time 0.364 (0.364)\tData Time 0.243 (0.243)\tLoss val (average) 4.3516 (4.3516)\t\n", + "Epoch: [25][0/30]\tBatch Time 0.359 (0.359)\tData Time 0.236 (0.236)\tLoss val (average) 4.4434 (4.4434)\t\n", + "Epoch: [26][0/30]\tBatch Time 0.398 (0.398)\tData Time 0.278 (0.278)\tLoss val (average) 4.3724 (4.3724)\t\n", + "Epoch: [27][0/30]\tBatch Time 0.383 (0.383)\tData Time 0.261 (0.261)\tLoss val (average) 4.6017 (4.6017)\t\n", + "Epoch: [28][0/30]\tBatch Time 0.402 (0.402)\tData Time 0.280 (0.280)\tLoss val (average) 4.2785 (4.2785)\t\n", + "Epoch: [29][0/30]\tBatch Time 0.428 (0.428)\tData Time 0.308 (0.308)\tLoss val (average) 4.5009 (4.5009)\t\n", + "Epoch: [30][0/30]\tBatch Time 0.477 (0.477)\tData Time 0.354 (0.354)\tLoss val (average) 3.9579 (3.9579)\t\n", + "Epoch: [31][0/30]\tBatch Time 0.360 (0.360)\tData Time 0.239 (0.239)\tLoss val (average) 3.9041 (3.9041)\t\n", + "Epoch: [32][0/30]\tBatch Time 0.393 (0.393)\tData Time 0.263 (0.263)\tLoss val (average) 3.8265 (3.8265)\t\n", + "Epoch: [33][0/30]\tBatch Time 0.315 (0.315)\tData Time 0.192 (0.192)\tLoss val (average) 3.7582 (3.7582)\t\n", + "Epoch: [34][0/30]\tBatch Time 0.371 (0.371)\tData Time 0.249 (0.249)\tLoss val (average) 4.0377 (4.0377)\t\n", + "Epoch: [35][0/30]\tBatch Time 0.405 (0.405)\tData Time 0.285 (0.285)\tLoss val (average) 4.1851 (4.1851)\t\n", + "Epoch: [36][0/30]\tBatch Time 0.316 (0.316)\tData Time 0.191 (0.191)\tLoss val (average) 3.7542 (3.7542)\t\n", + "Epoch: [37][0/30]\tBatch Time 0.389 (0.389)\tData Time 0.267 (0.267)\tLoss val (average) 4.3031 (4.3031)\t\n", + "Epoch: [38][0/30]\tBatch Time 0.285 (0.285)\tData Time 0.162 (0.162)\tLoss val (average) 3.9916 (3.9916)\t\n", + "Epoch: [39][0/30]\tBatch Time 0.427 (0.427)\tData Time 0.306 (0.306)\tLoss val (average) 3.8861 (3.8861)\t\n", + "Time needed for training: 157.3 seconds, i.e. 2.6 minutes\n" + ] + } + ], + "source": [ + "check = None\n", + "epochs = 40\n", + "start = time()\n", + "red_detector = Reduced_Detector(network, check, priors_cxcy, n_classes, epochs,\n", + " batch_size, print_freq, lr, decay_lr_at,\n", + " decay_lr_to, momentum, weight_decay, grad_clip,\n", + " train_loader, test_loader, 'Adam', red_method)\n", + "\n", + "start = time()\n", + "check, loss_value = red_detector.train_detector()\n", + "end = time()\n", + "print(f'Time needed for training: {round(end-start,2)} seconds, i.e. {round((end-start)/60,1)} minutes')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Accuracy of the reduced detector\n", + "We can now test the accurcay of the reduced detector against the testing dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Evaluating: 100%|██████████| 8/8 [00:11<00:00, 1.48s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'cat': 34.66533422470093, 'dog': 23.27975034713745}\n", + "{'cat': 34.66533422470093, 'dog': 23.27975034713745}\n", + "\n", + "Mean Average Precision (mAP): 28.973\n", + "Time needed for testing: 12.08 seconds, i.e. 0.2 minutes\n" + ] + } + ], + "source": [ + "start_test = time()\n", + "red_detector.eval_detector(label_map)\n", + "end_test = time()\n", + "print(f'Time needed for testing: {round(end_test-start_test,2)} seconds, i.e. {round((end_test-start_test)/60,1)} minutes')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Image Detection\n", + "By choosing a specific image from the directory used, the network is able to detect the object(s) in it and save a version of the image in which the bounding box(es) with the relative label(s) is(/are) pictured. To view this, open the file ``out.jpg``, as described below." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "img_path = 'VOC_dog_cat/JPEGImages/001825.jpg'\n", + "original_image = Image.open(img_path, mode='r')\n", + "original_image = original_image.convert('RGB')\n", + "\n", + "red_detector.detect(original_image,\n", + " label_map,\n", + " min_score=0.01,\n", + " max_overlap=0.45,\n", + " top_k=1).show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "out_img = Image.open('out.jpg')\n", + "display(out_img)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Memory Footprint reduced detector\n", + "It can be noted that the space required by the reduced detector obtained using AHOSV is decreased with respect to the one obetined with POD and with the full network. The use of the tensorial approach is hence more useful in this kind of problems." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SSD300 reduced-storage\n", + " Pre-model = 6.62, Reduction Layer nnz=0.04, feature_loc nnz=0.1696, feature_cl nnz=0.1272\n", + "The total amount of space required is 6.952 MB.\n" + ] + } + ], + "source": [ + "rednet_storage = torch.zeros(4)\n", + "\n", + "rednet_storage[0], rednet_storage[1], rednet_storage[2], rednet_storage[3] = [\n", + " Total_param(red_detector.model[0]),\n", + " Total_param(red_detector.model[1]),\n", + " Total_param(red_detector.model[2].features_loc),\n", + " Total_param(red_detector.model[2].features_cl)]\n", + "\n", + "print('SSD300 reduced-storage')\n", + "print(\n", + " ' Pre-model = {:.2f}, Reduction Layer nnz={:.2f}, feature_loc nnz={:.4f}, feature_cl nnz={:.4f}'.format(\n", + " rednet_storage[0], rednet_storage[1],\n", + " rednet_storage[2], rednet_storage[3]))\n", + "space_rednet = (rednet_storage[0]+rednet_storage[1]+rednet_storage[2]+rednet_storage[3]).item()\n", + "print('The total amount of space required is {:.3f} MB.'.format(space_rednet))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "vscode": { + "interpreter": { + "hash": "8c5bf16c94eb6f9341fa612a12f652937166e39821fa969ec7095b77ab48ffd1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/smithers/ml/tutorials/reduction_VGG16.ipynb b/smithers/ml/tutorials/reduction_VGG16.ipynb new file mode 100644 index 0000000..07e5e2f --- /dev/null +++ b/smithers/ml/tutorials/reduction_VGG16.ipynb @@ -0,0 +1,610 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dimensionality Reduction of VGG16\n", + "In this tutorial we will present how to create a reduced version of VGG16 using the techniques described in the article \n", + "\n", + "''A Dimensionality Reduction Approach for Convolutional Neural Networks'', Meneghetti L., Demo N., Rozza G., https://arxiv.org/abs/2110.09163 (2021).\n", + "\n", + "and in the paper ''Deep neural network compression via tensor decomposition'' by S. Zanin, L. Meneghetti, N. Demo and G. Rozza, that is currently in preparation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports\n", + "We start by importing all the necessary libraries and functions." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, '/scratch/lmeneghe/Smithers/')\n", + "import os\n", + "import torch\n", + "import numpy as np\n", + "import torchvision\n", + "from torch import nn\n", + "\n", + "import torchvision.transforms as transforms\n", + "import torchvision.datasets as datasets\n", + "import pandas as pd\n", + "import torch.optim as optim\n", + "\n", + "from smithers.ml.models.vgg import VGG\n", + "from smithers.ml.models.utils_rednet import get_seq_model, Total_param, Total_flops, compute_loss, train_kd\n", + "from smithers.ml.models.netadapter import NetAdapter\n", + "\n", + "\n", + "import warnings" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setting the proper device\n", + "The following lines will detect if a gpu is available in the system running this tutorial. If that is the case, all the objects of the following tutorial will be allocated in the gpu, thus speeding up the training process." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cuda has been detected as the device which the script will be run on.\n" + ] + } + ], + "source": [ + "if torch.cuda.is_available():\n", + " device = torch.device('cuda')\n", + "else:\n", + " device = torch.device('cpu')\n", + "print(f\"{device} has been detected as the device which the script will be run on.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading of the dataset\n", + "### CIFAR10 Dataset\n", + "We use the CIFAR10 dataset (already implemented in PyTorch) to test our technique. It is a computer-vision dataset used for object recognition. It consists of 60000 32 × 32 colour images divided in 10 non-overlapping classes: airplane, automobile, bird, cat, deer, dog, frog, horse, ship, and truck.\n", + "\n", + "See https://www.cs.toronto.edu/~kriz/cifar.html for more details on this dataset and on how to download it." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files already downloaded and verified\n", + "Files already downloaded and verified\n" + ] + } + ], + "source": [ + "batch_size = 8 \n", + "data_path = '../cifar/' \n", + "# transform functions: take in input a PIL image and apply this\n", + "# transformations\n", + "transform_train = transforms.Compose([\n", + " transforms.RandomCrop(32, padding=4),\n", + " transforms.RandomHorizontalFlip(),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n", + "])\n", + "\n", + "transform_test = transforms.Compose([\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n", + "])\n", + "train_dataset = datasets.CIFAR10(root=data_path + 'CIFAR10/',\n", + " train=True,\n", + " download=True,\n", + " transform=transform_train)\n", + "train_loader = torch.utils.data.DataLoader(train_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=True)\n", + "test_dataset = datasets.CIFAR10(root=data_path + 'CIFAR10/',\n", + " train=False,\n", + " download=True,\n", + " transform=transform_test)\n", + "test_loader = torch.utils.data.DataLoader(test_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=True)\n", + "train_labels = torch.tensor(train_loader.dataset.targets)\n", + "targets = list(train_labels)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Custom dataset\n", + "If we want to use a custom dataset, we need firstly to construct it, following for example the tutorial on the construction of a custom dataset for the problem of Image Recognition (***customdata_imagerec***). " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading of the model\n", + "First of all we need to load the model we want to use (in this case VGG16) starting from a checkpoint file, i.e. a file containing the status of the model after a training process with a chosen dataset. Here we will use the CIFAR10 dataset, but everythong can be also generalized for a custom dataset or another benchmark dataset.\n", + "\n", + "It is important to highlight that the models of VGG-nets implemented in PyTorch (https://pytorch.org/hub/pytorch_vision_vgg/), e.g. \n", + "```\n", + "model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', pretrained=True),\n", + "```\n", + "\n", + "are models pre-trained on the ImageNet dataset, that consists of images of dimensions 224x224. Therefore, in order to use datasets like the CIFAR10, composed of images 32x32, we need to change the architecture of VGG-nets, as was done in the file ***smithers/ml/vgg.py***.\n", + "\n", + "In order to obtain a checkpoint file, the tutorial ***training_VGG16*** can be followed." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# pretrained = insert here the proper path for your device\n", + "pretrained = 'check_vgg.pth'\n", + "VGGnet = torch.load(pretrained)\n", + "seq_model = get_seq_model(VGGnet).to(device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reduction of VGG16\n", + "We now perform the reduction of VGG16 using the module ***NetAdapter***. For the reduced method and the input-output mapping there are multiple choices: 'POD', 'AS', 'RandSVD' or 'HOSVD' for the first one, and 'PCE' or 'FNN' for the latter. We are now going to provide some examples of possible combinations of the aforementioned techniques. The Figure below summarizes the reduction method proposed, as described in the article ''A Dimensionality Reduction Approach for Convolutional Neural Networks'', Meneghetti L., Demo N., Rozza G., https://arxiv.org/abs/2110.09163 (2021).\n", + "\n", + "\n", + "\n", + "NOTE: To use the Active Subspace as reduction method, the Python package ATHENA should be downloaded from https://github.com/mathLab/ATHENA.\n", + "\n", + "\n", + "Let's start by computing the current accuracy of the network." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of the full network on test images is 87.5100\n" + ] + } + ], + "source": [ + "total = 0\n", + "correct = 0\n", + "seq_model.eval()\n", + "for test, y_test in iter(test_loader):\n", + "#Calculate the class probabilities (softmax) for img\n", + " with torch.no_grad():\n", + " output = seq_model(test.to(device)).to(device)\n", + " ps = torch.exp(output)\n", + " _, predicted = torch.max(output.data,1)\n", + " total += y_test.size(0)\n", + " correct += (predicted == y_test.to(device)).sum().item()\n", + " \n", + "print(\"Accuracy of the full network on test images is {:.4f}\".format(100*correct/total))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## POD + FNN\n", + "The first method we describe uses POD as reduction technique and a Feedforward Neural Network (FNN) as input-output mapping." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "cutoff_idx = 7 \n", + "red_dim = 50 \n", + "red_method = 'POD' \n", + "inout_method = 'FNN'\n", + "n_class = 10\n", + "netadapter = NetAdapter(cutoff_idx, red_dim, red_method, inout_method)\n", + "red_model = netadapter.reduce_net(seq_model, train_dataset, train_labels, train_loader, n_class)\n", + "print(red_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## RandSVD + FNN\n", + "A small variant of the previous case can be obtained using Random SVD as reduction technique and a Feedforward Neural Network (FNN) as input-output mapping." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cutoff_idx = 5 \n", + "red_dim = 50 \n", + "red_method = 'RandSVD' \n", + "inout_method = 'FNN'\n", + "n_class = 10\n", + "netadapter = NetAdapter(cutoff_idx, red_dim, red_method, inout_method)\n", + "red_model = netadapter.reduce_net(seq_model, train_dataset, train_labels, train_loader, n_class)\n", + "print(red_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## AHOSVD + FNN\n", + "A different choice is represented by the introduction of HOSVD as reduction technique that keeps into account the tensorial structure of the objects under consideration. Hence, in this case we are using a variant of HOSVD, called Averaged HOSVD (AHOSVD), which performs HOSVD in batches and then computes the average between them to overcome the high computational effort needed. In particular, we are the n coupling AHOSVD with FNN as before." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FNN training initialized\n", + "FNN training completed\n", + "RedNet(\n", + " (premodel): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU(inplace=True)\n", + " (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU(inplace=True)\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (6): ReLU(inplace=True)\n", + " (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (8): ReLU(inplace=True)\n", + " (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (11): ReLU(inplace=True)\n", + " (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (13): ReLU(inplace=True)\n", + " (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (15): ReLU(inplace=True)\n", + " (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " )\n", + " (proj_model): tensor_product_layer(in_dimensions=[256, 4, 4], out_dimensions=[35, 3, 3])\n", + " (inout_map): FNN(\n", + " (model): Sequential(\n", + " (0): Linear(in_features=315, out_features=20, bias=True)\n", + " (1): Softplus(beta=1, threshold=20)\n", + " (2): Linear(in_features=20, out_features=10, bias=True)\n", + " )\n", + " )\n", + ")\n" + ] + } + ], + "source": [ + "cutoff_idx = 7\n", + "red_method= 'HOSVD'\n", + "red_dim = [35, 3, 3]\n", + "inout_method = 'FNN'\n", + "n_class = 10 \n", + "\n", + "netadapter = NetAdapter(cutoff_idx, red_dim, red_method, inout_method)\n", + "red_model = netadapter.reduce_net(seq_model, train_dataset, train_labels, train_loader, n_class, device = device).to(device) \n", + "print(red_model, flush=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training of the reduced network\n", + "Now that the reduced network has been defined, we can train it. The technique used is \"knowledge distillation\", i.e. try to use the knowledge contained in the original full model, also referred as the teacher model, to train the the reduced model, called student model." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Loss 0.4235516825962067\n", + " Top 1: Accuracy: 4614.0/50000 (9.23%)\n", + "Loss Value: 8.471033651924133e-06\n", + "Test Loss 0.5047410353899002\n", + " Top 1: Accuracy: 841.0/10000 (8.41%)\n", + "Loss Value: 5.047410353899002e-05\n", + "EPOCH 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/scratch/lmeneghe/anaconda/lib/python3.8/site-packages/torch/nn/functional.py:2747: UserWarning: reduction: 'mean' divides the total loss by both the batch size and the support size.'batchmean' divides only by the batch size, and aligns with the KL div math definition.'mean' will be changed to behave the same as 'batchmean' in the next major release.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Loss kd: 1.5311928987503053e-05\n", + "Test Loss -0.029346163740754126\n", + " Top 1: Accuracy: 8097.0/10000 (80.97%)\n", + "Loss Value: -2.9346163740754128e-06\n", + "EPOCH 2\n", + "Train Loss kd: 3.4757274389266966e-06\n", + "Test Loss 0.4364694202244282\n", + " Top 1: Accuracy: 8363.0/10000 (83.63%)\n", + "Loss Value: 4.364694202244282e-05\n" + ] + } + ], + "source": [ + "import copy\n", + "\n", + "optimizer = torch.optim.Adam([{\n", + " 'params': red_model.premodel.parameters(),\n", + " 'lr': 1e-4\n", + " }, {\n", + " 'params': red_model.proj_model.parameters(),\n", + " 'lr': 1e-5\n", + " }, {\n", + " 'params': red_model.inout_map.parameters(),\n", + " 'lr': 1e-5\n", + " }])\n", + "\n", + "train_loss = []\n", + "test_loss = []\n", + "train_loss.append(compute_loss(red_model, device, train_loader))\n", + "test_loss.append(compute_loss(red_model, device, test_loader))\n", + "\n", + " \n", + "epochs = 2\n", + "filename = './cifar10_VGG16_RedNet'+red_method+'_cutIDx_%d.pth'%(cutoff_idx)\n", + "for epoch in range(1, epochs + 1): \n", + " print('EPOCH {}'.format(epoch), flush=True)\n", + " train_loss.append(\n", + " train_kd(red_model,\n", + " VGGnet,\n", + " device,\n", + " train_loader,\n", + " optimizer,\n", + " train_max_batch=200,\n", + " alpha=0.1,\n", + " temperature=1.,\n", + " epoch=epoch))\n", + " test_loss.append(compute_loss(red_model, device, test_loader))\n", + "torch.save(copy.deepcopy(red_model), filename)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loading a reduced network checkpoint\n", + "If a reduced network has been already defined and saved on the computer, it can be loaded with the following instructions" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "checkpoint = filename #path to the checkpoint file\n", + "red_model = torch.load(checkpoint)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Accuracy testing\n", + "We can further test the accuracy of the network with the following code." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of the full network on test images is 83.6300\n" + ] + } + ], + "source": [ + "total = 0\n", + "correct = 0\n", + "for test, y_test in iter(test_loader):\n", + " with torch.no_grad():\n", + " output = red_model(test.to(device))\n", + " ps = torch.exp(output)\n", + " _, predicted = torch.max(output.data,1)\n", + " total += y_test.size(0)\n", + " correct += (predicted == y_test.to(device)).to(device).sum().item()\n", + "\n", + "print(\"Accuracy of the full network on test images is {:.4f}\".format(100*correct/total))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Storage and flops needed for the model\n", + "The following lines of code provide the amounts of storage needed to save the reduced model together with the number of floating point operations needed to compute them.\n", + "\n", + "We start by counting the number of non-zero entries (nnz) of the three components of the reduced network (this method only concerns the POD+FNN and RandSVD+FNN techniques, regarding the storage) and the flops." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre nnz = 6.62, proj_model nnz=0.03, FNN nnz=0.0249\n", + "flops: Pre = 190.51, proj_model = 0.00, FNN =0.01\n" + ] + } + ], + "source": [ + "rednet_storage = torch.zeros(3)\n", + "rednet_flops = torch.zeros(3)\n", + "\n", + "rednet_storage[0], rednet_storage[1], rednet_storage[2] = [\n", + " Total_param(red_model.premodel),\n", + " Total_param(red_model.proj_model),\n", + " Total_param(red_model.inout_map)]\n", + "\n", + "rednet_flops[0], rednet_flops[1], rednet_flops[2] = [\n", + " Total_flops(red_model.premodel, device),\n", + " Total_flops(red_model.proj_model, device),\n", + " Total_flops(red_model.inout_map, device)]\n", + "\n", + "\n", + "print('Pre nnz = {:.2f}, proj_model nnz={:.2f}, FNN nnz={:.4f}'.format(\n", + " rednet_storage[0], rednet_storage[1],\n", + " rednet_storage[2]))\n", + "print('flops: Pre = {:.2f}, proj_model = {:.2f}, FNN ={:.2f}'.format(\n", + " rednet_flops[0], rednet_flops[1], rednet_flops[2]))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can define another method that counts the storage needed for saving the reduced model (in MB)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing the storage needed by the RedNet model.\n", + "Components summary:\n", + "premodel.0.weight \t torch.Size([64, 3, 3, 3])\n", + "premodel.0.bias \t torch.Size([64])\n", + "premodel.2.weight \t torch.Size([64, 64, 3, 3])\n", + "premodel.2.bias \t torch.Size([64])\n", + "premodel.5.weight \t torch.Size([128, 64, 3, 3])\n", + "premodel.5.bias \t torch.Size([128])\n", + "premodel.7.weight \t torch.Size([128, 128, 3, 3])\n", + "premodel.7.bias \t torch.Size([128])\n", + "premodel.10.weight \t torch.Size([256, 128, 3, 3])\n", + "premodel.10.bias \t torch.Size([256])\n", + "premodel.12.weight \t torch.Size([256, 256, 3, 3])\n", + "premodel.12.bias \t torch.Size([256])\n", + "premodel.14.weight \t torch.Size([256, 256, 3, 3])\n", + "premodel.14.bias \t torch.Size([256])\n", + "proj_model.param0 \t torch.Size([35, 256])\n", + "proj_model.param1 \t torch.Size([3, 4])\n", + "proj_model.param2 \t torch.Size([3, 4])\n", + "inout_map.model.0.weight \t torch.Size([20, 315])\n", + "inout_map.model.0.bias \t torch.Size([20])\n", + "inout_map.model.2.weight \t torch.Size([10, 20])\n", + "inout_map.model.2.bias \t torch.Size([10])\n", + "\n", + "\n", + "The MB used are: 7.004007816314697\n" + ] + } + ], + "source": [ + "print('Computing the storage needed by the RedNet model.\\nComponents summary:')\n", + "storage = 0\n", + "for param_tensor in red_model.state_dict():\n", + " print(param_tensor, \"\\t\", red_model.state_dict()[param_tensor].size())\n", + " storage += torch.prod(torch.tensor(list(red_model.state_dict()[param_tensor].size())))\n", + "print(f\"\\n\\nThe MB used are: {4 * storage / 10 ** 6}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "vscode": { + "interpreter": { + "hash": "8c5bf16c94eb6f9341fa612a12f652937166e39821fa969ec7095b77ab48ffd1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/smithers/ml/tutorials/training_SSD.ipynb b/smithers/ml/tutorials/training_SSD.ipynb new file mode 100644 index 0000000..6c044b9 --- /dev/null +++ b/smithers/ml/tutorials/training_SSD.ipynb @@ -0,0 +1,512 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training SSD300\n", + "In this tutorial, we will show how to initialize, train and test SSD300 for object detection.\n", + "The tutorial is based on a subset of pictures from the PascalVOC dataset (both 2007 and 2012), but can be generalized to be used with the whole PascalVOC or other custom/benchmark datasets." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports\n", + "We start by importing all the necessary functions." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from PIL import Image\n", + "from time import time\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import torchvision.transforms as transforms\n", + "\n", + "import sys\n", + "sys.path.insert(0, '/scratch/lmeneghe/Smithers/')\n", + "\n", + "from smithers.ml.models.vgg import VGG\n", + "from smithers.ml.models.aux_conv import AuxiliaryConvolutions\n", + "from smithers.ml.models.predictor import PredictionConvolutions\n", + "from smithers.ml.dataset.pascalvoc_dataset import PascalVOCDataset\n", + "from smithers.ml.models.detector import Detector\n", + "from smithers.ml.models.utils_objdet import create_prior_boxes\n", + "\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameters Initialization\n", + "We set the parameters used for the data, the detector and the learning phase." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Learning parameters\n", + "batch_size = 8 # batch size\n", + "workers = 4 # number of workers for loading data in the DataLoader\n", + "iterations = 120000 # number of iterations to train\n", + "print_freq = 200 # print training status every __ batches\n", + "lr = 1e-4 # learning rate\n", + "decay_lr_at = [80000, 100000] # decay learning rate after these many iterations\n", + "decay_lr_to = 0.1\n", + "# decay learning rate to this fraction of the existing learning rate\n", + "#n_classes = 6\n", + "momentum = 0.9 # momentum\n", + "weight_decay = 5e-4 # weight decay\n", + "grad_clip = None\n", + "# clip if gradients are exploding, which may happen at larger batch sizes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dataset Loading\n", + "We need to load and create the datasets for training and testing our model. In this case we are using a dataset extracted from PascalVOC that has been created using ***smithers/ml/dataset/sample_dataset.py***. For more details about this, refer to the tutorial ***pascalvoc_preparation***, which explains also how to use the whole PascalVOC dataset. Instead, to use a custom dataset for this purpose, refer to the turial ***customdata_objdet***." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "categories: {'cat': 1, 'dog': 2, 'background': 0}\n", + "n_classes: 3\n", + "Training images: 240\n", + "Testing images: 60\n" + ] + } + ], + "source": [ + "#voc_labels = ('aeroplane', 'bicycle', 'bird', 'boat',\n", + "# 'bottle', 'bus', 'car', 'cat', 'chair',\n", + "# 'cow', 'diningtable', 'dog', 'horse',\n", + "# 'motorbike', 'person', 'pottedplant',\n", + "# 'sheep', 'sofa', 'train', 'tvmonitor')\n", + "voc_labels = ('cat', 'dog')\n", + "label_map = {k: v + 1 for v, k in enumerate(voc_labels)}\n", + "label_map['background'] = 0\n", + "n_classes = len(label_map)\n", + "print('categories:',label_map)\n", + "print('n_classes:', n_classes)\n", + "\n", + "# Data parameters\n", + "data_folder = 'VOC_dog_cat/JSONfiles' #folder with json data files\n", + "keep_difficult = True\n", + "\n", + "\n", + "train_dataset = PascalVOCDataset(data_folder,\n", + " split='train',\n", + " keep_difficult=keep_difficult)\n", + "train_loader = torch.utils.data.DataLoader(\n", + " train_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=True,\n", + " collate_fn=train_dataset.collate_fn,\n", + " num_workers=workers,\n", + " pin_memory=True)\n", + "\n", + "epochs = iterations // (len(train_dataset) // 16) #500\n", + "decay_lr_at = [it // (len(train_dataset) // 16) for it in decay_lr_at]\n", + "print('Training images:', len(train_dataset))\n", + "\n", + "\n", + "test_dataset = PascalVOCDataset(data_folder,\n", + " split='test',\n", + " keep_difficult=keep_difficult)\n", + "test_loader = torch.utils.data.DataLoader(test_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=False,\n", + " collate_fn=test_dataset.collate_fn,\n", + " num_workers=workers,\n", + " pin_memory=True)\n", + "print('Testing images:', len(test_dataset))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creation and loading of the SSD300 model\n", + "We are now going to initialize SSD300 using the class ***Detector*** of ***smithers/ml/models/detector.py***, based on the original paper: \n", + "\n", + "'SSD: Single Shot Multibox Detector' by Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, Alexander C. Berg https://arxiv.org/abs/1512.02325 ,DOI: 10.1007/978-3-319-46448-0_2\n", + "\n", + "In this case, we should select 'ssd' as classifier for VGG in order to substitute the feedforward classification layers of the original VGG with convolutional layers. We have then initialized SSD300 using pre-trained wegiths on ImageNet (a common choice in this field).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Loaded base model.\n", + "\n", + "Time needed to initialize the net: 2.58 seconds\n" + ] + } + ], + "source": [ + "start_init = time()\n", + "base_net = VGG(classifier='ssd', init_weights='imagenet')\n", + "aux_conv = AuxiliaryConvolutions()\n", + "predictor = PredictionConvolutions(n_classes)\n", + "network = [base_net, aux_conv, predictor]\n", + "priors_cxcy = create_prior_boxes()\n", + "end_init = time()\n", + "print('Time needed to initialize the net: {} seconds'.format(round(end_init-start_init,2)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training Phase\n", + "Once we have created and initliazed the network we can train it.\n", + "\n", + "\n", + "Here, the network will trained and, if provided, a checkpoint can be used to start from an already trained network.\n", + "\n", + "The training procedure will store a checkpoint file named ``checkpoint_ssd300.pth.tar``, once it is completed.\n", + "Furthermore, the plot of the value of the loss against the corresponding epoch is produced." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[VGG(\n", + " (features): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU(inplace=True)\n", + " (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU(inplace=True)\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (6): ReLU(inplace=True)\n", + " (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (8): ReLU(inplace=True)\n", + " (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (11): ReLU(inplace=True)\n", + " (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (13): ReLU(inplace=True)\n", + " (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (15): ReLU(inplace=True)\n", + " (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (18): ReLU(inplace=True)\n", + " (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (20): ReLU(inplace=True)\n", + " (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (22): ReLU(inplace=True)\n", + " (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=True)\n", + " (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (25): ReLU(inplace=True)\n", + " (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (27): ReLU(inplace=True)\n", + " (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (29): ReLU(inplace=True)\n", + " (30): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))\n", + " (classifier): Sequential(\n", + " (0): Conv2d(512, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(6, 6), dilation=(6, 6))\n", + " (1): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + "), AuxiliaryConvolutions(\n", + " (features): Sequential(\n", + " (0): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " (1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (2): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (3): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (4): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (5): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1))\n", + " (6): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (7): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1))\n", + " )\n", + "), PredictionConvolutions(\n", + " (features_loc): Sequential(\n", + " (0): Conv2d(512, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): Conv2d(1024, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (2): Conv2d(512, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): Conv2d(256, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (4): Conv2d(256, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (5): Conv2d(256, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " )\n", + " (features_cl): Sequential(\n", + " (0): Conv2d(512, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): Conv2d(1024, 18, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (2): Conv2d(512, 18, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): Conv2d(256, 18, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (4): Conv2d(256, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (5): Conv2d(256, 12, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " )\n", + ")]\n", + "Epoch: [0][0/30]\tBatch Time 0.638 (0.638)\tData Time 0.342 (0.342)\tLoss val (average) 68.6633 (68.6633)\t\n", + "Epoch: [1][0/30]\tBatch Time 0.372 (0.372)\tData Time 0.163 (0.163)\tLoss val (average) 10.0403 (10.0403)\t\n", + "Epoch: [2][0/30]\tBatch Time 0.426 (0.426)\tData Time 0.220 (0.220)\tLoss val (average) 5.1005 (5.1005)\t\n", + "Epoch: [3][0/30]\tBatch Time 0.539 (0.539)\tData Time 0.330 (0.330)\tLoss val (average) 6.9545 (6.9545)\t\n", + "Epoch: [4][0/30]\tBatch Time 0.430 (0.430)\tData Time 0.220 (0.220)\tLoss val (average) 4.1425 (4.1425)\t\n", + "Epoch: [5][0/30]\tBatch Time 0.404 (0.404)\tData Time 0.193 (0.193)\tLoss val (average) 3.9427 (3.9427)\t\n", + "Epoch: [6][0/30]\tBatch Time 0.435 (0.435)\tData Time 0.224 (0.224)\tLoss val (average) 3.8563 (3.8563)\t\n", + "Epoch: [7][0/30]\tBatch Time 0.486 (0.486)\tData Time 0.275 (0.275)\tLoss val (average) 4.0572 (4.0572)\t\n", + "Epoch: [8][0/30]\tBatch Time 0.416 (0.416)\tData Time 0.202 (0.202)\tLoss val (average) 3.9776 (3.9776)\t\n", + "Epoch: [9][0/30]\tBatch Time 0.552 (0.552)\tData Time 0.341 (0.341)\tLoss val (average) 4.8194 (4.8194)\t\n", + "Epoch: [10][0/30]\tBatch Time 0.466 (0.466)\tData Time 0.240 (0.240)\tLoss val (average) 3.1516 (3.1516)\t\n", + "Epoch: [11][0/30]\tBatch Time 0.387 (0.387)\tData Time 0.174 (0.174)\tLoss val (average) 3.6156 (3.6156)\t\n", + "Epoch: [12][0/30]\tBatch Time 0.466 (0.466)\tData Time 0.253 (0.253)\tLoss val (average) 3.2068 (3.2068)\t\n", + "Epoch: [13][0/30]\tBatch Time 0.450 (0.450)\tData Time 0.234 (0.234)\tLoss val (average) 3.6957 (3.6957)\t\n", + "Epoch: [14][0/30]\tBatch Time 0.452 (0.452)\tData Time 0.239 (0.239)\tLoss val (average) 3.5414 (3.5414)\t\n", + "Epoch: [15][0/30]\tBatch Time 0.391 (0.391)\tData Time 0.177 (0.177)\tLoss val (average) 3.7986 (3.7986)\t\n", + "Epoch: [16][0/30]\tBatch Time 0.406 (0.406)\tData Time 0.189 (0.189)\tLoss val (average) 2.9297 (2.9297)\t\n", + "Epoch: [17][0/30]\tBatch Time 0.480 (0.480)\tData Time 0.265 (0.265)\tLoss val (average) 4.0120 (4.0120)\t\n", + "Epoch: [18][0/30]\tBatch Time 0.420 (0.420)\tData Time 0.196 (0.196)\tLoss val (average) 3.1850 (3.1850)\t\n", + "Epoch: [19][0/30]\tBatch Time 0.518 (0.518)\tData Time 0.304 (0.304)\tLoss val (average) 4.4751 (4.4751)\t\n", + "Epoch: [20][0/30]\tBatch Time 0.416 (0.416)\tData Time 0.201 (0.201)\tLoss val (average) 3.8222 (3.8222)\t\n", + "Epoch: [21][0/30]\tBatch Time 0.438 (0.438)\tData Time 0.225 (0.225)\tLoss val (average) 3.3555 (3.3555)\t\n", + "Epoch: [22][0/30]\tBatch Time 0.521 (0.521)\tData Time 0.301 (0.301)\tLoss val (average) 3.4589 (3.4589)\t\n", + "Epoch: [23][0/30]\tBatch Time 0.425 (0.425)\tData Time 0.210 (0.210)\tLoss val (average) 3.0993 (3.0993)\t\n", + "Epoch: [24][0/30]\tBatch Time 0.431 (0.431)\tData Time 0.216 (0.216)\tLoss val (average) 3.4437 (3.4437)\t\n", + "Epoch: [25][0/30]\tBatch Time 0.420 (0.420)\tData Time 0.204 (0.204)\tLoss val (average) 2.7177 (2.7177)\t\n", + "Epoch: [26][0/30]\tBatch Time 0.441 (0.441)\tData Time 0.226 (0.226)\tLoss val (average) 3.4953 (3.4953)\t\n", + "Epoch: [27][0/30]\tBatch Time 0.492 (0.492)\tData Time 0.276 (0.276)\tLoss val (average) 3.2687 (3.2687)\t\n", + "Epoch: [28][0/30]\tBatch Time 0.463 (0.463)\tData Time 0.248 (0.248)\tLoss val (average) 3.0055 (3.0055)\t\n", + "Epoch: [29][0/30]\tBatch Time 0.387 (0.387)\tData Time 0.169 (0.169)\tLoss val (average) 2.7852 (2.7852)\t\n", + "Epoch: [30][0/30]\tBatch Time 0.433 (0.433)\tData Time 0.211 (0.211)\tLoss val (average) 3.4330 (3.4330)\t\n", + "Epoch: [31][0/30]\tBatch Time 0.442 (0.442)\tData Time 0.221 (0.221)\tLoss val (average) 2.9321 (2.9321)\t\n", + "Epoch: [32][0/30]\tBatch Time 0.434 (0.434)\tData Time 0.219 (0.219)\tLoss val (average) 3.2044 (3.2044)\t\n", + "Epoch: [33][0/30]\tBatch Time 0.457 (0.457)\tData Time 0.241 (0.241)\tLoss val (average) 3.1426 (3.1426)\t\n", + "Epoch: [34][0/30]\tBatch Time 0.422 (0.422)\tData Time 0.208 (0.208)\tLoss val (average) 2.5958 (2.5958)\t\n", + "Epoch: [35][0/30]\tBatch Time 0.456 (0.456)\tData Time 0.242 (0.242)\tLoss val (average) 2.5629 (2.5629)\t\n", + "Epoch: [36][0/30]\tBatch Time 0.446 (0.446)\tData Time 0.227 (0.227)\tLoss val (average) 3.7601 (3.7601)\t\n", + "Epoch: [37][0/30]\tBatch Time 0.492 (0.492)\tData Time 0.276 (0.276)\tLoss val (average) 3.4058 (3.4058)\t\n", + "Epoch: [38][0/30]\tBatch Time 0.466 (0.466)\tData Time 0.252 (0.252)\tLoss val (average) 3.0383 (3.0383)\t\n", + "Epoch: [39][0/30]\tBatch Time 0.439 (0.439)\tData Time 0.222 (0.222)\tLoss val (average) 3.2623 (3.2623)\t\n", + "Epoch: [40][0/30]\tBatch Time 0.403 (0.403)\tData Time 0.175 (0.175)\tLoss val (average) 2.4125 (2.4125)\t\n", + "Epoch: [41][0/30]\tBatch Time 0.477 (0.477)\tData Time 0.245 (0.245)\tLoss val (average) 3.3063 (3.3063)\t\n", + "Epoch: [42][0/30]\tBatch Time 0.451 (0.451)\tData Time 0.233 (0.233)\tLoss val (average) 2.9198 (2.9198)\t\n", + "Epoch: [43][0/30]\tBatch Time 0.499 (0.499)\tData Time 0.284 (0.284)\tLoss val (average) 2.6425 (2.6425)\t\n", + "Epoch: [44][0/30]\tBatch Time 0.508 (0.508)\tData Time 0.291 (0.291)\tLoss val (average) 4.0416 (4.0416)\t\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: [45][0/30]\tBatch Time 0.508 (0.508)\tData Time 0.294 (0.294)\tLoss val (average) 3.0490 (3.0490)\t\n", + "Epoch: [46][0/30]\tBatch Time 0.495 (0.495)\tData Time 0.281 (0.281)\tLoss val (average) 2.6906 (2.6906)\t\n", + "Epoch: [47][0/30]\tBatch Time 0.422 (0.422)\tData Time 0.206 (0.206)\tLoss val (average) 2.9869 (2.9869)\t\n", + "Epoch: [48][0/30]\tBatch Time 0.501 (0.501)\tData Time 0.287 (0.287)\tLoss val (average) 3.2848 (3.2848)\t\n", + "Epoch: [49][0/30]\tBatch Time 0.431 (0.431)\tData Time 0.217 (0.217)\tLoss val (average) 2.5937 (2.5937)\t\n", + "Epoch: [50][0/30]\tBatch Time 0.494 (0.494)\tData Time 0.276 (0.276)\tLoss val (average) 2.8005 (2.8005)\t\n", + "Epoch: [51][0/30]\tBatch Time 0.534 (0.534)\tData Time 0.323 (0.323)\tLoss val (average) 3.4860 (3.4860)\t\n", + "Epoch: [52][0/30]\tBatch Time 0.463 (0.463)\tData Time 0.248 (0.248)\tLoss val (average) 2.7057 (2.7057)\t\n", + "Epoch: [53][0/30]\tBatch Time 0.496 (0.496)\tData Time 0.285 (0.285)\tLoss val (average) 2.9458 (2.9458)\t\n", + "Epoch: [54][0/30]\tBatch Time 0.495 (0.495)\tData Time 0.280 (0.280)\tLoss val (average) 3.0684 (3.0684)\t\n", + "Epoch: [55][0/30]\tBatch Time 0.464 (0.464)\tData Time 0.242 (0.242)\tLoss val (average) 2.4921 (2.4921)\t\n", + "Epoch: [56][0/30]\tBatch Time 0.414 (0.414)\tData Time 0.197 (0.197)\tLoss val (average) 2.5531 (2.5531)\t\n", + "Epoch: [57][0/30]\tBatch Time 0.500 (0.500)\tData Time 0.286 (0.286)\tLoss val (average) 2.6622 (2.6622)\t\n", + "Epoch: [58][0/30]\tBatch Time 0.419 (0.419)\tData Time 0.205 (0.205)\tLoss val (average) 2.3643 (2.3643)\t\n", + "Epoch: [59][0/30]\tBatch Time 0.429 (0.429)\tData Time 0.209 (0.209)\tLoss val (average) 2.3899 (2.3899)\t\n", + "Time needed for training the net: 403.77 seconds, i.e. 6.7 minutes\n" + ] + } + ], + "source": [ + "check = None # if no checkpoint available\n", + "#check = 'checkpoint_ssd300.pth.tar' #if a checkpoint is available\n", + "epochs = 60\n", + "start = time()\n", + "detector = Detector(network, check, priors_cxcy, n_classes, epochs,\n", + " batch_size, print_freq, lr, decay_lr_at,\n", + " decay_lr_to, momentum, weight_decay, grad_clip,\n", + " train_loader, test_loader, 'Adam')\n", + "print(detector.model)\n", + "checkpoint, loss_values = detector.train_detector()\n", + "end = time()\n", + "print(f'Time needed for training the net: {round(end-start,2)} seconds, i.e. {round((end-start)/60,1)} minutes')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loss function\n", + "In order to understand if the training phase was completed in an optimal way, we can plot the loss function in order to show its behavior over time." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n_epochs = np.arange(start=0, stop=epochs, step=1)\n", + "plt.plot(n_epochs, loss_values)\n", + "plt.yscale('log')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Value Loss')\n", + "plt.savefig('loss_function.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Testing Phase\n", + "Once we have a trained model, we can analyze its accuracy against the testing dataset using the method ***eval_detector*** implemented in the class ***Detector***. It provides in output the accuracy for each class composing the dataset and the Mean Average Precision (mAP), which represents the mean of the precisions over the different categories under consideration." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Evaluating: 100%|██████████| 8/8 [00:03<00:00, 2.52it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'cat': 71.9229519367218, 'dog': 49.422404170036316}\n", + "{'cat': 71.9229519367218, 'dog': 49.422404170036316}\n", + "\n", + "Mean Average Precision (mAP): 60.673\n", + "Time needed for testing the net: 3.39 seconds, i.e. 0.1 minutes\n" + ] + } + ], + "source": [ + "start_test = time()\n", + "detector.eval_detector(label_map)\n", + "end_test = time()\n", + "\n", + "print(f'Time needed for testing the net: {round(end_test-start_test,2)} seconds, i.e. {round((end_test-start_test)/60,1)} minutes')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Image Detection\n", + "By choosing a specific image from the directory used, the network is able to detect the object(s) in it and save a version of the image in which the bounding box(es) with the relative label(s) is(/are) pictured. To view this, open the file ``out.jpg``, as described below." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "img_path = 'VOC_dog_cat/JPEGImages/001825.jpg'\n", + "original_image = Image.open(img_path, mode='r')\n", + "original_image = original_image.convert('RGB')\n", + "\n", + "detector.detect(original_image,\n", + " label_map,\n", + " min_score=0.01,\n", + " max_overlap=0.45,\n", + " top_k=1).show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "out_img = Image.open('out.jpg')\n", + "display(out_img)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "vscode": { + "interpreter": { + "hash": "8c5bf16c94eb6f9341fa612a12f652937166e39821fa969ec7095b77ab48ffd1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/smithers/ml/tutorials/training_VGG16.ipynb b/smithers/ml/tutorials/training_VGG16.ipynb new file mode 100644 index 0000000..3cb40ae --- /dev/null +++ b/smithers/ml/tutorials/training_VGG16.ipynb @@ -0,0 +1,491 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training VGG16 - Tutorial\n", + "\n", + "In this tutorial we will present how to train a VGG16 network and create a checkpoint file for the trained network." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports\n", + "Firstly, we start by importing all the necessary functions" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "import torchvision\n", + "import torch.nn as nn\n", + "import torchvision.transforms as transforms\n", + "import torchvision.datasets as datasets\n", + "import torch.optim as optim\n", + "import sys\n", + "sys.path.insert(0, '/scratch/lmeneghe/Smithers/')\n", + "\n", + "from smithers.ml.models.vgg import VGG\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setting the proper device\n", + "The following lines will detect if a gpu is available in the system running this tutorial. If that is the case, all the objects of the following tutorial will be allocated in the gpu, thus speeding up the training process." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cuda has been detected as the device which the script will be run on.\n" + ] + } + ], + "source": [ + "if torch.cuda.is_available():\n", + " device = torch.device('cuda')\n", + "else:\n", + " device = torch.device('cpu')\n", + "print(f\"{device} has been detected as the device which the script will be run on.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loading of the model\n", + "We use VGG16 as model, as implemented in ***smithers/ml/models/vgg.py***. The net is initialized using weights pre-trained on ImageNet, a common choice instead of using random ones (i.e. setting init_weights=True)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Loaded base model.\n", + "\n" + ] + } + ], + "source": [ + "VGGnet = VGG(cfg=None,\n", + " classifier='cifar',\n", + " batch_norm=False,\n", + " num_classes=10,\n", + " init_weights='imagenet').to(device)\n", + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = optim.SGD(VGGnet.parameters(), lr=0.001, momentum=0.9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loading of the CIFAR10 dataset\n", + "As stated before, we use the CIFAR10 dataset (already implemented in PyTorch) to test our technique. It is a computer-vision dataset used for object recognition. It consists of 60000 32 × 32 colour images divided in 10 non-overlapping classes: airplane, automobile, bird, cat, deer, dog, frog, horse, ship, and truck.\n", + "\n", + "See https://www.cs.toronto.edu/~kriz/cifar.html for more details on this dataset and on how to download it." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files already downloaded and verified\n", + "Files already downloaded and verified\n" + ] + } + ], + "source": [ + "batch_size = 8 #this can be changed\n", + "data_path = '../cifar/' \n", + "# transform functions: take in input a PIL image and apply this\n", + "# transformations\n", + "transform_train = transforms.Compose([\n", + " transforms.RandomCrop(32, padding=4),\n", + " transforms.RandomHorizontalFlip(),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n", + "])\n", + "\n", + "transform_test = transforms.Compose([\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n", + "])\n", + "train_dataset = datasets.CIFAR10(root=data_path + 'CIFAR10/',\n", + " train=True,\n", + " download=True,\n", + " transform=transform_train)\n", + "train_loader = torch.utils.data.DataLoader(train_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=True)\n", + "test_dataset = datasets.CIFAR10(root=data_path + 'CIFAR10/',\n", + " train=False,\n", + " download=True,\n", + " transform=transform_test)\n", + "test_loader = torch.utils.data.DataLoader(test_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=True)\n", + "train_labels = torch.tensor(train_loader.dataset.targets).to(device)\n", + "targets = list(train_labels)\n", + "classes = ('airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n", + "n_classes = len(classes)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Custom Dataset\n", + "If we want to use a custom dataset, we need firstly to construct it, following for example the tutorial on the construction of a custom dataset for the problem of Image Recognition. Hence, the previuous cell will be substitute with the following one." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data.sampler import SubsetRandomSampler\n", + "from collections import OrderedDict\n", + "from smithers.ml.imagerec_dataset import Imagerec_Dataset\n", + "\n", + "# load custom dataset for training and testing\n", + "transform = transforms.Compose(\n", + " [transforms.ToTensor(),\n", + " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n", + "\n", + "data = pd.read_csv('../dataset_imagerec/dataframe.csv')\n", + "data_path = '../dataset_imagerec/'\n", + "# SPLIT OF THE DATASET\n", + "batch_size = 128\n", + "validation_split = .2\n", + "shuffle_dataset = True\n", + "random_seed = 42\n", + "\n", + "dataset_size = len(data)\n", + "indices = list(range(dataset_size))\n", + "split = int(np.floor(validation_split * dataset_size))\n", + "if shuffle_dataset:\n", + " np.random.seed(random_seed)\n", + " np.random.shuffle(indices)\n", + "train_indices, val_indices = indices[split:], indices[:split]\n", + "print('train data', len(train_indices))\n", + "train_sampler = SubsetRandomSampler(train_indices)\n", + "valid_sampler = SubsetRandomSampler(val_indices)\n", + "resize_dim = [32, 32]\n", + "\n", + "dataset_imagerec = Imagerec_Dataset(data, data_path, resize_dim, transform)\n", + "train_dataset = dataset_imagerec.getdata(train_indices)\n", + "train_loader = torch.utils.data.DataLoader(dataset_imagerec,\n", + " batch_size=batch_size,\n", + " sampler=train_sampler)\n", + "test_loader = torch.utils.data.DataLoader(dataset_imagerec,\n", + " batch_size=batch_size,\n", + " sampler=valid_sampler)\n", + "\n", + "data.sort_values(by=['encoded_labels'], inplace=True)\n", + "classes = data['labels'].unique()\n", + "#classes = ('class_1', 'class_2', 'class_3', 'class_4')\n", + "n_class = len(classes)\n", + "targets = list(dataset_imagerec.targets[train_indices])\n", + "train_labels = torch.tensor(targets)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training phase \n", + "The following lines of code will train the network on the train images from the CIFAR10 dataset. Beware that training time can be very long and a gpu is recommended.\n", + "\n", + "It is possible to change the number of epochs for the training: if a large number is given, the network will perform better on the train images but will take longer to train, vice versa for a low number." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Loss Value: 0.09345\n", + "Epoch 2, Loss Value: 0.05922\n", + "Epoch 3, Loss Value: 0.04876\n", + "Epoch 4, Loss Value: 0.04112\n", + "Epoch 5, Loss Value: 0.03649\n", + "The network has been successfully trained for 5 epochs.\n" + ] + } + ], + "source": [ + "n_epochs = 5\n", + "for epoch in range(n_epochs):\n", + " running_loss = 0.0\n", + " for i, data in enumerate(train_loader, 0):\n", + " # get the inputs; data is a list of [inputs, labels]\n", + " inputs, labels = data\n", + " inputs = inputs.to(device)\n", + " labels = labels.to(device)\n", + "\n", + " # zero the parameter gradients\n", + " optimizer.zero_grad()\n", + "\n", + " # forward + backward + optimize\n", + " outputs = VGGnet(inputs)\n", + " loss = criterion(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " # Let's print statistics at the end of the epoch\n", + " running_loss += loss.item() # extract the loss value\n", + " if i==len(train_loader)-1:\n", + " print('Epoch {}, Loss Value: {:.5f}'.format\n", + " (epoch + 1, running_loss / ((i+1)*batch_size)))\n", + " # zero the loss\n", + " running_loss = 0.0\n", + "\n", + "\n", + "print(\"The network has been successfully trained for {} epochs.\".format(n_epochs))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Accuracy after the training phase\n", + "Once we have trained our model we can check its accuracy on the testing dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def testAccuracy(net, test_loader, device):\n", + " '''\n", + " Function for testing the accuracy of the model.\n", + "\n", + " :param nn.Module net: network under consideration\n", + " :param iterable test_loader: iterable object, it load the dataset for\n", + " testing. It iterates over the given dataset, obtained combining a\n", + " dataset(images, labels) and a sampler.\n", + " '''\n", + " net.eval()\n", + " accuracy = 0.0\n", + " total = 0.0\n", + " net.to(device)\n", + " \n", + " with torch.no_grad():\n", + " for data in test_loader:\n", + " images, labels = data\n", + " images = images.to(device)\n", + " labels = labels.to(device)\n", + " # run the model on the test set to predict labels\n", + " outputs = net(images)\n", + " # the label with the highest energy will be our prediction\n", + " _, predicted = torch.max(outputs.data, 1)\n", + " total += labels.size(0)\n", + " accuracy += (predicted == labels).sum().item()\n", + "\n", + " # compute the accuracy over all test images\n", + " accuracy = (100 * accuracy / total)\n", + " return(accuracy)\n", + "\n", + "\n", + "def testClasses(net, n_classes, test_loader, classes, device):\n", + " '''\n", + " Function testing the accuracy reached for each class\n", + " composing the dataset.\n", + "\n", + " :param nn.Module net: network under consideration\n", + " :param int n_classes: number of classes composing the dataset\n", + " :param iterable test_loader: iterable object, it load the dataset for\n", + " testing. It iterates over the given dataset, obtained combining a\n", + " dataset(images, labels) and a sampler.\n", + " '''\n", + " class_correct = list(0. for i in range(n_classes))\n", + " class_total = list(0. for i in range(n_classes))\n", + " net.eval()\n", + " net.to(device)\n", + " \n", + " with torch.no_grad():\n", + " for data in test_loader:\n", + " images, labels = data\n", + " images = images.to(device)\n", + " labels = labels.to(device) \n", + " outputs = net(images)\n", + " _, predicted = torch.max(outputs, 1)\n", + " c = (predicted == labels).squeeze()\n", + " if len(labels)==1:\n", + " c = torch.tensor([c])\n", + " for i in range(len(labels)):\n", + " label = labels[i]\n", + " class_correct[label] += c[i].item()\n", + " class_total[label] += 1\n", + "\n", + " for i in range(n_classes):\n", + " print('Accuracy of {} : {:.2f}%'.format(\n", + " classes[i], 100 * class_correct[i] / class_total[i]))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The accuracy over the whole test set is 87.51%\n", + "Accuracy of airplane : 92.30%\n", + "Accuracy of automobile : 96.80%\n", + "Accuracy of bird : 87.90%\n", + "Accuracy of cat : 82.40%\n", + "Accuracy of deer : 87.30%\n", + "Accuracy of dog : 73.80%\n", + "Accuracy of frog : 89.50%\n", + "Accuracy of horse : 87.30%\n", + "Accuracy of ship : 92.80%\n", + "Accuracy of truck : 85.00%\n" + ] + } + ], + "source": [ + "accuracy = testAccuracy(VGGnet, test_loader, device)\n", + "print('The accuracy over the whole test set is {:.2f}%'.format(accuracy))\n", + "testClasses(VGGnet, n_classes, test_loader, classes, device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating a checkpoint of the state of the network\n", + "Once the training is done, the state of the network should be saved for a later use." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import copy\n", + "torch.save(copy.deepcopy(VGGnet), 'check_vgg.pth')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loading state of the network from a checkpoint file\n", + "Once the state of the network has been saved in a ***.pth*** file, we can load it for a futher use, as an additional training or other tests." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "VGGnet = torch.load('check_vgg.pth')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The accuracy over the whole test set is 87.51%\n", + "Accuracy of airplane : 92.30%\n", + "Accuracy of automobile : 96.80%\n", + "Accuracy of bird : 87.90%\n", + "Accuracy of cat : 82.40%\n", + "Accuracy of deer : 87.30%\n", + "Accuracy of dog : 73.80%\n", + "Accuracy of frog : 89.50%\n", + "Accuracy of horse : 87.30%\n", + "Accuracy of ship : 92.80%\n", + "Accuracy of truck : 85.00%\n" + ] + } + ], + "source": [ + "accuracy = testAccuracy(VGGnet, test_loader, device)\n", + "print('The accuracy over the whole test set is {:.2f}%'.format(accuracy))\n", + "testClasses(VGGnet, n_classes, test_loader, classes, device)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "vscode": { + "interpreter": { + "hash": "8c5bf16c94eb6f9341fa612a12f652937166e39821fa969ec7095b77ab48ffd1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/smithers/ml/utils_imagerec.py b/smithers/ml/utils_imagerec.py new file mode 100644 index 0000000..cee8d92 --- /dev/null +++ b/smithers/ml/utils_imagerec.py @@ -0,0 +1,160 @@ +''' +Utilities for initiliazing, training and testing a network +for the problem of Image Recognition. +''' +import copy +import torch +import torch.nn as nn +import torch.optim as optim + + +def decimate(tensor, m): + ''' + Decimate a tensor by a factor 'm', i.e. downsample by keeping every + 'm'th value. This is used when we convert FC layers to equivalent + Convolutional layers, but of a smaller size. + :param torch.Tensor tensor: tensor to be decimated + :param list m: list of decimation factors for each dimension of the + tensor; None if not to be decimated along a dimension + :return: decimated tensor + :rtype: torch.Tensor + ''' + assert tensor.dim() == len(m) + for d in range(tensor.dim()): + if m[d] is not None: + tensor = tensor.index_select(dim=d, + index=torch.arange(start=0, + end=tensor.size(d), + step=m[d]).long()) + + return tensor + +def train(net, num_epochs, train_loader, test_loader, optim_str, device): + ''' + Function performing the training of a network. + + :param nn.Module net: network under consideration + :param int num_epochs: number of training epochs + :param iterable train_loader: iterable object, it load the dataset for + training. It iterates over the given dataset, obtained combining a + dataset(images, labels) and a sampler. + :param iterable test_loader: iterable object, it load the dataset for + testing. It iterates over the given dataset, obtained combining a + dataset(images, labels) and a sampler. + :param str optim_str: optimizer to use in the training + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + ''' + criterion = nn.CrossEntropyLoss() + if optim_str == 'sgd': + optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) + elif optim_str == 'adam': + optimizer = optim.Adam(net.parameters(), lr=0.001) + + net.to(device) + batch_size = train_loader.batch_size() + for epoch in range(num_epochs): # loop over the dataset multiple times + running_loss = 0.0 + + for i, (images, labels) in enumerate(train_loader, 0): + images = images.to(device) + labels = labels.to(device) + # zero the parameter gradients + optimizer.zero_grad() + # predict classes using images from the training set + outputs = net(images) + # compute the loss based on model output and real labels + loss = criterion(outputs, labels) + # backpropagate the loss + loss.backward() + # adjust parameters based on the calculated gradients + optimizer.step() + + # Let's print statistics at the end of the epoch + running_loss += loss.item() # extract the loss value + if i == len(train_loader)-1: + print('Epoch {}, Loss Value: {:.5f}'.format + (epoch + 1, running_loss / ((i+1)*batch_size))) + # zero the loss + running_loss = 0.0 + + # Compute and print the average accuracy fo this epoch when + # tested over all 10000 test images + accuracy_train = testAccuracy(net, train_loader, device) + print('For epoch {} the train accuracy over the whole train set' + + 'is {:.2f}%'.format(epoch + 1, accuracy_train)) + accuracy = testAccuracy(net, test_loader, device) + print('For epoch {} the test accuracy over the whole test set' + + 'is {:.2f}%'.format(epoch + 1, accuracy)) + + torch.save(copy.deepcopy(net), 'check_network.pth') + +def testAccuracy(net, test_loader, device): + ''' + Function for testing the accuracy of the model. + + :param nn.Module net: network under consideration + :param iterable test_loader: iterable object, it load the dataset for + testing. It iterates over the given dataset, obtained combining a + dataset(images, labels) and a sampler. + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + ''' + net.eval() + accuracy = 0.0 + total = 0.0 + net.to(device) + + with torch.no_grad(): + for data in test_loader: + images, labels = data + images = images.to(device) + labels = labels.to(device) + # run the model on the test set to predict labels + outputs = net(images) + # the label with the highest energy will be our prediction + _, predicted = torch.max(outputs.data, 1) + total += labels.size(0) + accuracy += (predicted == labels).sum().item() + + # compute the accuracy over all test images + accuracy = (100 * accuracy / total) + return accuracy + + +def testClasses(net, n_classes, test_loader, classes, device): + ''' + Function testing the accuracy reached for each class + composing the dataset. + + :param nn.Module net: network under consideration + :param int n_classes: number of classes composing the dataset + :param iterable test_loader: iterable object, it load the dataset for + testing. It iterates over the given dataset, obtained combining a + dataset(images, labels) and a sampler. + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + ''' + class_correct = list(0. for i in range(n_classes)) + class_total = list(0. for i in range(n_classes)) + net.eval() + net.to(device) + + with torch.no_grad(): + for data in test_loader: + images, labels = data + images = images.to(device) + labels = labels.to(device) + outputs = net(images) + _, predicted = torch.max(outputs, 1) + c = (predicted == labels).squeeze() + if len(labels) == 1: + c = torch.tensor([c]) + for i, _ in range(len(labels)): + label = labels[i] + class_correct[label] += c[i].item() + class_total[label] += 1 + + for i in range(n_classes): + print('Accuracy of {} : {:.2f}%'.format( + classes[i], 100 * class_correct[i] / class_total[i])) diff --git a/smithers/ml/utils_objdet.py b/smithers/ml/utils_objdet.py new file mode 100644 index 0000000..fdadfe5 --- /dev/null +++ b/smithers/ml/utils_objdet.py @@ -0,0 +1,1105 @@ +''' +Utilities for the transformations needed inside a CNN and performing +object detection +''' +import random +import torch +import torch.nn.functional as F +import torchvision.transforms.functional as FT +import numpy as np + +device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + + +def decimate(tensor, m): + ''' + Decimate a tensor by a factor 'm', i.e. downsample by keeping every + 'm'th value. This is used when we convert FC layers to equivalent + Convolutional layers, but of a smaller size. + :param torch.Tensor tensor: tensor to be decimated + :param list m: list of decimation factors for each dimension of the + tensor; None if not to be decimated along a dimension + :return: decimated tensor + :rtype: torch.Tensor + ''' + assert tensor.dim() == len(m) + for d in range(tensor.dim()): + if m[d] is not None: + tensor = tensor.index_select(dim=d, + index=torch.arange(start=0, + end=tensor.size(d), + step=m[d]).long()) + + return tensor + + +def find_intersection(set_1, set_2): + ''' + Find the intersection of every box combination between two sets of boxes + that are in boundary coordinates. + + :param torch.Tensor set_1: set 1, a tensor of dimensions (n1, 4) + :param torch.Tensor set_2: set 2, a tensor of dimensions (n2, 4) + :return: intersection of each of the boxes in set 1 with respect to each + of the boxes in set 2, i.e. a tensor of dimensions (n1, n2) + :rtype: torch.Tensor + ''' + + # PyTorch auto-broadcasts singleton dimensions + lower_bounds = torch.max(set_1[:, :2].unsqueeze(1), + set_2[:, :2].unsqueeze(0)) # (n1, n2, 2) + upper_bounds = torch.min(set_1[:, 2:].unsqueeze(1), + set_2[:, 2:].unsqueeze(0)) # (n1, n2, 2) + intersection_dims = torch.clamp(upper_bounds - lower_bounds, + min=0) # (n1, n2, 2) + # intersection is given by the area of the box, those the area of + # a rectangular + return intersection_dims[:, :, 0] * intersection_dims[:, :, 1] # (n1, n2) + + +def find_jaccard_overlap(set_1, set_2): + ''' + Find the Jaccard Overlap (IoU) of every box combination between two + sets of boxes that are in boundary coordinates. + + :param torch.Tensor set_1: set 1, a tensor of dimensions (n1, 4) + :param torch.Tensor set_2: set 2, a tensor of dimensions (n2, 4) + :return: Jaccard Overlap (float) of each of the boxes in set 1 with + respect to each of the boxes in set 2, i.e. a tensor of + dimensions (n1, n2) + :rtype: torch.Tensor + ''' + + # Find intersections + intersection = find_intersection(set_1, set_2) # (n1, n2) + + # Find areas of each box in both sets + areas_set_1 = (set_1[:, 2] - set_1[:, 0]) * (set_1[:, 3] - set_1[:, 1] + ) # (n1) + areas_set_2 = (set_2[:, 2] - set_2[:, 0]) * (set_2[:, 3] - set_2[:, 1] + ) # (n2) + + # Find the union + # PyTorch auto-broadcasts singleton dimensions + union = areas_set_1.unsqueeze(1) + areas_set_2.unsqueeze( + 0) - intersection # (n1, n2) + + return intersection / union # (n1, n2) + + +def xy_to_cxcy(xy): + ''' + Convert bounding boxes from boundary coordinates + (x_min, y_min, x_max, y_max) to center-size + coordinates (c_x, c_y, w, h). + + :param torch.Tensor xy: bounding boxes in boundary coordinates, a tensor + of size (n_boxes, 4) + :return: bounding boxes in center-size coordinates, a tensor of + size (n_boxes, 4) + :rtype: torch.Tensor + ''' + return torch.cat( + [ + (xy[:, 2:] + xy[:, :2]) / 2, # c_x, c_y + xy[:, 2:] - xy[:, :2] + ], + 1) # w, h + + +def cxcy_to_xy(cxcy): + ''' + Convert bounding boxes from center-size coordinates (c_x, c_y, w, h) + to boundary coordinates (x_min, y_min, x_max, y_max). + + :param torch.Tensor cxcy: bounding boxes in center-size coordinates, a + tensor of size (n_boxes, 4) + :return: bounding boxes in boundary coordinates, a tensor of + size (n_boxes, 4) + :rtype: torch.Tensor + ''' + return torch.cat( + [ + cxcy[:, :2] - (cxcy[:, 2:] / 2), # x_min, y_min + cxcy[:, :2] + (cxcy[:, 2:] / 2) + ], + 1) # x_max, y_max + + +def cxcy_to_gcxgcy(cxcy, priors_cxcy): + ''' + Encode bounding boxes (that are in center-size form) w.r.t. + the corresponding prior boxes (that are in center-size form). + Thus the offests are found, i.e. how much the prior has to + be adjusted to produce the bounding box. + For the center coordinates, find the offset with respect to + the prior box, and scale by the size of the prior box. + For the size coordinates, scale by the size of the prior box, + and convert to the log-space. + + In the model, we are predicting bounding box coordinates in this + encoded form. + + :param torch.Tensor cxcy: bounding boxes in center-size coordinates, + a tensor of size (n_priors, 4) + :param troch.Tensor priors_cxcy: prior boxes with respect to which + the encoding must be performed, a tensor of size (n_priors, 4) + :return: encoded bounding boxes, a tensor of size (n_priors, 4) + :rtype: torch.Tensor + ''' + + # The 10 and 5 below are referred to as 'variances' in the + # original Caffe repo, completely empirical. They are for some + # sort of numerical conditioning, for 'scaling the localization gradient' + # See https://github.com/weiliu89/caffe/issues/155 + return torch.cat( + [ + (cxcy[:, :2] - priors_cxcy[:, :2]) / + (priors_cxcy[:, 2:] / 10), # g_c_x, g_c_y + torch.log(cxcy[:, 2:] / priors_cxcy[:, 2:]) * 5 + ], + 1) # g_w, g_h + + +def gcxgcy_to_cxcy(gcxgcy, priors_cxcy): + ''' + Decode bounding box coordinates predicted by the model, since + they are encoded in the form mentioned above. + (see function cxcy_to_gcxgcy) + They are decoded into center-size coordinates. + + This is the inverse of the function above. + + :param torch.Tensor gcxgcy: encoded bounding boxes, i.e. output of the + model, a tensor of size (n_priors, 4) + :param torch.Tensor priors_cxcy: prior boxes with respect to which the + encoding is defined, a tensor of size (n_priors, 4) + :return: decoded bounding boxes in center-size form, a tensor of + size (n_priors, 4) + :rtype: torch.Tensor + ''' + + return torch.cat( + [ + gcxgcy[:, :2] * priors_cxcy[:, 2:] / 10 + + priors_cxcy[:, :2], # c_x, c_y + torch.exp(gcxgcy[:, 2:] / 5) * priors_cxcy[:, 2:] + ], + 1) # w, h + + +def create_prior_boxes(fmap_dims=None, obj_scales=None, aspect_ratios=None): + ''' + Create the 8732 prior (default) boxes for the SSD300, as defined + in the paper. + + :param dict fmap_dict: If None, it corresponds to the dimension of + the low and high(auxiliary) feature maps for SSD300. Otherwise, + you need to provide a dictionary, where the keys are the + convolutional layers and the values associated are the + dimensions of those feature maps. + :param dict obj_scales: If None, it returns the scaling values for + the priors in SSD300, i.e the percentage of the image that is + detected. In particular, in SSD300 larger feature maps as + conv4_3 have smaller object scales, thus they will used to + detect smaller objects. Otherwise you need to provide a + dictionary where the keys are the convolutional layers + corresponding to the low and high level features anf the values + associated the scales used for each of them. + :param dict aspect_ratios: If None, the aspect ratios used are that + of SSD300. Otherwise, you need to provide a dictionary where + the keys are the low and high level feature maps and the value + associated is a list with the different aspect ratios used for + the priors in that layer. + :return: prior boxes in center-size coordinates, a tensor of + dimensions (8732, 4) + :rtype: torch.Tensor + ''' + + if fmap_dims is None: + fmap_dims = { + 'conv4_3': 38, + 'conv7': 19, + 'conv8_2': 10, + 'conv9_2': 5, + 'conv10_2': 3, + 'conv11_2': 1 + } + if obj_scales is None: + obj_scales = { + 'conv4_3': 0.1, + 'conv7': 0.2, + 'conv8_2': 0.375, + 'conv9_2': 0.55, + 'conv10_2': 0.725, + 'conv11_2': 0.9 + } + if aspect_ratios is None: + aspect_ratios = { + 'conv4_3': [1., 2., 0.5], + 'conv7': [1., 2., 3., 0.5, .333], + 'conv8_2': [1., 2., 3., 0.5, .333], + 'conv9_2': [1., 2., 3., 0.5, .333], + 'conv10_2': [1., 2., 0.5], + 'conv11_2': [1., 2., 0.5] + } + + fmaps = list(fmap_dims.keys()) + + prior_boxes = [] + + for k, fmap in enumerate(fmaps): + for i in range(fmap_dims[fmap]): + for j in range(fmap_dims[fmap]): + cx = (j + 0.5) / fmap_dims[fmap] + cy = (i + 0.5) / fmap_dims[fmap] + + for ratio in aspect_ratios[fmap]: + prior_boxes.append([ + cx, cy, obj_scales[fmap] * np.sqrt(ratio), + obj_scales[fmap] / np.sqrt(ratio) + ]) + + # For an aspect ratio of 1, use an additional prior + # whose scale is the geometric mean of the scale of + # the current feature map and the scale of the next + # feature map + if ratio == 1.: + try: + additional_scale = np.sqrt(obj_scales[fmap] * + obj_scales[fmaps[k + 1]]) + # For the last feature map, there is no "next" + # feature map + except IndexError: + additional_scale = 1. + prior_boxes.append( + [cx, cy, additional_scale, additional_scale]) + + prior_boxes = torch.FloatTensor(prior_boxes).to(device) # (8732, 4) + prior_boxes.clamp_(0, 1) # (8732, 4) + + return prior_boxes + + +def expand(image, boxes, filler): + ''' + Perform a zooming out operation by placing the image in a larger canvas + of filler material. This helps to learn to detect smaller objects. + + :param torch.Tensor image: image, a tensor of dimensions + (3, original_h, original_w) + :param torch.Tensor boxes: bounding boxes in boundary coordinates, a tensor + of dimensions (n_objects, 4) + :param list filler: RBG values of the filler material, a list like [R, G, B] + where R, G, B are scalar values + :return: expanded image, updated bounding box coordinates + :rtype: torch.Tensor, torch.Tensor + ''' + # Calculate dimensions of proposed expanded (zoomed-out) image + original_h = image.size(1) + original_w = image.size(2) + # The zoomed out image must be between 1 and 4 times as large as the + # original. + max_scale = 4 + scale = random.uniform(1, max_scale) + new_h = int(scale * original_h) + new_w = int(scale * original_w) + + # Create such an image with the filler + filler = torch.FloatTensor(filler) # (3) + new_image = torch.ones( + (3, new_h, new_w), dtype=torch.float) * filler.unsqueeze(1).unsqueeze( + 1) # (3, new_h, new_w) + # Note - do not use expand() like + # new_image = filler.unsqueeze(1).unsqueeze(1).expand(3, new_h, new_w) + # because all expanded values will share the same memory, so changing one + # pixel will change all + + # Place the original image at random coordinates in this new image + # (origin at top-left of image) + left = random.randint(0, new_w - original_w) + right = left + original_w + top = random.randint(0, new_h - original_h) + bottom = top + original_h + new_image[:, top:bottom, left:right] = image + + # Adjust bounding boxes' coordinates accordingly + new_boxes = boxes + torch.FloatTensor([left, top, left, top]).unsqueeze( + 0) # (n_objects, 4), n_objects is the no. of objects in this image + + return new_image, new_boxes + + +def random_crop(image, boxes, labels, difficulties): + ''' + Performs a random crop(zoom in) in the manner stated in the SSD paper. + Helps to learn to detect larger and partial objects. Note that some + objects may be cut out entirely. Adapted from: + https://github.com/amdegroot/ssd.pytorch/blob/master/utils/augmentations.py + + :param torch.Tensor image: image, a tensor of dimensions + (3, original_h, original_w) + :param torch.Tensor boxes: bounding boxes in boundary coordinates, a tensor + of dimensions (n_objects, 4) + :param torch.Tensor labels: labels of objects, a tensor of dimensions + (n_objects) + :param torch.Tensor difficulties: difficulties of detection of these objs, + a tensor of dimensions (n_objects) + :return: cropped image, updated bounding box coordinates, updated labels, + updated difficulties + :rtype: torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor + ''' + original_h = image.size(1) + original_w = image.size(2) + # Keep choosing a minimum overlap until a successful crop is made + while True: + # Randomly draw the value for minimum overlap + min_overlap = random.choice([0., .1, .3, .5, .7, .9, + None]) # 'None' refers to no cropping + #print('min_overlap', min_overlap) + # If not cropping, thus if we have None, we exit and return the + # original image + if min_overlap is None: + #print('min overlap is None') + return image, boxes, labels, difficulties + + # Try up to 50 times for this choice of minimum overlap + # This isn't mentioned in the paper, of course, but 50 is chosen in + # paper authors' original Caffe repo + max_trials = 50 + for _ in range(max_trials): + #print('current trial', _) + # Crop dimensions must be in [0.3, 1] of original dimensions + # Note - it's [0.1, 1] in the paper, but actually [0.3, 1] in the + # authors' repo + min_scale = 0.3 + scale_h = random.uniform(min_scale, 1) + scale_w = random.uniform(min_scale, 1) + new_h = int(scale_h * original_h) + new_w = int(scale_w * original_w) + # Aspect ratio has to be in [0.5, 2] + aspect_ratio = new_h / new_w + if not 0.5 < aspect_ratio < 2: + #print('Aspect ratio not in the range allowed') + continue + + # Crop coordinates (origin at top-left of image) + left = random.randint(0, original_w - new_w) + right = left + new_w + top = random.randint(0, original_h - new_h) + bottom = top + new_h + crop = torch.FloatTensor([left, top, right, bottom]) # (4) + + # Calculate Jaccard overlap between the crop and the bounding boxes + overlap = find_jaccard_overlap( + crop.unsqueeze(0), boxes + ) # (1, n_objects), n_objects is the no. of objects in this image + overlap = overlap.squeeze(0) # (n_objects) + + # If not a single bounding box has a Jaccard overlap of greater than + # the minimum, try again + if overlap.max().item() < min_overlap: + #print( + # 'no bounding box has Jaccard overlap greater than\ + # the minimum' + #) + continue + + # Crop image + new_image = image[:, top:bottom, left:right] # (3, new_h, new_w) + + # Find centers of original bounding boxes + bb_centers = (boxes[:, :2] + boxes[:, 2:]) / 2. # (n_objects, 2) + + # Find bounding boxes whose centers are in the crop, thus at the end + # not all the bounding boxes may be in the crop + centers_in_crop = (bb_centers[:, 0] > left) * ( + bb_centers[:, 0] < right) * (bb_centers[:, 1] > + top) * (bb_centers[:, 1] < bottom) + # size centers_in_crop: (n_objects), a Torch uInt8/Byte tensor, can + # be used as a boolean index + + # If not a single bounding box has its center in the crop, try again + if not centers_in_crop.any(): + #print('No bounding box has its center in the crop') + continue + + # Discard bounding boxes that don't meet this criterion + new_boxes = boxes[centers_in_crop, :] + new_labels = labels[centers_in_crop] + new_difficulties = difficulties[centers_in_crop] + + # Calculate bounding boxes' new coordinates in the crop + new_boxes[:, :2] = torch.max(new_boxes[:, :2], + crop[:2]) # crop[:2] is [left, top] + # adjust to crop (by substracting crop's left,top), idem below + new_boxes[:, :2] -= crop[:2] + new_boxes[:, + 2:] = torch.min(new_boxes[:, 2:], + crop[2:]) # crop[2:] is [right, bottom] + new_boxes[:, 2:] -= crop[:2] + #print(new_image.size()) + return new_image, new_boxes, new_labels, new_difficulties + + +def flip(image, boxes): + ''' + Flip image horizontally. + + :param PIL Image image: image, a PIL Image + :param torch.Tensor boxes: bounding boxes in boundary coordinates, a tensor + of dimensions (n_objects, 4) + :return: flipped image, updated bounding box coordinates + :rtype: PIL Image, torch.Tensor + ''' + # Flip image horizontally + new_image = FT.hflip(image) + + # Flip boxes + new_boxes = boxes + new_boxes[:, 0] = image.width - boxes[:, 0] - 1 + new_boxes[:, 2] = image.width - boxes[:, 2] - 1 + new_boxes = new_boxes[:, [2, 1, 0, 3]] + + return new_image, new_boxes + + +def photometric_distort(image): + ''' + Distort brightness, contrast, saturation, and hue, each with a 50% chance, + in random order. + + :param PIL Image image: image, a PIL Image + :return: distorted image + :rtype: PIL Image + ''' + new_image = image + + distortions = [ + FT.adjust_brightness, FT.adjust_contrast, FT.adjust_saturation, + FT.adjust_hue + ] + + random.shuffle(distortions) + + for d in distortions: + if random.random() < 0.5: + if d.__name__ == 'adjust_hue': + # Caffe repo uses a 'hue_delta' of 18 - we divide by 255 + #because PyTorch needs a normalized value + adjust_factor = random.uniform(-18 / 255., 18 / 255.) + else: + # Caffe repo uses 'lower' and 'upper' values of 0.5 and 1.5 + #for brightness, contrast, and saturation + adjust_factor = random.uniform(0.5, 1.5) + + # Apply this distortion + new_image = d(new_image, adjust_factor) + + return new_image + + +def resize(image, boxes, dims=(300, 300), return_percent_coords=True): + ''' + Resize image. For the SSD300, it resizes to (300, 300). + + Since percent/fractional coordinates are calculated for the bounding boxes + (w.r.t image dimensions) in this process, you may choose to retain them. + + :param PIL Image image: image, a PIL Image + :param torch.Tensor boxes: bounding boxes in boundary coordinates, a tensor + of dimensions (n_objects, 4) + :param tuple dims: if None, the image is rescaled to (300,300) as needed + for SSD300. Otherwise, a tuple with the desired dimensions need to + be provided. + :param bool return_percent_coords: If True, it returns the + percent/fractional coordinates. Otherwise, it returns the new + coordinates of the bounding boxes for the rescaled image. + :return: resized image, updated tensor for bounding box + coordinates.(or fractional coordinates, in which case they + remain the same) + :rtype: PIL Image, torch.Tensor + ''' + # Resize image + new_image = FT.resize(image, dims) + + # Resize bounding boxes + old_dims = torch.FloatTensor( + [image.width, image.height, image.width, image.height]).unsqueeze(0) + new_boxes = boxes / old_dims # percent coordinates + + if not return_percent_coords: + new_dims = torch.FloatTensor([dims[1], dims[0], dims[1], + dims[0]]).unsqueeze(0) + new_boxes = new_boxes * new_dims + + return new_image, new_boxes + + +def transform(image, boxes, labels, difficulties, split): + ''' + Apply the transformations above. + NOTE: Since random_crop is used, the output size from the bounding boxes + may differ from that of the input bounding boxes + + :param PIL Image image: image, a PIL Image + :param torch.Tensor boxes: bounding boxes in boundary coordinates, a + tensor of dimensions (n_objects, 4) + :param torch.Tensor labels: a tensor of dimensions (n_objects) containing + the labels of objects. + :param torch.Tensor difficulties: a tensor of dimensions (n_objects) + representing the difficulties of detection for the objects in + the picture. + :param str split: Expected strings are: 'TRAIN' or 'TEST', since + different sets of transformations are applied. If a different string + is given, an error arise. + :return: transformed image, transformed bounding box coordinates, + transformed labels, transformed difficulties + :rtype: torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor + ''' + assert split in {'TRAIN', 'TEST'} + + # Mean and standard deviation of ImageNet data that our base VGG from + # torchvision was trained on. + # See: https://pytorch.org/docs/stable/torchvision/models.html + mean = [0.485, 0.456, 0.406] + std = [0.229, 0.224, 0.225] + + new_image = image + new_boxes = boxes + new_labels = labels + new_difficulties = difficulties + # Skip the following operations if evaluation/testing + if split == 'TRAIN': + # A series of photometric distortions in random order, each with + # 50% chance of occurrence, as in Caffe repo + new_image = photometric_distort(new_image) + + # Convert PIL image to Torch tensor + new_image = FT.to_tensor(new_image) + + # Expand image (zoom out) with a 50% chance - helpful for training + # detection of small objects. Fill surrounding space with the mean + # of ImageNet data that our base VGG was trained on + if random.random() < 0.5: + new_image, new_boxes = expand(new_image, boxes, filler=mean) + + # Randomly crop image (zoom in) + new_image, new_boxes, new_labels, new_difficulties = random_crop( + new_image, new_boxes, new_labels, new_difficulties) + + # Convert Torch tensor to PIL image + new_image = FT.to_pil_image(new_image) + + # Flip image with a 50% chance + if random.random() < 0.5: + new_image, new_boxes = flip(new_image, new_boxes) + + # Resize image to (300, 300) - this also converts absolute boundary + #coordinates to their fractional form + new_image, new_boxes = resize(new_image, new_boxes, dims=(300, 300)) + + # Convert PIL image to Torch tensor + new_image = FT.to_tensor(new_image) + + # Normalize by mean and standard deviation of ImageNet data that our + #base VGG was trained on + new_image = FT.normalize(new_image, mean=mean, std=std) + + return new_image, new_boxes, new_labels, new_difficulties + + +class AverageMeter(object): + ''' + Keeps track of most recent value, average, sum, and count of a + metric. + ''' + def __init__(self): + self.reset() + + def reset(self): + ''' + Reset value, average, sum and count of the metric. + ''' + self.val = 0 + self.avg = 0 + self.sum = 0 + self.count = 0 + + def update(self, val, n=1): + ''' + Update value, sum, counter and average of the metric. + + :param int val: current value of the object we are considering + :param int n: integer number corresponding to the step at which + we are updating the counter and other values + ''' + self.val = val + self.sum += val * n + self.count += n + self.avg = self.sum / self.count + + +def clip_gradient(optimizer, grad_clip): + ''' + Clips gradients computed during backpropagation in order to avoid + explosion of gradients. + + :param optimizer: optimizer with the gradients to be clipped + :param grad_clip: clip value + ''' + for group in optimizer.param_groups: + for param in group['params']: + if param.grad is not None: + param.grad.data.clamp_(-grad_clip, grad_clip) + + +def save_checkpoint_objdet(epoch, model, optimizer, path): + ''' + Save model checkpoint. + + :param scalar epoch: epoch number + :param list model: list of constructed classes that compose our network + :param torch.Tensor optimizer: optimizer chosen + :parma str path: path to the checkpoint file. + :return: path to the checkpoint file, with the current status of the net. + :rtype: str + ''' + state = {'epoch': epoch, 'model': model, 'optimizer': optimizer} + torch.save(state, path) + return path + + +def adjust_learning_rate(optimizer, scale): + ''' + Scale learning rate by a specified factor. + + :param optimizer: optimizer whose learning rate must be shrunk. + :param float scale: factor to multiply learning rate with. + ''' + for param_group in optimizer.param_groups: + param_group['lr'] *= scale + print("DECAYING learning rate.\n The new LR is %f\n" % + (optimizer.param_groups[-1]['lr'], )) + + + +def non_max_sup(n_above_min_score, class_decoded_locs, overlap, max_overlap): + ''' + Non-Maximum Suppression (NMS) + + :param n_above_min_score + :param torch.Tensor class_decoded_locs: (n_qualified, 4) + :param torch.Tensor overlap: tensor containing Jaccard overlap between + predicted boxes, size (n_above_min_score, n_above_min_score) + :param float max_overlap: maximum overlap two boxes can have so that the + one with the lower score is not suppressed via NMS + :return: NMS + :rtype: torch.Tensor + ''' + # A torch.uint8 (byte) tensor to keep track of which predicted boxes + # to suppress: 1 implies suppress, 0 implies don't suppress + suppress = torch.zeros((n_above_min_score), + dtype=torch.uint8).to(device) # (n_qualified) + + # Consider each box in order of decreasing scores + for box in range(class_decoded_locs.size(0)): + # If this box is already marked for suppression + if suppress[box] == 1: + continue + + # Suppress boxes whose overlaps (with this box) are greater than + # maximum overlap (but we are keeping the box we are considering + # in the for loop). Find such boxes and update suppress indices. + suppress = torch.max( + suppress, + (overlap[box] > max_overlap).byte()) #type(torch.ByteTensor)) + # The max operation retains previously suppressed boxes, like an 'OR' + # operation + + # Don't suppress this box, even though it has an overlap of 1 with + # itself + suppress[box] = 0 + return suppress + + +def detect_objects(priors_cxcy, predicted_locs, predicted_scores, n_classes, + min_score, max_overlap, top_k): + ''' + Decipher the 8732 locations and class scores (output of the SSD300) + to detect objects. For each class, perform Non-Maximum Suppression (NMS) + on boxes that are above a minimum threshold. + + :param torch.Tensor priors_cxcy: priors (default bounding boxes) in + center-size coordinates, a tensor of size (n_boxes, 4) + :param torch.Tensor predicted_locs: predicted locations/boxes w.r.t the 8732 + prior boxes, a tensor of dimensions (N, 8732, 4) + :param torch.Tensor predicted_scores: class scores for each of the encoded + locations/boxes, a tensor of dimensions (N, 8732, n_classes) + :param scalar n_classes: number of different type of objects in your dataset + :param float min_score: minimum threshold for a box to be considered a match + for a certain class + :param float max_overlap: maximum overlap two boxes can have so that the one + with the lower score is not suppressed via NMS + :param int top_k: if there are a lot of resulting detection across all + classes, keep only the top 'k' + :return: detections (boxes, labels, and scores), lists of length + batch_size + :rtype: list, list, list + ''' + batch_size = predicted_locs.size(0) + n_priors = priors_cxcy.size(0) + predicted_scores = F.softmax(predicted_scores, + dim=2) # (N, 8732, n_classes) + + # Lists to store final predicted boxes, labels, and scores for all images + all_images_boxes = list() + all_images_labels = list() + all_images_scores = list() + + assert n_priors == predicted_locs.size(1) == predicted_scores.size(1) + + for i in range(batch_size): + # Decode object coordinates from the form we regressed predicted + # boxes to + decoded_locs = cxcy_to_xy(gcxgcy_to_cxcy(predicted_locs[i], + priors_cxcy)) + # (8732, 4), these are fractional pt. coordinates + + # Lists to store boxes and scores for this image + image_boxes = list() + image_labels = list() + image_scores = list() + + max_scores, best_label = predicted_scores[i].max(dim=1) # (8732) + + # Check for each class + # Note: we do not consider class 0, that is associated with background. + for c in range(1, n_classes): + # Keep only predicted boxes and scores where scores for this class + # are above the minimum score + class_scores = predicted_scores[i][:, c] # (8732) + score_above_min_score = class_scores > min_score + # torch.uint8 (byte) tensor, for indexing + n_above_min_score = score_above_min_score.sum().item() + if n_above_min_score == 0: + continue + class_scores = class_scores[score_above_min_score] # (n_qualified) + #n_qualified=n_above_min_score <= 8732 + class_decoded_locs = decoded_locs[ + score_above_min_score] # (n_qualified, 4) + + # Sort predicted boxes and scores by scores + class_scores, sort_ind = class_scores.sort( + dim=0, descending=True) # (n_qualified), (n_above_min_score) + class_decoded_locs = class_decoded_locs[ + sort_ind] # (n_above_min_score, 4) + + # Find the overlap between predicted boxes + overlap = find_jaccard_overlap( + class_decoded_locs, + class_decoded_locs) # (n_above_min_score, n_above_min_score) + + ################################# + # Non-Maximum Suppression (NMS) # + ################################# + suppress = non_max_sup(n_above_min_score, class_decoded_locs, + overlap, max_overlap) + + # Store only unsuppressed boxes for this class + image_boxes.append(class_decoded_locs[~suppress.bool()]) + image_labels.append( + torch.LongTensor((1 - suppress).sum().item() * [c]).to(device)) + image_scores.append(class_scores[~suppress.bool()]) + + # If no object in any class is found, store a placeholder for + # 'background' + if len(image_boxes) == 0: + image_boxes.append(torch.FloatTensor([[0., 0., 1., 1.]]).to(device)) + image_labels.append(torch.LongTensor([0]).to(device)) + image_scores.append(torch.FloatTensor([0.]).to(device)) + + # Concatenate into single tensors + image_boxes = torch.cat(image_boxes, dim=0) # (n_objects, 4) + image_labels = torch.cat(image_labels, dim=0) # (n_objects) + image_scores = torch.cat(image_scores, dim=0) # (n_objects) + n_objects = image_scores.size(0) + + # Keep only the top k objects + if n_objects > top_k: + image_scores, sort_ind = image_scores.sort(dim=0, descending=True) + image_scores = image_scores[:top_k] # (top_k) + image_boxes = image_boxes[sort_ind][:top_k] # (top_k, 4) + image_labels = image_labels[sort_ind][:top_k] # (top_k) + + # Append to lists that store predicted boxes and scores for all images + all_images_boxes.append(image_boxes) + all_images_labels.append(image_labels) + all_images_scores.append(image_scores) + + return all_images_boxes, all_images_labels, all_images_scores + + +def calculate_AP(true_images, true_boxes, true_difficulties, true_labels, + det_images, det_boxes, det_scores, det_labels, n_classes): + ''' + Calculate the Average Precision (AP) of detected objects. + + :param torch.Tensor true_images: tensor for storing the images with the + actual objects contained in them, size (n_objects) + :param torch.Tensor true_boxes: tensor for storing the true boxes for the + actual objects in our images, size (n_objects, 4) + :param torch.ByteTensor true_difficulties: tensor for storing the true + difficulties for the actual objects in our images, size (n_objects) + :param torch.Tensor true_labels: tensor containing actual objects' labels + for our images, size (n_objects) + :param torch.Tensor det_images: tensor for storing the images containing the + detected objects, size (n_detections) + :param torch.Tensor det_boxes: tensor for storing the boxes of the detected + objects in our images, size (n_detections, 4) + :param torch.Tensor det_scores: tensor for storing the scores of the + detected objects in our images, size (n_detections) + :param torch.Tensor det_labels: tensor containing detected objects' labels + in our images, size (n_objects) + :param int n_classes: number of classes in the dataset + :return: average_precisions (AP) corresponding to + the mean of the recalls above the threshold chosen for each class in the + dataset + :rtype: torch.Tensor + ''' + average_precisions = torch.zeros((n_classes - 1), + dtype=torch.float) # (n_classes - 1) + for c in range(1, n_classes): + # Extract only objects with this class + true_class_images = true_images[true_labels == c] # (n_class_objects) + true_class_boxes = true_boxes[true_labels == c] # (n_class_objects, 4) + true_class_difficulties = true_difficulties[true_labels == + c] # (n_class_objects) + n_easy_class_objects = ( + ~true_class_difficulties).sum().item() # ignore difficult objects + + # Keep track of which true objects with this class have already been + # 'detected'. So far, none + + true_class_boxes_detected = torch.zeros( + (true_class_difficulties.size(0)), + dtype=torch.uint8).to(device) # (n_class_objects) + + # Extract only detections with this class + det_class_images = det_images[det_labels == c] # (n_class_detections) + det_class_boxes = det_boxes[det_labels == c] # (n_class_detections, 4) + det_class_scores = det_scores[det_labels == c] # (n_class_detections) + n_class_detections = det_class_boxes.size( + 0) #number of objects detected for this class + if n_class_detections == 0: + continue + + # Sort detections in decreasing order of confidence/scores + det_class_scores, sort_ind = torch.sort( + det_class_scores, dim=0, descending=True) # (n_class_detections) + det_class_images = det_class_images[sort_ind] # (n_class_detections) + det_class_boxes = det_class_boxes[sort_ind] # (n_class_detections, 4) + + # In the order of decreasing scores, check if true or false positive + true_positives = torch.zeros( + (n_class_detections), + dtype=torch.float).to(device) # (n_class_detections) + false_positives = torch.zeros( + (n_class_detections), + dtype=torch.float).to(device) # (n_class_detections) + for d in range(n_class_detections): + # take the corresponding box and image for the detected object + # we are considering + this_detection_box = det_class_boxes[d].unsqueeze(0) # (1, 4) + this_image = det_class_images[d] # (), scalar + + # Find objects in the same image with this class, their + # difficulties, and whether they have been detected before. + # in particular given a detected obj in this class c, consider + # the other obj of the same class that you find in this_image to + # which it belong. + object_boxes = true_class_boxes[ + true_class_images == this_image] # (n_class_objects_in_img) + object_difficulties = true_class_difficulties[ + true_class_images == this_image] # (n_class_objects_in_img) + # If no such object in this image, then the detection is a false + # positive. + # It is necessary to have at least one obj, i.e. the obj in exam. + # Otherwise is a false positive + if object_boxes.size(0) == 0: + false_positives[d] = 1 + continue + + # Find maximum overlap of this detection with objects in this image + # of this class + overlaps = find_jaccard_overlap( + this_detection_box, object_boxes) # (1, n_class_objects_in_img) + max_overlap, ind = torch.max(overlaps.squeeze(0), + dim=0) # (), () - scalars + + # 'ind' is the index of the object in these image-level tensors + # 'object_boxes', 'object_difficulties' + # In the original class-level tensors 'true_class_boxes', etc., + # 'ind' corresponds to object with index... + original_ind = torch.LongTensor(range( + true_class_boxes.size(0)))[true_class_images == this_image][ind] + # We need 'original_ind' to update 'true_class_boxes_detected' + + # If the maximum overlap is greater than the threshold of 0.5, + # it's a match + if max_overlap.item() > 0.5: + # If the object it matched with is 'difficult', ignore it + if object_difficulties[ind] == 0: + # If this object has already not been detected, + # it's a true positive + if true_class_boxes_detected[original_ind] == 0: + true_positives[d] = 1 + true_class_boxes_detected[original_ind] = 1 + # this object has now been detected/accounted for + # Otherwise, it's a false positive (since this object + # is already accounted for) + else: + false_positives[d] = 1 + # Otherwise, the detection occurs in a different location than + # the actual object, and is a false positive + else: + false_positives[d] = 1 + + # Compute cumulative precision and recall at each detection + # in the order of decreasing scores + cumul_true_positives = torch.cumsum(true_positives, + dim=0) # (n_class_detections) + cumul_false_positives = torch.cumsum(false_positives, + dim=0) # (n_class_detections) + cumul_precision = cumul_true_positives / ( + cumul_true_positives + cumul_false_positives + 1e-10 + ) # cumul_precision--> size: (n_class_detections) + cumul_recall = cumul_true_positives / n_easy_class_objects + # cumul_recall--> size: (n_class_detections) + # recall = TP/(TP+FN) --> at denominator we will have all + # the objects that I want to detect (objs that are really on + # the images, not difficult to detect) + + # Find the mean of the maximum of the precisions corresponding + # to recalls above the threshold 't' + recall_thresholds = torch.arange(start=0, end=1.1, + step=.1).tolist() # (11) + precisions = torch.zeros((len(recall_thresholds)), + dtype=torch.float).to(device) # (11) + for i, t in enumerate(recall_thresholds): + recalls_above_t = cumul_recall >= t + if recalls_above_t.any(): + precisions[i] = cumul_precision[recalls_above_t].max() + else: + precisions[i] = 0. + average_precisions[c - 1] = precisions.mean() + # c is in [1, n_classes - 1] + return average_precisions + + +def calculate_mAP(det_boxes, det_labels, det_scores, true_boxes, true_labels, + true_difficulties, label_map): + ''' + Calculate the Mean Average Precision (mAP) of detected objects. + + See https://medium.com/@jonathan_hui/map-mean-average-precision-for-object-detection-45c121a31173 + for an explanation + + :param list det_boxes: list of tensors, one tensor for each image + containing detected objects' bounding boxes, thus the length of + det_boxes corresponds to the number of images we are considering + and the size of each tensor is (n_obj, 4), where n_obj is the + number of objects detected for that image + :param list det_labels: list of tensors, one tensor for each image + containing detected objects' labels, thus the length of det_labels + corresponds to the number of images we are considering and the + size of each tensor is (n_obj), where n_obj is the number of + objects detected for that image. + :param list det_scores: list of tensors, one tensor for each image + containing detected objects' labels' scores, thus the length of + det_scores corresponds to the number of images we are considering + and the size of each tensor is (n_obj), where n_obj is the number + of objects detected for that image. + :param list true_boxes: list of tensors, one tensor for each image + containing actual objects' bounding boxes, thus the length of + true_boxes corresponds to the number of images we are considering + and the size of each tensor is (n_obj, 4), where n_obj is the + number of objects for that image. + :param list true_labels: list of tensors, one tensor for each image + containing actual objects' labels, thus the length of true_labels + corresponds to the number of images we are considering and the + size of each tensor is (n_obj), where n_obj is the number of + objects for that image. + :param list true_difficulties: list of ByteTensors, one tensor for each + image containing actual objects' difficulty (0 or 1), thus the + length of true_difficulties corresponds to the number of images + we are considering and the size of each tensor is (n_obj), + where n_obj is the number of objects for that image. + :param dict label_map: dictionary for the label map, where the + keys are the labels of the objects(the classes) and their + values the number of the classes to which they belong + (0 for the background). Thus the length of this dict will be + the number of the classes of the dataset. + :return: average precisions for all classes, mean average + precision (mAP) + :rtype: list + NOTE: n_obj detected may be different from n_obj true. For example, + some objects could not have been detected. Or there can be + multiple proposals for them (even if NMS has been used) + ''' + assert len(det_boxes) == len(det_labels) == len(det_scores) == len( + true_boxes) == len(true_labels) == len(true_difficulties) + # these are all lists of tensors of the same length, i.e. number + # of images + n_classes = len(label_map) + + # Store all (true) objects in a single continuous tensor while keeping + # track of the image it is from + true_images = list() + for i in range(len(true_labels)): + true_images.extend([i] * true_labels[i].size(0)) + true_images = torch.LongTensor(true_images).to( + device + ) # (n_objects), n_objects is the total no. of objects across all images + true_boxes = torch.cat(true_boxes, dim=0) # (n_objects, 4) + true_labels = torch.cat(true_labels, dim=0) # (n_objects) + true_difficulties = torch.cat(true_difficulties, dim=0) # (n_objects) + + assert true_images.size(0) == true_boxes.size(0) == true_labels.size(0) + + # Store all detections in a single continuous tensor while keeping + # track of the image it is from + det_images = list() + for i in range(len(det_labels)): + det_images.extend([i] * det_labels[i].size(0)) + det_images = torch.LongTensor(det_images).to(device) # (n_detections) + det_boxes = torch.cat(det_boxes, dim=0) # (n_detections, 4) + det_labels = torch.cat(det_labels, dim=0) # (n_detections) + det_scores = torch.cat(det_scores, dim=0) # (n_detections) + + assert det_images.size(0) == det_boxes.size(0) == det_labels.size( + 0) == det_scores.size(0) + + #################################################### + # Calculate APs for each class (except background) # + #################################################### + average_precisions = calculate_AP(true_images, true_boxes, + true_difficulties, true_labels, + det_images, det_boxes, det_scores, + det_labels, n_classes) + + ########################################## + # Calculate Mean Average Precision (mAP) # + ########################################## + mean_average_precision = 100 * average_precisions.mean().item() + + # Keep class-wise average precisions in a dictionary + rev_label_map = {v: k for k, v in label_map.items()} # Inverse mapping + average_precisions = { + rev_label_map[c + 1]: 100 * v + for c, v in enumerate(average_precisions.tolist()) + } + + return average_precisions, mean_average_precision + + diff --git a/smithers/ml/utils_rednet.py b/smithers/ml/utils_rednet.py new file mode 100644 index 0000000..9565c9c --- /dev/null +++ b/smithers/ml/utils_rednet.py @@ -0,0 +1,468 @@ +''' +Utilities for the construction of the reduced version of a +Neural Network. +''' + +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +from sklearn import decomposition +from scipy import linalg + + + +if torch.cuda.is_available(): + device = torch.device('cuda') +else: + device = torch.device('cpu') + + +def get_seq_model(model): + ''' + Takes a model with model.features and model.classifier and + returns a sequential model. If attribute self.classifier_str + is not present, add this attribute to the model before running + this function. + + :param nn.Module model: CNN chosen, for example VGG16. + :return: sequential formula of the model that has be given in input. + :rtype: nn.Sequential + ''' + if list(model.classifier.children()): + if model.classifier_str == 'cifar': + seq_model = nn.Sequential(*(list(model.features.children()) + + [nn.Flatten(1, -1)] + + list(model.classifier.children()))) + else: #if model.classifier_str == 'standard': + seq_model = nn.Sequential(*(list(model.features.children()) + + [nn.AdaptiveAvgPool2d((7, 7))] + + [nn.Flatten(1, -1)]+ + list(model.classifier.children()))) + else: + if model.classifier_str == 'cifar': + seq_model = nn.Sequential(*(list(model.features.children()) + + [nn.Flatten(1, -1)] + + [model.classifier])) + elif model.classifier_str == 'standard': + seq_model = nn.Sequential(*(list(model.features.children()) + + [nn.AdaptiveAvgPool2d((7, 7))] + + [nn.Flatten(1, -1)] + + [model.classifier])) + return seq_model + + + +def PossibleCutIdx(seq_model): + ''' + Function that identifies the possible indexes where the net can be + cut, i.e. the indexes of the convolutional and fully-connected + layers. + + :param nn.Sequential seq_model: sequential container containing all + the layers of the model + :return: containing all the indexes of the convolutional and + fully-connected layers + :rtype: list + ''' + cutidx = [] + for i, m in seq_model.named_modules(): + if isinstance(m, (nn.Linear, nn.Conv2d)):# or isinstance(m, nn.Conv2d): + cutidx.append(int(i)) # Find the Linear or Conv2d Layer Idx + return cutidx + + +# RANDOM SVD + +def randomized_range_finder(A, size, n_iter=5): + A = A.to('cpu') + Q = np.random.normal(size=(A.shape[1], size)) + + for i in range(n_iter): + Q, _ = linalg.lu(A @ Q, permute_l=True) + Q, _ = linalg.lu(A.T @ Q, permute_l=True) + Q, _ = linalg.qr(A @ Q, mode='economic') + return Q + +def randomized_svd(M, n_components, n_oversamples=10, n_iter=2): + n_random = n_components + n_oversamples + + Q = torch.tensor(randomized_range_finder(M, n_random, n_iter),dtype = torch.float) + # project M to the (k + p) dimensional space using the basis vectors + M = torch.tensor(M, dtype = torch.float).to('cpu') + + B = Q.transpose(0, 1) @ M + # compute the SVD on the thin matrix: (k + p) wide + Uhat, s, V = linalg.svd(B, full_matrices=False) + Uhat = torch.tensor(Uhat).to('cpu') + del B + U = Q @ Uhat + + return U[:, :n_components], s[:n_components], V[:n_components, :] + +# ACTIVE SUBSPACES + +def give_inputs(dataset, model): + ''' + Generator for computing the inputs for a layer, e.g the reduction + layer. + + :param Dataset/list of tuples dataset: dataset containing the + images/data. + :param nn.Sequential model: Sequential container representing the + model, e.g. the pre-model. + :return: matrix of inputs/outputs of the model + :rtype: numpy.ndarray + ''' + for data in dataset: + input0 = data[0].unsqueeze(0) #add dimension as first axis + #target = torch.tensor([data[1]]) + input_ = model(input0) + yield torch.squeeze(input_.flatten(1)).detach().numpy() + +def spatial_gradients(dataset, pre_model, post_model): + ''' + Generator for computing the spatial gradients of the + loss function composed with the postmodel (the derivative is + computed w.r.t. the inputs of the AS, i.e. the evaluation of + the premodel in the input of the net. + + :param Dataset/list of tuples dataset: dataset containing the + images/data. + :param nn.Sequential pre_model: Sequential container representing the + pre-model, i.e. the model cut on the cut-off layer + :param nn.Sequential post_model: Sequential container representing + the post-model, i.e. the model after the cut-off layer. + :return: matrix of spatial gradients + :rtype: numpy.ndarray + ''' + for data in dataset: + input0 = data[0].unsqueeze(0) #add dimension as first axis + target = torch.LongTensor([data[1]]) + input_ = pre_model(input0) + out_post = post_model(input_) + output_ = F.nll_loss(out_post, target, reduce=False) + gradient = torch.autograd.grad( + output_, + input_, + grad_outputs=torch.ones(output_.size()).to(dtype=input_.dtype, + device=input_.device), + create_graph=True, + retain_graph=True, + allow_unused=True) + yield torch.squeeze(gradient[0].flatten(1)).detach().numpy() + + + +def projection(proj_mat, data_loader, matrix, device = device): + ''' + Funtion that performs the projection onto a space (e.g. the reduced + space) of a matrix. + + :param torch.Tensor proj_mat: projection matrix n_feat x n_red.dim. + :param iterable data_loader: iterable object for loading the dataset. + It iterates over the given dataset, obtained combining a + dataset(images and labels) and a sampler. + :param torch.Tensor matrix: matrix to project n_images x n_feat. + Possible way to construct it using the function forward_dataset. + :param torch.device device: device used to allocate the variables for + the function. + :return: reduced matrix n_images x n_red.dim + :rtype: torch.Tensor + ''' + proj_mat = proj_mat.to(device) + matrix_red = torch.zeros(0).to(device) + num_batch = len(data_loader) + batch_old = 0 + for idx_, batch in enumerate(data_loader): + if idx_ >= num_batch: + break + + images = batch[0].to(device) + + with torch.no_grad(): + proj_data = (matrix[batch_old : batch_old + images.size()[0], : ] @ proj_mat).to(device) + batch_old = images.size()[0] + matrix_red = torch.cat([matrix_red, proj_data.to(device)]) + + return matrix_red + + +def forward_dataset(model, data_loader, device = device, flattening = True): + ''' + Forward of a model using the whole dataset, i.e. the forward is + performed by splitting the dataset in batches in order to reduce + the computational effort needed. + + :param nn.Sequential/nn.Module model: model. + :param iterable data_loader: iterable object for loading the dataset. + It iterates over the given dataset, obtained combining a + dataset(images and labels) and a sampler. + :param torch.device device: device used to allocate the variables for the function. + :param bool flattening: used to state whether flattening is desired or not (e.g. flattening = False for HOSVD). + :return: output of the model computed on the whole dataset with + dimensions n_images x n_feat (corresponds to n_class for the last + layer) + :rtype: torch.Tensor + ''' + out_model = torch.zeros(0).to(device) + num_batch = len(data_loader) + for idx_, batch in enumerate(data_loader): + if idx_ >= num_batch: + break + images = batch[0].to(device) + + with torch.no_grad(): + outputs = model(images).to(device) + if flattening: + outputs = torch.squeeze(outputs.flatten(1)).detach() + out_model = torch.cat([out_model.to(device), outputs.to(device)]).to(device) + return out_model.to(device) + + +# HOSVD - tensorial approach +def tensor_projection(proj_matrices, data_loader, model, device): + ''' + Funtion that performs the projection onto a space (e.g. the reduced + space) of a tensor (more than 2 dimensions). + + :param list proj_matrices: list containing the projection matrices for + each dimension of the tensor. For each dimension i, the related + projection matrix has size (input_dim[i], red_dim_list[i]) + :param iterable data_loader: iterable object for loading the dataset. + It iterates over the given dataset, obtained combining a + dataset(images and labels) and a sampler. + :param nn.Module/torch.Tensor model: model under consideration for computing its + outputs (that has to be reduced) or matrix to project n_images x C X H X W. + Possible way to construct it using the function forward_dataset. + :param torch.device device: device used to allocate the variables for + the function. + :return: reduced tensor n_images x red_dim[1] x red_dim[2] x red_dim[3] + :rtype: torch.Tensor + ''' + out_model = torch.zeros(0).to(device) + batch_old = 0 + for idx_, batch in enumerate(data_loader): + images = batch[0].to(device) + with torch.no_grad(): + if torch.is_tensor(model): + outputs = model[batch_old : batch_old + images.size()[0], : ] + batch_old = images.size()[0] + else: + outputs = model(images).to(device) + outputs = project_multiple_observations(proj_matrices, outputs) + out_model = torch.cat([out_model, outputs.to(device)]).to(device) + del outputs + #torch.cuda.empty_cache() + snapshots_red = torch.squeeze(out_model.flatten(1)).detach() + return snapshots_red + + +def tensor_reverse(tensor): + """ + Function that reverses the directions of a tensor + + :param torch.Tensor A: the input tensor with dimensions (d_1,d_2,...,d_n) + :return: input tensor with reversed dimensions (d_n,...,d_2,d_1) + :rtype: torch.Tensor + """ + incr_list = [i for i in range(len(tensor.shape))] + incr_list.reverse() + return torch.permute(tensor, tuple(incr_list)) + +def project_single_observation(proj_matrices, observation_tensor): + for i, _ in enumerate(observation_tensor.shape): + observation_tensor = torch.tensordot(proj_matrices[i], observation_tensor, ([1],[i])) + return tensor_reverse(observation_tensor) + +def project_multiple_observations(proj_matrices, observations_tensor): + for i in range(len(proj_matrices)): + observations_tensor = torch.tensordot(proj_matrices[i], observations_tensor, ([1],[i+1])) + return tensor_reverse(observations_tensor) + + +def Total_param(model, storage_per_param=4): + ''' + Function that computes the total number of parameters + + :param nn.Module model: part of the net in exam + :param int storage_per_param: memory needed to store a parameter. + Default value set at 4. + :return: total number of parameters + :rtype: int + ''' + total_params = 0 + for t in filter(lambda p: p.requires_grad, model.parameters()): + total_params += np.prod(t.data.cpu().numpy().shape) + return total_params / 2**20 * storage_per_param + +def Total_flops(model, device, is_PCE=False, p=2, red_dim=50): + ''' + Function that computes the total number of flops + + :param nn.Module model: part of the net in exam + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + :param bool is_PCE: Boolean value identifying the use of PCE + as input_ouput mapping. Default value set at False. + :param int p: degree polynomial used in PCE. + :param int red_dim: reduction dimension. Default value is + set at 50. + :return: total number of flops + :rtype: float + ''' + x = torch.ones([1, 3, 32, 32]).to(device) + flops = 0. + for _, m in model.named_modules(): + xold = x + if isinstance(m, nn.MaxPool2d): + x = m(x) + if isinstance(m, nn.Conv2d): + x = m(x) + flops += xold.shape[1]*x.shape[1:].numel()*\ + torch.tensor(m.kernel_size).prod() + if isinstance(m, nn.Linear): + flops += m.in_features * m.out_features + + if is_PCE: + flops += p * (model.PCE.in_features + nAS) #Basis function + return float(flops) / 10**6 + + +def compute_loss(model, device, test_loader, is_print=True, topk=[1], features=None): + ''' + Function that computes the top-k accuracy of model for dataset=test_loader + :param nn.Module model: reduced net + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + :param iterable test_loader: iterable object, it load the dataset. + It iterates over the given dataset, obtained combining a + dataset(images and labels) and a sampler. + :param bool is_print: + :param list top_k + :return float test_accuracy + ''' + model.eval() + model.to(device) + test_loss = 0 + + res = [] + maxk = max(topk) + batch_old = 0 + with torch.no_grad(): + for data, target in test_loader: + data, target = data.to(device), target.to(device) + batch = data.size()[0] + if features is None: + output = model(data) + else: + output = model(data, features=features[batch_old : batch_old + batch, :]) + batch_old = batch + test_loss += F.nll_loss(output, target, + reduction='sum').item() # sum up batch loss + # torch.tok Returns the k largest elements of the given + # input tensor along a given dimension. + _, pred = torch.topk(output, maxk, dim=1, largest=True, sorted=True) + pred = pred.t() + correct = pred.eq(target.view(1, -1).expand_as(pred)) + for k in topk: + correct_k = correct[:k].view(-1).float().sum(0, keepdim=True) + res.append(correct_k) + test_loss /= len(test_loader.sampler) + correct = torch.FloatTensor(res).view(-1, len(topk)).sum(dim=0) + test_accuracy = 100. * correct / len(test_loader.sampler) + for idx, k in enumerate(topk): + print(' Top {}: Accuracy: {}/{} ({:.2f}%)'.format( + k, correct[idx], len(test_loader.sampler), test_accuracy[idx])) + print('Loss Value:', test_loss) + if len(topk) == 1: + return test_accuracy[0] + else: + return test_accuracy + +def train_kd(student, + teacher, + device, + train_loader, + optimizer, + train_max_batch, + alpha=0.0, + temperature=1., + lr_decrease=None, + epoch=1, + features=None): + ''' + Function that retrains the model with knowledge distillation + when alpha=0, it reduced to the original training + :param nn.Module student: reduced net + :param nn.Module teacher: full net + :param torch.device device: object representing the device on + which a torch.Tensor is or will be allocated. + :param iterable train_loader: iterable object, it load the dataset for + training. It iterates over the given dataset, obtained combining a + dataset(images and labels) and a sampler. + :param optimizer + :param train_max_batch + :param float alpha: regularization parameter. Default value set to 0.0, + i.e. when the training is reduced to the original one + :param float temperature: temperature factor introduced. When T tends to + infinity all the classes have the same probability, whereas when T + tends to 0 the targets become one-hot labels. Default value set to 1. + :param lr_decrease: + :param int epoch: epoch number + :return: accuracy + ''' + student.train() + teacher.eval() + student.to(device) + teacher.to(device) + correct = 0.0 + batch_old = 0 + for batch_idx, (data, target) in enumerate(train_loader): + data, target = data.to(device), target.to(device) + batch = data.size()[0] + optimizer.zero_grad() + if features is None: + output = student(data) + else: + output = student(data, features[batch_old : batch_old + batch, :]) + output_teacher = teacher(data) + batch_old = batch + + # The Kullback-Leibler divergence loss measure + loss = nn.KLDivLoss()(F.log_softmax(output / temperature, dim=1),F.softmax(output_teacher / temperature, dim=1) + )*(alpha*temperature*temperature) + \ + F.cross_entropy(output, target) * (1. - alpha) + + loss.backward() + optimizer.step() + + pred = output.data.max(1, keepdim=True)[1] + correct += pred.eq(target.data.view_as(pred)).sum().item() + print('Train Loss kd:', loss.item() / len(train_loader.sampler)) + train_loss_val = loss.item() / len(train_loader.sampler) + accuracy = correct / len(train_loader.sampler) * 100.0 + if lr_decrease is not None: + for param_group in optimizer.param_groups: + param_group['lr'] *= lr_decrease + else: + for param_group in optimizer.param_groups: + param_group['lr'] = param_group['lr'] * (epoch) / (epoch + 1) + return accuracy, train_loss_val + + + +def save_checkpoint(epoch, model, path, optimizer): + ''' + Save model checkpoint. + :param scalar epoch: epoch number + :param list model: list of constructed classes that compose our network + :param str path: path to the checkpoint location + :param torch.Tensor optimizer: optimizer chosen + ''' + torch.save({ + 'epoch': epoch, + 'model_state_dict': model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict() + }, path) + diff --git a/tests/test_fnn.py b/tests/test_fnn.py new file mode 100644 index 0000000..d681a6b --- /dev/null +++ b/tests/test_fnn.py @@ -0,0 +1,24 @@ +from unittest import TestCase +import torch +import torch.nn as nn +from smithers.ml.models.fnn import FNN, training_fnn + +class Testfnn(TestCase): + def test_constructor(self): + fnn = FNN(50, 10, 20) + assert isinstance(fnn.model[0], nn.Linear) + self.assertEqual(fnn.n_input, 50) + self.assertEqual(fnn.n_output, 10) + + def test_forward(self): + fnn = FNN(50, 40, 10) + input_net = torch.rand(12, 50) + out = fnn(input_net) + self.assertEqual(list(out.size()), [12, 40]) + + def test_training(self): + fnn = FNN(30, 4, 40) + input_net = torch.rand(12, 30) + real_out = torch.rand(12, 4) + training_fnn(fnn, 10, input_net, real_out) + self.assertEqual(len(fnn.model), 3) diff --git a/tests/test_netadapter.py b/tests/test_netadapter.py new file mode 100644 index 0000000..b985950 --- /dev/null +++ b/tests/test_netadapter.py @@ -0,0 +1,52 @@ +from unittest import TestCase +import torch +import torch.nn as nn +from torch.utils.data import TensorDataset, DataLoader +from smithers.ml.models.netadapter import NetAdapter +from smithers.ml.utils_rednet import get_seq_model +from smithers.ml.models.vgg import VGG + +inps = torch.arange(100 * 3 * 224 * 224, + dtype=torch.float32).view(100, 3, 224, 224) +tgts = torch.arange(100, dtype=torch.float32) +train_dat = TensorDataset(inps, tgts) +train_load = DataLoader(train_dat, batch_size=2, pin_memory=True) +model = VGG(classifier='standard', init_weights='imagenet') +seq_model = get_seq_model(model) + + +class TestNetAdapter(TestCase): + def test_constructor(self): + netadapter = NetAdapter(3, 50, 'AS', 'PCE') + self.assertEqual(netadapter.cutoff_idx, 3) + self.assertEqual(netadapter.red_dim, 50) + self.assertEqual(netadapter.red_method, 'AS') + self.assertEqual(netadapter.inout_method, 'PCE') + + + def test_reducenet_01(self): + netadapter = NetAdapter(11, 50, 'AZ', 'PCE') + with self.assertRaises(ValueError): + netadapter.reduce_net(seq_model, train_dat, tgts, train_load, 40) + + def test_reducenet_02(self): + netadapter = NetAdapter(5, 50, 'POD', 'ANN') + with self.assertRaises(ValueError): + netadapter.reduce_net(seq_model, train_dat, tgts, train_load, 40) + + def test_reducenet_03(self): + netadapter = NetAdapter(5, 30, 'POD', 'FNN') + red_net = netadapter.reduce_net(seq_model, train_dat, tgts, train_load, 1000) + assert isinstance(red_net, nn.Module) + assert isinstance(red_net.proj_model, nn.Linear) + assert isinstance(red_net.inout_map, nn.Module) + + def test_reducenet_04(self): + netadapter = NetAdapter(5, 40, 'POD', 'FNN') + red_net = netadapter.reduce_net(seq_model, train_dat, tgts, train_load, 1000) + input_ = torch.arange(1 * 3 * 224 * 224, + dtype=torch.float32).view(1, 3, 224, 224) + out = red_net(input_) + self.assertEqual(list(out.size()), [1, 1000]) + + diff --git a/tests/test_pcemodel.py b/tests/test_pcemodel.py new file mode 100644 index 0000000..5cb61fe --- /dev/null +++ b/tests/test_pcemodel.py @@ -0,0 +1,60 @@ +from unittest import TestCase +import torch +import torch.nn as nn +import numpy as np +from smithers.ml.layers.pcemodel import PCEModel + +input_ = torch.rand(120, 50) +mean = torch.mean(input_, 0) +var = torch.var(input_, 0) + +class TestPECModel(TestCase): + def test_constructor_pce_01(self): + pce = PCEModel(mean, var) + assert isinstance(pce, nn.Module) + self.assertEqual(pce.d, 50) + self.assertEqual(pce.p, 2) + self.assertEqual(pce.device, 'cpu') + assert isinstance(pce.var, torch.Tensor) + assert isinstance(pce.mean, torch.Tensor) + assert isinstance(pce.oneDbasis, torch.Tensor) + assert isinstance(pce.idxset, torch.Tensor) + + def test_constructor_pce_02(self): + pce = PCEModel(mean, var, 40, 4) + assert isinstance(pce, nn.Module) + self.assertEqual(pce.d, 40) + self.assertEqual(pce.p, 4) + assert isinstance(pce.oneDbasis, torch.Tensor) + assert isinstance(pce.idxset, torch.Tensor) + + def test_normalbasis(self): + pce = PCEModel(mean, var, 40, 2) + B = pce.NormalBasis() + assert isinstance(B, torch.Tensor) + self.assertEqual(list(B.size()), [3, 3]) + + def test_forward(self): + pce = PCEModel(mean, var, 50, 3) + input1 = torch.rand(120, 50) + Phi = pce.forward(input1) + assert isinstance(Phi, torch.Tensor) + self.assertEqual(Phi.size()[0], 120) + + def test_training(self): + pce = PCEModel(mean, var, 50, 3) + input1 = torch.rand(120, 50) + out = torch.rand(120, 1) + label = torch.rand(120, 1) + coeff, approx, score = pce.Training(input1, out, label) + assert isinstance(coeff, np.ndarray) + assert isinstance(approx, float) + assert isinstance(score, float) + + def test_inference(self): + pce = PCEModel(mean, var, 50, 4) + input1 = torch.rand(120, 50) + coeff = torch.rand(1, 120) + inf_mat = pce.Inference(input1, coeff) + assert isinstance(inf_mat, torch.Tensor) + diff --git a/tests/test_rednet.py b/tests/test_rednet.py new file mode 100644 index 0000000..264a5b1 --- /dev/null +++ b/tests/test_rednet.py @@ -0,0 +1,48 @@ +from unittest import TestCase +import torch +import torch.nn as nn +from smithers.ml.models.rednet import RedNet +from smithers.ml.models.fnn import FNN + +if torch.cuda.is_available(): + device = torch.device('cuda') +else: + device = torch.device('cpu') + +class Testrednet(TestCase): + def test_constructor_0(self): + pre_model = nn.Sequential(nn.Linear(500, 300), nn.Linear(300, 200)) + proj_mat = torch.rand(200, 50) + inout_map = FNN(50, 5, 10) + rednet = RedNet(5, pre_model, proj_mat, inout_map) + assert isinstance(rednet.inout_map, nn.Module) + assert isinstance(rednet.proj_model, nn.Linear) + assert isinstance(rednet.premodel, nn.Sequential) + + def test_constructor_1(self): + pre_model = nn.Sequential(nn.Conv2d(500, 200, 3)) + proj_mat = torch.rand(200, 50) + inout_map = FNN(50, 5, 10) + rednet = RedNet(5, pre_model, proj_mat, inout_map) + assert isinstance(rednet.inout_map, nn.Module) + assert isinstance(rednet.proj_model, nn.Linear) + assert isinstance(rednet.premodel, nn.Sequential) + +# TO DO: MISSING TEST CONSTRUCTOR CASE PCE (LIST MODEL AND COEFF) + def test_forward_0(self): + pre_model = nn.Sequential(nn.Linear(650, 250), nn.Linear(250, 200)) + proj_mat = torch.rand(200, 50) + inout_map = FNN(50, 5, 10) + rednet = RedNet(5, pre_model, proj_mat, inout_map).to(device) + input_net = torch.rand(20, 650).to(device) + output_net = rednet(input_net) + self.assertEqual(list(output_net.size()), [20, 5]) + + def test_forward_1(self): + pre_model = nn.Sequential(nn.Conv2d(600, 200, 3)) + proj_mat = torch.rand(200, 80) + inout_map = FNN(80, 40, 50) + rednet = RedNet(5, pre_model, proj_mat, inout_map).to(device) + input_net = torch.rand(120, 600, 3, 3).to(device) + output_net = rednet(input_net) + self.assertEqual(list(output_net.size()), [120, 40]) diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 0000000..77a1d93 --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,167 @@ +from unittest import TestCase +import types +import torch +import torch.nn as nn +import numpy as np +from torch.utils.data import TensorDataset, DataLoader +from smithers.ml.utils_rednet import get_seq_model, PossibleCutIdx, spatial_gradients, projection, forward_dataset + +if torch.cuda.is_available(): + device = torch.device('cuda') +else: + device = torch.device('cpu') + +class Testutils(TestCase): + def test_get_seq_model_01(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg11', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + assert isinstance(seq_model, nn.Sequential) + self.assertEqual(len(seq_model), 30) + self.assertEqual(len(seq_model), len(model.features) + + len(model.classifier) + 2) + + def test_get_seq_model_02(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + assert isinstance(seq_model, nn.Sequential) + self.assertEqual(len(seq_model), 40) + self.assertEqual(len(seq_model), len(model.features) + + len(model.classifier) + 2) + + def test_possiblecutidx_01(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg11', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + cut_idx = PossibleCutIdx(seq_model) + assert isinstance(cut_idx, list) + self.assertEqual(len(cut_idx), 11) + + def test_possiblecutidx_02(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + cut_idx = PossibleCutIdx(seq_model) + assert isinstance(cut_idx, list) + self.assertEqual(len(cut_idx), 16) + + def test_constructor_spatial_gradients_01(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + pre_model = seq_model[:12] + post_model = seq_model[12:] + input_ = [(torch.rand(3, 224, 224), torch.IntTensor([5]))] + grad = spatial_gradients(input_, pre_model, post_model) + assert isinstance(grad, types.GeneratorType) + + def test_constructor_spatial_gradients_02(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + pre_model = seq_model[:11] + post_model = seq_model[11:] + input1 = (torch.rand(3, 224, 224), torch.IntTensor([5])) + input2 = (torch.rand(3, 224, 224), torch.IntTensor([9])) + input3 = (torch.rand(3, 224, 224), torch.IntTensor([3])) + inputs = [input1, input2, input3] + gradients = [] + for grad in spatial_gradients(inputs, pre_model, post_model): + gradients.append(grad) + assert isinstance(gradients[0], np.ndarray) + + def test_spatial_gradients_01(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + pre_model = seq_model[:11] + post_model = seq_model[11:] + input1 = (torch.rand(3, 224, 224), torch.IntTensor([4])) + input2 = (torch.rand(3, 224, 224), torch.IntTensor([8])) + input3 = (torch.rand(3, 224, 224), torch.IntTensor([1])) + inputs = [input1, input2, input3] + gradients = [] + for grad in spatial_gradients(inputs, pre_model, post_model): + gradients.append(grad) + self.assertEqual(grad.size, 256 * 56 * 56) + + def test_spatial_gradients_02(self): + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + pre_model = seq_model[:8] + post_model = seq_model[8:] + input1 = (torch.rand(3, 224, 224), torch.IntTensor([1])) + input2 = (torch.rand(3, 224, 224), torch.IntTensor([2])) + input3 = (torch.rand(3, 224, 224), torch.IntTensor([3])) + inputs = [input1, input2, input3] + gradients = [] + generator = spatial_gradients(inputs, pre_model, post_model) + for _ in range(2): + grad = next(generator) + gradients.append(grad) + self.assertEqual(len(gradients), 2) + + def test_spatial_gradients_03(self): + model = torch.hub.load('pytorch/vision:v0.9.0', 'vgg11', + pretrained=True) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + pre_model = seq_model[:9] + post_model = seq_model[9:] + input1 = (torch.rand(3, 224, 224), torch.IntTensor([6])) + input2 = (torch.rand(3, 224, 224), torch.IntTensor([7])) + input3 = (torch.rand(3, 224, 224), torch.IntTensor([0])) + inputs = [input1, input2, input3] + gradients = [] + generator = spatial_gradients(inputs, pre_model, post_model) + for _ in range(2, 3): + grad = next(generator) + gradients.append(grad) + self.assertEqual(len(gradients), 1) + + def test_projection(self): + inps = torch.arange(10 * 5, dtype=torch.float32).view(10, 5) + tgts = torch.arange(10 * 5, dtype=torch.float32).view(10, 5) + dataset = TensorDataset(inps, tgts) + data_loader = DataLoader(dataset, batch_size=2, pin_memory=True) + proj_mat = torch.rand(2400, 50).to(device) + matrix = torch.rand(10, 2400).to(device) + mat_red = projection(proj_mat, data_loader, matrix) + self.assertEqual(list(mat_red.size()), [10, 50]) + + def test_forwarddataset_01(self): + inps = torch.arange(10 * 3 * 224 * 224, + dtype=torch.float32).view(10, 3, 224, 224) + tgts = torch.arange(10, dtype=torch.float32) + dataset = TensorDataset(inps, tgts) + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True).to(device) + model.classifier_str = 'standard' + data_loader = DataLoader(dataset, batch_size=2, pin_memory=True) + out_model = forward_dataset(model, data_loader) + self.assertEqual(list(out_model.size()), [10, 1000]) + + def test_forwarddataset_02(self): + inps = torch.arange(50 * 3 * 224 * 224, + dtype=torch.float32).view(50, 3, 224, 224) + tgts = torch.arange(50, dtype=torch.float32) + dataset = TensorDataset(inps, tgts) + model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', + pretrained=True).to(device) + model.classifier_str = 'standard' + seq_model = get_seq_model(model) + pre_model = seq_model[:11] + data_loader = DataLoader(dataset, batch_size=2, pin_memory=True) + out_model = forward_dataset(pre_model, data_loader) + self.assertEqual(list(out_model.size()), [50, 256 * 56 * 56]) + diff --git a/tests/test_vgg.py b/tests/test_vgg.py new file mode 100644 index 0000000..c08914c --- /dev/null +++ b/tests/test_vgg.py @@ -0,0 +1,94 @@ +from unittest import TestCase +import torch.nn as nn +import torchvision.transforms.functional as FT + +from smithers.ml.models.vgg import VGG + +default_cfg = [ + 64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, + 512, 512, 'M' +] #vgg16 +vgg19_cfg = [ + 64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, + 'M', 512, 512, 512, 512, 'M' +] + +n_classes = 1000 + + +class Testvgg(TestCase): + def test_constuctor_empty(self): + net = VGG() + + def test_make_layers_vgg16(self): + net = VGG() + layers = net.make_layers() + assert len(layers) == 31 + + def test_make_layers_conv(self): + net = VGG() + layers = net.make_layers() + assert isinstance(layers[0], nn.Conv2d) + + def test_make_layers_vgg16bn(self): + net = VGG() + layers = net.make_layers(True) + assert len(layers) == 44 + + def test_make_layers_batch(self): + net = VGG() + layers = net.make_layers(True) + assert isinstance(layers[1], nn.BatchNorm2d) + + def test_make_layers_maxp(self): + net = VGG() + layers = net.make_layers(True) + assert isinstance(layers[6], nn.MaxPool2d) + + def test_constructor_arg(self): + net = VGG(vgg19_cfg, 'ssd', True, init_weights='random') + + def test_vgg16_cifar(self): + net = VGG(classifier='cifar') + + def test_ssd300(self): + net = VGG(classifier='ssd', init_weights='imagenet') + + def test_init_weights(self): + net = VGG(init_weights='random') + params = list(net.parameters()) + assert len(params) == 32 + + def test_init_weights_conv(self): + net = VGG(init_weights='random') + params = list(net.parameters()) + assert list(params[0].size()) == [64, 3, 3, 3] + + def test_init_weights_bias(self): + net = VGG(init_weights='random') + params = list(net.parameters()) + print(list(params[25].size())) + assert list(params[25].size()) == [512] + + def test_load_pretrained_weights_01(self): + net = VGG(init_weights='imagenet') + state_dict = net.load_pretrained_layers(None) + assert list(state_dict['features.0.bias'].size()) == [64] + assert list(state_dict['classifier.6.weight'].size()) == [1000, 4096] + + def test_load_pretrained_weights_02(self): + net = VGG(classifier='ssd', init_weights='imagenet') + state_dict = net.load_pretrained_layers(None) + assert list( + state_dict['classifier.0.weight'].size()) == [1024, 512, 3, 3] + + def test_load_pretrained_weights_03(self): + with self.assertRaises(RuntimeError): + VGG(vgg19_cfg, 'ssd', init_weights='imagenet') + + def test_load_pretrained_weights_04(self): + net = VGG(init_weights='imagenet', num_classes=4) + state_dict = net.load_pretrained_layers(None) + assert list(state_dict['features.0.bias'].size()) == [64] + assert list(state_dict['classifier.6.weight'].size()) == [4, 4096] +