华科自动化模式识别大作业

已于 2022-09-13 10:40:31 修改
阅读量559 收藏 6
点赞数
文章标签： python 机器学习
于 2022-09-12 18:26:29 首次发布
原文链接：https://blog.csdn.net/weixin_47336144/article/details/122539106
版权

华科（狗都不读）自动化模式识别作业

 

Draw.py

import matplotlib.pyplot as plt
import numpy as np
import pylab as pl


def huatu1(x, y, w):
    xc1 = []
    yc1 = []
    xc2 = []
    yc2 = []
    x_num = x.shape[0]
    for i in range(x_num):
        if (y[i] == 1):
            xc1.append(x[i, 0])
            yc1.append(x[i, 1])
        else:
            xc2.append(x[i, 0])
            yc2.append(x[i, 1])
    plt.figure()
    plt.scatter(xc1, yc1, s=40, c='red', marker='o')
    plt.scatter(xc2, yc2, s=40, c='blue')
    plt.xlabel('x1')
    plt.ylabel('x2')
    # 绘制分类线
    x = np.arange(-10.0, 5.0, 0.1)
    y = (-w[0] - w[1] * x) / w[2]
    plt.plot(x, y)
    plt.savefig('xunlian.png', dpi=75)
    plt.show()


def huatu2(x, y, w):
    xc1 = []
    yc1 = []
    xc2 = []
    yc2 = []
    x_num = x.shape[0]
    for i in range(x_num):
        if (y[i] == 1):
            xc1.append(x[i, 0])
            yc1.append(x[i, 1])
        else:
            xc2.append(x[i, 0])
            yc2.append(x[i, 1])
    plt.figure()
    plt.scatter(xc1, yc1, s=40, c='red', marker='x')
    plt.scatter(xc2, yc2, s=40, c='blue', marker='x')
    plt.xlabel('x1')
    plt.ylabel('x2')
    # 绘制分类线
    x = np.arange(-10.0, 5.0, 0.1)
    y = (-w[0] - w[1] * x) / w[2]
    plt.plot(x, y)
    plt.savefig('ceshi.png', dpi=75)
    plt.show()

Data.py

import math
import numpy as np
import random
import pylab as pl
def shuju1(num):
    m1 = np.array([-5, 0])
    s1 = np.array([[1, 0], [0, 1]])
    m2 = np.array([0, 5])
    s2 = np.array([[1, 0], [0, 1]])
    X1 = np.empty((num, 2))
    X2 = np.empty((num, 2))
    y1 = np.ones((1, num))
    y2 = -np.ones((1, num))
    for i in range(num):
        X1[i] = np.random.multivariate_normal(m1, s1)
        X2[i] = np.random.multivariate_normal(m2, s2)
    X = np.append(X1, X2, axis=0)
    y0 = np.append(y1, y2)
    x = np.zeros([int(num * 0.8 * 2), 2])
    y = np.zeros(int(num * 0.8 * 2))
    x_test = np.zeros([num * 2 - int(num * 0.8 * 2), 2])
    y_test = np.zeros(num * 2 - int(num * 0.8 * 2))
    st = np.random.get_state()
    np.random.shuffle(X)
    np.random.set_state(st)
    np.random.shuffle(y0)
    for i in range(num * 2):
        if i < num * 0.8 * 2:
            x[i] = X[i]
            y[i] = y0[i]
        else:
            x_test[i - int(num * 0.8 * 2)] = X[i]
            y_test[i - int(num * 0.8 * 2)] = y0[i]
    return x, y, x_test, y_test


def shuju2(num):
    m1 = np.array([1, 0])
    s1 = np.array([[1, 0], [0, 1]])
    m2 = np.array([0, 1])
    s2 = np.array([[1, 0], [0, 1]])
    X1 = np.empty((num, 2))
    X2 = np.empty((num, 2))
    y1 = np.ones((1, num))
    y2 = -np.ones((1, num))
    for i in range(num):
        X1[i] = np.random.multivariate_normal(m1, s1)
        X2[i] = np.random.multivariate_normal(m2, s2)
    X = np.append(X1, X2, axis=0)
    y0 = np.append(y1, y2)
    x = np.zeros([int(num * 0.8 * 2), 2])
    y = np.zeros(int(num * 0.8 * 2))
    x_test = np.zeros([num * 2 - int(num * 0.8 * 2), 2])
    y_test = np.zeros(num * 2 - int(num * 0.8 * 2))
    st = np.random.get_state()
    np.random.shuffle(X)
    np.random.set_state(st)
    np.random.shuffle(y0)
    for i in range(num * 2):
        if i < num * 0.8 * 2:
            x[i] = X[i]
            y[i] = y0[i]
        else:
            x_test[i - int(num * 0.8 * 2)] = X[i]
            y_test[i - int(num * 0.8 * 2)] = y0[i]
    return x, y, x_test, y_test
