def ex_1_1_c(x_train, x_test, y_train, y_test): """ Solution for exercise 1.1 c) Remember to set alpha to 0 when initializing the model :param x_train: The training dataset :param x_test: The testing dataset :param y_train: The training targets :param y_test: The testing targets :return: """ ## TODO neuron_numbers = [1, 2, 3, 4, 6, 8, 12, 20, 40] mses_test = np.zeros((9, 10)) mses_train = np.zeros((9, 10)) for n in neuron_numbers: for i in range(0, 10): random_seed = randint(1, 1000) regressor = MLPRegressor(hidden_layer_sizes=(n, ), solver="lbfgs", activation="logistic", alpha=0.0, max_iter=200, random_state=random_seed) regressor.fit(x_train, y_train) mses_train[neuron_numbers.index(n)][i] = calculate_mse( regressor, x_train, y_train) mses_test[neuron_numbers.index(n)][i] = calculate_mse( regressor, x_test, y_test) plot_mse_vs_neurons(mses_train, mses_test, neuron_numbers) pass
def ex_1_1_c(x_train, x_test, y_train, y_test): """ Solution for exercise 1.1 c) Remember to set alpha to 0 when initializing the model. :param x_train: The training dataset :param x_test: The testing dataset :param y_train: The training targets :param y_test: The testing targets :return: """ MSE_train, MSE_test = np.zeros((8, 10)), np.zeros((8, 10)) hiddenN = [1, 2, 4, 6, 8, 12, 20, 40] randoms = np.random.randint(0, 1000, size=10) print(randoms) for i, n_h in enumerate(hiddenN): for j, rand in enumerate(randoms): nn = MLPRegressor(activation='logistic', solver='lbfgs', max_iter=5000, hidden_layer_sizes=(n_h, ), alpha=0, random_state=rand) nn.fit(x_train, y_train) MSE_train[i][j] = calculate_mse(nn, x_train, y_train) MSE_test[i][j] = calculate_mse(nn, x_test, y_test) plot_mse_vs_neurons(MSE_train, MSE_test, hiddenN)
def ex_1_1_c(x_train, x_test, y_train, y_test): """ Solution for exercise 1.1 c) Remember to set alpha to 0 when initializing the model Use max_iter = 10000 and tol=1e-8 :param x_train: The training dataset :param x_test: The testing dataset :param y_train: The training targets :param y_test: The testing targets :return: """ ## TODO hidden_neurons_totest = np.array([1, 2, 3, 4, 6, 8, 12, 20, 40]) # hidden_neurons_totest = np.array([20]) dim1 = hidden_neurons_totest.shape[0] mse_test_matrix = np.zeros((dim1, 10)) mse_train_matrix = np.zeros((dim1, 10)) k = 0 for i in hidden_neurons_totest: n_hidden_neurons = i for j in range(10): nn = MLPRegressor(activation='logistic', solver='lbfgs', max_iter=10000, tol=1e-8, hidden_layer_sizes=(n_hidden_neurons,), alpha=0, random_state=j) nn.fit(x_train, y_train) predictions_test = nn.predict(x_test) mse_test_matrix[k, j] = calculate_mse(nn, x_test, y_test) mse_train_matrix[k, j] = calculate_mse(nn, x_train, y_train) k += 1 plot_mse_vs_neurons(mse_train_matrix, mse_test_matrix, hidden_neurons_totest) plt.show() plot_learned_function(40, x_train, y_train, 0, x_test, y_test, predictions_test) plt.show()
def ex_1_1_c(x_train, x_test, y_train, y_test): """ Solution for exercise 1.1 c) Remember to set alpha to 0 when initializing the model :param x_train: The training dataset :param x_test: The testing dataset :param y_train: The training targets :param y_test: The testing targets :return: """ params_n_h = np.array([1, 2, 3, 4, 6, 8, 12, 20, 40]) seeds = np.array(range(1, 11)) train_mses = np.zeros((params_n_h.shape[0], seeds.shape[0])) test_mses = np.zeros((params_n_h.shape[0], seeds.shape[0])) for index_seed, seed in np.ndenumerate(seeds): for index_n_h, n_h in np.ndenumerate(params_n_h): nn = MLPRegressor(solver='lbfgs', max_iter=200, activation='logistic', hidden_layer_sizes=(n_h, ), alpha=0, random_state=seed) nn.fit(x_train, y_train) train_mses[index_n_h, index_seed] = calculate_mse(nn, x_train, y_train) test_mses[index_n_h, index_seed] = calculate_mse(nn, x_test, y_test) print("Min MSE ", np.min(train_mses)) plot_mse_vs_neurons(train_mses, test_mses, params_n_h) pass
def ex_1_1_c(x_train, x_test, y_train, y_test): """ Solution for exercise 1.1 c) Remember to set alpha to 0 when initializing the model Use max_iter = 10000 and tol=1e-8 :param x_train: The training dataset :param x_test: The testing dataset :param y_train: The training targets :param y_test: The testing targets :return: """ ## TODO n_h = [1, 2, 3, 4, 6, 8, 12, 20, 40] train_array = np.zeros((9, 10)) test_array = np.zeros((9, 10)) for n in n_h: for i in range(0, 10): index = n_h.index(n) nn = MLPRegressor(tol=1e-8, activation='logistic', solver='lbfgs', alpha=0.0, hidden_layer_sizes=(n_h[index],), max_iter=10000, random_state=i) nn.fit(x_train, y_train) train_array[index][i] = calculate_mse(nn, x_train, y_train) test_array[index][i] = calculate_mse(nn, x_test, y_test) y_pred_train = nn.predict(x_train) y_pred_test = nn.predict(x_test) if n == 1: plot_learned_function(n, x_train, y_train, y_pred_train, x_test, y_test, y_pred_test) plot_mse_vs_neurons(np.array(train_array), np.array(test_array), n_h)
def ex_1_1_d(x_train, x_test, y_train, y_test): """ Solution for exercise 1.1 b) Remember to set alpha to 0 when initializing the model :param x_train: The training dataset :param x_test: The testing dataset :param y_train: The training targets :param y_test: The testing targets :return: """ ## TODO #pass N = 500 n_hidden = [2, 5, 50] mse_train = np.zeros([np.size(n_hidden), N]) mse_test = np.zeros([np.size(n_hidden), N]) for j in range(np.size(n_hidden)): reg = MLPRegressor(hidden_layer_sizes=(n_hidden[j], ), activation='logistic', solver='lbfgs', alpha=0, random_state=0, warm_start=True, max_iter=1) for r in range(N): reg.fit(x_train, y_train) mse_train[j, r] = calculate_mse(reg, x_train, y_train) mse_test[j, r] = calculate_mse(reg, x_test, y_test) # PLOT plot_mse_vs_neurons(mse_train, mse_test, n_hidden) #mse_test_mean = np.mean(mse_test, axis=1) #ind = np.argmin(mse_test_mean) ind = np.unravel_index(np.argmin(mse_test), mse_test.shape) # geht es auch ohne den MLPRegressor nochmal zu initialisieren? Keine Ahnung obs anders besser geht reg = MLPRegressor(hidden_layer_sizes=(n_hidden[j], ), activation='logistic', solver='lbfgs', alpha=0, random_state=random.randint(0, 1000), max_iter=500) reg.fit(x_train, y_train) y_pred_test = reg.predict(x_test) y_pred_train = reg.predict(x_train) plot_learned_function(n_hidden[ind[0]], x_train, y_train, y_pred_train, x_test, y_test, y_pred_test)
def ex_1_1_c(x_train, x_test, y_train, y_test): """ Solution for exercise 1.1 c) Remember to set alpha to 0 when initializing the model Use max_iter = 10000 and tol=1e-8 :param x_train: The training dataset :param x_test: The testing dataset :param y_train: The training targets :param y_test: The testing targets :return: """ m = 0 n = 0 #declaring variables used in MLP-Regressor hidden_layers = np.array([1, 2, 3, 4, 6, 8, 12, 20, 40]) random_state = 10 activation_mode = 'logistic' solver_mode = 'lbfgs' alpha = 0 max_iter = 10000 tol = 1e-8 train_mse = np.zeros((hidden_layers.size, random_state)) test_mse = np.zeros((hidden_layers.size, random_state)) for m in range(random_state): for n in range(hidden_layers.size): nn = MLPRegressor(hidden_layer_sizes=(hidden_layers[n], ), activation=activation_mode, solver=solver_mode, alpha=alpha, max_iter=max_iter, random_state=m, tol=tol) nn.fit(x_train, y_train) #calculate for every random seed train_mse and test_mse train_mse[n][m] = calculate_mse(nn, x_train, y_train) test_mse[n][m] = calculate_mse(nn, x_test, y_test) plot_mse_vs_neurons(train_mse, test_mse, hidden_layers) y_test_pred = nn.predict(x_test) y_train_pred = nn.predict(x_train) plot_learned_function(40, x_train, y_train, y_train_pred, x_test, y_test, y_test_pred) pass
def ex_1_1_c(x_train, x_test, y_train, y_test): """ Solution for exercise 1.1 c) Remember to set alpha to 0 when initializing the model :param x_train: The training dataset :param x_test: The testing dataset :param y_train: The training targets :param y_test: The testing targets :return: """ ## TODO #pass N = 10 n_hidden = [1, 2, 3, 4, 6, 8, 12, 20, 40] mse_train = np.zeros([np.size(n_hidden), N]) mse_test = np.zeros([np.size(n_hidden), N]) for j in range(np.size(n_hidden)): reg = MLPRegressor(hidden_layer_sizes=(1, n_hidden[j]), activation='logistic', solver='lbfgs', alpha=0, random_state=random.randint(0, 1000)) for r in range(N): reg.fit(x_train, y_train) mse_train[j, r] = calculate_mse(reg, x_train, y_train) mse_test[j, r] = calculate_mse(reg, x_test, y_test) # PLOT plot_mse_vs_neurons(mse_train, mse_test, n_hidden) """ mse_test_mean = np.mean(mse_test, axis=1) ind = np.argmin(mse_test_mean) """ ind = np.unravel_index(np.argmin(mse_test), mse_test.shape) reg = MLPRegressor(hidden_layer_sizes=(n_hidden[ind[0]], ), activation='logistic', solver='lbfgs', alpha=0, random_state=random.randint(0, 1000)) reg.fit(x_train, y_train) y_pred_test = reg.predict(x_test) y_pred_train = reg.predict(x_train) plot_learned_function(n_hidden[ind[0]], x_train, y_train, y_pred_train, x_test, y_test, y_pred_test)
def ex_1_1_c(x_train, x_test, y_train, y_test): """ Solution for exercise 1.1 c) Remember to set alpha to 0 when initializing the model :param x_train: The training dataset :param x_test: The testing dataset :param y_train: The training targets :param y_test: The testing targets :return: """ ## TODO n_seeds = 10 n_neur = [1, 2, 3, 4, 6, 8, 12, 20, 40] mse_train = np.zeros([np.size(n_neur), n_seeds]) mse_test = np.zeros([np.size(n_neur), n_seeds]) for h in range(np.size(n_neur)): for s in range(n_seeds): seed = np.random.randint(100) reg = MLPRegressor(hidden_layer_sizes=(n_neur[h], ), max_iter=5000, activation='logistic', solver='lbfgs', alpha=0, random_state=seed) reg.fit(x_train, y_train) mse_train[h, s] = calculate_mse(reg, x_train, y_train) mse_test[h, s] = calculate_mse(reg, x_test, y_test) plot_mse_vs_neurons(mse_train, mse_test, n_neur) sum_mse = mse_test.sum(axis=1) ind_min = sum_mse.argmin() reg = MLPRegressor(hidden_layer_sizes=(n_neur[ind_min], ), max_iter=5000, activation='logistic', solver='lbfgs', alpha=0, random_state=np.random.randint(100)) reg.fit(x_train, y_train) y_pred_test = reg.predict(x_test) y_pred_train = reg.predict(x_train) plot_learned_function(n_neur[ind_min], x_train, y_train, y_pred_train, x_test, y_test, y_pred_test)
def ex_1_1_c(x_train, x_test, y_train, y_test): """ Solution for exercise 1.1 c) Remember to set alpha to 0 when initializing the model. :param x_train: The training dataset :param x_test: The testing dataset :param y_train: The training targets :param y_test: The testing targets :return: """ ## TODO nh = [1, 2, 4, 6, 8, 12, 20, 40] mse_all_train = np.zeros(shape=(8, 10)) mse_all_test = np.zeros(shape=(8, 10)) for i in range(0, 10): for j in range(0, 8): seed = np.random.randint(1, 100) nn = MLPRegressor(activation='logistic', solver='lbfgs', max_iter=5000, alpha=0, hidden_layer_sizes=(nh[j], ), random_state=seed) nn.fit(x_train, y_train) mse_train = calculate_mse(nn, x_train, y_train) mse_test = calculate_mse(nn, x_test, y_test) mse_all_train[j][i] = mse_train mse_all_test[j][i] = mse_test plot_mse_vs_neurons(mse_all_train, mse_all_test, nh) nn = MLPRegressor(activation='logistic', solver='lbfgs', max_iter=5000, alpha=0, hidden_layer_sizes=(nh[2], )) nn.fit(x_train, y_train) y_pred_train = nn.predict(x_train) y_pred_test = nn.predict(x_test) plot_learned_function(nh[2], x_train, y_train, y_pred_train, x_test, y_test, y_pred_test) pass
def ex_1_1_c(x_train, x_test, y_train, y_test): """ Solution for exercise 1.1 c) Remember to set alpha to 0 when initializing the model Use max_iter = 10000 and tol=1e-8 :param x_train: The training dataset :param x_test: The testing dataset :param y_train: The training targets :param y_test: The testing targets :return: """ n_hidden_neurons_list = [1, 2, 3, 4, 6, 8, 12, 20, 40] seeds = 10 mse = np.zeros((len(n_hidden_neurons_list), seeds, 2)) for i in range(len(n_hidden_neurons_list)): for j in range(seeds): regressor = MLPRegressor( hidden_layer_sizes=(n_hidden_neurons_list[i], ), activation='logistic', solver='lbfgs', alpha=0, max_iter=10000, random_state=j, tol=1e-8) regressor.fit(x_train, y_train) # mse shape: [train_mses, test_mses] mse[i][j] = calculate_mse(regressor, [x_train, x_test], [y_train, y_test]) plot_mse_vs_neurons(mse[:, :, 0], mse[:, :, 1], n_hidden_neurons_list) n_hidden = 40 regressor = MLPRegressor(hidden_layer_sizes=(n_hidden, ), activation='logistic', solver='lbfgs', alpha=0, max_iter=10000, tol=1e-8) regressor.fit(x_train, y_train) y_pred_train = regressor.predict(x_train) y_pred_test = regressor.predict(x_test) plot_learned_function(n_hidden, x_train, y_train, y_pred_train, x_test, y_test, y_pred_test) ## TODO pass
def ex_1_1_c(x_train, x_test, y_train, y_test): """ Solution for exercise 1.1 c) Remember to set alpha to 0 when initializing the model Use max_iter = 10000 and tol=1e-8 :param x_train: The training dataset :param x_test: The testing dataset :param y_train: The training targets :param y_test: The testing targets :return: """ n_hidden_neurons_list = [1, 2, 3, 4, 6, 8, 12, 20, 40] n_iterations = 10 train_mses = numpy.zeros((9, n_iterations)) test_mses = numpy.zeros((9, n_iterations)) r = 0 for n_hidden_neuron in n_hidden_neurons_list: for i in range(n_iterations): trained_regressor = MLPRegressor( hidden_layer_sizes=(n_hidden_neuron, ), activation='logistic', solver='lbfgs', alpha=0, tol=1e-8, max_iter=10000, random_state=i) trained_regressor = trained_regressor.fit(x_train, y_train) train_mses[r][i] = calculate_mse(trained_regressor, x_train, y_train) test_mses[r][i] = calculate_mse(trained_regressor, x_test, y_test) r = r + 1 plot_mse_vs_neurons(train_mses, test_mses, n_hidden_neurons_list) # trained_regressor = MLPRegressor(hidden_layer_sizes=(40, ), activation='logistic', solver='lbfgs', alpha=0,tol= 1e-8, max_iter=10000,random_state=1) # trained_regressor = trained_regressor.fit(x_train,y_train) # y_pred_train = trained_regressor.predict(x_train) # y_pred_test = trained_regressor.predict(x_test) # plot_learned_function(40, x_train, y_train, y_pred_train, x_test, y_test, y_pred_test) pass
def ex_1_1_d(x_train, x_test, y_train, y_test): """ Solution for exercise 1.1 b) Remember to set alpha to 0 when initializing the model :param x_train: The training dataset :param x_test: The testing dataset :param y_train: The training targets :param y_test: The testing targets :return: """ ## TODO total_iter = 50 n_neur = [2, 5, 50] solvers = ['lbfgs', 'sgd', 'adam'] counter_solv = 0 mse_train = np.zeros([np.size(n_neur), total_iter, np.size(solvers)]) mse_test = np.zeros([np.size(n_neur), total_iter, np.size(solvers)]) for solv in solvers: for j in range(np.size(n_neur)): reg = MLPRegressor(hidden_layer_sizes=(n_neur[j], ), activation='logistic', solver=solv, alpha=0, random_state=0, warm_start=True, max_iter=1) for r in range(total_iter): reg.fit(x_train, y_train) mse_train[j, r, counter_solv] = calculate_mse(reg, x_train, y_train) mse_test[j, r, counter_solv] = calculate_mse(reg, x_test, y_test) counter_solv += 1 # PLOT for s in range(np.size(solvers)): plot_mse_vs_neurons(mse_train[:, :, s], mse_test[:, :, s], n_neur)