Python
算法伪码：
对未知类别属性的数据集中的每个点依次执行以下操作：
1)计算已知类别数据集中的点与当前点之间的距离；
2)按照距离递增次序排序；
3)选取与当前点距离最小的k个点；
4)确定前k个点所在类别的出现频率；
5)返回前k个点出现频率最高的类别作为当前点的预测分类。
欧氏距离计算：
(1)二维平面上两点xA(x1,y1)与xB(x2,y2)间的欧氏距离：
(2)三维空间两点xA(x1,y1,z1)与xB(x2,y2,z2)间的欧氏距离：
(3)两个n维向量xA(x11,x12,…,x1n)与 xB(x21,x22,…,x2n)间的欧氏距离：
算法实现如下：
1、评价指标
def createDataSet():
group = array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])
labels = ['A','A','B','B']
return group, labels
2、knn核心算法
#inX    要检测的数据
#dataSet  数据集
#labels    结果集
#k      要对比的长度
def classify0(inX, dataSet, labels, k):
dataSetSize = dataSet.shape[0]                #计算有多少行
# tile(inX, (dataSetSize,1))生成对应inX维度的矩阵，方便做差
diffMat = tile(inX, (dataSetSize,1)) - dataSet
sqDiffMat = diffMat**2                          #差求平方
sqDistances = sqDiffMat.sum(axis=1)            # axis=0, 表示列 axis=1, 表示行。
distances = sqDistances**0.5                  #开方
sortedDistIndicies = distances.argsort()      #argsort()排序，求下标
classCount={}
for i in range(k):
voteIlabel = labels[sortedDistIndicies[i]]  #通过下标索引分类
# 通过构造字典，记录分类频数
classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
# 对字段按值排序(从大到小)
sortedClassCount = sorted(classCount.items(),key=lambda classCount:classCount[1], reverse=True)
return sortedClassCount[0][0]
3、测试类
#测试
if __name__ == "__main__" :
dataset = array([[1.0, 1.1], [1.0, 1.0], [0.0, 0.0], [0.0, 0.1]])
labels = ['A', 'A', 'B', 'B']
X = [1.2, 1.1]
Y = [0.1, 0.1]
k = 3
labelX =  classify0(X,dataset,labels,k)
labelY =  classify0(Y,dataset,labels,k)
print ("Your input is:", X, "and classified to class: ", labelX)
print ("Your input is:", Y, "and classified to class: ", labelY )
结果：
Your input is: [1.2, 1.1] and classified to class:  A
Your input is: [0.1, 0.1] and classified to class:  B
4、注意
knn算法的开销很大,因为要计算每个样本点到其他所有点的距离.
knn算法的距离一般要根据实际样本点的情况来选取.
knn算法的距离阈值要根据样本的分散集中程度来选取.经验一般选取样本点集合的均方差.
matlab
5、任性matlab
没错，matlab就是这么任性只需要一行，其他都是读取数据
train_data=load('sample_feature.txt');
train_label=load('train_label.txt');
test_data=load('features.txt');
k=knnclassify(test_data,train_data,train_label,3,'cosine','random');
train_data保存的是训练样本特征，要求是最能代表本类别的，不一定多，当然不能太少；
train_label保存的是样本标号，如0,1,2等等，随便设置，只有能区分就行,具体格式可以为:
test_data测试文件保存的是测试数据的特征；
关键函数介绍：
knnclassify是利用最近邻进行分类的分类器；
函数调用形式：
1.CLASS = KNNCLASSIFY(SAMPLE,TRAINING,GROUP)
标号和训练数据必须有相同的行数；训练数据和测试数据必须有相同的列；函数对于无效值或者空值会作为丢失值或者忽略这一行。
2.CLASS = KNNCLASSIFY(SAMPLE,TRAINING,GROUP,K)
此函数允许你设置距离矩阵形式，如：
'euclidean'    欧氏距离，默认的
'cityblock'    绝对差的和
'cosine'     角度距离
'correlation' 相关距离
'Hamming'      汉明距离
3.CLASS =KNNCLASSIFY(SAMPLE,TRAINING,GROUP,K,DISTANCE,RULE)
本函数允许你选择如何对样本进行分类，如你可以选择：
'nearest'  最近的K个的最多数
'random'    随机的最多数
'consensus' 投票法，默认的
而我选择的函数形式是：
k=knnclassify(test_data,train_data,train_label,3,'cosine','random');

