Veirlog学习记录-5-循环移位数码管的设计与实现

Posted on

实现功能：在开发板的数码管上显示特定数字，并且让这些数字循环移位。

总体框图如下：
总体框图

代码如下：

分频模块：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
module div(
    input clk, //输入自带的系统时钟(100Mhz)
    input rst, //复位
    output scan_clk //输出时钟，用于驱动数码管，让其动态扫描用
    );
    reg [19:0] clkdiv;
    
    always @(posedge clk or posedge rst)
    begin
        if( rst == 1)  clkdiv <=0;
        else  clkdiv <= clkdiv + 1;
    end
    assign scan_clk = clkdiv[15]; //使得san_clk = 190Hz
endmodule

其他模块（显示模块）：

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
module otherModel(
    input rst,
    input scan_clk,
    
    output reg [7:0] an,
    output reg [6:0] seg
    );
    reg [3:0] digit;  //选择位上显示的数字
    reg [2:0] cnt;  //选择哪一位显示
    
    always @(posedge scan_clk or posedge rst)
        begin
        if ( rst == 1) cnt <=0;
        else cnt <=cnt + 1;
        end
    
    always @ (*)
    begin
        case ( cnt )
        3'b000:begin digit = 4'b0000; an = 8'b01111111; end
        3'b001:begin digit = 4'b0001; an = 8'b10111111; end
        3'b010:begin digit = 4'b0010; an = 8'b11011111; end
        3'b011:begin digit = 4'b0011; an = 8'b11101111; end
        3'b100:begin digit = 4'b0100; an = 8'b11110111; end
        3'b101:begin digit = 4'b0101; an = 8'b11111011; end
        3'b110:begin digit = 4'b0110; an = 8'b11111101; end
        3'b111:begin digit = 4'b0111; an = 8'b11111110; end
         default:begin digit= 4'b0000; an = 8'b01111111; end
        endcase
    end
    
    always @ (*)
      begin
         case ( digit )
         4'b0000:seg = 7'b0100100;
         4'b0001:seg = 7'b1000000;
         4'b0010:seg = 7'b1111001;
         4'b0011:seg= 7'b0000000;
         4'b0100:seg =7'b0100100;
         4'b0101:seg =7'b1000000;
         4'b0110:seg =7'b1111000;
         4'b0111:seg =7'b0000000;
         default: seg = 7'b0000001;
         endcase
     end
         
         
         
endmodule

顶层模块：

1
2
3
4
5
6
7
8
9
10
module top(
    input clk,
    input rst,
    output [7:0] an,
    output [6:0] seg
    );
    
    div u1(clk,rst,scan_clk); //例化模块
    otherModel u2(rst,scan_clk,an,seg);
endmodule

测试文件：
注意：测试文件是针对otherModel文件的。在写测试文件之前，最好不要添加顶层模块，否则测试时会找不到想要测试的那个文件。如果，已经编写完了顶层模块，可以在design列表中，右键要测试的文件，然后点击 设置为顶层文件，这样就会测试到指定的文件了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
module otherModel_tb();
    reg rst,scan_clk; //输入信号要用 reg型
    wire [7:0] an; //输出信号要用 wire型
    wire [6:0] seg; //输出信号
    
    otherModel test(
                     .rst(rst),
                     .scan_clk(scan_clk),
                     .an(an),
                     .seg(seg)
                     
                        );
     initial fork
           scan_clk = 0;
           rst = 1; #50 rst = 0;
     join
                              
     always #10 scan_clk = ~scan_clk; //定义没过10毫秒，信号就会进行翻转
     
endmodule

仿真波形如下：
仿真结果
我也写了几篇关于Veirlog的文章，感兴趣的同学可以去看看。该模块链接如下：
Verilog学习

matlab实现随机攻击网络节点+蓄意攻击网络节点(2)

Posted on

更新：

有同学反馈说：网络效率的函数可能有点问题。可以试试这个网络效率函数，对应的部分改一下就可以了。

还有最大连通子图比例函数：最大连通子图比例函数



上一篇介绍了随机攻击网络节点与蓄意攻击节点的基本方法。上一篇文章地址：matlab实现随机攻击网络节点+蓄意攻击网络节点（1）

