机器学习之感知机

最新推荐文章于 2022-10-31 16:22:33 发布
最新推荐文章于 2022-10-31 16:22:33 发布
阅读量256 收藏
点赞数
分类专栏： 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012704941/article/details/74528859
版权

    本文主要记录本人在学习机器学习过程中的相关代码实现，参考《机器学习实战》

package perceptron;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.*;

public class PerceptronFrame extends JFrame {

	protected int dim = 1;// 输入空间特征维数
	protected int num = 1;// 训练数据个数
	double[][] xData;// 存储训练数据
	double[] yData;// 存储训练数据的类型
	int i_n = 0;// 遍历num
	int i_d = 0;// 遍历dim
	protected double learn = 0;// 学习率
	double[] w;//原始训练
	double[] alpha;//对偶训练
	double b;
	double[][] gram;
	private static final int DEFAULT_WIDTH = 600;
	private static final int DEFAULE_HEIGHT = 400;
	private JPanel panel1;
	private InputPanel panel2;
	private ButtonPanel pabel3;
	private JTextArea textArea;
	private JTextField field2;
	public JTextField fieldX;
	public JTextField fieldY;
	public JButton addButton;
	public JTextField field3;
	public JButton original;
	public JButton dual;
	public JButton confirmButton;
	public JTextField field1;
	public JTextField inputField;
	public JButton predictButton;

	public PerceptronFrame() {
		dim = 1;// 输入空间特征维数
		num = 1;// 训练数据个数
		xData=null;// 存储训练数据
		yData=null;// 存储训练数据的类型
		i_n = 0;// 遍历num
		i_d = 0;// 遍历dim
		learn = 0;// 学习率
		w=null;//原始训练
		alpha=null;//对偶训练
		b=0;
		gram=null;
		
		setTitle("感知机学习");
		setSize(DEFAULT_WIDTH, DEFAULE_HEIGHT);
		panel1 = new JPanel();
		textArea = new JTextArea("请点击下面的按钮进行操作", 10, 52);
		textArea.setEditable(false);
		textArea.setLineWrap(true);
		JScrollPane scrollPane = new JScrollPane(textArea);
		panel1.add(scrollPane);
		add(panel1, BorderLayout.NORTH);

		panel2 = new InputPanel();
		add(panel2, BorderLayout.CENTER);

		pabel3 = new ButtonPanel();
		add(pabel3, BorderLayout.SOUTH);
	}

	public class InputPanel extends JPanel {

