def test_repeated_reverse_inline_connection(self): input_layer_1 = layers.Input(1) input_layer_2 = layers.Input(1) hidden_layer = layers.Relu(4) output_layer = layers.Softmax(5) connection_1 = output_layer < hidden_layer < input_layer_1 connection_2 = output_layer < hidden_layer < input_layer_2 self.assertListEqual(list(connection_1), [input_layer_1, hidden_layer, output_layer]) self.assertListEqual(list(connection_2), [input_layer_2, hidden_layer, output_layer])
def test_mixture_of_experts(self): dataset = datasets.load_diabetes() data, target = asfloat(dataset.data), asfloat(dataset.target) insize, outsize = data.shape[1], 1 input_scaler = preprocessing.MinMaxScaler((-1, 1)) output_scaler = preprocessing.MinMaxScaler() x_train, x_test, y_train, y_test = model_selection.train_test_split( input_scaler.fit_transform(data), output_scaler.fit_transform(target.reshape(-1, 1)), train_size=0.8) n_epochs = 10 scaled_y_test = output_scaler.inverse_transform(y_test) scaled_y_test = scaled_y_test.reshape((y_test.size, 1)) # -------------- Train single GradientDescent -------------- # bpnet = algorithms.GradientDescent((insize, 20, outsize), step=0.1, verbose=False) bpnet.train(x_train, y_train, epochs=n_epochs) network_output = bpnet.predict(x_test) network_error = rmsle(output_scaler.inverse_transform(network_output), scaled_y_test) # -------------- Train ensemlbe -------------- # moe = algorithms.MixtureOfExperts( networks=[ algorithms.Momentum((insize, 20, outsize), step=0.1, batch_size=1, verbose=False), algorithms.Momentum((insize, 20, outsize), step=0.1, batch_size=1, verbose=False), ], gating_network=algorithms.Momentum( layers.Input(insize) > layers.Softmax(2), step=0.1, verbose=False)) moe.train(x_train, y_train, epochs=n_epochs) ensemble_output = moe.predict(x_test) ensemlbe_error = rmsle( output_scaler.inverse_transform(ensemble_output), scaled_y_test) self.assertGreater(network_error, ensemlbe_error)
def test_mixture_of_experts_repr(self): moe = algorithms.MixtureOfExperts( networks=[ algorithms.Momentum((3, 2, 1)), algorithms.GradientDescent((3, 2, 1)), ], gating_network=algorithms.Adadelta( layers.Input(3) > layers.Softmax(2), )) moe_repr = str(moe) self.assertIn('MixtureOfExperts', moe_repr) self.assertIn('Momentum', moe_repr) self.assertIn('GradientDescent', moe_repr) self.assertIn('Adadelta', moe_repr)
def test_mixture_of_experts_training_exceptions(self): moe = algorithms.MixtureOfExperts( # Invalid gating network output layer networks=self.networks, gating_network=algorithms.GradientDescent( layers.Input(1) > layers.Softmax(2), verbose=False), ) with self.assertRaises(ValueError): # Wrong number of train input features moe.train(np.array([[1, 2]]), np.array([[0]])) with self.assertRaises(ValueError): # Wrong number of train output features moe.train(np.array([[1]]), np.array([[0, 0]]))
def test_repeated_inline_connections(self): input_layer_1 = layers.Input(1) input_layer_2 = layers.Input(1) hidden_layer = layers.Relu(17) output_layer = layers.Softmax(5) connection_1 = input_layer_1 > hidden_layer > output_layer connection_2 = input_layer_2 > hidden_layer > output_layer self.assertListEqual(list(connection_1), [input_layer_1, hidden_layer, output_layer]) self.assertListEqual(list(connection_2), [input_layer_2, hidden_layer, output_layer])
def test_mixture_of_experts_init_gating_network_exceptions(self): networks = self.networks with self.assertRaises(ValueError): # Invalid gating error function algorithms.MixtureOfExperts( networks=networks, gating_network=algorithms.GradientDescent( layers.Input(1) > layers.Softmax(2), error='rmsle', verbose=False), ) with self.assertRaises(ValueError): # Invalid gating network algorithm algorithms.MixtureOfExperts( networks=networks, gating_network=algorithms.PNN(), ) with self.assertRaises(ValueError): # Invalid gating network output layer algorithms.MixtureOfExperts( networks=networks, gating_network=algorithms.GradientDescent( layers.Input(1) > layers.Sigmoid(2), verbose=False, )) with self.assertRaises(ValueError): # Invalid gating network output layer size algorithms.MixtureOfExperts( networks=networks, gating_network=algorithms.GradientDescent( layers.Input(1) > layers.Softmax(1), verbose=False, ))
def test_repeated_inline_connections_with_list(self): input_layer_1 = layers.Input(1) input_layer_2 = layers.Input(1) hd1 = layers.Relu(4) hd2 = layers.Sigmoid(4) output_layer = layers.Softmax(5) connection_1 = input_layer_1 > [hd1, hd2] > output_layer connection_2 = input_layer_2 > [hd1, hd2] > output_layer self.assertListEqual(list(connection_1), [input_layer_1, hd1, hd2, output_layer]) self.assertListEqual(list(connection_2), [input_layer_2, hd1, hd2, output_layer])
def init_network(self, member): network = layers.join(layers.Input(self.inputneurons)) for index in range(0, len(member[1][0])): if member[1][1][index] == 1: network = network > layers.Sigmoid(member[1][0][index]) elif member[1][1][index] == 2: network = network > layers.Relu(member[1][0][index]) elif member[1][1][index] == 3: network = network > layers.Softmax(member[1][0][index]) elif member[1][1][index] == 4: network = network > layers.Tanh(member[1][0][index]) elif member[1][1][index] == 5: network = network > layers.LeakyRelu(member[1][0][index]) network = network > layers.Sigmoid(self.outputneurons) return(network)
def test_gated_average_layer_multi_dimensional_inputs(self): input_layer = layers.Input((5, 5, 1)) network = layers.join([ input_layer > layers.Reshape() > layers.Softmax(2), input_layer > layers.Convolution((2, 2, 3)), input_layer > layers.Convolution((2, 2, 3)), ], layers.GatedAverage()) self.assertEqual(network.input_shape, (5, 5, 1)) self.assertEqual(network.output_shape, (4, 4, 3)) random_input = asfloat(np.random.random((8, 5, 5, 1))) actual_output = self.eval(network.output(random_input)) self.assertEqual(actual_output.shape, (8, 4, 4, 3))
def test_gated_average_layer_multi_dimensional_inputs(self): input_layer = layers.Input((1, 5, 5)) network = layers.join([ input_layer > layers.Reshape() > layers.Softmax(2), input_layer > layers.Convolution((3, 2, 2)), input_layer > layers.Convolution((3, 2, 2)), ], layers.GatedAverage()) self.assertEqual(network.input_shape, (1, 5, 5)) self.assertEqual(network.output_shape, (3, 4, 4)) predict = network.compile() random_input = asfloat(np.random.random((8, 1, 5, 5))) actual_output = predict(random_input) self.assertEqual(actual_output.shape, (8, 3, 4, 4))
def create_VIN(input_image_shape=(2, 8, 8), n_hidden_filters=150, n_state_filters=10, k=10): HalfPaddingConv = partial(layers.Convolution, padding='half', bias=None) R = layers.join( layers.Input(input_image_shape, name='grid-input'), layers.Convolution((n_hidden_filters, 3, 3), padding='half', weight=init.Normal(), bias=init.Normal()), HalfPaddingConv((1, 1, 1), weight=init.Normal()), ) # Create shared weights q_weight = random_weight((n_state_filters, 1, 3, 3)) fb_weight = random_weight((n_state_filters, 1, 3, 3)) Q = R > HalfPaddingConv((n_state_filters, 3, 3), weight=q_weight) for i in range(k): V = Q > GlobalMaxPooling() Q = layers.join( # Convolve R and V separately and then add # outputs together with the Elementwise layer [[ R, HalfPaddingConv((n_state_filters, 3, 3), weight=q_weight) ], [ V, HalfPaddingConv((n_state_filters, 3, 3), weight=fb_weight) ]], layers.Elementwise(merge_function=T.add), ) input_state_1 = layers.Input(10, name='state-1-input') input_state_2 = layers.Input(10, name='state-2-input') # Select the conv-net channels at the state position (S1, S2) VIN = [Q, input_state_1, input_state_2] > SelectValueAtStatePosition() # Set up softmax layer that predicts actions base on (S1, S2) # position. Each action encodes specific direction: # N, S, E, W, NE, NW, SE, SW (in the same order) VIN = VIN > layers.Softmax(8, bias=None, weight=init.Normal()) return VIN
def test_inline_connections_after_exception(self): # One possibility to solve it is to reset all states in # connections/inline.py and when we assing new shape # in connections/graph.py:connect_layers catch error if happens # and destroy connection between layers input_layer = layers.Input(2) with self.assertRaises(LayerConnectionError): # it suppose to fail because layers in parallel connections # specified with different output shapes. input_layer > [layers.Sigmoid(20), layers.Sigmoid(10)] > layers.Elementwise() # Issue #181. Bug presented in NeuPy versions <= 0.7.2 network = input_layer > layers.Softmax(5) self.assertEqual(network.input_shape, (2, )) self.assertEqual(network.output_shape, (5, ))
def test_connection_inside_connection_conv(self): connection = [ layers.Input((1, 28, 28)), layers.Convolution((8, 3, 3)) > layers.Relu(), layers.Convolution((8, 3, 3)) > layers.Relu(), layers.MaxPooling((2, 2)), layers.Reshape(), layers.Softmax(1), ] network = algorithms.GradientDescent(connection) self.assertEqual(8, len(network.layers)) self.assertIsInstance(network.layers[1], layers.Convolution) self.assertIsInstance(network.layers[2], layers.Relu) self.assertIsInstance(network.layers[3], layers.Convolution) self.assertIsInstance(network.layers[4], layers.Relu) self.assertIsInstance(network.layers[5], layers.MaxPooling)
def test_connection_inside_connection_conv(self): connection = layers.join( layers.Input((28, 28, 1)), layers.Convolution((3, 3, 8)) > layers.Relu(), layers.Convolution((3, 3, 8)) > layers.Relu(), layers.MaxPooling((2, 2)), layers.Reshape(), layers.Softmax(1), ) self.assertEqual(8, len(connection)) expected_order = [ layers.Input, layers.Convolution, layers.Relu, layers.Convolution, layers.Relu, layers.MaxPooling, layers.Reshape, layers.Softmax ] for actual_layer, expected_layer in zip(connection, expected_order): self.assertIsInstance(actual_layer, expected_layer)
def test_gated_average_layer_multi_dimensional_inputs(self): network = layers.join( layers.Input((5, 5, 1)), layers.parallel( layers.Reshape() >> layers.Softmax(2), layers.Convolution((2, 2, 3)), layers.Convolution((2, 2, 3)), ), layers.GatedAverage(), ) self.assertShapesEqual(network.input_shape, (None, 5, 5, 1)) self.assertShapesEqual(network.output_shape, (None, 4, 4, 3)) random_input = asfloat(np.random.random((8, 5, 5, 1))) actual_output = self.eval(network.output(random_input)) self.assertEqual(actual_output.shape, (8, 4, 4, 3))
def __init__(self): self.population = [] self.size_population = 20 self.inputneurons = 4 self.outputneurons = 1 self.data = datasets.load_iris() for i in range(0,self.size_population): #connections network = layers.join(layers.Input(self.inputneurons)) num = random.randint(1,4) temp1 = list(random.randint(1,50) for i in range(0, num)) #print(temp1, end="\n\n") temp2 = [] for neu in temp1: n = random.randint(1,5) temp2.append(n) if n == 1: network = network > layers.Sigmoid(neu) elif n == 2: network = network > layers.Relu(neu) elif n == 3: network = network > layers.Softmax(neu) elif n == 4: network = network > layers.Tanh(neu) elif n == 5: network = network > layers.LeakyRelu(neu) #print(network, end="\n~\n") network = network > layers.Sigmoid(self.outputneurons) attributes = [temp1, temp2] self.population.append([network, attributes, 0]) # 0 --> fitness #print(self.population) self.run() while self.best_members[0][2][0] > 1: print("next iteration") print(self.population) self.run() file = open("pickle_bestnet.txt", "w")
def train(X, Y): environment.reproducible() img_size = X.shape[1] network = algorithms.Momentum( [ layers.Input(img_size), layers.Relu(100), layers.Softmax(Y.shape[1]), ], error='categorical_crossentropy', step=0.01, verbose=True, shuffle_data=True, momentum=0.9, nesterov=True, ) network.architecture() network.train(X, Y, epochs=20) return network
def model_network(self, algorithm='LevenbergMarquardt', model=None, opt=None): model = self.decode_model(model) if model is None: model = [ [1, 'hidden', 15, 'Linear'], [2, 'hidden', 10, 'Linear'], [3, 'output', self.output_classes, 'Elu'] ] # [Input(4), Elu(1)] # [Input(4), Elu(6), Elu(1)] EP: 100 layer_model = [layers.Input(self.input_features)] for layer in model: if layer[3] == 'Linear': layer_model.append(layers.Linear(layer[2])) if layer[3] == 'Relu': layer_model.append(layers.Relu(layer[2])) if layer[3] == 'Sigmoid': layer_model.append(layers.Sigmoid(layer[2])) if layer[3] == 'HardSigmoid': layer_model.append(layers.HardSigmoid(layer[2])) if layer[3] == 'Step': layer_model.append(layers.Step(layer[2])) if layer[3] == 'Tanh': layer_model.append(layers.Tanh(layer[2])) if layer[3] == 'Softplus': layer_model.append(layers.Softplus(layer[2])) if layer[3] == 'Softmax': layer_model.append(layers.Softmax(layer[2])) if layer[3] == 'Elu': layer_model.append(layers.Elu(layer[2])) if layer[3] == 'PRelu': layer_model.append(layers.PRelu(layer[2])) if layer[3] == 'LeakyRelu': layer_model.append(layers.LeakyRelu(layer[2])) print('Model warstw: ' + str(layer_model)) self.layers = layer_model self.select_algorithm(algorithm, options=opt)
def test_inline_connection_with_parallel_connection(self): left_branch = layers.join( layers.Convolution((32, 3, 3)), layers.Relu(), layers.MaxPooling((2, 2)), ) right_branch = layers.join( layers.Convolution((16, 7, 7)), layers.Relu(), ) input_layer = layers.Input((3, 10, 10)) concat = layers.Concatenate() network_concat = input_layer > [left_branch, right_branch] > concat network = network_concat > layers.Reshape() > layers.Softmax() self.assertEqual(network_concat.input_shape, (3, 10, 10)) self.assertEqual(network_concat.output_shape, (48, 4, 4)) self.assertEqual(network.input_shape, (3, 10, 10)) self.assertEqual(network.output_shape, (768,))
def train_network(n_hidden, x_train, x_test, y_train, y_test): network = algorithms.Momentum( [ layers.Input(64), layers.Relu(n_hidden), layers.Softmax(10), ], # Randomly shuffle dataset before each # training epoch. shuffle_data=True, # Do not show training progress in output verbose=False, step=0.001, batch_size=128, error='categorical_crossentropy', ) network.train(x_train, y_train, epochs=100) # Calculates categorical cross-entropy error between # predicted value for x_test and y_test value return network.prediction_error(x_test, y_test)
def test_inline_network_with_parallel_network(self): left_branch = layers.join( layers.Convolution((3, 3, 32)), layers.Relu(), layers.MaxPooling((2, 2)), ) right_branch = layers.join( layers.Convolution((7, 7, 16)), layers.Relu(), ) input_layer = layers.Input((10, 10, 3)) concat = layers.Concatenate() network_concat = input_layer > (left_branch | right_branch) > concat network = network_concat > layers.Reshape() > layers.Softmax() self.assertShapesEqual(network_concat.input_shape, (None, 10, 10, 3)) self.assertShapesEqual(network_concat.output_shape, (None, 4, 4, 48)) self.assertShapesEqual(network.input_shape, (None, 10, 10, 3)) self.assertShapesEqual(network.output_shape, (None, 768))
def test_save_link_to_assigned_connections(self): # Tree structure: # # Sigmoid(10) # / # Input(10) - Sigmoid(5) # \ # Softmax(10) # input_layer = layers.Input(10) minimized = input_layer > layers.Sigmoid(5) reconstructed = minimized > layers.Sigmoid(10) classifier = minimized > layers.Softmax(20) x_matrix = asfloat(np.random.random((3, 10))) minimized_output = self.eval(minimized.output(x_matrix)) self.assertEqual((3, 5), minimized_output.shape) reconstructed_output = self.eval(reconstructed.output(x_matrix)) self.assertEqual((3, 10), reconstructed_output.shape) classifier_output = self.eval(classifier.output(x_matrix)) self.assertEqual((3, 20), classifier_output.shape)
def train_network(parameters): print("Parameters:") pprint(parameters) print() step = parameters['step'] batch_size = int(parameters['batch_size']) proba = parameters['dropout'] activation_layer = parameters['act_func_type'] layer_sizes = [int(n) for n in parameters['layers']['n_units_layer']] network = layers.Input(784) for layer_size in layer_sizes: network = network > activation_layer(layer_size) network = network > layers.Dropout(proba) > layers.Softmax(10) mnet = algorithms.RMSProp( network, batch_size=batch_size, step=step, error='categorical_crossentropy', shuffle_data=True, epoch_end_signal=on_epoch_end, ) mnet.train(x_train, y_train, epochs=50) score = mnet.prediction_error(x_test, y_test) y_predicted = mnet.predict(x_test).argmax(axis=1) accuracy = metrics.accuracy_score(y_test.argmax(axis=1), y_predicted) print("Final score: {}".format(score)) print("Accuracy: {:.2%}".format(accuracy)) return score
def train_network(n_hidden, x_train, x_test, y_train, y_test, n_classes, n_dimensionality): network = algorithms.Momentum( [ layers.Input(n_dimensionality), #input dimensionality layers.Relu(n_hidden), #optimisable hyperparam layers.Softmax(n_classes), #class output ], # Randomly shuffle dataset before each # training epoch. shuffle_data=True, # Do not show training progress in output verbose=False, step=0.001, batch_size=128, error='categorical_crossentropy', ) network.train(x_train, y_train, x_test, y_test, epochs=100) # Calculates categorical cross-entropy error between # predicted value for x_test and y_test value return network, network.prediction_error(x_test, y_test)
]], layers.Concatenate(), ) googlenet = layers.join( layers.Input((3, None, None)), layers.Convolution((64, 7, 7), padding='half', stride=2), layers.Relu(), layers.MaxPooling((3, 3), stride=2), layers.LocalResponseNorm(alpha=0.00002, k=1), layers.Convolution((64, 1, 1)) > layers.Relu(), layers.Convolution((192, 3, 3), padding='half') > layers.Relu(), layers.LocalResponseNorm(alpha=0.00002, k=1), layers.MaxPooling((3, 3), stride=2), Inception((32, 64, 96, 128, 16, 32)), Inception((64, 128, 128, 192, 32, 96)), layers.MaxPooling((3, 3), stride=2), Inception((64, 192, 96, 208, 16, 48)), Inception((64, 160, 112, 224, 24, 64)), Inception((64, 128, 128, 256, 24, 64)), Inception((64, 112, 144, 288, 32, 64)), Inception((128, 256, 160, 320, 32, 128)), layers.MaxPooling((3, 3), stride=2), Inception((128, 256, 160, 320, 32, 128)), Inception((128, 384, 192, 384, 48, 128)), layers.GlobalPooling(function=T.mean), layers.Softmax(1000), ) plots.layer_structure(googlenet)
adanet.train(x_train, y_train) aresult = adanet.predict(x_test) aerror = estimators.rmse(aresult, y_test) ''' network = architectures.mixture_of_experts([ layers.join( layers.Input(58), layers.Softmax(22), layers.Softmax(1), ), layers.join( layers.Input(58), layers.Relu(60), layers.Relu(40), layers.Softmax(22), layers.Softmax(1), ), layers.join( layers.Input(58), layers.Tanh(12), layers.Tanh(25), layers.Tanh(1), ),
x_train, x_test, y_train, y_test = cross_validation.train_test_split( data.astype(np.float32), target.astype(np.float32), train_size=(6 / 7.)) network = algorithms.Adadelta( [ layers.Convolution((32, 1, 3, 3)), layers.Relu(), layers.Convolution((48, 32, 3, 3)), layers.Relu(), layers.MaxPooling((2, 2)), layers.Dropout(0.2), layers.Reshape(), layers.Relu(6912), layers.Dropout(0.3), layers.Softmax(200), layers.ArgmaxOutput(10), ], error='categorical_crossentropy', step=1.0, verbose=True, shuffle_data=True, epochs_step_minimizator=8, addons=[algorithms.SimpleStepMinimization], ) network.architecture() network.train(x_train, y_train, x_test, y_test, epochs=6) y_predicted = network.predict(x_test) y_test_labels = np.asarray(y_test.argmax(axis=1)).reshape(len(y_test))
def test_storage_save_dict(self): network = layers.join( layers.parallel([ layers.Input(2, name='input-1'), layers.PRelu(1, name='prelu') ], [ layers.Input(1, name='input-2'), layers.Sigmoid(4, name='sigmoid'), layers.BatchNorm(name='batch-norm'), ]), layers.Concatenate(name='concatenate'), layers.Softmax(3, name='softmax'), ) dict_network = storage.save_dict(network) expected_keys = ('metadata', 'layers', 'graph') self.assertItemsEqual(expected_keys, dict_network.keys()) expected_metadata_keys = ('created', 'language', 'library', 'version') actual_metadata_keys = dict_network['metadata'].keys() self.assertItemsEqual(expected_metadata_keys, actual_metadata_keys) self.assertEqual(len(dict_network['layers']), 7) expected_layers = [{ 'class_name': 'Input', 'configs': { 'name': 'input-1', 'shape': (2, ) }, 'name': 'input-1', }, { 'class_name': 'PRelu', 'configs': { 'alpha_axes': (-1, ), 'name': 'prelu', 'n_units': 1 }, 'name': 'prelu', }, { 'class_name': 'Input', 'configs': { 'name': 'input-2', 'shape': (1, ) }, 'name': 'input-2', }, { 'class_name': 'Sigmoid', 'configs': { 'name': 'sigmoid', 'n_units': 4 }, 'name': 'sigmoid', }, { 'class_name': 'BatchNorm', 'configs': { 'alpha': 0.1, 'axes': (0, ), 'epsilon': 1e-05, 'name': 'batch-norm' }, 'name': 'batch-norm', }, { 'class_name': 'Concatenate', 'configs': { 'axis': -1, 'name': 'concatenate' }, 'name': 'concatenate', }, { 'class_name': 'Softmax', 'configs': { 'name': 'softmax', 'n_units': 3 }, 'name': 'softmax', }] actual_layers = [] for i, layer in enumerate(dict_network['layers']): self.assertIn('parameters', layer, msg="Layer #" + str(i)) layer = copy.deepcopy(layer) del layer['parameters'] actual_layers.append(layer) self.assertEqual(actual_layers, expected_layers)
def test_storage_load_dict_using_wrong_names(self): network = layers.join( layers.Input(3), layers.Relu(4, name='relu'), layers.Linear(5, name='linear') >> layers.Relu(), layers.Softmax(6, name='softmax'), ) storage.load_dict( network, { 'metadata': {}, # avoided for simplicity 'graph': {}, # avoided for simplicity # Input layer was avoided on purpose 'layers': [{ 'name': 'name-1', 'class_name': 'Relu', 'configs': {}, 'parameters': { 'weight': { 'trainable': True, 'value': np.ones((3, 4)) }, 'bias': { 'trainable': True, 'value': np.ones((4, )) }, } }, { 'name': 'name-2', 'class_name': 'Relu', 'configs': {}, 'parameters': { 'weight': { 'trainable': True, 'value': np.ones((4, 5)) }, 'bias': { 'trainable': True, 'value': np.ones((5, )) }, } }, { 'name': 'name-3', 'class_name': 'Softmax', 'configs': {}, 'parameters': { 'weight': { 'trainable': True, 'value': np.ones((5, 6)) }, 'bias': { 'trainable': True, 'value': np.ones((6, )) }, } }] }, load_by='order', skip_validation=False) relu = network.layer('relu') self.assertEqual(12, np.sum(self.eval(relu.weight))) self.assertEqual(4, np.sum(self.eval(relu.bias))) linear = network.layer('linear') self.assertEqual(20, np.sum(self.eval(linear.weight))) self.assertEqual(5, np.sum(self.eval(linear.bias))) softmax = network.layer('softmax') self.assertEqual(30, np.sum(self.eval(softmax.weight))) self.assertEqual(6, np.sum(self.eval(softmax.bias)))
SCALE = 70 SENS_SCALE = 195 CONE_TIMER = 200 SAVE_SPAN = 5 fundo_size = 150 esqYpos = 300 + (fundo_size / 2) - 5 dirYpos = 300 - (fundo_size / 2) + 5 nn = layers.join( layers.Input(4), layers.Sigmoid(12), layers.Sigmoid(8), layers.Softmax(3), ) #out-> [0]-acelerar [1]-esquerda [2]-direita otimizador = algorithms.Momentum(nn) class MyGame(arcade.Window): """ Main application class. """ def __init__(self, width, height): super().__init__(width, height) self.time_elapsed = 0.0 self.distance_map = 0.0 self.distance_car = 0.0 self.maxDistance = 0.0 self.last_checkUpX = 0.0