其中随机攻击的部分还有一些瑕疵，就是在实际的研究中，需要对网络进行多次（数十次甚至上百次）攻击后取指标变化平均值，这样的实验数据才具有一定的说服力。

其实这个问题乍一听起来，原理也比较简单：就是让一个程序运行指定的次数然后，累加程序中某一个变量后取平均值。

实现起来也并不费劲，首先就是把这个程序定义为一个函数，然后把所需要累加的变量作为函数的返回值。然后在另一个文件中创建循环，在循环中调用该函数，用一个变量接收该函数的返回值，以达到累加的效果，最后在循环外部取一个平均值即可。

代码如下所示：

定义函数文件名称（该名称需要与函数名称相同）

函数的参数介绍：

输入值： str：意为数据文件的路径；numDelete:删除节点的个数（这里的命名只是为了方便并不是必选项）
返回值：Eglob，即网络效率值的数组

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
function Eglob = ATestAver(str,numDelete)
%输入 ： 
%        str：意为数据文件的路径
%        numDelete:删除节点的个数

%返回值：Eglob，即网络效率值的数组

%加载数据文件
load(str);

Name_Struct = Node_Key_Sort_Descend;       %  Name_Struct 数据集名称，更换网络数据集时，需要更改此处结构体名称
A_Init =  Name_Struct.Adjacent_Matrix;      %% 网络邻接矩阵
N_Init = size(A_Init,1);                     %% 节点个数

NetEff_Init = zeros(1,numDelete);
Struct_Init = struct('Deg',NetEff_Init);

% 初始网络性能
%生成随机数，以此进行随机攻
Name_Struct.Node_Key_Degree = randperm(440);

%% 
%  按照 Degree 算法排序，删除节点
A = A_Init;          %% 网络邻接矩阵 A
for i = 1:numDelete
     % 按照 Degree 算法排序，删除节点       
end

定义测试文件：

文件中需要定义随机攻击的次数和随机攻击节点的个数，具体参数设置应视具体网络而定。
在调用函数时，要传入文件路径，和删除节点的个数。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
%定义随机攻击节点的个数，具体数值根据网络规模拟定
numDelete = 22;

%定义网络效率初始矩阵
netSum = zeros(1,numDelete);

%定义随机攻击的次数，也就是函数循环的次数
numRandom = 50;
for i=1:numRandom
    
    %把得到的网络效率数组赋给netI
    netI = ATestAver('Data\12_15jiaQuanData.mat',numDelete);
    %累加
    netSum = netSum + netI;
end

%求出平均值
netAver = netSum/numRandom;

我的测试数据具有小世界特性与无标度特性。并得到了以下的结果:
例子
大家可以看出，经过多次随机攻击取指标平均值之后，曲线近似于一条直线，下降速率较小且符合实际的网络情况。验证了无标度网络对于随机攻击拥有较好的鲁棒性。

希望本文对大家有所帮助，有任何问题或者是建议，欢迎大家与我交流。

matlab实现随机攻击网络节点+蓄意攻击网络节点(1)附github完整工程地址

Posted on

更新：

有同学反馈说：网络效率的函数可能有点问题。可以试试这个网络效率函数，对应的部分改一下就可以了。

还有最大连通子图比例函数：最大连通子图比例函数

在研究网络的鲁棒性的时候，我们往往会通过随机与蓄意攻击网络节点，观察网络效率的下降比例来进行网络特性的研究。

常见的指标有：最大连通子图比例、网络效率、平均距离等等。
这三个指标是不同的，但是实现随机攻击与蓄意攻击的原理是相同的，这里以按照节点度攻击的网络效率变化为例（其他两个指标就是函数不同，想按照其他节点重要度排序指标，也是类似的，只需要按照想要的排序方法得出节点的排序即可）。

就是按照节点的重要性排序，通过循环来删除节点。把临界矩阵中节点对应的行和列先置0，然后再删除。每删除一次节点，就生成了一个新的邻接矩阵，然后每一次都通过testEglob函数计算出当前的网络效率值。

首先需要准备的数据如下：

网络的邻接矩阵，节点度的排序（从大到小排名，度大的排名靠前）。

节点度的排名要按照节点的编号排序，下图是一个简单的例子，建议先在Excel中排列好了，然后再复制到Matlab中转置一下保存为mat文件就可以了。

