1. StackOverflow 文档
  2. machine-learning 教程
  3. 感知
  4. 在 C 中实现 Perceptron 模型

在 C 中实现 Perceptron 模型

Created: November-22, 2018

在这个例子中，我将介绍 C++中感知器模型的实现，以便你可以更好地了解它的工作原理。

首先，首先写一个我们想要做的简单算法是一个好习惯。

算法：

  1. 制作权重的向量并将其初始化为 0（不要忘记添加偏差项）
  2. 继续调整权重，直到我们得到 0 错误或错误计数低。
  3. 对看不见的数据做出预测。

编写了一个超级简单的算法之后，我们现在编写一些我们需要的函数。

  • 我们需要一个函数来计算网络的输入（ei x * wT 乘以输入时间的权重）
  • 阶梯函数，以便我们得到 1 或 -1 的预测
  • 并且找到权重的理想值的函数。

所以没有进一步的努力让我们直接进入它。

让我们通过创建一个感知器类开始简单：

class perceptron
{
public:
    
private:

};

现在让我们添加我们需要的功能。

class perceptron
{
public:
    perceptron(float eta,int epochs);
    float netInput(vector<float> X);
    int predict(vector<float> X);
    void fit(vector< vector<float> > X, vector<float> y);
private:

};

注意函数拟合如何将向量<float>的向量作为参数。那是因为我们的训练数据集是一个输入矩阵。基本上我们可以想象矩阵作为几个向量 x 将一个叠加在另一个上面，并且该矩阵的每列都是一个特征。

最后，让我们添加我们的类需要具有的值。例如用于保持权重的向量 w ，表示我们将在训练数据集上进行的遍数的时期数。并且常数 eta 是我们将每个重量更新乘以学习速率以通过拨打此值来使训练过程更快或者如果 eta 过高我们可以将其调低以获得理想结果（对于大多数应用）我会建议感知器的 eta 值为 0.1）。

class perceptron
{
public:
    perceptron(float eta,int epochs);
    float netInput(vector<float> X);
    int predict(vector<float> X);
    void fit(vector< vector<float> > X, vector<float> y);
private:
    float m_eta;
    int m_epochs;
    vector < float > m_w;
};

现在我们的类设置。是时候编写每个函数了。

我们将从构造函数开始（ perceptron（float eta，int epochs）; ）

perceptron::perceptron(float eta, int epochs)
{
    m_epochs = epochs; // We set the private variable m_epochs to the user selected value
    m_eta = eta; // We do the same thing for eta
}

正如你所看到的，我们将要做的事情非常简单。那么让我们继续讨论另一个简单的函数。预测函数（ int 预测（向量 X）; ）。请记住，所有预测函数的作用是获取净输入，如果 netInput 大于 0 则返回值 1，其他为 -1。

int perceptron::predict(vector<float> X)
{
    return netInput(X) > 0 ? 1 : -1; //Step Function
}

请注意，我们使用内联 if 语句来简化我们的生活。以下是内联 if 语句的工作原理：

条件？if_true：else

到现在为止还挺好。让我们继续实现 netInput 函数（ float netInput（vector X）; ）

netInput 执行以下操作; 将输入向量乘以权重向量的转置

x * wT

换句话说，它将输入向量 x 的每个元素乘以权重 w 的向量的对应元素，然后获取它们的和并加上偏差。

（x1 * w1 + x2 * w2 + … + xn * wn）+偏差

偏差= 1 * w0

float perceptron::netInput(vector<float> X)
{
    // Sum(Vector of weights * Input vector) + bias
    float probabilities = m_w[0]; // In this example I am adding the perceptron first
    for (int i = 0; i < X.size(); i++)
    {
        probabilities += X[i] * m_w[i + 1]; // Notice that for the weights I am counting
        // from the 2nd element since w0 is the bias and I already added it first.
    }
    return probabilities;
}

好吧，所以我们现在已经完成了很多工作，我们需要做的是编写修改权重的 fit 函数。

void perceptron::fit(vector< vector<float> > X, vector<float> y)
{
    for (int i = 0; i < X[0].size() + 1; i++) // X[0].size() + 1 -> I am using +1 to add the bias term
    {
        m_w.push_back(0); // Setting each weight to 0 and making the size of the vector
        // The same as the number of features (X[0].size()) + 1 for the bias term
    }
    for (int i = 0; i < m_epochs; i++) // Iterating through each epoch
    {
        for (int j = 0; j < X.size(); j++) // Iterating though each vector in our training Matrix
        {
            float update = m_eta * (y[j] - predict(X[j])); //we calculate the change for the weights
            for (int w = 1; w < m_w.size(); w++){ m_w[w] += update * X[j][w - 1]; } // we update each weight by the update * the training sample
            m_w[0] = update; // We update the Bias term and setting it equal to the update
        }
    }
}

所以这基本上就是它。只有 3 个函数，我们现在有一个工作感知器类，我们可以使用它来进行预测！

如果你想复制粘贴代码并尝试它。这是整个类（我添加了一些额外的功能，例如打印权重向量和每个时期的错误，以及添加导入/导出权重的选项。）

