人工智能与机器学习原理精解【1】

未来之蓝

已于 2024-07-07 18:50:08 修改

阅读量1.5k

点赞数 34

分类专栏：数学与应用数学文章标签：神经网络人工智能深度学习

于 2024-07-01 18:38:41 首次发布

本文链接：https://blog.csdn.net/sakura_sea/article/details/139902396

版权

数学与应用数学专栏收录该内容

31 篇文章 0 订阅

订阅专栏

文章目录

Rosenblatt感知器
- 感知器基础
- 收敛算法
- - 算法概述
  - 算法步骤
  - 关键点说明
  - 总结
- C++实现
- - 要点
  - 代码
参考文献

Rosenblatt感知器

感知器基础

感知器，也可翻译为感知机，是一种人工神经网络。它可以被视为一种最简单形式的前馈式人工神经网络，是一种二元线性分类器。
Rosenblatt感知器建立在一个非线性神经元上，但是它只能完成线性分类
硬限幅与超平面
$\\v=\sum_{i=1}^mw_ix_i+b \\从上面公式看来，只能完成线性分类 \\完成线性分类靠最后的输出，就是硬限幅的功能了 \\输入为正数，输出+1，否则输出-1。 \\如果 v>0 输出 +1，否则输出-1。 \\v=0就是一个超平面，线性分隔两类（也叫两个决策区域）$
为什么Rosenblatt感知器是非线性神经元，因为硬限幅的存在。

收敛算法

下面内容来自文心一言的自动生成内容

Rosenblatt的收敛算法，也被称为感知器收敛算法或Rosenblatt误差修正训练规则，是一种用于训练单层感知机的算法。该算法由Frank
Rosenblatt在1957年提出，主要用于解决二分类问题。以下是对该算法的详细解释：

算法概述

Rosenblatt的收敛算法是一个迭代过程，通过不断调整感知机的权重和偏置（阈值），使得感知机能够正确分类给定的输入数据。

算法步骤

初始化：

权重向量w(0)初始化为0或随机值。
偏置b（在算法中通常包含在权重向量中，作为w(0)的一个分量）也初始化为0或随机值。

迭代过程：

对于每一个输入样本x(n)（其中n代表时间步或样本序号）和对应的期望输出d(n)：
计算输出：y(n) = sgn(w(n) * x(n))，其中sgn是符号函数，当w(n) * x(n)大于0时返回1，小于0时返回-1，等于0时可以根据需要定义。
计算误差：e(n) = d(n) - y(n)。
更新权重和偏置：w(n+1) = w(n) + q * e(n) * x(n)，其中q是学习率参数，通常是一个小于1的正数。

重复上述过程，直到满足停止条件。

停止条件：

可以是达到预设的最大迭代次数。
也可以是网络的输出与期望输出的误差小于某个预设的阈值。

关键点说明

学习率（q）：学习率决定了权重更新的步长。较大的学习率可能导致算法收敛速度加快，但也可能导致算法不稳定；较小的学习率则可能使算法收敛速度变慢，但更加稳定。
权重和偏置：权重和偏置是感知机的可调整参数，通过调整这些参数，感知机可以学习如何正确分类输入数据。
符号函数（sgn）：符号函数用于将加权输入转换为二元输出。在实际应用中，可以根据需要选择其他激活函数来替代符号函数。

总结

Rosenblatt的收敛算法是一种简单而有效的神经网络学习算法，它通过不断调整感知机的权重和偏置来使得网络能够逐渐逼近最优解，实现正确的分类。需要注意的是，该算法仅适用于线性可分的问题。对于非线性可分的问题，需要使用更复杂的神经网络算法来解决。

可在文心一言中输入更多相关内容查询。

C++实现

要点

把偏置b作为权值的第一个元素 $w (0)$
对应权值的输入x，设置为+1
样本文件可在iris网站下载。但注意只留两种花的样本，因为这是二分类，只能线性分为两类。