度排序示例

明白了蓄意攻击的原理，那么随机攻击的原理也比较好理解了，蓄意攻击是按照节点重要度排序进行的攻击，那么随机攻击可以理解为给所有节点随机赋排名，所以攻击的时候就等效于随机攻击了。也就是说，在随机攻击时，你只需要在蓄意攻击的基础上添加一行代码，把度排序的数组赋值上长度相同的一个随机数组，即：

1
Name_Struct.Node_Key_Degree = randperm(440);

具体代码如下：

主函数： testRandom（命名随意。。。）
作用：原理挺简单的，就是通过循环来删除节点。把临界矩阵中节点对应的行和列先置0，然后再删除。每删除一次节点，就生成了一个新的邻接矩阵，然后每一次都通过testEglob函数计算出当前的网络效率值。

部分代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
% 蓄意攻击：按照节点重要性顺序，一次攻击一个节点

clc;
clear; 

         
% 初始网络性能
%生成随机数，以此进行随机攻击（注释掉即为蓄意攻击），随机数值改为你自己网络的节点数
Name_Struct.Node_Key_Degree = randperm(440);

%%
%  按照 Degree 算法排序，删除节点
A = A_Init;          %% 网络邻接矩阵 A
B=[];                %%定义空数组，接收被删除的节点序号

for i = 1:NumDelete
     %% 删除节点 Node_Key_Degree(i),用 0 占位，不能置空
    B(i) = Name_Struct.Node_Key_Degree(i);
    Con_Index_NetEff = testEglob( AA );
    Eglob(i) = Con_Index_NetEff.Net_Eff_Mymod;
end          

%接下来就是生成网络连通效率图
%Eglob存储了相应的网络效率的数值

正常情况下，一次随机攻击并不能说明什么，一次随机攻击的数据也并不可靠，所以需要多次随机攻击之后取平均值，这样得出的数据才更具有说服力，下一篇将介绍如何实现，matlab实现随机攻击网络节点+蓄意攻击网络节点（2）

希望对大家有所帮助，有任何疑问欢迎与我交流，谢谢你的时间。

Veirlog学习记录(4)分频模块+层次化的模块设计

Posted on

 前三篇文章都是单一模块的设计，然后测试是否来完成特定的功能，不过这种方法只能解决一些简单的问题，所以实际中需要层次花的设计。

​ 这次给大家分享的就是一个层次化的设计，移位寄存器模块+分频模块，然后再用顶层文件把它们组合在一起。

​ 寄存器模块：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
module shift1(clk,D,MD,QB);

    input clk;  //时钟信号
    input [7:0] D;  //预置数，可以在测试文件中预置，或者在板子上选取
    input [1:0] MD;  //模式选择数值
    output [7:0] QB;  //输出的数值
    reg [7:0] REG;  //定义寄存器类型
       
    always @ ( posedge clk ) begin  //对时钟信号上升沿敏感
        case (MD)   //根据MD的数值，选择模式
            2'b01: begin REG[0] <= REG[7] ; REG[7:1] <= REG[6:0]; end //循环左移
            2'b10: begin REG[7] <= REG[0] ; REG[6:0] <= REG[7:1]; end //循环右移
            2'b00: begin REG <= D; end  //加载预置的数值
      
       endcase
       end
       assign QB[7:0] = REG[7:0];   //把REG中的数值赋给QB
          
       endmodule

​ 分频模块：

​ 记得一开始的十进制可加可减计数器设计中，我们没有用分频模块，而是把时钟模块绑到了一个按键上，然后按一次表示一个时钟，这样很麻烦，引入分频模块就很有必要了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
module div(
    input div_rst,
    input div_clk,  //输出的时钟是100M的
    output clk_out
    );
    reg [30:0] div_q;
    reg temp;
    always @ (posedge div_clk or posedge div_rst)
    begin
        if ( div_rst == 0 ) div_q <= 0;
        else if( div_q == 50000000) //保证输出的时钟是1s一次的
            begin
         div_q <= 0; temp <= ~temp;
            end
        else div_q <= div_q + 1;
     end
     assign clk_out = temp;
endmodule

​ 顶层文件：