		public InputPanel() {
			setSize(550, 100);
			JLabel labelx = new JLabel("x:");
			fieldX = new JTextField(10);
			JLabel labely = new JLabel("y:");
			fieldY = new JTextField(10);
			JLabel label1 = new JLabel("输入空间特征维数:");
			field1 = new JTextField(10);
			JLabel label2 = new JLabel("输入训练数据组数:");
			field2 = new JTextField(10);
			field2.setEditable(false);

			setLayout(null);
			add(labelx);
			labelx.setBounds(10, 10, 30, 20);
			add(fieldX);
			fieldX.setBounds(30, 10, 100, 20);
			fieldX.setEditable(false);
			add(labely);
			labely.setBounds(10, 40, 30, 20);
			add(fieldY);
			fieldY.setBounds(30, 40, 100, 20);
			fieldY.setEditable(false);
			add(label1);
			label1.setBounds(200, 10, 150, 20);
			add(field1);
			field1.setBounds(320, 10, 100, 20);
			add(label2);
			label2.setBounds(200, 40, 150, 20);
			add(field2);
			field2.setBounds(320, 40, 100, 20);

			addButton = new JButton("添加");
			addButton.setEnabled(false);
			confirmButton = new JButton("确定");
			confirmButton.setEnabled(false);
			JLabel label3 = new JLabel("输入学习率:");
			field3 = new JTextField();
			field3.setEditable(false);
			original = new JButton("原始形式");
			original.setEnabled(false);
			dual = new JButton("对偶形式");
			dual.setEnabled(false);
			field1.addActionListener(new ActionListener() {

				@Override
				public void actionPerformed(ActionEvent e) {
					// TODO Auto-generated method stub
					dim = Integer.parseInt(field1.getText());
					textArea.append("\n空间特征维数为：" + dim);
					field1.setEditable(false);
					field2.setEditable(true);
				}
			});

			field2.addActionListener(new ActionListener() {

				@Override
				public void actionPerformed(ActionEvent e) {
					// TODO Auto-generated method stub
					num = Integer.parseInt(field2.getText());
					textArea.append("\n训练数据个数为：" + num);
					field2.setEditable(false);
					fieldX.setEditable(true);
					fieldY.setEditable(true);
					addButton.setEnabled(true);
					xData = new double[num][dim];
					yData = new double[num];
				}
			});

			addButton.addActionListener(new ActionListener() {

				@Override
				public void actionPerformed(ActionEvent e) {
					// TODO Auto-generated method stub

					if (i_n < num) {
						String[] s = fieldX.getText().split(",");
						yData[i_n] = Double.parseDouble(fieldY.getText());
						textArea.append("\n(" + i_n + "): y=" + yData[i_n]
								+ "	");
						for (i_d = 0; i_d < dim; i_d++) {
							xData[i_n][i_d] = Double.parseDouble(s[i_d]);
							textArea.append("x" + i_d + "=" + xData[i_n][i_d]
									+ "	");
						}
						i_n++;
					}
					if (i_n >= num) {
						i_n = 0;
						fieldX.setEditable(false);
						fieldY.setEditable(false);
						addButton.setEnabled(false);
						field3.setEditable(true);
					}
				}
			});

			add(addButton);
			addButton.setBounds(20, 80, 60, 25);
			add(confirmButton);
			confirmButton.setBounds(100, 80, 60, 25);
			add(label3);
			label3.setBounds(180, 80, 70, 25);
			add(field3);
			field3.setBounds(260, 80, 60, 25);
			add(original);
			original.setBounds(340, 80, 100, 25);
			add(dual);
			dual.setBounds(450, 80, 100, 25);

			field3.addActionListener(new ActionListener() {

				@Override
				public void actionPerformed(ActionEvent e) {
					// TODO Auto-generated method stub
					learn = Double.parseDouble(field3.getText());
					textArea.append("\n学习率为：" + learn);
					field3.setEditable(false);
					original.setEnabled(true);
					dual.setEnabled(true);
				}
			});
			ActionListener originalActionListener = new OriginalActionListener();
			original.addActionListener(originalActionListener);
			ActionListener dualActionListener = new DualActionListener();
			dual.addActionListener(dualActionListener);
		}
	}

	public class ButtonPanel extends JPanel {
		private JButton clearButton;
		private JButton resetButton;

		public ButtonPanel() {
			clearButton = new JButton("清空");
			resetButton = new JButton("重置");
			inputField = new JTextField("输入预测数据");
			predictButton = new JButton("预测");
			add(clearButton);
			add(resetButton);
			add(inputField);
			add(predictButton);
			inputField.setEditable(false);
			predictButton.setEnabled(false);
			ActionListener predictActionListener=new PredictActionListener();
			predictButton.addActionListener(predictActionListener);
			clearButton.addActionListener(new ActionListener() {
				
				@Override
				public void actionPerformed(ActionEvent e) {
					// TODO Auto-generated method stub
					textArea.setText("");
				}
			});
			resetButton.addActionListener(new ActionListener() {
				
				@Override
				public void actionPerformed(ActionEvent e) {
					// TODO Auto-generated method stub
					dim = 1;// 输入空间特征维数
					num = 1;// 训练数据个数
					xData=null;// 存储训练数据
					yData=null;// 存储训练数据的类型
					i_n = 0;// 遍历num
					i_d = 0;// 遍历dim
					learn = 0;// 学习率
					w=null;//原始训练
					alpha=null;//对偶训练
					b=0;
					gram=null;
					
					field1.setEditable(true);
					field1.setText("");
					field2.setText("");
					field2.setEditable(false);
					fieldX.setText("");
					fieldX.setEditable(false);
					fieldY.setText("");
					fieldY.setEditable(false);
					field3.setText("");
					field3.setEditable(false);
					addButton.setEnabled(false);
					confirmButton.setEnabled(false);
					field3.setEditable(false);
					original.setEnabled(false);
					dual.setEnabled(false);
					inputField.setEditable(false);
					predictButton.setEnabled(false);
				}
			});
		}
	}

	public class OriginalActionListener implements ActionListener {

