def main(neural_net_func, data_sets, rate=1.0, max_iterations=10000): verbose = True for name, training_data, test_data in data_sets: print("-" * 40) print("Training on %s data" % (name)) nn = neural_net_func() train(nn, training_data, rate=rate, max_iterations=max_iterations, verbose=verbose) print("Trained weights:") for w in nn.weights: print("Weight '%s': %f" % (w.get_name(), w.get_value())) print("Testing on %s test-data" % (name)) result = test(nn, test_data, verbose=verbose) print("Accuracy: %f" % (result)) if (verbose): print("Finite Difference Check:", finite_difference(nn)) print("Decision Boundary on Training Data:") plot_decision_boundary(nn, -PLOT_SIZE, PLOT_SIZE, -PLOT_SIZE, PLOT_SIZE, training_data) print("Decision Boundary on Test Data:") plot_decision_boundary(nn, -PLOT_SIZE, PLOT_SIZE, -PLOT_SIZE, PLOT_SIZE, test_data) test_result = test(nn, test_data, verbose=verbose) print("Test Data Accuracy: %f" % (test_result)) train_result = test(nn, training_data, verbose=verbose) print("Train Data Accuracy: %f" % (train_result))
def get_Qmax(state, minimal_actions, nn): Qvalues = nn.test(state)[0, minimal_actions] index = tc.argmax(Qvalues) # print('index :\n', index) # print('type(Qvalues :\n', Qvalues) Amax = tc.Tensor([minimal_actions[index]]).long() Qmax = Qvalues[index] # print('Qmax :\n', Qmax) return Amax, Qmax
def main(neural_net_func, data_sets, rate=1.0, max_iterations=10000): verbose = True for name, training_data, test_data in data_sets: print("-" * 40) print("Training on %s data" % (name)) nn = neural_net_func() train(nn, training_data, rate=rate, max_iterations=max_iterations, verbose=verbose) print("Trained weights:") for w in nn.weights: print("Weight '%s': %f" % (w.get_name(), w.get_value())) print("Testing on %s train-data" % (name)) result = test(nn, training_data, verbose=verbose) print("Accuracy on train data: %f" % (result)) print("Testing on %s test-data" % (name)) result = test(nn, test_data, verbose=verbose) print("Accuracy on test data: %f" % (result))
def main(neural_net_func, data_sets, max_iterations=10000): verbose = True for name, training_data, test_data in data_sets: print "-" * 40 print "Training on %s data" % (name) nn = neural_net_func() train(nn, training_data, max_iterations=max_iterations, verbose=verbose) print "Trained weights:" for w in nn.weights: print "Weight '%s': %f" % (w.get_name(), w.get_value()) print "Testing on %s test-data" % (name) result = test(nn, test_data, verbose=verbose) print "Accuracy: %f" % (result)
def main(neural_net_func, data_sets, max_iterations=10000): verbose = True for name, training_data, test_data in data_sets: print "-"*40 print "Training on %s data" %(name) nn = neural_net_func() train(nn, training_data, max_iterations=max_iterations, verbose=verbose) print "Trained weights:" for w in nn.weights: print "Weight '%s': %f"%(w.get_name(),w.get_value()) print "Testing on %s test-data" %(name) result = test(nn, test_data, verbose=verbose) print "Accuracy: %f"%(result)
def main(neural_net_func, data_sets, rate=1.0, max_iterations=10000): verbose = True for name, training_data, test_data in data_sets: print("-"*40) print("Training on %s data" %(name)) nn = neural_net_func() train(nn, training_data, rate=rate, max_iterations=max_iterations, verbose=verbose) finite_difference(nn) print("Trained weights:") for w in nn.weights: print("Weight '%s': %f"%(w.get_name(),w.get_value())) print("Testing on %s test-data" %(name)) # plot_decision_boundary(nn, 0,4,0,4) result = test(nn, test_data, verbose=verbose) print("Accuracy: %f"%(result))
def ep_greedy(ep, state, minimal_actions, nn): Qvalues = nn.test(state)[0, minimal_actions] num = random.random() index = tc.argmax(Qvalues).type(tc.long) Qmax = Qvalues[index] Amax = tc.Tensor([minimal_actions[index]]).long() if num < ep + (1 - ep) / len(minimal_actions): action_index = random.randrange(0, len(minimal_actions) - 1) if action_index >= index: action_index = action_index + 1 return tc.Tensor([minimal_actions[action_index] ]).long(), Qvalues[action_index] else: return Amax, Qmax
# K-Nearest neighbors if model == 'nearest' and phase == 'train': model = knn.train(image_list) serialize_to_file(model, model_file) elif model == 'nearest' and phase == 'test': model = deserialize_from_file(model_file) knn.test(image_list, model) # ADA boost elif model == "adaboost" and phase == "train": params = Adaboost(image_list).adaboost() serialize_to_file(params, model_file) elif model == "adaboost" and phase == "test": params = deserialize_from_file(model_file) Adaboost(image_list).adaboost_test(image_list, params) # Neural net elif model == 'nnet' and phase == 'train': net = neural_net.train(image_list) serialize_to_file(net, model_file) elif model == 'nnet' and phase == 'test': net = deserialize_from_file(model_file) neural_net.test(net, image_list) print 'End time', time() if phase == 'test': accuracy = get_accuracy(image_list) save_output(image_list, 'output.txt') print 'Accuracy ->', accuracy
def run_algo(ticker, spy): df = neural_net.test(ticker, model) df, beta, risk, sharpe, ret, profit = backtest.trade(df) visualization.algo_vs_market(df, spy) visualization.visualize_dollar_profits(df)
raise Exception("Error: expected 4 arguments") if sys.argv[1] == 'train': # Train your model # train train_file.txt model_file.txt [model] train_image_ids, train_data = read_data(sys.argv[2]) if sys.argv[4] == 'nearest': # KNN KNN.train_data(sys.argv[2], sys.argv[3]) elif sys.argv[4] == 'tree': # Decision tree DecisionTree.train(train_data, sys.argv[3]) elif sys.argv[4] == 'nnet' or sys.argv[4] == 'best': # Neural nets is the best case neural_net.train(train_data, sys.argv[3]) elif sys.argv[1] == 'test': # Test against your model_file.txt # test test_file.txt model_file.txt [model] test_image_ids, test_data = read_data(sys.argv[2]) if sys.argv[4] == 'nearest': # KNN train_image_ids, train_data = read_data(sys.argv[3]) KNN.start(train_data, test_data, test_image_ids) elif sys.argv[4] == 'tree': # Decision tree DecisionTree.test(test_data, sys.argv[3], test_image_ids) elif sys.argv[4] == 'nnet' or sys.argv[4] == 'best': # Neural Nets is the best case neural_net.test(sys.argv[3], test_data, test_image_ids)
x_train = proc.st_scale(x_train) # train_data = proc.ZCA(train_data) # x_train = proc.PCA_reduction(x_train, n_pca) # Trainning process using K-Fold if training: if model_type == "net": models = net.kfold(model_params, x_train, y_train, n_folds, verbose, grad_check) else: models = logistic.kfold(model_params, x_train, y_train, n_folds, verbose) if not training: # Pre-prossesing test x_test = proc.normalize_l2(x_test) x_test = proc.st_scale(x_test) if model_type == "net": # Testing process on neural net net.test(model_params, x_train, y_train, x_test, y_test) else: print("Testing Logistic Regression on Test dataset") # Testing process on logistic regression model = logistic.create_model(*model_params) model.fit(x_train, y_train.ravel()) score = model.score(x_test, y_test.ravel()) metrics.print_acc(score)
elif kind == 'aleatoric': model = aleatoric elif kind == 'combined': model = combined else: print('kind can be epistemic, aleatoric or combined') exit() net = model.Net(28 * 28, 10, 1024, 2) net.apply(neural_net.init_weights) criterion = model.Loss() predict = model.predict kwargs = dict(lr=1e-4, weight_decay=0.0001) if kind == 'aleatoric' else dict( lr=1e-4) optimizer = torch.optim.Adam(net.parameters(), **kwargs) scheduler = ExponentialLR(optimizer, gamma=0.9999) net.train() for epoch in range(10): train_losses = neural_net.train(train_loader, net, criterion, optimizer, scheduler) print('Train loss = %s' % (sum(train_losses) / len(train_losses))) score, loss = neural_net.test(test_loader, predict, net, criterion) print('Testing: Accuracy = %.2f%%, Loss %.4f' % (score * 100, loss)) torch.save(net, '%s.pt' % kind)