精华内容
下载资源
问答
  • BP神经网络的Matlab实现——人工智能算法

    万次阅读 多人点赞 2018-01-27 23:07:23
    这几天在各大媒体上接触到了人工智能机器学习,觉得很有意思,于是开始入门最简单的机器算法——神经网络训练算法(Neural Network Training);以前一直觉得机器学习很高深,到处是超高等数学、线性代数、数理统计。...

    这几天在各大媒体上接触到了人工智能机器学习,觉得很有意思,于是开始入门最简单的机器算法——神经网络训练算法(Neural Network Training);以前一直觉得机器学习很高深,到处是超高等数学、线性代数、数理统计。入坑发现确实是这样!但是呢由项目实例驱动的学习比起为考试不挂科为目的的学习更为高效、实用!在遗传算法、神经网络算法的学习入门之后觉得数学只要用心看没问题的(即使是蒙特卡洛和马尔科夫问题),但是呢需要把数学统计应用到程序中,来解决实际的问题这是两码事。主要呢还是需要动手打代码。下面呢是今天的机器学习之神经网络学习入门记录篇,希望帮助到同样入门采坑的哥们,一起进步!

    一、主题闲扯

    神经网络学习-顾名思义,就是类似我们人类的学习方式,通过模拟神经元的活动,在神经系统中进行信息处理、存储记忆和反馈的生物机理功能。其实这样是机器学习算法的共性吧,所有的智能算法都是善于发现生活中的常见情节推广到计算仿真的范畴,例如:遗传算法、烟花算法、蚁群算法、模拟退火算法等等。
    神经网络学习是人工智能领域的基本算法之一,它是在1943年被心理学家McCulloch和数学家Pitts合作提出的数学模型。并在之后不断完善发展到今天的。它的主要应用领域涉及到模式识别、智能机器人、非线性系统识别、知识处理等。

    二、算法理论

    2.1、人工神经元模型
    神经元模型

    这里我们先解释一下机器学习的一些特性,总体来说呢,机器学习的核心就是学习。这个学习过程呢就是通过已知来训练机器。比如:我们通过大量的青蛙图像数据样本来进行输入训练算法,使得我们给这个程序算法一张新的青蛙图像,它能利用训练数据的学习来判断我们新给它的图像数据是青蛙。所以呢,机器学习算法来说就是通过输入变量到算法,算法通过分析反馈进行判断,最后做出结果。
    在上图中是简化的神经元模型,我们的Xi是一系列的输入变量,对应在其箭头方向上的是一个权重系数。权重系数呢是为了消除样本数据的偏差,通常是一个rand函数在0-1之间的取值。通过输入变量Xi和其自己的权重系数Wi的乘积的求和输入到神经元上。此时神经元得到了输入变量和其权重的乘积累加和。通过映射函数F(x)来进行映射得到结果。以上就是一个简单的神经元模型和信息传递过程。
    这里写图片描述

    也可以简化成下面的数学推导公式:我们可以把输入变量和对应权重变换成矩阵相乘,这在Matlab中的运算时是十分有利的。
    这里写图片描述

    对于以上的输入变量和对应权重值我们很容易处理,但是这个模型的核心是基于激活函数F(x)的,下面是我们常见的一些激活函数:
    激活函数

    2.2、神经网络模型
    我们的神经网络是由若干的神经元连接而成的,我们常见的模型分类为:
    1、连接方式:前向神经网络和递归神经网络*(反馈神经网络)
    2、训练方式:监督式学习和非监督式学习
    3、按照实现功能:拟合(回归)神经网络 vs. 分类神经网络

    2.3、BP(反向传递)神经网络概述:
    概述、
    1、Backpropagation is a common method of teaching artificial neural networks how to
    perform a given task.
    2、It is a supervised learning method, and is a generalization of the delta rule. It
    requires a teacher that knows, or can calculate, the desired output for any input in
    the training set.
    3、 Backpropagation requires that the activation function used by the artificial neurons
    (or “nodes”) be differentiable

    算法学习过程
    Phase 1:神经传递
    1. 通过神经网络进行训练模式输入的向前传播以产生传播的输出激活。
    2. 训练模式中通过神经网络对传播的输出激活进行反向传播,目标是生成所有输出和隐藏神经元的增量以便进行反馈调整。
    Phase 2: 权值更新
    1. 用它的输出增量和输入激活变量来得到权重的梯度。
    2. 通过从权重中减去它的比例来使权重朝着相反的梯度方向移动(最小梯度法)。

    算法递进过程图解:(Source:)
    该项目描述了利用反向传播算法实现多层神经网络的教学过程。为了说明这一过程,有两个输入和一个输出的三层神经网络,如下图所示:
    这里写图片描述

    1、每个神经元由两个单位组成。第一个单元添加权重系数和输入信号,第二个单元实现非线性功能,称为神经元激活功能。信号e是加法器输出信号,y=f(e)是非线性元件的输出信号。信号y也是神经元的输出信号。如下图:
    这里写图片描述

    2、为了训练神经网络,我们需要训练数据集。训练数据集由输入信号(x1和x2)组成,并分配相应的目标(期望输出)z。网络训练是一个迭代的过程。在每个迭代中权重系数的节点使用新的训练数据集的数据被修改。修改计算使用下面描述的算法:每个教学步骤开始迫使这两个输入信号从训练集,在这个阶段我们可以确定每个网络层中的每个神经元的输出信号值。下面的图片说明了信号是如何传播的。
    这里写图片描述
    同理如下:
    这里写图片描述

    这里写图片描述

    3、通过隐藏层传播信号。符号wmn表示下一层神经元的输出和神经元n的输入之间的连接。
    这里写图片描述

    这里写图片描述

    4、通过输出层传播信号
    这里写图片描述

    5、在接下来的算法步骤中,将网络y的输出信号与期望的输出值(目标)进行比较,在训练数据集中找到了输出信号。这种差异被称为输出层神经元的错误信号d。
    这里写图片描述

    6、直接计算内部神经元的错误信号是不可能的,因为这些神经元的输出值是未知的。多年来,多人网络训练的有效方法一直是未知的。只有在80年代中期,反向传播算法才被设计出来。这个想法是将错误信号d(在单个教学步骤中计算)返回给所有神经元,输出信号是被讨论神经元的输入信号。
    这里写图片描述

    这里写图片描述

    7、用于传播错误的权重系数,等于在计算输出值时使用的系数。只有数据流的方向被改变(信号从一个输出到另一个输入)。该技术适用于所有网络层。如果传播错误来自少数神经元,它们就会被添加。下面的例子是:
    这里写图片描述

    这里写图片描述

    这里写图片描述

    8、当计算每个神经元的错误信号时,可以修改每个神经元输入节点的权重系数。在下面的公式中,df(e)/de代表了神经元激活功能的导数(权重被修改)。
    这里写图片描述

    这里写图片描述

    这里写图片描述

    这里写图片描述

    这里写图片描述

    这里写图片描述

    8、系数h(罗马字符学习因子)影响网络训练速度。有一些技术可以选择这个参数。第一种方法是用参数的大值开始教学过程。当权重系数被确定时,参数正逐渐减少。第二种,更复杂的方法,开始以小的参数值教学。在教学过程中,在教学过程中,在教学过程中增加了参数,在最后阶段又减少了。以较低的参数值启动教学过程,可以确定权重系数的符号。

    插入重点:有导师学习的神经网络状态:

    有导师学习状态简而言之就是对输入的训练集,可以根据网络中的实际输出与期望输出之间的误差来反向调整个连接权值的学习方法。其主要步骤如下:

    1. 从样本数据中随机性的选取一个样本数据{Ai,Bi},其中Ai是输出,Bi是期望输出
    2. 通过训练得出实际输出Oi
    3. 求误差D = Bi - Oi
    4. 根据步骤3得到的误差D,来调整各隐含层之间连接权值
    5. 对,每个样本重复用以上步骤,直到对整体样本数据来说,误差收敛到控制范围内为止。

    有导师学习算法:Delta学习规则
    Delta是一种简单的经典有导师算法规则。根据实际输出与期望输出的差别;来调整连接权。其数学表达:
    这里写图片描述

    在上述公式中,Wij表示的是神经元 i 到 j之间的连接权di是神经元i的期望输出Yi是神经元 i 的实际输出**。Xj是神经元的状态。,如果是激活状态则为**1,否则为0或者-1
    通过神经元j的实际输出与期望值比较取值,我们可以知道Delta的本质,就是如果实际输出大于期望输出(di - yi)为负数,就是减小所有输入为正的连接权值。增大输入为负的权值。反之,如果实际输出小与期望输出。则增大输入为正的连接权值,减小输入为负的连接权值。


    2.4、数据归一化
    什么是归一化?
    将数据映射到[0, 1]或[-1, 1]区间或其他的区间。

    为什么要归一化?
    1. 输入数据的单位不一样,有些数据的范围可能特别大,导致的结果是神经网络收敛慢、训练时间长。
    2. 数据范围大的输入在模式分类中的作用可能会偏大,而数据范围小的输入作用就可能会偏小。
    3. 由于神经网络输出层的激活函数的值域是有限制的,因此需要将网络训练的目标数据映射到激活函数的值域。例如神经网络的输出层若采用S形激活函数,由于S形函数的值域限制在(0,1),也就是说神经网络的输出只能限制在(0,1),所以训练数据的输出就要归一化到[0,1]区间。
    4. S形激活函数在(0,1)区间以外区域很平缓,区分度太小。例如S形函数f(X)在参数a=1时,f(100)与f(5)只相差0.0067

    归一化算法
    1、这里写图片描述
    其中min为x的最小值,max为x的最大值,输入向量为x,归一化后的输出向量为y。上式将数据归一化得到[0,1]区间,当激活函数采用S形函数时(值域为(0,1))时这条公式适用。
    2、这里写图片描述
    这条公式将数据归一化到[-1, 1]区间。当激活函数采用双极S形函数(值域为(-1,1))时,该公式适用。

    归一化算法重点知识函数:
    几个要说明的函数接口:

    [Y,PS] = mapminmax(X)
    [Y,PS] = mapminmax(X,FP)
    Y = mapminmax('apply',X,PS)
    X = mapminmax('reverse',Y,PS)

    用实例来讲解,测试数据 x1 = [1 2 4], x2 = [5 2 3];

    >> [y,ps] = mapminmax(x1)
    y =
       -1.0000   -0.3333    1.0000
    
    ps = 
          name: 'mapminmax'
         xrows: 1
          xmax: 4
          xmin: 1
        xrange: 3
         yrows: 1
          ymax: 1
          ymin: -1
        yrange: 2

    其中y是对进行某种规范化后得到的数据,这种规范化的映射记录在结构体ps中.让我们来看一下这个规范化的映射到底是怎样的?

    y = (ymax-ymin)*(x-xmin)/(xmax-xmin) + ymin;
    [关于此算法的一个问题.算法的假设是每一行的元素都不想相同,那如果都相同怎么办?实现的办法是,如果有一行的元素都相同比如xt = [1 1 1],此时xmax = xmin = 1,把此时的变换变为y = ymin,matlab内部就是这么解决的.否则该除以0了,没有意义!]

    也就是说对x1 = [1 2 4]采用这个映射 f: 2*(x-xmin)/(xmax-xmin)+(-1),就可以得到y = [ -1.0000 -0.3333 1.0000]
    我们来看一下是不是: 对于x1而言 xmin = 1,xmax = 4;
    则y(1) = 2*(1 - 1)/(4-1)+(-1) = -1;
    y(2) = 2*(2 - 1)/(4-1)+(-1) = -1/3 = -0.3333;
    y(3) = 2*(4-1)/(4-1)+(-1) = 1;

    看来的确就是这个映射来实现的.
    对于上面algorithm中的映射函数 其中ymin,和ymax是参数,可以自己设定,默认为-1,1;

    比如:

    >>[y,ps] = mapminmax(x1);
    >> ps.ymin = 0;
    >> [y,ps] = mapminmax(x1,ps)
    y =
             0    0.3333    1.0000
    
    ps = 
          name: 'mapminmax'
         xrows: 1
          xmax: 4
          xmin: 1
        xrange: 3
         yrows: 1
          ymax: 1
          ymin: 0
        yrange: 1

    则此时的映射函数为: f: 1*(x-xmin)/(xmax-xmin)+(0)

    如果我对x1 = [1 2 4]采用了某种规范化的方式, 现在我要对x2 = [5 2 3]采用同样的规范化方式[同样的映射],如下可办到:

    >> [y1,ps] = mapminmax(x1);
    >> y2 = mapminmax('apply',x2,ps)
    y2 =
        1.6667   -0.3333    0.3333

    即对x1采用的规范化映射为: f: 2*(x-1)/(4-1)+(-1),(记录在ps中),对x2也要采取这个映射.
    x2 = [5,2,3],用这个映射我们来算一下.

    y2(1) = 2(5-1)/(4-1)+(-1) = 5/3 = 1+2/3 = 1.66667
    y2(2) = 2(2-1)/(4-1)+(-1) = -1/3 = -0.3333
    y2(3) = 2(3-1)/(4-1)+(-1) = 1/3 = 0.3333

    X = mapminmax(‘reverse’,Y,PS)的作用就是进行反归一化,讲归一化的数据反归一化再得到原来的数据:

    >> [y1,ps] = mapminmax(x1);
    >> xt = mapminmax('reverse',y1,ps)
    xt =
         1     2     4

    此时又得到了原来的x1(xt = x1);

    **

    三、神经网络参数定义以及对BP神经网络性能的影响

    **
    常见的训练函数:
    训练方法 训练函数
    梯度下降法 traingd
    有动量的梯度下降法 traingdm
    自适应lr梯度下降法 traingda
    自适应lr动量梯度下降法 traingdx
    弹性梯度下降法 trainrp
    Fletcher-Reeves共轭梯度法 traincgf
    Ploak-Ribiere共轭梯度法 traincgp
    Powell-Beale共轭梯度法 traincgb
    量化共轭梯度法 trainscg
    拟牛顿算法 trainbfg
    一步正割算法 trainoss
    Levenberg-Marquardt trainlm

    神经网路学习的参数:
    训练参数 参数介绍
    net.trainParam.epochs 最大训练次数(缺省为10)
    net.trainParam.goal 训练要求精度(缺省为0)
    net.trainParam.lr 学习率(缺省为0.01)
    net.trainParam.max_fail 最大失败次数(缺省为5)
    net.trainParam.min_grad 最小梯度要求(缺省为1e-10)
    net.trainParam.show 显示训练迭代过程(NaN表示不显示,缺省为25)
    net.trainParam.time 最大训练时间(缺省为inf)
    net.trainParam.mc 动量因子(缺省0.9)
    net.trainParam.lr_inc 学习率lr增长比(缺省为1.05)
    net.trainParam.lr_dec 学习率lr下降比(缺省为0.7)
    net.trainParam.max_perf_inc 表现函数增加最大比(缺省为1.04)
    net.trainParam.delt_inc 权值变化增加量(缺省为1.2)
    net.trainParam.delt_dec 权值变化减小量(缺省为0.5)
    net.trainParam.delt0 初始权值变化(缺省为0.07)
    net.trainParam.deltamax 权值变化最大值(缺省为50.0)
    net.trainParam.searchFcn 一维线性搜索方法(缺省为srchcha)
    net.trainParam.sigma 因为二次求导对权值调整的影响参数(缺省值5.0e-5)
    net.trainParam.lambda Hessian矩阵不确定性调节参数(缺省为5.0e-7)
    net.trainParam.men_reduc 控制计算机内存/速度的参量,内存较大设为1,否则设为2(缺省为1)
    net.trainParam.mu u的初始值(缺省为0.001)
    net.trainParam.mu_dec u的减小率(缺省为0.1)
    net.trainParam.mu_inc u的增长率(缺省为10)
    net.trainParam.mu_max u的最大值(缺省为1e10)

    神经网络学习主要函数说明
    newff:前馈网络创建函数
    语法:
    net = newff(A,B,{C},’trainFun’,’BLF’,’PF’)。
    A:一个n*2的矩阵,第i行元素为输入信号Xi的最大最小值
    B:一个K维行向量,其元素为网络中各个节点的数量。
    C:一个K维字符串行向量,每一个分量为对应层的神经元的激活函数,默认为“tansig”
    trainFun:为学习规则的采用的训练算法。默认为:“trainlm”
    BLF:BP权值/偏差学习函数。默认为:“learngdm”
    PF:性能函数,默认为“mse”

    train函数
    语法:
    即网络学习函数:
    [net,tr,YI,E] = train(net,X,Y)
    X:网络实际输入
    Y:网络应有输出
    tr:网络跟踪信息
    YI:网络实际输出
    E:误差矩阵

    sim函数
    **语法:**Y = sim(net,X)
    X:输入给网络的K*N矩阵,K为网络输入个数,N为样本数据量
    Y:输出矩阵Q*N,其中Q为网络输出个数

    四、实例解读:

    利用三层BP神经网络来完成非线性函数的逼近任务,其中隐层神经元个数为五个。
    样本数据:
    这里写图片描述

    代码如下:

    clear;
    clc;
    X=-1:0.1:1;
    D=[-0.9602 -0.5770 -0.0729 0.3771 0.6405 0.6600 0.4609...
        0.1336 -0.2013 -0.4344 -0.5000 -0.3930 -0.1647 -.0988...
        0.3072 0.3960 0.3449 0.1816 -0.312 -0.2189 -0.3201];
    figure;
    plot(X,D,'*'); %绘制原始数据分布图
    net = newff([-1 1],[5 1],{'tansig','tansig'});
    net.trainParam.epochs = 100; %训练的最大次数
    net.trainParam.goal = 0.005; %全局最小误差
    net = train(net,X,D); 
    O = sim(net,X); 
    figure; 
    plot(X,D,'*',X,O); %绘制训练后得到的结果和误差曲线
    V = net.iw{1,1}%输入层到中间层权值
    theta1 = net.b{1}%中间层各神经元阈值
    W = net.lw{2,1}%中间层到输出层权值
    theta2 = net.b{2}%输出层各神经元阈值

    最后得到结果:
    这里写图片描述

    **

    五、学习总结

    **
    通过神经网络的学习入门,发现机器学习的共性和乐趣;由浅入深、循序渐进。虽然看起来很是晦涩难懂。但是一门心思钻进去,最后做出实例是一种巨大的喜悦和自豪。从中得到知识的喜悦和探索规律的满足。
    总结神经网络:
    1、导入需要处理的数据。
    2、对数据进行打乱,随机获取实验数据和目标数据。(其中包括归一化:mapminmax)
    3、构建一个训练网络:newwff
    4、对构建的网络进行训练:train
    5、进行数据仿真操作sin(net,x)
    6、验证和后评价
    7、绘图直观的显示数据模拟训练的效果。
    在上面的神经网络训练中,我们要清楚构建神经网络的实验数据和目标收敛数据都是从原始数据中随机获取的。

                                 **By:wangyun 2018-01-28 11:01:57**
    
    展开全文
  • 人工智能算法

    2012-03-09 14:05:32
    人工智能算法,例如遗传算法,回溯思想,驿群算法
  • 人工智能算法 UCSD的COGS 188,人工智能算法的分配 作业: 作业1:感知器和KNN 作业2:K均值和期望最大化(EM)算法作业3:遗传算法(待完成) 其他: KNN句子嵌入:使用KNN的情感分析
  • 如何成为一名AI人工智能算法工程师?.pdf
  • AI算法实现及应用

    2021-06-14 08:34:20
    该课程主要介绍了如何利用常见的人工智能算法实现AI算法,同时将其应用到项目开发中,常用的AI算法有:AI行为树,FSM,基于脚本,基于感知的等等,课程讲解了很多AI算法,这些算法都有相关案例展示。也是解决AI算法...
  • 人工智能算法缺陷与伦理安全,人工智能算法缺陷与伦理安全 人工智能算法缺陷与伦理安全 人工智能算法缺陷与伦理安全 人工智能算法缺陷与伦理安全 人工智能算法缺陷与伦理安全 人工智能算法缺陷与伦理安全 人工智能...
  • 胡牌算法以及AI算法

    2021-01-30 00:01:07
    胡牌算法以及AI算法
  • 如何成为一名AI人工智能算法工程师?

    万次阅读 多人点赞 2019-06-30 12:25:21
    经常有朋友私信问,如何学python呀,如何敲代码呀,如何进入AI行业呀? ...正好回头看看自己这一年走过的路,进行一次经验总结。...人工智能/机器学习/深度学习 自学如何寻找学习资料 如何选择编...

    https://www.toutiao.com/a6707050434688713227/

     

    如何成为一名AI人工智能算法工程师?

     

    经常有朋友私信问,如何学python呀,如何敲代码呀,如何进入AI行业呀?

    正好回头看看自己这一年走过的路,进行一次经验总结。

    来看看你距离成为一名AI工程师还有多远吧~

    ⭐具体内容:

    我是因为什么开始接触敲代码

    人工智能/机器学习/深度学习

    自学如何寻找学习资料

    如何选择编程语言/框架

    校招/社招/实习/面试经验

    一碗鸡汤

    ⭐声明:

    本篇内容均属于个人观点,建议采纳对自己有用的经验,如有疏漏,欢迎指正,共同进步!

    2017年5月开始第一份实习 / 2017年7月开始学敲代码 / 2017年11月硕士毕业

    擅长的编程语言:R / Python

    不花钱报班,全靠自学,最初是因为穷,后来发现“开源”的世界真是太美好了!

    如何成为一名AI人工智能算法工程师?

     

    我是因为什么开始接触敲代码?

    我的第一个模型是什么

    由于本科是数学,研究生是量化分析,第一份实习是一家金融科技公司,开始接触所谓的“Fintech”

    第一个任务就是做客户的信用评分卡模型,目的给每个用户打一个信用分数,类似支付宝的芝麻信用分。这是银行标配的一个模型,最常见最传统的算法用的就是逻辑回归

    在课堂上使用的工具是SAS,SPSS,属于有操作界面的,菜单非常齐全,只需要鼠标点一点就能建模,很好上手。但是SAS这些要付钱的,年费还是相当的贵,所以深圳大部分公司进行数据分析和建模工作都选择开源免费的R语言或者Python。这就体现了掌握一门编程语言的重要性。

    虽然说是建模任务,但是前三个月跟建模基本都扯不上边。都在做数据清洗,表格整理(摊手),都在library各种包,用的最多的可能是data.table和dplyr。没办法,很多模型都有包可以直接调用,是最简单的环节了。其实一开始,我一直在犯很低级的错误,各种报错,没有library啦,标点符号没打对啦,各种很low的错误犯了一次又一次,而且连报错的内容都不会看,不知道怎么去改正。如果你也像我一样,真的请不要灰心,我就是这样走过来的。对着错误一个个去解决就好了~

    当时什么都不知道的时候,觉得真难呀,每个环节都有那么多细节要照顾,要学的那么多,做完一个还有一个,还要理解业务含义。但是当完整的做一遍之后再回头,就会觉得,其实,也没那么难嘛~

    如何成为一名AI人工智能算法工程师?

     

    敲代码容易吗?

    因为我不是计算机专业的,所以基本上属于没怎么敲过代码的那种。

    后来发现程序员也有好多种类的,前端后端等,因此敲的代码种类也很多,才会有几十种的编程语言,下图是一些这几年的主流语言。

    如何成为一名AI人工智能算法工程师?

     

    实习时我一直被队友嫌弃很蠢,而且一开始敲的东西怎么也运行不通,运行出来的都是鬼结果。有n次想放弃的念头,“我干嘛一定要敲这玩意儿?”,但也有n+1次想坚持的理由,因为我真的喜欢我正在做的事。为什么用“坚持”,因为真的不容易。不难,但真的需要有耐心。

    一开始我的状态就是一行行代码的运行,一个个命令的熟悉,反复看,反复运行。

    • 从敲出第一行代码到敲出第一个完整的模型花了3个月
    • 学习XGBoost,光是理论学了3个月,因为前期铺垫要学的还有adaboost/gbdt和各种机器学习的知识模块
    • 从R切换到python花了1个月
    • 从机器学习(Machine Learning)切换到自动机器学习(Auto Machine Learning)花了2个月
    • 从NLP零基础到搭建一个智能问答机器人花了1个月

    从一年前的“什么是过拟合,什么是交叉检验,损失函数有哪些”到后来参加全球人工智能峰会时都能听懂的七七八八,会觉得,努力没有白费呀!

    如何成为一名AI人工智能算法工程师?

     

    可以看出,经过前面的积累,后面会学的越来越快。

    慢慢的就从一开始的那种“唉,怎么又报错啊,好挫败”的心态变成现在的“啊?没error?感觉不对啊,再查验一遍吧”这种抖M倾向的人。代码虐我千百遍,我已经被磨的没有了脾气。

    已经有几个朋友说想转行了,我何曾没想过,只是不知不觉中坚持了下来而已。因为热爱,越虐越停不下来

    小结

    设定一个非常清晰的目标

    为什么第一个写:“我是因为什么开始敲代码的”,因为动机真的非常重要!

    所以,很多人在问我“如何学python?”这种问题时,我的第一回答都是“你学python用来干嘛?”

    在学校也敲打过python,做个爬虫demo什么的,因为目的性不强没多久就放一边了。清晰的目标就比如说你要做NLP,你要知道NLP的应用有智能问答,机器翻译,搜索引擎等等。然后如果你要做智能问答你要知道现在最发达的技术是深度学习,使用的算法有RNN/LSTM/Seq2Seq/等等一系列。而我的清晰目标是在实习的时候给我的任务。当任务很明确的时候,所需要的语言就明确了,所要学习的算法也就明确了,很多东西就顺理成章了不用一头乱撞了。

    从金融到科技

    AI的应用范围很广,每一个研究方向都是无穷尽的。由于金融公司很少与图像处理,NLP等技术会有交集,而我强大的好奇心让我决定去纯粹的科技公司一探究竟。目前已投身于智能家居,目标是Javis

    人工智能/机器学习/深度学习

    我经常在公交的广告牌上看见这些词,好像哪家公司没有这个技术就落后了似的。更多的还有强化学习,迁移学习,增量学习等各种学习。

    这些词儿之间到底什么关系

    机器学习是人工智能的一种,深度学习是机器学习的一种。学AI先学机器学习

    如何成为一名AI人工智能算法工程师?

     

    计算机的“算法” 与 数学的“算法” 的区别

    理论知识对于AI算法工程师极其重要。敲代码只是思路的一个实现过程。这里的“算法”和计算机CS的“算法”还不太一样,AI算法是偏数学推导的,所以数学底子还是需要点的,学的越深,要求越高。面试的时候,很少让手写代码,90%都是在问模型抠算法细节。

    在学校我是一个不爱记笔记的人,甚至是一个不爱上课的人。但是自从入了机器学习的坑后,笔记写的飞起~

    如何成为一名AI人工智能算法工程师?

     

    如何成为一名AI人工智能算法工程师?

     

    机器学习的框架

    按照数据集有没有Y值可以将机器学习分为监督学习、半监督学习和无监督学习。监督学习是分类算法,无监督学习是聚类算法。

    如何成为一名AI人工智能算法工程师?

     

    机器学习的通用流程和相关技术如下图:

    如何成为一名AI人工智能算法工程师?

     

    ML这棵树还可以有更多的分支。先有个整体感受,再一个一个的解决掉。这里的知识点也是面试最爱问的几个,是重点呀!面试过的同学应该都不陌生了。

    机器学习如何入门

    机器学习之大,初学者都无从下手。说白了,机器学习就是各种模型做预测,那么就需要有数据,要想有好的效果,就要把原始的脏数据洗干净了才能用。数据内隐藏的信息有时候是肉眼不可见的,那么就需要一些相关技巧来把有用信息挖出来。所有绞尽脑汁使用的技巧,都是为了能预测的更准确。但是谁也没办法做到百分百的命中。

    这里简单介绍下机器学习的三大块:传统的机器学习ML、图像处理CV、自然语言处理NLP

    再推荐一个入门神器:

    Kaggle(www.kaggle.com)

    这是一个世界级的最权威的机器学习比赛,已被谷歌收购。上面的赛题不仅很有代表性,还有很多免费的优秀的数据集供你使用,要知道收集数据是机器学习的第一大难题,它就帮你解决了。入门不用立马参加比赛,把数据下载下来,尽情折腾就好了,要是没有思路,去网上搜别人的解题笔记和代码借鉴一下也很美好~因为这是大家都争相打榜的比赛,所以你并不孤单。

    ML入门该参加的赛题(Titanic)

    如何成为一名AI人工智能算法工程师?

     

    图像入门该参加的赛题(数字识别)

    如何成为一名AI人工智能算法工程师?

     

    NLP入门该参加的赛题(情感分析、quora问句语义匹配)

    如何成为一名AI人工智能算法工程师?

     

    如何成为一名AI人工智能算法工程师?

     

    等做完第一个titanic的比赛应该就有点感觉了。上面4个比赛我都做过,觉得很经典,很适合入门。

    深度学习的入门算法有哪些

    如今的样本输入可以是文字,可以是图像,可以是数字。

    深度学习是跟着图像处理火起来的。甚至现在这个概念都火过了“机器学习”。

    深度学习的算法主要都是神经网络系列。入门推荐CNN(卷积神经网络)的一系列:

    LeNet5

    AlexNet

    VGG

    GoogleNet

    ResNet

    自学如何寻找学习资料?

    开源的世界,美好的世界❤

    “开源”,我的爱!代码届里开源的中心思想就是,share and free

    对于机器学习,网上的社区氛围特别好,分享的很多很全面,而且MLer都非常乐于助人。

    介绍几个我经常逛的社区,论坛,和网页:

    kaggle (www.kaggle.com)

    全球最权威的机器学习比赛,已被谷歌收购。赛题覆盖传统机器学习、nlp、图像处理等,而且都是很实际的问题,来自各行各业。kaggle是数一数二完善的ML社区了,赛题开放的数据集就很有用,非常适合新手练手。对优秀的kaggler也提供工作机会。

    github(www.github.com)

    全球最大同性交友网站,适合搜项目,开源大社区,大家一起看星星,看issue~

    StackOverFlow(www.stackoverflow.com)

    代码报错找它,代码不会敲找它!所有与代码相关的坑,基本都有人踩过啦

    csdn(www.csdn.net)

    最接地气的博客聚集地,最常看的网页之一,一般用来搜索细节知识点或者代码报错时

    sklearn(scikit-learn.org/stable)

    专业做机器学习100年!各算法各技巧的例子code应有尽有

    medium(medium.com)

    创办人是Twitter的创始人,推崇优质内容,国内很多AI公众大号的搬运都来自于这里,medium里每个作者都有自己独特的见解,值得学习和开拓眼界,需要科学上网

    towards data science(towardsdatascience.com)

    与medium很像,需要科学上网

    google AI blog(ai.googleblog.com)

    谷歌的AI团队维护的博客,每天至少更新一篇技术博客。刚在上海开的谷歌开发者大会宣布将会免费开放机器学习课程,值得关注一下,毕竟是AI巨头

    各种大神的技术博客/个人网站

    有很多的网站,会不定期的更新在我的个人博客里

    有口碑的AI公开课平台

    首先说明我没有上课,也没有报班,属于个人学习习惯问题。但考虑到学习差异性,所以还是总结了口碑排名靠前的课程系列。前提,需要有一定数学基础,没有的可以顺便补一补。

    coursera(www.coursera.org/browse)

    吴恩达(Andrew Ng)机器学习

    deeplearning.ai(www.deeplearning.ai)

    fast.ai(www.fast.ai)

    专注于深度学习。Fast.ai的创始人就蛮有意思的,是横扫kaggle图像处理的高手,不摆架子,也不故弄玄虚。中心思想就是深度学习很简单,不要怕。fast.ai有博客和社区。Jeremy和Rachel鼓励撰写博客,构建项目,在会议中进行讨论等活动,以实力来代替传统证书的证明作用。

    udacity(in.udacity.com)

    有中文版,课程覆盖编程基础,机器学习,深度学习等。

    网易云课堂

    碎片时间

    科技圈也是有潮流要赶的,等你入坑就知道。

    追最新的论文,最新的算法,最新的比赛,以及AI圈的网红是哪些~有条件的开个twitter,平时娱乐看看机器学习板块还是蛮有意思的,有很多自嘲的漫画~

    推荐几个我超爱看的AI主题美剧

    硅谷(强推!简直是我日常生活,太有共鸣了~下饭剧)

    西部世界(看的时候不要学我一直在思考如何实现这个那个技术)

    实用的小技巧

    浏览器首推 chrome

    当阅读英文网页呼吸困难时,右击选择“翻成中文(简体)”

    考过雅思和GMAT,曾经我也是一个热爱英文的孩子,如今跪倒在海量技术文档和文献里苟活

    搜索问题一定用google,如果没解决是你的问题不是google的锅

    baidu???ummm......别为难我......很少用

    学会提问很重要,搜索格式推荐

    语言+问题,例如:python how to convert a list to a dataframe

    直接复制错误信息,例如:ValueError: No variables to save...

    请把所有的问题往上抛,网上查比问人快!总是问别人会引起关系破裂的~

    学会顺藤摸瓜

    当你读到一个非常不错的技术文档时,看完别急着关掉。这可能是一个个人网站,去观察菜单栏里有没有【About】选项。或者这也可能是一个优秀的社区,看看有没有【Home】选项,去看看po的其它的文章。

    很多优秀网站都是英文,科学上网必不可少

    学习费用不来自课程,可能来自于硬件要求,学生党要利用好学校资源

    小结

    虽然说了那么多,但还是要说请放弃海量资料!用多少,找多少就好了!(别把这句话当耳旁风

    资料不在量多而在于内容是有质量保证的。很多课程或者公众号只管塞知识,你有疑问它也解答不了的时候,这样出来的效果不好,就像一个模型只管训练,却不验证,就是耍流氓

    如何选择编程语言/框架

    首选英语!!!(咳咳,我认真的)

    说到底,语言只是工具,不去盲目的追求任何一种技术。根据任务来选择语言,不一样的程序员选择不一样的编程语言。很多人最后不是把重点放在能力而是炫工具,那就有点走偏了。

    据观察,在机器学习组里R和Python是使用率最高的两门语言,一般你哪个用的顺就用哪个,只要能达到效果就行,除非强制规定。

    我使用之后的感受是,人生苦短,我用python

    用python建个模型到底多难?

    算法任务大致分为两种,一种是普通算法工程师做的“调包、调参”,另一种是高级算法工程师做的,可以自己创建一个算法或者能灵活修改别人的算法。

    先说说建个模到底有多简单吧。

    有优秀的算法封装框架

    tensorflow / caffe / keras /...

    Auto ML 是不可阻挡的一个方向

    Auto ML(auto machine learning),自动机器学习。就是你只管丢进去数据,坐等跑出结果来就行了。前一阵子谷歌的CloudML炒的很火,愿景是让每个人都能建模,但毕竟这种服务是要钱的。所以我研究了下开源的auto sklearn框架的代码,发现了什么呢?建模到底有多简单呢?就,简单到4行代码就可能打败10年工作经验的建模师。

    再说回来,如果你自己根本不知道自己在做什么,只能跑出来一个你不能负责的结果,就是很糟糕的,那还不是一个合格的算法工程师。你的模型必须像你亲生的那样。但是,只要你想,绝对能做到的!

    学习python电脑上要装哪些东西

    Anaconda

    对,就是这么简单粗暴,装这个就ok了

    学python的应该都会面临到底是python2还是python3的抉择吧。语言版本和环境真的很让人头疼,但是Anaconda惊艳到我了,就是可以自定义python环境,你可以左手py2右手py3

    推荐几个python的IDE

    Spyder

    Anaconda自带的ide。界面排版与Rstudio和Matlab很相似。输入什么就输出什么结果,适合分析工作,我写小功能的时候很喜欢用。

    Jupyter Notebook

    Anaconda自带的ide,属于web界面的。当你程序跑在虚拟机,想调代码的时候适合用。

    PyCharm

    对于写项目的,或者代码走读的比较友好。当你需要写好多python文件互相import时,特别好用。

    我的笔记本配置

    (不考虑经济约束的请忽略这条)

    牌子+型号:ThinkPad X1 Carbon

    推荐配置:i7+16G内存+256G(或更多)硬盘

    系统推荐:Linux,因为开源,有空可以玩玩

    校招/社招/实习/面试经验

    如何安排校招

    大厂的开放时间会比较早,密切关注网申时间节点:

    2019届的秋招:2019年7月 - 2019年11月

    2020届的春招:2020年2月 - 2020年4月

    2020届的暑期实习:2020年3月 - 2020年5月

    2020届的秋招:2020年7月 - 2020年11月

    (以此类推)

    手撕代码能力

    建议提早半年开始准备。我的代码也是从实习开始敲起,敲了半年才觉得下手如有神哈哈。不要做没实际意义的课后题,也不要照着书本例题敲,敲完你就忘了,书本这些都是已经排除万难的东西,得不到什么成长。

    入门修炼:全国大学生数学建模竞赛、全美大学生数学建模竞赛、kaggle、天池…

    项目经历/实习经历

    如果明确自己的职业方向为人工智能/数据挖掘类的,请不要浪费时间去申请其他与技术无关的实习。端茶送水,外卖跑腿,打印纸并不能帮你。当时由于身边同学都断断续续出去实习,面前有一份大厂行政的实习,我…竟然犹豫了一下,好在也还是拒绝了。

    尽量选择大厂的技术实习,毕竟以后想进去会更难。但是不要因为一个月拿3000块就只干3000块的活。把整个项目跟下来,了解框架的架构,优化的方向,多去尝试,就算加班(加班在深圳很正常)也是你赚到,思考如何简化重复性工作,去尝试了解自己部门和其他部门的工作内容与方向,了解的越多你对自己想做的事情了解的也越多。我实习做的评分卡模型,除了传统逻辑回归,也尝试新的XGB等等,而且虽然别人也在做,但是私下自己会把整个模型写一遍,包含数据清洗和模型调优等,这样对业务的了解也更透彻,面试起来所有的细节都是亲手做过的,也就比较顺了。

    如果没有实习在手,世界给我们数据挖掘选手的大门还是敞开着的。kaggle上有专门给数据挖掘入门者的练习场。相关的比赛还有很多,包括腾讯、阿里等大厂也时不时会发布算法大赛,目测这样的算法大赛只会越来越多,你坚持做完一个项目,你在平台上还可以得到相关名次,名次越靠前越有利哈哈哈这是废话。

    BAT常见的面试题(不分先后)

    自我介绍/项目介绍

    类别不均衡如何处理

    数据标准化有哪些方法/正则化如何实现/onehot原理

    为什么XGB比GBDT好

    数据清洗的方法有哪些/数据清洗步骤

    缺失值填充方式有哪些

    变量筛选有哪些方法

    信息增益的计算公式

    样本量很少情况下如何建模

    交叉检验的实现

    决策树如何剪枝

    WOE/IV值计算公式

    分箱有哪些方法/分箱原理是什么

    手推SVM:目标函数,计算逻辑,公式都写出来,平面与非平面

    核函数有哪些

    XGB原理介绍/参数介绍/决策树原理介绍/决策树的优点

    Linux/C/Java熟悉程度

    过拟合如何解决

    平时通过什么渠道学习机器学习(好问题值得好好准备)

    决策树先剪枝还是后剪枝好

    损失函数有哪些

    偏向做数据挖掘还是算法研究(好问题)

    bagging与boosting的区别

    模型评估指标有哪些

    解释模型复杂度/模型复杂度与什么有关

    说出一个聚类算法

    ROC计算逻辑

    如何判断一个模型中的变量太多

    决策树与其他模型的损失函数、复杂度的比较

    决策树能否有非数值型变量

    决策树与神经网络的区别与优缺点对比

    数据结构有哪些

    model ensembling的方法有哪些

    小结

    问题是散的,知识是有关联的,学习的时候要从大框架学到小细节。

    没事多逛逛招聘网站看看招聘需求,了解市场的需求到底是什么样的。时代变化很快,捕捉信息的能力要锻炼出来。你可以关注的点有:职业名/职业方向/需要会什么编程语言/需要会什么算法/薪资/...

    每个面试的结尾,面试官会问你有没有什么想问的,请注意这个问题也很关键。

    比如:这个小组目前在做什么项目/实现项目主要用什么语言和算法/…

    尽量不要问加不加班,有没有加班费之类的,别问我为什么这么说(摊手)

    在面试中遇到不理解的,比如C++语法不懂,可以问这个C++具体在项目中实现什么功能。如果你提出好问题,能再次引起面试官对你的兴趣,那就能增加面试成功率。

    应届生就好好准备校招,别懒,别怕输,别怕被拒,从哪里跌倒从哪里起来。社招不是你能招呼的,会更挫败,因为你什么也没做过。

    虽然是做技术的,但是日常social一下还是收益很大的。实习的时候,也要与周围同事和平相处,尤其是老大哥们,也许哪天他就帮你内推大厂去了。内推你能知道意想不到的信息,面试官,岗位需求,最近在做什么项目之类的。

    挑选给你机会的公司,不要浪费自己的时间。不要每家都去,去之前了解这家公司与你的匹配度

    尤其社招,你一改动简历就很多人给你打电话,你要有策略的去进行面试,把握总结每个机会。像我就是东一榔头西一榔头的,好多都是止步于第一面,就没回信儿了,因为每次面完没有好好反思总结,等下次再遇到这问题还是抓瞎,十分消耗自己的时间和信心。

    一碗鸡汤

    一切才刚刚开始,别着急

    AI才刚刚起步,为什么呢?因为上数学课的时候,课本上都是柯西,牛顿,高斯等等,感觉他们活在遥远的时代,很有陌生感。但是现在,我每天用的模型是比我没大几岁的陈天奇创造出来的,我甚至follow他的社交账号,他就鲜活在我的世界里,这种感觉,很奇妙。每次查论文查文献的时候,看2017年出来的都觉得晚了,懊悔自己怎么学的这么慢,看2018年2月出来的才心里有点安慰。这个证明,你在时代发展的浪潮上,也是一切刚刚起步的证明。机遇与挑战并肩出现的时候,是你离创造历史最近的时候。而所谓的风口所谓的浪尖都不重要,重要的是,因为你喜欢

    找一件可以坚持的事,不要停止去寻找的脚步

    当人做喜欢的事情时,会发光呀!

    当你因为真的热爱某件事,而不断接近它的时候,你的灵魂像是被上帝指点了迷津,受到了指示,受到了召唤。你会很自然的知道该做什么,你想做什么,好像生而为了这件事而来。你有时候自己都想不明白为什么做这件事。看过月亮与六便士的应该懂这种使命感~

    如何成为一名AI人工智能算法工程师?

     

    我不是属于聪明的那类人,我是属于比较倔的那种。就是只要我认定的,我认定到底。天知道我有多少次怀疑过自己,有多少次想放弃,但我还是选择咬牙向前,选择相信自己。坚持的意义就在这里。

    如何成为一名AI人工智能算法工程师?

    展开全文
  • AI算法论文:日常视频一秒变游戏,人物可以随意操控,Facebook的实时算法
  • AI算法不断突破 人工智能驱动创新需找对方向.pdf
  • 遗传算法课件 人工智能 算法设计 讲义,学习人工智能的材料
  • 算法的范围从经典的人工智能搜索算法到机器学习和深度学习算法。 如果您希望对某种算法进行编码和解释,欢迎提出。 我也有实现AI / ml到现实世界项目的实现,请参见下面的目录,以偷偷摸摸地查看这些项目! 表中...
  • 人工智能算法:遗传算法

    千次阅读 多人点赞 2021-01-21 19:33:15
    遗传算法是一种特殊的演化算法,但是在描述遗传算法的文献中,其定义各不相同。本书将遗传算法定义为一种可以用交叉和突变算子优化固定长度向量的演化算法。计分函数可以区分优劣方案,以优化该固定长度的向量。这个...

    遗传算法是一种特殊的演化算法,但是在描述遗传算法的文献中,其定义各不相同。本书将遗传算法定义为一种可以用交叉和突变算子优化固定长度向量的演化算法。计分函数可以区分优劣方案,以优化该固定长度的向量。这个定义说明了遗传算法的本质。

    此外,可以将可选特征添加到遗传算法中,以增强其性能。例如物种形成、精英和其他选择方法之类的技术,有时可以改善遗传算法的运行效果。

    3.1 离散问题的遗传算法

    与其他算法相似,针对连续学习和离散学习,遗传算法采用略有不同的方法。连续学习涉及计算数值,而离散学习涉及识别非数值。本节将展示如何将离散学习和连续学习应用于以下两个经典的AI问题:

    • 旅行商问题;
    • 鸢尾花物种建模。

    对于旅行商问题,我们将展示如何将遗传算法应用于离散学习的组合问题,目标是找到最佳的城市序列。同时,我们将拟合RBF神经网络的权重以识别鸢尾花种类,这将作为连续问题的遗传算法示例,即对数字权重进行调整。

    3.1.1 旅行商问题

    旅行商问题(Traveling Salesman Problem,TSP)涉及为旅行商确定最短路径。旅行商必须访问一定数量的城市,尽管他可以从任何城市开始和结束,但他只能访问每个城市一次。TSP有多个变体,其中一些变体允许多次访问每个城市,或为每个城市分配不同的值。本章中的TSP只是寻求一条尽可能短的路线,每个城市访问一次。图3-1展示了这里介绍的TSP和最短路径。

    人工智能算法:遗传算法

     

    图3-1 旅行商问题

    对于普通的迭代程序而言,找到最短的路径似乎很容易。但是,随着城市数量的增加,可能的组合数量也会急剧增加。如果问题有一个或两个城市,则只能选择一条路径;如果包括3个城市,则可能的路径将增加到6个。以下列表展示了路径数量增长的速度:

    1个城市有1条路径
    2个城市有2条路径
    3个城市有6条路径
    4个城市有24条路径
    5个城市有120条路径
    6个城市有720条路径
    7个城市有5 040条路径
    8个城市有40 320条路径
    9个城市有362 880条路径
    10个城市有3 628 800条路径
    11个城市有39 916 800条路径
    12个城市有479 001 600条路径
    13个城市有6 227 020 800条路径
    ……
    50个城市有3.041 × 10ˆ64条路径

    在上表中,用于计算总路径条数的公式是阶乘。使用阶乘运算符!作用于城市数n。某个任意值n的阶乘由n×(n − 1)×(n − 2)×…×3× 2×1给出。当程序必须执行蛮力搜索时,这些值会变得非常大。TSP是“非确定性多项式时间”(non-deterministic polynomialtime,NP)难题的一个例子。“NP困难”(NP-hard)被非正式地定义为“一系列不能用暴力搜索法求解的问题”。当超过10个城市时,TSP满足这个定义。NP困难的正式定义可以在Computers and Intractability: A Guide to the Theory of NP-Completeness [1]一书中找到。

    动态编程是解决TSP的另一种常用方法,如图3-2的漫画所示。

    尽管本书没有全面讨论动态编程,但了解其基本功能还是很有价值的。动态编程将TSP之类的大问题分解为较小的问题,这项工作可以被许多较小的程序复用,从而减少蛮力解所需的迭代次数。

    人工智能算法:遗传算法

     

    图3-2 解决TSP的方法(来自xkcd网站)

    与蛮力解和动态编程不同,遗传算法不能保证找到最优解。尽管它将找到一个很好的解,但分数可能不是最好的。在3.1.2节中讨论的示例程序,将展示遗传算法如何在短短几分钟内为50个城市的TSP产生可接受的解 [2]。

    3.1.2 为旅行商问题设计遗传算法

    TSP是最著名的计算机科学问题之一。由于传统的迭代算法通常无法解决NP困难问题,因此程序员必须使用遗传算法来生成潜在解。因此,我们将研究如何将遗传算法应用于TSP。

    离散遗传算法决定了你要使用的交叉和突变算子的类型。由于离散问题是分类问题,因此你无须处理数值。所以,你可能访问的城市就是TSP中的分类信息。按照访问顺序,城市列表是每个解的基因组。下面展示了如何表达TSP基因组:

    [洛杉矶, 芝加哥, 纽约]

    你的初始种群将是这些城市的随机排列。例如,初始随机种群可能类似于以下列表:

    [洛杉矶, 芝加哥, 纽约] 
    [芝加哥, 洛杉矶, 纽约] 
    [纽约, 洛杉矶, 芝加哥]

    你可以计算在每条路径上行驶的英里(1英里=1 609.344米)数,从而为上述城市创建一个计分函数。考虑第一个种群成员。根据Google Maps的驾驶导航,洛杉矶至芝加哥为2 016英里,芝加哥至纽约为790英里。因此,第一个种群成员覆盖的整个距离为2 806英里。距离是我们要最小化的分数。以上3个种群成员及其分数显示如下。

    [洛杉矶, 芝加哥, 纽约] -> 分数: 2 016 + 790 = 2 806
    [芝加哥, 洛杉矶, 纽约] -> 分数: 2 016 + 2 776 = 4 792 
    [纽约, 洛杉矶, 芝加哥] -> 分数: 2 776 + 2 016 = 4 792

    如你所见,最后两条路径的分数相同,因为旅行商可以从任何城市开始,所以最后两条路径产生相同的距离。旅行商问题的某些变体可以固定起点和终点城市。作为旅行商的家乡,起点和终点是相同的。其他变体让旅行商可以多次访问同一座城市。简而言之,如何定义旅行商问题的规则将决定如何实现计算机程序。

    考虑一下这种情况:旅行商总是从同一城市(即他的家乡)开始,并最终返回这里。在这个例子中,家乡城市是密苏里州的圣路易斯。此外,分数将是两个城市间最便宜机票的价格。由于基因组仍将由洛杉矶、芝加哥和纽约的排列组成,因此圣路易斯没有必要出现在基因组的开始和结尾。这样可以防止算法将圣路易斯更改为不是路径的起点或终点。换言之,计分函数隐式地将圣路易斯作为路径的起点和终点,并对其进行适当的处理。检查第一个种群成员,如下所示。

    [洛杉矶, 芝加哥, 纽约]

    该示例包括以下旅程。

    圣路易斯至洛杉矶 -> 费用: $393
    洛杉矶至芝加哥 -> 费用: $452
    芝加哥至纽约 -> 费用: $248 
    纽约至圣路易斯 -> 费用: $295 
    总计: $1388

    对问题的微小改动带来了很大的复杂性。由于圣路易斯位于美国中部,旅行商无法再从东到西或从西到东走一条简单的路。此外,机票价格不可互换,因为从芝加哥到圣路易斯的票价不一定与从圣路易斯到芝加哥的票价相同。旅行当天机票价格的变化使这个问题更加复杂。因此,基因组可以包括开始和结束日期。这样,遗传算法可以优化出行计划和城市顺序。

    你还可以创建算法,以允许旅行商多次访问同一座城市,但是,这个要求增大了计分函数的复杂性。如果你放宽要求,让旅行商可以多次访问同一座城市,则最佳分数可能来自以下解:

    [芝加哥, 芝加哥, 芝加哥]

    上述解的分数十分理想。该算法选择了从圣路易斯到最便宜的目的地芝加哥的路径。然后,算法再次选择芝加哥作为第2和第3站。因为从芝加哥到芝加哥的机票是0美元,所以这次旅行的分数非常好。显然,在这种情况下,该算法没有为程序员做任何额外的工作。因此,计分函数需要更复杂才能传达真正最优解的参数。也许有些城市更有价值,需要拜访,而另一些则是可选的。设计计分函数对于遗传算法编程至关重要。

    3.1.3 旅行商问题在遗传算法中的应用

    现在,我们将看到一个简单的遗传算法的示例,它用一条好路径穿过一系列城市。50个城市随机放置在256×256网格上。该程序使用了1 000条路径的种群,来演化出穿过这些城市的最佳路径。因为城市列表是分类值,所以TSP是一个离散的问题。在这个示例中,计分函数计算出一条城市路径所覆盖的总距离,这些城市中的任何一个都不会被访问两次。

    这些参数决定了最合适的突变和交叉算子的选择。对于这个示例,改组突变算子是最佳选择。如第2章所述,改组突变算子可与固定长度的分类数据配合使用。同样,我们将使用无重复的拼接交叉算子。两个算子都允许1 000条路径的种群演化,并且无重复的交叉强制实现了我们的要求,即同一城市只被访问一次。

    我对该程序进行了数百次迭代,直到连续经过50次迭代而没有出现一次改善最佳路径长度的情况。一次迭代即经过了一个世代。程序的输出在下面列出。

    Iteration: 1 , Best Path Length = 5308.0
    Iteration: 2 , Best Path Length = 5209.0
    Iteration: 3 , Best Path Length = 5209.0
    Iteration: 4 , Best Path Length = 5209.0
    Iteration: 5 , Best Path Length = 5209.0
    Iteration: 6 , Best Path Length = 5163.0
    Iteration: 7 , Best Path Length = 5163.0
    Iteration: 8 , Best Path Length = 5163.0
    Iteration: 9 , Best Path Length = 5163.0
    Iteration: 10 , Best Path Length = 5163.0
    ...
    Iteration: 260 , Best Path Length = 4449.0
    Iteration: 261 , Best Path Length = 4449.0
    Iteration: 262 , Best Path Length = 4449.0
    Iteration: 263 , Best Path Length = 4449.0
    Iteration: 264 , Best Path Length = 4449.0
    Iteration: 265 , Best Path Length = 4449.0
    Good solution found:
    22>1>37>30>11>33>39>24>9>16>40>3>17>49>31>48>46>20>13>47>23>
    0>2>29>27>14>34>26>15>7>35>19>21>18>6>28>25>45>8>38>43>32>
    41>5>10>4>44>36>12>42

    如你所见,在程序确定一个解之前,发生了265次迭代。由于城市是随机的,因此它们没有实际名称,而是将城市标记为“1”“2”“3”等。上面显示的最优解从城市22开始,接下来是城市1,最终在城市42停止。你可以在以下网址查看在线的TSP实现:

    http://www.heatonresearch.com/aifh/vol2/tsp_genetic.html

    3.2 连续问题的遗传算法

    程序员还可以利用遗传算法来演化连续的(即数值的)数据。在下面的示例中,我们将基于4个输入测量值来预测鸢尾花的种类。因此,我们的遗传算法将训练一个径向基函数(Radial-Basis Function,RBF)网络模型。

    模型是一种算法,它基于输入向量进行预测,这称为预测建模。对于鸢尾花数据集,我们将为RBF网络提供4个描述鸢尾花的测量值。RBF网络将根据这4个测量结果预测鸢尾花种属。它通过训练示例中的150朵花的数据来进行学习预测。该模型可以预测训练集中未包含的新花的种属。

    让我们回顾一下如何训练模型。3个主要部分确定了遗传算法如何训练任何模型:

    • 训练设置;
    • 超参数;
    • 参数。

    训练设置是遗传算法所独有的,例如种群数量、精英数、交叉算法和突变算法。在本书的后文,我们将学习粒子群优化(PSO)和蚁群优化(ACO),它们是RBF网络模型的训练算法。PSO和ACO的训练设置具有独有的特征。程序员通常会建立训练参数,因此,选择最佳的参数可能需要反复试验。

    超参数定义模型的结构。考虑图3-3,该图展示了RBF网络的结构。

    人工智能算法:遗传算法

     

    图3-3 以鸢尾花数据集为输入的RBF网络的结构

    在图3-3中,第2列显示的是3个具有凸起形状曲线的框,它们是RBF,使RBF网络能够做出预测。这个任务所需的RBF网络的数量是一个超参数,程序员或计算机可以确定该超参数。尽管RBF数量不影响遗传训练,但是如果你正在使用PSO和ACO进行训练,你仍然需要设置RBF数量。不过,你要小心,如果将RBF数量设置得太低,则创建的模型会很简单,以至于无法从信息中学习;如果将RBF数量设置得太高,则创建的网络会很复杂且难以训练,并可能导致过度拟合。这是我们不希望的情况,这时模型开始将数据存储在数据集中,而不是学习更通用的解。第10章将介绍过度拟合及其避免方法。在本章中,我们将RBF数量设置为5,这对于鸢尾花数据集似乎效果很好。我通过试验确定了这个数字。

    计算机也可以确定超参数,其中试错法通常是找到超参数的方法。只需在1~10个RBF之间循环,并让计算机尝试每种情况。一旦测试了全部10个RBF,程序就会选择获得最佳分数的模型。该模型将告诉你RBF数量超参数的最佳设置。

    最后的组成部分是参数向量。在训练模型时,模型会调整参数向量。这方面与超参数有所不同,因为一旦训练开始,模型就不会调整超参数。实际上,超参数定义了模型,无法更改。对参数向量进行调整是一种训练算法(例如遗传算法、PSO或ACO)教给模型针对给定输入的正确响应的方法。遗传算法利用交叉和突变来调整参数向量。

    下面列出的输出展示了使用遗传算法针对鸢尾花数据集训练RBF网络的进度。如你所见,分数在前10次迭代中并没有提高。这些迭代中的每一次迭代代表一代潜在解。分数代表错误分类的150朵鸢尾花的百分比,我们力求让这个分数最小。

    Iteration #1, Score = 0.1752302452792032, Species Count: 1
    Iteration #2, Score = 0.1752302452792032, Species Count: 1
    Iteration #3, Score = 0.1752302452792032, Species Count: 1
    Iteration #4, Score = 0.1752302452792032, Species Count: 1
    Iteration #5, Score = 0.1752302452792032, Species Count: 1
    Iteration #6, Score = 0.1752302452792032, Species Count: 1
    Iteration #7, Score = 0.1752302452792032, Species Count: 1
    Iteration #8, Score = 0.1752302452792032, Species Count: 1
    Iteration #9, Score = 0.1752302452792032, Species Count: 1
    Iteration #10, Score = 0.1752302452792032, Species Count: 1
    ...
    Iteration #945, Score = 0.05289116605845716, Species Count: 1
    Iteration #946, Score = 0.05289116605845716, Species Count: 1
    Iteration #947, Score = 0.05289116605845716, Species Count: 1
    Iteration #948, Score = 0.051833695704776035, Species Count: 1
    Iteration #949, Score = 0.05050776383877834, Species Count: 1
    Iteration #950, Score = 0.04932340367757065, Species Count: 1
    Final score: 0.04932340367757065
    [- 0.55, 0.24, -0.86, -0.91] -> Iris-setosa, Ideal: Iris-setosa
     
    [-0.66, -0.16, -0.86, -0.91] -> Iris-setosa, Ideal: Iris-setosa
    [-0.77, 0. 0, -0.89, -0.91] -> Iris-setosa, Ideal: Iris-setosa
    ...
    [0.22, -0.16, 0.42, 0.58] -> Iris-virginica, Ideal: Iris-virginica
    [0.05, 0.16, 0.49, 0.83] -> Iris-virginica, Ideal: Iris-virginica
    [-0.11, -0.16, 0.38, 0.41] -> Iris-virginica, Ideal: Iris-
    virginica

    在以上输出中,你可能还看到了物种计数(species count)。由于我们目前不使用物种,因此它保持为1。第5章将介绍物种。

    3.3 遗传算法的其他应用

    鸢尾花数据集和旅行商问题是人工智能文献中的常见例子。观察各种算法如何解决相同的问题,可以有助于理解它们的差异,检查新问题与遗传算法相符合的方式同样有价值。本节将说明如何让各种问题适应遗传算法。

    尽管本书目前未实现这些应用程序,但将来可能会包含它们。以下各小节的主要目的是演示遗传算法在各种情况下的应用。

    3.3.1 标签云

    标签云是一种方便的工具,可用于可视化文档中的单词频率计数。实际上,一个小的标签云可以代表一个很长的文档中的常用单词,但是,标签云算法通常会从单词数统计中删除结构化单词(例如“the”)。图3-4展示了根据《人工智能算法(卷1):基础算法》英文版创建的标签云。

    人工智能算法:遗传算法

     

    图3-4 卷1的标签云

    图3-4所示的标签云展示了每个单词出现的频率。你可以轻松地看到,“algorithm”是卷1中最常见的单词。

    要创建标签云,必须统计单词数。下面展示了构建图3-4所示标签云的单词计数:

    341 algorithm
    239 training
    203 data
    201 output
    198 random
    192 algorithms
    169 number
    163 input
    ...

    单词计数提供每个单词的出现频率,并与其他单词对比。标签云中的单词互相交织,使得单词之间的空白空间最小。在示例中,较小的单词填充了“algorithm”的“h”和“m”下的空白。

    创建标签云的第一步是选择一些单词并确定它们的大小。上面的单词计数说明了这个步骤。最有可能的是,你会在标签云中包含文档中大约100个最常见的单词。标签云中的确切字数将根据显示美观度进行调整。单词在文本中出现的次数将决定单词的大小。

    消除空白是遗传算法的一项重要应用。xy坐标、方向指示共同代表了每个单词。其中xy坐标表明每个单词在显示屏上的位置,方向指示表明单词是水平的还是垂直的。这3个数据项产生的向量长度等于标签云中单词数量的3倍。如果显示100个单词,则向量的长度为300个元素。对于空白和重叠文本,基因组将接受罚分。标签云不应该有重叠的文本。因此,你需要创建类似于以下内容的计分函数:

    [空白像素数] + ([重叠像素数] × 100)

    遗传算法应设法最小化这个计分函数。如果文本重叠,则需要增加系数100。

    3.3.2 马赛克艺术

    艺术生成是遗传算法的另一个非常常见的例子。编写计算机艺术的计分函数非常容易。你需要将源图像与遗传算法创建的图像进行比较;还要为遗传算法提供一组工具,以便它可以生成图像并显示其模拟的创造力。

    人类画家的工作方式基本相同。显然,产生图像的最简单方法是用数码相机照相,但是,画家用自己的工具(画笔和颜料)创造了艺术。对于遗传算法,工具是编程语言的图形命令,计分函数只是将原始图像与遗传算法产生的图像进行比较。例如,你可以限制遗传算法,让它仅用少数几种颜色画圆。仅使用程序中允许的元素,遗传算法将通过演化,产生原始照片的最佳渲染效果。通过这种方式,它展示了模拟的创造力。

    用遗传算法创建计算机艺术的一个例子是马赛克,它是由较小图像集合组成的较大图像。主图像包含一个图像网格,较小的图像将放置在每个网格单元中。图3-5展示了一幅马赛克。

    人工智能算法:遗传算法

     

    图3-5 玄凤鹦鹉马赛克

    图3-5描绘了由动物图像生成的玄凤鹦鹉马赛克。玄凤鹦鹉的图像尺寸为2 048像素×2 048像素,每张尺寸为32像素×32像素的较小动物图像的网格将构成该马赛克。将这些较小的动物图像的网格覆盖到较大的图像上,则将形成64×64的网格。(图3-5经过裁剪,仅展示其中一部分。)选择一组较小的动物图像放入64×64的网格中,使得网格在整体上可以最佳地呈现出一只玄凤鹦鹉的样子。

    每个基因组都是固定长度的数组,长度等于64×64即4 096字节。使用计分函数比较生成的马赛克图像和原始图像之间的差异。一旦得分降到最低,你将拥有与玄凤鹦鹉非常相似的马赛克。

    3.4 本章小结

    遗传算法利用种群、计分、交叉和突变来解决实际的编程问题。遗传算法是在第1章和第2章中学到的概念的具体实现,这些概念与交叉和突变一起工作,可以为下一代提供更好的解。

    遗传算法要求解以固定长度数组表示。这项要求似乎很有局限性,但是许多解都可以用这种方式表示。在本章中,我们还演示了旅行商问题和鸢尾花数据集。另外,我们讨论了遗传算法如何应用于标签云和马赛克艺术。

    为了超越定长数组,第4章将介绍如何演化实际的程序。实际上,遗传编程可以将计算机程序表示为树状结构,以便为下一代创建更好的程序。

    本文摘自《人工智能算法 卷2 受大自然启发的算》

    人工智能算法:遗传算法

    算法是人工智能技术的核心,大自然是人工智能算法的重要灵感来源。本书介绍了受到基因、鸟类、蚂蚁、细胞和树影响的算法,这些算法为多种类型的人工智能场景提供了实际解决方法。全书共10章,涉及种群、交叉和突变、遗传算法、物种形成、粒子群优化、蚁群优化、细胞自动机、人工生命和建模等问题。书中所有算法均配以具体的数值计算来进行讲解,每章都配有程序示例,读者可以自行尝试。

    本书适合人工智能入门读者以及对人工智能算法感兴趣的读者阅读参考。

    展开全文
  • 人工智能算法合集,用python3实现,运行在notebook上,注解详细,包括聚类、神经网络等算法
  • 象棋人工智能算法的C++实现(一)

    万次阅读 多人点赞 2018-10-16 23:33:41
    前言:自AlphaGo战胜世界著名九段围棋手李世石之后,我就对棋类人工智能产生了极大的...首先说明一下本系列博客描述的人工智能算法不是基于机器学习、深度学习这么高深的知识,而是一种穷举找最优走法的算法。之所以...

    前言:自AlphaGo战胜世界著名九段围棋手李世石之后,我就对棋类人工智能产生了极大的兴趣,并想要自己实现象棋的人工智能。然而那个时候我还在读高二,没有这么深厚的代码基础,所以那个时候也就只能想想了。但是现在不一样了,通过学习编程,已经可以让我在棋类人工智能这个领域向前探索了。

    首先说明一下本系列博客描述的人工智能算法不是基于机器学习、深度学习这么高深的知识,而是一种穷举找最优走法的算法。之所以AlphaGo不能使用这种算法战胜李世石,是因为围棋棋局局势的判断是极为复杂的,想要穷举所有的情况,全世界所有的计算机一起运行一百万年也无法找到最优走法。所以DeepMind团队的大佬就想出了另一种解决方案就是让AlphaGo自己学习高水平棋手间的对局,从而提升AlphaGo的棋力。然而象棋的棋局判断还是比较容易的,杀掉对面的老将就可以获胜,杀掉对面的车马炮等棋子就可以提高自己的胜率/降低对方的胜率。具体的算法在之后的篇章详细讲解。

    实现本系列博客中算法的编程工具是Qt5.5.1。

    既然实现象棋人工智能的算法的本质是穷举,那么就要找到所有的通路,所谓的通路就是能够走棋的那些“路”们,走不通的那些“路”就要直接被pass掉。

    1.先把棋盘抽象出来,象棋棋盘有10行9列,行标设为0~9,列标设为0~8。以左上角的坐标为(0,0),假设初始时上方为红棋,下方为黑棋。则初始时所有棋子的坐标为:

    车1(红方):(0,0);车2(红方):(0,8);

    马1(红方):(0,1);马2(红方):(0,7);

    相1(红方):(0,2);相2(红方):(0,6);

    士1(红方):(0,3);士2(红方):(0,5);

    将(红方):(0,4);

    炮1(红方):(2,1);炮2(红方):(2,7);

    兵1(红方):(3,0);兵2(红方):(3,2);兵3(红方):(0,4);兵4(红方):(0,6);兵5(红方):(0,8);

    注:红方的棋子行列坐标对应黑方棋子的行列坐标的关系为:红方行号+黑方行号=9;红方列号+黑方列号=8。

    车1(黑方):(9,8);车2(黑方):(9,0);

    马1(黑方):(9,7);马2(黑方):(9,1);

    相1(黑方):(9,6);相2(黑方):(9,2);

    士1(黑方):(9,5);士2(黑方):(9,3);

    将(黑方):(9,4);

    炮1(黑方):(7,7);炮2(黑方):(7,1);

    兵1(黑方):(6,8);兵2(黑方):(6,6);兵3(黑方):(6,4);兵4(黑方):(6,2);兵5(黑方):(6,0);

    下面给大家看一下棋盘类的源代码,里面是关于棋盘类的一些属性(数据成员)和需要在棋盘上进行的一些操作(函数成员),在这里我只给大家提供一个框架,各种成员函数的具体实现就要靠大家开动脑筋了。如果大家在这期间遇到什么问题,尽量要自己解决,如果实在解决不了,给大家提供一下我的邮箱:freedom11235@126.com。

    #ifndef BOARD_H
    #define BOARD_H
    
    #include <QFrame>
    #include "Stone.h"
    #include "Step.h"
    #include <QVector>
    #include <QMouseEvent>
    
    class Board : public QWidget
    {
        Q_OBJECT
    public:
        explicit Board(QWidget *parent = 0);
    
        //32颗棋子
        Stone _s[32];
    
        //棋子的像素半径
        int _r;
    
        //选中棋子的id
        int _selectid;
    
        //该不该红棋走
        bool _bRedTurn;
    
        //保存棋子的行走步骤
        QVector<Step*> _steps;
    
        //输入行列获取棋子的id
        int getStoneId(int row,int col);
        //计算即将行走的棋子与某一坐标之间有几颗棋子
        int num_of_Stone(int moveid,int row,int col);
        //输入行列坐标判断该坐标上有没有棋子
        bool beStone(int row,int col);
    
        bool canSelect(int id);
        //最基本的能不能走的判断判断
        bool canMove(int moveid,int row,int col,int killid);
        //判断将能不能走
        bool canMoveJIANG(int moveid,int row,int col,int killid);
        //判断士能不能走
        bool canMoveSHI(int moveid,int row,int col,int killid);
        //判断象能不能走
        bool canMoveXIANG(int moveid,int row,int col,int killid);
        //判断车能不能走
        bool canMoveCHE(int moveid,int row,int col,int killid);
        //判断马能不能走
        bool canMoveMA(int moveid,int row,int col,int killid);
        //判断炮能不能走
        bool canMovePAO(int moveid,int row,int col,int killid);
        //判断兵能不能走
        bool canMoveBING(int moveid,int row,int col,int killid);
    
        //尝试函数
        void trySelectStone(int id);
        void tryMoveStone(int killid, int row, int col);
    
        //判断两个棋子是否是同一方的
        bool sameColor(int id1, int id2);
    
        //走棋函数极其重载
        void moveStone(int moveid, int killid, int row, int col);
        void moveStone(int moveid, int row, int col);
    
        //杀死棋子的函数
        void killStone(int id);
        //复活棋子的函数
        void reliveStone(int id);
    
        void saveStep(int moveid, int killid, int row, int col, QVector<Step*>& steps);
    
        //与鼠标点击有关的函数
        void mouseReleaseEvent(QMouseEvent *);
        void click(QPoint pt);
        virtual void click(int id,int row,int col);
        //获取鼠标点击位置的行列坐标
        bool getRowCol(QPoint pt,int &row,int &col);
    
        //与显示到窗口中有关的函数
        void drawStone(QPainter& painter,int id);
        void paintEvent(QPaintEvent *);
        //输入行列坐标 返回像素坐标
        QPoint center(int row,int col);
        //输入棋子的id 返回像素坐标
        QPoint center(int id);
    signals:
    
    public slots:
    };
    
    #endif // BOARD_H

    2.再把棋子抽象出来。每个棋子都有一个id,初始时共有32枚棋子,id从0到31;棋子所具有的属性除了id还有所处的行列位置,棋子的类型(车马炮将士相兵),棋子的颜色(红/黑),棋子是否还存活着。id置为int型;棋子类型置为枚举类型enum TYPE{JIANG,CHE,PAO,MA,BING,SHI,XIANG};棋子的颜色置为bool型_red,红棋为true,黑棋为false;棋子是否还存活置为bool型,活着为true,被吃掉为false。

    #ifndef STONE_H
    #define STONE_H
    
    #include <QString>
    class Stone
    {
    public:
        Stone();
        //枚举棋子的所有类型
        enum TYPE{JIANG,CHE,PAO,MA,BING,SHI,XIANG};
        //棋子所处的行
        int _row;
        //棋子所处的列
        int _col;
        //棋子的id
        int _id;
        //棋子是否已死
        bool _dead;
        //棋子是否为红子
        bool _red;
        //棋子类型
        TYPE _type;
        //初始化棋子
        void init(int id);
        //获取棋子的类型名
        QString getText();
    };
    
    #endif // STONE_H

    3.按照象棋的规则实现每个棋子的走法的前期函数铺垫。这一部分是后期人工智能算法的基础,因为后期要将所有能走的通的“路”保存在一个C++容器(类似于C语言中的数组)里。

    (1)确定某个行列位置上是否存在棋子。

    这个函数在后面具体棋子的走法算法中应用的非常广泛。例如走马的时候需要判断是否别了马腿,也就是需要判定想要移动的马在要去的方向的正前方的位置是否有别的棋子挡住,即判断该位置上是否存在棋子;再例如如果出现了“对将”的情况,需要判断红将和黑将之间与其在同一直线上的所有位置上是否存在棋子,若所有位置都不存在棋子则两个将可以对吃。

    其实现的原理很简单,即输入一个行列坐标后遍历所有存活的棋子的行列坐标看一下有没有棋子与之完全吻合,若存在这样的棋子,则表示该行列坐标上存在棋子。

    /*确定某个行列位置上是否有棋子*/
    bool Board::beStone(int row,int col)
    {
        for(int i=0;i<32;i++)
            if(_s[i]._row==row&&_s[i]._col==col&&!_s[i]._dead)
                    return true;
    
        return false;
    }

    (2)计算某一棋子与某一行列坐标之间有几颗棋子。

    这个函数主要应用在“对将”以及车和炮的走棋算法上。例如炮如果想要隔着炮架吃掉对方的棋子就需要保证该炮与想要吃掉的对方的棋子之间有且仅有一个棋子;再例如车想要走棋到某一行列坐标必须保证该车与想要走到的位置之间没有棋子。

    有了(1)的铺垫,本函数的实现就变得容易了。首先需要判定一下即将行走的棋子的位置与目标位置在不在同一行(列)上。如果不在同一行(列)上则直接返回-1;如果在则可以遍历一整行(列)并调用(1)所介绍的函数beStone来统计即将行走的棋子与目标位置之间棋子的个数。

    //计算即将行走的棋子与某一坐标之间有几颗棋子 默认返回值为-1
    int Board::num_of_Stone(int moveid,int row,int col)
    {
        int i;
        int sum=0;
        if(_s[moveid]._row==row)
        {
            if(col-_s[moveid]._col>0)
                for(i=_s[moveid]._col+1;i<col;i++)
                {
                    if(beStone(_s[moveid]._row,i)==true)
                        sum++;
                }
            else
                for(i=_s[moveid]._col-1;i>col;i--)
                {
                    if(beStone(_s[moveid]._row,i)==true)
                        sum++;
                }
            return sum;
        }
        else if(_s[moveid]._col==col)
        {
            if(row-_s[moveid]._row>0)
                for(i=_s[moveid]._row+1;i<row;i++)
                {
                    if(beStone(i,_s[moveid]._col)==true)
                        sum++;
                }
            else
                for(i=_s[moveid]._row-1;i>row;i--)
                {
                    if(beStone(i,_s[moveid]._col)==true)
                        sum++;
                }
            return sum;
        }
    
        //两个棋子不在一条直线上
        return -1;
    }

     这个项目我会连载,后期各种算法的实现敬请期待!

    欢迎大家关注/订阅我的微信公众号Code Art Online,我会在我的公众号分享个人见闻,发现生活趣味;这里不仅有0和1,还有是诗和远方↓↓↓

    展开全文
  • Unity人工智能学习—确定性AI算法之追踪算法
  • Unity人工智能学习—确定性AI算法之反追踪算法
  • 2019年度人工智能算法文章合集.pdf
  • AI算法开源手册

    2019-07-31 18:14:03
    人工智能算法开源手册,学习相关数学及算法,值得一阅
  • AI算法人工智能学习必看的“知识图谱”解读.docx
  • 人工智能算法分类

    千次阅读 2020-03-07 20:29:06
    人工智能算法大体上来说可以分类两类:基于统计的机器学习算法(Machine Learning)和深度学习算法(Deep Learning) 总的来说,在sklearn中机器学习算法大概的分类如下: 纯算法类 (1).回归算法 (2).分类算法 (3).聚类...
  • 人工智能算法金融应用评价规范.pdf

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 382,893
精华内容 153,157
关键字:

ai算法