机器学习算法,单变量线性回归、多变量线性回归

2021/11/12 22:12:31

本文主要是介绍机器学习算法,单变量线性回归、多变量线性回归,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

机器学习
机器学习分为监督学习和无监督学习,监督学习为有标签,无监督学习无标签。监督学习分为分类和回归,而无监督学习包括聚类和降维。分类是预测的结果可列出,成为分类问题,为离散型;回归预测的结果是不可列出的,成为回归问题,为连续型。
在这里插入图片描述

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


这篇关于机器学习算法,单变量线性回归、多变量线性回归的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程