def ex_2_1(X_train, y_train, X_test, y_test): """ Solution for exercise 2.1 :param X_train: Train set :param y_train: Targets for the train set :param X_test: Test set :param y_test: Targets for the test set :return: """ # >>> from sklearn.neural_network import MLPClassifier # >>> from sklearn.datasets import make_classification # >>> from sklearn.model_selection import train_test_split # >>> X, y = make_classification(n_samples=100, random_state=1) # >>> X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, # ... random_state=1) # >>> clf = MLPClassifier(random_state=1, max_iter=300).fit(X_train, y_train) # >>> clf.predict_proba(X_test[:1]) # array([[0.038..., 0.961...]]) # >>> clf.predict(X_test[:5, :]) # array([1, 0, 1, 0, 1]) # >>> clf.score(X_test, y_test) # 0.8... ## TODO train_accuracy = [0, 0, 0, 0, 0] test_accuracy = [0, 0, 0, 0, 0] clf = [0, 0, 0, 0, 0] for seed in range(1, 6): clf[seed - 1] = MLPClassifier(hidden_layer_sizes=(10, ), activation='tanh', max_iter=50, random_state=(seed * 3)) clf[seed - 1].fit(X_train, y_train) train_accuracy[seed - 1] = clf[seed - 1].score(X_train, y_train) test_accuracy[seed - 1] = clf[seed - 1].score(X_test, y_test) print(train_accuracy[seed - 1]) print(test_accuracy[seed - 1]) plot_boxplot(train_accuracy, test_accuracy) y_test_pred = clf[4].predict(X_test) confusion = confusion_matrix(y_test, y_test_pred) # plot misclass misclass_coun = 0 for ix, y in enumerate(y_test): if (y != y_test_pred[ix]): plot_image(X_test[ix]) misclass_coun += 1 if misclass_coun == 3: break # TODO: plot missclassified images based on confusion matrix print(confusion) # TODO: plot weights between input and hidden plot_hidden_layer_weights(clf[4].coefs_[0]) pass
def ex_2_1(input2, target2): """ Solution for exercise 2.1 :param input2: The input from dataset2 :param target2: The target from dataset2 :return: """ #declaring variables used for MLPClassifier hidden_layers = 6 solver_mode = 'adam' activation_mode = 'tanh' max_iter = 200 cf = MLPClassifier(hidden_layer_sizes=(hidden_layers, ), solver=solver_mode, activation=activation_mode, max_iter=max_iter) #training the classifier cf.fit(input2, target2[:, 1]) #calculate y_predicted and y_true for confusion matrix calculation #printing confusion matrix print(confusion_matrix(target2[:, 1], cf.predict(input2))) #plotting the hidden layer weights plot_hidden_layer_weights(cf.coefs_[0]) pass
def ex_2_1(input2, target2): ''' • Write code to train a feed-forward neural network with 1 hidden layers containing 6 hidden units for pose recognition. Use dataset2 for training after normalization, ‘adam’ as the training solver and train for 200 iterations. • Calculate the confusion matrix • Plot the weights between each input neuron and the hidden neurons to visualize what the network has learnt in the first layer. inote Use scikit-learn’s confusion_matrix function to to calculate the confusion matrix. Documentation for this can be found here inote You can use the coefs_ attribute of the model to read the weights. It is a list of length nlayers − 1 where the ith element in the list represents the weight matrix corresponding to layer i. inote Use the plot_hidden_layer_weights in nn_classification_plot.py to plot the hidden weights. ''' # dataset2 = normalize(input2) already done by main x_train = input2 y_train = target2[:, 1] # print(y_train) nn = MLPClassifier(solver='adam', activation='tanh', max_iter=200, hidden_layer_sizes=(6, )) nn.fit(x_train, y_train) cm = confusion_matrix(y_train, nn.predict(x_train)) plot_hidden_layer_weights(nn.coefs_[0]) print(cm) pass
def ex_2_1(input2, target2): """ Solution for exercise 2.1 :param input2: The input from dataset2 :param target2: The target from dataset2 :return: """ # parse target2 2nd column pose2 = [] for target in target2: pose2.append(target[1]) mlp = MLPClassifier(activation='tanh', hidden_layer_sizes=6) print("===========fit started===========") mlp.fit(input2, pose2) print("===========fit finished===========") print("classes_: ", mlp.classes_) print("n_layers_: ", mlp.n_layers_) plot_hidden_layer_weights(mlp.coefs_[0]) print("===========predict started===========") prediction = mlp.predict(input2) print("===========predict finished===========") cnf_matrix = confusion_matrix(pose2, prediction) print(cnf_matrix) return
def ex_2_1(input2, target2): ## TODO classifier = MLPClassifier(hidden_layer_sizes=(6, ), solver="adam", max_iter=200, activation="tanh") classifier.fit(input2, target2[:, 1]) con_mat = confusion_matrix(target2[:, 1], classifier.predict(input2)) plot_hidden_layer_weights(classifier.coefs_[0])
def ex_2_1(input2, target2): """ Solution for exercise 2.1 :param input2: The input from dataset2 :param target2: The target from dataset2 :return: """ ## TODO pose = target2[:,1] nn = MLPClassifier(hidden_layer_sizes=(6,) ,activation='tanh', max_iter=200) nn.fit(input2, pose) y_pred = nn.predict(input2) C = confusion_matrix(pose, y_pred, labels=None, sample_weight=None) plot_hidden_layer_weights(nn.coefs_[0]) return C
def ex_2_1(input2, target2): """ Solution for exercise 2.1 :param input2: The input from dataset2 :param target2: The target from dataset2 :return: """ ## TODO n_hidden_neurons = 6 nn = MLPClassifier(activation='tanh', solver='adam', max_iter=200, hidden_layer_sizes=(n_hidden_neurons,)) target = target2[:,2] ## Train the network nn.fit(input2, target) predictions = nn.predict(input2) C=confusion_matrix(target,predictions) hidden_layer_weights = nn.coefs_[0] plot_hidden_layer_weights(hidden_layer_weights) print(C)
def ex_2_1(input2, target2): target2 = np.transpose(target2) target2 = target2[1] nn = MLPClassifier(hidden_layer_sizes=(8, ), activation='tanh', solver='adam', max_iter=200) model = nn.fit(input2, target2) y_predict = model.predict(input2) C = confusion_matrix(y_predict, target2) print(C) hidden_layer_weights = model.coefs_ plot_hidden_layer_weights(hidden_layer_weights[0]) pass
def ex_2_1(input2, target2): """ Solution for exercise 2.1 :param input2: The input from dataset2 :param target2: The target from dataset2 :return: """ classifier = MLPClassifier(hidden_layer_sizes=(6, ), activation='tanh', solver='adam', max_iter=200) classifier.fit(input2, target2[:, 1]) pred2 = classifier.predict(input2) confmat = confusion_matrix(target2[:, 1], pred2) coefs = classifier.coefs_ print(confmat) plot_hidden_layer_weights(coefs[0]) ## TODO pass
def ex_2_2(input1, target1, input2, target2): target1 = np.transpose(target1) target1 = target1[0] target2 = np.transpose(target2) target2 = target2[0] acc_train = np.zeros((10, )) acc_test = np.zeros((10, )) max = -1 for i in range(10): nn = MLPClassifier(random_state=i, hidden_layer_sizes=(20, ), activation='tanh', solver='adam', max_iter=1000) model = nn.fit(input1, target1) acc_train[i] = model.score(input1, target1) acc_test[i] = model.score(input2, target2) if acc_test[i] > max: max = acc_test[i] y_predict = model.predict(input2) C = confusion_matrix(target2, y_predict) k = 0 for i, a in enumerate(target2): if a != y_predict[i] and k < 20: plot_image(input2[i]) k = k + 1 hidden_layer_weights = model.coefs_ plot_hidden_layer_weights(hidden_layer_weights[0]) plot_histogram_of_acc(acc_train, acc_test) print(C) pass
def ex_2_1(X_train, y_train, X_test, y_test): """ Solution for exercise 2.1 :param X_train: Train set :param y_train: Targets for the train set :param X_test: Test set :param y_test: Targets for the test set :return: """ randomSeed = np.random.randint(1, 100, 1) n_hidd = [100] score_train, score_test = [], [] best_score = 0 bestNetwork = MLPClassifier() classes = [ "T-shirt/top", "trousers/pants", "pullover shirt", "dress", "coat", "sandal", "shirt", "sneaker", "bag", "ankle boot" ] for n, n_h in enumerate(n_hidd): for s, seed in enumerate(randomSeed): nn = MLPClassifier(hidden_layer_sizes=(n_h, ), activation='tanh', max_iter=50, random_state=seed) nn.fit(X_train, y_train) scoretrain = nn.score(X_train, y_train) scoretest = nn.score(X_test, y_test) score_train.append(scoretrain) score_test.append(scoretest) if scoretest > best_score: bestNetwork = nn best_score = scoretest print( 100 / (len(n_hidd) * len(randomSeed)) * ((n * len(randomSeed)) + (s + 1)), "%") plot_boxplot(score_train, score_test) prediction = bestNetwork.predict(X_test) confusionMatrix = confusion_matrix(y_test, prediction) #confusion matrix print("Confusion matrix:") print(classes) print(confusionMatrix) #Weight print(len(bestNetwork.coefs_)) plot_hidden_layer_weights(bestNetwork.coefs_[0]) print("Misclassified Pictures") falseList = prediction == y_test indexPosList = [] for i, index in enumerate(falseList): if index == False: indexPosList.append(i) print(indexPosList) for i in range(5): print("MLPClassifer think it is", prediction[indexPosList[i]] + 1, "but it is", y_test[indexPosList[i]] + 1) plot_image(X_test[indexPosList[i]]) ## TODO pass