代码

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <regex>
#include "e:/eigen/Eigen/Dense"


using namespace std;
using namespace Eigen;

struct IrisDa{
    float *irisX;
    int dataSize;
    int d;
    ~IrisDa(){
        delete[] irisX;
    }
};
struct IrisDaW{
    float *irisW;
    int dataSize;
    ~IrisDaW(){
        delete[] irisW;
    }
};
IrisDaW *irisDaW=nullptr;//权值参数

vector<string> split(const string &text, char separator);
string removeSpaces(const string& input);
void dataLearn(const IrisDa *irisDa);
int sgn(float x);
void showIrisW();
void dataTest();
void rbTest(const IrisDa *irisDa);

int main(){

    ifstream fileIn;
    char helloStr[100];
    //read csv
    fileIn.open("e:/ml_data/iris/iris_sample.data");
    if (!fileIn.is_open()){
        cout<<"打开失败！"<<endl;
        return 1;
    }

    regex strRx(R"((\d+)(\.)(\d+))");
    smatch match;
    while (fileIn>>helloStr){
        //construct x(n) and d(n)
        IrisDa *irisDa=new IrisDa;
        vector<string> sampleDatas=split(helloStr,',');
        int dataCount=sampleDatas.size();
        float *irisX= new float[dataCount];//x(n)
        irisX[0]=1.0;
        int irisD;//d(n)
        int i=1;
        for (const string &data: sampleDatas) {
            string irisData=removeSpaces(data);
            bool found = regex_match(irisData, match, strRx);
            if (found) {
                irisX[i]=stof(irisData);
                i++;
            }
            else{
                if (irisData=="Iris-setosa"){
                    irisD=1;
                }
                else{
                    irisD=-1;
                }
            }
        }
        irisDa->irisX=irisX;
        irisDa->d=irisD;
        irisDa->dataSize=dataCount;
        dataLearn(irisDa);
        showIrisW();
    }
    fileIn.close();
    dataTest();
}

void rbTest(const IrisDa *irisDa){
    if (!irisDaW){
        cout<<"请检查参数w是否生成！"<<endl;
        return ;
    }
    cout<<"正在处理测试数据..."<<endl;
    for (int i=0;i<irisDa->dataSize;i++) {
        cout<<irisDa->irisX[i]<<" ";
    }
    cout<<endl;
    VectorXf irisW(irisDa->dataSize);
    VectorXf irisX(irisDa->dataSize);
    for (int i=0;i<irisDa->dataSize;i++){
        irisX[i]=irisDa->irisX[i];
        irisW[i]=irisDaW->irisW[i];
    }
    float y=sgn(irisW.transpose()*irisX);
    cout<<"正确分类："<<irisDa->d<<"预测分类："<<y<<endl;
}

void dataLearn(const IrisDa *irisDa){//训练样本
    float a=0.25;
    cout<<"正在处理数据..."<<endl;
    for (int i=0;i<irisDa->dataSize;i++) {
        cout<<irisDa->irisX[i]<<" ";
    }
    cout<<irisDa->d<<endl;
    if (!irisDaW) {
        irisDaW=new IrisDaW;
        irisDaW->irisW=new float[irisDa->dataSize]{0.0};
        irisDaW->dataSize=irisDa->dataSize;
    }
    VectorXf irisW(irisDa->dataSize);
    VectorXf irisX(irisDa->dataSize);
    for (int i=0;i<irisDa->dataSize;i++){
        irisX[i]=irisDa->irisX[i];
        irisW[i]=irisDaW->irisW[i];
    }
    float y=sgn(irisW.transpose()*irisX);
    irisW=irisW+a*(irisDa->d-y)*irisX;
    for (int i=0;i<irisDa->dataSize;i++){
        irisDaW->irisW[i]=irisW[i];
    }
}

void showIrisW(){
    cout<<"权值："<<endl;
    for (int i=0;i<irisDaW->dataSize;i++){
        cout<<irisDaW->irisW[i]<<" ";
    }
    cout<<endl;
}

