readme

基于神经网络的学习

神经网络性质主要取决于网络拓扑结构，网络权值，工作规划。神经网络的学习是网络的权值调整问题，连接权值有两种方式

• 通过设计算法确定
• 网络按照一定规划得到（反向传播算法，HopFiled算法）

反向传播算法

由两次通过网络不同层的传播组成，一次前向传播，一次反向传播。

在前向传播中，一个活动模式作用于网络感知点，它的影响通过网络一层接一层地传播，最后产生一个输出作为网络的实际响应。（网络突触全被固定）

在反向传播中，突触权值全部根据突触修正规则来调整，特别是网络的目标响应，减去实际响应而产生的误差信号（这个误差信号，反向传播通过网络，与突触连接方向相反，因此叫误差反向传播，突触权值被调整使得网络的实际响应从统计意义上接近目标响应）

K-means

基本概念

K-means（K均值）是基于数据划分的无监督聚类算法。聚类算法可以理解为无监督的分类方法，即样本集预先不知所属的类别或标签，需要根据样本之间的距离或相似程度进行自动分类。

算法步骤

1. 初始化聚类中心，可选取样本集的前k个样本或随机选取k个样本
2. 分配各样本Xj到相近的聚类集合
3. 根据步骤2的结果，更新聚类中心
4. 若迭代达到最大迭代步数或前后两次迭代的差小于设定阈值，则算法结束。

K-means聚类算法中的步骤2和步骤分别对样本集合进行重新分配和更新计算聚类中心 ，通过迭代计算过程优化目标函数，实现类内误差平方和最小。

基于K-means图像分割

https://docs.opencv.org/3.4/d1/d5c/tutorial_py_kmeans_opencv.html

def kmeans_cluster():
    img = cv2.imread("c1.jpg")

    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

    # 更改图片维度以适用kmeans输入
    pixel_vals = img.reshape((-1,3))
    pixel_vals = np.float32(pixel_vals)

    # 停止准则是90%
    criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100, 0.9)
 
    k = 5
    retval, labels, centers = cv2.kmeans(pixel_vals, k, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS)
    
    centers = np.uint8(centers)
    segmented_data = centers[labels.flatten()]
    segmented_img = segmented_data.reshape((img.shape))

    
    plt.rcParams["figure.figsize"] = (15,5)
    fig,axs = plt.subplots(1,2)
    axs[0].imshow(img)
    axs[1].imshow(segmented_img)
    
    plt.show()

基于K-means字典学习

• https://github.com/danyow-cheung/text-cluster/blob/main/text_cluster.ipynb
• https://scikit-learn.org/stable/auto_examples/text/plot_document_clustering.html

需要预先了解一些自然语言处理的基础

import gensim
from sklearn.cluster import KMeans
from collections import Counter
from sklearn import metrics
import os
import matplotlib.pyplot as plt
import re 
import pandas as pd 

df = pd.read_csv("train.csv")
df.head()
from sklearn.feature_extraction.text import  TfidfVectorizer
from sklearn.cluster import KMeans
documents = df['description_x'].values.astype("U")
vectorizer = TfidfVectorizer(stop_words='english')
features = vectorizer.fit_transform(documents)

k =20 
model = KMeans(n_clusters=k,init='k-means++',max_iter=100,n_init=1)
model.fit(features)
df['same_security'] = model.labels_
df.head()

clusters = df.groupby("same_security")

for cluster in clusters.groups:
    data = clusters.get_group(cluster)[['description_x','same_security']]
    print(data)

order_centroids = model.cluster_centers_.argsort()[:,::-1]
terms = vectorizer.get_feature_names()

for i in range(k):
    print('cluster %d'%i)
    for j in order_centroids[i,:3]:
        print('%s'%terms[j])
    print("---")
k

KNN

基本概念

输入没有标签即未经分类的新数据，首先提取新数据的特征并与测试集中的每一个数据特征进行比较，然后从样本中提取k个最邻近（最相似）数据特征的分类标签，统计这k个最邻近数据中出现次数最多的分类，将其作为新数据的类别。

分类&回归

• 分类
  在样本数有限的情况下，KNN误判概率和距离的具体测度有直接关系，因为在选择最近样本数时利用适当的距离函数，可以提高分类的正确率。通常KNN有

  • Euclidean距离
  • Manhattan距离
  • Mahalanobis距离

  区别：https://blog.csdn.net/weixin_41620451/article/details/105918973

• 回归
  得到待处理数据的k个最相似训练数据后，求取这些训练数据属性的平均值，并将该平均值作为待处理数据的属性值，这一求取待处理数据属性的过程称为KNN学习中的回归。
  
  进一步，根据每一个最相似训练数据和待处理数据间的实际距离，赋予每一个最相似训练数据不同的权值，然后再进行加权平均，这样得到的回归更为有效。

基于KNN的人脸分类

实现步骤

1. 描述训练人脸特征向量
2. 确定新人脸的向量表示
3. 在训练人脸集中选出与新人脸最相似的k个人脸
4. 在新人脸的k个最相似的人脸中，依次计算每类的权重
5. 比较类的权重，将新人脸分到权重最大的那个类型

'''
基于KNN的人脸分类
分为三个实现功能
1. facedetect()检测人脸
2. npwriter()写入人脸特征向量
3. recog()识别
'''
import numpy as np 
import cv2 
import pandas as pd 
import os 