原理知道一百遍不如自己动手写一遍，当然，现在基本上不需要自己来写算法的底层code了，各路大神们已经为我等凡夫俗子写好了，直接调用就行。
这里介绍在MATLAB中和Python中应用贝叶斯算法的小例子。
一、 matlab实现朴素贝叶斯算法
先load matlab中自带的数据集fisheriris，数据集中每一个样本有两个特征，Y代表所属的类。
load fisheriris
X = meas(:,3:4);
Y = species;
tabulate(Y)%返回概率表格
接下来用朴素贝叶斯算法进行拟合，大家可以注意下matlab的机器学习算法的命名规则，都是以'fit'开头,中间一个字母'c’或者‘r’，c’代表是分类算法(classification)，'r’代表回归算法(regression)，后面的字母就是算法的通用名称。
以下是对X、Y进行拟合，指定Y变量中分类的名称分别为'setosa','versicolor'和'virginica'
Mdl = fitcnb(X,Y,'ClassNames',{'setosa','versicolor','virginica'})
Mdl =
ClassificationNaiveBayes
ResponseName: 'Y'
CategoricalPredictors: []
ClassNames: {'setosa'  'versicolor'  'virginica'}
ScoreTransform: 'none'
NumObservations: 150
DistributionNames: {'normal'  'normal'}
DistributionParameters: {3x2 cell}
这里返回了贝叶斯分类器的各种参数，包含分类名称、数据行数是否归一化等。
在matlab中，默认每一个特征的都符合高斯分布，拟合结果中也计算了每一个特征的均值和方差。
假如我们想看分类为‘setosa’类的X的第一个特征的均值和方差。
setosaIndex = strcmp(Mdl.ClassNames,'setosa');
estimates = Mdl.DistributionParameters{setosaIndex,1}
estimates =
1.4620
0.1737
均值是1.4620，方差是0.1737
接下来我们将拟合结果可视化，让大家更直观地感受拟合效果。
figure 打开一个新的画布
gscatter(X(:,1),X(:,2),Y);%画出散点图
h = gca;
cxlim = h.XLim;%获取x轴坐标
cylim = h.YLim; %获取y轴坐标
hold on
Params = cell2mat(Mdl.DistributionParameters);%获取高斯分布的参数
Mu = Params(2*(1:3)-1,1:2); % 提取均值列
Sigma = zeros(2,2,3);
for j = 1:3
Sigma(:,:,j) = diag(Params(2*j,:)).^2; % Create diagonal covariance matrix
xlim = Mu(j,1) + 4*[1 -1]*sqrt(Sigma(1,1,j));
ylim = Mu(j,2) + 4*[1 -1]*sqrt(Sigma(2,2,j));
ezcontour(@(x1,x2)mvnpdf([x1,x2],Mu(j,:),Sigma(:,:,j)),[xlim ylim])
% 绘制多元正态分布的等高线
end
h.XLim = cxlim;%设置X轴显示范围
h.YLim = cylim;%设置Y轴显示范围
title('Naive Bayes Classifier -- Fisher''s Iris Data')
xlabel('Petal Length (cm)')
ylabel('Petal Width (cm)')
hold off
默认情况下，先验类概率分布是根据数据集计算的各类的相对频率分布，在这种情况下，对于每个分类，其相对频率分布均为33%。但是假如你知道在总样本中50%的’ setosa’，20%是’versicolor’，30%’ ViGiCina’。你可以在训练分类器的时候指定先验概率。
prior = [0.5 0.2 0.3];
Mdl = fitcnb(X,Y,'ClassNames',classNames,'Prior',prior)%指定每一类的概率
使用10倍交叉验证估计两个模型的交叉验证误差。
rng(1); % For reproducibility
defaultCVMdl = crossval(defaultPriorMdl);
defaultLoss = kfoldLoss(defaultCVMdl)
CVMdl = crossval(Mdl);
Loss = kfoldLoss(CVMdl)
二、 Python(sklearn实现贝叶斯算法)
1. 利用GaussianNB类建立简单模型
import numpy as np
from sklearn.naive_bayes import GaussianNB
X = np.array([[-1, -1], [-2, -2], [-3, -3],[-4,-4],[-5,-5], [1, 1], [2,2], [3, 3]])
y = np.array([1, 1, 1,1,1, 2, 2, 2])
clf = GaussianNB() #默认priors=None
clf.fit(X,y)
GaussianNB(priors=None)
2. 经过训练集训练后，观察各个属性值
clf.priors #无返回值，因priors=None
clf.set_params(priors=[0.625, 0.375]) #设置priors参数值
GaussianNB(priors=[0.625, 0.375])
clf.priors #返回各类标记对应先验概率组成的列表
clf.class_count_ #获取各类标记对应的训练样本数
clf.sigma_ #获取各个类标记在各个特征上的方差
算法类文章我都会同期更新到个人公众号：宽客塔，欢迎关注~~
这个公众号以前是写金融类消息的，后来因为个人转行，就改为分享机器学习算法知识，也算是边学边写，跟大家共同学习~

