def main(): # Get the data data_train = pd.read_csv('dataset/train.csv') data_test = pd.read_csv('dataset/test.csv') # Transforming and dividing features Id_test = data_test['PassengerId'] selected_features = ['Pclass','Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked'] df_train, df_test = data_process.transform_features(data_train, data_test, selected_features) df_train, df_test = data_process.features_scaling(df_train, df_test, selected_features) X_train, Y_train, X_test, Y_test, test_X = data_process.split_data(df_train, df_test, selected_features) # Set parameters parameters = {} parameters['model_path'] = 'model/Titanic.ckpt' parameters['n_input'], parameters['n_features'] = X_train.shape parameters['n_hidden'] = 2 parameters['hidden_dim'] = 40 parameters['n_class'] = 1 parameters['learning_rate'] = 0.01 parameters['training_epochs'] = 15000 parameters['visualize'] = False if ((len(argv) > 1 and argv[1] == '-v') or (len(argv) > 2 and argv[2] == '-v')): parameters['visualize'] = True # Get model & train titanic_model = model.make_model(parameters) if (len(argv) > 1 and argv[1] == '-n') or (len(argv) > 2 and argv[2] == '-n'): model.neural_network(X_train, Y_train, parameters, titanic_model, X_test, Y_test) # Print accuracy if os.path.isfile(parameters['model_path']) == True: accuracy_estimation.Accuracy(parameters, titanic_model, X_train, Y_train, X_test, Y_test) # Output the submission to estimation.csv if os.path.isfile(parameters['model_path']) == True: accuracy_estimation.Estimation(parameters, titanic_model, test_X, Id_test) else: print("\nNo model found, please create a new file named 'Titanic.ckpt' in a directory named 'model' and launch the programme with th folowing commande :\n'python3 main.py -n'\n")
def run(): X_train, Y_train, X_test, Y_test = load_dataset() print("SVM model...") SVM(X_train, Y_train, X_test, Y_test) print("Done SVM") print("Random forest model...") random_forest(X_train, Y_train, X_test, Y_test) print("Done random forest") print("Neural network model...") C = tf.constant(2, name='C') one_hot_matrix_train = tf.one_hot(Y_train, C, axis=0) one_hot_matrix_test = tf.one_hot(Y_test, C, axis=0) with tf.Session() as sess: one_hot_train = sess.run(one_hot_matrix_train) one_hot_test = sess.run(one_hot_matrix_test) Y_train = one_hot_train Y_test = one_hot_test X_train = X_train.T X_test = X_test.T weights = neural_network(X_train, Y_train, X_test, Y_test, [18, 8, 2], print_cost=True) return weights
def create_model(): clf = neural_network() sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) model = clf.build(28, 28, 1, 10) model.compile(loss="categorical_crossentropy", optimizer=sgd, metrics=["accuracy"]) return model
def test_main(model_name): """ main for testing mode """ env = FrozenLake() model = neural_network(16, 16, 4, 0.01) model.load_model(model_name) env.render_wQ(get_q_values(model)) state = env.reset() env.render() done = False for _ in range(100): time.sleep(0.5) action = np.argmax(model.predict(np.array([state]))) next_state, _, done = env.step(action) state = next_state env.render() if done: break
test_label = test_data[:, 445:446] elif args.choice == 'permeability': test_label = test_data[:, 444:445] * 100 else: raise NotImplementedError() valid_input = Variable(torch.FloatTensor(valid_data[:, 0:444]), requires_grad=False) if args.choice == 'rejection': valid_label = valid_data[:, 445:446] elif args.choice == 'permeability': valid_label = valid_data[:, 444:445] * 100 else: raise NotImplementedError() model = neural_network(choice=args.choice, init='load', data=args.data, device='cpu') train_predict = model(train_input) test_predict = model(test_input) valid_predict = model(valid_input) if args.choice == 'permeability': train_predict *= 100 test_predict *= 100 valid_predict *= 100 # the first figure plt.figure(1) plt.plot(train_label, train_label, color=color1, linestyle=":",
def train_main(r_mode): """ main for training mode """ env = FrozenLake() model = neural_network(16, 16, 4, 0.01) memory = deque(maxlen=1000) memory = fill_memory(env, memory) epsilon = 1 for eps in range(10000): state = env.reset() last_position = env.position already = np.empty((0, 16)) already = np.append(already, np.array([state]), axis=0) done = False if r_mode == "weights": time.sleep(0.01) env.render_wQ(get_q_values(model)) elif r_mode == "map": time.sleep(0.2) env.render() for _ in range(100): if np.random.rand() > epsilon: action = np.argmax(model.predict(np.array([state]))) else: action = np.random.randint(0, 4, size=1)[0] next_state, reward, done = env.step(action) for _, item in enumerate(already): flag = True for e, elem in enumerate(next_state): if item[e] != elem: flag = False break if flag: reward -= 0.1 break already = np.append(already, np.array([next_state]), axis=0) if epsilon > 0.1: epsilon -= 0.001 if last_position == env.position: reward -= 0.1 memory.append((state, action, reward, next_state, done)) train(model, memory, 64, 0.9) if r_mode == "weights": time.sleep(0.01) env.render_wQ(get_q_values(model)) elif r_mode == "map": time.sleep(0.2) env.render() state = next_state last_position = env.position if done: if test(env, eps, epsilon, model, r_mode): model.save_model("model") print("[SUCCESSFUL RUN]") return break
def main(): # tf flag flags = tf.flags flags.DEFINE_string("data_path", "D:/M1_lecture/lecture/image_analysis/no_normalized_data.csv", "data path") flags.DEFINE_string("outdir", "D:/M1_lecture/lecture/image_analysis/no_norm", "outdir path") flags.DEFINE_string("gpu_index", "0", "GPU-index") flags.DEFINE_integer("num_epoch", 1000, "number of iteration") flags.DEFINE_integer("kfold", 10, "number of fold") flags.DEFINE_list("input_size", [22], "input vector size") flags.DEFINE_bool("cv", True, "if 10 fold CV or not") FLAGS = flags.FLAGS # load train data data = np.loadtxt(FLAGS.data_path, delimiter=",").astype(np.float32) feature = data[:, :data.shape[1]-1] label = data[:, data.shape[1]-1] # initializer init_op = tf.group(tf.initializers.global_variables(), tf.initializers.local_variables()) with tf.Session(config = utils.config(index=FLAGS.gpu_index)) as sess: # Resubstitution Method if FLAGS.cv == False: # set network kwargs = { 'sess': sess, 'input_size': FLAGS.input_size, 'learning_rate': 1e-3 } NN = neural_network(**kwargs) # print parmeters utils.cal_parameter() # check floder if not (os.path.exists(os.path.join(FLAGS.outdir, 'R', 'tensorboard'))): os.makedirs(os.path.join(FLAGS.outdir, 'R', 'tensorboard')) if not (os.path.exists(os.path.join(FLAGS.outdir, 'R', 'model'))): os.makedirs(os.path.join(FLAGS.outdir, 'R', 'model')) if not (os.path.exists(os.path.join(FLAGS.outdir, 'R', 'predict'))): os.makedirs(os.path.join(FLAGS.outdir, 'R', 'predict')) # prepare tensorboard writer_train = tf.summary.FileWriter(os.path.join(FLAGS.outdir, 'R', 'tensorboard', 'train'), sess.graph) writer_test = tf.summary.FileWriter(os.path.join(FLAGS.outdir, 'R', 'tensorboard', 'test')) value_loss = tf.Variable(0.0) tf.summary.scalar("loss", value_loss) merge_op = tf.summary.merge_all() # initialize sess.run(init_op) # training tbar = tqdm(range(FLAGS.num_epoch), ascii=True) for i in tbar: train_step, train_data = utils.batch_iter(feature, label, batch_size=feature.shape[0], shuffle=True) train_data_batch = next(train_data) train_loss = NN.update(train_data_batch[0], np.reshape(train_data_batch[1] , (train_data_batch[1].shape[0],1))) s = "Loss: {:.4f}".format(np.mean(train_loss)) tbar.set_description(s) summary_train_loss = sess.run(merge_op, {value_loss: np.mean(train_loss)}) writer_train.add_summary(summary_train_loss, i+1) NN.save_model(i+1, outdir=os.path.join(FLAGS.outdir, 'R')) # test test_loss_min = [] sess.run(init_op) test_step, test_data = utils.batch_iter(feature, label, batch_size=feature.shape[0], shuffle=False) tbar = tqdm(range(FLAGS.num_epoch), ascii=True) for i in tbar: NN.restore_model(os.path.join(FLAGS.outdir, 'R', 'model', 'model_{}'.format(i+1))) test_data_batch = next(test_data) test_loss, predict = NN.test(test_data_batch[0], np.reshape(test_data_batch[1], (test_data_batch[1].shape[0], 1))) s = "Loss: {:.4f}".format(np.mean(test_loss)) tbar.set_description(s) test_loss_min.append(np.mean(test_loss)) summary_test_loss = sess.run(merge_op, {value_loss: np.mean(test_loss)}) writer_test.add_summary(summary_test_loss, i+1) predict_label = np.zeros((test_data_batch[0].shape[0], 2)) predict_label[:, 0] = test_data_batch[1] predict_label[:, 1] = np.where(predict > 0.5, 1, 0)[:, 0] np.savetxt(os.path.join(FLAGS.outdir, 'R', 'predict', 'result_{}.csv'.format(i + 1)), predict_label.astype(np.int), delimiter=',', fmt="%d") test_loss_min = np.argmin(np.asarray(test_loss_min)) np.savetxt(os.path.join(FLAGS.outdir, 'R' ,'min_loss_index.txt'), [test_loss_min+1], fmt="%d") # Leave-one-out method (10-fold CV) if FLAGS.cv == True: kfold = StratifiedKFold(n_splits=FLAGS.kfold, shuffle=True, random_state=1) fold_index = 0 # set network kwargs = { 'sess': sess, 'input_size': FLAGS.input_size, 'learning_rate': 1e-3 } NN = neural_network(**kwargs) # print parmeters utils.cal_parameter() for train, test in kfold.split(feature, label): fold_index += 1 # check folder if not (os.path.exists(os.path.join(FLAGS.outdir, 'L', str(fold_index) , 'tensorboard'))): os.makedirs(os.path.join(FLAGS.outdir, 'L', str(fold_index), 'tensorboard')) if not (os.path.exists(os.path.join(FLAGS.outdir, 'L', str(fold_index), 'model'))): os.makedirs(os.path.join(FLAGS.outdir, 'L', str(fold_index), 'model')) if not (os.path.exists(os.path.join(FLAGS.outdir, 'L', str(fold_index), 'predict'))): os.makedirs(os.path.join(FLAGS.outdir, 'L', str(fold_index), 'predict')) # prepare tensorboard writer_train = tf.summary.FileWriter(os.path.join(FLAGS.outdir, 'L', str(fold_index), 'tensorboard', 'train'), sess.graph) writer_test = tf.summary.FileWriter(os.path.join(FLAGS.outdir, 'L', str(fold_index), 'tensorboard', 'test')) value_loss = tf.Variable(0.0) tf.summary.scalar("loss", value_loss) merge_op = tf.summary.merge_all() # initialize sess.run(tf.global_variables_initializer()) # training tbar = tqdm(range(FLAGS.num_epoch), ascii=True) for i in tbar: train_step, train_data = utils.batch_iter(feature[train], label[train], batch_size=feature[train].shape[0], shuffle=True) train_data_batch = next(train_data) train_loss = NN.update(train_data_batch[0], np.reshape(train_data_batch[1], (train_data_batch[1].shape[0], 1))) s = "Loss: {:.4f}".format(np.mean(train_loss)) tbar.set_description(s) summary_train_loss = sess.run(merge_op, {value_loss: np.mean(train_loss)}) writer_train.add_summary(summary_train_loss, i + 1) NN.save_model(i + 1, outdir=os.path.join(FLAGS.outdir, 'L', str(fold_index))) # test sess.run(init_op) test_loss_min = [] test_step, test_data = utils.batch_iter(feature[test], label[test], batch_size=feature[test].shape[0], shuffle=False) tbar = tqdm(range(FLAGS.num_epoch), ascii=True) for i in tbar: NN.restore_model(os.path.join(FLAGS.outdir, 'L', str(fold_index) , 'model', 'model_{}'.format(i + 1))) test_data_batch = next(test_data) test_loss, predict = NN.test(test_data_batch[0], np.reshape(test_data_batch[1], (test_data_batch[1].shape[0], 1))) s = "Loss: {:.4f}".format(np.mean(test_loss)) tbar.set_description(s) test_loss_min.append(np.mean(test_loss)) summary_test_loss = sess.run(merge_op, {value_loss: np.mean(test_loss)}) writer_test.add_summary(summary_test_loss, i + 1) predict_label = np.zeros((test_data_batch[0].shape[0], 2)) predict_label[:, 0] = test_data_batch[1] predict_label[:, 1] = np.where(predict > 0.5, 1, 0)[:,0] np.savetxt(os.path.join(FLAGS.outdir, 'L', str(fold_index), 'predict', 'result_{}.csv'.format(i + 1)), predict_label.astype(np.int), delimiter=',', fmt="%d") test_loss_min = np.argmin(np.asarray(test_loss_min)) np.savetxt(os.path.join(FLAGS.outdir, 'L', str(fold_index),'min_loss_index.txt'), [test_loss_min+1], fmt="%d")
if args.choice == 'rejection': batch_size, epoch, lr = 200, 5, 1e-3 regularization = 1e-2 if args.data[0:2] == '72' else 1e-1 # manually pick the threshold to save the model parameters threshold = 0 elif args.choice == 'permeability': batch_size, epoch, lr = 200, 5, 5e-5 # it is very likely to encounter overfitting when training permeability, # you can set regularization to a recommending range from 3e-1 to 3, . regularization = 0 if args.data[0:2] == '72' else 0 # manually pick the threshold to save the model parameters threshold = -1 '''model structure''' model = neural_network(choice=args.choice, init=args.init, data=args.data, device=args.device) if args.init == 'start' and args.manual_init: model.apply(weight_init) if args.optim == 'adam': optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=regularization) elif args.optim == 'sgd': optimizer = optim.SGD(model.parameters(), lr=lr, weight_decay=regularization, momentum=0.8) else: raise NotImplementedError("Please select between adam and sgd") # learning_rate decay if args.choice == 'rejection': scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.95) elif args.choice == 'permeability': scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.95) criterion = nn.MSELoss(reduction='mean')
mkdir(combination_folder) training_set = [X_word] right_set = [R_word] # approximate_set = [A_word] wrong_set = [W_word] if pos_tag: training_set += [X_pos] right_set += [R_pos] # approximate_set += [A_pos] wrong_set += [W_pos] if offset: training_set += [X_d1, X_d2] right_set += [R_d1, R_d2] # approximate_set += [A_d1, A_d2] wrong_set += [W_d1, W_d2] model = neural_network(dim, lstm_units, dropout, r_dropout, pos_tag, offset) history = model.fit(training_set, Y_train, validation_split=0.15, batch_size=batch_size, epochs=epochs, verbose=2) plot( combination_folder, 'loss_accuracy_' + datetime.datetime.now().strftime("%Y%m%d-%H%M%S"), history) total_right_labels, right_predictions = generate_predictions( model, right_set, right_labels, generate_negative_labels(right_negative)) '''total_approximate_labels, approximate_predictions = generate_predictions(model, approximate_set, approximate_labels, generate_negative_labels( approximate_negative))'''
complete_test = np.zeros((X_test.shape[0],n_class)) # Training set X_train = train_data['X_train'] y_train = train_data['y_train'] mask_train = train_data['mask_train'] partition = train_data['partition'] # Number of features n_feat = np.shape(X_test)[2] # Training for i in range(1,5): # Network compilation print("Compilation model {}\n".format(i)) train_fn, val_fn, network_out = neural_network(batch_size, n_hid, n_feat, n_class, lr, drop_per, drop_hid, n_filt) # Train and validation sets train_index = np.where(partition != i) val_index = np.where(partition == i) X_tr = X_train[train_index].astype(np.float32) X_val = X_train[val_index].astype(np.float32) y_tr = y_train[train_index].astype(np.int32) y_val = y_train[val_index].astype(np.int32) mask_tr = mask_train[train_index].astype(np.float32) mask_val = mask_train[val_index].astype(np.float32) print("Validation shape: {}".format(X_val.shape)) print("Training shape: {}".format(X_tr.shape)) eps = []
# Observe how increasing the size and number of layers # results in overfitting on the dataset # UNCOMMENT THE NEXT THREE LINES AND FILL IN YOUR HYPERPARAMETERS # no_epochs = ? # lr = ? # layer_sizes = [input_dim, hidden_1, hidden_2, ..., no_classes] # list specifying network architecture #################################################### # MODIFY HYPERPARAMETERS (END) #################################################### no_layers = len(layer_sizes) + 1 # create a neural network model model_nn = model.neural_network(layer_sizes) begin_time = time.time() # The data is a 2D spiral. So the input is a 2 dimensional point, and they are classified into three # classes # data taken from http://cs231n.github.io/neural-networks-case-study/ # load the data X_train = np.load('train_X.npy') Y_train = np.load('train_Y.npy') X_val = np.load('val_X.npy') Y_val = np.load('val_Y.npy') # make the dimensions of data as [no_features x batch_size]
x[ix] = oldval # restore # compute the partial derivative with centered formula grad[ix] = (fxph - fxmh) / (2 * h) # the slope if verbose: print(ix, grad[ix]) it.iternext() # step to next dimension return grad # define an arbitrary neural network layer_sizes = [2, 4, 2, 4, 5] no_layer = len(layer_sizes) - 1 batch_size = 16 model_nn = model.neural_network(layer_sizes) # create a single sample example X = np.random.randn(layer_sizes[0], batch_size) Y = np.random.randint(0, layer_sizes[-1], batch_size) # analytical evaluation Y_hat, loss = model_nn.forward(X, Y) model_nn.compute_gradients() # numerical evaluation grad_W = [None] * (no_layer+1) grad_b = [None] * (no_layer+1) f = lambda W: model_nn.forward(X, Y)[1]