Posted on

Neural Collaborative Filtering

这篇文章主要介绍了深度学习在推荐系统方面的应用，主要是应用了神经网络搭建协同过滤的网络，形成一个较好的结果。

我将结合文章中所提及的主要方法及其代码来回顾整篇文章。

3. NEURAL COLLABORATIVE FILTERING

从第三部分才来到实践的关键，所以我们直接跳过前两个部分，来到第三部分，并对它进行学习和理解。论文的主要部分在于，首先实现NCF，并对于NCF实例化之后利用DNN对其进行改善，提出了MLP，然后结合NCF和MLP来综合形成最后的结果。

GMF

首先的input层是一个one-hot向量，将每一个user和每一个item都设置为one-hot向量之后再进行处理。在input 层之后是一个embedding 层，然后将item和user 的embedding层 的结果合在一起之后放入一个多层神经网络中，我们将这个多层的神经网络视作神经协同过滤层，隐藏层的最后一层的维度决定了这个模型的泛化能力。最终的输出层(output)得到的是最终预测的结果。

补充

关于range 和 xrange，如果只看效果的话，两者差距很小，但是xrange每次返回的是xrange 的一个数据结构，而不是range返回的list，因此，当对于大数据进行处理时，建议使用xrange，而不是range。

关于代码中的参数说明：
| 符号| 含义|
| —- | —- |
| num_factors|将其映射到的空间的维度大小|
|regs|即正则化过程中的偏移量|
|num_neg|展示的negtive数量|
|lr|学习率|
|learner|学习的方式，一般来说使用adam|
|verbose|实质上是设置多少次迭代后输出结果|
|out| 设置输出|
|epochs| 迭代次数（学习次数）|
|batch_size|每一个batch的数量，使用sgd进行训练时需要弄清楚|

重点看model函数，即训练的函数。
这里的模型极其简单，实际上加深模型，应该有助于最后的训练结果。加深应该在哪里呢？从predict_vector开始，多加入几层，同时应该考虑不要社会太少的latent_dim，毕竟是大数据量的结果，考虑将其加深。原文中主要是为了能使得CPU较快的运行，才使用了这样一种方式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def get_model(num_users, num_items, latent_dim, regs=[0,0]):
    # Input variables
    user_input = Input(shape=(1,), dtype='int32', name = 'user_input')
    item_input = Input(shape=(1,), dtype='int32', name = 'item_input')

    MF_Embedding_User = Embedding(input_dim = num_users, output_dim = latent_dim, name = 'user_embedding',
                                  init = init_normal, W_regularizer = l2(regs[0]), input_length=1)
    MF_Embedding_Item = Embedding(input_dim = num_items, output_dim = latent_dim, name = 'item_embedding',
                                  init = init_normal, W_regularizer = l2(regs[1]), input_length=1)   
    
    # Crucial to flatten an embedding vector!
    user_latent = Flatten()(MF_Embedding_User(user_input))
    item_latent = Flatten()(MF_Embedding_Item(item_input))
    
    # Element-wise product of user and item embeddings 
    predict_vector = merge([user_latent, item_latent], mode = 'mul')
    
    # Final prediction layer
    #prediction = Lambda(lambda x: K.sigmoid(K.sum(x)), output_shape=(1,))(predict_vector)
    prediction = Dense(1, activation='sigmoid', init='lecun_uniform', name = 'prediction')(predict_vector)
    
    model = Model(input=[user_input, item_input], 
                output=prediction)

    return model

get_train_instances函数将训练集传入并对其进行处理，构成one-hot向量。
但是实际上这里的label只是用于论文中所说的是否进行点击，对于后续的操作的意义不大。需要注意这里的区别。实际上，如果真正需要做评分系统的话，那么就需要将label定义为打分的结果，而不是0,1的二值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def get_train_instances(train, num_negatives):
    user_input, item_input, labels = [],[],[]
    num_users = train.shape[0]
    for (u, i) in train.keys():
        # positive instance
        user_input.append(u)
        item_input.append(i)
        labels.append(1)
        # negative instances
        for t in xrange(num_negatives):
            j = np.random.randint(num_items)#从0到item_num的数量中选择一个
            while train.has_key((u, j)):
                j = np.random.randint(num_items)
            user_input.append(u)
            item_input.append(j)
            labels.append(0)
    return user_input, item_input, labels

自己的尝试，主要用于大数据作业的数据集，简要介绍一下这个数据集：

  1. 大概有20000个用户和600000个item，同时，总共有5000000条的打分，打分从0-100，但是分布极其不均匀，因此，需要对其进行处理，为了避免与稀疏矩阵的重合，将score变为:
    1
    score=np.floor(score/10)+1

因此，构建的模型为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def get_model(num_users, num_items, latent_dim=100, regs=[0,0]):
    # Input variables
    user_input = Input(shape=(1,), dtype='int32', name = 'user_input')
    item_input = Input(shape=(1,), dtype='int32', name = 'item_input')

    MF_Embedding_User = Embedding(input_dim = num_users, output_dim = latent_dim, name = 'user_embedding',
                                  init = 'uniform', W_regularizer = l2(regs[0]), input_length=1)
    MF_Embedding_Item = Embedding(input_dim = num_items, output_dim = latent_dim, name = 'item_embedding',
                                  init = 'uniform', W_regularizer = l2(regs[1]), input_length=1)   
    
    # Crucial to flatten an embedding vector!
    user_latent = Flatten()(MF_Embedding_User(user_input))
    item_latent = Flatten()(MF_Embedding_Item(item_input))
    
    # Element-wise product of user and item embeddings 
    #predict_vector = merge([user_latent, item_latent], mode = 'mul')
    predict_vector = keras.layers.Multiply()([user_latent,item_latent])
    # Final prediction layer
    #prediction = Lambda(lambda x: K.sigmoid(K.sum(x)), output_shape=(1,))(predict_vector)
    predict_layer1=Dense(64,activation='sigmoid',init='lecun_uniform',name='predict_layer1')(predict_vector)
    predict_layer2=Dense(32,activation='sigmoid',init='lecun_uniform',name='predict_layer2')(predict_layer1)
    prediction = Dense(11, activation='softmax', init='lecun_uniform', name = 'prediction')(predict_layer2)
    
    model = Model(input=[user_input, item_input], 
                output=prediction)

    return model