原理知道一百遍不如自己动手写一遍，当然，现在基本上不需要自己来写算法的底层code了，各路大神们已经为我等凡夫俗子写好了，直接调用就行。
这里介绍在MATLAB中和Python中应用贝叶斯算法的小例子。
1、matlab实现朴素贝叶斯算法
先load matlab中自带的数据集
load fisheririsX = meas(:,3:4);Y = species;tabulate(Y)%返回概率表格
用朴素贝叶斯算法进行拟合，大家可以注意下matlab的机器学习算法的命名规则，都是以fit开头,中间一个字母'c'或者'r'， 'c'代表是分类算法(classification)，'r'代表回归算法(regression)，后面的字母就是算法的通用名称。
以下是对X、Y进行拟合，指定Y变量中分类的名称分别为'setosa', 'versicolor' 和 'virginica'
Mdl = fitcnb(X,Y,'ClassNames',{'setosa','versicolor','virginica'})
Mdl =   ClassificationNaiveBayes              ResponseName: 'Y'     CategoricalPredictors: []                ClassNames: {'setosa'  'versicolor'  'virginica'}            ScoreTransform: 'none'           NumObservations: 150         DistributionNames: {'normal'  'normal'}    DistributionParameters: {3x2 cell}这里返回了贝叶斯分类器的各种参数，包含分类名称、数据行数是否归一化等。
在matlab中，默认每一个特征的都符合高斯分布，拟合结果中也计算了每一个特征的均值和方差。
假如我们想看分类为'setosa'类的X的第一个特征的均值和方差。
setosaIndex = strcmp(Mdl.ClassNames,'setosa');estimates = Mdl.DistributionParameters{setosaIndex,1}estimates =
均值是1.4620，方差是0.1737
接下来我们将拟合结果可视化，让大家更直观地感受拟合效果。
figure 打开一个新的画布gscatter(X(:,1),X(:,2),Y);%画出散点图h = gca;cxlim = h.XLim;%获取x轴坐标cylim = h.YLim; %获取y轴坐标hold onParams = cell2mat(Mdl.DistributionParameters);%获取高斯分布的参数Mu = Params(2*(1:3)-1,1:2); % 提取均值列Sigma = zeros(2,2,3);for j = 1:3    Sigma(:,:,j) = diag(Params(2*j,:)).^2; % Create diagonal covariance matrix    xlim = Mu(j,1) + 4*[1 -1]*sqrt(Sigma(1,1,j));    ylim = Mu(j,2) + 4*[1 -1]*sqrt(Sigma(2,2,j));ezcontour(@(x1,x2)mvnpdf([x1,x2],Mu(j,:),Sigma(:,:,j)),[xlim ylim])% 绘制多元正态分布的等高线endh.XLim = cxlim;%设置X轴显示范围h.YLim = cylim;%设置Y轴显示范围title('Naive Bayes Classifier -- Fisher''s Iris Data')xlabel('Petal Length (cm)')ylabel('Petal Width (cm)')hold off
默认情况下，先验类概率分布是根据数据集计算的各类的相对频率分布，在这种情况下，对于每个分类，其相对频率分布均为33%。但是假如你知道在总样本中50%的'setosa'，20%是'versicolor'，30%是' ViGiCina’。你可以在训练分类器的时候指定先验概率。
prior = [0.5 0.2 0.3];Mdl = fitcnb(X,Y,'ClassNames',classNames,'Prior',prior)%指定每一类的概率
使用10倍交叉验证估计两个模型的交叉验证误差。
rng(1); % For reproducibilitydefaultCVMdl = crossval(defaultPriorMdl);defaultLoss = kfoldLoss(defaultCVMdl)CVMdl = crossval(Mdl);Loss = kfoldLoss(CVMdl)
2、Python(sklearn实现贝叶斯算法)
2.1 利用GaussianNB类建立简单模型.
import numpy as npfrom sklearn.naive_bayes import GaussianNBX = np.array([[-1, -1], [-2, -2], [-3, -3],[-4,-4],[-5,-5], [1, 1], [2,2], [3, 3]])y = np.array([1, 1, 1,1,1, 2, 2, 2])clf = GaussianNB()  #默认priors=Noneclf.fit(X,y)GaussianNB(priors=None)
2.2 经过训练集训练后，观察各个属性值
clf.priors  #无返回值，因priors=None
clf.set_params(priors=[0.625, 0.375])  #设置priors参数值GaussianNB(priors=[0.625, 0.375])clf.priors  #返回各类标记对应先验概率组成的列表clf.class_count_ #获取各类标记对应的训练样本数clf.sigma_#获取各个类标记在各个特征上的方差

