def main(): """ Task Main """ # download and parse Fashion MNIST training set train_set = datasets.FashionMNIST( root='./data', train=True, download=True, transform=transforms.Compose([ transforms.ToTensor() ]) ) # download and parse Fashion MNIST testing set test_set = datasets.FashionMNIST( root='./data', train=False, download=True, transform=transforms.Compose([ transforms.ToTensor() ]) ) # instantiate train data loader train_data_loader = torch.utils.data.DataLoader(train_set, batch_size=1000) # instantiate test data loader test_data_loader = torch.utils.data.DataLoader(test_set, batch_size=1000) # instantiate multilayer perceptron neural network mlp = MLP() # train the multilayer perceptron neural network mlp_performance = mlp.train( train_data_loader, learning_rate=0.01, n_epochs=20) # test the multilayer perceptron neural network mlp.test(test_data_loader) # instantiate base architecture convolutional neural network base_cnn = BaseCNN() # train the base architecture convolutional neural network base_cnn_performance = base_cnn.train( train_data_loader, learning_rate=0.01, n_epochs=20) # test the base architecture convolutional neural network base_cnn.test(test_data_loader) # instantiate the variant 1 architecture convolutional neural network cnn1 = CNN1() # train the variant 1 architecture convolutional neural network cnn1_performance = cnn1.train( train_data_loader, learning_rate=0.01, n_epochs=20) # test the variant 1 architecture convolutional neural network cnn1.test(test_data_loader) # instantiate the variant 2 architecture convolutional neural network cnn2 = CNN2() # train the variant 2 architecture convolutional neural network cnn2_performance = cnn2.train( train_data_loader, learning_rate=0.01, n_epochs=20) # test the variant 2 architecture convolutional neural network cnn2.test(test_data_loader) # plot the test results plt.plot(range(20), mlp_performance, color='black', label='MLP') plt.plot(range(20), base_cnn_performance, color='red', label='Base CNN') plt.plot(range(20), cnn1_performance, color='green', label='CNN 1') plt.plot(range(20), cnn2_performance, color='blue', label='CNN 2') plt.title('Neural Network Image Classification Accuracy') plt.xlabel('epochs') plt.ylabel('accuracy') plt.legend() plt.show()
class Classifier(object): def __init__(self, task_type='transitivity', classifier_type='mlp'): self.task_type = task_type self.task_undefined = False self.classifier_type = classifier_type def get_xys(self, x_dict, y_dict): x_list = [] y_list = [] x_ids = [] for key in x_dict: y_avc = y_dict[key[:2]] yItem = self.get_task_y(y_avc, self.task_type) if yItem is not None: y_list.append(yItem) x_list.append(x_dict[key]) x_ids.append(key) return x_ids, x_list, y_list def get_y_gold(self, x_ids, y_gold): return [ self.get_task_y(y_gold[x_id[:2]], self.task_type) for x_id in x_ids ] def get_task_y(self, avc, task_type): #this should not be here or class misnamed if task_type == "transitivity": return sum([avc.has_dobj, avc.has_iobj]) if task_type == "intransitive": return sum([avc.has_dobj, avc.has_iobj]) == 0 elif task_type == "dobj": return int(avc.has_dobj) elif task_type == "iobj": return int(avc.has_iobj) elif task_type == "subj": return int(avc.has_subj) elif task_type == "subj_num": return avc.subj_num elif task_type == "subj_pers": return avc.subj_pers elif task_type == 'subj_n_pers': if avc.subj_num == None and avc.subj_pers == None: return None else: return "".join([ str(i) for i in filter(None, [avc.subj_num, avc.subj_pers]) ]) else: raise Exception("Task unknown: %s" % task_type) def get_train_info(self, x_train, y_train): #check that we have at least 2 classes and 10 training examples if len(set(y_train)) < 2 or len(x_train) < 10: self.task_undefined = True self.trainsize = 0 else: self.trainsize = len(x_train) def train(self, train_x, train_y): x_ids, x_train, y_train = self.get_xys(train_x, train_y) self.get_train_info(x_train, y_train) if self.task_undefined: return if self.classifier_type == 'perceptron': #averaged perceptron from sklearn.linear_model import SGDClassifier self.model = SGDClassifier(loss="perceptron", eta0=1, learning_rate="constant", penalty=None, average=10) self.model.fit(x_train, y_train) elif self.classifier_type == 'mlp': from multilayer_perceptron import MLP data = zip(x_train, y_train) labels = set(y_train) input_size = len(x_train[0]) out_size = len(labels) hidden_size = input_size # same as Adi et al. self.model = MLP(input_size, hidden_size, out_size, labels, epochs=100) self.model.train(data) def predict(self, test_x, test_y): if not self.task_undefined: x_ids, x_test, y_test = self.get_xys(test_x, test_y) y_pred = self.model.predict(x_test) self.testsize = len(x_test) #write pred to file return x_ids, y_pred else: self.testsize = 0 return None, None def evaluate(self, x_ids, pred, all_y_gold): if x_ids is not None and pred is not None: y_gold = self.get_y_gold(x_ids, all_y_gold) return accuracy_score(y_gold, pred) else: return np.nan def majority_baseline(self, train_x, train_y, test_x, test_y): x_ids, x_train, y_train = self.get_xys(train_x, train_y) x_ids, x_test, y_test = self.get_xys(test_x, test_y) y_maj = max(y_train, key=y_train.count) y_maj_pred = [y_maj for i in range(len(y_test))] return accuracy_score(y_test, y_maj_pred)