if(__name__ == "__main__"):
    x,y,x_test,y_test = shuju1(10)
    print(x)
    print(y)

Fisher线性判别

import numpy as np
import Draw
import Data
def cheshi(w1,w2,W_,S):
    sum = 0
    for x1 in w1:
        if W_[0]*x1[0]+W_[1]*x1[1] < S:
            sum+=1
    for x2 in w2:
        if W_[0]*x2[0]+W_[1]*x2[1] > S:
            sum+=1

    return sum
def Fisher(w1,w2):
    E1 = np.empty((2,2))
    E2 = np.empty((2,2))
    e11,e12,e21,e22 = 0,0,0,0
    sum1 = 0
    sum2 = 0
    for w in w1:
        sum1 += w[0]
        sum2 += w[1]
    u1 = np.array([sum1/(len(w1)),sum2/(len(w1))])
    sum11 = 0
    sum22 = 0
    for w in w2:
        sum11 += w[0]
        sum22 += w[1]
    u2 = np.array([sum11 / (len(w2)), sum22 / (len(w2))])
    for w in w1:
        n = w - u1
        e11 += (n[0])**2
        e12 += n[0]*n[1]
        e22 += (n[1])**2
    E1[0][0],E1[0][1],E1[1][0],E1[1][1] = e11,e12,e12,e22
    e11,e12,e21,e22 = 0,0,0,0
    for w in w2:
        n = w-u2
        e11 += (n[0]) ** 2
        e12 += n[0] * n[1]
        e22 += (n[1]) ** 2
    E2[0][0],E2[0][1],E2[1][0],E2[1][1] = e11,e12,e12,e22
    E1 = E1+E2
    E_ = np.linalg.inv(E1)
    W_ = np.dot(E_,(u1-u2))#W*
    S = (np.dot(W_,(u1+u2))/2)#判别门限
    return W_,S
if __name__ =="__main__":
    #数据处理：（均值向量分别为[0,5][-5,0]）
    x, y, x_test, y_test = Data.shuju1(200)
    #（均值向量分别为[0,1][1,0]）
    # x, y, x_test, y_test = Data.shuju2(200)
    j,z=0,0
    for i in range(len(x)):
        if y[i]>0:
            j+=1
        else:
            z+=1
    w1 = np.empty((j,2))
    w2 = np.empty((z,2))
    j, z = 0, 0
    for i in range(len(x)):
        if y[i] > 0:
            w1[j] = x[i]
            j += 1
        else:
            w2[z] = x[i]
            z += 1
    j,z = 0,0
    for i in range(len(x_test)):
        if y_test[i]>0:
            j+=1
        else:
            z+=1
    w1_test = np.empty((j, 2))
    w2_test = np.empty((z, 2))
    j, z = 0, 0
    for i in range(len(x_test)):
        if y_test[i]>0:
            w1_test[j] = x_test[i]
            j+=1
        else:
            w2_test[z] = x_test[i]
            z+=1

    W_,S = Fisher(w1, w2)

    print(f"W_ = {W_}")
    print(f"S  = {S}")
    w = np.array([-S,W_[0],W_[1]])
    Draw.huatu1(x, y, w)
    print(f"训练集有{cheshi(w1, w2, W_, S)}个错误")
    print(f"测试集有{cheshi(w1_test, w2_test, W_, S)}个错误")

PLA算法

import numpy as np
import time
import Data
import Draw


# 1、导入数据集


# 训练感知机模型
class Perceptron:
    def __init__(self, x, y, a=1):
        self.x = x
        self.y = y
        self.w = np.zeros((x.shape[1], 1))  # 初始化权重，w1,w2均为0
        self.b = 0
        self.a = 0.1  # 学习率
        self.numsamples = self.x.shape[0]
        self.numfeatures = self.x.shape[1]

    def sign(self, w, b, x):
        y = np.dot(x, w) + b
        return int(y)

    def update(self, label_i, data_i):
        tmp = label_i * self.a * data_i
        tmp = tmp.reshape(self.w.shape)
        # 更新w和b
        self.w = tmp + self.w
        self.b = self.b + label_i * self.a

    def train(self):
        isFind = False
        num = 0
        while not isFind:
            count = 0
            for i in range(self.numsamples):
                tmpY = self.sign(self.w, self.b, self.x[i, :])
                if tmpY * self.y[i] <= 0:  # 如果是一个误分类实例点
                    count += 1
                    num += 1
                    self.update(self.y[i], self.x[i, :])
            if count == 0:
                print( '最终训练得到的w和b为：', self.w, self.b)
                isFind = True
        return self.w, self.b
