使用C++实现感知机模型
最近在上机器学习课程，刚学习了感知机模型，于是决定自己动手写一下。
设计想法： 想要构建出一种通用的模型设计形式，方便之后的机器学习模型也可以套用，于是尝试将最近看的设计模式运用上，类图一中在Train_data类中使用单例模式，在类图二中使用装饰者模式。
结构说明： Train_data类中封装了Data* data，通过data指针指向存储的训练数据；Perceptron_entity类中封装了Data* Weight_and_bias_step、int modle_value[N]、int functional_margin[N]，通过Weight_and_bias_step指针指向存储的权重W、偏置B以及步长n; 通过modle_value[N]存储感知机模型的值(WX+b), 通过functional_margin[N]存储函数间隔的值( Yi*(WX+b) ), 通过Perceptron_entity类来实例化感知机对象；Function类和 Optimize类分别是用来计算函数间隔和优化权重W、偏置B以及步长n。
结果分析：1. 事实证明，设计模式的使用是要分场景的； 在Train_data类中并不需要使用单例模式，因为我还需要对Data进行修改，在Public中写了set函数对数据进行修改，这与单例模式的本意相悖；单例模式的本意是初始化一份资源，只可以供其他函数读取。 2. 此外，对类的的设计不够清晰，将数据、权重、偏置、以及学习率封装在Data类中，导致之后函数调用不够清楚。
改进想法：1.对类进一步细化，将Data类分为两个类：Data和 Weight_bias，Data类封装数据；Weight_bias类封装W1、W2、B、n。 2.增强代码的复用性： 使用户能够对Perceptron_entity类中的Weight_and_bias_step进行修改，对一份数据可以定义不同Perceptron_entity的对象，可以尝试提供友元函数，破坏封装性，来达到这个目的。 3.进一步提升：使用户能够对Train_data类的对象中的原始数据进行修改和增加， 从而达到：不同数据，不同Perceptron_entity，的使用。
一.类图
二.C++代码
Data.h文件
#pragma once
class Data
{
private:
int X1;
int X2;
int sample_signal;//正样本or负样本
bool symbol=false;//标记分类正确与否
int W1;
int W2;
int B;
int n; //步长
public:
Data();
~Data();
void set_x1(const int x1);
void set_x2(const int x2);
void set_sample_signal(const int sample_signal);
void set_W1(const int W1);
void set_W2(const int W2);
void set_B(const int B);
void set_n(const int n);
void set_symbol(bool symbol);
int get_x1();
int get_x2();
int get_sample_signal();
int get_W1( );
int get_W2( );
int get_B( );
int get_n( );
bool get_symbol( );
};
Data::Data()
{
}
Data::~Data()
{
}
inline void Data::set_x1(const int x1)
{
this->X1=x1;
}
inline void Data::set_x2(const int x2)
{
this->X2 = x2;
}
inline void Data::set_sample_signal(const int sample_signal)
{
this->sample_signal = sample_signal;
}
inline void Data::set_W1(const int W1)
{
this->W1 = W1;
}
inline void Data::set_W2(const int W2)
{
this->W2 = W2;
}
inline void Data::set_B(const int B)
{
this->B = B;
}
inline void Data::set_n(const int n)
{
this->n = n;
}
inline void Data::set_symbol(bool symbol)
{
this->symbol = symbol;
}
inline int Data::get_x1()
{
return X1;
}
inline int Data::get_x2()
{
return X2;
}
inline int Data::get_sample_signal()
{
return sample_signal;
}
inline int Data::get_W1()
{
return W1;
}
inline int Data::get_W2()
{
return W2;
}
inline int Data::get_B()
{
return B;
}
inline int Data::get_n()
{
return n;
}
inline bool Data::get_symbol()
{
return symbol;
}
Train_data.h文件
#pragma once
#include"Data.h"
#define N 3
class Train_data
{
private:
Data *data;
static Train_data * unique_instance;
Train_data();
public:
int judge();
~Train_data();
static Train_data* getinstance();
Data * get_data();
};
Train_data* Train_data::unique_instance = nullptr;
Train_data::Train_data()
{
this->data = new Data[N];
data[0].set_x1(3);
data[0].set_x2(3);
data[0].set_sample_signal(1);
data[1].set_x1(4);
data[1].set_x2(3);
data[1].set_sample_signal(1);
data[2].set_x1(1);
data[2].set_x2(1);
data[2].set_sample_signal(-1);
}
Train_data::~Train_data()
{
//释放数组
delete [ ]data;
}
inline Train_data* Train_data::getinstance()
{
if (unique_instance == nullptr)
{
unique_instance = new Train_data();
}
return unique_instance;
}
inline Data * Train_data::get_data()
{
return this->data;
}
inline int Train_data::judge()
{
int number = 0;
for (int i = 0; i < N; i++)
if (data[i].get_symbol() == true)
number++;
return number;
}
Perceptron.h文件
#pragma once
#include<iostream>
#include<string>
#include"Data.h"
#include"F://python/include/Python.h"
using namespace std;
class Perceptron
{
private:
string description;
public:
Perceptron();
~Perceptron();
//ostream& operator <<(ostream& ostr, const Perceptron& x);
string get_Description() {}
virtual int* caculate() { return nullptr; }
virtual void caculate(int n) {};
virtual void display(){}
virtual void set_functional_margin(const int value, const int n) {}
virtual int * get_functional_margin() { return nullptr; }
virtual Data * get_Weight_and_bias_and_step(){ return nullptr; }
};
Perceptron::Perceptron()
{
this->description = "This is a perceptron class";
}
Perceptron::~Perceptron()
{
}
Perceptron_entity.h文件
#pragma once
#include"Perceptron.h"
#include"Train_data.h"
#include"Data.h"
#include <cstdlib>
class Perceptron_entity: public Perceptron
{
private:
Data * Weight_and_bias_and_step;
int model_value[N];
int functional_margin[N];
public:
Perceptron_entity();
~Perceptron_entity();
string get_Description();
int * caculate();
void display();
void set_functional_margin(const int value, const int n);
int * get_functional_margin();
int * get_model_value();
Data* get_Weight_and_bias_and_step();
};
inline Perceptron_entity::Perceptron_entity()
{
cout << "init" << endl;
Weight_and_bias_and_step = new Data();
Weight_and_bias_and_step->set_W1(0);
Weight_and_bias_and_step->set_W2(0);
Weight_and_bias_and_step->set_B(0);
Weight_and_bias_and_step->set_n(1);
cout << Weight_and_bias_and_step->get_n() << endl;
}
Perceptron_entity::~Perceptron_entity()
{
delete Weight_and_bias_and_step;
}
inline string Perceptron_entity::get_Description()
{
return string();
}
inline int* Perceptron_entity::caculate()
{
cout <<" model_value "<< endl;
Train_data *sample= Train_data::getinstance();
for(int i=0;i<N;i++)
model_value[i]=(sample->get_data())[i].get_x1() * Weight_and_bias_and_step->get_W1() + (sample->get_data())[i].get_x2() * Weight_and_bias_and_step->get_W2() + Weight_and_bias_and_step->get_B();
//if (temp >= 0)
// model_value = 1;
//else
// model_value = -1;
return model_value;
}
inline void Perceptron_entity::set_functional_margin(const int value, const int n)
{
this->functional_margin[n] = value;
}
inline int* Perceptron_entity::get_functional_margin()
{
return functional_margin;
}
inline int * Perceptron_entity::get_model_value()
{
return model_value;
}
inline Data* Perceptron_entity::get_Weight_and_bias_and_step()
{
return Weight_and_bias_and_step;
}
inline void Perceptron_entity::display()
{
//int j = 0;
// Train_data* sample = Train_data::getinstance();
cout <<" print Weight_and_bias_and_step " << endl;
cout << "W1: " << Weight_and_bias_and_step->get_W1()<<endl;
cout << "W2: " << Weight_and_bias_and_step->get_W2()<<endl;
cout << "B: " << Weight_and_bias_and_step->get_B()<<endl;
cout << "n: " << Weight_and_bias_and_step->get_n()<<endl;
////***python调用***//
////初始化python模块
//Py_Initialize();
//// 检查初始化是否成功
//if (!Py_IsInitialized())
//{
// cout << "szzvz" << endl;
// Py_Finalize();
//}
//PyRun_SimpleString("import sys");
////添加Insert模块路径
////PyRun_SimpleString(chdir_cmd.c_str());
//PyRun_SimpleString("sys.path.append('./')");
////PyRun_SimpleString("sys.argv = ['python.py']");
//PyObject* pModule = NULL;
////导入模块
//pModule = PyImport_ImportModule("draw");
//if (!pModule)
//{
// cout << "Python get module failed." << endl;
//
//}
//cout << "Python get module succeed." << endl;
//PyObject* pFunc = NULL;
//pFunc = PyObject_GetAttrString(pModule, "_draw");
//PyObject* ret=PyEval_CallObject(pFunc, NULL);
////获取Insert模块内_add函数
//PyObject* pv = PyObject_GetAttrString(pModule, "_draw_");
//if (!pv || !PyCallable_Check(pv))
//{
// cout << "Can't find funftion (_draw_)" << endl;
//}
//// cout << "Get function (_draw_) succeed." << endl;
//////初始化要传入的参数，args配置成传入两个参数的模式
//PyObject* args = PyTuple_New(2*N+3);
//PyObject* ArgList = PyTuple_New(1);
////将Long型数据转换成Python可接收的类型
//for (int i=0; i < N; i++,j++)
//{
// PyObject* arg1 = PyLong_FromLong((sample->get_data())[i].get_x1());
// PyObject* arg2 = PyLong_FromLong((sample->get_data())[i].get_x2());
// PyTuple_SetItem(args, j, arg1);
// PyTuple_SetItem(args, ++j, arg2);
//}
// PyObject* arg3 = PyLong_FromLong(Weight_and_bias_and_step->get_W1());
// PyTuple_SetItem(args, j++, arg3);
// PyObject* arg4 = PyLong_FromLong(Weight_and_bias_and_step->get_W2());
// PyTuple_SetItem(args, j++, arg4);
// PyObject* arg5 = PyLong_FromLong(Weight_and_bias_and_step->get_B());
// PyTuple_SetItem(args, j++, arg5);
// PyTuple_SetItem(ArgList, 0, args);
////传入参数调用函数，并获取返回值
//PyObject* pRet = PyObject_CallObject(pv, ArgList);
//if (pRet)
//{
// //将返回值转换成long型
// long result = PyLong_AsLong(pRet);
// cout << "result:" << result << endl;
//}
//Py_CLEAR(pModule);
//Py_CLEAR(pFunc);
//Py_CLEAR(ret);
//Py_CLEAR(pv);
//Py_CLEAR(args);
//Py_CLEAR(ArgList);
//Py_CLEAR(pRet);
//Py_Finalize();
//system("pause");
}
Suan_fa.h文件
#pragma once
#include"Perceptron.h"
#include"Data.h"
class Suan_fa: public Perceptron
{
private:
public:
Suan_fa();
~Suan_fa();
};
Suan_fa::Suan_fa()
{
}
Suan_fa::~Suan_fa()
{
}
Function.h文件
#pragma once
#include"Suan_fa.h"
#include"Data.h"
#include"Perceptron_entity.h"
class Function: public Suan_fa
{
private:
Perceptron * perceptron;
public:
Function(Perceptron * entity);
~Function();
void caculate(int n);
void display();
};
Function::Function(Perceptron * entity)
{
this->perceptron = entity;
}
Function::~Function()
{
}
inline void Function::caculate(int n)
{
cout <<" print origin samples "<< endl;
//计算functional_margin
Train_data* sample = Train_data::getinstance();
cout << " print first sample " << endl;
cout <<"x1: "<<(sample->get_data())[0].get_x1() << endl;
cout <<"y1: "<<(sample->get_data())[0].get_x2() << endl;
cout << " print second sample " << endl;
cout <<"x2: "<<(sample->get_data())[1].get_x1() << endl;
cout <<"y2: "<<(sample->get_data())[1].get_x2() << endl;
cout << " print third sample " << endl;
cout <<"x3: "<<(sample->get_data())[2].get_x1() << endl;
cout <<"y3: "<<(sample->get_data())[2].get_x2() << endl;
int* array = perceptron->caculate();
cout <<array[0]<< endl;
cout <<array[1]<< endl;
cout <<array[2]<< endl;
perceptron->set_functional_margin(array[n]*(sample->get_data())[n].get_sample_signal(),n);
}
inline void Function::display()
{
perceptron->display();
//cout << "this is function" << endl;
}
Optimize.h文件
#pragma once
#include"Perceptron.h"
#include"Suan_fa.h"
#include"Train_data.h"
class Optimize:public Suan_fa
{
private:
Perceptron * perceptron;
public:
Optimize(Perceptron * entity);
~Optimize();
void caculate(int n);
void display();
};
Optimize::Optimize(Perceptron * entity)
{
this->perceptron = entity;
}
Optimize::~Optimize()
{
}
inline void Optimize::caculate(int n)
{
cout <<" print functional_margin "<< endl;
Train_data * sample = Train_data::getinstance();
cout << perceptron->get_functional_margin()[0] << endl;
cout << perceptron->get_functional_margin()[1] << endl;
cout << perceptron->get_functional_margin()[2] << endl;
if (perceptron->get_functional_margin()[n] <= 0)
{
cout <<" this time functional_margin 小于0 "<< endl<<endl;
/* cout <<perceptron->get_Weight_and_bias_and_step()->get_W1()<< endl;
cout <<perceptron->get_Weight_and_bias_and_step()->get_n()<< endl;
cout <<(sample->get_data())[n].get_sample_signal()<< endl;
cout <<(sample->get_data())[n].get_x1()<< endl;*/
(sample->get_data())[n].set_symbol(false);
perceptron->get_Weight_and_bias_and_step()->set_W1(perceptron->get_Weight_and_bias_and_step()->get_W1() + perceptron->get_Weight_and_bias_and_step()->get_n() * (sample->get_data())[n].get_sample_signal() * (sample->get_data())[n].get_x1());
perceptron->get_Weight_and_bias_and_step()->set_W2(perceptron->get_Weight_and_bias_and_step()->get_W2() + perceptron->get_Weight_and_bias_and_step()->get_n() * (sample->get_data())[n].get_sample_signal() * (sample->get_data())[n].get_x2());
perceptron->get_Weight_and_bias_and_step()->set_B(perceptron->get_Weight_and_bias_and_step()->get_B() + perceptron->get_Weight_and_bias_and_step()->get_n() * (sample->get_data())[n].get_sample_signal());
}
else
(sample->get_data())[n].set_symbol(true);
}
inline void Optimize::display()
{
perceptron->display();
//cout << "this is optimize" << endl;
}
main.cpp文件
#include"Data.h"
#include"Function.h"
#include"Optimize.h"
#include"Perceptron.h"
#include"Perceptron_entity.h"
#include"Suan_fa.h"
#include"Train_data.h"
#include<iostream>
#include"F://python/include/Python.h"
using namespace std;
int main()
{
int loop_number = 1;
int number = 0;
Train_data * samples = Train_data::getinstance();
Perceptron* Entity = new Perceptron_entity();
while (samples->judge()!=3)
{
cout<<"This is "<<loop_number<<" loop "<<endl;
//Entity->display();
Function entity(Entity);
entity.caculate(number);
entity.display();
Optimize optimize(Entity);
optimize.caculate(number);
cout <<" print the Weight_and_bias_and_step after optimize " << endl;
optimize.display();
loop_number++;
if (number == 2)
number = number % 2;
else
number++;
}
return 0;
}