def main(main_params, optimization_type="minibatch_sgd"): ### set the random seed ### np.random.seed(int(main_params['random_seed'])) ### data processing ### Xtrain, Ytrain, Xval, Yval, _, _ = data_loader_mnist( dataset=main_params['input_file']) N_train, d = Xtrain.shape N_val, _ = Xval.shape index = np.arange(10) unique, counts = np.unique(Ytrain, return_counts=True) counts = dict(zip(unique, counts)).values() trainSet = DataSplit(Xtrain, Ytrain) valSet = DataSplit(Xval, Yval) ### building/defining MLP ### """ In this script, we are going to build a MLP for a 10-class classification problem on MNIST. The network structure is input --> linear --> relu --> dropout --> linear --> softmax_cross_entropy loss the hidden_layer size (num_L1) is 1000 the output_layer size (num_L2) is 10 """ model = dict() num_L1 = 1000 num_L2 = 10 # experimental setup num_epoch = int(main_params['num_epoch']) minibatch_size = int(main_params['minibatch_size']) # optimization setting: _alpha for momentum, _lambda for weight decay _learning_rate = float(main_params['learning_rate']) _step = 10 _alpha = float(main_params['alpha']) _lambda = float(main_params['lambda']) _dropout_rate = float(main_params['dropout_rate']) _activation = main_params['activation'] if _activation == 'relu': act = relu else: act = tanh # create objects (modules) from the module classes model['L1'] = linear_layer(input_D=d, output_D=num_L1) model['nonlinear1'] = act() model['drop1'] = dropout(r=_dropout_rate) model['L2'] = linear_layer(input_D=num_L1, output_D=num_L2) model['loss'] = softmax_cross_entropy() # Momentum if _alpha > 0.0: momentum = add_momentum(model) else: momentum = None train_acc_record = [] val_acc_record = [] train_loss_record = [] val_loss_record = [] ### run training and validation ### for t in range(num_epoch): print('At epoch ' + str(t + 1)) if (t % _step == 0) and (t != 0): _learning_rate = _learning_rate * 0.1 idx_order = np.random.permutation(N_train) train_acc = 0.0 train_loss = 0.0 train_count = 0 val_acc = 0.0 val_count = 0 val_loss = 0.0 for i in range(int(np.floor(N_train / minibatch_size))): # get a mini-batch of data x, y = trainSet.get_example(idx_order[i * minibatch_size:(i + 1) * minibatch_size]) ### forward ### a1 = model['L1'].forward(x) h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train=True) a2 = model['L2'].forward(d1) loss = model['loss'].forward(a2, y) ### backward ### grad_a2 = model['loss'].backward(a2, y) ###################################################################################### # TODO: Call the backward methods of every layer in the model in reverse order # We have given the first and last backward calls # Do not modify them. ###################################################################################### grad_d1 = model['L2'].backward(d1, grad_a2) grad_h1 = model['drop1'].backward(h1, grad_d1) grad_a1 = model['nonlinear1'].backward(a1, grad_h1) #raise NotImplementedError("Not Implemented BACKWARD PASS in main()") ###################################################################################### # NOTE: DO NOT MODIFY CODE BELOW THIS, until next TODO ###################################################################################### grad_x = model['L1'].backward(x, grad_a1) ### gradient_update ### model = miniBatchGradientDescent(model, momentum, _lambda, _alpha, _learning_rate) ### Computing training accuracy and obj ### for i in range(int(np.floor(N_train / minibatch_size))): x, y = trainSet.get_example( np.arange(i * minibatch_size, (i + 1) * minibatch_size)) ### forward ### ###################################################################################### # TODO: Call the forward methods of every layer in the model in order # Check above forward code # Make sure to keep train as False ###################################################################################### #raise NotImplementedError("Not Implemented COMPUTING TRAINING ACCURACY in main()") a1 = model['L1'].forward(x) h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train=False) a2 = model['L2'].forward(d1) loss = model['loss'].forward(a2, y) ###################################################################################### # NOTE: DO NOT MODIFY CODE BELOW THIS, until next TODO ###################################################################################### loss = model['loss'].forward(a2, y) train_loss += loss train_acc += np.sum(predict_label(a2) == y) train_count += len(y) train_loss = train_loss train_acc = train_acc / train_count train_acc_record.append(train_acc) train_loss_record.append(train_loss) print('Training loss at epoch ' + str(t + 1) + ' is ' + str(train_loss)) print('Training accuracy at epoch ' + str(t + 1) + ' is ' + str(train_acc)) ### Computing validation accuracy ### for i in range(int(np.floor(N_val / minibatch_size))): x, y = valSet.get_example( np.arange(i * minibatch_size, (i + 1) * minibatch_size)) ### forward ### ###################################################################################### # TODO: Call the forward methods of every layer in the model in order # Check above forward code # Make sure to keep train as False ###################################################################################### #raise NotImplementedError("Not Implemented COMPUTING VALIDATION ACCURACY in main()") a1 = model['L1'].forward(x) h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train=False) a2 = model['L2'].forward(d1) loss = model['loss'].forward(a2, y) ###################################################################################### # NOTE: DO NOT MODIFY CODE BELOW THIS, until next TODO ###################################################################################### loss = model['loss'].forward(a2, y) val_loss += loss val_acc += np.sum(predict_label(a2) == y) val_count += len(y) val_loss_record.append(val_loss) val_acc = val_acc / val_count val_acc_record.append(val_acc) print('Validation accuracy at epoch ' + str(t + 1) + ' is ' + str(val_acc)) # save file json.dump( { 'train': train_acc_record, 'val': val_acc_record }, open( 'MLP_lr' + str(main_params['learning_rate']) + '_m' + str(main_params['alpha']) + '_w' + str(main_params['lambda']) + '_d' + str(main_params['dropout_rate']) + '_a' + str(main_params['activation']) + '.json', 'w')) print('Finish running!') return train_loss_record, val_loss_record
def main(main_params, optimization_type="minibatch_sgd"): # data processing data = pd.read_csv("dataset/london_merged.csv") data.drop(['timestamp'], inplace=True, axis=1) bins = [-1, 1000, 2000, 3000, 4000, 100000] dpy = data['cnt'].to_numpy() r = pd.cut(dpy, bins) data_y = r.codes data.drop(['cnt'], inplace=True, axis=1) # Normalization data = (data - data.min()) / (data.max() - data.min()) data = data.to_numpy() x_train, x_val, y_train, y_val = train_test_split(data, data_y, test_size=0.33, random_state=int(main_params['random_seed'])) N_train, d = x_train.shape N_val, _ = x_val.shape trainSet = DataSplit(x_train, y_train) valSet = DataSplit(x_val, y_val) # building/defining model # experimental setup num_epoch = int(main_params['num_epoch']) minibatch_size = int(main_params['minibatch_size']) # optimization setting: _alpha for momentum, _lambda for weight decay _learning_rate = float(main_params['learning_rate']) _step = 10 _alpha = float(main_params['alpha']) _lambda = float(main_params['lambda']) _dropout_rate = float(main_params['dropout_rate']) _activation = main_params['activation'] if _activation == 'relu': act = relu else: act = tanh # The network structure is input --> linear --> relu --> dropout --> linear --> softmax_cross_entropy loss # num_L1:the hidden_layer1 size # num_L2:the hidden_layer2 size # num_L3:the output_layer size model = dict() num_L1 = 100 num_L2 = 50 num_L3 = 5 # create objects (modules) from the module classes model['L1'] = linear_layer(input_D=d, output_D=num_L1) model['nonlinear1'] = act() model['drop1'] = dropout(r=_dropout_rate) model['L2'] = linear_layer(input_D=num_L1, output_D=num_L2) model['nonlinear2'] = act() model['L3'] = linear_layer(input_D=num_L2, output_D=num_L3) model['loss'] = softmax_cross_entropy() # Momentum if _alpha > 0.0: momentum = add_momentum(model) else: momentum = None train_acc_record = [] val_acc_record = [] train_loss_record = [] val_loss_record = [] # training & validation for t in range(num_epoch): if (t % _step == 0) and (t != 0): _learning_rate = _learning_rate * 0.1 idx_order = np.random.permutation(N_train) train_acc = 0.0 train_loss = 0.0 train_count = 0 val_acc = 0.0 val_count = 0 val_loss = 0.0 for i in range(int(np.floor(N_train / minibatch_size))): # get a mini-batch of data x, y = trainSet.get_example(idx_order[i * minibatch_size: (i + 1) * minibatch_size]) # forward a1 = model['L1'].forward(x) h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train=True) a2 = model['L2'].forward(d1) h2 = model['nonlinear2'].forward(a2) a3 = model['L3'].forward(h2) loss = model['loss'].forward(a3, y) # backward grad_a3 = model['loss'].backward(a3, y) grad_h2 = model['L3'].backward(h2, grad_a3) grad_a2 = model['nonlinear2'].backward(a2, grad_h2) grad_d1 = model['L2'].backward(d1, grad_a2) grad_h1 = model['drop1'].backward(h1, grad_d1) grad_a1 = model['nonlinear1'].backward(a1, grad_h1) grad_x = model['L1'].backward(x, grad_a1) # update gradient model = miniBatchGradientDescent(model, momentum, _lambda, _alpha, _learning_rate) # training accuracy for i in range(int(np.floor(N_train / minibatch_size))): x, y = trainSet.get_example(np.arange(i * minibatch_size, (i + 1) * minibatch_size)) # forward a1 = model['L1'].forward(x) h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train=False) a2 = model['L2'].forward(d1) h2 = model['nonlinear2'].forward(a2) a3 = model['L3'].forward(h2) loss = model['loss'].forward(a3, y) train_loss += loss train_acc += np.sum(predict_label(a3) == y) train_count += len(y) train_loss = train_loss train_acc = train_acc / train_count train_acc_record.append(train_acc) train_loss_record.append(train_loss) # validation accuracy for i in range(int(np.floor(N_val / minibatch_size))): x, y = valSet.get_example(np.arange(i * minibatch_size, (i + 1) * minibatch_size)) # forward a1 = model['L1'].forward(x) h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train=False) a2 = model['L2'].forward(d1) h2 = model['nonlinear2'].forward(a2) a3 = model['L3'].forward(h2) loss = model['loss'].forward(a3, y) val_loss += loss val_acc += np.sum(predict_label(a3) == y) val_count += len(y) val_loss_record.append(val_loss) val_acc = val_acc / val_count val_acc_record.append(val_acc) print('At epoch ' + str(t + 1)) print('Training loss at epoch ' + str(t + 1) + ' is ' + str(train_loss)) print('Training accuracy at epoch ' + str(t + 1) + ' is ' + str(train_acc)) print('Validation accuracy at epoch ' + str(t + 1) + ' is ' + str(val_acc)) index = [int(i+1) for i in range(num_epoch)] plt.figure() plt.grid() plt.plot(index, train_acc_record, color='b', label='train_acc') plt.plot(index, val_acc_record, color='darkorange', label='valadation_acc') plt.xlabel('training epoch') plt.ylabel('accuracy') plt.legend() plt.show() return train_acc_record, val_acc_record
results[previous_numFrames:previous_numFrames + num_frames] = model.predict( X_test[previous_numFrames:previous_numFrames + num_frames, :, :, :]) s_counter = 0 for j in range(previous_numFrames, previous_numFrames + num_frames): #normalize the results total = results[j, :].sum() results[j, :] = results[j, :] / total print('Percentage of genre prediction for seconds ' + str(20 + s_counter * 30) + ' to ' + str(20 + (s_counter + 1) * 30) + ': ') print(sort_result(tags, results[j, :].tolist())) predicted_label_frames = predict_label(results[j, :]) predicted_labels_frames[n] = predicted_label_frames s_counter += 1 n += 1 print('\n', 'Mean genre of the song: ') results_song = results[previous_numFrames:previous_numFrames + num_frames] mean = results_song.mean(0) sort_result(tags, mean.tolist()) predicted_label_mean = predict_label(mean) predicted_labels_mean[i] = predicted_label_mean print('\n', 'The predicted music genre for the song is', str(tags[predicted_label_mean]), '!\n')
def main(main_params, optimization_type="minibatch_sgd"): ### set the random seed ### np.random.seed(int(main_params['random_seed'])) ### data processing ### Xtrain, Ytrain, Xval, Yval , _, _ = data_loader_mnist(dataset = main_params['input_file']) N_train, d = Xtrain.shape N_val, _ = Xval.shape index = np.arange(10) unique, counts = np.unique(Ytrain, return_counts=True) counts = dict(zip(unique, counts)).values() trainSet = DataSplit(Xtrain, Ytrain) valSet = DataSplit(Xval, Yval) model = dict() num_L1 = 1000 num_L2 = 10 num_epoch = int(main_params['num_epoch']) minibatch_size = int(main_params['minibatch_size']) # optimization setting: _alpha for momentum, _lambda for weight decay _learning_rate = float(main_params['learning_rate']) _step = 10 _alpha = float(main_params['alpha']) _lambda = float(main_params['lambda']) _dropout_rate = float(main_params['dropout_rate']) _activation = main_params['activation'] if _activation == 'relu': act = relu else: act = tanh # create objects (modules) from the module classes model['L1'] = linear_layer(input_D = d, output_D = num_L1) model['nonlinear1'] = act() model['drop1'] = dropout(r = _dropout_rate) model['L2'] = linear_layer(input_D = num_L1, output_D = num_L2) model['loss'] = softmax_cross_entropy() # Momentum if _alpha > 0.0: momentum = add_momentum(model) else: momentum = None train_acc_record = [] val_acc_record = [] train_loss_record = [] val_loss_record = [] ### run training and validation ### for t in range(num_epoch): print('At epoch ' + str(t + 1)) if (t % _step == 0) and (t != 0): _learning_rate = _learning_rate * 0.1 idx_order = np.random.permutation(N_train) train_acc = 0.0 train_loss = 0.0 train_count = 0 val_acc = 0.0 val_count = 0 val_loss = 0.0 for i in range(int(np.floor(N_train / minibatch_size))): # get a mini-batch of data x, y = trainSet.get_example(idx_order[i * minibatch_size : (i + 1) * minibatch_size]) ### forward ### a1 = model['L1'].forward(x) h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train = True) a2 = model['L2'].forward(d1) loss = model['loss'].forward(a2, y) ### backward ### grad_d1 = model['L2'].backward(d1, grad_a2) grad_h1 = model['drop1'].backward(h1, grad_d1) grad_a1 = model['nonlinear1'].backward(a1, grad_h1) ###################################################################################### grad_x = model['L1'].backward(x, grad_a1) ### gradient_update ### model = miniBatchGradientDescent(model, momentum, _lambda, _alpha, _learning_rate) ### Computing training accuracy and obj ### for i in range(int(np.floor(N_train / minibatch_size))): a1 = model['L1'].forward(x) h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train = False) a2 = model['L2'].forward(d1) loss = model['loss'].forward(a2, y) train_loss += loss train_acc += np.sum(predict_label(a2) == y) train_count += len(y) train_loss = train_loss train_acc = train_acc / train_count train_acc_record.append(train_acc) train_loss_record.append(train_loss) print('Training loss at epoch ' + str(t + 1) + ' is ' + str(train_loss)) print('Training accuracy at epoch ' + str(t + 1) + ' is ' + str(train_acc)) ### Computing validation accuracy ### for i in range(int(np.floor(N_val / minibatch_size))): x, y = valSet.get_example(np.arange(i * minibatch_size, (i + 1) * minibatch_size)) a1 = model['L1'].forward(x) h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train = False) a2 = model['L2'].forward(d1) ###################################################################################### loss = model['loss'].forward(a2, y) val_loss += loss val_acc += np.sum(predict_label(a2) == y) val_count += len(y) val_loss_record.append(val_loss) val_acc = val_acc / val_count val_acc_record.append(val_acc) print('Validation accuracy at epoch ' + str(t + 1) + ' is ' + str(val_acc))
def run(path): # Parameters to set TEST = 1 LOAD_MODEL = 0 LOAD_WEIGHTS = 1 MULTIFRAMES = 1 time_elapsed = 0 # GTZAN Dataset Tags tags = [ 'blues', 'classical', 'country', 'disco', 'hiphop', 'jazz', 'metal', 'pop', 'reggae', 'rock' ] tags = np.array(tags) # Paths to set model_name = "example_model" model_path = "models_trained/" + model_name + "/" weights_path = "models_trained/" + model_name + "/weights/" test_songs_list = path #if(vid_id == None): # test_songs_list = "./music" #else: # test_songs_list = "./music2" # Initialize model model = MusicTaggerCRNN(weights=None, input_tensor=(1, 96, 1366)) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) if LOAD_WEIGHTS: model.load_weights(weights_path + 'crnn_net_gru_adam_ours_epoch_40.h5') #model.summary() X_test, num_frames_test = extract_melgrams(test_songs_list, MULTIFRAMES, process_all_song=False, num_songs_genre='') num_frames_test = np.array(num_frames_test) t0 = time.time() print '\n--------- Predicting ---------', '\n' results = np.zeros((X_test.shape[0], tags.shape[0])) predicted_labels_mean = np.zeros((num_frames_test.shape[0], 1)) predicted_labels_frames = np.zeros((X_test.shape[0], 1)) song_paths = os.listdir(test_songs_list) previous_numFrames = 0 n = 0 for i in range(0, num_frames_test.shape[0]): print 'Song number' + str(i) + ': ' + song_paths[i] num_frames = num_frames_test[i] print 'Num_frames of 30s: ', str(num_frames), '\n' results[previous_numFrames:previous_numFrames + num_frames] = model.predict( X_test[previous_numFrames:previous_numFrames + num_frames, :, :, :]) s_counter = 0 for j in range(previous_numFrames, previous_numFrames + num_frames): #normalize the results total = results[j, :].sum() results[j, :] = results[j, :] / total print 'Percentage of genre prediction for seconds '+ str(20+s_counter*30) + ' to ' \ + str(20+(s_counter+1)*30) + ': ' sort_result(tags, results[j, :].tolist()) predicted_label_frames = predict_label(results[j, :]) predicted_labels_frames[n] = predicted_label_frames s_counter += 1 n += 1 print '\n', 'Mean genre of the song: ' results_song = results[previous_numFrames:previous_numFrames + num_frames] mean = results_song.mean(0) sort_result(tags, mean.tolist()) predicted_label_mean = predict_label(mean) predicted_labels_mean[i] = predicted_label_mean print '\n', 'The predicted music genre for the song is', str( tags[predicted_label_mean]), '!\n' previous_numFrames = previous_numFrames + num_frames print '************************************************************************************************' # colors = ['b','g','c','r','m','k','y','#ff1122','#5511ff','#44ff22'] # fig, ax = plt.subplots() # index = np.arange(tags.shape[0]) # opacity = 1 # bar_width = 0.2 # #print mean.tolist() # #for g in range(0, tags.shape[0]): # plt.bar(left=index, height=mean, width=bar_width, alpha=opacity, color=colors) # # plt.xlabel('Genres') # plt.ylabel('Percentage') # plt.title('Scores by genre') # plt.xticks(index + bar_width / 2, tags) # plt.tight_layout() # fig.autofmt_xdate() # plt.savefig('genres_prediction.png') return tags[predicted_label_mean], song_paths[0], mean.tolist()
def main(main_params, optimization_type="minibatch_sgd"): np.random.seed(int(main_params['random_seed'])) Xtrain, Ytrain, Xval, Yval, _, _ = data_loader_mnist( dataset=main_params['input_file']) N_train, d = Xtrain.shape N_val, _ = Xval.shape index = np.arange(10) unique, counts = np.unique(Ytrain, return_counts=True) counts = dict(zip(unique, counts)).values() trainSet = DataSplit(Xtrain, Ytrain) valSet = DataSplit(Xval, Yval) model = dict() num_L1 = 1000 num_L2 = 10 num_epoch = int(main_params['num_epoch']) minibatch_size = int(main_params['minibatch_size']) _learning_rate = float(main_params['learning_rate']) _step = 10 _alpha = float(main_params['alpha']) _lambda = float(main_params['lambda']) _dropout_rate = float(main_params['dropout_rate']) _activation = main_params['activation'] if _activation == 'relu': act = relu else: act = tanh model['L1'] = linear_layer(input_D=d, output_D=num_L1) model['nonlinear1'] = act() model['drop1'] = dropout(r=_dropout_rate) model['L2'] = linear_layer(input_D=num_L1, output_D=num_L2) model['loss'] = softmax_cross_entropy() # Momentum if _alpha > 0.0: momentum = add_momentum(model) else: momentum = None train_acc_record = [] val_acc_record = [] train_loss_record = [] val_loss_record = [] for t in range(num_epoch): print('At epoch ' + str(t + 1)) if (t % _step == 0) and (t != 0): _learning_rate = _learning_rate * 0.1 idx_order = np.random.permutation(N_train) train_acc = 0.0 train_loss = 0.0 train_count = 0 val_acc = 0.0 val_count = 0 val_loss = 0.0 for i in range(int(np.floor(N_train / minibatch_size))): # get a mini-batch of data x, y = trainSet.get_example(idx_order[i * minibatch_size:(i + 1) * minibatch_size]) a1 = model['L1'].forward(x) h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train=True) a2 = model['L2'].forward(d1) a2 = model['L2'].forward(h1) loss = model['loss'].forward(a2, y) grad_a2 = model['loss'].backward(a2, y) l2_backward = model['L2'].backward(d1, grad_a2) drop1_backward = model['drop1'].backward(h1, l2_backward) nonlinear1_backward = model['nonlinear1'].backward( a1, drop1_backward) grad_x = model['L1'].backward(x, nonlinear1_backward) model = miniBatchGradientDescent(model, momentum, _lambda, _alpha, _learning_rate) for i in range(int(np.floor(N_train / minibatch_size))): x, y = trainSet.get_example( np.arange(i * minibatch_size, (i + 1) * minibatch_size)) a1 = model['L1'].forward(x) h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train=False) a2 = model['L2'].forward(d1) loss = model['loss'].forward(a2, y) loss = model['loss'].forward(a2, y) train_loss += loss train_acc += np.sum(predict_label(a2) == y) train_count += len(y) train_loss = train_loss train_acc = train_acc / train_count train_acc_record.append(train_acc) train_loss_record.append(train_loss) print('Training loss at epoch ' + str(t + 1) + ' is ' + str(train_loss)) print('Training accuracy at epoch ' + str(t + 1) + ' is ' + str(train_acc)) for i in range(int(np.floor(N_val / minibatch_size))): x, y = valSet.get_example( np.arange(i * minibatch_size, (i + 1) * minibatch_size)) a1 = model['L1'].forward(x) h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train=False) a2 = model['L2'].forward(d1) loss = model['loss'].forward(a2, y) loss = model['loss'].forward(a2, y) val_loss += loss val_acc += np.sum(predict_label(a2) == y) val_count += len(y) val_loss_record.append(val_loss) val_acc = val_acc / val_count val_acc_record.append(val_acc) print('Validation accuracy at epoch ' + str(t + 1) + ' is ' + str(val_acc)) json.dump( { 'train': train_acc_record, 'val': val_acc_record }, open( 'MLP_lr' + str(main_params['learning_rate']) + '_m' + str(main_params['alpha']) + '_w' + str(main_params['lambda']) + '_d' + str(main_params['dropout_rate']) + '_a' + str(main_params['activation']) + '.json', 'w')) print('Finish running!') return train_loss_record, val_loss_record
def main(main_params, optimization_type="minibatch_sgd"): ### set the random seed ### np.random.seed(int(main_params['random_seed'])) USAGE = 'neuralNetworkMT.py <number of neurons in hidden layer>' \ ' <max number of Iterations> <train data> <test data>' # if len(sys.argv) != 5: # print(USAGE) # else: # num_neurons = int(sys.argv[1]) # num_iteration = int(sys.argv[2]) # train_data = sys.argv[3] # test_data = sys.argv[4] train_data = 'downgesture_train.list' test_data = 'downgesture_test.list' num_neurons = 100 num_iteration = 1000 # read input data and separate to 'down' and 'not_down' gestures files print("start reading input text files") train_files_label1, train_files_label0 = parse_file_list(train_data) test_files_label1, test_files_label0 = parse_file_list(test_data) print("start reading input pictures files") data_one_train = read_pgm_image(train_files_label1, 1) data_zero_train = read_pgm_image(train_files_label0, 0) data_one_test = read_pgm_image(test_files_label1, 1) data_zero_test = read_pgm_image(test_files_label0, 0) # combine pgm data with corresponding labels in train and test data_train = np.concatenate((data_one_train, data_zero_train), axis=0) data_test = np.concatenate((data_one_test, data_zero_test), axis=0) # shuffle and prepare data print("start shuffling and splitting data") np.random.seed(7) np.random.shuffle(data_train) # prepare data Xtrain = data_train[:, :-1] Ytrain = data_train[:, -1] Xval = data_test[:, :-1] Yval = data_test[:, -1] ### data processing ### # Xtrain, Ytrain, Xval, Yval , _, _ = data_loader_mnist(dataset = main_params['input_file']) N_train, d = Xtrain.shape N_val, _ = Xval.shape index = np.arange(10) unique, counts = np.unique(Ytrain, return_counts=True) counts = dict(zip(unique, counts)).values() trainSet = DataSplit(Xtrain, Ytrain) valSet = DataSplit(Xval, Yval) ### building/defining MLP ### """ In this script, we are going to build a MLP for a 10-class classification problem on MNIST. The network structure is input --> linear --> relu --> dropout --> linear --> softmax_cross_entropy loss the hidden_layer size (num_L1) is 100 the output_layer size (num_L2) is 10 """ model = dict() num_L1 = 100 num_L2 = 10 # experimental setup num_epoch = int(main_params['num_epoch']) minibatch_size = int(main_params['minibatch_size']) # optimization setting: _alpha for momentum, _lambda for weight decay _learning_rate = float(main_params['learning_rate']) _step = 10 _alpha = float(main_params['alpha']) _lambda = float(main_params['lambda']) _dropout_rate = float(main_params['dropout_rate']) _activation = main_params['activation'] if _activation == 'relu': act = relu else: act = tanh # create objects (modules) from the module classes model['L1'] = linear_layer(input_D = d, output_D = num_L1) model['nonlinear1'] = act() model['drop1'] = dropout(r = _dropout_rate) model['L2'] = linear_layer(input_D = num_L1, output_D = num_L2) model['loss'] = softmax_cross_entropy() # Momentum if _alpha > 0.0: momentum = add_momentum(model) else: momentum = None train_acc_record = [] val_acc_record = [] train_loss_record = [] val_loss_record = [] ### run training and validation ### for t in range(num_epoch): print('At epoch ' + str(t + 1)) if (t % _step == 0) and (t != 0): _learning_rate = _learning_rate * 0.1 idx_order = np.random.permutation(N_train) train_acc = 0.0 train_loss = 0.0 train_count = 0 val_acc = 0.0 val_count = 0 val_loss = 0.0 for i in range(int(np.floor(N_train / minibatch_size))): # get a mini-batch of data x, y = trainSet.get_example(idx_order[i * minibatch_size : (i + 1) * minibatch_size]) ### forward ### x -L1> a1 -NL> h1 -Dr> d1 -L2> a2 -loss> y a1 = model['L1'].forward(x) # a1 or u h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train = True) # d1 or h after dropout a2 = model['L2'].forward(d1) loss = model['loss'].forward(a2, y) ### backward ### grad_a2 = model['loss'].backward(a2, y) ###################################################################################### # TODO: Call the backward methods of every layer in the model in reverse order # We have given the first and last backward calls # Do not modify them. ###################################################################################### # raise NotImplementedError("Not Implemented BACKWARD PASS in main()") grad_a2 = model['loss'].backward(a2, y) grad_d1 = model['L2'].backward(d1, grad_a2) grad_h1 = model['drop1'].backward(h1, grad_d1) grad_a1 = model['nonlinear1'].backward(a1,grad_h1) ###################################################################################### # NOTE: DO NOT MODIFY CODE BELOW THIS, until next TODO ###################################################################################### grad_x = model['L1'].backward(x, grad_a1) ### gradient_update ### model = miniBatchGradientDescent(model, momentum, _lambda, _alpha, _learning_rate) ### Computing training accuracy and obj ### for i in range(int(np.floor(N_train / minibatch_size))): x, y = trainSet.get_example(np.arange(i * minibatch_size, (i + 1) * minibatch_size)) ### forward ### ###################################################################################### # TODO: Call the forward methods of every layer in the model in order # Check above forward code ###################################################################################### # raise NotImplementedError("Not Implemented COMPUTING TRAINING ACCURACY in main()") a1 = model['L1'].forward(x) # a1 or u h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train = True) # d1 or h after dropout a2 = model['L2'].forward(d1) ###################################################################################### # NOTE: DO NOT MODIFY CODE BELOW THIS, until next TODO ###################################################################################### loss = model['loss'].forward(a2, y) train_loss += loss train_acc += np.sum(predict_label(a2) == y) train_count += len(y) train_loss = train_loss train_acc = train_acc / train_count train_acc_record.append(train_acc) train_loss_record.append(train_loss) print('Training loss at epoch ' + str(t + 1) + ' is ' + str(train_loss)) print('Training accuracy at epoch ' + str(t + 1) + ' is ' + str(train_acc)) ### Computing validation accuracy ### for i in range(int(np.floor(N_val / minibatch_size))): x, y = valSet.get_example(np.arange(i * minibatch_size, (i + 1) * minibatch_size)) ### forward ### ###################################################################################### # TODO: Call the forward methods of every layer in the model in order # Check above forward code ###################################################################################### a1 = model['L1'].forward(x) # a1 or u h1 = model['nonlinear1'].forward(a1) d1 = model['drop1'].forward(h1, is_train = True) # d1 or h after dropout a2 = model['L2'].forward(d1) # raise NotImplementedError("Not Implemented COMPUTING VALIDATION ACCURACY in main()") ###################################################################################### # NOTE: DO NOT MODIFY CODE BELOW THIS, until next TODO ###################################################################################### loss = model['loss'].forward(a2, y) val_loss += loss val_acc += np.sum(predict_label(a2) == y) val_count += len(y) val_loss_record.append(val_loss) val_acc = val_acc / val_count val_acc_record.append(val_acc) print('Validation accuracy at epoch ' + str(t + 1) + ' is ' + str(val_acc)) # save file json.dump({'train': train_acc_record, 'val': val_acc_record}, open('MLP_lr' + str(main_params['learning_rate']) + '_m' + str(main_params['alpha']) + '_w' + str(main_params['lambda']) + '_d' + str(main_params['dropout_rate']) + '_a' + str(main_params['activation']) + '.json', 'w')) print('Finish running!') return train_loss_record, val_loss_record
import streamlit as st from errors import FailedToDownloadException, EmptyStringException, InvalidURL from utils import download_image, predict_label st.title("Image classifier") image_url = st.text_input("Image URL") error = "" if st.button("Classify!", key="enter"): try: img = download_image(image_url) st.image(img, width=200) error = "" label = predict_label(img) st.info("{object_type}: {confidence_rate}%".format( object_type=label[1], confidence_rate=round(label[2] * 100, 2))) except FailedToDownloadException: error = "Oops, something went wrong" except InvalidURL: error = "Invalid URL" except EmptyStringException: error = "" if error: st.error(error)