机器学习：监督学习

线性回归

单变量底层 （数据集自备）

import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

#模型函数
def mode(theta):
    h=np.dot(xx,theta)
    return h

#代价函数
def cost(h):
    m=xx.shape[0]
    J=1/(2*m)*((h-y).T.dot(h-y))
    return J

#梯度下降
def GrandientDecline(xx,alpha,nums):
    m,n=xx.shape
    theta=np.zeros(n)
    J=np.zeros(nums)
    for i in range(nums):
        h=mode(theta)
        J[i]=cost(h)
        deltatheta=(1/m)*xx.T.dot(h-y)
        theta=theta-alpha*deltatheta

    return theta,h,J

if __name__ == '__main__':
    data = np.loadtxt(r'ex1data1.txt', delimiter=',')
    # print(data)
    x = data[:, :-1]
    y = data[:, -1]
    xx = np.c_[np.ones(len(x)), x]
    theta,h,J=GrandientDecline(xx,0.001,15000)
    plt.subplot(1,2,1)
    # plt.xlim(4.5,23)
    plt.scatter(x,y)
    plt.plot(x,h)
    plt.subplot(1,2,2)
    plt.plot(J)
    plt.show()

    print('最佳θ为：',theta)
    print('代价函数为：',J)
    print('模型函数为：',h)

多变量底层

import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

#模型函数
def mode(x,theta):
    h=np.dot(x,theta)
    return h

#代价函数
def cost(h,y):
    m=X.shape[0]
    J=1/(2*m)*((h-y).T.dot(h-y))
    return J

#梯度下降
def StandadFn(x,y):
    theta=np.dot(np.linalg.inv(x.T.dot(x)),x.T.dot(y))

    return theta

def suof(x):
    minX=np.min(x,axis=0)
    maxX=np.max(x,axis=0)
    X=(x-minX)/(maxX-minX)
    return X

if __name__ == '__main__':
    data=np.loadtxt(r'ex1data2.txt',delimiter=',')

    x=data[:,:-1]
    y=data[:,-1:]
    print('x=\n',x)
    print('y=\n',y)

    #特诊缩放
    #归一化缩放
    minX=np.min(x,axis=0)
    maxX=np.max(x,axis=0)
    X=(x-minX)/(maxX-minX)

    # #标准缩放
    # meanX=np.mean(x,axis=0)
    # sigmaX=np.std(x,axis=0,ddof=1)
    # x=(x-meanX)/sigmaX

    #数据拼接
    xx=np.c_[np.ones(len(x)),x]
    Y=np.c_[y]
    #训练集和测试集切分
    # m=len(x)
    # trainNum=int(m*0.7)
    # trainX=X[:trainNum,:]
    # testX=X[trainNum:,:]
    # trainY=y[:trainNum,:]
    # testY=y[trainNum:,:]

    theta = StandadFn(xx,y)
    H = mode(xx, theta)
    # print(len(H))
    # J = cost(H, y)
    # print(len(xx))

    plt.plot(Y, Y, c='b')  # 画数据真实值散点图
    plt.scatter(Y, H, c='r')  # 画线性模型
    plt.show()

简易导包实现 

from sklearn.datasets import load_boston
from sklearn.linear_model import LinearRegression
import numpy as np
'''
1.特征缩放
2.拼接数据集
3.数据切分
4.调库                             
4.1训练模型
5.输出精度，权重，截距，预测值
'''
def suof(x):
    minX=np.min(x,axis=0)
    maxX=np.max(x,axis=0)
    X=(x-minX)/(maxX-minX)
    return X

if __name__ == '__main__':
    data = load_boston()
    # data=np.array(data)
    # print(data)

    x = data.data
    y = data.target

    print(x)
    # print(y)
    m,n=x.shape
    XX=np.c_[np.ones(m),suof(x)]
    # train=int(len(x)*0.7)
    # trainX=x[:train,:]
    # trainY=y[:train]
    # testX=x[train:,:]
    # testY=y[train:]

    DATA=LinearRegression()
    DATA.fit(x, y)
    print('score=',DATA.score(x,y))
    print('权重为：',DATA.coef_)
    print('截距为：',DATA.intercept_)

多项式回归

