单层感知器、线性神经网络、几种数据结构算法的学习报告

1 本周工作

1、深入学习神经网络（神经网络概述、单层感知器、线性神经网络）（并用简单数据验证）

2、初步了解深度神经网络。

3、尝试验证SVM。

4、学习数据结构及算法（并用java实现）

2 实验总结

（1）内容介绍

一、深入学习神经网络

（1）、神经网络概述

1、神经网络称为ANN，是一种数据的处理模型，可塑性表现在链接权值是可调的，将一系列具有简单处理能力的节点通过权值相连，当权值调整恰当时，就可以输出正确的结果。网络将知识存储到权值中这就是ANN的精髓。

2、ANN的应用与特点

特点：

表现在其模式识别与数据的拟合能力上。

自学习与自适应性上：给网络输入样本，网络可以自己调节参数。改变映射关系。

非线性：可以是ANN处于激活与抑制状态。

鲁棒性：容错性，局部的损坏会降低效果，但是不致命。

计算的并行性与存储的分布性

应用：

模式分类；聚类；回归与拟合；优化计算；数据压缩

3、神经网络的模型

单层网络（线性网络）；多层网络；前向网络（BP/RBF/自组织）；反馈网络（hopfield、Elman）

4、学习方式：

有监督学习；无监督学习；半监督学习

Hebb学习规则：权值调整量是输入前一神经元与后一神经元的乘积为正比

纠错学习规则：权值调整量与误差的大小成正比

随机学习规则；竞争学习规则

（2）、单层感知器

1、单层前向网络，只能解决线性可分的二类问题。感知器结构

 

  n维向量

     对二值阈值进行判断

2、学习算法

通常采用纠错学习规则的学习算法，将偏置作为一个固定的输入一般取1。

输入为

权值为

算法步骤：

（1）定义参数与变量x为输入y为输出d为期望值b为偏差w为权值

（2）初始化，n=0权值向量设为随机与全零。

（3）激活：输入样本，每个样本指定其输出每个输出指定其期望输出

（4）实际的输出：

（5）权值更新

（6）判断：误差小于某个预定值；迭代之间权值很小；最大的迭代次数。

学习速率，不能取的太多，不能取得 太大，依靠经验选择。

3.感知器的局限

无法解决线性不可分的问题，只做近似的分类

激活函数，使用阈值函数输出只有两种情况限制使用

存在；

存在奇异值样本，时间变长算法只对单层有效。

4.matlab函数

Net=newp（P,T,TF,LF）;train;sim;handlims;init;adapt;mae

二、线性神经网络

最典型的是自适应线性元件，与感知器的区别是1.感知器的输出函数只能输出两种值而线性网络输出是任意的，其传函是线性的。2.在收敛的精度与速度上有较大的提高，但由于线性运算的规则，也只能解出线性可分的问题。线性神经元结构为

 

           

网络中包含多个神经元的节点就能输出多个输出这种神经网络叫做Madaline网络。

 

上图是间接的解决线性不可分的问题用多个线性函数对区域进行划分。另一个方法是对神经增加非线性输入

2.LMS算法

LMS算法与感知器算法在权值的调整上都是基于纠错学习方法的，而且LMS算法是更容易实现的因此更加广泛。

采用均方误差为评价标准，用mse对求偏导，另其为0，可以求出极值

3.算法步骤

1.定义变量与参数

2.初始化

3.输入样本，计算实际的输出与误差

4.调整权值向量

5.判断是否收敛

对于权值调整时的学习率，取值越小运行时间越长，算法记忆更多的数据，因此学习率反映了容量。

4.与单层感知器的对比

1网络传输函数，感知器是二值元件，线性网络是线性的

2学习算法，lms得带是边界在正中间，而感知器在正确位置即停。

二、初步了解深度神经网络

深度学习简单来说就是通过学习一种深层非线性网络结果，实现复杂函数的逼近，实现从原始数据中学习数据的本质特征。

一般都是采用的逐层贪婪训练方法来训练网络的参数，即先训练网络的第一个隐含层，然后接着训练第二个，第三个…最后用这些训练好的网络参数值作为整体网络参数的初始值。这样的好处是数据更容易获取，因为前面的网络层次基本都用无监督的方法获得，很容易，只有最后一个输出层需要有监督的数据。另外由于无监督学习其实隐形之中已经提供了一些输入数据的先验知识，所以此时的参数初始化值一般都能得到最终比较好的局部最优解。