1
2
3
4
5
6
7
8
9
10
11
12
module top(
    input clk,
    input rst,
    input [7:0] D,
    input [1:0] MD,
    output [7:0] QB);
    
    wire a; //这个a就是把分频模块输出的时钟信号接入到寄存器模块中
    div u1 (rst,clk,a); //把模块和顶层连接起来，子模块名字要和之前起的一致
    shift1 u2 (a,D,MD,QB);//要注意：这里输入输出端的排布顺序要和在子模块写的顺序一致，否则就会报错。
    
endmodule

注意：
测试子模块时，比如寄存器模块，那么写完这个模块时，就应该编译，然后写测试文件直接就测试，不要先等写完顶层模块再测试，否则系统会默认测试的是顶层文件，可能会导致没有任何输出产生的情况。

​ 如果没有什么问题，你写顶层文件，然后保存，会出现如下的样子：

​ 表明顶层文件和子模块联系成功，编译没有错误之后，就可以进行下一步了。顶层模块也可以不用测试，如果不写测试文件的话，可以选择 综合下面的：

​ 然后就可以看形成的逻辑图，再比对是否哪里有问题，按照以上程序设计会生成以下的图：

移位寄存器模块如何编写测试文件，可以参考如下链接：
https://blog.csdn.net/weixin_43877139/article/details/88851235

我也写了几篇关于Veirlog的文章，感兴趣的同学可以去看看。该模块链接如下：
Verilog学习

阿里云Ubuntu18.04服务器安装Mono_C#开发环境

Posted on

重要：安装Mono一定要参照官方文档

一开始安装的时候走了很多的弯路，就是没看官方帮助文档。实际上当你想安装什么东西，首选就是官方文档，其次才是别人的经验把。

官方帮助文档：https://www.mono-project.com/download/stable/#download-lin

这里面介绍的很清楚：对于不同的系统也有自己的安装方法。

第一种方法：直接安装

第一步：

1
sudo apt-get update

第二步：

1
2
3
4
5
6
7
sudo apt install gnupg ca-certificates

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF

echo "deb https://download.mono-project.com/repo/ubuntu stable-bionic main" | sudo tee /etc/apt/sources.list.d/mono-official-stable.list

sudo apt update

第三步：

根据自己的需要，可以根据官方文档中的提示，选择安装不同的类库。这种方式可能会出现下载速度过慢的情况，可以把安装源换为国内的，然后使用，具体请Goole或者百度。

第二种：解压缩方式或者直接从网站安装

我这里选择的是5.20.1.19版本，你可以自行选择下载安装的版本。
下载地址：http://download.mono-project.com/sources/mono/

第一步：

1
sudo apt-get update

第二步：

1
2
3
4
5
6
7
8
9
10
11
12
13
cd /usr/local/src/

sudo wget http://download.mono-project.com/sources/mono/mono-5.20.1.19.tar.bz2

tar -jxvf mono-5.20.1.19.tar.bz2

cd mono-5.20.1.19

sudo ./configure --prefix=/usr

sudo make

sudo make install

sudo make这一步执行之后，可能提示你缺少 cmake 这个依赖。执行

1
sudo apt install cmake

之后继续步骤就可以了。

这些步骤执行之后，可以输入 mono -V 查看版本信息。如下图一样便是成功了。

实际上感觉在ubuntu系统的服务器发布C#写的网页还是比较费劲的，推荐还是用Windows server系统安装IIS来发布Asp.net网站。最近我也在弄这个，有兴趣的朋友可以去看我发的相关内容。

Veirlog学习记录(3)--移位寄存器(左循环，右循环)的实现

Posted on

移位寄存器的设计：
有三个模式：

  • 左循环

  • 右循环

  • 加载预置的数

  • 具体功能可以根据需要对程序做出一些修改即可

    代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
module shift1(clk,D,MD,QB);

    input clk;  //时钟信号
    input [7:0] D;  //预置数，可以在测试文件中预置，或者在板子上选取
    input [1:0] MD;  //模式选择数值
    output [7:0] QB;  //输出的数值
    reg [7:0] REG;  //定义寄存器类型
       
    always @ ( posedge clk ) begin  //对时钟信号上升沿敏感
        case (MD)   //根据MD的数值，选择模式
            2'b01: begin REG[0] <= REG[7] ; REG[7:1] <= REG[6:0]; end //循环左移
            2'b10: begin REG[7] <= REG[0] ; REG[6:0] <= REG[7:1]; end //循环右移
            2'b00: begin REG <= D; end  //加载预置的数值
      
       endcase
       end
       assign QB[7:0] = REG[7:0];   //把REG中的数值赋给QB
          
       endmodule