import numpy as np
import matplotlib.pyplot as plt
from sklearn import  linear_model
from pylab import polyfit#polyfit--->#多项式拟合

plt.rcParams['font.sans-serif']=['SimHei'] #显示中文

x=[1.5,0.8,2.6,1.0,0.6,2.8,1.2,0.9,0.4,1.3,1.2,2.0,1.6,1.8,2.2]
y=[3.1,1.9,4.2,2.3,1.6,4.9,2.8,2.1,1.4,2.4,2.4,3.8,3.0,3.4,4.0]
x1=np.c_[x]
xx=np.c_[np.ones(len(x)),x]

'''调库应用'''
line=linear_model.LinearRegression()
line.fit(x1,y)

theta0=line.intercept_#偏执——θ0
print('theta0=',theta0)
theta1=line.coef_#截距θ1
print('theta1=',theta1)

plt.scatter(x,y,c='r',label='样本值')
plt.plot(x,line.predict(x1))#预测函数
score=line.score(x1,y)
print('精度=',score)
plt.show()

'''正规方程'''
theta3=np.linalg.inv(xx.T.dot(xx)).dot(xx.T).dot(y)
print('正规方程的θ值=',theta3)
#999
'''多项式回归'''
nihe=polyfit(x,y,deg=2)#函数拟合，输出的是θ值
print('nihe=',nihe)#得出的theta值
p=np.poly1d(nihe)#输入三个theta值，得到2项公式p=θ0*x**2+θ1*x+θ3
print('p(x)"--------\n',p(x)) #得到多项式回归公式p，将x一一带入公式里去求解。预测值

plt.figure('多项式回归求解')
plt.title('predicet-sample')
plt.scatter(x,y,c='g',label='样本值')
plt.scatter(x,p(x),c='r',label='预测值')
plt.legend(loc='best')
plt.show()

逻辑回归底层

import matplotlib.pyplot as plt
import  numpy as np#导包
import warnings
warnings.filterwarnings('ignore')

plt.rcParams['font.sans-serif']=['SimHei']

data=np.loadtxt('ex2data1.txt',delimiter=',')#加载数据

#切分数据
x=data[:,0:2]#取前两列特征
y=data[:,-1]#取最后一列标签

#特征缩放
meanx=np.mean(x,axis=0)#取每列均值
sigma=np.std(x,axis=0)#标准差
xx=(x-meanx)/sigma

#数据拼接
xxx=np.c_[np.ones(len(x)),xx]

#预测函数
def sigmoid(theta):
    z=xxx.dot(theta)
    h=1/(1+np.exp(-z))
    return h
#代价函数
def cost(h):
    J=-np.mean(y*np.log(h)+(1-y)*np.log(1-h))
    return J

#梯度下降函数

def Grad(nums,alpha):
    m,n=xxx.shape
    theta=np.zeros(n)
    #theta=np.zeros((n,1))
    J=np.zeros(nums)
    for i in range(nums):
        h=sigmoid(theta)
        J[i]=cost(h)
        delteatheta=(1/m)*xxx.T.dot(h-y)
        theta=theta-alpha*delteatheta
    return theta,J,h

#精度求解
def score(xxx,theta):
    m, n = xxx.shape
    # predict_y=[]
    count=0
    for i in range(m):
        h=sigmoid(theta)
        #predict_y.append(h)#m个预测值
        if(np.where(h[i]>0.5,1,0)==y[i]):
            count+=1

    accurancy=count/m
    return count,accurancy

# prd_y=np.where(h>=0.5,1,0)
# acc=np.where(np.equal(prd_y,text_y))
# print(acc)


if __name__ == '__main__':
    theta, J,h =Grad(10000,0.1)
    print(theta)

    plt.plot(J)
    plt.xlabel('迭代次数')
    plt.ylabel('代价值')
    plt.show()

    #plt.scatter(x[:,0],x[:,1])
    plt.scatter(xx[y==0,0],xx[y==0,1],c='b')
    plt.scatter(xx[y==1,0],xx[y==1,1],c='r')
    # plt.scatter(xx[y[:, -1] == 0, 0], xx[y[:, -1] == 0, 1], c='b')
    # plt.scatter(xx[y[:, -1] == 1, 0], xx[y[:, -1] == 1, 1], c='r')
    xx1min=xx[:,0].min()#取第一列特征的最小值
    xx1max=xx[:,0].max()#取第一列特征的最大值
    xx2min=-(theta[0]+theta[1]*xx1min)/theta[2]#xx1min最小值对应的最小值xx2min
    xx2max=-(theta[0]+theta[1]*xx1max)/theta[2]


    plt.plot([xx1min,xx1max],[xx2min,xx2max],c='k')
    plt.show()

    print('score=',score(xxx,theta))

    # x=np.array([30,43])
    # if 1/(1+np.exp(-(theta[0]+x[0]*theta[1]+x[1]*theta[2])))>0.5:
    #     print(1)
    # else:
    #     print(0)










