def __init__(self, position, direction, tick_count, configuration, parent=None): self.id = random.getrandbits(32) self.position = position self.direction = direction self.health = configuration["Agent_Health"] self.birth = tick_count self.age = 0 self.configuration = configuration if parent is None: self.neural_network = NeuralNetwork(configuration["Neural_Network_Nodes_In_Layers"]) self.neural_network.mutate(1) else: self.neural_network = deepcopy(parent.neural_network) self.generation = parent.generation + 1 self.mutate()
def __init__(self, buy_in, n_players, ID=0): self.n_opponents = n_players - 1 self.states = [buy_in, 0, None] # [current funds, bet amount, action] self.earnings = 0 self.id = ID self.evaluator = Evaluator() self.n_opponents = n_players - 1 self.earnings = 0 self.id = ID self.evaluator = Evaluator() self.num_opp_actions = 5 self.num_feature_elements = 52 + (self.num_opp_actions * self.n_opponents) + 3 self.batch_size = 50000 # could have this as a parameter # initialize neural network self.network = NeuralNetwork(test_mnist=False, input_layer_size=self.num_feature_elements) # array of feature vectors self.X_train = np.empty([self.batch_size, self.num_feature_elements]) # array of target values (i.e. Q(feature vector)) self.y_train = np.empty([self.batch_size, 1]) self.prev_state_action_vector = None self.e = 0.3 # value for e-greedy self.iteration_num = 0
def main(): script = str(sys.argv[1]) epochs = 3000 # script = 'example' if script == "example": x = np.array([[0.05, 0.1]]) y = np.array([[0.01, 0.99]]) desired_y = np.array([[0.773, 0.778]]) # After one training step (epoch) parameters = { "num inputs" : 2, "num outputs" : 2, "num hidden layers" : 1, "num neurons" : 2, "activations": ['sigmoid'] * 2, "learning rate": 0.5, "loss function": 'squared error' } nn = NeuralNetwork(parameters) # In this example, don't use randomly-initialized weights - use the ones from the example. So, to make things # simple, just over-write the existing, randomly-initialized weights from the NeuralNetwork instantiation. weights = np.array([[0.15, 0.20, 0.25, 0.30], [0.40, 0.45, 0.50, 0.55]]) biases = np.array([[0.35, 0.35], [0.60, 0.60]]) for l in range(0, len(nn.layers)): nn.layers[l].weights = weights[l] nn.layers[l].biases = biases[l] nn.layers[0].neurons[0].weights = weights[0, 0:2] nn.layers[0].neurons[1].weights = weights[0, 2::] nn.layers[0].neurons[0].bias = biases[0, 0] nn.layers[0].neurons[1].bias = biases[0, 1] nn.layers[1].neurons[0].weights = weights[1, 0:2] nn.layers[1].neurons[1].weights = weights[1, 2::] nn.layers[1].neurons[0].bias = biases[1, 0] nn.layers[1].neurons[1].bias = biases[1, 1] nn.train(x, y, epochs=1) new_output = nn.calculate(x) # Print to screen print('\n') print('Class example: single epoch') print('--------------------------------------------------------------------------------') print('Initial output is: {}. After one training step, the next output should be {}, (with sigmoid activation).'.format(y, desired_y)) print('New output is... {}'.format(new_output)) elif script == "and": x = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) y = np.array([0, 0, 0, 1]) parameters = { "num inputs": 2, "num outputs": 1, "num hidden layers": 0, "num neurons": 0, "activations": ['sigmoid'], "learning rate": 0.1, "loss function": 'squared error' } nn = NeuralNetwork(parameters) nn.train(x, y, epochs=epochs) # Plotting plt.plot(nn.loss_epoch) plt.grid() plt.xlabel('Epoch') plt.ylabel('Loss') plt.title('AND Neural Network, {} activation and \n {} loss'.format(parameters['activations'][0], parameters['loss function'])) plt.show() # Printing to screen print('\n') print('AND Gate Perceptron:') print('--------------------------------------------------------------------------------') print('For y = 1, output should be >= 0.5. For y = 0, output should be < 0.5.') for input, output in zip(x, y): print("MULTI-LAYER PERCEPTRON: Output for input x = {} should be y = {}. Computed value: {}".format(input, output, nn.calculate( input))) elif script == "xor": x = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) y = np.array([0, 1, 1, 0]) parameters_perceptron = { "num inputs": 2, "num outputs": 1, "num hidden layers": 0, "num neurons": 0, "activations": ['sigmoid'], "learning rate": 0.1, "loss function": 'squared error' } parameters_multilayer_perceptron = { "num inputs": 2, "num outputs": 1, "num hidden layers": 1, "num neurons": 4, "activations": ['sigmoid'] * 2, "learning rate": 0.1, "loss function": 'squared error' } nn_single = NeuralNetwork(parameters_perceptron) nn_single.train(x, y, epochs=epochs) nn_multi = NeuralNetwork(parameters_multilayer_perceptron) nn_multi.train(x, y, epochs=epochs) # Plotting plt.plot(nn_single.loss_epoch, label='Single Perceptron') plt.ylabel('Loss') plt.plot(nn_multi.loss_epoch, label='Multi-layer Perceptron') plt.grid() plt.xlabel('Epoch') plt.ylabel('Loss') plt.legend(loc='upper right') plt.title('XOR Neural Network {} activation and \n {} loss'.format( parameters_multilayer_perceptron['activations'][0], parameters_multilayer_perceptron['loss function'])) plt.show() # Printing results to screen print('\n') print('XOR Gate: Single-layer Perceptron:') print('--------------------------------------------------------------------------------') print('For y = 1, output should be >= 0.5. For y = 0, output should be < 0.5.') for input, output in zip(x, y): print("SINGLE PERCEPTRON: Output for input x = {} should be y = {}. Computed value: {}".format(input, output, nn_single.calculate(input))) print('\n') print('XOR Gate: Multi-layer Perceptron:') print('--------------------------------------------------------------------------------') print('For y = 1, output should be >= 0.5. For y = 0, output should be < 0.5.') for input, output in zip(x, y): print("MULTI-LAYER PERCEPTRON: Output for input x = {} should be y = {}. Computed value: {}".format(input, output, nn_multi.calculate( input)))
class NNAgent(Agent): def __init__(self, buy_in, n_players, ID=0): self.n_opponents = n_players - 1 self.states = [buy_in, 0, None] # [current funds, bet amount, action] self.earnings = 0 self.id = ID self.evaluator = Evaluator() self.n_opponents = n_players - 1 self.earnings = 0 self.id = ID self.evaluator = Evaluator() self.num_opp_actions = 5 self.num_feature_elements = 52 + (self.num_opp_actions * self.n_opponents) + 3 self.batch_size = 50000 # could have this as a parameter # initialize neural network self.network = NeuralNetwork(test_mnist=False, input_layer_size=self.num_feature_elements) # array of feature vectors self.X_train = np.empty([self.batch_size, self.num_feature_elements]) # array of target values (i.e. Q(feature vector)) self.y_train = np.empty([self.batch_size, 1]) self.prev_state_action_vector = None self.e = 0.3 # value for e-greedy self.iteration_num = 0 # get output of neural network def Q(self, vector): return self.network.predict(vector) def trainQ(self): self.network.updateData(train_data=self.X_train, train_labels=self.y_train, input_layer_size=self.num_feature_elements) self.network.train(num_epochs=10) def getAction(self, game, call, raise_amt): cur_funds = self.states[0] cur_bet = self.states[1] diff = call - cur_bet raise_bet = diff + raise_amt action = None # can't call if diff > cur_funds: action = 'F' # can't raise if raise_bet > cur_funds: action_set = ['F', 'C'] # can do anything else: action_set = ['F', 'C', 'R'] # 52 elements to represent the hand, number opponents elements * 3 elements to represent last actions, 3 elements to represent agents action state_action_vector = np.zeros(52 + self.num_opp_actions * self.n_opponents + 3) # indicating the hand state_action_vector[getCardNum(self.hole_cards[0])] = 1 state_action_vector[getCardNum(self.hole_cards[1])] = 1 other_player_actions = tuple(game.last_player_actions) # indicating the opp. actions for i in xrange(self.n_opponents): state_action_vector[52 + self.num_opp_actions * i + action_numbers[other_player_actions[i]]] = 1 num_state_features = 52 + (self.num_opp_actions * self.n_opponents) if not action: # net has not been trained yet if self.iteration_num < self.batch_size: max_action_value = 0 action = random.choice(action_set) else: r = random.uniform(0, 1) max_action_value = -np.inf max_legal_action_value = -np.inf # might not be able to do every action # choose best possible action for (i, a) in enumerate(actions): state_action_vector[num_state_features + i] = 1 action_value = self.Q(state_action_vector) if action_value > max_action_value: max_action_value = action_value if a in action_set: if action_value > max_legal_action_value: max_legal_action_value = action_value action = a state_action_vector[num_state_features + i] = 0 # e-greedy exploration if r < self.e: action = random.choice(action_set) else: max_action_value = 0 # print action state_action_vector[num_state_features + action_numbers[action]] = 1 if self.prev_state_action_vector is not None: self.X_train[self.iteration_num % self.batch_size] = self.prev_state_action_vector self.y_train[self.iteration_num % self.batch_size] = np.array(max_action_value) self.iteration_num += 1 if self.iteration_num % self.batch_size == 0: self.trainQ() self.prev_state_action_vector = state_action_vector return action # add reward to training set def QReward(self, reward): if self.prev_state_action_vector is not None: self.X_train[self.iteration_num % self.batch_size] = self.prev_state_action_vector self.y_train[self.iteration_num % self.batch_size] = np.array(reward) self.iteration_num += 1 if self.iteration_num % self.batch_size == 0: self.trainQ() self.prev_state_action_vector = None
): # none of the cards with same suit and lower value as the current card should have all of their identical cards discarded graveyard[i] = 0 graveyard[ int(card) - 1] = 1 # This one means that all the cards identical to the current card have been discarded but not the current card, which is necessary but not in keeping with the other slots graveyard += card.toBinary() return graveyard if __name__ == '__main__': for i in range(10): seed = random.randint(-65536, 65535) # -13920 good seed random.seed(seed) print("seed : ", seed) nn = NeuralNetwork(neuronsPerLayer=[31, 31, 1]) kb = [] testKB = [] for i in range(10000): kb.append((generateDispensableCard(), [1])) kb.append((generateIndispensableCard(), [0])) for i in range(1000): testKB.append((generateDispensableCard(), [1])) testKB.append((generateIndispensableCard(), [0])) untrainedErrorOnKB = nn.test(knowledgeBase=kb) print("untrainedErrorOnKB : ", untrainedErrorOnKB) untrainedErrorOnTest = nn.test(knowledgeBase=testKB) print("untrainedErrorOnTest : ", untrainedErrorOnTest)
class Agent: id = None position = [] direction = None # 0 to 1 clockwise, 0 is facing up position_change_x = 0 # TODO: store as array (causes bug) position_change_y = 0 direction_change = None health = None birth = None age = None configuration = {} neural_network = None sensors = [] output = [] marked = False generation = 0 last_attacked_by = None def __init__(self, position, direction, tick_count, configuration, parent=None): self.id = random.getrandbits(32) self.position = position self.direction = direction self.health = configuration["Agent_Health"] self.birth = tick_count self.age = 0 self.configuration = configuration if parent is None: self.neural_network = NeuralNetwork(configuration["Neural_Network_Nodes_In_Layers"]) self.neural_network.mutate(1) else: self.neural_network = deepcopy(parent.neural_network) self.generation = parent.generation + 1 self.mutate() def eat(self): self.health += self.configuration["Food_Value"] def perform_attack(self, agents): self.health -= self.configuration["Agent_Attack_Cost"] for agent in agents: if agent != self: distance = self.get_distance(agent.position, self.configuration["Agent_Attack_Range"]) if distance < self.configuration["Agent_Attack_Range"]: agent.get_attacked(self) def get_attacked(self, other_agent): self.health -= self.configuration["Agent_Attack_Damage"] self.last_attacked_by = other_agent def get_distance(self, position, max_range): distance_x = self.position[0] - position[0] distance_y = self.position[1] - position[1] if abs(distance_x) <= max_range and abs(distance_y) <= max_range: distance = math.sqrt(math.pow(distance_x, 2) + math.pow(distance_y, 2)) return distance else: return 999999 def get_information_string(self, tick_count): string = "Sensors: [" + ", ".join(str(e) for e in self.sensors) + "]\n" string += "Output: [" + ", ".join(str(e) for e in self.output) + "]\n" string += "Position: [" + str(round(self.position[0], 2)) + ", " + str(round(self.position[1], 2)) + "]\n" string += "Health: " + str(round(self.health, 2)) + "\n" string += "Age: " + str(tick_count - self.birth) + "\n" string += "Generation: " + str(self.generation) + "\n" return string def react(self, sensors): self.output = self.neural_network.feed(sensors) def mutate(self): self.neural_network.mutate(self.configuration["Neural_Network_Mutate"])
lg.Logger(parser.h_params.expt_dir + '/log_loss_train.txt', loss_formatter), 'valid_loss_logger': lg.Logger(parser.h_params.expt_dir + '/log_loss_valid.txt', loss_formatter), 'test_loss_logger': lg.Logger(parser.h_params.expt_dir + '/log_loss_test.txt', loss_formatter), 'train_error_logger': lg.Logger(parser.h_params.expt_dir + '/log_error_train.txt', error_formatter), 'valid_error_logger': lg.Logger(parser.h_params.expt_dir + '/log_error_valid.txt', error_formatter), 'test_error_logger': lg.Logger(parser.h_params.expt_dir + '/log_error_test.txt', error_formatter) } else: loggers = {} neural_net = NeuralNetwork(parser.h_params.sizes, loss, activation_function, activation_prime, act_f.softmax, loggers, parser.h_params.expt_dir, parser.h_params.save_dir, parser.h_params.anneal) neural_net.stochastic_gradient_descent( training, validation, testing, parser.h_params.batch_size, parser.h_params.epochs, parser.h_params.lr, parser.h_params.momentum, parser.h_params.lmbda, nesterov, adam, build_logs)
""" random.seed(seed) fireWork = Card() card = Card() while not (fireWork.getSuit() == card.getSuit() and fireWork.getValue() == card.getValue() - 1): fireWork.setSuit(Suit(random.randint(1, 5))) fireWork.setValue(random.randint(1, 5)) card.setSuit(Suit(random.randint(1, 5))) card.setValue(random.randint(1, 5)) return (Suit.toInt(fireWork.getSuit()), fireWork.getValue(), Suit.toInt(card.getSuit()), card.getValue()) if __name__ == '__main__': nn = NeuralNetwork(neuronsPerLayer=[4, 4, 1]) trainKB = [] testKB = [] for i in range(2000): trainKB.append((generateGoodCombo(), [1])) trainKB.append((generateBadCombo(), [0])) testKB.append((generateGoodCombo(), [1])) testKB.append((generateBadCombo(), [0])) untrainedErrorOnKB = nn.test(knowledgeBase=trainKB) untrainedErrorOnTest = nn.test(knowledgeBase=testKB) trainedErrorOnKB1 = nn.train(knowledgeBase=trainKB) for _ in range(10): nn.train(knowledgeBase=trainKB, doTests=False) print() trainedErrorOnKB10 = nn.test(knowledgeBase=trainKB)
graveyard[(Suit.toInt(card.getSuit()) - 1) * 5] = random.randint(0, 2) for i in range((Suit.toInt(card.getSuit()) - 1) * 5 + 1, int(card) - 1): graveyard[i] = random.randint(0, 1) graveyard[int(card) - 1] = 0 if card.getValue() == 5 else 2 if card.getValue() == 1 else 1 # 5 can't be discarded must be the last 1 must be the last of its kind graveyard.append(Suit.toInt(card.getSuit())) graveyard.append(card.getValue()) return graveyard if __name__ == '__main__': for i in range(10): seed = random.randint(-65536, 65535) random.seed(seed) nn = NeuralNetwork(neuronsPerLayer=[27, 50, 5, 1]) kb = [] testKB = [] for i in range(10000): kb.append((generateDispensableCard(), [1])) kb.append((generateIndispensableCard(), [0])) for i in range(1000): testKB.append((generateDispensableCard(), [1])) testKB.append((generateIndispensableCard(), [0])) untrainedErrorOnKB = nn.test(knowledgeBase=kb) untrainedErrorOnTest = nn.test(knowledgeBase=testKB) trainedErrorOnKB1 = nn.train(knowledgeBase=kb) for _ in range(1000): nn.train(knowledgeBase=kb, doTests=False)
""" Play a game to save the best computed moves and feed the neural network . Arg: -model : our neural network. """ log = neuralNetAutoMain(neuralNet=net) score = log[-1].getScore() net.train(log2kb(log, score), doTests=False) print(score) return score if __name__ == '__main__': for j in range(10): nn = NeuralNetwork(neuronsPerLayer=[ 93, 40, 1 ]) # 93 inputs with a hidden layer of 40 nodes and 1 output scores = [0 for _ in range(5000)] i = 0 while mean(scores) < 20: scores[i % 5000] = trainOnGame(net=nn) if i % 5000 == 0: with open("scores" + str(j) + ".csv", mode='a') as file: file.write(str(mean(scores)) + ";") i += 1 print(i, end="\t") file.close()
from neuralnet import NeuralNetwork from logistic import LogisticRegression nn = NeuralNetwork() nn.test_nn_gradient()
test_y['pred_dead'] = [np.rint(x) for x in test_y['pred_dead']] cost = ((test_y['pred_survived'] - test_y['Survived'])**2).mean() test_y = test_y[['pred_survived']] test_y.columns = ['Survived'] return test_y, cost if __name__ == '__main__': x, y = prep_train_data() test_x, test_y = prep_test_data() h_layers = [10, 10] inputs = x.values outputs = y.values nn = NeuralNetwork(n_inputs=4, n_outputs=2, h_layers=h_layers, inputs=inputs, expected_outputs=outputs) nn.open_session() nn.make_model(is_weights_rand=True) nn.make_tensor_board() s = time.time() nn.train(epochs=999, learning_rate=0.01, isliveplot=False) raw_outputs, _ = nn.test(test_inputs=test_x.values, test_outputs=test_y.values) test_y, cost = categorize_output(raw_outputs, test_y) test_y.to_csv('./data/my_submission.csv') print('cost: ', cost) e = time.time() - s print("Training took ", e, "seconds") nn.close_session()
[7.68, 2.43], [6.45, 1.23], [9.56, 0.78], [5.34, 2.67], [8.21, 4.21], [7.54, 1.88], [6.77, 3.56], [9.0, 2.56], [8.0, 2.0], [2.31, 11.0], [7.0, 4.5] ], dtype=float) answers = np.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], dtype=float) nn = NeuralNetwork(2, 3, 1, 0.1) # training neural network for i in range(0, 100000): random_index = np.random.randint(0, np.size(answers)) nn.train(inputs[random_index], answers[random_index]) print("Training Complete\n") # Get insect dimension from end user input_width = float(input("Enter insect width:\t\t")) input_length = float(input("Enter insect length:\t")) # Get a trained guess output = nn.feed_forward([input_width, input_length])
def main(): #这里tr_data:each row is a training sequence数据表示为 #item编号 #training_data:[batch_size,seqlen+1,onehot_size] tr_data = getTrainData() seqlen = 9 onehot_size = 3953 hidden_dims = [300, 200, 100, 50] #参数有:n_step,hidden_size,item_code_size,u_code_size,latent_vec_size model = NeuralNetwork(seqlen, onehot_size, hidden_dims) #训练轮数 n_epoch = 6 learning_rate = 0.1 #train_input = tr_data[:,:-1] #train_target = tr_data[:,-1] #batch_size = train_input.shape[0] batch_size = 10000 total_size = tr_data.shape[0] n_batch = total_size / batch_size optimizer = tf.train.GradientDescentOptimizer(learning_rate) begintrain = time.time() print "start train" #在一个session内完成训练与预测 with tf.Session() as sess: sess.run(tf.global_variables_initializer()) opt = optimizer.minimize(model.loss) for epoch in xrange(n_epoch): """ 进行n_epoch轮训练,每轮训练是逐batch进行的 """ n = 0 for batch in xrange(n_batch): onehot_input = np.zeros([batch_size, seqlen, onehot_size]) onehot_target = np.zeros([batch_size, onehot_size]) n = 100 * batch #生成onehot编码的输入与输出 for i in range(batch_size): onehot_target[i][tr_data[n + i][-1]] = 1 for j in range(seqlen): onehot_input[i][j][tr_data[n + i][j]] = 1 _, loss = sess.run([opt, model.loss], feed_dict={ model.X_input: onehot_input, model.Y_tar: onehot_target }) #训练最后一个batch为100的数据,数据设置的时候倒着来 onehot_input = np.zeros([batch_size, seqlen, onehot_size]) onehot_target = np.zeros([batch_size, onehot_size]) for i in xrange(batch_size): onehot_target[-i - 1][tr_data[-i - 1][-1]] = 1 for j in xrange(seqlen): onehot_input[-i - 1][j][tr_data[-i - 1][j]] = 1 _, loss = sess.run([opt, model.loss], feed_dict={ model.X_input: onehot_input, model.Y_tar: onehot_target }) aveloss = loss.mean() print "epoch %d cost is %f" % (epoch, aveloss) endtrain = time.time() print "train run %d miniutes" % ((endtrain - begintrain) / 60) print "start run pred" """ 开始预测 """ te_input, te_target = getTestData() n_te_lines = te_input.shape[0] #将te_input转换为onehot编码的形式 _te_input = np.zeros([n_te_lines, seqlen, onehot_size]) for i in xrange(n_te_lines): for j in xrange(seqlen): _te_input[i][j][te_input[i][j]] = 1 """ #预测返回的是一个列表,每一项为一个用户的预测,预测结果为一个大小为3953的向量 #向量每一项对应一部电影的概率值 """ pred_res = model.pred(sess, _te_input) print "start evaluate" recall = evaluate(pred_res, te_target, seqlen) print "recall is %f" % recall