def output(partId):
# Random Test Cases
X1 = np.column_stack(
(np.ones(20), np.exp(1) + np.exp(2) * np.linspace(0.1, 2, 20)))
Y1 = X1[:, 1] + np.sin(X1[:, 0]) + np.cos(X1[:, 1])
X2 = np.column_stack((X1, X1[:, 1]**0.5, X1[:, 1]**0.25))
Y2 = np.power(Y1, 0.5) + Y1
if partId == '1':
out = formatter('%0.5f ', warmUpExercise())
elif partId == '2':
out = formatter('%0.5f ', computeCost(X1, Y1, np.array([0.5, -0.5])))
elif partId == '3':
out = formatter(
'%0.5f ', gradientDescent(X1, Y1, np.array([0.5, -0.5]), 0.01, 10))
elif partId == '4':
out = formatter('%0.5f ', featureNormalize(X2[:, 1:4]))
elif partId == '5':
out = formatter(
'%0.5f ', computeCostMulti(X2, Y2, np.array([0.1, 0.2, 0.3, 0.4])))
elif partId == '6':
out = formatter(
'%0.5f ',
gradientDescentMulti(X2, Y2, np.array([-0.1, -0.2, -0.3, -0.4]),
0.01, 10))
elif partId == '7':
out = formatter('%0.5f ', normalEqn(X2, Y2))
return out
def output(partId):
# Random Test Cases
X1 = column_stack((ones(20), exp(1) + dot(exp(2), arange(0.1, 2.1, 0.1))))
Y1 = X1[:,1] + sin(X1[:,0]) + cos(X1[:,1])
X2 = column_stack((X1, X1[:,1]**0.5, X1[:,1]**0.25))
Y2 = Y1**0.5 + Y1
if partId == '1':
return sprintf('%0.5f ', warmUpExercise())
elif partId == '2':
return sprintf('%0.5f ', computeCost(X1, Y1, array([0.5, -0.5])))
elif partId == '3':
return sprintf('%0.5f ', gradientDescent(X1, Y1, array([0.5, -0.5]), 0.01, 10))
elif partId == '4':
return sprintf('%0.5f ', featureNormalize(X2[:,1:3]));
elif partId == '5':
return sprintf('%0.5f ', computeCostMulti(X2, Y2, array([0.1, 0.2, 0.3, 0.4])))
elif partId == '6':
return sprintf('%0.5f ', gradientDescentMulti(X2, Y2, array([-0.1, -0.2, -0.3, -0.4]), 0.01, 10))
elif partId == '7':
return sprintf('%0.5f ', normalEqn(X2, Y2))
input('Program paused. Press enter to continue.\n')
## ================ Part 3: Normal Equations ================
print('Solving with normal equations...\n')
## Load Data
data = np.loadtxt('ex1data2.txt', delimiter=",")
X = data[:, 0:2]
y = data[:, 2].reshape(-1, 1)
m = len(y)
# Add intercept term to X
X = np.vstack((np.ones(m), X.T)).T
# Calculate the parameters from the normal equation
theta = normalEqn(X, y)
# Display normal equation's result
print('Theta computed from the normal equations: \n')
print(theta)
print('\n')
temp = np.array([[1.0, 1650.0, 3.0]])
price = np.dot(temp, theta)
print(
'Predicted price of a 1650 sq-ft, 3 br house (using gradient descent):\n $%f\n'
% price)
input('Program paused. Press enter to continue.\n')
print('Solving with normal equations...')
# ====================== YOUR CODE HERE ====================
# Load Data
data = np.asmatrix(np.loadtxt('ex1data2.txt', delimiter=','))
X = data[:, :2]
y = data[:, 2]
m = y.shape[0]
# Add intercept term to X
X = np.hstack((np.ones((m, 1)), X))
# Calculate the parameters from the normal equation
theta = normalEqn(X, y)
# Display normal equation's result
print('Theta computed from the normal equations:')
print(theta)
# Estimate the price of a 1650 sq-ft, 3 br house
# ====================== YOUR CODE HERE ======================
price = 0 # You should change this
price = np.matrix([1, 1650, 3]).dot(theta)
# ============================================================
print('Predicted price of a 1650 sq-ft, 3 br house ' +
'(using normal equations):\n $%f\n' % (price))
#
# After doing so, you should complete this code
# to predict the price of a 1650 sq-ft, 3 br house.
#
## Load Data
data = np.loadtxt('ex1data2.txt', delimiter=",")
X = data[:, :2]
y = data[:, 2]
m = len(y) # number of training examples
# Add intercept term to X
X_padded = np.column_stack((np.ones((m, 1)), X))
# Calculate the parameters from the normal equation
theta = ne.normalEqn(X_padded, y)
# Display normal equation's result
print('Theta computed from the normal equations:')
print("{:f}, {:f}, {:f}".format(theta[0], theta[1], theta[2]))
print('')
# Estimate the price of a 1650 sq-ft, 3 br house
# ====================== YOUR CODE HERE ======================
house_norm_padded = np.array([1, 1650, 3])
price = np.array(house_norm_padded).dot(theta)
# ============================================================
print(
"Predicted price of a 1650 sq-ft, 3 br house (using gradient descent):\n ${:,.2f}"
# ====================== YOUR CODE HERE ======================
# Instructions: The following code computes the closed form solution for linear regression using the normal
# equations. You should complete the code in normalEqn.m
# After doing so, you should complete this code to predict the price of a 1650 sq-ft, 3 br house.
# # Load Data
data = np.loadtxt('ex1data2.txt', delimiter=',')
X = data[:, 0:2]
y = data[:, 2]
m = len(y)
# Add intercept term to X
X = np.column_stack((np.ones((m, 1)), X))
# Calculate the parameters from the normal equation
theta = ne.normalEqn(X, y)
# Display normal equation's result
print('Theta computed from the normal equations: \n')
print(' {:f} {:f} {:f}\n'.format(theta[0], theta[1], theta[2]))
print('\n')
# Estimate the price of a 1650 sq-ft, 3 br house
# ====================== YOUR CODE HERE ======================
price = 0 # You should change this
area = 1650
br = 3
added = np.array([1, area, br])
theta = np.array(theta)
price = np.dot(added, theta)
# ============================================================
plt.plot(np.arange(0, num_iters), J_history, "b-")
plt.xlabel('Number of Iteration')
plt.ylabel('Cost J')
plt.title('Gradient Descent')
plt.draw()
plt.pause(0.001)
#Display gradient descent's result
print('Theta computed from gradient descent: \n', theta)
# % Estimate the price of a 1650 sq-ft, 3 br house
# % Recall that the first column of X is all-ones. Thus, it does not need to be normalized.
price = ((np.array([[1, (1650 - mu[0]) / sigma[0],
(3 - mu[1]) / sigma[1]]])) @ theta)[0, 0]
print("Estimated price of a 1650 sq-ft, 3 br house $", price)
input("Press Enter to continue...")
# ================ Part 3: Normal Equations ================
print('Solving with normal equations...\n')
data = pd.read_csv('ex1data2.txt', header=None)
X, y = data.iloc[:, :2], data.iloc[:,
2] #Data Separated into two pandas series
X = np.concatenate([np.ones((m, 1)), np.array(X)], axis=1)
theta = NE.normalEqn(X, y)
print('Theta computed from the normal equations\n', theta)
price = np.array([[1, 1650, 3]]) @ theta
print(
'Predicted price of a 1650 sq-ft, 3 br house (using normal equations):\n',
price)
# The complete model to execute the whole multi-regression
import loadData
import featureNormalize
import normalEqn
import gradientDescent
import numpy
def init(number):
return numpy.random.normal(0, 1, number + 1)
def multiRegression(number, x, y, learning_rate=1e-3, epoch=50):
weights = init(number)
for i in range(epoch):
weights = gradientDescent.computeCost(learning_rate, weights, x, y)
return weights
if __name__ == '__main__':
x, y = loadData.loadData('ex1data2.txt', 2)
x = featureNormalize.featureNormalize(x, 2)
print normalEqn.normalEqn(x, y)
print multiRegression(2, x, y)
# Choose some alpha value
alpha = 0.01
num_iters = 1500
# Init Theta and Run Gradient Descent
theta = np.zeros((3, 1))
theta, J_history = gdm.gradientDescent(X_norm, y, theta, alpha, num_iters)
#Plot the convergence of the cost function
def plotConvergence(jvec):
plt.figure()
plt.plot(range(len(jvec)), jvec, 'bo')
plt.grid(True)
plt.title("Convergence of Cost Function")
plt.xlabel("Iteration number")
plt.ylabel("Cost function")
plt.show()
#Plot convergence of cost function:
# plotConvergence(J_history)
#compute the gradient by using Normal Equations without feature scaling and gradient descent
X = np.column_stack((np.ones(m), X)) # Add a column of ones to x
theta = neqn.normalEqn(X, y)
print(theta)
print("$%0.2f" % np.dot(theta.T, [[1], [1650.], [3]]))
#
# After doing so, you should complete this code
# to predict the price of a 1650 sq-ft, 3 br house.
#
## Load Data
data = np.loadtxt('ex1data2.txt', delimiter=",")
X = data[:,:2]
y = data[:,2]
m = len(y) # number of training examples
# Add intercept term to X
X_padded = np.column_stack((np.ones((m,1)), X))
# Calculate the parameters from the normal equation
theta = ne.normalEqn(X_padded, y)
# Display normal equation's result
print('Theta computed from the normal equations:')
print("{:f}, {:f}, {:f}".format(theta[0], theta[1], theta[2]))
print('')
# Estimate the price of a 1650 sq-ft, 3 br house
# ====================== YOUR CODE HERE ======================
house_norm_padded = np.array([1, 1650, 3])
price = np.array(house_norm_padded).dot(theta)
# ============================================================
print("Predicted price of a 1650 sq-ft, 3 br house (using gradient descent):\n ${:,.2f}".format(price))
print('\nRunning Gradient Descent ...\n')
# run gradient descent
from gradientDescent import gradientDescent
theta, J_history = gradientDescent(X, y, theta, alpha, iterations)
# plot the convergence graph
print('\nploting the convergence graph...\n')
plt.plot(range(iterations), J_history, color='coral')
plt.xlabel('Number of iterations')
plt.ylabel('Cost J')
plt.show()
print('\nRunning Normal Equation ...\n')
# run normal equation
from normalEqn import normalEqn
theta_ne = normalEqn(X, y)
# print theta to screen
print('Theta found by gradient descent:\n')
print(' {:.4f}\n {:.4f}\n'.format(theta[0][0], theta[1][0]))
print('Theta found by normal equation:\n')
print(' {:.4f}\n {:.4f}\n'.format(theta_ne[0, 0], theta_ne[1, 0]))
print('Expected theta values (approx)\n')
print(' -3.6303\n 1.1664\n\n')
print('\nProgram paused. Press enter to continue.\n')
input()
# plot the linear fit
print('\nploting linear fit...\n')
plt.scatter(X[:, 1], y, color='red', marker='x', s=10)
#Display gradient descent's result
print('Theta computed from gradient descent: \n');
print(" %s \n" %theta);
print('\n');
price =np.matrix( [ 1 , -0.44604386, -0.224428357 ]) * theta
price=str(price).replace('[','').replace(']','')
print("Predicted price of 1650sq with 3 bedrooms is %s $\n"%price)
"""==============================Normal Equation ==================="""
#load Data since we dont normalize it in Norma Equation
data = np.loadtxt(('ex1data2.txt'),delimiter=",");
X = data[:, 0:2]
y = data[:, 2:3];
m = len(y);
# Add intercept term to X
X=np.c_[np.ones(m),X]
#Display theta computed from norma equations
print('Theta computed from the normal equations: \n');
theta=nEqn.normalEqn(X,y)
print(' %s \n' %(theta));
print('\n');
price =np.matrix( [1, 1650, 3] )* theta
price=str(price).replace('[','').replace(']','')
"""==========================predicting price of a house using normal Eqns=================================="""
print('Predicted price of a 1650 sq-ft, 3 br house (using normal equations):\n%s $\n' %price);
# to predict the price of a 1650 sq-ft, 3 br house.
#
print('Solving with normal equations...')
# Load Data
data = np.loadtxt('ex1data2.txt', delimiter=',')
X = data[:, :2]
y = data[:, 2]
m = y.T.size
# Add intercept term to X
X = np.concatenate((np.ones((m, 1)), X), axis=1)
# Calculate the parameters from the normal equation
theta_norm = normalEqn(X, y)
# Display normal equation's result
print('Theta computed from the normal equations: $')
print('%s \n' % theta)
# Estimate the price of a 1650 sq-ft, 3 br house
price = np.array([1, 1650, 3]).dot(theta_norm)
# ============================================================
print("Predicted price of a 1650 sq-ft, 3 br house ")
print('(using normal equations):\n $%f\n' % price)
input("Program paused. Press Enter to continue...")
def ex1_multi():
# Initialization
# ================ Part 1: Feature Normalization ================
# Clear and Close Figures
#clear ; close all; clc
print('Loading data ...')
# Load Data
data = np.loadtxt('ex1data2.txt', delimiter=',')
X = np.reshape(data[:, 0:2], (data.shape[0], 2))
y = np.reshape(data[:, 2], (data.shape[0], 1))
m = y.shape[0]
# Print out some data points
print('First 10 examples from the dataset: ')
print(np.c_[X[0:10, :], y[0:10, :]].T)
print('Program paused. Press enter to continue.')
#input()
# Scale features and set them to zero mean
print('Normalizing Features ...')
X, mu, sigma = featureNormalize(X)
# Add intercept term to X
X = np.c_[np.ones((m, 1)), X]
# ================ Part 2: Gradient Descent ================
# ====================== YOUR CODE HERE ======================
# Instructions: We have provided you with the following starter
# code that runs gradient descent with a particular
# learning rate (alpha).
#
# Your task is to first make sure that your functions -
# computeCost and gradientDescent already work with
# this starter code and support multiple variables.
#
# After that, try running gradient descent with
# different values of alpha and see which one gives
# you the best result.
#
# Finally, you should complete the code at the end
# to predict the price of a 1650 sq-ft, 3 br house.
#
# Hint: By using the 'hold on' command, you can plot multiple
# graphs on the same figure.
# Hint: At prediction, make sure you do the same feature normalization.
# Begin: My code plotting for different learning rates
alphas = [0.3, 0.1, 0.03, 0.01]
colors = ['r', 'g', 'b', 'k']
short_iters = 50
fig = plt.figure()
#hold on;
plt.xlabel('Number of iterations')
plt.ylabel('Cost J')
for i in range(len(alphas)):
_, J = gradientDescentMulti(X, y, np.reshape(np.zeros((3, 1)), (3, 1)), alphas[i], short_iters)
plt.plot(range(len(J)), J, colors[i], markersize=2)
plt.savefig('figure1.multi.png')
# End: My code plotting for different learning rates
print('Running gradient descent ...')
# Choose some alpha value
alpha = 0.01
num_iters = 400
# Init Theta and Run Gradient Descent
theta = np.reshape(np.zeros((3, 1)), (3, 1))
theta, J_history = gradientDescentMulti(X, y, theta, alpha, num_iters)
# Plot the convergence graph
fig = plt.figure()
plt.plot(range(len(J_history)), J_history, '-b', markersize=2)
plt.xlabel('Number of iterations')
plt.ylabel('Cost J')
plt.savefig('figure2.multi.png')
# Display gradient descent's result
print('Theta computed from gradient descent: ')
print(theta)
print()
# Estimate the price of a 1650 sq-ft, 3 br house
# ====================== YOUR CODE HERE ======================
# Recall that the first column of X is all-ones. Thus, it does
# not need to be normalized.
#price = 0; % You should change this
price = np.dot(np.r_[1, np.divide(np.subtract([1650, 3], mu), sigma)], theta)
# ============================================================
print('Predicted price of a 1650 sq-ft, 3 br house (using gradient descent):\n $%f' % price)
print('Program paused. Press enter to continue.')
#input()
# ================ Part 3: Normal Equations ================
print('Solving with normal equations...')
# ====================== YOUR CODE HERE ======================
# Instructions: The following code computes the closed form
# solution for linear regression using the normal
# equations. You should complete the code in
# normalEqn.m
#
# After doing so, you should complete this code
# to predict the price of a 1650 sq-ft, 3 br house.
#
# Load Data
data = np.loadtxt('ex1data2.txt', delimiter=',')
X = np.reshape(data[:, 0:2], (data.shape[0], 2))
y = np.reshape(data[:, 2], (data.shape[0], 1))
m = y.shape[0]
# Add intercept term to X
X = np.c_[np.ones((m, 1)), X]
# Calculate the parameters from the normal equation
theta = normalEqn(X, y)
# Display normal equation's result
print('Theta computed from the normal equations: ')
print(theta)
print('')
# Estimate the price of a 1650 sq-ft, 3 br house
# ====================== YOUR CODE HERE ======================
price = np.dot([1, 1650, 3], theta) # You should change this
# ============================================================
print('Predicted price of a 1650 sq-ft, 3 br house (using normal equations):\n $%f' % price)
# http://scikit-learn.org/stable/auto_examples/linear_model/plot_ridge_coeffs.html
# Using sklearn
X = np.reshape(data[:, 0:2], (data.shape[0], 2))
y = np.reshape(data[:, 2], (data.shape[0], 1))
model = linear_model.Ridge(max_iter=num_iters, solver='lsqr')
count = 200
alphas = np.logspace(-3, 1, count)
coefs = np.zeros((count, 2))
errors = np.zeros((count, 1))
for i, alpha in enumerate(alphas):
model.set_params(alpha=alpha)
model.fit(X, y)
coefs[i, :] = model.coef_
errors[i, 0] = metrics.mean_squared_error(model.predict(X), y)
results = [(r'$\theta_1$', coefs[:, 0]), (r'$\theta_2$', coefs[:, 1]), ('MSE', errors)]
for i, result in enumerate(results):
label, values = result
plt.figure()
ax = plt.gca()
ax.set_xscale('log')
ax.plot(alphas, values)
plt.xlabel(r'$\alpha$')
plt.ylabel(label)
plt.savefig('figure%d.multi.sklearn.png' % (i + 1))
#model = linear_model.LinearRegression()
model = linear_model.Ridge(alpha=alpha, max_iter=num_iters, solver='lsqr')
model.fit(X, y)
print('Theta found: ')
print('%f %f %f' % (model.intercept_[0], model.coef_[0, 0], model.coef_[0, 1]))
print('Predicted price of a 1650 sq-ft, 3 br house (using sklearn):\n $%f' % model.predict([[1650, 3]]))
# =============Use Scikit-learn =============
regr = linear_model.LinearRegression(fit_intercept=False, normalize=True)
regr.fit(X, y)
print 'Theta found by scikit: '
print '%s %s \n' % (regr.coef_[0], regr.coef_[1])
predict1 = np.array([1, 3.5]).dot(regr.coef_)
predict2 = np.array([1, 7]).dot(regr.coef_)
print 'For population = 35,000, we predict a profit of {:.4f}'.format(
predict1 * 10000)
print 'For population = 70,000, we predict a profit of {:.4f}'.format(
predict2 * 10000)
plt.figure()
plotData(data)
plt.plot(X[:, 1],
X.dot(regr.coef_),
'-',
color='black',
label='Linear regression wit scikit')
plt.legend(loc='upper right', shadow=True, fontsize='x-large', numpoints=1)
## plt.show()
raw_input("Program paused. Press Enter to continue...")
print 'Now, here are the optional parts!'
print "Normal equation theta parameters"
print normalEqn(X, y)