# data=pd.read_csv('ex2data1.txt')

#
# #print(data)
#
# #分割数据
# x=data[:,0:2]
# y=data[:,-1]
# #x=data[:,:-1]
# #print(x)
# #特征缩放
# mu=np.mean(x,axis=0)#每一列的均值
# sigma=np.std(x,axis=0,ddof=1)#标准差
# x1=(x-mu)/sigma
#
# #初始化
# xx=np.c_[np.ones(len(x1)),x1]
#
# #模型函数
# def sigmoid(theta):
#     z=xx.dot(theta)
#     h=1/(1+np.exp(-z))
#     return h
#
# #代价函数
# def cost(h):
#     J=-np.mean(y*np.log(h)+(1-y)*np.log(1-h))
#     return J
#
# #梯度下降函数
# def grade(num,alpha):
#     m,n=xx.shape
#     theta=np.zeros(n)
#     J=np.zeros(num)
#     for i in range(num):
#         h=sigmoid(theta)
#         J[i]=cost(h)
#         deltatheta=(1/m)*xx.T.dot(h-y)
#         theta=theta-alpha*deltatheta
#
#     return h,J,theta
#
#  #''' 精度求解'''
# def scorelogisc(xx,theta):
#     m,n=xx.shape
#     predict_y=[]
#     count=0
#     for i in range(m):
#         h=sigmoid(theta)
#         predict_y.append(h)
#         if (np.where(h[i]>0.5,1,0)==(y[i])):
#             count+=1
#
#     accuracy=count/m
#     return  count,accuracy
#
#
#
#
#
# if __name__ == '__main__':
#     m=xx.shape[0]
#     h, J, theta=grade(20000,0.01)
#     print(theta)
#     count, accuracy=scorelogisc(xx,theta)
#     print('精准度=',accuracy)
#     print(count)
#     #精准度求解
#     s=np.where(abs(h-y)<0.5,1,0)
#     accuracy1=sum(s)/m
#     print('accuracy1=',accuracy1)
#
#
#
#
#
#     plt.figure()
#     plt.subplot(121)
#     plt.plot(J)
#
#     '''画边界图'''
#     plt.subplot(122)
#    # plt.scatter(x[:,0],x[:,1])
#     plt.scatter(x1[y==0,0],x1[y==0,1],c='g')#用特征缩放的数据x1
#     #plt.scatter(x1[:,0][y==0],x1[:,1][y==0],c='g')#用特征缩放的数据x1
#     plt.scatter(x1[y==1,0],x1[y==1,1],c='r')#用特征缩放的数据x1
#     x1min=x1[:,0].min()#第一个特征的最小值
#     x1max=x1[:,0].max()#第一个特征的最大值
#     x2min=-(theta[0]+theta[1]*x1min)/theta[2]#x1最新小值对应的x2最值
#     x2max=-(theta[0]+theta[1]*x1max)/theta[2]#x1最新大值对应的x2最值
#     plt.plot([x1min,x1max],[x2min,x2max],c='b')
#     plt.show()
#

正则

引入正则参数λ

单变量正则

import numpy as np
import matplotlib.pyplot as plt

#加载数据
data=np.loadtxt('ex1data1.txt',delimiter=',')
# print('data.shape=',data.shape)

#提取数据
x=data[:,0]
y=data[:,-1]

#特征缩放
mu=np.mean(x)
sigma=np.std(x,0,ddof=1)
x-=mu
X=x/sigma

#数据标准化
# print('X.shape=',X.shape)
m=X.shape[0]            #取样本数和特征数
X=np.c_[np.ones(m),X]
# y=np.c_[y]
# print('y.shape=',y.shape)

