吴恩达机器学习课后编程作业（Week1)

单变量线性回归

#线性回归

#1.单变量线性回归

import numpy as np
from numpy.lib.shape_base import column_stack  #下线性代数工具包
import pandas as pd  #数据处理工具包
import matplotlib.pyplot as plt #画图工具包
 
path = 'ex1data1.txt'
data = pd.read_csv(path, header=None, names=['Population','Profit'])   #CSV读取和导出
data.head()  #预览数据 

data.describe()#打印出详细的数据
#print(data.head())  #终端打印出来

data.plot(kind = 'scatter', x = 'Population' , y = 'Profit',figsize = (8,6))  #绘图 figsize是大小
plt.show()  #终端打印出来
#kind = 'scatter'意思是绘制散点图

#现在让我们使用梯度下降来实现线性回归，以最小化成本函数。
#计算代价函数的函数（计算误差）
def computeCost(X,y,theta):
    inner = np.power(((X*theta.T)-y),2)   #thera.T 就是theta的转置
    
    return np.sum(inner)/(2*len(X))
    

#让我们在训练集中添加一列，以便我们可以使用向量化的解决方案来计算代价和梯度。
data.insert(0,'Ones',1)  #在第一列插入一列全为1
#data.head()  #预览数据 

#现在我们来做一些变量初始化。

#shape 它的功能是读取矩阵的长度，比如shape[0]就是读取矩阵第一维度的长度。
#它的输入参数可以使一个整数表示维度，也可以是一个矩阵。
cols = data.shape[1]   #3列
#print(cols)  打印出来3  矩阵的长度是3   
X = data.iloc[:,0:cols-1]#X是所有行，去掉最后一列    行，列   ：意思是所有的  
y = data.iloc[:,cols-1:cols]#X是所有行，最后一列   2：3就是只取第三列
X.head() #head()是观察前5行
y.head()


#代价函数是应该是numpy矩阵，所以我们需要用np.matrix转换X和Y，然后才能使用它们。 我们还需要初始化theta，即把theta所有元素都设置为0.
X = np.matrix(X.values)  #把x y都转换成numpy矩阵的形式
y = np.matrix(y.values) 
#定义一个theta      初始化一个二维数组 np.array([0,0])
# 再把theta转化成一个1*2的numpy矩阵
theta = np.matrix(np.array([0,0]))

theta   #看一下当前维度   输出 matrix([[0, 0]])
#看下维度
X.shape,  theta.shape,  y.shape


#计算代价函数
computeCost(X, y, theta)

批量梯度下降

#2.batch gradient decent（批量梯度下降）
#找出一个theta0 theta1  使J取得最小
#先对theta0来求导  

def gradientDescent(X,y,theta,alpha,iters):  #iters是梯度下降的次数
    temp = np.matrix(np.zeros(theta.shape))  #构建零值矩阵
    parameters = int(theta.ravel().shape[1]) #ravel计算需要求解的参数个数 功能将多维数组降至一维
    cost = np.zeros(iters) #构造iters个0数组  iters 迭代次数
    
    for i in range(iters):  #先进行整个梯度的循环
        error = (X * theta.T) - y
        for j  in range(parameters):  #在进行theta的循环
            term  = np.multiply(error,X[:,j]) #计算两矩阵(hθ(x)-y)x    当j=0 时，相当于乘以X的第一列
            temp[0,j] = theta[0,j] - ((alpha / len(X)) * np.sum(term) )   #这是计算梯度下降的更新公式
             #np.sum(term) 是求和  np.multiply（）是乘
            
        #梯度更新完了之后,将更新结果复制给theta
        theta = temp     
        cost[i] = computeCost(X,y,theta)
        
    return theta , cost
        
      
#初始化一些附加变量 - 学习速率α和要执行的迭代次数。
alpha =  0.01  
iters = 1000

#现在让我们运行梯度下降算法来将我们的参数θ适合于训练集。        
g,cost = gradientDescent(X,y,theta,alpha,iters)   
#元组拆包  
# g等于theta cost= cost
# g = matrix([[-3.24140214,  1.1272942 ]])

