机器学习
机器学习分为监督学习和无监督学习，监督学习为有标签，无监督学习无标签。监督学习分为分类和回归，而无监督学习包括聚类和降维。分类是预测的结果可列出，成为分类问题，为离散型；回归预测的结果是不可列出的，成为回归问题，为连续型。
1. 单变量线性回归
步骤：
‘’’
1,导包
2.加载数据
3.数据初始化（数据切割，数据拼接，。。。。。）
4.写模型函数
5.代价函数
6。梯度算法
7.数据分析（数据可视化，数据分析）
‘’’
1.1 模型函数
#模型
def model(x,theta):
return x.dot(theta)
1.2 代价函数
#代价函数
def cost(h,y):
# return 1/(2*m)*(np.sum(h-y))**2
J=1/(2*m)*(h-y).T.dot(h-y)
return J
1.3 梯度下降函数（降维函数）
#梯度下降函数
def gradedecline(x,y,alpha,nums):
m, n = x.shape
theta = np.zeros(n)
# theta=np.array([0,1])
# [0,0]
# j = np.zeros(nums)
j=[]
for i in range(nums):
h=model(xx,theta)
# j[i]=cost(h,y)
k=cost(h,y)
j.append(k)
# 计算梯度
deltatheta = 1 / m * x.T.dot(h - y)
# 更新参数
theta = theta - alpha * deltatheta
return theta,h,j
1.4. 缩放函数
#缩放
def suofang(x):
miu=np.mean(x)
sigma=np.std(x)
x=(x-miu)/sigma
return x
def suofang(x):
xmin=np.min(x,axis=0)
xmax=np.max(x,axis=0)
return x-xmin/(xmax-xmin)
1.5 代码运行
if __name__ == '__main__':
#1.加载数据
data=np.loadtxt('ex1data1.txt',delimiter=',')
# print(data)
#2.切割数据
x=data[:,:-1]
y=data[:,-1]
m,n=x.shape
# print(x.shape)
# print(y.shape)
# print(x)
# print(y)
#3.行拼接（方法一）
xx=np.c_[np.ones(len(x)),x]
# print(xx)
#行拼接（方法二）
#one=np.ones(len(x))
#b=one.reshape(m,1)
#xx=np.hstack([b,x])
# print(xx)
#4.调用梯度算法
theta,h,j=gradedecline(xx,y,0.01,1000)
#创建画布
plt.figure()
plt.subplot(121)
plt.scatter(x,y)
plt.plot(x,h)
plt.subplot(122)
plt.plot(j)
plt.show()
# 结果完善
print('theta=', theta) # 输出最优theta
print('h=\n', h)
print('y=\n',y)
2. 多变量线性回归
步骤
# 1.加载数据包
# 2.读取数据集ex1data2.txt
# 3.数据切分成x和y（所有数据都是二维）
# 4.用标准化做特征缩放
# 5.数据拼接
# 5.1 将拼接的数据进行训练集测试集切分
# 6.写模型函数
# 7.写代价函数
# 8.梯度下降
# 9.调用梯度下降，花出代价函数，输出theta值
# 10.将第8步改用正规方程去做，输出theta值
2.1 模型函数
# 定义x*theta函数
def model(x,theta):
return x.dot(theta)
2.2 代价函数
def cost(h,y):
return -1/m * np.sum(y*np.log(h)+(1-y)*np.log(1-h))
2.3 降维函数
def gradeDecline(xx,y,alpha,nums):
m,n=xx.shape
print(m,n)
theta=np.zeros((n,1))#必须是列（n,1）
print(theta)
# jarr=[]
jarr=np.zeros(nums)
for i in range(nums):
h=model(xx,theta)
k=cost(h,y)
# jarr.append(k)
jarr[i]=cost(h,y)
dietasaita=(1/m)*xx.T.dot(h-y)
theta=theta-alpha*dietasaita
return theta,jarr,h
2.4缩放函数
def suofang(x):
xmin=np.min(x,axis=0)
xmax=np.max(x,axis=0)
X=(x-xmin)/(xmax-xmin)
return X
2.5 代码运行
import matplotlib.pyplot as plt
import numpy as np
# 1.加载数据包
# 2.读取数据集ex1data2.txt
data=np.loadtxt('E:\机器学习\机器学习1\机器\ex1data2.txt',delimiter=',')
# print(data)
# 3.数据切分成x和y（所有数据都是二维）
x=data[:,:-1]
y=data[:,-1:]
# print(x)
# print(y)
m,n=x.shape
# print(m,n)
a=np.ones(len(data))
# 4.用标准化做特征缩放
x=suofang(x)
# 5.数据拼接
xx=np.c_[a,x]
# print(xx)
# 5.1 将拼接的数据进行训练集测试集切分
m=len(x)
trainnum=int(m*0.7)
trainx=xx[:trainnum,:]
testx=xx[trainnum:,:]
# print(trainx)
# print(trainx.shape)
trainy=y[:trainnum]
testy=y[trainnum:]
theta,jarr,h=gradeDecline(trainx,trainy,0.01,15000)
print(theta)
plt.subplot(121)
# plt.scatter(trainy,trainy)#训练值
plt.scatter(trainy,model(trainx,theta))#测试值
plt.plot(testy,testy)
# plt.scatter(testy,model(testx,theta))#测试值
# plt.subplot(122)
# plt.plot(jarr)
plt.show()
2.6 正规方程
#正规方程直接求theta
def zhenggui(x,y):
theta=np.linalg.inv(x.T.dot(x))*(x.T.dot(y))
return theta
b=zhenggui(trainx,trainy)
print(b)
3. 线性回归模型（导入sklearn包）
'''
1.特征缩放
2.拼接数据集
3.数据切分
4.调库
4.1训练模型
5.输出精度，权重，截距，预测值
'''
from sklearn.datasets import load_boston
import numpy as np
from sklearn.linear_model import LinearRegression,LogisticRegression
#1.加载数据
data=load_boston()
x=data.data#读取特征
y=data.target#读取标签
print(x.shape)
print(y.shape)
a=np.ones(len(x))
# 2.用标准化做特征缩放
def suofang(x):
xmin=np.min(x,axis=0)
xmax=np.max(x,axis=0)
X=(x-xmin)/(xmax-xmin)
return X
x=suofang(x)
# 3.数据拼接
xx=np.c_[a,x]
print(xx)
#4.数据切分
#5.调库
line=LinearRegression()
line.fit(xx,y)#创建模型
print('精度',line.score(xx,y))
print('权重',line.coef_)#相当于k
print('截距',line.intercept_)#相当于b
xxxx=np.array([1,0.2,1.3,1.1,0.4,6,2,0.6,3,0.6,0.1,0.7,0.2,0.5])
print(xxxx)
b=xxxx.reshape(1,14)
print(b)
print('预测值',line.predict(b))