def ex_1_2_a(x_train, x_test, y_train, y_test):
"""
Solution for exercise 1.2 a)
: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 = 5000
n_hidden = 50
alpha_ = np.power(10, np.linspace(-8, 2, 11))
mse_train = np.zeros([np.size(alpha_), N])
mse_test = np.zeros([np.size(alpha_), N])
for j in range(np.size(alpha_)):
reg = MLPRegressor(hidden_layer_sizes=(n_hidden, ),
activation='logistic',
solver='lbfgs',
alpha=alpha_[j],
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_mse_vs_alpha(mse_train, mse_test, alpha_)
def ex_1_2(x_train, x_test, y_train, y_test):
"""
Solution for exercise 1.2 a)
: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 = 50
alp = [0.000001, 0.00001, 0.0001, 0.001, 0.01, 0.1, 1, 10, 100]
seed = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
iterations = 5000
mse_all_train = np.zeros(shape=(9, 10))
mse_all_test = np.zeros(shape=(9, 10))
for j in range(0, 9):
for i in range(0, 10):
nn = MLPRegressor(
activation='logistic',
solver='lbfgs',
max_iter=5000,
alpha=alp[j],
hidden_layer_sizes=(50, ),
random_state=seed[i]) #for i in range(0,iterations):
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_alpha(mse_all_train, mse_all_test, alp)
pass
def ex_1_2(x_train, x_test, y_train, y_test):
"""
Solution for exercise 1.2 a)
: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:
"""
alphas = [10**-6, 10**-5, 10**-4, 10**-3, 10**-2, 10**-1, 1, 10, 100]
randoms = np.random.randint(0, 1000, size=10)
MSE_train, MSE_test = np.ndarray((len(alphas), len(randoms))), np.ndarray(
(len(alphas), len(randoms)))
n_h = 50
for a, alpha in enumerate(alphas):
for r, random in enumerate(randoms):
nn = MLPRegressor(activation='logistic',
solver='lbfgs',
max_iter=5000,
hidden_layer_sizes=(n_h, ),
alpha=alpha,
random_state=random)
nn.fit(x_train, y_train)
MSE_train[a][r] = calculate_mse(nn, x_train, y_train)
MSE_test[a][r] = calculate_mse(nn, x_test, y_test)
plot_mse_vs_alpha(MSE_train, MSE_test, alphas)
def ex_1_2_a(x_train, x_test, y_train, y_test):
"""
Solution for exercise 1.2 a)
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
hidden_neurons = 40
alphas = [1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1, 10, 100]
mses_train = np.zeros((len(alphas), 10))
mses_test = np.zeros((len(alphas), 10))
for alpha in alphas:
for i in range(10):
random_seed = randint(0, 1000)
regressor = MLPRegressor(hidden_layer_sizes=(hidden_neurons, ),
solver="lbfgs",
activation="logistic",
alpha=alpha,
max_iter=200,
random_state=random_seed)
regressor.fit(x_train, y_train)
mses_test[alphas.index(alpha)][i] = calculate_mse(
regressor, x_test, y_test)
mses_train[alphas.index(alpha)][i] = calculate_mse(
regressor, x_train, y_train)
plot_mse_vs_alpha(mses_train, mses_test, alphas)
def ex_1_2_a(x_train, x_test, y_train, y_test):
"""
Solution for exercise 1.2 a)
: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 = 5000
n_neuro = 50
n_seeds = 10
alph = np.power(10, np.linspace(-8, 2, 11))
mse_train = np.zeros([np.size(alph), n_seeds])
mse_test = np.zeros([np.size(alph), n_seeds])
for j in range(np.size(alph)):
for s in range(n_seeds):
seed = np.random.randint(100)
reg = MLPRegressor(hidden_layer_sizes=(n_neuro, ),
activation='logistic',
solver='lbfgs',
alpha=alph[j],
random_state=seed,
max_iter=total_iter)
reg.fit(x_train, y_train)
mse_train[j, s] = calculate_mse(reg, x_train, y_train)
mse_test[j, s] = calculate_mse(reg, x_test, y_test)
plot_mse_vs_alpha(mse_train, mse_test, alph)
def ex_1_2_a(x_train, x_test, y_train, y_test):
"""
Solution for exercise 1.2 a)
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:
"""
alphas = [1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1, 10, 100]
seeds = 10
mse = np.zeros((len(alphas), seeds, 2))
for i in range(len(alphas)):
for j in range(seeds):
regressor = MLPRegressor(hidden_layer_sizes=(40, ),
activation='logistic',
solver='lbfgs',
alpha=alphas[i],
max_iter=200,
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_alpha(mse[:, :, 0], mse[:, :, 1], alphas)
## TODO
pass
def ex_1_2_a(x_train, x_test, y_train, y_test):
"""
Solution for exercise 1.2 a)
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
alpha_values = np.array([1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1, 10, 100])
dim1 = alpha_values.shape[0]
mse_test_matrix = np.zeros((dim1, 10))
mse_train_matrix = np.zeros((dim1, 10))
k = 0
for i in alpha_values:
alpha = i
for j in range(10):
nn = MLPRegressor(activation='logistic', solver='lbfgs', max_iter=200,
hidden_layer_sizes=(40,), alpha=i, 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_alpha(mse_train_matrix, mse_test_matrix, alpha_values)
plt.show()
def ex_1_2_a(x_train, x_test, y_train, y_test):
"""
Solution for exercise 1.2 a)
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 - done
n_h = 40
test_array = np.zeros((11, 10))
train_array = np.zeros((11, 10))
alphas = [pow(10, i) for i in range(-8, 3)]
for alpha in alphas:
for j in range(0, 10):
index = alphas.index(alpha)
nn = MLPRegressor(activation='logistic', solver='lbfgs', alpha=alpha, hidden_layer_sizes=(n_h,),
max_iter=200, random_state=j)
nn.fit(x_train, y_train)
test_array[index][j] = calculate_mse(nn, x_test, y_test)
train_array[index][j] = calculate_mse(nn, x_train, y_train)
plot_mse_vs_alpha(train_array, test_array, alphas)
def ex_1_2_a(x_train, x_test, y_train, y_test):
"""
Solution for exercise 1.2 a)
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:
"""
m = 0
n = 0
# declaring variables used in MLP-Regressor
hidden_layers = 40
alphas = np.array([
10**(-8), 10**(-7), 10**(-6), 10**(-5), 10**(-4), 10**(-3), 10**(-2),
10**(-1), 1, 10, 100
])
random_state = 10
activation_mode = 'logistic'
solver_mode = 'lbfgs'
max_iter = 200
train_mse = np.zeros((alphas.size, random_state))
test_mse = np.zeros((alphas.size, random_state))
for m in range(alphas.size):
for n in range(random_state):
nn = MLPRegressor(hidden_layer_sizes=(hidden_layers, ),
activation=activation_mode,
solver=solver_mode,
alpha=alphas[m],
max_iter=max_iter,
random_state=n)
nn.fit(x_train, y_train)
train_mse[m][n] = calculate_mse(nn, x_train, y_train)
test_mse[m][n] = calculate_mse(nn, x_test, y_test)
plot_mse_vs_alpha(train_mse, test_mse, alphas)
pass
def ex_1_2_a(x_train, x_test, y_train, y_test):
"""
Solution for exercise 1.2 a)
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:
"""
alphas = [
pow(10, -8),
pow(10, -7),
pow(10, -6),
pow(10, -5),
pow(10, -4),
pow(10, -3),
pow(10, -2),
pow(10, -1), 1, 10, 100
]
n_iterations = 10
train_mses = numpy.zeros((11, n_iterations))
test_mses = numpy.zeros((11, n_iterations))
r = 0
for alph in alphas:
for i in range(n_iterations):
trained_regressor = MLPRegressor(hidden_layer_sizes=(40, ),
activation='logistic',
solver='lbfgs',
alpha=alph,
tol=1e-8,
max_iter=200,
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_alpha(train_mses, test_mses, alphas)
pass
def ex_1_2_a(x_train, x_test, y_train, y_test):
"""
Solution for exercise 1.2 a)
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:
"""
'''
Write code to train a neural network with n = 40 hidden neurons with values of alpha α =
[10−8, 10−7, 10−6, 10−5, 10−4, 10−3, 10−2, 10−1, 1, 10, 100]. Stack your results in an array where
the first axis correspond to the regularization parameter and the second to the number of
random seeds. Use the training solver ‘lbfgs’, for 200 iterations and 10 different random seeds.
'''
params_alpha = np.array([
10**-8, 10**-7, 10**-6, 10**-5, 10**-4, 10**-3, 10**-2, 10**-1, 1, 10,
100
])
seeds = np.array(range(1, 11))
train_mses = np.zeros((params_alpha.shape[0], seeds.shape[0]))
test_mses = np.zeros((params_alpha.shape[0], seeds.shape[0]))
for index_seed, seed in np.ndenumerate(seeds):
for index_alpha, alpha in np.ndenumerate(params_alpha):
nn = MLPRegressor(solver='lbfgs',
max_iter=200,
activation='logistic',
hidden_layer_sizes=(40, ),
alpha=alpha,
random_state=seed)
nn.fit(x_train, y_train)
train_mses[index_alpha,
index_seed] = calculate_mse(nn, x_train, y_train)
test_mses[index_alpha,
index_seed] = calculate_mse(nn, x_test, y_test)
plot_mse_vs_alpha(train_mses, test_mses, params_alpha)
pass
