05-11 02:39 阅读 221

吴恩达机器学习作业（一）_python实现

必做部分：（主要参考了黄海广老师的文档）

import numpy as np

import matplotlib.pyplot as plt

import pandas as pd

df = pd.read_csv('ex1data1.txt', names=['population', 'profit'])

data = df

#def normalize_feature(df):

#return df.apply(lambda column: (column - column.mean()) / column.std())#特征缩放

def get_X(df):#读取特征

ones = pd.DataFrame({'ones': np.ones(len(df))})#ones是m行1列的dataframe

data = pd.concat([ones, df], axis=1) # 合并数据，根据列合并 axis：需要合并链接的轴，0是行，1是列

return data.iloc[:, :-1]

def linear_cost(theta , X , y):

m = X.shape[0] #样本数

inner = X @ theta - y #与目标的差值即h(theta),inner算出来为一行

square_sum = inner.T @ inner #h(theta)的平方

cost = square_sum/(2*m)

return cost

def gradient(theta, X, y):

m = X.shape[0]

inner = X.T @ (X@theta - y) #X仅有仅有一个特征，恒为1的不算，即该语句算的是更新theta1时，损失函数对theta1的求导

return inner/m

def batch_gradient_decent(theta, X, y, epoch, alpha=0.02):

cost_data = [linear_cost(theta, X, y)]

for _ in range(epoch): #_仅是一个循环标志，在循环中不会用到

theta = theta - alpha * gradient(theta, X, y)

cost_data.append(linear_cost(theta, X, y))

return theta, cost_data

X = get_X(df)

y = df.values[:, 1]

theta = np.zeros(df.shape[1])

epoch = 6000

final_theta, cost_data = batch_gradient_decent(theta, X, y, epoch)

b = final_theta[0]

k = final_theta[1]

plt.scatter(data.population, data.profit, label="Training data")

plt.plot(data.population, data.population*k + b, label="Prediction")

plt.xlabel('population')

plt.ylabel('profit')

plt.legend(loc=2)

forecast = float(input('population'))

predict_profit = forecast*k+b

print(predict_profit)

plt.scatter(forecast, predict_profit, marker='+', c='red')

plt.show()

我预测值（forecast）输入的23，用红色标记了

选作部分

import numpy as np

import matplotlib.pyplot as plt

import pandas as pd

ax = plt.axes(projection='3d')

df = pd.read_csv('ex1data2.txt', names=['square', 'bedrooms', 'price'])

def normalize_feature(df):

return df.apply(lambda column: (column - column.mean()) / column.std())

def get_X(df):#读取特征

ones = pd.DataFrame({'ones': np.ones(len(df))})#ones是m行1列的dataframe

data = pd.concat([ones, df], axis=1) # 合并数据，根据列合并 axis：需要合并链接的轴，0是行，1是列

return data.iloc[:, :-1]

def lr_cost(theta, X, y):

m = X.shape[0]#m为样本数

inner = X @ theta - y # R(m*1)，X @ theta等价于X.dot(theta)

square_sum = inner.T @ inner

cost = square_sum / (2 * m)

return cost

def gradient(theta, X, y):

m = X.shape[0] #样本个数

inner = X.T @ (X @ theta - y) # (m,n).T @ (m, 1) -> (n, 1)，X @ theta等价于X.dot(theta)

return inner / m

def batch_gradient_decent(theta, X, y, epoch, alpha=0.01):

cost_data = [lr_cost(theta, X, y)]

for _ in range(epoch):

theta = theta - alpha * gradient(theta, X, y)

cost_data.append(lr_cost(theta, X, y))

return theta, cost_data

def normalEqn(X, y): #正规方程

theta = np.linalg.inv(X.T@X)@X.T@y#X.T@X等价于X.T.dot(X)

return theta

data = normalize_feature(df) #特征缩放

y = data.values[:, 2]

X = get_X(data)

ax.scatter(X['square'], X['bedrooms'], y, alpha=0.3)

plt.xlabel('square')

plt.ylabel('bedrooms')

ax.set_zlabel(r'$prices$')

epoch = 500

alpha = 0.01

theta = np.zeros(X.shape[1]) #在该问题中X有三个特征(1,square,bedrooms)，所以theta初始为三个零

final_theta, cost_data = batch_gradient_decent(theta, X, y, epoch, alpha=alpha)

D = final_theta[0]

A = final_theta[1]

B = final_theta[2]

Z = A*X['square'] + B*X['bedrooms'] + D

ax.plot_trisurf(X['square'], X['bedrooms'], Z,

linewidth=0, antialiased=False)

predict_square = float(input('square:'))

predict_square = ((predict_square - df.square.mean())/df.square.std())

predict_bedrooms = float(input('bedrooms'))

predict_bedrooms = ((predict_bedrooms - df.bedrooms.mean())/df.bedrooms.std())

p = A * predict_square + B*predict_bedrooms + D

ax.scatter(predict_square, predict_bedrooms, marker='+', c='red')

p = p * df.price.std() + df.price.mean()

print('I predict the prices is :')

print(p)

plt.show()

输入为

square=1635

bedrooms=3

I predict the prices is :

292611.913236568

理论上说预测的点应该在所画的平面上，但实际却不在，可能是因为我平面画的不对。预测结果可以使用。

————————————————

原文链接：https://blog.csdn.net/qq_45882032/article/details/116500250