机器学习
机器学习分为监督学习和无监督学习，监督学习为有标签，无监督学习无标签。监督学习分为分类和回归，而无监督学习包括聚类和降维。分类是预测的结果可列出，成为分类问题，为离散型；回归预测的结果是不可列出的，成为回归问题，为连续型。

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))