学习率，由学习者自行设置，根据经验设置，

学习率不同，对神经网络的训练影响很大。

感知器数据分类步骤：

1，初始化权重向量w

2，把样本输入感知器，得到分类结果

3，根据分类结果前向反馈更新权重

课程的内容

要构造的神经网络，图示

panda数据分析库
df = pd.read_csv(file , header = None)
df.head(10) 读取10行
df.loc[0:100 , 4].values 读取0到100行的第四列数据
iloc主要使用数字来索引数据，而不能使用字符型的标签来索引数据
而loc则刚好相反，只能使用字符型标签来索引数据，不能使用数字
来索引数据

plt.scatter绘制散点图
plt.scatter(X[:50 , 0] , X[:50 , 1] , color='red' , marker='o')
前50列数据，x轴为0列，y轴为1列数据,画出的点为红圈

 X:[   [1,2,3] , [4,5,6]   ]
 y:[        1    ,    -1       ]
 zip(X,y) = [[1,2,3, 1 ] , [4,5,6 , -1]]
 
 np.zero 向量全赋零操作
 np.dot(X , y)  点积  w_[1:]权重w从1到最后
 np.where(x>0 , true , false) 等价于冒号表达式

和方差求偏导

对人类智商和尊严进行全面的碾压...

感知器数据分类算法步骤

file=""
import pandas as pd
import matplotlib.pyplot  as plt
import numpy as np
df=pd.read_cvs(flie,header=none)//文件第一行即数据第一行

y=df.loc[0:100,4].values//读取数据，将0-100行数据的第四列，作为输出y（vector）
y=np.where(y=="",1,-1)//将输出字符串转化成数字
x=df.loc[0:100,[0,2]].values//第0列和第2列作为输入抽取出来

plt.scatter(x[:50,0],x[:50,1],color='red',marker='o',label="xxx")
plt.scatter(x[50:100,0],x[50:100,1],color='blue',marker='x',label="yyy")
plt.xlabel('lll')
plt.ylabel('mmm')
plt.legend(loc='upper left')//设置图例属性
plt.show()

阈值的更新

    阈值

        一开始是 根据我们的经验，设定一个值

        这个值再后续中要不断的更新。

        就是 w0 的更新。没有x0可以乘。

θ = -w0 

wo = w0 + dw0

dw0 = η * e(y)

权重更新算法：

wj = wj + dwj

dwj = η * （y - y^） * xj

       = η * e(y) * xj 

η：学习率，是[0, 1]间的一个小数。

    需要模型的设计者自己去设定。模型自己训练中不断地调整权重w的取值。然鹅，不同的学习率η，有可能会影响到最后的模型学习效果。

步调函数 & 阈值

z* = z - theta  (????)

z* ><  2* theta

感知器 数据分类算法 步骤：

1. 把权重向量w初始化为0（或[0, 1]间任意小数）；

2. 把训练样本输入感知器，得到分类结果（-1， 或1）；

3. 根据分类结果更新权重向量w 。

整个机器学习的目的，就是 通过输入的训练样本，反复去更新权重向量w，直到权重向量更新到一定程度之后，我们的整个模型才能有效地对未知输入做出有效的分类和预测。

import numpy as np
class Perceptron(object):
    """    
    eta:学习率    
    n_iter:权重向量的训练次数    
    w_:神经分叉权重向量    
    errors:用于记录神经元判断出错次数    
    """
    def __init__(self, eta, n_iter):        
        self.eta=eta        
        self.n_iter=n_iter        
        pass
    def net_input(self,X):            
        """            
        z = W0*1 + W1*X1 +.... Wn*Xn            
        """            
        return np.dot(X,self.w_[1:]) + self.w_[0]            
        pass
    
    def predict(self, X):        
        return np.where(self.net_input(X) >= 0.0 ,1, -1)        
        pass
    def fit(self,X,y):        
        """        
        输入训练数据，训练神经元，x输入样本向量，y对应样本的正确分类                
        X:shape[n_samples, n_features]        
        eg:X:[[1, 2, ,3],[4, 5, 6]]           
           n_samples: 2           
           n_features: 3                      
           y:[1, -1]        
        """        
        """        
        初始化权重向量为0        
        加一是因为前面算法提到的w0,也就是步调函数阈值        
        """        
        self.w_ = np.zeros(1+X.shape[1])        
        self.errors_ =[]                
        
        for _ in range(self.n_iter):            
            errors = 0            
            """            
            X:[[1,2,3],[4,5,6]]            
            y:[1, -1]            
            zip(X,y)=[[1,2,3, 1],[4,5,6, -1]]            
            """            
            for xi, target in zip(X,y):                 
                """                
                update = 学习率 * （y-y'）                
                """                
                update = self.eta * (target - self.predict(xi))                
                """                
                xi 是一个向量                
                update * xi 等价：                
                [更新w(1) = X[1]*update, 更新w(2) = X[2]*update,更新w(3) = X[3]*update,]                
                """                
                self.w_[1:]+=update * xi                
                self.w_[0] += update                                
                errors += int(update != 0.0)                
                self.errors_.append(errors)                
                pass                        
            pass   
    pass


file = "D:/PyCharm_test_file/Jupyter_test/iris1.xlsx"
import pandas as pd

df = pd.read_excel(file,header=None)
#df.head(10)
#print(df)  


import matplotlib.pyplot as plt
import numpy as npy = df.loc[0:99, 4].values
y = np.where(y == 'Iris-setosa', -1, 1)
#print(y)
X = df.iloc[0:100, [0, 2]].values
#print(X)
plt.scatter(X[:50, 0], X[:50, 1], color='red', marker='o', label='setosa')
plt.scatter(X[50:100, 0], X[50:100, 1], color='blue', marker='x', label='vericolor')
plt.rcParams['font.sans-serif']=['SimHei']
plt.xlabel('花瓣长度')
plt.ylabel('花茎长度')
plt.legend(loc='upper left')
plt.show()  



from matplotlib.colors import ListedColormap
def plot_decision_regions(X, y, classifier, resolution=0.02):    
    marker = ('s', 'x', 'o', 'v')    
    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')    
    cmap = ListedColormap(colors[:len(np.unique(y))])    
    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max()    
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max()    
    #将x1、x2最大最小值通过arange函数得到的向量，扩展成两个二维矩阵    
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution), np.arange(x2_min, x2_max, resolution))    
    #预测    
    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T) #ravel还原成单维向量    
    #绘制    
    Z= Z.reshape(xx1.shape) #将Z转换成与xx1一样的二维数组    
    plt.contourf(xx1, xx2, Z, alpha=0.4, cmap=cmap) #在两组分类结果中间画分割线-->必须线性可分    
    plt.xlim(xx1.min(), xx1.max())    
    plt.ylim(xx2.min(), xx2.max())    
    for idx, cl in enumerate(np.unique(y)):        
        plt.scatter(x=X[y==cl, 0], y=X[y==cl, 1], alpha=0.8, c=cmap(idx), marker=marker[idx], label=cl)
        
        
ppn = Perceptron(0.1, 10)
ppn.fit(X, y)
plot_decision_regions(X, y, ppn, resolution=0.02)