基本思想：假设我们有一个系统S，它有n层（S1,…Sn），它的输入是I，输出是O，形象地表示为： I =>S1=>S2=>…..=>Sn => O，如果输出O等于输入I，即输入I经过这个系统变化之后没有任何的信息损失，保持不变，这意味着输入I经过每一层Si都没有任何的信息损失，即在任何一层Si，它都是原有信息（即输入I）的另外一种表示。现在回到我们的主题Deep Learning，我们需要自动地学习特征，假设我们有一堆输入I（如一堆图像或者文本），假设我们设计了一个系统S（有n层），我们通过调整系统中参数，使得它的输出仍然是输入I，那么我们就可以自动地获取得到输入I的一系列层次特征，即S1，…, Sn。

       对于深度学习来说，其思想就是对堆叠多个层，也就是说这一层的输出作为下一层的输入。通过这种方式，就可以实现对输入信息进行分级表达了。

       另外，前面是假设输出严格地等于输入，这个限制太严格，我们可以略微地放松这个限制，例如我们只要使得输入与输出的差别尽可能地小即可，这个放松会导致另外一类不同的Deep Learning方法。上述就是Deep Learning的基本思想。

三、学习数据结构及算法（并用java实现）

学习了栈，队列，以及链表。

栈只许访问一个数据项；即最后的插入项，只有移除这个数据项之后才可以访问下一个数据，以此类推。大部分的微处理器就是基于栈的体系结构。先进后出。

队列是一种数据结构类似于栈，只是在队列中第一个插入的会最先被移除，先进先出。

链表中，每一个数据项都包含在一个连接点中，一个连接点是某个类的对象这个类可以叫做link，因为一个链表中有很多的节点，所以有必要用不同于链表的类来表达连接点，详细内容见下面程序。

（2）程序实现

感知器程序

p=[-100,100];                % 输入数据是标量，取值范围-100~100

t=1;                             % 网络含有一个输出节点

net=newp(p,t);                  % 创建一个感知器

P=[-5,-4,-3,-2,-1,0,1,2,3,4]    % 训练输入

T=[0,0,0,0,0,1,1,1,1,1]         % 训练输出，负数输出0，非负数输出1

 net=train(net,P,T);            % 用train’进行训练

 newP=-10:.2:10;                % 测试输入

newT=sim(net,newP);             % 测试输入的实际输出

 

线性网络程序

x=-5:5;

y=3*x-7;                    % 直线方程为 

randn('state',2);               % 设置种子，便于重复执行

y=y+randn(1,length(y))*1.5;         % 加入噪声的直线

plot(x,y,'o');

P=x;T=y;

net=newlind(P,T);               % 用newlind建立线性层

new_x=-5:.2:5;                  % 新的输入样本

new_y=sim(net,new_x);               % 仿真

hold on;plot(new_x,new_y);

legend('原始数据点','最小二乘拟合直线');

net.iw                      % 权值为2.9219

net.b                       % 偏置为-6.6797

title('newlind用于最小二乘拟合直线');

 

数据结构及算法程序

逆推法：（没有主方法，单独的类）

public class niTui

{

private int n;//月份

double money;

double my[];

public niTui(){}

public niTui(int i,double m)//i is year

{

n=i*12;

money=m;

my=new double[n];

}

public void comput()

{

my[47]=money;

for(int k=46;k>0;k--)

{

my[k]=(my[k+1]+money)/(1+0.0171/12);

}

}

public void display()

{

for(int i=47;i>-1;i--)

{

System.out.println("this is "+(i+1)+"month"+my[i]);

}

}

/*public double comput()

{

int k;

for(k=0,money=1000;k<n;k++)

{

money=money/(1+0.0171/12);

}

return money;

}

public void display()

{

System.out.println(comput());

}*/

}

 

栈的操作（使得输入与输出逆序）

public class arrDo 