		@Override
		public void actionPerformed(ActionEvent e) {
			// TODO Auto-generated method stub
			int i = 0;// 记录迭代次数
			textArea.append("\n迭代次数\t误分类点\tw\tb\tw*x+b");
			textArea.append("\n" + (i++) + "\t初始状态\t0\t0\t0");
			w = new double[dim];
			b = 0;
			boolean flag = true;// flag为true表示存在误分类点
			while (flag) {
				flag = false;
				for (i_n = 0; i_n < num; i_n++) {
					if (yData[i_n] * multiply(w, xData[i_n], b) <= 0) {
						flag = true;
						b = b + learn * yData[i_n];
						textArea.append("\n" + (i++) + "	(" + i_n + ")" + "\t(");
						for (i_d = 0; i_d < dim; i_d++) {
							w[i_d] = w[i_d] + learn * xData[i_n][i_d]
									* yData[i_n];
							if (i_d < (dim - 1)) {
								textArea.append(w[i_d] + ",");
							} else {
								textArea.append(w[i_d] + ")");
							}
						}
						textArea.append("\t" + b + "\t");
						for (i_d = 0; i_d < dim; i_d++) {
							if ((i_d + 1) < dim && (w[i_d + 1] >= 0)) {
								textArea.append(+w[i_d] + "x" + i_d + "+");
							} else {
								textArea.append(+w[i_d] + "x" + i_d);
							}
						}
						if (b >= 0) {
							textArea.append("+" + b);
						} else {
							textArea.append("" + b);
						}
						break;
					}
				}
			}
			inputField.setEditable(true);
			predictButton.setEnabled(true);
		}
	}

	public class DualActionListener implements ActionListener {

		@Override
		public void actionPerformed(ActionEvent e) {
			// TODO Auto-generated method stub
			//初始化gram矩阵
			gram=new double[num][num];
			alpha=new double[num];
			b=0;
			for(int i=0;i<num;i++){
				for(int j=0;j<num;j++){
					for(i_d=0;i_d<dim;i_d++){
						gram[i][j]=gram[i][j]+xData[i][i_d]*xData[j][i_d];
					}
				}
			}
			boolean flag = true;//flag为true表示存在误分类点
			int j=0;//记录迭代次数
			textArea.append("\n迭代次数\t");
			textArea.append("误分类点\t");
			for(int i=0;i<num;i++){
				textArea.append("alpha"+i+"\t");
			}
			textArea.append("b");
			textArea.append("\n"+(j++)+"\t初始状态\t0\t0\t0\t");
			
			while(flag){
				flag=false;
				for(i_n=0;i_n<num;i_n++){
					if(yData[i_n]*multiply2(alpha, gram, b,i_n)<=0){
						flag=true;
						alpha[i_n]=alpha[i_n]+learn;
						b=b+yData[i_n]*learn;
						textArea.append("\n"+(j++)+"\tx"+i_n+"\t");
						for(int i=0;i<num;i++){
							textArea.append(alpha[i]+"\t");
						}
						textArea.append(b+"");
						break;
					}
				}
			}
			inputField.setEditable(true);
			predictButton.setEnabled(true);
		}
	}
	
	public class PredictActionListener implements ActionListener {

		@Override
		public void actionPerformed(ActionEvent e) {
			// TODO Auto-generated method stub
			String[] s=inputField.getText().split(",");
			double[] x=new double[s.length];
			for(int i=0;i<dim;i++){
				x[i]=Double.parseDouble(s[i]);
			}
			if(multiply(w, x, b) <= 0){
				textArea.append("\n输入的x是反例");
			}else{
				textArea.append("\n输入的x是正例");
			}
		}

	}

	public double multiply(double[] w2, double[] ds, double b2) {
		// TODO Auto-generated method stub
		double sum = 0;
		for (i_d = 0; i_d < dim; i_d++) {
			sum = sum + w2[i_d] * ds[i_d];
		}
		return sum + b2;
	}

	public double multiply2(double[] alpha2, double[][] gram2, double b2,
			int i_n2) {
		// TODO Auto-generated method stub
		double sum=0;
		for(int i=0;i<num;i++){
			sum=sum+alpha2[i]*yData[i]*gram2[i_n2][i];
		}
		return sum+b2;
	}
}

