def analyzeSymbol(stockSymbol): startTime = time.time() trainingData = getTrainingData(stockSymbol) network = NeuralNetwork(inputNodes=3, hiddenNodes=3, outputNodes=1) network.train(trainingData) # get rolling data for most recent day predictionData = getPredictionData(stockSymbol) # get prediction returnPrice = network.test(predictionData) # de-normalize and return predicted stock price predictedStockPrice = denormalizePrice(returnPrice, predictionData[1], predictionData[2]) # create return object, including the amount of time used to predict returnData = {} returnData['price'] = predictedStockPrice returnData['time'] = time.time() - startTime return returnData
def analyzeSymbol(stockSymbol): startTime = time.time() flag = 0 trainingData = getTrainingData(stockSymbol) network = NeuralNetwork(inputNodes=3, hiddenNodes=3, outputNodes=1) network.train(trainingData) # get rolling data for most recent day network.train(trainingData) for i in range(0, 5): # get rolling data for most recent day predictionData = getPredictionData(stockSymbol, flag) returnPrice = network.test(predictionData) # de-normalize and return predicted stock price predictedStockPrice = denormalizePrice(returnPrice, predictionData[1], predictionData[2]) print predictedStockPrice flag += 1 global new_value new_value = predictedStockPrice return predictedStockPrice
def analyzeSymbol(): trainingData = getTrainingData() network = NeuralNetwork(inputNodes = 3, hiddenNodes = 5, outputNodes = 1) model = network.train(trainingData) # get rolling data for most recent day predictionData = getPredictionData(0) returnPrice = network.test(predictionData) predictedStockPrice = denormalizePrice(returnPrice, predictionData[1], predictionData[2]) returnData = {} returnData[0] = predictedStockPrice return (predictedStockPrice)
def getAccuracy(var, begin, name, step, loop, path="./results/"): value = begin for i in range(loop): print(i) # create network if (var == 'hid'): nn = NeuralNetwork(hid=value, act=ACT) elif (var == 'lay'): nn = NeuralNetwork(lay=value, act=ACT) elif (var == 'lr'): nn = NeuralNetwork(lr=value, act=ACT) elif (var == 'epoch'): nn = NeuralNetwork(act=ACT) # train network if (var == 'epoch'): nn.train(ds.train_data, ds.train_labels_arr, value, DATA) else: nn.train(ds.train_data, ds.train_labels_arr, EPOCH, DATA) # counters correct = 0 false = 0 for i in range(TEST): output = nn.feedforward(ds.test_data[i], isRound=False, isSoftmax=True) output_digit = np.where(output == np.amax(output)) if output_digit[0][0] == ds.test_labels[i]: correct += 1 else: false += 1 # calc accuracy accuracy = (correct * 100) / (correct + false) # log accuracy logResults(path, name, value, accuracy) # increment value value += step
def analyzeSymbol(stockSymbol): startTime = time.time() trainingData = getTrainingData(stockSymbol) network = NeuralNetwork(inputNodes = 3, hiddenNodes = 3, outputNodes = 1) network.train(trainingData) # get rolling data for most recent day predictionData = getPredictionData(stockSymbol) # get prediction returnPrice = network.test(predictionData) # de-normalize and return predicted stock price predictedStockPrice = denormalizePrice(returnPrice, predictionData[1], predictionData[2]) # create return object, including the amount of time used to predict returnData = {} returnData['price'] = predictedStockPrice returnData['time'] = time.time() - startTime return returnData
def analyzeId(c_id): startTime = time.time() count2 =0 itr = 0 if (c_id>0): network = NeuralNetwork(inputNodes = 5, hiddenNodes = 18, outputNodes = 1) #company id >0 for individual prediciton averageError = 1 while (averageError>0.01 and itr<2000): #for i in range(1000): count1 =0 resultBackProp =[] while (count1<295): trainingData = getTrainingData(c_id,count1) resultBackProp.append(network.train(trainingData)) count1 = count1 +1 averageError = sum(resultBackProp)/len(resultBackProp) print ("avgError = ", averageError) #================================================================== # get data for testing testError =[] while (count2<95): testData = getTestData(c_id,count2) testError.append(network.accuracyTest(testData)) count2 = count2 + 1 testErrorAverage = sum(testError)/len(testError) #==================================================================== # get data for tomorrow's prediction predictionData = getPredictionData(c_id) # get prediction result returnPrice = network.test(predictionData) # de-normalize and return predicted stock price final = InitialCalculation() predictedStockPrice = final.denormalizePrice(returnPrice) # create return object, including the accuracy of the testing returnData ={} returnData['price'] = predictedStockPrice #returnData['accuracy'] = accuracy returnData['error'] = testErrorAverage returnData['time'] = time.time() - startTime print(returnData) else: nep_network = NeuralNetwork(inputNodes = 8, hiddenNodes = 20, outputNodes = 1) #company id =0 for nepse prediciton averageError = 1 while (averageError>0.03 ): #for i in range(1000): count1 =0 resultBackProp =[] #print(getTrainingData(c_id,count1)) while (count1<95): trainingData = getTrainingData(c_id,count1) resultBackProp.append(nep_network.trainNepse(trainingData)) count1 = count1 +1 averageError = sum(resultBackProp)/len(resultBackProp) print ("avgError = ", averageError) #================================================================== # get data for testing # considering 50 test data, we nedd 45 loops testError =[] while (count2<10): testData = getTestData(c_id,count2) testError.append(nep_network.accuracyTestNepse(testData)) count2 = count2 + 1 testErrorAverage = sum(testError)/len(testError) #print ("test error =", testError) #print("te average = ", testErrorAverage) #accuracy = (1- testErrorAverage)*100 #==================================================================== # get data for tomorrow's prediction predictionData = getPredictionData(c_id) # get prediction result returnPrice = nep_network.test(predictionData) # de-normalize and return predicted stock price final = InitialCalculation() predictedStockPrice = final.denormalizePriceNepse(returnPrice) # create return object, including the accuracy of the testing returnData ={} returnData['price'] = predictedStockPrice #returnData['accuracy'] = accuracy returnData['error'] = testErrorAverage returnData['time'] = time.time() - startTime print(returnData)
def analyzeSymbol(name): filename = ('uploads/'+name) count = sum(1 for line in open(filename)) con = sql.connect("EBL.db") cur = con.cursor() y =name #cur.execute ("DROP TABLE if exists bankname ") #cur.execute ('''CREATE TABLE bankname (id INTEGER not null PRIMARY KEY, bankname)''') # cur.execute("insert into bankname (bankname) values (?)", (y,)) #cur.execute("insert into bankname (name) values (55)") con.commit() cur.execute ("DROP TABLE if exists {} ".format (name)) cur.execute( '''CREATE TABLE {}(id INTEGER not null PRIMARY KEY, date DATE, ltp INTEGER, percent INTEGER, high INTEGER, low INTEGER, prediction INTEGER)'''.format(y)) #cur.execute("CREATE TABLE fuche ( id INTEGER not null PRIMARY KEY, date, volume, lamo)") with open ('uploads/'+name) as csvfile: readCSV = csv.reader(csvfile, delimiter=',') #print(readCSV) for row in readCSV: cur.execute("insert into {} (date, ltp, percent, high, low) values (?,?, ?, ?, ?)".format(y), ( row[0], row[1], row[2], row[3], row[4])) con.commit() #b=b+1 #INSERT INTO MyTable(MyIntColumn) VALUES(NULL); # cur.execute("insert into {} (date, ltp, percent, high, low) values (NULL, NULL, NULL, NULL, NULL)".format(y)) # con.commit() x = name trainingData = getTrainingData(x) network = NeuralNetwork(inputNodes = 3, hiddenNodes = 2, outputNodes = 1) network.train(trainingData) f****n = [] pussy = [] for a in range (0,count-9): predictionData = getPredictionData(name, a) #returnPrice = loaded_model(network.test(predictionData)) returnPrice = network.test(predictionData) #result = loaded_model.returnPrice predictedStockPrice = denormalizePrice(returnPrice, predictionData[1], predictionData[2]) predictedStockPrice=math.floor(predictedStockPrice) returnData = {} returnData[a] = predictedStockPrice con = sql.connect("EBL.db") cur = con.cursor() pussy += [predictedStockPrice] #pussy[a]=predictedStockPrice cur.execute('update {} set prediction = ? WHERE (id = ?)'.format(y), (pussy[a], a+11,)) #cur.execute('insert into fuche (lamo) values (?) WHERE (id = 5)', (returnData[a],)) Working code con.commit() ''' for x in range (0,9): cur.execute ('SELECT * FROM plcs WHERE id=(SELECT max(id)-? FROM plcs)', (x,)) print(x) result = cur.fetchall() for row in result: #print (result) print (row[0]) ''' #cur.execute ('SELECT COUNT(1) from {}'.format(y) ) # totalrow = cur.fetchone()[0] #con.commit() #cur.execute('UPDATE fuche set lamo = "maya" where id = (?)', (a)) # con.commit() #print ("Return price") #print (returnData['price']) #print ("Prediction") #conn = sqlite3.connect('EBL.db') #curs = conn.cursor() #nm = '2036-12-30' #addr = '230' #city = '776' # curs.execute("INSERT INTO banks (date, value, luck) VALUES (?,?,?)",(nm, addr, returnData[a]) ) #conn.commit() # to insert the predicted value inside the database #print (returnData[a]) # print (b) for bipin in range (0, 9): xdata=[] for r in range (0,10): cur.execute ('SELECT * FROM {} WHERE id=(SELECT max(id)-? FROM {} )'.format(name, name), (r,)) # print(a) result = cur.fetchall() for row in result: #print (result) #print (row[0]) data = row[2] if data==None: data=row[6] xdata.append(data) # print (xdata) fuckoff = getTimeSeriesValues(xdata, 10) f****n = fuckoff[0][0] Predicted = network.test(f****n) predict = float(denormalizePrice(Predicted, f****n[1], f****n[2])) predict=math.floor(predict) # print ("Predicted") # print (predict) cur.execute("SELECT * from {} where id = (SELECT max(id) FROM {})".format(name, name)) result = cur.fetchall() for row in result: x = row[0] print (x) datee=row[1] # print(row[1]+1) # end_date = row[1] + datetime.timedelta(days=10) # print (end_date) date = datetime.strptime(row[1], "%Y-%m-%d") modified_date = date + timedelta(days=1) x = datetime.strftime(modified_date, "%Y-%m-%d") # print(row[1]) cur.execute("insert into {} (date, prediction) values (?, ?)".format(name), (x, predict,)) con.commit() return (returnData[a])
from neuralNetwork import NeuralNetwork from dataset import Dataset import getArgs import gc args = getArgs.train() batch_size = args["batch_size"] dataset = Dataset(args["dataset"]) net = NeuralNetwork(args["epochs"], batch_size, args["learn_rate"], dataset) net.train() net.evaluate(dataset) net.save_model(args["model"]) dataset.save_labels(args["le"])
# 2 Train the neural network # ============================== epochs = 3000 for epoch in range(epochs): for record in training_data_list: # split the record by the ',' semicolon and parse to float values values = record.split(',') # parse x1 and x2 input_vector = [float(values[0]), float(values[1])] # parse output target_value = [float(values[2])] # train neural network neuralNetwork.train(input_vector, target_value) # print status if ((epoch + 1) % 500) == 0: print("epoch: ", epoch + 1) # 3 Show trained neural network # ============================== # generate test values step_width = 0.01 x1_test = [] x2_test = [] for i in range(int(1.0 / step_width) + 1): x1_test.append(i * step_width) x2_test.append(i * step_width)
def trainNeuralNetwork(reload=False, wantDeskew=True): # Get the MNIST data, either by loading saved data or getting it new. X_train, labels_train, X_test, labels_test = get_data(reload, wantDeskew) print("X_train.shape", X_train.shape) print("labels_train.shape", labels_train.shape) # ___________ Initialize the neural network. ____________ neural_net = NeuralNetwork(n_in=X_train.shape[1], n_hid=1200, n_out=10, eta=0.1, decay_const=0.8, alpha=0.9, l2=0.07, batch_size=50, n_epochs=15) # Give training data to neural_net to store and further preprocessing. neural_net.set_data(X_train, labels_train) # Create arrays for plotting results. accuracy = [] loss = [] n_train = int(50e3) n_batches = n_train // neural_net.batch_size batches = np.array_split(np.arange(n_train), n_batches) print("Splitting into", len(batches), "of size", neural_net.batch_size) epochs = np.arange(neural_net.n_epochs) n_iter_total = len(epochs) * len(batches) x_axis = np.arange(0, n_iter_total, n_iter_total // 100) print("preparing to collect", len(x_axis), "points to plot.") print("Beginning", n_iter_total, "iterations of minibatch gradient descent.") for i in epochs: print('\n========== EPOCH {} ======'.format(i)) neural_net.new_epoch(i) for j, batch in enumerate(batches): # Tell neural net what data to train with. neural_net.set_active(batch) # Calculate values along feedforward. X, S_h, H, S_o, O = neural_net.forward_pass() # Get the training loss at this iteration. if i * len(batches) + j in x_axis: print(".", end=" ") sys.stdout.flush() loss.append(neural_net.get_loss()) accuracy.append(neural_net.train_accuracy()) # Update weights via backprop. neural_net.train(X, H, O) # Save Kaggle predictions in CSV file. if True: pred_labels_test = neural_net.predict_test(util.preprocess(X_test)) Id = np.reshape(np.arange(1, 1 + X_test.shape[0]), (X_test.shape[0], 1)) Category = np.reshape(pred_labels_test, (X_test.shape[0], 1)) columns = np.hstack((Id, Category)) np.savetxt('predictions.csv', columns, delimiter=',', header='Id, Category', fmt='%d') neural_net.print_results() util.plot_error(x_axis, loss, accuracy, neural_net.get_params())
def main(): # training sets for the XOR problem only have 4 cases training_sets = [ [[0, 0], [0]], [[0, 1], [1]], [[1, 0], [1]], [[1, 1], [0]] ] # call global variable to use sigmoid for this problem global activation activation = "sigmoid" nn = NeuralNetwork(len(training_sets[0][0]), 5, len(training_sets[0][1]), False) # can use large learning rate due to simple training nn.LEARNING_RATE = 1 temp1, temp2 = [], [] # bigger range = longer training = less error = better results for i in range(10000): training_inputs, training_outputs = random.choice(training_sets) nn.train(training_inputs, training_outputs) temp1.append(i) k = nn.calculate_total_error(training_sets) temp2.append(k) print(i, k) print() test1 = [0, 0] test2 = [0, 1] test3 = [1, 0] test4 = [1, 1] # verify performance print(nn.feed_forward(test1)[0]) print(nn.feed_forward(test2)[0]) print(nn.feed_forward(test3)[0]) print(nn.feed_forward(test4)[0]) print() plt.plot(temp1, temp2) nn.inspect() training_sets = [] # much larger training set to account for many multiplications for i in range(1000): x = random.randint(-100, 100) y = random.randint(-100, 100) training_sets.append([[x / 100.0, y / 100.0], [(x * y) / 10000.0]]) # call global variable to use relu for this problem global activation activation = "relu" nn = NeuralNetwork(len(training_sets[0][0]), 20, len(training_sets[0][1]), True) # smaller learning rate so error rate doesn't stagnate nn.LEARNING_RATE = .05 temp1, temp2 = [], [] # my computer's not fast enough to run a higher value so my error rate is high for i in range(10000): training_inputs, training_outputs = random.choice(training_sets) nn.train(training_inputs, training_outputs) temp1.append(i) k = nn.calculate_total_error(training_sets) temp2.append(k) print(i, k) plot_learning_curves(temp1, temp2) nn.inspect()
input_nodes = 784 hidden_nodes = 200 output_nodes = 10 learning_rate = 0.1 epochs = 2 history_performance = [] training_data = tuple(load_mnist.load_training(output_nodes)) test_data = tuple(load_mnist.load_test()) for i in range(0, 100): scorecard = [] network = NeuralNetwork(input_nodes, hidden_nodes, output_nodes, learning_rate) for row in training_data: network.train(*row) for row in test_data: correct_label = row[1] outputs = network.query(row[0]) label = numpy.argmax(outputs) if label == correct_label: scorecard.append(1) else: scorecard.append(0) performance = sum(scorecard) / len(scorecard) print("ШАГ:", i, "/,", "Эффективность =", performance) history_performance.append(performance)
MNIST_train_ans_set = one_hot_encode(labels=MNIST_train[:, 0:1]) # Pre-processing the images so that, instead of having pixel values in [0, 255], they are normalized to [0, 1]. MNIST_train_inp_set_temp = MNIST_train[:, 1:] / 255 # input matrix; X MNIST_train_inp_set = np.ceil(MNIST_train_inp_set_temp) # Creating a neural network object. MNIST_nn = NeuralNetwork(num_inputs=784, num_hidden=50, num_outputs=10) # Defining a learning rate. eta = 1 # Training the neural network. MNIST_nn.train(ans_set=MNIST_train_ans_set, inp_set=MNIST_train_inp_set, epochs=10, eta=eta, threshold=.02) # Using the trained neural network to generate predictions on the test set. # First, reading in the test set images, and doing the same pre-processing as on the training set. MNIST_test_df = pd.read_csv('MNIST_test.csv') MNIST_test = MNIST_test_df.values # no labels in the test set MNIST_test_inp_set_temp = MNIST_test / 255 # input matrix; X MNIST_test_inp_set = np.ceil(MNIST_test_inp_set_temp) # Transposing the input set so X is a collection of column vectors, each column representing an image. MNIST_test_inp_set_transpose = np.transpose(MNIST_test_inp_set) # Loop through and feed forward every image to generate the prediction.
epochs = 1 for e in range(epochs): # go through all records in the training data set for i, record in enumerate(training_data_list): print(str(((i + 1) / len(training_data_list) * 100) / epochs) + "%") # split the record by the ',' commas all_values = record.split(',') # scale and shift the inputs inputs = (np.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01 # create the target output values (all 0.01, except the desired label which is 0.99) targets = np.zeros(output_nodes) + 0.01 # all_values[0] is the target label for this record targets[int(all_values[0])] = 0.99 n.train(inputs, targets) pass pass # load the mnist test data CSV file into a list test_data_file = open("data/mnist_test.csv", 'r') test_data_list = test_data_file.readlines() test_data_file.close() # test the neural network # scorecard for how well the network performs, initially empty scorecard = [] # go through all the records in the test data set for record in test_data_list:
import pandas as pd # Importing time to time execution - https://pythonhow.com/measure-execution-time-python-code/ import time # Starting off the timer start = time.time() # Importing the excel data for the XOR problem. Pandas dataframe. df = pd.read_excel('XOR_dataset.xlsx', 'Sheet1') # Numpy array - https://stackoverflow.com/questions/13187778/convert-pandas-dataframe-to-numpy-array-preserving-index data = df.values ans_set = data[:, 0:1] # first column; Y inp_set = data[:, 1:] # input matrix; X # Defining a learning rate eta = 0.5 # Creating a neural network object. nn = NeuralNetwork(2, 6, 1) # Training the neural network. nn.train(ans_set, inp_set, 15000, eta) # Validating the neural network. print('\nValidation Success rate: ', nn.validate(ans_set, inp_set)) # Printing the execution time end = time.time() print('Execution time (s): ', format(end - start, '.10f'))
expected_outputs = np.array([ [1], [0], [0], [0], [0], [0], [0], [0], ]) # This learning rate is extremely high, yet yields very good results. # I think this is due to the fact that the perfect output values are 0 and 1 and the sigmoid function is only 0 or 1 at its extremes # and needs an infinite input for that. To do this the network is trying to train infinite weights. nn.train(inputs, expected_outputs, learning_rate, epochs) print('After training:') MSE = 0.0 for input, expected_output in zip(inputs, expected_outputs): output = nn.activate(input) print('{} -> {}'.format(input, output)) MSE += ((expected_output - output)**2).sum() print('MSE: {}\n'.format(MSE / len(inputs))) # 4.3 C. XOR and Back-propagation # Neural Network Settings learning_rate = 20 epochs = 1000 weight_lower_bound = -1 weight_upper_bound = 1
INPUTS = 784 OUTPUTS = 10 HIDDEN = 131 LAYERS = 4 LR = 0.0595 ACT = "sigmoid" EPOCH = 65 DATA = 100 TEST = 500 ds = Dataset() nn = NeuralNetwork(INPUTS, OUTPUTS, HIDDEN, LAYERS, LR, ACT) nn.train(ds.train_data, ds.train_labels_arr, EPOCH, DATA) # counters correct = 0 false = 0 for i in range(TEST): output = nn.feedforward(ds.test_data[i], isRound=False, isSoftmax=True) output_digit = np.where(output == np.amax(output)) if output_digit[0][0] == ds.test_labels[i]: correct += 1 else: false += 1 # calc accuracy accuracy = (correct * 100) / (correct + false) # log accuracy # set file path