def sign1(w, b, x):
    y = np.dot(x, w) + b
    return int(y)
def classify1(w, b,x,y):
    mistakes = 0
    for i in range(x.shape[0]):
        tmpY = sign1(w, b, x[i, :])
        if tmpY * y[i] <= 0:  # 如果是误分类
            mistakes += 1
    return mistakes
if __name__ == '__main__':
    x, y, x_test, y_test = Data.shuju1(200)
    myperceptron = Perceptron(x=x, y=y)
    start = time.time()
    w0, b = myperceptron.train()
    w = np.array([w0[0][0],w0[1][0]])
    costtime = time.time() - start
    w1 = np.array([b,w0[0][0],w0[1][0]])
    Draw.huatu1(x, y, w1)
    Draw.huatu2(x_test, y_test, w1)
    print(f"训练集有{classify1(w, b, x, y)}个错误")
    print(f"测试集有{classify1(w, b, x_test, y_test)}个错误")
    print("Time used:", costtime)

Pocket

import time

import numpy as np
import random
import Data
import Draw
# 感知机模型
class Pocket:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.w = np.zeros(x.shape[1])  # 初始化权重，w1,w2均为0
        self.best_w = np.zeros(x.shape[1])  # 最好
        self.b = 0
        self.best_b = 0

    def sign(self, w, b, x):
        y = np.dot(x, w) + b
        return int(y)

    def classify(self, w, b):
        mistakes = []
        for i in range(self.x.shape[0]):
            tmpY = self.sign(w, b, self.x[i, :])
            if tmpY * self.y[i] <= 0:  # 如果是误分类
                mistakes.append(i)
        return mistakes

    def update(self, label_i, data_i):
        tmp = label_i * data_i
        tmpw = tmp + self.w
        tmpb = self.b + label_i
        if (len(self.classify(self.best_w, self.best_b)) >= (len(self.classify(tmpw, tmpb)))):
            self.best_w = tmp + self.w
            self.best_b = self.b + label_i
        self.w = tmp + self.w
        self.b = self.b + label_i

    def train(self, max_iters):
        iters = 0
        isFind = False
        while not isFind:
            mistakes = self.classify(self.w, self.b)
            if (len(mistakes) == 0):
                return self.best_w, self.best_b
            n = mistakes[random.randint(0, len(mistakes) - 1)]
            self.update(self.y[n], self.x[n, :])
            iters += 1
            if iters == max_iters:
                isFind = True
        return self.best_w, self.best_b
def sign1(w, b, x):
    y = np.dot(x, w) + b
    return int(y)
def classify1(w, b,x,y):
    mistakes = 0
    for i in range(x.shape[0]):
        tmpY = sign1(w, b, x[i, :])
        if tmpY * y[i] <= 0:  # 如果是误分类
            mistakes += 1
    return mistakes
if __name__ == '__main__':
    # 编程题输出（均值向量分别为[0,5][-5,0]）
    x, y, x_test, y_test = Data.shuju1(200)
    # 编程题输出（均值向量分别为[0,1][1,0]）
    # x, y, x_test, y_test = Data.shuju2(200)

    myPocket_PLA = Pocket(x, y)
    time1 = time.time()
    w, b = myPocket_PLA.train(50)
    time2 = time.time()
    w1 = np.array([b, w[0], w[1]])
    # 计算测试时间
    time_ = time2 - time1
    print(f"所花时间时间为{time_}s")
    print(f"训练集有{classify1(w,b,x,y)}个错误")
    print(f"测试集有{classify1(w,b,x_test,y_test)}个错误")
    # 画出数据集与分类面
    Draw.huatu1(x, y, w1)
    Draw.huatu2(x_test, y_test, w1)

广义逆

import numpy as np
from 模式识别 import Draw
import Data
import Draw


def guangyini(x, y):
    x_num = x.shape[0]
    x_d = x.shape[1]
    w = np.zeros(x_d + 1)
    a = np.ones([x_num, 1])
    x = np.concatenate((a, x), 1)
    x_ = np.linalg.pinv(x)
    w = np.matmul(x_, y)
    return w