#最后，我们可以使用我们拟合的参数计算训练模型的代价函数（误差）。
computeCost(X, y, g)  #看看我们的新解对数据集的总误差是多少  


#现在我们来绘制线性模型以及数据，直观地看出它的拟合。fig代表整个图像，ax代表实例
x = np.linspace(data.Population.min(),data.Population.max(),100) #抽100个样
# python中创建数值序列工具 numpy.linspace(start,stop,num=50,endpoint=True,retstep=False,dtype=None)
f = g[0,0] + (g[0,1] * x) #g[0,0] 代表theta0 , g[0,1] 代表theta1

fig , ax1 = plt.subplots(figsize=(8,6))  #figsize用来设置图形的大小，a为图形的宽， b为图形的高      subplots绘图
ax1.plot(x, f, 'r', label='Prediction')
ax1.scatter(data.Population, data.Profit, label='Traning Data')
ax1.legend(loc=4)#显示标签位置
ax1.set_xlabel('Population')
ax1.set_ylabel('Profit')
ax1.set_title('Predicted Profit vs. Population Size')
plt.show()


#由于梯度方程式函数也在每个训练迭代中输出一个代价的向量，所以我们也可以绘制。 请注意，代价总是降低 - 这是凸优化问题的一个例子。
fig, ax2 = plt.subplots(figsize=(8,6))
ax2.plot(np.arange(iters), cost, 'r') 
ax2.set_xlabel('Iterations')
ax2.set_ylabel('Cost')
ax2.set_title('Error vs. Training Epoch')
plt.show()

# np.arange()函数返回一个序列  
             #1.只有一个参数的时候，默认从0开始到输入的参数，产生序列，步进为默认的1
             #2.有两个参数的时候，序列中的元素从第一个参数到第二个参数的区间产生，步进为默认的1
             #3.有三个参数的时候，序列中的元素从第一个参数到第二个参数的区间产生，步进为第三个参数
             
             

多变量线性回归

#3.多变量线性回归

#练习1还包括一个房屋价格数据集，其中有2个变量（房子的大小，卧室的数量）和目标（房子的价格）。 我们使用我们已经应用的技术来分析数据集。

path = 'ex1data2.txt'
data2 = pd.read_csv(path,header = None,names = ['Size','Bedrooms','Price'])
data2.head()  #在交互式中显示出来

#预处理步骤 - 特征归一化  
#如果这个房子价格不归一化，它的数量级和你输入值规一化数量级差别太大，几十万的数量级和个位小数做回归，就不能保证收敛了 预测的y和实际上y几十万差的太多了
data2 = (data2 - data2.mean()) / data2.std()  #mean()函数功能：求取均值
data2.head()

#现在我们重复第1部分的预处理步骤，并对新数据集运行线性回归程序。
#先插入一个ones
data2.insert(0,'Ones',1)
#data2.head()

#设置x和y
cols = data2.shape[1]
X2 = data2.iloc[:,0:cols-1]
y2 = data2.iloc[:,cols-1:cols]

#弄成numpy矩阵形式
X2 = np.matrix(X2.values)
y2 = np.matrix(y2.values)
theta2 = np.matrix(np.array([0,0,0]))

#用梯度下降函数求最小值theta
g2,cost2 = gradientDescent(X2,y2,theta2,alpha,iters)

#计算代价函数
computeCost(X2,y2,g2)

#可视化

fig,ax3 = plt.subplots(figsize=(8,6))
ax3.plot(np.arange(iters), cost2, 'r')
ax3.set_xlabel('Iterations')
ax3.set_ylabel('Cost')
ax3.set_title('Error vs. Training Epoch')
plt.show()

正规方程

#4.正规方程   一次性求解得到最优解
#np.linalg.inv求逆操作 @相当于dot() ,dot函数可以通过numpy库调用，也可以由数组实例对象进行调用。a.dot(b) 与 np.dot(a,b)效果相同。
#dot()返回的是两个数组的点积
#正规方程
def normalEqn(X,y):
    theta = np.linalg.inv(X.T@X)@X.T@y
    return theta

final_thata2 = normalEqn(X,y)
final_thata2
# 结果 matrix([[-3.89578088], [ 1.19303364]])