测试文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
module shift1_tb();
    reg clk;
    reg [7:0] D;
    reg [1:0] MD;
    wire [7:0] QB;  //输出
              
   initial 
        begin  //初始化
        clk = 0;
        D = 8'b11110000;  //初始化待移数值（这样赋值只是为了最后好观察波形） 
        MD = 2'b00;  //以置数模式开始
        end 
        
         always #10 clk = ~clk;  //时钟信号
        always #100 MD = MD+1；//循环改变模式，
 
     shift1 test( .clk(clk),
                     .D(D),
                     .MD(MD),
                     .QB(QB)
                  );
       
endmodule

这里图形没有从一开始截取，而是选择能看到三个模式效果的时间段，MD=0时，一直在加载预置数，输出等于D 11110000.MD=1时，开始循环左移。MD=2时，开始循环右移。

基本的设计就是这样子，可以在它的基础上进行改进，以达到大家需要的功能，比如在shift1中的case加几个模式。D的值也可以随便赋值。

我也写了几篇关于Veirlog的文章，感兴趣的同学可以去看看。该模块链接如下：
Verilog学习

Veirlog学习记录(2)--十(多)进制可加可减计数器的实现

Posted on

上一篇实现的是，十(多)进制的加计数。

这次是要加上减计数，也就是实现可加可减的操作，并且在板子上验证，这次设计没有加分频模块，时钟脉冲是用按键控制的，加分频也可以。

如果要加上一个减的功能，就是要在加计数的基础上加一个使能端up_down，使能端为1的时候，自加。为0的时候自减。同时从0减到9的时候要有一个借位。