{

long[] arr;

int index;

//构造方法

public void arrDo(int n)

{

arr=new long[n];

index=0;

}

//数组赋值

public void inset(long num)

{

arr[index]=num;

index++;

}

//显示数组

public void display()

{

int i;

for(i=0;i<index;i++)

{

System.out.print(arr[i]+"\t");

}

System.out.println("");

}

//查找数字

public boolean find(long num)

{

int j;

for(j=0;j<index;j++)

{

if(arr[j]==num)

break;

}

if(j==index)

{

return false;

}else

return true;

}

//查找数字询标

public int find1(long num)

{

int j;

for(j=0;j<index;j++)

{

if(arr[j]==num)

break;

}

if(j==index)

{

return 0;

}

else 

return j;

}

//删除

public void del(long num)

{

int i,k;

k=find1(num);

for(i=k;i<index;i++)

{

arr[i]=arr[i+1];

}

index--;

}

}

链表操作（没有主类，可直接调用）

 

public class linkList 

{

private link first;

public linkList()

{

first=null;

}

public boolean isEmpty()

{

return (first==null);

}

public void insert(int i,double d)

{

link newlink=new link(i,d);

newlink.next=first;

first =newlink;

}

public link deletlink()

{

link temp=first;

first=first.next;

return temp;

}

public void displaylink()

{

System.out.println("begin");

link now=first;

while(now!=null)

{

now.displaylink();

now=now.next;

}//end while

}

public link find(int key)

{

link now=first;

while(now.iData!=key)

{

if(now.next==null)

now=null;

else

now= now.next;

}//end while

return now;

}//end find

}//end linkList

++++++++++++++++++++++++++++++

 

public class link 

{

public int iData;

public double dData;

public link next;//自引式

public link(){}//

public link(int i,double d)

{

iData=i;

dData=d;

}

public void displaylink()

{

System.out.println(iData+","+dData);

}

}//end link

 

 

（3）结果分析

感知器程序结果

newP =

 

  Columns 1 through 13

 

  -10.0000   -9.8000   -9.6000   -9.4000   -9.2000   -9.0000   -8.8000   -8.6000   -8.4000   -8.2000   -8.0000   -7.8000   -7.6000

 

  Columns 14 through 26

 

   -7.4000   -7.2000   -7.0000   -6.8000   -6.6000   -6.4000   -6.2000   -6.0000   -5.8000   -5.6000   -5.4000   -5.2000   -5.0000

 

  Columns 27 through 39

 

   -4.8000   -4.6000   -4.4000   -4.2000   -4.0000   -3.8000   -3.6000   -3.4000   -3.2000   -3.0000   -2.8000   -2.6000   -2.4000

 

  Columns 40 through 52

 

   -2.2000   -2.0000   -1.8000   -1.6000   -1.4000   -1.2000   -1.0000   -0.8000   -0.6000   -0.4000   -0.2000         0    0.2000

 

  Columns 53 through 65

 

    0.4000    0.6000    0.8000    1.0000    1.2000    1.4000    1.6000    1.8000    2.0000    2.2000    2.4000    2.6000    2.8000

 

  Columns 66 through 78

 

    3.0000    3.2000    3.4000    3.6000    3.8000    4.0000    4.2000    4.4000    4.6000    4.8000    5.0000    5.2000    5.4000

 

  Columns 79 through 91

 

    5.6000    5.8000    6.0000    6.2000    6.4000    6.6000    6.8000    7.0000    7.2000    7.4000    7.6000    7.8000    8.0000

 

  Columns 92 through 101

 

    8.2000    8.4000    8.6000    8.8000    9.0000    9.2000    9.4000    9.6000    9.8000   10.0000

 

 

newT =

 

  Columns 1 through 23

 

     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0

 

  Columns 24 through 46

 

     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0

 

  Columns 47 through 69

 

     0     0     0     0     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1

 

  Columns 70 through 92

 

     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1

 

  Columns 93 through 101

 

     1     1     1     1     1     1     1     1     1

线性网络的结果

ans =  [2.9219]

ans =  [-6.6797]

 

（4）未解决问题

在传统的CNN中卷积滤波核是自定义的还是学习得到的？

3参考文献

深度学习笔记整理系列blog

支持向量机通俗导论（理解SVM的三层境界）

Java数据结构和算法

神经网络与机器学习

4 下周工作

学习深度神经网络

找出学过东西的未知点并进行总结

继续学习数据结构及算法