package perceptron;

import java.awt.*;

import javax.swing.*;

public class PerceptronTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		EventQueue.invokeLater(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				JFrame frame=new PerceptronFrame();
				frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
				frame.setVisible(true);
			}
		});
	}

}



走投无路的乐乐
关注
专栏目录
机器学习——感知机模型
Bio大恐龙
03-07 3111
感知机模型的定义以及介绍，数学推导过程、代码实现感知机模型迭代过程。
机器学习之感知机模型
cug_humoumou的博客
07-22 6307
机器学习之感知机模型写在前面感知机模型的初步理解自我理解 写在前面 这部分主要是基于李航老师的《统计学习方法》以及参考部分博客完成，写出来让自己更好理解。 感知机模型的初步理解 感知机模型应该是机器学习中最简单的模型，是一种二分类的线性分类模型。感知机学习旨在求出将训练数据进行线性划分的超平面。 自我理解 以苹果为例子，现在我们面前有一堆苹果要卖，我们需要将苹果分成两部分，一部分又大又好看的，卖的贵一点，一部分又小又不好看的分为另一部分，卖的便宜点。对于我们来说，我们需要将两个，尽可能的分开，因为如果不好看
机器学习——感知机
zyz博客
10-31 8033
在本部分，我参考了网上多位博文对感知机的不同理解，大家可以根据自己的喜好进行对应的理解。输入为实例的特征向量，输出为实例的类别，取+1和-1；感知机对应于输入空间中将实例划分为正负两类的分离超平面，属于判别模型；导入基于误分类的损失函数；利用梯度下降法对损失函数进行极小化；感知机学习算法具有简单而易于实现的优点，分为原始形式和对偶形式；1957年由Rosenblatt提出，是神经网络与支持向量机的基础。感知机接收多个输入信号，输出一个信号。感知机的信号只有“流/不流”（1/0）两种取值。
机器学习之感知机算法原理及python实现
weixin_43509698的博客
09-13 4724
一、感知机的定义 感知机是二分类的线性分类模型，输入多个信号，输出一个信号（类别），属于判别模型。 二、感知机模型 感知机模型的公式： 其中w表示输入信号在模型公式中的权重，b输入信号在模型公式中的偏置，w•x表示w和x的内积。sign为激励函数，即激活函数： 感知机超平面的线性方程为： 为什么说w为超平面S的法向量？ 三、感知机的学习策略 假设训练数据是线性可分的，感知机的学习目标是求得一个能够将数据集正实例点和负实例点完全正确分开的超平面。为找出
机器学习之感知机python实现
小白进阶的博客
09-04 2757
机器学习之感知机python实现机器学习之感知机python实现 一 理论基础损失函数 更新参数 二 python实现代码 结果 一. 理论基础1. 损失函数L(w,b)=−∑i=0myi(wxi+b)L(w,b) = -\sum_{i = 0}^{m}{y_i(w x_i + b)}2. 更新参数w=w+α∑i=0mxiyiw = w + \alpha \sum_{i=0}^{m}{x_i y_i
机器学习-感知机
yiwenbin94的博客
03-11 2632
感知机可以说是最古老的分类方法之一了，在1957年就已经提出。他的思考方法就是在平面画出一条直线，或者在空间画出一个平面，或者可以推广到更高维的向量空间画一个超平面，将两种不同的东西分开。感知机模型虽然古老、简单、基础，但是原理很重要，下一步再学习支持向量机，进而再学习神经网络，深度学习。...
机器学习之感知机与梯度下降法认知
zc20161202005的博客
04-18 3201
感知机原理：        感知机是一种线性二分类模型，其目的是找到能将训练数据线性可分的分离超平面。对于数据集T                                                 来说，存在可将数据集线线性划分的超平面S：                                                                         ...
机器学习之感知机（Perceptron）模型
热门推荐
havefun00的博客
01-11 1万+
机器学习之Perceptron模型 本文主要介绍机器学习领域最为基础的模型，感知机模型： 1、感知机模型介绍 2、感知机数学原理 3、算法及Python代码实现 4、小结 1、感知机模型介绍 定义（感知机） 假设输入空间（特征空间）是，输出空间是Y={+1，-1}，输入表示实例的特征向量，对应于输入空间（特征空间）的点；输出表示实例的类别。由输入空间到输出空间的如下函数 ...
【机器学习】感知机Python代码实现
Daycym的博客
07-13 1万+
回顾 感知机 前面我们介绍了感知机，它是一个二分类的线性分类器，输入为特征向量，输出为实例的类别。感知机算法利用随机梯度下降法对基于误分类的损失函数进行最优化求解，得到感知机模型，即求解w,bw,bw,b。感知机算法简单易于实现，那么我们如何通过python代码来实现呢？ 接下来我们通过对我们给定的数据进行训练，得到最终的w,bw,bw,b，并将其可视化。 Python实现 impo...
机器学习-感知机模型实战
最新发布
02-11
在机器学习领域，感知机模型是一种基础且重要的线性分类算法。它的工作原理可以视为一个简单的神经网络，只有一个神经元，适用于二分类问题。在这个实战项目中，我们将深入理解感知机模型的理论基础，以及如何在...
Contrastive Loss，Triplet Loss
乐乐的博客
03-11 2278
孪生神经网络（siamese network）中，其采用的损失函数是contrastive loss，这种损失函数可以有效的处理孪生神经网络中的paired data的关系。contrastive loss的表达式如下： 其中d=||an−bn||2，代表两个样本特征的欧氏距离，y为两个样本是否匹配的标签，y=1代表两个样本相似或者匹配，y=0则代表不匹配，margin为设定的阈值。 ...
图片分类比赛总结
乐乐的博客
11-02 2120
0.拿到数据集后别急着建模型，先分析数据可视化数据。        在大多数机器学习任务中，我们首先要做的（也是最重要的任务）就是在使用算法之前分析数据集。这一步骤之所以重要，是因为它能够让我们对数据集的复杂度有深入的了解，这最终将有助于算法的设计。        因此，我决定使用 t 分布随机邻域嵌入（https://lvdmaaten.github.io/tsne/）可视化技术来查看图片的...
RANSAC
乐乐的博客
11-21 1681
        RANSAC为Random Sample Consensus的缩写，它是根据一组包含异常数据的样本数据集，计算出数据的数学模型参数，得到有效样本数据的算法。它于1981年由Fischler和Bolles最先提出 [1]  。         RANSAC算法经常用于计算机视觉中。例如，在立体视觉领域中同时解决一对相机的匹配点问题及基本矩阵的计算。         RANSAC算...
Windows64位下各版本Python安装numpy，SciPy，matplotlib，Ipython模块
乐乐的博客
07-13 1509
刚从Linux装回Windows，体会到了Linux下开发的各种便利后，回到Windows下安装几个Python模块都费了老大劲，写篇博客记录一下。我的系统是Windows64，安装的Python3.5      1、首先你得下载你所需要的各种.whl文件，我是在这里下载的http://www.lfd.uci.edu/~gohlke/pythonlibs/，这里面基本上啥都有。注意在下载的时候对
机器学习之预测数值型数据: 回归
乐乐的博客
07-06 1255
本文主要记录本人在学习机器学习过程中的相关代码实现，参考《机器学习实战》 from numpy import * import matplotlib.pyplot as plt def loadDataSet(fileName): numFeat=len(open(fileName).readline().split('\t'))-1 with open(fileName)
机器学习之使用FP-growth算法来高效发现频繁项集
乐乐的博客
07-07 582
本文主要记录本人在学习机器学习过程中的相关代码实现，参考《机器学习实战》 from numpy import * #构造简单测试数据 def loadSimpDat(): simpDat = [['r', 'z', 'h', 'j', 'p'], ['z', 'y', 'x', 'w', 'v', 'u', 't', 's'],
机器学习之使用Apriori算法进行关联分析
乐乐的博客
07-06 546
本文主要记录本人在学习机器学习过程中的相关代码实现，参考《机器学习实战》 from numpy import * def loadDataSet(): return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]] def createC1(dataSet): C1=[] for transaction in dataSet:
机器学习之利用K-均值聚类算法对未标注数据分组
乐乐的博客
07-06 496
本文主要记录本人在学习机器学习过程中的相关代码实现，参考《机器学习实战》from numpy import * def loadDataSet(fileName): dataMat=[] with open(fileName) as fr: for line in fr.readlines(): curLine=line.strip().s
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值