def cost(x,y,theta,lambd=0.1):
    m,f=x.shape
    h=np.dot(x,theta)
    R=lambd/(2*m)*np.dot(theta.T,theta)
    J=1/(2*m)*((h-y).T.dot(h-y))+R

    return J

def grand(x,y,alpha,nums,lambd=0.1):
    m,n=x.shape
    theta=np.zeros(n)
    J=np.zeros(nums)
    for i in range(nums):
        h=np.dot(x,theta)
        J[i]=cost(x,y,theta)
        deltatheta=1/m*x.T.dot(h-y)+lambd/m*theta
        theta-=alpha*deltatheta

    return theta,h,J

theta,h,J=grand(X,y,0.01,15000)
plt.plot(J)
plt.show()
plt.scatter(x,y)
plt.plot(x,h)
plt.show()

多变量正则

import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')



#代价函数
def cost(x,y,theta,lambd=0.1):
    m=x.shape[0]
    h = np.dot(x, theta)
    R=lambd/(2*m)*(theta.T.dot(theta))
    J=1/(2*m)*((h-y).T.dot(h-y))+R
    return J

#梯度下降
def Grand(x,y,alpha,nums,lambd=0.1):
    m, n = x.shape  # m是X的行数，n是列数
    theta = np.zeros(n)
    J = np.zeros(nums)  # 存储代价的数组

    for i in range(nums):
        H=np.dot(x,theta)
        # e=H-Y
        J[i] = cost(x, y,theta)  # 存储每一次迭代的代价
        deltatheta = 1.0 / m * x.T.dot(H - y)- lambd/m*theta # theta 的更新方向
        theta -= alpha * deltatheta  # 更新theta

    return J, theta, H


if __name__ == '__main__':
    data=np.loadtxt(r'ex1data2.txt',delimiter=',')

    x=data[:,:-1]
    y=data[:,-1]


    #特征缩放
    #归一化缩放
    minX=np.min(x,axis=0)
    maxX=np.max(x,axis=0)
    X=(x-minX)/(maxX-minX)

    # #标准缩放
    # meanX=np.mean(x,axis=0)
    # sigmaX=np.std(x,axis=0,ddof=1)
    # x=(x-meanX)/sigmaX

    #数据拼接
    xx=np.c_[np.ones(len(x)),X]

    #训练集和测试集切分
    # m=len(x)
    # trainNum=int(m*0.7)
    # trainX=X[:trainNum,:]
    # testX=X[trainNum:,:]
    # trainY=y[:trainNum,:]
    # testY=y[trainNum:,:]

    J, theta, H = Grand(xx,y,alpha=0.01,nums=15000)

    # print(len(H))
    # J = cost(H, y)
    # print(len(xx))

    plt.plot(y, y, c='b')  # 画数据真实值散点图
    plt.scatter(y, H, c='r')  # 画线性模型
    plt.show()

 逻辑回归正则

# 1.加载数据包
import numpy as np
import matplotlib.pyplot as plt
# 2.加载指定数据集
data=np.loadtxt(r'ex2data2.txt',delimiter=',')
# 2.1 数据预处理 洗牌 ，特征（标准差）， 拼接 数据分成训练，测试
x=data[:,:2]
y=data[:,2]


xmean=np.mean(x,axis=0)
xstd=np.std(x,axis=0)
x=(x-xmean)/xstd

np.random.seed(4)
m1=np.random.permutation(len(x))
x=x[m1]
y=y[m1]

x1=np.c_[np.ones(len(x)),x]
# print(x1)
# trainx=x1[:int(len(x)*0.7)]
# trainy=y[:int(len(x)*0.7)]
# testx=x1[int(len(x)*0.7):]
# testy=y[int(len(x)*0.7):]
m,n=x1.shape
# 3.写模型函数
def sigmoid(x,theta):
    z=x.dot(theta)
    h=1/(1+np.exp(-z))

    return h

# 4.写代价函数
def cost(x,y,theta,lamda=0.01):
    h=sigmoid(x,theta)
    # J=-(1/m)*(y*np.log(h)+(1-y)*np.log(1-h))
    R = lamda / (2 * m) * np.dot(theta.T, theta)
    J = -np.mean(y * np.log(h) + (1 - y) * np.log(1 - h))+R
    return J
