def testLinreg():
train_x, train_y, dev_x, dev_y, test_x, test_y, x_max, y_max = util.loadLinRegData(
)
LR = LinearRegression()
LR.fit_stochastic(train_x, train_y, eta=.01, eps=10**-12, max_iters=10**8)
preds = LR.predict(train_x)
train_linreg_rmse = util.findRMSE(preds, train_y) * y_max[0]
preds = LR.predict(test_x)
test_linreg_rmse = util.findRMSE(preds, test_y) * y_max[0]
print('Linreg RMSE: \t', test_linreg_rmse)
return train_linreg_rmse, test_linreg_rmse
y = np.matrix((allData[:, -1])).T
n, d = X.shape
# Add a row of ones for the bias term
X = np.c_[np.ones((n, 1)), X]
# initialize the model
init_theta = np.matrix(
np.ones((d + 1, 1))
) * 10 # note that we really should be initializing this to be near zero, but starting it near [10,10] works better to visualize gradient descent for this particular problem
n_iter = 1500
alpha = 0.01
# Instantiate objects
lr_model = LinearRegression(init_theta=init_theta,
alpha=alpha,
n_iter=n_iter)
plotData1D(X[:, 1], y)
lr_model.fit(X, y)
plotRegLine1D(lr_model, X, y)
# Visualize the objective function convex shape
theta1_vals = np.linspace(-10, 10, 100)
theta2_vals = np.linspace(-10, 10, 100)
visualizeObjective(lr_model, theta1_vals, theta2_vals, X, y)
# Compute the closed form solution in one line of code
theta_closed_form = 0 # TODO: replace "0" with closed form solution
print "theta_closed_form: ", theta_closed_form
eta_vals = [10**-4, 10**-3, 10**-2]
max_iters = [10**8, 10**7, 10**6]
results = []
for eps_val in eps_vals:
for eta_val in eta_vals:
for max_iter in max_iters:
print('Fitting regression with eta', eta_val, 'eps', eps_val,
'max iter', max_iter)
cur_result = []
cur_result.append(eps_val)
cur_result.append(eta_val)
cur_result.append(max_iter)
LR = LinearRegression()
LR.fit_stochastic(train_x,
train_y,
eta=eta_val,
eps=eps_val,
max_iters=max_iter)
preds = LR.predict(train_x)
rmse = util.findRMSE(preds, train_y)
cur_result.append(rmse * y_max[0])
preds = LR.predict(dev_x)
rmse = util.findRMSE(preds, dev_y)
cur_result.append(rmse * y_max[0])
results.append(cur_result)
Xtrain = X[train_indice:valid_indice_one - 1]
ytrain = y[train_indice:valid_indice_one - 1]
Xvalidate_one = X[valid_indice_one:valid_indice_two - 1]
yvalidate_one = y[valid_indice_one:valid_indice_two - 1]
Xvalidate_two = X[valid_indice_two:]
yvalidate_two = y[valid_indice_two:]
num_of_polynomials = 5
best_poly = 1
best_err = 100
for poly in range(1, num_of_polynomials):
print("Polynomial degree: %.3f" % poly)
model = LinearRegression(poly)
model.fit(Xtrain, ytrain)
y_hat_train = model.predict(Xtrain)
y_hat_validate_one = model.predict(Xvalidate_one)
y_hat_validate_two = model.predict(Xvalidate_two)
tr_err = np.mean((y_hat_train - ytrain)**2)
va_err_one = np.mean((y_hat_validate_one - yvalidate_one)**2)
va_err_two = np.mean((y_hat_validate_two - yvalidate_two)**2)
print("Train error: %.3f" % tr_err)
print("Val1 error: %.3f" % va_err_one)
print("Val2 error: %.3f \n" % va_err_two)
sum_err = (va_err_one + va_err_two) / 2
if sum_err < best_err:
best_err = sum_err
# and the third column is the price of the house, which we want to predict.
file_name = 'dataset/ex1data2.txt'
with open(file_name, 'r') as f:
house_data = np.loadtxt(file_name, delimiter=',')
num_sample = house_data.shape[0] # number of all the samples
X = house_data[:, :2]
y = house_data[:, 2].reshape((-1, 1))
# Add intercept term or bias to X
print('X shape: ', X.shape)
print('y shape: ', y.shape)
print('First 10 examples from the dataset')
print(house_data[0:10, :])
# Normalize
X = (X - np.mean(X, axis=0)) / np.std(X, axis=0)
# Add bias dimension
X = np.hstack((X, np.ones((num_sample, 1))))
lr_bgd = LinearRegression()
tic = time.time()
losses_bgd = lr_bgd.train(X,
y,
method='sgd',
learning_rate=1e-2,
num_iters=1000,
verbose=True)
toc = time.time()
print('Traning time for BGD with vectorized version is %f \n' % (toc - tic))
print(lr_bgd.W)