中间多加了几层，对于报错处的记录

‘Dense’ object has no attribute ‘outbound_nodes’

MLP

Posted on

Colab的使用

Colab介绍

好东西！！ 贫穷的人民，想拥有GPU或者TPU的难得的方式
对于一些基础的东西，都不加以介绍了，如果有兴趣，可以自己去查一下，或者ucadity的tensorflow教程里面就要用到这个东西，直接视频观看即可。
这里直接记录配置方式

首先选择修改，改为GPU或者TPU

然后添加如下代码后执行

1
2
3
4
5
6
7
8
9
10
11
12
!apt-get install -y -qq software-properties-common python-software-properties module-init-tools
!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null
!apt-get update -qq 2>&1 > /dev/null
!apt-get -y install -qq google-drive-ocamlfuse fuse
from google.colab import auth
auth.authenticate_user()
from oauth2client.client import GoogleCredentials
creds = GoogleCredentials.get_application_default()
import getpass
!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL
vcode = getpass.getpass()
!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}

然后挂载

1
2
!mkdir -p drive
!google-drive-ocamlfuse drive

如果需要安装包的时候，比如：

1
!pip install http://download.pytorch.org/whl/cu80/torch-0.3.1-cp36-cp36m-linux_x86_64.whl torchvision

这样安装就ok了

当然在执行之前还需要更改目录：

1
2
import os
os.chdir('drive/.../...')#进入你希望进入的目录

Posted on

Paper Reading

BTS-DSN: Deeply supervised neural network with short connections forretinal vessel segmentation

references: you can read this papar via BTS-DSN or star/fork this github project

Abstract

  1. An important method was proposed by this group called short-connection, that improve quite a lot the result of this model’s ability. They use sensitivity,specificity, AUC and F1-score to test their model. If you aren’t familiar with these indicators, you can read these two blogs to learn moreAUC &AUC-2.

1. Introduction

  1. why we hope to achieve early dignosis.
  2. some researchs done by other scholar group

    (1) Unsupervised methods: some methods have been proposed by scholoars, mainly about detect the profile and contour of vessel. These methods are mostly based on geometric computation model. defects: However, the unsupervised methods are sensitive to the manually designed features and rules.(poor in generalization)

(2)supervised methods:when we use supervised method, we usually view this problem as a pixel-wise binary classification. deep learning methods are popular in this area. Other ways to solve this problem about semantic segmentation results. defects:different methods have different disadvantages such as time-consuming and so on

  1. the contributions of this paper

    (1)”We propose a deeply-supervised fully convolutional neural network with bottom-top and top-bottom short connections (BTS-DSN) for vessel segmentation. “

(2)”We used VGGNet and ResNet-101 as backbone and conducted extensive experiments on DRIVE, STARE and CHASE_DB1”

“We employed cross-training experiments to show the generalization of BTS-DSN.”

attributes : more about VGGNet and ResNet can be found in their papers.{vgg(including vgg-16&vgg-19)&ResNet_paper&ResNet_github}.If you want to understand these model better, baidu or google it may help you.

2.BTS-DSN

  1. from HED to DSN, and then to BS-DSN and BST-DSN. this method was proposed to alleviate the gradient vanish problem in deep network. It’s a deep supervision

  2. bottom-top short connnections: pass low level fine semantic information to high levels to alleviate the blurring situation.

  3. top-bottom short connection: Bottom-top short connections aim to refine high-level segmentation results.

  4. inference: do feature confusion

3. Implementation details

  1. data augmentation: using quite a lot various transformations to augment the training set, including rotation, flipping and scaling.

  2. model implementation : using the network framework Caffe, short connections of the BTS-DSN.

  3. Parameter settings

When the backbone is VGGNet, we fine-tuned our network with a learning rate of 1e-8, a weight decay of 0.0005, and a momentum of 0.9. We use a fixed learning rate.

in two different backbone(VGGNet & ResNet-101),they use different type of parameters .

and for patch-level S-DSN, they split a raw retinal image into 9 patches, each of which was 1/4 the size of the raw image, meanwhile, patches were up-sampled $2 \times$

4.running environment:……

Evaluation criteria

In vessel segmentation, each pixel belongs to a vessel or non-vessel pixel.(be seen as a binary classfication problem).they iemployed six evaluation criteria, including AUC,SE,SP,ACC,F1-score and MCC.

Result

the result are shown in the fig in this paper, so you can just look through and get them.

Conclusion

这篇文章成功实现了目前基本上是最高水平的眼底血管分类成果，其使用VGGNet或者ResNet-101作为支柱(backbone)来实现整个CNN卷积的过程，同时，为了缓解语义分割中语义分割之间的差距，使用top-bottom 和 bottom-top short connection来实现整个过程，最终实现了BTS-DSN网络，达到了好的效果。同时，这个网络也使用了特征融合的方法，可以加以了解。对于更多的细节，还需要继续了解。

发散

（采样方法）上采样与下采样

短连接与ResNet连接方式的不同

评估方法

Posted on

Paper Reading

ImageNet Classification with Deep Convolutional Neural Networks

references: you can read this papar via BTS-DSN or star/fork this github project

Abstract

To achieve a great result, using ImageNet LSVRC-2010 contest dataset, this network model ,including dropout and some other operations, is quite fancy.

1.Introduction

  1. machine learning methods have achieved great result on small image dataset, but still been poor in big dataset.

  2. To learn about thousands of objects from millions of images, we need a model with a large learning capacity.

Dataset

ImageNet is a dataset of over 15 million labeled high-resolution images belonging to roughly 22,000 categories.
to show which dataset this paper trained to test its result.

3.The Architecture!!!

1.ReLU Nonlinearity

why we use ReLU instead of sigmoid or tanh function?
In terms of training time with gradient descent, these saturating nonlinearities are much slower than the non-saturating nonlinearity f(x) = max(0, x).

ps : 当我们使用ReLU函数而不是sigmoid或者tanh函数进行激活时，主要原因在于其更快的速度。当然，我们可以使用Leaky ReLU甚至Randomized Leaky ReLU来防止其它一些问题。还有一些其它的变体，包括PReLU和RReLU。

2.Training on Multiple GPUs