遗传算法，(英文全称是genetic algorithm，GA)是一种非常经典的优化算法，是上个世纪60年代提出的，经过这么长时间的不断地改进，现在已经成为一个体系。原理就是模仿生物界中的进化方法，“物竞天择，适者生存”就是这个算法最好的概述。
遗传算法，简单来说就是，把一个非常具体的问题用数学言语(也就是数学公式)来描述清楚，比如找出对应问题合适的适应度函数和对应的目标状态集合；
再把问题的参数(x,y,z,i,h,l 这样的参数)进行编码，也就是把这些参数二进制化(比如 X=8,就是表示成1000)，这些由0和1组成的组合串就被称为染色体(也可以说成个体)，这种组合成染色体的1和0 就是基因。这每一个染色体也可以理解为这个问题的一个解，只不过不一定是最优解，遗传算法就是通过一些接下来的操作来找出问题的最优解。
由一定数量的个体，就组成了群体，这个群体就叫：种群，这个群体内部的个体数量就叫：种群大小，也可以叫成：种群规模。
这个群体在算法刚开始进行的时候就是随机从问题参数中进行选取出来的，先计算每个个体对应的适应度函数值，之后就是根据这个计算值，进行排序。
按照排序的高低，一般视适应度函数和目标状态而定，如果需要适应度函数值最小，那么就是计算值越小越好，反之也是同样的道理。
算法进行到这里，就是整个遗传算法的最重要的地方了。整个遗传算法的精髓可以说是：复制、交叉、变异。
把排名最好的那几个计算值挑出来，他们对应的个体，也就是染色体不要变，原样的ctrl + C，ctrl+V到下一代的种群中。
排名靠前但是不是前几名的计算值也挑出来，他们个体的二进制数的对应的位数，进行交叉的操作，其实就是把我的数给你，你的数再给我，就是相互交换，这样就会产生新的个体，这样也进入下一代新的种群中去。
剩下的就是排名最差的计算值，他们所对应的个体就需要进行变异的操作，所谓的变异，就是把这些个体的二进制数的对应位数上的0和1，进行变换，比如说原来第2位上是0，现在就要变成1，这样操作过后，也会产生新的个体进入到下一代新的种群去。
就是经过了：复制、交叉、变异，这三个核心操作之后，一个新的种群诞生了，就可以开始新的一轮上述的操作了。这就是迭代的过程。
最经典的遗传算法，是在算法最开始的地方设置：最大迭代数，每一次迭代，迭代计数器就会自动加一，再判断是否达到最大迭代数，达到之后，整个算法就会退出循环，按照最后一代的种群的计算值的最优解，将其视为整个问题的最优解。
我之前也上传过遗传算法的讲解视频。链接如下：知乎视频​www.zhihu.com
下面，通过一个非常简单的小栗子来从代码的角度说明以上思路。
问题：简单的一元函数优化，利用遗传算法来寻找一下函数的最小值
首先是利用matlab代码来进行解释说明。运行本代码需要事先安装谢非尔得大学的matlab遗传算法工具箱
clc
clear all
close all
%% 画出函数图
figure(1);
hold on;
lb=1;ub=2; %函数自变量范围【1,2】
ezplot('sin(10*pi*X)/X',[lb,ub]);   %画出函数曲线
xlabel('自变量/X')
ylabel('函数值/Y')
%% 定义遗传算法参数
NIND=40;        %个体数目
MAXGEN=20;      %最大遗传代数
PRECI=20;       %变量的二进制位数
GGAP=0.95;      %代沟
px=0.7;         %交叉概率
pm=0.01;        %变异概率
trace=zeros(2,MAXGEN);                        %寻优结果的初始值
FieldD=[PRECI;lb;ub;1;0;1;1];                      %区域描述器
Chrom=crtbp(NIND,PRECI);                      %初始种群
%% 优化
gen=0;                                  %代计数器
X=bs2rv(Chrom,FieldD);                 %计算初始种群的十进制转换
ObjV=sin(10*pi*X)./X;        %计算目标函数值
while gen
FitnV=ranking(ObjV);                               %分配适应度值
SelCh=select('sus',Chrom,FitnV,GGAP);              %选择
SelCh=recombin('xovsp',SelCh,px);                  %重组
SelCh=mut(SelCh,pm);                               %变异
X=bs2rv(SelCh,FieldD);               %子代个体的十进制转换
ObjVSel=sin(10*pi*X)./X;             %计算子代的目标函数值
[Chrom,ObjV]=reins(Chrom,SelCh,1,1,ObjV,ObjVSel);      %重插入子代到父代，得到新种群
X=bs2rv(Chrom,FieldD);                           %计算种群的十进制转换
gen=gen+1;                                             %代计数器增加
[Y,I]=min(ObjV);                              %获取每代的最优解及其序号，Y为最优解,I为个体的序号
trace(1,gen)=X(I);                            %记下每代的最优值
trace(2,gen)=Y;                               %记下每代的最优值
end
plot(trace(1,:),trace(2,:),'bo');                            %画出每代的最优点
grid on;
plot(X,ObjV,'b*');   %画出最后一代的种群
hold off
%% 画进化图
figure(2);
plot(1:MAXGEN,trace(2,:));
grid on
xlabel('遗传代数')
ylabel('解的变化')
title('进化过程')
bestY=trace(2,end);
bestX=trace(1,end);
fprintf(['最优解:\nX=',num2str(bestX),'\nY=',num2str(bestY),'\n'])
这篇文章是我第一次尝试用大白话来讲讲这个遗传算法，可能其中会有一些不太严谨或者我理解错误的地方，希望读者有思考和收获，若发现错误，可以指出，也欢迎讨论交流。