void dataTest(){//样本测试
    ifstream fileIn;
    char helloStr[100];
    //read csv
    fileIn.open("e:/ml_data/iris/iris_test.data");
    if (!fileIn.is_open()){
        cout<<"打开失败！"<<endl;
        return ;
    }

    regex strRx(R"((\d+)(\.)(\d+))");
    smatch match;
    while (fileIn>>helloStr){
        //construct x(n) and d(n)
        IrisDa *irisDa=new IrisDa;
        vector<string> sampleDatas=split(helloStr,',');
        int dataCount=sampleDatas.size();
        float *irisX= new float[dataCount];//x(n)
        irisX[0]=1.0;
        int irisD;//d(n)
        int i=1;
        for (const string &data: sampleDatas) {
            string irisData=removeSpaces(data);
            bool found = regex_match(irisData, match, strRx);
            if (found) {
                irisX[i]=stof(irisData);
                i++;
            }
            else{
                if (irisData=="Iris-setosa"){
                    irisD=1;
                }
                else{
                    irisD=-1;
                }
            }
        }
        irisDa->irisX=irisX;
        irisDa->d=irisD;
        irisDa->dataSize=dataCount;
        rbTest(irisDa);
    }
    fileIn.close();
}


int sgn(float x){
    if (x>=0) {
            return 1;
    }
    else {
            return -1;
    }
}

vector<string> split(const string &text, char separator) {
    vector<string> tokens;
    stringstream ss(text);
    string item;
    while (getline(ss, item, separator)) {
        if (!item.empty()) {
            tokens.push_back(item);
        }
    }
    return tokens;
}

string removeSpaces(const string& input) {
    string result = input;
    result.erase(std::remove(result.begin(), result.end(), ' '), result.end());
    return result;
}

运行效果如下：