Current GPUs are particularly well-suited to cross-GPU parallelization, as they are able to read from and write to one another’s memory directly, without going through host machine memory.using a method to parallel the training process.Notice the parallelization scheme that is employed in this paper, which are quite inspirsed.

ps : 在利用多个GPU进行并行处理的时候，需要注意之间的信息传递与交互。如何提高数据之间传输的效率，是能够提高计算速度的关键。

3.Local Response Normalization

using local normalization to aid generation.

ps : 这一小节主要讲解了这个normalization的方式，这个公式的结果展示出来的效果在于，提高泛化能力（即b能更好地代表一个连续性的结果）简单分析三个超参数,k为一个偏移量，使得本身有一个偏移；n在于考虑其连续的范围，考虑泛化能力，在于一个权衡，$
\beta$在于调整参数的大小，使得与模型契合。

4. Overlapping Pooling

using overlapping can make our pooling result more precise than non-overlapping.We generally observe during training that models with overlapping pooling find it slightly more difficult to overfit

ps : 我们应该注意一个overlapping 与 non-overlapping之间的平衡，建议是首先不用overlapping，如果得到的结果处于欠拟合状态，则修改而使用overlapping pooling

5. Overall Architecture

the overall architecture will be shown in figure 1 below.

ps : 主要理解这个结构一些中间的部分，需要掌握对其的理解并且与前面的相贯通。

Reducing Overfitting

too many parameters in this model(60 million) are not insufficient to learn.

1.Data Augmentation

  1. The first form of data augmentation consists of generating image translations and horizontal reflections.
  2. The second form of data augmentation consists of altering the intensities of the RGB channels in training images.using PCA on the set.

ps: 由于原来的网络模型过深，所以需要避免过拟合，第一种方法就是增加数据量，可以通过对图像的一些处理来进行，包括进行图像的裁剪和对颜色进行处理。

2.Dropout

dropout 是一个重要的内容，我在附加的部分主要说明，这里就直接跳过。这里也只是运用了这种方法，没有做什么修改。

5.Details of learning

We trained our models using stochastic gradient descent with a batch size of 128 examples, momentum of 0.9, and weight decay of 0.0005.

the update relu for weight w was:

6.Results

this part is not so necessary, you should look through the paper to learn the result.

7.Discussion

the depth really is important for achieving our results.you can see that, from the discussion in this paper, deep network on image classfication have been aroused.

my conclusion

这篇文章主要提出了AlexNet这种结构，其主要有几个主要的因素构成：

  1. 使用两个GPU交互训练的网络
  2. 使用dropout方法进行正则化的方法
  3. 使用深层的深度网络进行学习（这是使用深度神经网络的一个重要的开端，它有后来的工作很大的启发作用）
  4. 使用data augmentation来进行数据的预处理，防止过拟合
  5. 使用了normalization方法来处理原来的数据，同时采用ReLU激活函数，使得整个计算过程更加快捷，且没有降低最终的效果。

发散

1. dropout

2.深层的神经网络的问题及其解决

Posted on

龙芯杯备战4

国科大试验系统迁移 LAB3-1

代码对比

1.接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
//机组cpu
module pipeline_cpu(  
    input clk,           
    input resetn,       
    
    //display data
    input  [ 4:0] rf_addr,//regfile 的测试地址（用于测试regfile)
    input  [31:0] mem_addr,//memory的地址，用于取出数据
    output [31:0] rf_data,
    output [31:0] mem_data,
    output [31:0] IF_pc,
    output [31:0] IF_inst,
    output [31:0] ID_pc,
    output [31:0] EXE_pc,
    output [31:0] MEM_pc,
    output [31:0] WB_pc,
    
    //最后需要用来检测的数据（检测5级的valid信号以及wb的数据)
    output [31:0] cpu_5_valid,
    output [31:0] HI_data,
    output [31:0] LO_data
    );



//国科大 CPU
module mycpu_top(
	input         clk,//时钟
	input         resetn,//复位信号

//ram  指令
	input [31:0]  inst_sram_rdata,//ram 读数据  -> inst(所得到的指令)
	output        inst_sram_en,//ram 使能信号   (需要自己添加这一信号的赋值)    ---->还未修改
	output [3:0]  inst_sram_wen,//ram 字节写使能信号 (在机组的流水线中，并未实现)  ---> 还未修改
	output [31:0] inst_sram_addr,//ram 读写地址，字节寻址  -> pc  (inst_addr)   
	output [31:0] inst_sram_wdata,//ram 写数据  (所需要修改的数据指令)    ---> 还未修改
//ram  数据    ->类似于inst_sram   可以直接在mem.v阶段使用
	input [31:0]  data_sram_rdata,//ram 读数据
	output        data_sram_en,//ram 使能信号，高电平有效    ----> 还未修改
	output [3:0]  data_sram_wen,//ram 字节写使能信号
	output [31:0] data_sram_addr,//ram 读写地址
	output [31:0] data_sram_wdata,//ram 写数据 

	output [31:0] debug_wb_pc,//wb级的PC，因而需要mycpu 的PC 一路带到写回级
	output [3:0]  debug_wb_rf_wen,// 写回级写寄存器堆(regfiles) 的写使能，为字节写使能
	output [4:0]  debug_wb_rf_wnum,// 写回级写regfiles的目的寄存器号
	output [31:0] debug_wb_rf_wdata// 写回级写regfiles的写数据
	);