if(__name__ == "__main__"):
    #作业计算题
    # x,y =date()
    # w = guangyini(x,y)
    # Draw.huatu1(x, y, w)
    # print(w)
    # 编程题输出（均值向量分别为[0,5][-5,0]）
    x, y, x_test, y_test = Data.shuju1(200)
    # 编程题输出（均值向量分别为[0,1][1,0]）
    # x, y, x_test, y_test = Data.shuju2(200)
    w1 = guangyini(x, y)
    Draw.huatu1(x, y, w1)
    Draw.huatu2(x_test, y_test, w1)
    print(w1)

梯度下降

import numpy as np
import time
import Data
import Draw


def gardient_descent(x, y, t, u):
    x_num = x.shape[0]
    x_d = x.shape[1]
    w = np.zeros(x_d + 1)
    a = np.ones([x_num, 1])
    x = np.concatenate((a, x), 1)

    for i in range(t):
        L_G = np.zeros(x_d + 1)
        for j in range(x_num):
            L_G = L_G + (np.dot(w, x[j]) - y[j]) * x[j]
        w = w - u * L_G
        if (abs(L_G.any()) <= 1e-6):
            break
    return w
def sign1(w1, x):
    x = np.array([1,x[0],x[1]])
    y = np.dot(x, w1)

    return y
def classify1(w1,x,y):
    mistakes = 0
    for i in range(x.shape[0]):
        tmpY = sign1(w1, x[i, :])
        if tmpY * y[i] <= 0:  # 如果是误分类
            mistakes += 1
    return mistakes
# 编程题输出（均值向量分别为[0,5][-5,0]）
x, y, x_test, y_test = Data.shuju1(200)
# 编程题输出（均值向量分别为[0,1][1,0]）
# x, y, x_test, y_test = Data.shuju2(200)
Mepoch = 50
Lout = np.zeros(Mepoch)

for t in range(Mepoch):
    w1 = gardient_descent(x, y, t, 0.0001)

Draw.huatu1(x, y, w1)
Draw.huatu2(x_test, y_test, w1)
print(f"训练集有{classify1(w1,x,y)}个错误")
print(f"测试集有{classify1(w1,x_test,y_test)}个错误")

逻辑斯特

import math
import numpy as np
import time
import Data
import Draw


def luojisite(x, y, t, u):
    x_num = x.shape[0]
    x_d = x.shape[1]
    w = np.zeros(x_d + 1)
    a = np.ones([x_num, 1])
    x = np.concatenate((a, x), 1)

    for i in range(t):
        L_G = np.zeros(x_d + 1)
        for j in range(x_num):
            L_G = L_G + (-y[j]*x[j])/(1+math.exp(-np.dot(w, x[j])*y[j]))
        w = w - u * L_G / x_num
        if (abs(L_G.any()) <= 1e-6):
            break
    return w
def sign1(w1, x):
    x = np.array([1,x[0],x[1]])
    y = np.dot(x, w1)

    return y
def classify1(w1,x,y):
    mistakes = 0
    for i in range(x.shape[0]):
        tmpY = sign1(w1, x[i, :])
        if tmpY * y[i] <= 0:  # 如果是误分类
            mistakes += 1
    return mistakes
# 编程题输出（均值向量分别为[0,5][-5,0]）
x, y, x_test, y_test = Data.shuju1(200)
# 编程题输出（均值向量分别为[0,1][1,0]）
# x, y, x_test, y_test = Data.shuju2(200)
Mepoch = 50
Lout = np.zeros(Mepoch)

for t in range(Mepoch):
    w1 = luojisite(x, y, t, 0.0001)

Draw.huatu1(x, y, w1)
Draw.huatu2(x_test, y_test, w1)
print(f"训练集有{classify1(w1,x,y)}个错误")
print(f"测试集有{classify1(w1,x_test,y_test)}个错误")

部分来自网上各大大佬的代码，我只是做了整合，如有侵权请私聊，立刻删除

 