# 5.写梯度下降
def grandDE(x,y,alpha,nums,lamda=0.01):
    theta=np.zeros(n)
    J=np.zeros(nums)
    for i in range(nums):
        h=sigmoid(x,theta)
        J[i]=cost(x,y,theta,lamda)
        deltatheta=1/m*x.T.dot(h-y)+lamda/m*theta
        theta=theta-alpha*deltatheta

    return theta,J,h
# 6.写精度函数
def score(x,y,theta):
    count=0
    for i in range(m):
        h=sigmoid(x,theta)
        if (np.where(h[i]>0.5,1,0)==y[i]):
            count+=1

    acc=count/m

    return f'精确度为{acc*100}％'
# 7.画出代价图，画出边界线
if __name__=='__main__':
    theta,J,h=grandDE(x1,y,0.01,100000)
    plt.subplot(121)
    plt.plot(J)
    plt.subplot(122)
    plt.scatter(x[y==0,0],x[y==0,1])
    plt.scatter(x[y==1,0],x[y==1,1])
    x1max=x[:,0].max()
    x1min=x[:,0].min()
    x2max=x[:,1].max()
    x2min=x[:,1].min()
    # x=(x1max+x1min)/2
    # y1=(x2min+x2max)/2
    # r=np.min([x-x1min,x1max-x,x2max-y1,y1-x2min])
    # circle = plt.Circle((x, y1), r-0.5, color='y', fill=False)
    # plt.gcf().gca().add_artist(circle)
    plt.plot([x1max,x2min],[x1min,x2max])
    plt.show()
    # print(x1.shape)
    # print(y.shape)
    print(score(x1,y,theta))
    print(theta)

神经网络

此处不对数学逻辑进行赘述，多隐藏层的单元数可自行设定

单隐藏层

import numpy as np
import matplotlib.pyplot as plt

#西瓜数据
X1 = [0.697,0.774,0.634,0.608,0.556,0.403,0.481,0.437,0.666,0.243,0.245,0.343,0.639,0.657,0.360,0.593,0.719]
X2 = [0.460,0.376,0.264,0.318,0.215,0.237,0.149,0.211,0.091,0.267,0.057,0.099,0.161,0.198,0.370,0.042,0.103]
Y =  [1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0]


#数据处理(1切分，2拼接，3特征缩放，4洗牌)
xx=np.c_[np.ones(len(X1)),X1,X2]
yy=np.c_[Y]
#洗牌
order=np.random.permutation(len(X1))
xx1=xx[order]
yy1=yy[order]

'''
1,加载数据
2，数据处理（1切分,2拼接,，3特征缩放，4洗牌，）
3，写激活函数-模型函数
4，前向传播
5，写代价函数
6，BP（反向传播）
7，梯度下降（迭代反复学习）
8.出结果
'''

#激活函数
def sigmoid(z,grid=False):

    if grid==True:
        return z*(1-z)

    return 1 / (1 + np.exp(-z))

#前向传播
def FP(a1,theta1,theta2):
    #第一层
    z2=a1.dot(theta1)
    a2=sigmoid(z2)

    #第二层
    z3=a2.dot(theta2)
    a3=sigmoid(z3)

    return a2,a3

#代价函数
def cost(a3,y):
    J=-np.mean(y*np.log(a3)+(1-y)*np.log(1-a3))

    return J

#反向传播
def BP(a3,a2,a1,y,theta2,theta1,alpha):
    sigma3=(a3-y)/len(a1)
    sigma2=sigma3.dot(theta2.T)*sigmoid(a2,True)

    deltatheta2=a2.T.dot(sigma3)
    deltatheta1=a1.T.dot(sigma2)

    theta2=theta2-alpha*deltatheta2
    theta1=theta1-alpha*deltatheta1

    return theta1,theta2

#梯度下降
def grand(a1,y,alpha,nums,k):
    m,n=a1.shape
    J=np.zeros(nums)
    # theta1=np.zeros((n,k))
    # theta2=np.zeros((k,1))
    np.random.seed(0)
    theta1=2*np.random.rand(n,k)-1
    theta2=2*np.random.rand(k,1)-1
    for i in range(nums):
        a2,a3=FP(a1,theta1,theta2)
        J[i]=cost(a3,y)
        theta1, theta2=BP(a3,a2,a1,y,theta2,theta1,alpha)

    return theta1,theta2,J,a3