2.regfile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
//regilfe 中原机组代码有test，但是由于在修改后的cpu后没有test的input信号，所以修改后直接删除就好
`timescale 1ns / 1ps
//*************************************************************************
//  LOONGSON
//  2016-04-14
//*************************************************************************
module regfile(
    input             clk,
    input             wen,
    input      [4 :0] raddr1,
    input      [4 :0] raddr2,
    input      [4 :0] waddr,
    input      [31:0] wdata,
    output reg [31:0] rdata1,
    output reg [31:0] rdata2,
    input      [4 :0] test_addr,
    output reg [31:0] test_data
    );
    reg [31:0] rf[31:0];
     
    // three ported register file
    // read two ports combinationally
    // write third port on rising edge of clock
    // register 0 hardwired to 0

    always @(posedge clk)
    begin
        if (wen) 
        begin
            rf[waddr] <= wdata;
        end
    end
     
    always @(*)
    begin
        case (raddr1)
            5'd1 : rdata1 <= rf[1 ];
            5'd2 : rdata1 <= rf[2 ];
            5'd3 : rdata1 <= rf[3 ];
            5'd4 : rdata1 <= rf[4 ];
            5'd5 : rdata1 <= rf[5 ];
            5'd6 : rdata1 <= rf[6 ];
            5'd7 : rdata1 <= rf[7 ];
            5'd8 : rdata1 <= rf[8 ];
            5'd9 : rdata1 <= rf[9 ];
            5'd10: rdata1 <= rf[10];
            5'd11: rdata1 <= rf[11];
            5'd12: rdata1 <= rf[12];
            5'd13: rdata1 <= rf[13];
            5'd14: rdata1 <= rf[14];
            5'd15: rdata1 <= rf[15];
            5'd16: rdata1 <= rf[16];
            5'd17: rdata1 <= rf[17];
            5'd18: rdata1 <= rf[18];
            5'd19: rdata1 <= rf[19];
            5'd20: rdata1 <= rf[20];
            5'd21: rdata1 <= rf[21];
            5'd22: rdata1 <= rf[22];
            5'd23: rdata1 <= rf[23];
            5'd24: rdata1 <= rf[24];
            5'd25: rdata1 <= rf[25];
            5'd26: rdata1 <= rf[26];
            5'd27: rdata1 <= rf[27];
            5'd28: rdata1 <= rf[28];
            5'd29: rdata1 <= rf[29];
            5'd30: rdata1 <= rf[30];
            5'd31: rdata1 <= rf[31];
            default : rdata1 <= 32'd0;
        endcase
    end
  
    always @(*)
    begin
        case (raddr2)
            5'd1 : rdata2 <= rf[1 ];
            5'd2 : rdata2 <= rf[2 ];
            5'd3 : rdata2 <= rf[3 ];
            5'd4 : rdata2 <= rf[4 ];
            5'd5 : rdata2 <= rf[5 ];
            5'd6 : rdata2 <= rf[6 ];
            5'd7 : rdata2 <= rf[7 ];
            5'd8 : rdata2 <= rf[8 ];
            5'd9 : rdata2 <= rf[9 ];
            5'd10: rdata2 <= rf[10];
            5'd11: rdata2 <= rf[11];
            5'd12: rdata2 <= rf[12];
            5'd13: rdata2 <= rf[13];
            5'd14: rdata2 <= rf[14];
            5'd15: rdata2 <= rf[15];
            5'd16: rdata2 <= rf[16];
            5'd17: rdata2 <= rf[17];
            5'd18: rdata2 <= rf[18];
            5'd19: rdata2 <= rf[19];
            5'd20: rdata2 <= rf[20];
            5'd21: rdata2 <= rf[21];
            5'd22: rdata2 <= rf[22];
            5'd23: rdata2 <= rf[23];
            5'd24: rdata2 <= rf[24];
            5'd25: rdata2 <= rf[25];
            5'd26: rdata2 <= rf[26];
            5'd27: rdata2 <= rf[27];
            5'd28: rdata2 <= rf[28];
            5'd29: rdata2 <= rf[29];
            5'd30: rdata2 <= rf[30];
            5'd31: rdata2 <= rf[31];
            default : rdata2 <= 32'd0;
        endcase
    end

    always @(*)
    begin
        case (test_addr)
            5'd1 : test_data <= rf[1 ];
            5'd2 : test_data <= rf[2 ];
            5'd3 : test_data <= rf[3 ];
            5'd4 : test_data <= rf[4 ];
            5'd5 : test_data <= rf[5 ];
            5'd6 : test_data <= rf[6 ];
            5'd7 : test_data <= rf[7 ];
            5'd8 : test_data <= rf[8 ];
            5'd9 : test_data <= rf[9 ];
            5'd10: test_data <= rf[10];
            5'd11: test_data <= rf[11];
            5'd12: test_data <= rf[12];
            5'd13: test_data <= rf[13];
            5'd14: test_data <= rf[14];
            5'd15: test_data <= rf[15];
            5'd16: test_data <= rf[16];
            5'd17: test_data <= rf[17];
            5'd18: test_data <= rf[18];
            5'd19: test_data <= rf[19];
            5'd20: test_data <= rf[20];
            5'd21: test_data <= rf[21];
            5'd22: test_data <= rf[22];
            5'd23: test_data <= rf[23];
            5'd24: test_data <= rf[24];
            5'd25: test_data <= rf[25];
            5'd26: test_data <= rf[26];
            5'd27: test_data <= rf[27];
            5'd28: test_data <= rf[28];
            5'd29: test_data <= rf[29];
            5'd30: test_data <= rf[30];
            5'd31: test_data <= rf[31];
            default : test_data <= 32'd0;
        endcase
    end
endmodule

其它过程

对于整个迁移的其它过程，都主要是按照接口来做，没有什么特别的地方需要说明。

另外需要说明的一点是，在机组实现的流水线cpu中，是在整个cpu的总线中进行调用inst_sram和data_sram，而在国科大的lab中，由更高一层的soc_lite_top.v进行调用和控制，而my_cpu中只需要调用fetch,decode,exe,mem,wb以及regfile进行执行即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//*************************************************************************
//   > File Name   : soc_top.v
//   > Description : SoC, included cpu, 2 x 3 bridge,
//                   inst ram, confreg, data ram
// 
//           -------------------------
//           |           cpu         |
//           -------------------------
//         inst|                  | data
//             |                  | 
//             |        ---------------------
//             |        |    1 x 2 bridge   |
//             |        ---------------------
//             |             |            |           
//             |             |            |           
//      -------------   -----------   -----------
//      | inst ram  |   | data ram|   | confreg |
//      -------------   -----------   -----------
//
//   > Author      : LOONGSON
//   > Date        : 2017-08-04
//*************************************************************************

其主要框架如图所示，需要更具体地进行了解

IP核锁定解决方案

由于从旧的vivado版本迁移到新的版本中，会遇到IP核锁定的问题，所以我跑simulation的时候，发现跑不过，我开始以为是coe文件的问题，后来重新导入coe文件后，发现还是报错，于是我发现，是IP核锁定了。

首先查看网上的解决方案，在工具栏找到report->Report IP Status,然后发现没办法upgrade selected,这个时候点击右键，可以发现有UPGRADE IP的选项，果断选择，然后好像就OK了。容我跑一跑simulation(时间有点长，现在很慌~~)什么信息也不报一个

其它还需要修改的错误

wb端实际上还需要修改，同时，并没有将所有需要的output实现，目前还有很多X与Z的存在，需要进一步修改其中的代码。

Posted on

SVM

关于SVM的内容介绍，主要参考了这位博主的SVM文章点击此处进行查看（讲得太好了）

1.简介

支持向量机(Support Vector Machine)是Cortes和Vapnik于1995年首先提出的，它在解决小样本、非线性及高维模式识别中表现出许多特有的优势，并能够推广应用到函数拟合等其他机器学习问题中.

支持向量机方法是建立在统计学习理论的VC维理论和结构风险最小原理基础上的，根据有限的样本信息在模型的复杂性（即对特定训练样本的学习精度，Accuracy）和学习能力（即无错误地识别任意样本的能力）之间寻求最佳折衷，以期获得最好的推广能力（泛化能力）
所谓VC维是对函数类的一种度量，可以简单的理解为问题的复杂程度，VC维越高，一个问题就越复杂。正是因为SVM关注的是VC维，后面我们可以看到，SVM解决问题的时候，和样本的维数是无关的（甚至样本是上万维的都可以，这使得SVM很适合用来解决文本分类的问题，当然，有这样的能力也因为引入了核函数）。

与问题真实解之间的误差，就叫做风险（更严格的说，误差的累积叫做风险）。统计学习因此而引入了泛化误差界的概念，就是指真实风险应该由两部分内容刻画，一是经验风险，代表了分类器在给定样本上的误差；二是置信风险，代表了我们在多大程度上可以信任分类器在未知文本上分类的结果。很显然，第二部分是没有办法精确计算的，因此只能给出一个估计的区间，也使得整个误差只能计算上界，而无法计算准确的值（所以叫做泛化误差界，而不叫泛化误差）。置信风险与两个量有关，一是样本数量，显然给定的样本数量越大，我们的学习结果越有可能正确，此时置信风险越小；二是分类函数的VC维，显然VC维越大，推广能力越差，置信风险会变大。
SVM 有如下的优点

小样本 非线性 高维模式识别

2.数学定义

考虑线性分类器

假设线性分类函数 g(x)=wx+b ，当然，其中w,x,b 均为高维向量，那么，不妨假设以g(x)=0为分界面，对于每个$x_i$而言，即有$y_i=sign(g(x_i))$,那么$y_i$要么为1，要么为-1，如此，定义$\sigma_i =\frac{y_i*g(x_i)}{||w||_2}$ ,因此，实际上$\sigma = \sum_{i=1}^n {\sigma_i}$为所有的距离之和,因而，我们找到一个最好的分类的目标变为$min ||w||$,为了在后续过程中使得我们的计算简单，我们将目标函数变为

但如若着这样，会存在一个问题，即分类的结果都会存在于两个分类器的中间地带，那么这样会导致$||w||=0$实际上不是我们需要的值，故在此基础上，我们还需要加上约束条件$y_i*g(x_i)>=1(i=1,2,\ldots,n)$ 故，最终结果表示为

实际上，这里的问题变为了一个凸优化问题，同时也是一个二次规划问题。我们知道，这样一个凸的规划问题，完全可以求得最优解，故我们的问题能够得到实际上的解决。那么需要怎么解决呢？

3.问题解决

实际上，我们求解的目标就是w，因为求得了w之后，可以求得b，则最终可以求到我们想要得到的g(x)这个函数，也就是分界面。而实际上，w与样本有关，那么我们可以定义$w=a_1x_1+a_2x_2+\ldots+a_nx_n$ 其中$a$为拉格朗日乘子，那么再次回顾$g(x)=\vec{w} \cdot \vec{x} +\vec{b}$,再次分析$\vec{w}$ 的表达式，我们可以发现，依然有错误，实际上，w还与y有关，故，我们可以将w这样表示

因此 $g(x) = +b= \sum_{i=1}^n{(a_iy_i)}+b$,因此我们可以看到，我们实际上把w给消掉了，没有了w，实际上也减少了很多约束条件，接下来，我们将开始很重要的一个介绍，核函数

4.核函数

一个解决线性不可分问题的基本思路————向高维空间转化，使其变得线性可分（一个二维空间中的问题，当映射到四维空间中的时候，就变得线性可分了），然而于此同时，也出现了很多问题，例如对于一个文本分类问题，将其映射到上万维的空间中，依旧是线性不可分的，然而，对于高维空间的计算，需要耗费大量的计算资源，因此，这就带来了不可计算的问题（这是实际工程中的一个重要的问题）

因此我们的目标已经明确了，找到一种能够映射到很高维的方法（要是能到无穷维就更好了！），并且能保证其在有限时间中可计算（如果能与没有升维之前有同样的计算阶那就再好不过了，即是线性的）。因此我们幻想，是否能有这样一种函数K(w,x),他接受低维空间的输入值，却能算出高维空间的内积值。我们不妨假设这个函数为核函数K，那么即有

这两个函数完全相等。因此，我们的目标变为了对非线性的分类问题，有$g(x)=\sum_{i=1}^n a_iy_i+b$
那么核函数(kernel)存在吗？万幸的是，这样的K(w,x)确实存在（发现凡是我们人类能解决的问题，大都是巧得不能再巧，特殊得不能再特殊的问题，总是恰好有些能投机取巧的地方才能解决，由此感到人类的渺小），它被称作核函数（核，kernel），而且还不止一个，事实上，只要是满足了Mercer条件的函数，都可以作为核函数。核函数的基本作用就是接受两个低维空间里的向量，能够计算出经过某个变换后在高维空间里的向量内积值。
常用的核函数有哪些呢？这里可以直接参考这一篇blog，常用的核函数有四个，分别为线性核函数,多项式核函数，高斯(RBF)核函数与sigmoid核函数,对于其的比较，我在这里就不区分了，在实践中，多用，就能更好地理解这几个核函数的区别。

5.其它问题

我们必须再次思考其它的问题，即如果使用核函数向高维空间映射后，问题仍然是线性不可分的，那怎么办？

这一问题实际上我们可以理解为噪声问题，在实际过程中，我们所采集到的数据通常都会有噪声，那么，噪声会改变我们本来正确的分类结果，对程序而言，会导致一种情况，即我们无法对这样的数据，甚至映射到高维空间中后，也线性不可分。那么如何抑制此现象的产生呢？这实际上与我们之前提出的思路有极大的关联，即我们之前给出定义为

这实际上要求了所有的点，均必须满足这一条件，那么这会导致不可分（纵然在极高维的空间中，或许它也可分，但所分出来的结果必然是过拟合的，而不是我们想要的），所以我们模仿人类的思想，只保证绝大多数分类正确，因此,我们给这个阈值加上一个松弛变量，使得原式变为：

在此基础上，我们的优化问题的目标有所改变

其中，C是一个超参数，建议设一组值来进行尝试。这里在具体对C进行一个讨论，C是一个固定参数，对此可以这样理解，如果C设置得较大，则说明我们很care那些被丢弃掉的点，如果我们不care那些点的话，我们则可以将C设置得小一点，同时，我们也能对不同的点设置不同的C，那么，则代表我们对某些点有特殊的偏好,这被称作数据集偏斜。对于特定的问题，读者应该对C的设置有不同的思考，要把握C的实质内容。

6. 将SVM用于多类分类

我们实际上可以将一个多分类问题，看做一个”一类对其余“的问题，那么每次仍然是解一个两类分类的问题。比如我们有5个类别，第一次就把类别1的样本定为正样本，其余2，3，4，5的样本合起来定为负样本，这样得到一个两类分类器，它能够指出一篇文章是还是不是第1类的；第二次我们把类别2 的样本定为正样本，把1，3，4，5的样本合起来定为负样本，得到一个分类器，如此下去，我们可以得到5个这样的两类分类器（总是和类别的数目一致）。到了有文章需要分类的时候，我们就拿着这篇文章挨个分类器的问：是属于你的么？是属于你的么？哪个分类器点头说是了，文章的类别就确定了。这种方法的好处是每个优化问题的规模比较小，而且分类的时候速度很快（只需要调用5个分类器就知道了结果）。但有时也会出现两种很尴尬的情况，例如拿一篇文章问了一圈，每一个分类器都说它是属于它那一类的，或者每一个分类器都说它不是它那一类的，前者叫分类重叠现象，后者叫不可分类现象。分类重叠倒还好办，随便选一个结果都不至于太离谱，或者看看这篇文章到各个超平面的距离，哪个远就判给哪个。不可分类现象就着实难办了，只能把它分给第6个类别了……更要命的是，本来各个类别的样本数目是差不多的，但“其余”的那一类样本数总是要数倍于正类（因为它是除正类以外其他类别的样本之和嘛），这就人为的造成了上一节所说的“数据集偏斜”问题。
因此，这样一个思路看上去可行，但实际上也需要一定的调整才能对实际的多分类问题进行应用。那需要哪些改善呢？还是解两类分类问题，还是每次选一个类的样本作正类样本，而负类样本则变成只选一个类（称为“一对一单挑”的方法，哦，不对，没有单挑，就是“一对一”的方法），这就避免了偏斜。但这样，会大量增加分类器的数量。
看来我们必须再退一步，在分类的时候下功夫，我们还是像一对一方法那样来训练，只是在对一篇文章进行分类之前，我们先按照下面图的样子来组织分类器（如你所见，这是一个有向无环图，因此这种方法也叫做DAG SVM）

DAG SVM

这样在分类时,我们就可以先问分类器“1对5”（意思是它能够回答“是第1类还是第5类”），如果它回答5，我们就往左走，再问“2对5”这个分类器，如果它还说是“5”，我们就继续往左走，这样一直问下去，就可以得到分类结果。好处在哪？我们其实只调用了4个分类器（如果类别数是k，则只调用k-1个），分类速度飞快，且没有分类重叠和不可分类现象！缺点在哪？假如最一开始的分类器回答错误（明明是类别1的文章，它说成了5），那么后面的分类器是无论如何也无法纠正它的错误的（因为后面的分类器压根没有出现“1”这个类别标签），其实对下面每一层的分类器都存在这种错误向下累积的现象。

关于SMO算法的学习，在这里就不加以重点介绍，需要的可以参考SMO这一篇博客

python 代码实现

在python中，scikit-learn是一个广泛使用的用于实现机器学习算法的库（也许后面我也会对这个库的使用方法作一系列的博客介绍），SVM算法可以在这个库中找到并用于实现。
这里的python实现借用了blog的实现方式，需要源码的也可以从中进行下载

sklearn中的SVC函数是基于libsvm实现的，所以在参数设置上有很多相似的地方。（PS: libsvm中的二次规划问题的解决算法是SMO）。

1
2
3
4
5
6
7
8
9
10
#Import Library
from sklearn import svm
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create SVM classification object 
model = svm.svc(kernel='linear', c=1, gamma=1) 
# there is various option associated with it, like changing kernel, gamma and C value. Will discuss more # about it in next section.Train the model using the training sets and check score
model.fit(X, y)
model.score(X, y)
#Predict Output
predicted= model.predict(x_test)
1
sklearn.svm.SVC(C=1.0, kernel='rbf', degree=3, gamma=0.0, coef0=0.0, shrinking=True, probability=False,tol=0.001, cache_size=200, class_weight=None, verbose=False, max_iter=-1, random_state=None)

这里展示了sklearn.svm.SVC的主要的参数，其中C为我们设置的超参数，而kernel有多种选择，这里为’rbf’,即高斯核函数。除此之外，还可以选择’linear’:线性核函数 ‘poly’ 多项式核函数 ‘sigmoid’ sigmoid核函数 ‘precomputed’:核矩阵（precomputed表示自己提前计算好核函数矩阵，这时候算法内部就不再用核函数去计算核矩阵，而是直接用你给的核矩阵。）

degree: int型参数 默认为3这个参数只对多项式核函数有用，是指多项式核函数的阶数n如果给的核函数参数是其他核函数，则会自动忽略该参数。

gamma: float参数 默认为auto核函数系数，只对‘rbf’,‘poly’,‘sigmod’有效。如果gamma为auto，代表其值为样本特征数的倒数，即1/n_features.

coef0: float参数 默认为0.0。核函数中的独立项，只有对‘poly’和‘sigmod’核函数有用，是指其中的参数c

probability： bool参数 默认为False。是否启用概率估计。 这必须在调用fit()之前启用，并且会fit()方法速度变慢。

还有其它的参数，都可以参照svm参数说明进行学习，这里就不再具体说明。

Posted on

图与网络

basic conception

无向图 有向图 赋权图 有限图 简单图
完全图 二分图 子图 母图 顶点的度（入度，出度）

一个图称为简单图(simple graph)，如果它既没有环也没有两条边连接同一对顶点。

邻接矩阵表示法  邻接链表表示法   弧表表示法   关联矩阵  星形表示法（前向和反向）

弧表表示法将图以弧表（arc list）的形式存储在计算机中。所谓图的弧表，也就是图的弧集合中的所有有序对。弧表表示法直接列出所有弧的起点和终点，共需2m个存储单元，因此当网络比较稀疏时比较方便。

也就是说，在关联矩阵中，每行对应于图的一个节点，每列对应于图的一条弧。如果一个节点是一条弧的起点，则关联矩阵中对应的元素为1；如果一个节点是一条弧的终点，则关联矩阵中对应的元素为−1；如果一个节点与一条弧不关联，则关联矩阵中对应的元素为 0。

道路(walk) 迹(trail) 轨(path) 圈(cycle)

一个连通图的生成树很多,用 $\tau(G)$ 来表示图的生成树的个数，则有如下公式：

匹配问题

1.几个定义

对集 匹配 完美对集 最大对集 交错轨 可增广轨

2.定理:

(1)M是图G的最大对集当且仅当G中无M可增广轨

(2)G 为二分图， X与Y是顶点集的划分，G中存在把X中顶点皆许配的对集的充要条件是，∀S ⊂ X ，则|N(S)|≥|S|，其中N(S)是S中顶点的邻集。

推论 若G是k次正则二分图（每个顶点皆K度的图），则G有完美对集

3.人员分派问题

1.匈牙利算法：利用匈牙利算法可以直接解决人员分派问题，其思路非常简单，故在这里不做介绍。

2.->最优分派问题
这个问题的数学模型是：在人员分派问题的模型中，图 G 的每边加了权$w(x_i,y_j)>=0$表示$x_i$干$y_j$ 工作的效益，求加权图G 上的权最大的完美对集。

解决这个问题可以参照《数学建模算法与应用》（司守奎）（P84）所给出的定义以及Kuhn-Munkres算法，其实质上是在匈牙利算法的进一步改善
如果想要对KM算法作深入的理解，可以参考这个blog

可行顶标$l$,对于任意弧,满足$e(x \rightarrow y) 都有 l_x+l_y\ge w_e$，后定义相等子图，其包含所有的点，但只包含满足$l_x+l_y=w_e$的所有弧$e(x \rightarrow y)$,这些弧已经是最大的弧，如果有完美匹配，那么可以得到最优分派。KM 算法仅仅只适用于找二分图最佳完美匹配，如果无完美匹配，那么算法很可能陷入死循环（如果不存在的边为 -INF 的话就不会，但正确性就无法保证了），对于这种情况要小心处理。

4. Euler 图和Hamilton 图

1.基本概念

经过G 的每条边的迹叫做G 的Euler 迹；闭的Euler 迹叫做Euler 回路或E
回路；含Euler 回路的图叫做Euler 图。

定理
（i）G 是Euler 图的充分必要条件是G 连通且每顶点皆偶次。

（ ii ） G 是Euler 图的充分必要条件是G 连通且$G=\bigcup_{i=1}^dC_i,C_i$是圈，$E（C_i)\bigcap E(C_j)(i \neq j)$

（iii）G 中有Euler 迹的充要条件是G 连通且至多有两个奇次点。

包含G 的每个顶点的轨叫做Hamilton(哈密顿)轨；闭的Hamilton 轨叫做Hamilton 圈或H 圈；含Hamilton 圈的图叫做Hamilton 图。

Fleury 算法给出了求Euler 回路的算法

Posted on

1. 蒙特卡洛方法

（1）基本思路：

蒙特卡罗方法是一种计算方法。原理是通过大量随机样本，去了解一个系统，进而得到所要计算的值。

（2）一种应用：利用蒙特卡洛方法求积分：

假设我们需要求这样一个图的积分
求积分图1
那么实际上，我们所需要的过程可以表示如下
求积分过程

从这两个过程中，我们可以看到，实际上对于积分的求解可以简化为这样一个过程：

假设要计算的积分如下：

那么如果选择一个概率密度函数为$f_X(x)$的方式进行抽样,并且满足$\int_{a}^{b}f_X(x)\text{d}x=1$,那么令$g^*(x)=\frac{g(x)}{f_X(x)}$,原有的积分可以写成如下形式：

故，我们求积分的步骤为：


1.产生服从分布律$F_X$的随机变量$X_i(i=1,2,…,N)$

2.计算均值

一般采用均匀分布求解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import random

def calpai():
    n = 1000000
    r = 1.0
    a, b = (0.0, 0.0)
    x_neg, x_pos = a - r, a + r
    y_neg, y_pos = b - r, b + r

    count = 0
    for i in range(0, n):
        x = random.uniform(x_neg, x_pos)
        y = random.uniform(y_neg, y_pos)
        if x*x + y*y <= 1.0:
            count += 1

    print (count / float(n)) * 4

(3)蒙特卡洛树搜索

as we know, an important method used in alpha go and alpha zero is Monte Carlo Tree search. So if you want to know more about this method, you can search this website(Monte Carlo Tree search) and get some knowledge yourself. also, you can get information in almost every game theory book.And try to get the big idea in Monte Carlo Tree search.

2. 马尔科夫链

2.1 马尔可夫链的定义

现实世界中有很多这样的现象：某一系统在已知现在情况的条件下，系统未来时刻
的情况只与现在有关，而与过去的历史无直接关系。比如，研究一个商店的累计销售额，
如果现在时刻的累计销售额已知，则未来某一时刻的累计销售额与现在时刻以前的任一
时刻累计销售额无关。上节中的几个例子也均属此类。描述这类随机现象的数学模型称
为马氏模型。

对于马尔科夫链的数学定义，可以直接参照《数学建模算法与应用》（司守奎）。

2.2 马尔科夫链的性质

转移概率矩阵及柯尔莫哥洛夫定理

对于这个性质，可以查看我给出的代码morkov.py进行了解

2.3 马尔科夫链的应用

虽然马尔科夫链的性质极其简单，但是其应用广泛，有着极大的意义。
应用马尔可夫链的计算方法进行马尔可夫分析，主要目的是根据某些变量现在的情
况及其变动趋向，来预测它在未来某特定区间可能产生的变动，作为提供某种决策的依
据。

Posted on

math_modeling competition for 2019 preparation

abstract:

I'd like to record my preparation for this competition, including some tricks on coding, and comperhension on some important math models and algorithms. Also, I'd like to share some interesting tools we can use, such as Gephi, Citespace, and so on.
Meanwhile, I may record some basic knowledge on machine learning and data mining, even includes tensorflow and pytorch framework. So this series will be a hodgepodge of quite many things and knowledge. I hope I can truly learn something by doing so, and also help you work better.

part one

EA (Evolutionary Algorithms)

1. introduce

there are so many algorithms use the idea of evolution, and in the competition of math modeling, it’s so important that almost every time, we can slove a problem using it.

these algorithms include genetic algorithm, ant colony algorithm, Annealing Algorithm, neural network, tabu search and so on. I’d like to put focus on genetic algorithm this time, but I’ll also give some abstract on other algorithms. Also, codes will be shared on this website

2. genetic algorithm

1. 流程图(flow chart)

流程图

2.problem needs sloving
maxf(x1,x2) = 21.5+x1*sin(4*pi*x1)+x2*sin(20*pi*x2)

                     s.t. -3.0<=x1<=12.1

                            4.1<=x2<=5.8

so we’d like to slove this problem using genetic algorithm, to better understand the process of this great algorithm.

3.the big ideas

basic ideas:

  1. 适应度函数(to compute the performance)

    适应度函数能够有效帮助后续的选择过程，进行有条件的保留与选择，帮助进行有效的迭代
  2. 交叉(crossover)

    针对不同的问题有不同的交叉方式，在交叉过程中需要注意保持原有数据的真实性，不能出现超越规则之外的数据。通常，我们设置crossover rate=0.8，能够有效地帮助进行迭代，较快且较好地收敛
  3. 变异(mutation)

    我们一般设置mutation rete=1/L(L: len of vector)，变异能减少收敛到局部最优的可能性，使得整个算法有更好的优化性，能够得到较好的结果
  4. 选择(selection)

    选择是遗传算法中一个非常重要的步骤，通常，选择的方式有多种(including roulette wheel selection, rank selection, tournament selection and Elitism + Offspring selection )，根据不同的问题，采用不同的选择方式，能够得到较好的结果。在这个问题中，我们采用轮盘赌算法来进行选择（关于轮盘赌算法的讲解，你可以查看轮盘赌算法)
    4. the code on this problem
    you can find the code on my github repository MCM/ICM preparation, I save the python code on the floder learning_code.
    Because of the code is a little complicated, so maybe I’ll write down another blog or ipython to denote some details about this process.

other basic algorithms

1. 粒子群算法（蚁群算法）

在使用蚁群算法求解现实问题时，先生成具有一定数量蚂蚁的蚁群，让每一只蚂
蚁建立一个解或解的一部分，每只人工蚁从问题的初始状态出发，根据“激素”浓度来
选择下一个要转移到的状态，直到建立起一个解，每只蚂蚁根据所找到的解的好坏程度
在所经过的状态上释放与解的质量成正比例的“激素”。之后，每只蚂蚁又开始新的求
解过程，直到寻找到满意解。为避免停滞现象，引入了激素更新机制。

2. 遗传退火算法

模拟退火算法得益于材料的统计力学的研究成果。统计力学表明材料中粒子的不
同结构对应于粒子的不同能量水平。在高温条件下，粒子的能量较高，可以自由运动和
重新排列。在低温条件下，粒子能量较低。如果从高温开始，非常缓慢地降温（这个过
程被称为退火），粒子就可以在每个温度下达到热平衡。当系统完全被冷却时，最终形
成处于低能状态的晶体。

在模拟退火算法中应注意以下问题：
（1）理论上，降温过程要足够缓慢，要使得在每一温度下达到热平衡。但在计算
机实现中，如果降温速度过缓，所得到的解的性能会较为令人满意，但是算法会太慢，
相对于简单的搜索算法不具有明显优势。如果降温速度过快，很可能最终得不到全局最
优解。因此使用时要综合考虑解的性能和算法速度，在两者之间采取一种折衷。
（2）要确定在每一温度下状态转换的结束准则。实际操作可以考虑当连续m 次的
转换过程没有使状态发生变化时结束该温度下的状态转换。最终温度的确定可以提前定
为一个较小的值e T ，或连续几个温度下转换过程没有使状态发生变化算法就结束。
（3）选择初始温度和确定某个可行解的邻域的方法也要恰当。

3. 禁忌搜索

禁忌搜索算法是组合优化算法的一种，是局部搜索算法的扩展。禁忌搜索算法是人
工智能在组合优化算法中的一个成功应用。禁忌搜索算法的特点是采用了禁忌技术。所
谓禁忌就是禁止重复前面的工作。禁忌搜索算法用一个禁忌表记录下已经到达过的局部
最优点，在下一次搜索中，利用禁忌表中的信息不再或有选择地搜索这些点。
禁忌搜索算法实现的技术问题是算法的关键。禁忌搜索算法涉及侯选集合、禁忌
对象、评价函数、特赦规则、记忆频率信息等概念。

4. 神经网络

由于神经网络有极大的用途，一般会用其来进行深度学习，所以如果有时间的话，我会更新关于深度学习的部分博客用以记录和交流，故神经网络在这里不再提及。

当然，对于神经网络的搭建，现在已经有许多开源的框架，我在后续的博客中将使用pytorch框架，并尝试使用fastai 来实现相关的一些项目。

5. all in all

我们已经看到了一个简单的遗传算法，就要使用上百行的python代码来实现，那么显然，既然在matlab 中有实现相关进化算法的框架，在python中同样也有，推荐的一个是geatpy。
你可以使用 

pip install geatpy

来安装它。同时，你也可以通过这个网站geatpy来学习具体的框架，希望它能帮助你更好地掌握进化算法。