def train(net: NeuralNetwork, inputs: Tensor, targets: Tensor, num_epochs: int = 5000, iterator: DataIterator = BatchIterator(), loss: Loss = CrossEntropy(), optimizer: Optimizer = MBGD(), showGraph: bool = False) -> None: losses = [] for epoch in range(num_epochs): epoch_loss = 0.0 for batch in iterator(inputs, targets): for X, Y in zip(batch.inputs, batch.targets): predicted = net.forward(X) epoch_loss += loss.loss(predicted, Y) grad = loss.grad(predicted, Y) net.backwards(grad) optimizer.step(net) print(epoch, epoch_loss) losses.append(epoch_loss) if epoch_loss < 300: pass if showGraph: plt.plot(losses) plt.show()
def train_nn( net: NeuralNet, inputs: Tensor, targets: Tensor, epochs: int = 1, loss: Loss = MSE(), batch_iter: DataIterator = BatchIterator(), optimizer: Optimizer = SGD(), ) -> None: for epoch in range(epochs): epoch_loss = 0. for batch in batch_iter(inputs, targets): pred = net.forward(batch.input) batch_loss = loss.loss(pred, batch.target) epoch_loss += batch_loss loss_grad = loss.grad(pred, batch.target) net_grad = net.backward(loss_grad) optimizer.step(net) print(f'epoch:{epoch}, loss:{epoch_loss}')
def train_prediction( net: Neural_network.NeuralNet, inputs_train: Tensor, targets_train: Tensor, inputs_test: Tensor, targets_test: Tensor, loss: Loss.Loss = Loss.MeanSquareError(), optimizer: OptimizerClass.Optimizer = OptimizerClass.SGD(), num_epochs: int = 5000, batch_size: int = 32): Data = pd.DataFrame(columns=('MSE_train', 'MSE_test', 'error_round_train', 'error_round_test')) size_training = inputs_train.shape[0] for epoch in range(num_epochs): Chi2_train = 0.0 error_round_train = 0.0 nbr_batch = 0 for i in range(0, size_training, batch_size): nbr_batch += 1 # 1) feed forward y_actual = net.forward(inputs_train[i:i + batch_size]) # 2) compute the loss and the gradients Chi2_train += loss.loss(targets_train[i:i + batch_size], y_actual) grad_ini = loss.grad(targets_train[i:i + batch_size], y_actual) # 3)feed backwards grad_fini = net.backward(grad_ini) # 4) update the net optimizer.step(net, n_epoch=epoch) error_round_train += Error_round.error_round( targets_train[i:i + batch_size], y_actual) Chi2_train = Chi2_train / nbr_batch error_round_train = error_round_train / nbr_batch y_actual_test = net.forward(inputs_test) Chi2_test = loss.loss(targets_test, y_actual_test) error_round_test = Error_round.error_round(targets_test, y_actual_test) if epoch % 100 == 0: print('epoch : ' + str(epoch) + "/" + str(num_epochs) + "\r", end="") datanew = pd.DataFrame({ 'MSE_train': [Chi2_train], 'MSE_test': [Chi2_test], 'error_round_train': [error_round_train], 'error_round_test': [error_round_test] }) Data = Data.append(datanew) os.chdir(path_ini) Data.to_csv('Opt_num_epoch_backup.csv', index=False) return Data
def train(net: NeuralNet, inputs: Tensor, targets: Tensor, num_epochs: int = 5000, iterator: DataIterator = BatchIterator(), loss: Loss = MSE(), optimizer: Optimizer = SGD() ) -> None: for epoch in range(num_epochs): epoch_loss = 0.0 for batch in iterator(inputs, targets): predicted = net.forward(batch.inputs) epoch_loss += loss.loss(predicted, batch.targets) grad = loss.grad(predicted, batch.targets) net.backward(grad) optimizer.step(net) print(epoch, epoch_loss)
def train(net: NetWork, inputs: Tensor, targets: Tensor, epochs: int = 500, loss: Loss = MSE(), optimizer: Optimizer = SGD(), iterator: DataIterator = BatchIterator(), show_info: bool = False): for epoch in range(epochs): epoch_loss = .0 for batch_inputs, batch_targets in iterator(inputs, targets): predictions = net.forward(batch_inputs) epoch_loss += loss.loss(predictions, batch_targets) grad = loss.grad(predictions, batch_targets) net.backward(grad) optimizer.step(net) if show_info: print('epoch:{}, loss:{}'.format(epoch, epoch_loss))
def train_simultaneousNN( inputs_train: Tensor, targets_train: Tensor, loss: Loss.Loss = Loss.MeanSquareError(), optimizer: OptimizerClass.Optimizer = OptimizerClass.SGD(), num_epochs: int = 5000, batch_size: int = 32) -> tuple: size_training = inputs_train.shape[0] Result_chi2 = [[], [], [], [], [], [], [], [], []] list_epoch = np.array(range(10, 50, 5)) / 100 * num_epochs '''initialisation des 9 NN''' #verifier question seed() list_net = [] for i in range(9): layers = [] layers.append(Layer.Linear(6, 4)) layers.append(ActivationFunctions.Tanh()) layers.append(Layer.Linear(4, 2)) layers.append(ActivationFunctions.Tanh()) layers.append(Layer.Linear(2, 1)) layers.append(ActivationFunctions.Sigmoid()) list_net.append(Neural_network.NeuralNet(layers)) destroyed_NN = [] nbr_batch = size_training // batch_size ''' training des 9 NN''' for epoch in range(num_epochs): for k in range(9): if k not in destroyed_NN: Chi2_train = 0 for i in range(0, size_training, batch_size): # 1) feed forward y_actual = list_net[k].forward(inputs_train[i:i + batch_size]) # 2) compute the loss and the gradients Chi2_train += loss.loss(targets_train[i:i + batch_size], y_actual) grad_ini = loss.grad(targets_train[i:i + batch_size], y_actual) # 3)feed backwards grad_fini = list_net[k].backward(grad_ini) # 4) update the net optimizer.step(list_net[k], n_epoch=epoch) Chi2_train = Chi2_train / nbr_batch Result_chi2[k].append(Chi2_train) '''Supression du NN le moins efficace ''' if epoch in list_epoch: Comparaison = [[], []] for k in range(9): if k not in destroyed_NN: ErrorSlope = np.polyfit(np.array(range(epoch - 49, epoch)), Result_chi2[k][-50:-1], 1)[0] MixedError = Result_chi2[k][-1] * (1 - np.arctan(ErrorSlope) / (np.pi / 2)) Comparaison[0].append(k) Comparaison[1].append(MixedError) k = Comparaison[0][Comparaison[1].index(max(Comparaison[1]))] destroyed_NN.append(k) if epoch % 100 == 0: print('epoch : ' + str(epoch) + "/" + str(num_epochs) + "\r", end="") for k in range(9): if k not in destroyed_NN: my_NN = list_net[k] return my_NN, Result_chi2