def score(a3,y):
    count=0
    m,n=a3.shape
    for i in range(m):
        if np.where(a3[i]>0.5,1,0)==y[i]:
            count+=1
    return count/m

theta1,theta2,J,a3=grand(xx1,yy1,0.03,50000,60)
plt.plot(J)
plt.show()
print(score(a3,yy1))

多隐藏层

import numpy as np
import matplotlib.pyplot as plt

#西瓜数据
X1 = [0.697,0.774,0.634,0.608,0.556,0.403,0.481,0.437,0.666,0.243,0.245,0.343,0.639,0.657,0.360,0.593,0.719]
X2 = [0.460,0.376,0.264,0.318,0.215,0.237,0.149,0.211,0.091,0.267,0.057,0.099,0.161,0.198,0.370,0.042,0.103]
Y =  [1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0]


#数据处理(1切分，2拼接，3特征缩放，4洗牌)
xx=np.c_[np.ones(len(X1)),X1,X2]
yy=np.c_[Y]
#洗牌
order=np.random.permutation(len(X1))
xx1=xx[order]
yy1=yy[order]

'''
1,加载数据
2，数据处理（1切分,2拼接,，3特征缩放，4洗牌，）
3，写激活函数-模型函数
4，前向传播
5，写代价函数
6，BP（反向传播）
7，梯度下降（迭代反复学习）
8.出结果
'''

#激活函数
def sigmoid(z,grid=False):

    if grid==True:
        return z*(1-z)

    return 1 / (1 + np.exp(-z))

#前向传播
def FP(a1,theta1,theta2,theta3,theta4):
    #第一层
    z2=a1.dot(theta1)
    a2=sigmoid(z2)

    #第二层
    z3=a2.dot(theta2)
    a3=sigmoid(z3)

    #第三层
    z4=a3.dot(theta3)
    a4=sigmoid(z4)

    #第四层
    z5=a4.dot(theta4)
    a5=sigmoid(z5)

    return a2,a3,a4,a5

#代价函数
def cost(a5,y):
    J=-np.mean(y*np.log(a5)+(1-y)*np.log(1-a5))

    return J

#反向传播
def BP(a5,a4,a3,a2,a1,y,theta4,theta3,theta2,theta1,alpha):
    sigma5=(a5-y)/len(a1)
    sigma4=sigma5.dot(theta4.T)*sigmoid(a4,True)
    sigma3=sigma4.dot(theta3.T)*sigmoid(a3,True)
    sigma2=sigma3.dot(theta2.T)*sigmoid(a2,True)


    deltatheta4 = a4.T.dot(sigma5)
    deltatheta3 = a3.T.dot(sigma4)
    deltatheta2=a2.T.dot(sigma3)
    deltatheta1=a1.T.dot(sigma2)

    theta4 = theta4 - alpha * deltatheta4
    theta3 = theta3 - alpha * deltatheta3
    theta2=theta2-alpha*deltatheta2
    theta1=theta1-alpha*deltatheta1

    return theta1,theta2,theta3,theta4

#梯度下降
def grand(a1,y,alpha,nums):
    m,n=a1.shape
    J=np.zeros(nums)
    theta1=np.zeros((n,4))
    theta2=np.zeros((4,4))
    theta3=np.zeros((4,3))
    theta4=np.zeros((3,1))
    for i in range(nums):
        a2,a3,a4,a5=FP(a1,theta1,theta2,theta3,theta4)
        J[i]=cost(a5,y)
        theta1,theta2,theta3,theta4=BP(a5,a4,a3,a2,a1,y,theta4,theta3,theta2,theta1,alpha)

    return theta1,theta2,theta3,theta4,J,a5

def score(x,y,a5):
    count=0
    for i in range(len(x)):
        if np.where(a5[i]>0.5,1,0)==y[i]:
            count+=1

    acc=count/len(x)
    return f'准确率为{acc*100}％'