菜B阿康
关注
华中科技大学人工智能与自动化学院所有课程、实验报告与源码
04-21
笔者来自华中科技大学人工智能与自动化学院19级实验班，这份资料整合了AIA学院自大一到大四所有的课程报告与代码，其中绝大部分课程成绩90+，质量绝对保障。 总所周知A院有很多无关紧要的课设/实验，很多时候没有必要花很多精力浪费在这些不必要的内容上，笔者提供这份资源也是为了让更多人花更多时间在自己感兴趣的方向上，而不是浪费时间在自己不感兴趣的报告上。如果您觉得这个价格可以接受，可以直接在平台上购买，如果觉得价格欠妥，可以加我qq与我联系，我的qq号为：2675319752。 除了价格问题外，如果小伙伴们有任何问题或者对其中的报告/代码有什么疑问，欢迎与我沟通交流，这里再次声明一下我的qq为：2675319752。欢迎大家加我的qq号进行交流。
模式识别大作业（MATLAB版)
05-21
K-means聚类的MATLAB实现，GUI界面
【模式识别大作业】
vor234的博客
06-30 3907
一个完整的模式识别系统基本上是由三部分组成，即数据采集、数据处理和分类决策或模型匹配。在设计模式识别系统时，需要注意模式类的定义、应用场合、模式表示、特征提取和选择、聚类分析、分类器的设计和学习、训练和测试样本的选取、性能评价等。.........
模式识别大作业
11-14
这些代码是我精心组织，比较有代表意义的模式识别大作业，内容丰富，代码准确，有详细的注释，希望能够帮助到大家。
华科自动化保研真题及面经
09-17
华中科技大学自动化保研真题和面试经验
华中科技大自动化保研题和面试经验
06-29
【华中科技大学自动化保研题和面试经验】是关于...总的来说，【华科自动化保研真题及面经】这份资料对于有志于保研华中科技大学自动化专业的学生来说，是一份宝贵的参考资料，能够帮助他们有针对性地准备，提高成功率。
华科模式识别课件 李伟
06-25
华科 模式识别课件 任课老师：李伟
华科自动化学院考研c语言复试题目.rar
06-03
在准备华中科技大学人工智能与自动化学院的考研复试中，C语言是...对于给出的“华科自动化学院考研c语言复试题目”这个压缩包，考生应仔细研究其中的题目和源程序，从中学习解题思路和编程技巧，以提高自己的竞争力。
模式识别大作业程序
04-08
识别检测印刷电路板上圆形或方形焊盘上锡膏的边缘，要求：① 显示每个焊盘上锡膏图像的单像素边缘轮廓；② 精确求解每个焊盘上锡膏图像的几何中心，并显示中心坐标值。
模式识别大作业实验报告
06-12
通过摄像头捕捉公交车上的情况，经过计算机的图像处理，检测出公交车上座位有无乘客。
合工大通信研究生的模式识别大作业
11-19
自己做的模式识别大作业，里面有手写数字识别的最终的matlab代码，还布置的看吴恩达视频的作业，自己都写出来了，供大家使用
西交大模式识别编程大作业（报告+MATLAB源码）
07-15
这个资源为西安交通大学自动化专业模式分类选修课的编程大作业，matlab编写！
与大家分享华中科技大学模式识别课件-华中科技大学-模式识别.part01.rar
08-12
与大家分享华中科技大学模式识别课件-华中科技大学-模式识别.part01.rar 希望对大家有所帮助！
模式识别导论大作业(k均值算法，感知器算法，fisher算法，贝叶斯决策，特征提取)
热门推荐
喜爱兰兰
10-24 1万+
模式识别导论大作业(k均值算法，感知器算法，fisher算法，贝叶斯决策，特征提取)
模式识别大作业——PCA&Fisher&KNN&Kmeans
糕糕的博客
05-27 512
模式识别作业Kmeans&Fisher&PCA&KNN
模式识别作业
lee__7的博客
06-15 429
图像分类 数据集：CIFAR-10 分类器：KNN
matlab模式识别大作业_史上最萌最认真的机器学习/深度学习/模式识别入门指导手册(二)...
weixin_39603908的博客
12-04 561
谢谢你们。小夕昨晚又熬夜被发现了，谢谢对小夕的关心...有你们陪着，小夕很幸运。路人乙：“小夕，别人都说上完coursera上的那门机器学习课就已经入门机器学习了，可你又不这样认为。那你认为上完那门课，或者说学完上一篇的阶段一，处于什么水平呢？”小夕：“大忽悠水平。”前言2333，小夕没有开玩笑哦，coursera那门课是为了帮助大家从整体上了解一下机器学习大框架，并培养兴趣。而仅仅完...
华科药业企业管理信息化解决方案
本文档是北京英克科技有限公司为大庆华科股份有限公司的华科药业分公司提供的企业管理信息化解决方案建议书。该文档深入探讨了企业管理信息化的重要性和具体实施策略，旨在提升企业的运营效率和管理水平。 首先，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值