代码如下：

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
module M10_updown( 
    input EN,CP,Rd,up_down, //up_down=1时加计数，up_down=0时减计数
    output reg Cout,
    output reg [3:0] Q
    );
    always @ (posedge CP,negedge Rd)
    
       if( ~Rd ) Q<=4'b0000;  
        else if(EN&&up_down)  //当使能端为1，且选择加计数时，开始加计数
        begin
            if(Q<4'b1001) Q<=Q+1'b1; //判断是否加到了9
            else Q<=4'b0000;
          end
             else if ( EN && ~up_down )//当使能端为1，且选择加计数时，开始减计数
                 begin
                    if ( Q>4'b0000) Q<=Q-1'b1;//判断是否减到了0
                    else Q<= 4'b1001;
                 end
                 else Q<= Q;
    always @ (Q)
    
       if(Q==4'b1001 && up_down)  Cout = 1;//当加计数时 加到了9，进位
        else if(Q==4'b0000 && ~up_down) Cout = 1;//当减计数时 减到了9，借位
          else Cout=0;
          
    endmodule

​

测试文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
module M10_updown_tb();
    reg EN,CP,Rd,up_down;     //输入端口说明
    wire Cout;           //进位信号
    wire [3:0] Q;     //数据输出端口及变量的数据类型生命
    M10_updown test( .EN(EN),   //M10_updown这的名称要和design的文件名一致
                    .CP(CP),
                    .Rd(Rd),
                    .up_down(up_down),
                    .Cout(Cout),
                    .Q(Q) );
    initial fork
        CP=0;
        EN=1; #20 EN=0;#50 EN=1;
        Rd=0; #30 Rd=1;
        up_down=0; #300 up_down=1;
     join
    always #8 CP=~CP;
    
endmodule

仿真图如下：

然后就是布局布线，添加约束文件。接上板子就ok了。

我也写了几篇关于Veirlog的文章，感兴趣的同学可以去看看。该模块链接如下：
Verilog学习

win10完整Tensorflow-GPU环境搭建教程(附CUDA+cuDNN安装过程)

Posted on

最近一直想要用GPU训练一个五子棋AI，无奈自己的笔记本是A卡，速度太慢，计算一局需要7、8分钟。所以在之前安了Ubuntu虚拟机，使用了ROCm框架，训练速度提升为一局1、2分钟，但其实速度还是很慢。这两天实验室老师拿来了一台主机，配置：Nvidia 显卡，GeForce GTX1660。所以就想安一下GPU，安了一下午，终于可以调用GPU训练了，速度为1分钟12局。。。真是舒服了。

1.查看你的显卡是否支持GPU

点击查看显卡是否支持GPU

满足之后就可以进行下面的步骤了。

2.安装python环境

其实大家知道，安装python环境可以直接安装，也可以通过Anaconda安装，Anaconda安装时候需要注意你想要安装python版本，如果不想要默认自带的python版本，就不要勾选

建议不要勾选把path直接加入到环境变量中：

安装好之后，打开Anaconda命令行，输入conda -V，如果输出是你所安的版本，即为成功。

3.安装Tensorflow-GPU

可以打开tensorflow官网：https://www.tensorflow.org/install/install_windows#installing_with_anaconda ，可以了解下官网上有详细的教程。

我是新建了一个名为“tensorflow”的conda环境：版本可以自选，要注意tensorflow-GPU与python版本对应

1
conda create -n tensorflow pip python=3.6

推荐更换国内的源，速度会快很多的。

然后要激活环境，才能继续在这个环境下安装tensorflow-GPU。当然你也可以不新建一个环境，直接就在anaconda环境下安装也是可以的。

1
activate tensorflow

下面进行安装tensorflow-GPU，虽然换源了，但你会发现下载还是会很慢。

1
pip install --ignore-installed --upgrade tensorflow-gpu

推荐使用这行代码下载：

1
2
3
4
5
6
pip install --ignore-installed --upgrade tensorflow-gpu -i https://pypi.tuna.tsinghua.edu.cn/simple

这样安装的版本可能不是你所需要的，可以指定tensorflow的版本安装，只需在tensorflow-gpu后面指定版本即可，即改为：我安装的tensorflow-gpu 1.14.0版本

pip install --ignore-installed --upgrade tensorflow-gpu==1.14.0 -i https://pypi.tuna.tsinghua.edu.cn/simple

4.安装CUDA ToolKit +cuDNN

第一步要查看要安装的CUDA + cuDNN版本，因为大家要安的tensoflow版本不一样，所以对应的CUDA 和cuDNN版本也就不一样，所以一定要对应上，否则就会报错。

可以点击查看你所要安装的tensorflow所对应的版本cuDNN和CUDA版本

记得点击右上角的 语言选项，把中文改成英语，否则最新的版本显示不出来。然后点击左侧栏的windows

Image

然后向下翻，翻到这里，查看对应关系，我要安的是1.14.0，所以按第一行的对应版本安装

Image

然后下载CUDA + cuDNN

在这个网址查找CUDA已发布版本：https://developer.nvidia.com/cuda-toolkit-archive

按照刚才官网提示进行下载，我下载的是10.0本地安装版本。

下载好CUDA Toolkit 10.0 后，我们开始下载cuDnn 7.4，需要注意的是，下载cuDNN需要在nvidia上注册账号，使用邮箱注册，完全免费的。登陆账号之后才可以继续下载。

一定要按照tensorflow官网的提示，选择安装CUDA和cuDNN的版本，一定要对应好。

cuDNN历史版本在该网址下载网址：https://developer.nvidia.com/rdp/cudnn-archive

下载之后，下面进行安装。

注意：最重要的一步，先卸载原有的显卡的驱动。

CUDA Toolkit需要在指定版本显卡驱动环境下才能使用，如果已经安装了nvidia显卡驱动，再安装CUDA Toolkit时，会因二者版本不兼容而导致CUDA无法使用。而CUDA Toolkit安装包中自带与之匹配的显卡驱动，所以一定要删除电脑先前的显卡驱动。

大家可以在左下角的 小娜 中搜索，NVIDIA GeFore Experience(我安装的驱动是这个，具体还要看你自己的驱动名称，一定要找好了，别删错了)，找到之后，卸载掉就可以安装CUDA Toolkit了。建议先把自己原来的驱动型号先记下来，万一出什么问题，还可以补救。

先安装CUDA Toolkit,安装路径默认就可以了，但是要记住这个路径，一会还有用。接下来就是安装了，在安装选项时，选择自定义，然后在自定义安装选项中，勾选所有的安装项，然后就可以了。

接下来将cudnn的那个压缩包解压，里面有三个文件夹，直接复制到CUDA的根目录下就可以，例如这个路径下：C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0，然后进行环境变量配置。记住：要改成你自己的路径，否则系统是找不到。

1
2
3
4
5
6
7
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0\bin

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0\lib\x64

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0\libnvvp

到这里安装步骤已经全部完成，下面就可以开始愉快的测试了。

5 测试

在你的环境下依次运行代码：

1
2
3
4
5
python

import tensorflow as tf 

tf.test.gpu_device_name()

我的命令行输出的是：

上面是自己机器还有GPU的信息，出现的最后一句：‘/device：GPU：0’ 则说明安装成功了。

查看在使用那个GPU，依次输入代码：

1
2
3
from tensorflow.python.client import device_lib

device_lib.list_local_devices()

我这个主机只有一块GPU，所以输出的信息也是只有一块。

至此，终于安装完成了。。。

真心希望这个教程可以帮助到大家，少走一些弯路，早点开始调用GPU训练，说句题外话：训练的速度是真的快啊，如有任何疑问，欢迎交流。

tensorflow在AMD上用ROCm框架实现GPU训练

Posted on

众所周知，a卡对于tensorflow gpu的支持很小，要想使用的话一般都得配n卡的电脑。而我只是感兴趣一个项目，想要跑出来一个模型，如果不用gpu加速，可能得跑一个月，所以不得不寻找在a卡上的解决方案。好在，终于找到了一个解决方案，虽然只是取巧，速度也不如正常n卡跑的快，但已经很不错了。

1
2
3
4
我的配置：
显卡：RX 550
所用系统：虚拟机ubuntu 18
注：如果是虚拟机的话，最好分配3GB内存或以上，否则可能无法import tensorflow

a卡上支持的ROCm框架，暂时只支持ubuntu系统。如果你是windows系统，可以安一个虚拟机，道理是一样的，我也是在虚拟机上跑的。要注意，你的AMD显卡是否支持ROCm框架，请参考以下链接确定你的显卡是否支持。https://rocm.github.io/hardware.html 。还有你的工程如果不是python3.5\3.6,你也用不了。

如果条件都符合，就可以开始愉快的安装了。（变通的法子就是费劲儿。。。）

更新系统

建议：把源换为国内的，比如阿里的，会快很多的。

1
2
sudo apt update
sudo apt upgrade

安装ROCm

添加ROCm库（没有这一步，会提示找不到 软件包）

1
2
wget -qO - http://repo.radeon.com/rocm/apt/debian/rocm.gpg.key | sudo apt-key add -
sudo sh -c 'echo deb [arch=amd64] http://repo.radeon.com/rocm/apt/debian/ xenial main > /etc/apt/sources.list.d/rocm.list'

安装必要的软件包

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
sudo apt update && sudo apt install -y \
  build-essential \
  clang \
  clang-format \
  clang-tidy \
  cmake \
  cmake-qt-gui \
  ssh \
  curl \
  apt-utils \
  pkg-config \
  g++-multilib \
  git \
  libunwind-dev \
  libfftw3-dev \
  libelf-dev \
  libncurses5-dev \
  libpthread-stubs0-dev \
  vim \
  gfortran \
  libboost-program-options-dev \
  libssl-dev \
  libboost-dev \
  libboost-system-dev \
  libboost-filesystem-dev \
  rpm \
  wget

安装ROCm驱动

1
2
3
4
5
6
7
8
9
sudo apt update && \
    sudo apt install -y --allow-unauthenticated \
    rocm-dkms rocm-dev rocm-libs \
    rocm-device-libs \
    hsa-ext-rocr-dev hsakmt-roct-dev hsa-rocr-dev \
    rocm-opencl rocm-opencl-dev \
    rocm-utils \
    rocm-profiler cxlactivitylogger \
    miopen-hip miopengemm

提示：rocm-dkms这一步下载的非常的慢，也和你的网络状况相关，我下的时候慢的时候10几k，快的时候有200。一共大概要下载500m,耐心等待一下吧。

添加用户

1
2
sudo adduser $LOGNAME video
sudo reboot

安装miniconda（体积小、方便）

在使用python时我们很多时候会用到conda，但是conda会改变python的一些配置。所以我们先安装conda，这样就不会出现在使用tensorflow时需要使用/usr/bin/python3这样的命令。

下载地址（64位）：https://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Linux-x86_64.sh

1
2
3
cd 下载目录
chmod +x ./Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh

这一步安装的时候，会让你先阅读一个license，按enter到一个栏让你选择输入yes/no，当然选yes，然后进入下一步是选择安装路径，如果选择默认路径，就按enter，然后就会出现安装的信息，安装好之后会退出来。可以新建一个终端，验证一下是否安装成功：

1
2
3
4
5
6
7
8
9
10
11
12

conda -h

#输出以下信息就是成功了

usage: conda [-h] [-V] command ...

conda is a tool for managing and deploying applications, environments and packages.

Options:

.....

ROCm版的tensorflow仅支持3.5和3.6，我的项目也是3.6的，所以需要新建一个环境。

1
conda install python=3.6

安装python相关的软件包

1
2
3
4
5
6
7
8
9
sudo apt update && sudo apt install -y \
    python3-numpy \
    python3-dev \
    python3-wheel \
    python3-mock \
    python3-future \
    python3-pip \
    python3-yaml \
    python3-setuptools

安装TensorFlow

1
pip3 install --user tensorflow-rocm -i https://pypi.tuna.tsinghua.edu.cn/simple

下载的速度很快。之后就可以验证是否成功了。

1
2
3
4
5
python

import tensorflow as tf

tf.__version__

如果import没报错，然后最后输出了tensorflow的版本，我的是1.14.1。说明一切顺利，可以愉快的开始玩耍了。

import tensorflow这一句我碰到了两个bug，给大家贴出来，避一避。

1.ImportError: librccl.so: cannot open shared object file: No such file or directory During handling of the above exception, another exception occurred:

解决：Google到的。输入以下命令，安装这些包。

1
sudo apt-get update &&  sudo apt-get install -y --allow-unauthenticated  rocm-dkms rocm-dev rocm-libs rccl  rocm-device-libs  hsa-ext-rocr-dev hsakmt-roct-dev hsa-rocr-dev  rocm-opencl rocm-opencl-dev  rocm-utils  rocm-profiler cxlactivitylogger  miopen-hip miopengemm

2.terminate called after throwing an instance of ‘std::bad_alloc’ what(): std::bad_alloc 已放弃 (核心已转储)

解决：Google一下，你就知道。这句话的意思是虚拟机内存分配的不够，我原来只分配了2G的内存，加到3G以后，再import tensorflow就好用啦。

希望这个教程能帮助到大家，也希望大家都可以用a卡跑gpu。更简单的方法还是换电脑啊。。。。

Veirlog学习记录(1)--十进制计数器

Posted on

 最近在学校上FPGA这门课，课上做了一些小实验，现在记录一下。
我所使用的软件是vivado2015.4

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
module M10_counter(
    input EN,   //使能端
    input CP, //时钟
    input Rd, //清零
    output reg Cout, //进位
    output reg [3:0] Q //输出
    );
    
always @ (posedge CP,negedge Rd)
if(~Rd) Q<=4'b0000;  //异步清零
else if(EN) begin
    if(Q<4'b1001) Q<=Q+1'b1; //加计数
    else Q<=4'b0000;
end
else Q<=Q;
   always @ (Q)
    if(Q==4'b1001) Cout =1; //进位
    else Cout=0;
    
endmodule

测试文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
module M10_counter_tb();
    reg EN,CP,Rd;
    wire Cout;
    wire [3:0] Q;
    M10_counter test(.EN(EN),
                     .CP(CP),
                     .Rd(Rd),
                     .Cout(Cout),
                     .Q(Q)  );
        initial fork
            CP=0;
            EN=1; #20 EN=0; #50 EN=1;
            Rd=0; #30 Rd=1;
           join
           always #8 CP=~CP;
endmodule

仿真图：

同理可以改成任意进制，或者是可以改成减计数。

希望会对你有所启发。

更多内容可访问：

Verilog学习

© 2025 Three purple's blog All Rights Reserved. 本站总访客数 加载中... 人 | 本站总访问量 加载中... 次
Theme by hiero