def main(): print("Image:") image = input("") features = finding_face_landmark.finding_face_landmark(image) if (len(features) == 0): exit(0) data_file_name = "features.csv" X, Y, Q = utils.get_data(data_file_name, 2000) x_min, x_max = utils.get_min_max(X) X = utils.normalize_features(x_min, x_max, X) test_file_name = "test.csv" T, P, L = utils.get_data_test(test_file_name, x_min, x_max, len(X), Q, Y) model_file_name = './my_test_model.ckpt' neural_network = n.Neural_Network(X, Y, model_file_name) # neural_network.training() # neural_network.test(T,P) features = utils.normalize_features(x_min, x_max, features) predict = neural_network.predict([features]) image_path = Q[predict][0].strip() metadata = 'C:\\ProjekatSoft\\wiki_crop\\wiki.mat' name = utils.get_name(image_path, metadata) percent = utils.get_percent(features, X[predict:predict + 1, :15][0]) utils.show_image('C:\\ProjekatSoft\\wiki_crop\\' + image_path, name, percent)
def ns_loop(data, answers, zet_path): model = neural_network.Neural_Network() while True: os.system('cls') if model.learned: model.model.summary() print('Сеть обучена:', model.learned) key = int( input("1. Обучить нейронную сеть.\n" "2. Сохранить нейронную сеть.\n" "3. Загрузить нейронную сеть.\n" "4. Запуск\n" '5. Графики\n' '6. TT\n' "0. Назад.\n")) if key == 1: model.fit_model(data, answers) elif key == 2: model.save_neural_network() elif key == 3: model.load_neural_network() elif key == 4: model.work_neural_network(app, zet_path) elif key == 5: model.plotting() elif key == 6: model.test() elif key == 0: return
def __init__(self, ai): self.heros = [] self.ai = ai network_data_list = self.ai.manager.create_Generation() for network_data in network_data_list: network = neural_network.Neural_Network(config.network[0], config.network[1], config.network[2]) network.setNetwork(network_data) hero = Hero(network) self.heros.append(hero)
def __first_generation(self): ''' 创建第一个世代 :return: 世代中所有个体的神经网络数据 ''' network_data_list = [] for i in range(config.population): network = neural_network.Neural_Network(config.network[0], config.network[1], config.network[2]) network_data_list.append(network.getNetwork()) return network_data_list
def test_dropout_shake(): structure = [3, 4, 2] dropout = [0, 0.9, 0] dnn = nn.Neural_Network(structure, dropout) dnn.do[0] = np.array([[0, 0, 1], [0, 1, 1], [1, 0, 1]]) dnn._Neural_Network__dropout_shake(False) assert np.all(dnn.do[0] == np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])) assert np.all(dnn.do[1] == np.array([ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], ]))
def main (args=None): if args is None: args = sys.argv[1:] # gather data set dataX = d.x dataY = d.y # shuffle to ensure random testing data set np.random.shuffle(dataX) np.random.shuffle(dataY) # split up the data set training_split = .5 train_x_index = int(math.floor(len(dataX)*training_split)) train_y_index = int(math.floor(len(dataY)*training_split)) test_x_index = int(math.floor(len(dataX)*(1-training_split))) test_y_index = int(math.floor(len(dataY)*(1-training_split))) # training data trainX = np.array(tuple(dataX[:train_x_index]), dtype=float) trainY = np.array(tuple(dataY[:train_y_index]), dtype=float) # testing data testX = np.array(tuple(dataX[test_x_index:]), dtype=float) testY = np.array(tuple(dataY[train_y_index:]), dtype=float) # normalize inputs trainX = trainX/np.amax(trainX, axis=0) testX = testX/np.amax(testX, axis=0) # evaluate number of input/ouput neurons inputs = len(trainX[0]) outputs = len(trainY[0]) # train neural net NN = nn.Neural_Network(inputs, outputs, Lambda=0.001) T = t.trainer(NN) T.train(trainX, trainY, testX, testY) # print results results = NN.forward(testX) i = 0 for r in results: line = "Prediction: " + str("{:4.2f}").format(r[0]) + "; " line += "Actual: " + str("{:4.2f}").format(testY[i][0]) + "; " line += "Delta: " + str("{:4.2f}").format(testY[i][0] - r[0]) + "; " print line i = i + 1
def test_main_or_without_dropout(): datasetsize = 8 batchsize = 4 td_num = 2 tl_num = 2 # set data trainData = np.ones([datasetsize, batchsize, td_num]) trainLabel = np.zeros([datasetsize, batchsize, tl_num]) # ニューラルネットワークの生成 structure = [td_num + 1, 3, tl_num] myNN = nn.Neural_Network(structure) epoch = 10 # 学習 for i in range(epoch): myNN.train(trainData, trainLabel)
def test_forwordpropagation(): batchsize = 4 td_num = 2 tl_num = 2 test = np.array([[0.51301977, 0.52648607], [0.51301977, 0.52648607], [0.51301977, 0.52648607], [0.51301977, 0.52648607]]) # set data trainData = np.ones([batchsize, td_num]) # ニューラルネットワークの生成 structure = [td_num + 1, 3, tl_num] myNN = nn.Neural_Network(structure, w_method="test") # test myNN.forwardpropagation(trainData, batchsize) assert np.allclose( myNN.z[-1], test), "dnn/neural_network/forwardpropagaiton is output error"
def game_init(self): self.Running = True self.line = Line() weight_array = np.loadtxt("./res/my_modle.csv") network = neural_network.Neural_Network(config.network[0], config.network[1], config.network[2]) data = network.getNetwork() if len(data['weights']) == len(weight_array): for i in range(len(data['weights'])): data['weights'][i] = weight_array[i] network.setNetwork(data) self.hero = Hero(network) self.score = Score() self.obstacal_manager = ObstacleManager(self.surface, self.score, self.hero)
def train(path_to_images, csv_file): '''s Method to perform preprocessing on input images. Args: path_to_images = path to jpg image files csv_file = path and filename to csv file containing frame numbers and steering angles. Returns: NN = Trained Neural Network object ''' # Import Steering Angles CSV data = np.genfromtxt(csv_file, delimiter = ',') frame_nums = data[:,0] steering_angles = data[:,1] im_train_X = [] for frame_number in range(len(frame_nums)): temp = cv2.imread(path_to_images + '/' + str(int(frame_number)).zfill(4) + '.jpg') temp_resized = cv2.resize(temp, (60, 64)) temp_crop = crop_center(temp_resized) temp_lane = select_rgb_white_yellow(temp_crop) temp_gray = convert_to_grayscale(temp_lane) im_train_X.append(list(temp_gray.ravel())) rawangles = steering_angles steering_angles = signal_sci.savgol_filter(steering_angles, 3, 2) encoded_angles = encoder(steering_angles) trainX = np.array(im_train_X) trainY = encoded_angles trainX = trainX / 255 NN = ann.Neural_Network(rawangles) T = ann.trainer(NN) T.train(trainX,trainY) return NN
def create_next_generation(self): #1.选取精英个体直接遗传 network_data_list = [] for i in range(round(config.population * config.elite)): network_data_list.append(self.genomes[i].data) #2.创建一部分随机个体 for i in range(round(config.population * config.new_bron)): network = neural_network.Neural_Network(config.network[0], config.network[1], config.network[2]) network_data_list.append(network.getNetwork()) while True: if len(network_data_list) == config.population: break father = self.genomes[random.randint( 0, round(config.population / 2) - 1)] mother = self.genomes[random.randint(round(config.population / 2), config.population - 1)] child = self.breed(father, mother) network_data_list.append(child.data) return network_data_list
#model.add(layers.Dense(512, activation='relu', input_shape=(8, ))) #model.add(layers.Dense(128, activation='relu')) #model.add(layers.Dense(64, activation='relu')) #model.add(layers.Dense(1, activation='sigmoid')) #model.compile(optimizer='Adam', #loss='binary_crossentropy', #metrics=['accuracy']) #model.fit(X_train, y_train, epochs=150, batch_size=16) #Y_pred = model.predict(X_val) #score=model.evaluate(X_val,y_val,verbose=0) #nnh.kerasEval(Y_pred,y_val) #print(score) neuralNatwork = nn.Neural_Network(X_train,X_val,y_train,y_val,id_train,id_val,nnConfig) neuralNatwork.initializeWeights() neuralNatwork.trainNetwork() print(np.mean((neuralNatwork.initialNNParams==neuralNatwork.trainedParams).astype(int))) nnh.predict(neuralNatwork.Xtrain,neuralNatwork.yTrain,neuralNatwork.trainedParamsShaped) nnh.predict(neuralNatwork.Xval,neuralNatwork.yVal,neuralNatwork.trainedParamsShaped) testPred=nnh.testPred(X_test,neuralNatwork.trainedParamsShaped) print(id_test.shape) testRes=pd.DataFrame(data=np.column_stack((id_test,testPred)),columns=['PassengerId','Survived']) testRes=testRes.astype(int) #testRes=testRes.drop(testRes.columns[0],axis=1) print(testRes)
print() print(description) # Build training data grids = [] training_data = [] grids.append(init_grid) for i in range(frame_count): grids.append(next_grid(grids[i], my_rule)) training_data.extend(next_training_data(grids[i], my_rule)) print_grid(grids[i+1], height, width) test_points, test_inputs = input_data(grids[frame_count]) grids.append(next_grid(grids[frame_count], my_rule)) my_neural_network = nn.Neural_Network(num_inputs, num_outputs, hidden_layer_sizes) # # Train network # start_time = time.perf_counter() my_neural_network.train_in_batches(training_data, 10, 10000, learning_rate) print("Training took: ", time.perf_counter() - start_time) # # Print answer # prediction_grid = {} for point, test_input in zip(test_points, test_inputs):
import preprocess import neural_network as net import numpy as np import time import csv NN = net.Neural_Network() NN.W1 = np.loadtxt("saved_data/W1.txt") NN.W2 = np.loadtxt("saved_data/W2.txt") x = np.loadtxt("saved_data/x.txt") y = np.loadtxt("saved_data/y.txt") def train(): time_taken = 0 training_size = input("What size would you like the training set to be?: ") print() print("ok, building the training data ...") start = time.time() x, y, samples = preprocess.get_training_data(int(training_size)) T = net.trainer(NN) print() print("Now training the network.") print() T.train(x, y) end = time.time() time_taken = end - start np.savetxt("saved_data/W1.txt", NN.W1)
import doc_maker import unbuffered import cleaner s, timestamp, commitid, branchname = doc_maker.getdata("dnn") stdout_stream = io.StringIO() sys.stdout = unbuffered.Unbuffered(sys.stdout, stdout_stream) datasize = 20 batch = 4 logic = "and" # set data trainData, trainLabel, testData, testLabel = dataset.logic( logic, datasize, batch) # ニューラルネットワークの生成 structure = [2 + 1, 5, 2] myNN = nn.Neural_Network(structure) # # 学習 epoch = 1000 for i in range(epoch): myNN.train(trainData, trainLabel) myNN.test(testData, testLabel) doc_maker.docmaker(s, timestamp, stdout_stream.getvalue(), commitid, branchname) atool.draw(myNN.cost, timestamp) atool.accurancygraph(myNN.accurancy, timestamp) #atool.tdchart(myNN) npfiles.save(myNN.weight, timestamp) cleaner.clean()
# WOW import numpy as np import neural_network as neurn X = np.array(([2, 9], [1, 5], [3, 6]), dtype=float) y = np.array(([92], [86], [89]), dtype=float) X = X/np.amax(X, axis=0) y = y/100 nn = neurn.Neural_Network() xPredicted = np.array(([4,8]), dtype=float) xPredicted = xPredicted / np.amax(xPredicted, axis=0) # V2 for i in range(100000): print("Input: \n" + str(X)) print("Actual Output: \n" + str(y)) print("Predicted Output: \n" + str(nn.forward(X))) print("Loss: \n" + str(np.mean(np.square(y - nn.forward(X))))) print("\n") nn.train_AI(X, y) nn.predict(xPredicted)
x_train = combined_train[sample].values y_train = np.array([td.targets[sample].values]).T x_cv = combined_train[~sample].values y_cv = np.array([td.targets[~sample].values]).T x_test = td.combined[891:].values print('combined: ', td.combined.shape, ', x_train: ', x_train.shape, ', x_cv: ', x_cv.shape, ', x_test: ', x_test.shape) print('\n\n') NN = nn.Neural_Network(dimensionality=x_train.shape[1],hidden_size=400,\ output_size=1,learning_rate=0.01,\ dropout_hidden_rate=0.5,do_dropout=True,\ error_function='cross_entropy',do_regularize=True,\ regularization_rate=10,add_bias=True,use_nesterov_momentum=False,\ momentum_rate=0.5,do_random_seed=True,random_seed=1) #start_time = time.time() #for i in range(1000): # NN.learn_using_gradient_descent(x=x_train,y=y_train,current_iteration=i,\ # print_loss_every=100,clip=True) #print('\n\n') #print("--- %s seconds ---" % (time.time() - start_time)) #print('\n\n') #print('Accuracy on CV with gradient descent: ', NN.accuracy(x_cv,y_cv, 0.5)) #print('\n\n')
dummy_rows = [] for i in np.arange(0, len(settings)): if len(settings[i, 0]) == 1: dummy_rows.append(i) settings = np.delete(settings, dummy_rows, axis=0) print(settings) models = [] for i in np.arange(0, len(settings)): hn = settings[i, 0] lr = settings[i, 1] # mr = settings[i, 2] mr = 'NA' print(hn) models.append(nn.Neural_Network(size_input, hn)) models[i].train(X_train, y_train, X_val, y_val, lr, number_of_epochs, batch_size, mr) plt.figure(i) plt.subplot(211) plt.title("HN: {0}, LR: {1}, MR: {2}".format(hn, lr, mr)) # plt.xlabel('Epoch') plt.ylabel('Average Loss Value') plt.plot(models[i].training_history, 'k-', models[i].validation_history, 'r-') plt.subplot(212) plt.plot(models[i].training_history_bin_err, 'b-', models[i].validation_history_bin_err, 'r-') plt.xlabel('Epoch') plt.ylabel('Average Binary Error') plt.savefig('figure_' + str(i) + '.svg')
def test_save_weight(): structure = [2 + 1, 3, 3] test_nn = nn.Neural_Network(structure) npfiles.save(test_nn.weight, "test")
def get_neural_network(self): return neural_network.Neural_Network(self.objvars)
import sys if __name__ == '__main__': print 'network training' datapath = 'parameter/mnist_dropout/' #datapath = 'parameter/init_params/' training_data, validation_data, test_data = loader.load_data_wrapper() epochs = 50 mini_batch_size = 1 learning_rate = 0.01 dropout_rate = (0.8, 0.9) net = network.Neural_Network([784, 30, 10], dropout_rate) net.set_test(test_data) net.set_validation(validation_data) train = True #train = False if train: #net.load_parameter(path=datapath) net.train(training_data, epochs, mini_batch_size, learning_rate) print 'save parameter? (y/n)' if 'y' in sys.stdin.readline(): net.save_parameter(path=datapath) print 'Saved' else: net.load_parameter(path=datapath) net.feed_forward(test_data)
class Logic(object): logic_and = [[[0, 0], 0], [[0, 1], 0], [[1, 0], 0], [[1, 1], 1]] logic_or = [[[0, 0], 0], [[0, 1], 1], [[1, 0], 1], [[1, 1], 1]] logic_exor = [[[0, 0], 0], [[0, 1], 1], [[1, 0], 1], [[1, 1], 0]] def vectorize(x): ret = np.zeros((2, 1)) ret[x] = 1 return ret if __name__ == '__main__': print 'network training' datapath = 'parameter/logic/or/' logic = Logic() data = logic.logic_or training_data = [(np.array(x), vectorize(y)) for x, y in data] test_data = [(np.array(x), y) for x, y in data] epochs = 300 mini_batch_size = 1 learning_rate = 0.5 net = network.Neural_Network([2, 3, 2]) net.train(training_data, epochs, mini_batch_size, learning_rate) net.save_parameter(datapath) net.feed_forward(test_data)