这是代码：

类标题：

class perceptron
{
public:
    perceptron(float eta,int epochs);
    float netInput(vector<float> X);
    int predict(vector<float> X);
    void fit(vector< vector<float> > X, vector<float> y);
    void printErrors();
    void exportWeights(string filename);
    void importWeights(string filename);
    void printWeights();
private:
    float m_eta;
    int m_epochs;
    vector < float > m_w;
    vector < float > m_errors;
};

类 .cpp 文件的功能：

perceptron::perceptron(float eta, int epochs)
{
    m_epochs = epochs;
    m_eta = eta;
}

void perceptron::fit(vector< vector<float> > X, vector<float> y)
{
    for (int i = 0; i < X[0].size() + 1; i++) // X[0].size() + 1 -> I am using +1 to add the bias term
    {
        m_w.push_back(0);
    }
    for (int i = 0; i < m_epochs; i++)
    {
        int errors = 0;
        for (int j = 0; j < X.size(); j++)
        {
            float update = m_eta * (y[j] - predict(X[j]));
            for (int w = 1; w < m_w.size(); w++){ m_w[w] += update * X[j][w - 1]; }
            m_w[0] = update;
            errors += update != 0 ? 1 : 0;
        }
        m_errors.push_back(errors);
    }
}

float perceptron::netInput(vector<float> X)
{
    // Sum(Vector of weights * Input vector) + bias
    float probabilities = m_w[0];
    for (int i = 0; i < X.size(); i++)
    {
        probabilities += X[i] * m_w[i + 1];
    }
    return probabilities;
}

int perceptron::predict(vector<float> X)
{
    return netInput(X) > 0 ? 1 : -1; //Step Function
}

void perceptron::printErrors()
{
    printVector(m_errors);
}

void perceptron::exportWeights(string filename)
{
    ofstream outFile;
    outFile.open(filename);

    for (int i = 0; i < m_w.size(); i++)
    {
        outFile << m_w[i] << endl;
    }

    outFile.close();
}

void perceptron::importWeights(string filename)
{
    ifstream inFile;
    inFile.open(filename);

    for (int i = 0; i < m_w.size(); i++)
    {
        inFile >> m_w[i];
    }
}

void perceptron::printWeights()
{
    cout << "weights: ";
    for (int i = 0; i < m_w.size(); i++)
    {
        cout << m_w[i] << " ";
    }
    cout << endl;
}

此外，如果你想尝试一个示例，这是我做的一个例子：

main.cpp 中：

#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>
#include <string>
#include <math.h> 

#include "MachineLearning.h"

using namespace std;
using namespace MachineLearning;

vector< vector<float> > getIrisX();
vector<float> getIrisy();

int main()
{
    vector< vector<float> > X = getIrisX();
    vector<float> y = getIrisy();
    vector<float> test1;
    test1.push_back(5.0);
    test1.push_back(3.3);
    test1.push_back(1.4);
    test1.push_back(0.2);

    vector<float> test2;
    test2.push_back(6.0);
    test2.push_back(2.2);
    test2.push_back(5.0);
    test2.push_back(1.5);
    //printVector(X);
    //for (int i = 0; i < y.size(); i++){ cout << y[i] << " "; }cout << endl;

    perceptron clf(0.1, 14);
    clf.fit(X, y);
    clf.printErrors();
    cout << "Now Predicting: 5.0,3.3,1.4,0.2(CorrectClass=-1,Iris-setosa) -> " << clf.predict(test1) << endl;
    cout << "Now Predicting: 6.0,2.2,5.0,1.5(CorrectClass=1,Iris-virginica) -> " << clf.predict(test2) << endl;

    system("PAUSE");
    return 0;
}

vector<float> getIrisy()
{
    vector<float> y;

    ifstream inFile;
    inFile.open("y.data");
    string sampleClass;
    for (int i = 0; i < 100; i++)
    {
        inFile >> sampleClass;
        if (sampleClass == "Iris-setosa")
        {
            y.push_back(-1);
        }
        else
        {
            y.push_back(1);
        }
    }

    return y;
}

vector< vector<float> > getIrisX()
{
    ifstream af;
    ifstream bf;
    ifstream cf;
    ifstream df;
    af.open("a.data");
    bf.open("b.data");
    cf.open("c.data");
    df.open("d.data");

    vector< vector<float> > X;

    for (int i = 0; i < 100; i++)
    {
        char scrap;
        int scrapN;
        af >> scrapN;
        bf >> scrapN;
        cf >> scrapN;
        df >> scrapN;

        af >> scrap;
        bf >> scrap;
        cf >> scrap;
        df >> scrap;
        float a, b, c, d;
        af >> a;
        bf >> b;
        cf >> c;
        df >> d;
        X.push_back(vector < float > {a, b, c, d});
    }

    af.close();
    bf.close();
    cf.close();
    df.close();

    return X;
}

我导入虹膜数据集的方式并不是很理想，但我只想要一些有用的东西。

数据文件可以在这里找到。

我希望你发现这有用！