def facedetect():
    name = input('请输入名字')
    
    cap = cv2.VideoCapture(0)
    classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
    f_lst= []
    while True:
        ret,frame = cap.read()
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

        faces = classifier.detectMultiScale(gray,1.5,5)

        faces = sorted(faces,key=lambda x:x[2]*x[3],reverse=True)

        faces = faces[:1]
        if len(faces)==1:
            face = faces[0]
            x,y,w,h = face 
            im_face = frame[y:y+h,x:x+w]
            cv2.imshow('face',im_face)

        if not ret:
            continue
        cv2.imshow('full',frame)

        key = cv2.waitKey(1)
        if key==27:
            break
        elif key &0xFF ==ord('c'):
            if len(faces)==1:
                gray_face = cv2.cvtColor(im_face, cv2.COLOR_BGR2GRAY)
                gray_face = cv2.resize(gray_face,(100,100))
                print(len(f_lst),type(gray_face),gray_face.shape)
                f_lst.append(gray_face.reshape(-1))

            else:
                print("face not found")

            if len(f_lst)==10:
                break 
    
    # add
    npwriter(name,np.array(f_lst))
    cap.release()
    cv2.destroyAllWindows()

def npwriter(name,data):
    f_name = 'face_data.csv'
    if os.path.isfile(f_name):
        df = pd.read_csv(f_name,index_col=0)
        latest = pd.DataFrame(data,columns=map(str,range(10000)))
        latest['name'] = name 
        df = pd.concate((df,latest),ignore_index=True,sort = False)
    else:
        df = pd.DataFrame(data,columns=map(str,range(10000)))
        df['name'] = name 
    df.to_csv(f_name)

def recog():
    # main key 
    from sklearn.neighbors import KNeighborsClassifier
    data = pd.read_csv(f_name).values 
    X,Y = data[:,1:-1],data[:,-1]
    print(X,Y)
    model = KNeighborsClassifier(n_neighbors=5)
    model.fit(X,Y)
    cap = cv2.VideoCapture(0)
    classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
    f_lst = []
    while True:
        ret,frame = cap.read()
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        faces = classifier.detectMultiScale(gray,1.5,3)
        x_test =[]
        for face in faces:
            x,y,w,h = face 
            im_face = gray[y:y+h,x:x+w]
            im_face = cv2.resize(im_face,(100,100))
            x_test.append(im_face.reshape(-1))

        if len(faces)>0:
            response = model.predict(np.array(x_test))
            for i,face in enumerate(faces):
                x,y,w,h = face 
                cv2.rectangle(frame, (x,y), (x+w,y+h), (255,0,0),3)
                cv2.putText(frame, response[i], (x-50,y-50), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0),3)
        cv2.imshow('full', frame)
        key = cv2.waitKey(1)
        if key==27:
            break
    cap.release()
    cv2.destroyAllWindows()

if __name__ =='__main__':
    facedetect()
    print('ok')
    recog()

回归

基本概念

回归学习（又称为回归分析）是一种近似方法，从未知概率分布的随机样本中获得目标函数。
变量间的相互关系分为确定性和非确定的。

• 确定性：向量之间有明确的函数关系
• 不确定性：存在关系但不完全确定

回归学习：在存在统计关系变量，通过大量实验获得相关统计数据，并构造目标函数逼近该关系。

参数回归：随机变量间相关函数已知，但相关参数具体数据不详，根据样本值估计这些参数，叫做参数回归

基于回归学习的直线边缘提取

'''
基于回归学习的直线边缘提取
https://www.geeksforgeeks.org/line-detection-python-opencv-houghline-method/
'''
import cv2 
import numpy as np 
import matplotlib.pyplot as plt 

def line_detection():

    img = cv2.imread("road-line-detection-0.jpeg")
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    edges = cv2.Canny(gray, 50, 150)

    line_lst = []
    line_lst_x = []
    line_lst_y = [] 
    lines = cv2.HoughLinesP(
        edges, 
        1, 
        np.pi/180, 
        threshold=100,
        minLineLength=5,
        maxLineGap=10)

    for points in lines:
        x1,y1,x2,y2 = points[0]

        line_lst_x.append([x1,y1])
        line_lst_y.append([x2,y2])
        
        line_lst.append([(x1,y1),(x2,y2)])
        cv2.line(img,(x1,y1),(x2,y2),(0,255,0),2)
        # 存入的是起始像素点和终止像素点
        # line_lst.append([(x1,y1),(x2,y2)])

    

    plt.imshow(img)
    plt.show()
    return line_lst_x,line_lst_y

def regression():
    img = cv2.imread("road-line-detection-0.jpeg")
    '''https://blog.csdn.net/myf_666/article/details/119901115'''
    from sklearn.linear_model import LinearRegression

    line_lst_x,line_lst_y = line_detection()
    line_lst_x = np.array(line_lst_x)
    line_lst_y = np.array(line_lst_y)
    
    reg = LinearRegression()
    model = reg.fit(line_lst_x,line_lst_y)
    # print(line_lst_x)

    predictions = model.predict(line_lst_x)
    # 展示拟合之后的回归方程曲线,蓝色曲线
    plt.plot(line_lst_x,predictions,color = 'blue')
    # 加入原始数据的散点图，红色曲线
    plt.scatter(line_lst_x, line_lst_y,color = 'red')
    
    plt.show()
    
    line_lst_x = np.array(line_lst_x,dtype=np.int8)
    predictions = np.array(predictions,dtype=np.int8)
    
    for i,j in zip(line_lst_x,predictions):
        print(i,j)
        cv2.line(img,i,j,(0,255,0),2)
    plt.imshow(img)
    plt.show()

if __name__ =='__main__':
    regression()

基于回归学习的图像插值

引用

《视觉机器学习20讲》