theta1,theta2,theta3,theta4,J,a5=grand(xx1,yy1,0.01,100000)
plt.plot(J)
plt.show()
print(score(xx1,yy1,a5))

 简易导包实现

import numpy as np
from sklearn.neural_network import MLPClassifier
from sklearn.linear_model import LinearRegression,LogisticRegression

#西瓜数据
X1 = [0.697,0.774,0.634,0.608,0.556,0.403,0.481,0.437,0.666,0.243,0.245,0.343,0.639,0.657,0.360,0.593,0.719]
X2 = [0.460,0.376,0.264,0.318,0.215,0.237,0.149,0.211,0.091,0.267,0.057,0.099,0.161,0.198,0.370,0.042,0.103]
Y =  [1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0]


#数据处理(1切分，2拼接，3特征缩放，4洗牌)
xx=np.c_[np.ones(len(X1)),X1,X2]
yy=np.c_[Y]
#洗牌
order=np.random.permutation(len(X1))
xx1=xx[order]
yy1=yy[order]

CLF=MLPClassifier()
CLF.fit(xx1,yy1)
CLF.predict(xx1)
print('精度acc=',CLF.score(xx1,yy1))
print('预测h=',CLF.predict(xx1))
print('实际Y=',np.hstack(yy1))

支持向量机

import numpy as np
import matplotlib.pyplot as plt
import sklearn.datasets as dts
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
import warnings
warnings.filterwarnings(('ignore'))

#导入数据(鸢尾花数据集)
data=dts.load_iris()
# print(data)
X=data['data']
Y=data['target']
# print(X.shape)
# print(Y.shape)
x1=X[Y!=0,1:3]
y1=Y[Y!=0]
#特征缩放
xmean=np.mean(x1,axis=0)
xsg=np.std(x1,axis=0)
x2=(x1-xmean)/xsg

#切分数据集，洗牌
trainx,testx,trainy,testy=train_test_split(x2,y1,train_size=0.7,shuffle=True)
# print(trainx.shape)
# print(testx.shape)

model=SVC(C=3)#创建对象
pG=0.5
model.fit(trainx,trainy)#模型创建
print('精度=',model.score(testx, testy))
testh=model.predict(testx)
print('testh=\n',testh)
print('testy=\n',testy)
print('==================================================')
print('支持向量的个数=\n',model.n_support_)
print('支持向量的索引位置=\n',model.support_)

#画图，图片格式化
#c=y1自动将不同类标以不同颜色
# model.support_vectors_用于将向量从数据中挑选出来
s=model.support_vectors_
#c=Y按类别自动给颜色，cmap=plt.cm.Paired自动匹配一对颜色，
# edgecolors='k'点的边线颜色，zorder=4,让点在面的上面
#facecolors='none'让样本点的面的颜色是透明的
plt.scatter(x2[:,0],x2[:,1],c=y1,edgecolors='y',s=30,zorder=4)
plt.scatter(s[:,0],s[:,1],c='b',edgecolors='y',s=50,facecolors='none',zorder=4)

#获取网格最大值最小值
minx1,maxx1,minx2,maxx2=min(x2[:,0]),max(x2[:,0]),min(x2[:,1]),max(x2[:,1])
#对数据进行切分后，生成二维数据点
gri_XX,gri_YY=np.mgrid[minx1:maxx1:200j,minx2:maxx2:200j]
#复数200J代表取200个点

#计算格网点到超平面的距离
z=model.decision_function(np.c_[gri_XX.ravel(),gri_YY.ravel()])#4万行
#将Z整形成XX矩阵
z=z.reshape(gri_XX.shape)##1维转换成2维
print(z.shape)
#画分界面，参数说明：xx和yy表示x轴方向的二维数据，yy表示y轴的二维方向的数据，Z表示颜色对应的标签值， cmap表示颜色板
plt.contourf(gri_XX,gri_YY,z>0,cmap='Accent')#xx,YY是z的坐标值---plt.contourf用来画出不同分类的边界线
#画分界线（等高线）
plt.contour(gri_XX,gri_YY,z,levels=[-1,0,1],linestyles=['--','-','--'],colors=['r','k','b'])
#levels=代表等高线的距离
#plt.title('C=%.1f,gamma=%.1f,方差=%.2f,精度=%.2f'%(pC,pG,np.var(testH),score))
plt.show()