正在处理数据...
1 5.1 3.5 1.4 0.2 1
权值：
0 0 0 0 0
正在处理数据...
1 4.9 3 1.4 0.2 1
权值：
0 0 0 0 0
正在处理数据...
1 4.7 3.2 1.3 0.2 1
权值：
0 0 0 0 0
正在处理数据...
1 4.6 3.1 1.5 0.2 1
权值：
0 0 0 0 0
正在处理数据...
1 5.6 2.5 3.9 1.1 -1
权值：
-0.5 -2.8 -1.25 -1.95 -0.55
正在处理数据...
1 6.7 3 5 1.7 -1
权值：
-0.5 -2.8 -1.25 -1.95 -0.55
正在处理数据...
1 6.4 2.9 4.3 1.3 -1
权值：
-0.5 -2.8 -1.25 -1.95 -0.55
正在处理数据...
1 6.6 3 4.4 1.4 -1
权值：
-0.5 -2.8 -1.25 -1.95 -0.55
正在处理数据...
1 6.8 2.8 4.8 1.4 -1
权值：
-0.5 -2.8 -1.25 -1.95 -0.55
正在处理数据...
1 5.1 3.3 1.7 0.5 1
权值：
0 -0.25 0.4 -1.1 -0.3
正在处理数据...
1 4.8 3.4 1.9 0.2 1
权值：
0.5 2.15 2.1 -0.15 -0.2
正在处理数据...
1 5 3 1.6 0.2 1
权值：
0.5 2.15 2.1 -0.15 -0.2
正在处理数据...
1 5 3.4 1.6 0.4 1
权值：
0.5 2.15 2.1 -0.15 -0.2
正在处理数据...
1 5.2 3.5 1.5 0.2 1
权值：
0.5 2.15 2.1 -0.15 -0.2
正在处理数据...
1 5.2 3.4 1.4 0.2 1
权值：
0.5 2.15 2.1 -0.15 -0.2
正在处理数据...
1 4.7 3.2 1.6 0.2 1
权值：
0.5 2.15 2.1 -0.15 -0.2
正在处理数据...
1 5.1 3.8 1.9 0.4 1
权值：
0.5 2.15 2.1 -0.15 -0.2
正在处理数据...
1 4.8 3 1.4 0.3 1
权值：
0.5 2.15 2.1 -0.15 -0.2
正在处理数据...
1 5.1 3.8 1.6 0.2 1
权值：
0.5 2.15 2.1 -0.15 -0.2
正在处理数据...
1 4.6 3.2 1.4 0.2 1
权值：
0.5 2.15 2.1 -0.15 -0.2
正在处理数据...
1 5.3 3.7 1.5 0.2 1
权值：
0.5 2.15 2.1 -0.15 -0.2
正在处理数据...
1 5 3.3 1.4 0.2 1
权值：
0.5 2.15 2.1 -0.15 -0.2
正在处理数据...
1 7 3.2 4.7 1.4 -1
权值：
0 -1.35 0.5 -2.5 -0.9
正在处理数据...
1 6.4 3.2 4.5 1.5 -1
权值：
0 -1.35 0.5 -2.5 -0.9
正在处理数据...
1 6.9 3.1 4.9 1.5 -1
权值：
0 -1.35 0.5 -2.5 -0.9
正在处理数据...
1 5.5 2.3 4 1.3 -1
权值：
0 -1.35 0.5 -2.5 -0.9
正在处理数据...
1 4.8 3 1.4 0.1 1
权值：
0.5 1.05 2 -1.8 -0.85
正在处理数据...
1 4.3 3 1.1 0.1 1
权值：
0.5 1.05 2 -1.8 -0.85
正在处理数据...
1 5.8 4 1.2 0.2 1
权值：
0.5 1.05 2 -1.8 -0.85
正在处理数据...
1 5.7 4.4 1.5 0.4 1
权值：
0.5 1.05 2 -1.8 -0.85
正在处理数据...
1 5.7 2.8 4.5 1.3 -1
权值：
0 -1.8 0.6 -4.05 -1.5
正在处理数据...
1 6.3 3.3 4.7 1.6 -1
权值：
0 -1.8 0.6 -4.05 -1.5
正在处理数据...
1 4.9 2.4 3.3 1 -1
权值：
0 -1.8 0.6 -4.05 -1.5
正在处理数据...
1 6.6 2.9 4.6 1.3 -1
权值：
0 -1.8 0.6 -4.05 -1.5
正在处理数据...
1 5.2 2.7 3.9 1.4 -1
权值：
0 -1.8 0.6 -4.05 -1.5
正在处理数据...
1 5 2 3.5 1 -1
权值：
0 -1.8 0.6 -4.05 -1.5
正在处理数据...
1 4.8 3.1 1.6 0.2 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.4 3.4 1.5 0.4 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.2 4.1 1.5 0.1 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.5 4.2 1.4 0.2 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.1 3.4 1.5 0.2 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5 3.5 1.3 0.3 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 4.5 2.3 1.3 0.3 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 4.4 3.2 1.3 0.2 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5 3.5 1.6 0.6 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.9 3 4.2 1.5 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 6 2.2 4 1 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 6.1 2.9 4.7 1.4 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.6 2.9 3.6 1.3 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 6.7 3.1 4.4 1.4 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.4 3.7 1.5 0.2 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 4.8 3.4 1.6 0.2 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.6 3 4.5 1.5 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.8 2.7 4.1 1 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 6.2 2.2 4.5 1.5 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 4.9 3.1 1.5 0.1 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5 3.2 1.2 0.2 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.5 3.5 1.3 0.2 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 4.9 3.1 1.5 0.1 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 4.4 3 1.3 0.2 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.6 2.7 4.2 1.3 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.7 3 4.2 1.2 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.7 2.9 4.2 1.3 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 6.2 2.9 4.3 1.3 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.1 2.5 3 1.1 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 4.4 2.9 1.4 0.2 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 4.9 3.1 1.5 0.1 1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.5 2.4 3.8 1.1 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.5 2.4 3.7 1 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.8 2.7 3.9 1.2 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 6 2.7 5.1 1.6 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.4 3 4.5 1.5 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 6 3.4 4.5 1.6 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理数据...
1 5.7 2.8 4.1 1.3 -1
权值：
0.5 0.6 2.15 -3.25 -1.4
正在处理测试数据...
1 6 2.9 4.5 1.5
正确分类：-1预测分类：-1
正在处理测试数据...
1 5.7 2.6 3.5 1
正确分类：-1预测分类：-1
正在处理测试数据...
1 6.5 2.8 4.6 1.5
正确分类：-1预测分类：-1
正在处理测试数据...
1 5 2.3 3.3 1
正确分类：-1预测分类：-1
正在处理测试数据...
1 5 3.6 1.4 0.2
正确分类：1预测分类：1
正在处理测试数据...
1 5.4 3.9 1.7 0.4
正确分类：1预测分类：1
正在处理测试数据...
1 4.6 3.4 1.4 0.3
正确分类：1预测分类：1
正在处理测试数据...
1 5 3.4 1.5 0.2
正确分类：1预测分类：1
正在处理测试数据...
1 6.7 3.1 4.7 1.5
正确分类：-1预测分类：-1
正在处理测试数据...
1 6.3 2.3 4.4 1.3
正确分类：-1预测分类：-1
正在处理测试数据...
1 5.6 3 4.1 1.3
正确分类：-1预测分类：-1
正在处理测试数据...
1 5.5 2.5 4 1.3
正确分类：-1预测分类：-1
正在处理测试数据...
1 5.5 2.6 4.4 1.2
正确分类：-1预测分类：-1
正在处理测试数据...
1 6.1 3 4.6 1.4
正确分类：-1预测分类：-1
正在处理测试数据...
1 5.8 2.6 4 1.2
正确分类：-1预测分类：-1
正在处理测试数据...
1 5.4 3.9 1.3 0.4
正确分类：1预测分类：1
正在处理测试数据...
1 5.1 3.5 1.4 0.3
正确分类：1预测分类：1
正在处理测试数据...
1 5.7 3.8 1.7 0.3
正确分类：1预测分类：1
正在处理测试数据...
1 5.1 3.8 1.5 0.3
正确分类：1预测分类：1
正在处理测试数据...
1 5.4 3.4 1.7 0.2
正确分类：1预测分类：1
正在处理测试数据...
1 5.1 3.7 1.5 0.4
正确分类：1预测分类：1
正在处理测试数据...
1 4.6 3.6 1 0.2
正确分类：1预测分类：1
正在处理测试数据...
1 5.9 3.2 4.8 1.8
正确分类：-1预测分类：-1
正在处理测试数据...
1 6.1 2.8 4 1.3
正确分类：-1预测分类：-1
正在处理测试数据...
1 6.3 2.5 4.9 1.5
正确分类：-1预测分类：-1
正在处理测试数据...
1 6.1 2.8 4.7 1.2
正确分类：-1预测分类：-1

Process returned 0 (0x0)   execution time : 0.901 s
Press any key to continue.

参考文献

1、《神经网络与机器学习第三版》

未来之蓝

关注

34
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
人工智能与机器学习原理精解【1】

Rosenblatt的收敛算法是一个迭代过程，通过不断调整感知机的权重和偏置（阈值），使得感知机能够正确分类给定的输入数据。Rosenblatt的收敛算法是一种简单而有效的神经网络学习算法，它通过不断调整感知机的权重和偏置来使得网络能够逐渐逼近最优解，实现正确的分类。需要注意的是，该算法仅适用于线性可分的问题。对于非线性可分的问题，需要使用更复杂的神经网络算法来解决。可在文心一言中输入更多相关内容查询。
复制链接

扫一扫