som.v

拿verilog编写的som(自适应神经网络算法)

/////////////////////////////////////////////////////////////////////////////////////
//$DATE 2006/08/28
//$ATTHOR
//////////////////////////////////////////////////////////////////////////////////////

`include "define.v"
`include "220model.v"
`include "get_max6x1.v"
/////////////////////////////////////////////////////////////////////////////////////
module     som(  //input
                   clk,
                   init_wts,
                   start_train,
                   load_x,
                   X1,
                   X2,
                   X3,
                 //outputs
                   single_data_finish,
                   frame_finish,
                   pos_x,
                   pos_y,
                   test
               );
input                                clk,
                                     init_wts,
                                     start_train,
                                     load_x;
input      [`BIT_WIDTH_DATA-1:0]     X1,
                                     X2,
                                     X3;
output                               single_data_finish;
output                               frame_finish;
output     [`BIT_WIDTH_DATA-1:0]     pos_x,
                                     pos_y;
reg                                  single_data_finish,
                                     frame_finish;
wire       [2:0]                     winner_x,
                                     winner_y;
reg        [3:0]                     NC;                      //SOM算法中的邻域函数
reg        [10:0]                    lammda;                  //SOM算法学习因子
reg        [3:0]                     Nc;
reg        [10:0]                    lam;
//reg        [2:0]                     p_x,p_y;
output     [`BIT_WIDTH_DISTANCE-1:0] test;                                                                      
reg        [`BIT_WIDTH_DISTANCE-1:0]  distance[`AREA_NUM-1:0];
reg        [`BIT_WIDTH_DATA-1:0]      weights1[`AREA_NUM-1:0];
reg        [`BIT_WIDTH_DATA-1:0]      weights2[`AREA_NUM-1:0];
reg        [`BIT_WIDTH_DATA-1:0]      weights3[`AREA_NUM-1:0];
reg        [5:0]                  state1,state2,state3;
reg        [2:0]                  state;
reg        [9:0]                  count_num;

reg        [`BIT_WIDTH_DATA:0]        data_temp_b1,data_temp_b2,data_temp_b3; 

wire       [`BIT_WIDTH_DISTANCE-1:0]  distance_temp1,distance_temp2,distance_temp3;
reg        [`BIT_WIDTH_DATA:0]        wts_temp1,wts_temp2,wts_temp3;
wire       [`BIT_WIDTH_DATA-1:0]        deta1,deta2,deta3;  
integer file_p; 
integer i,j;                              
/////////////////////////////////
initial 
  begin
    file_p=$fopen("wts.dat");
    #6000000 $fclose(file_p);
  end
assign test=state;//distance[35];//{winner_x,winner_y};//{winner_x,winner_y};//distance[1];  
////////////////////////////////////////////
lpm_mult mul_distance1(
                .dataa(data_temp_b1),
                .datab(data_temp_b1),
                .result(distance_temp1)
                            );
defparam mul_distance1.lpm_widtha=`BIT_WIDTH_DATA+1;
defparam mul_distance1.lpm_widthb=`BIT_WIDTH_DATA+1;
defparam mul_distance1.lpm_widthp=`BIT_WIDTH_DISTANCE;
defparam mul_distance1.lpm_widths=2*(`BIT_WIDTH_DATA+1);
defparam mul_distance1.lpm_representation="SIGNED";

lpm_mult mul_distance2(
                .dataa(data_temp_b2),
                .datab(data_temp_b2),
                .result(distance_temp2)
                            );
defparam mul_distance2.lpm_widtha=`BIT_WIDTH_DATA+1;
defparam mul_distance2.lpm_widthb=`BIT_WIDTH_DATA+1;
defparam mul_distance2.lpm_widthp=`BIT_WIDTH_DISTANCE;
defparam mul_distance2.lpm_widths=2*(`BIT_WIDTH_DATA+1);
defparam mul_distance2.lpm_representation="SIGNED";

lpm_mult mul_distance3(
                .dataa(data_temp_b3),
                .datab(data_temp_b3),
                .result(distance_temp3)
                            );
defparam mul_distance3.lpm_widtha=`BIT_WIDTH_DATA+1;
defparam mul_distance3.lpm_widthb=`BIT_WIDTH_DATA+1;
defparam mul_distance3.lpm_widthp=`BIT_WIDTH_DISTANCE;
defparam mul_distance3.lpm_widths=2*(`BIT_WIDTH_DATA+1);
defparam mul_distance3.lpm_representation="SIGNED";

////////////////////////////////
wire         [2:0]    index1,index2,index3,index4,index5,index6;
wire         [`BIT_WIDTH_DATA-1:0]    D1,D2,D3,D4,D5,D6;
min6x1 A1(                                                             //6X6中取最小值
               //output
               .index(index1),
               .D(D1),
               //inputs
               .D1(distance[0]),
               .D2(distance[1]),
               .D3(distance[2]),
               .D4(distance[3]),
               .D5(distance[4]),
               .D6(distance[5])
              );
min6x1 A2(
               //output
               .index(index2),
               .D(D2),
               //inputs
               .D1(distance[6]),
               .D2(distance[7]),
               .D3(distance[8]),
               .D4(distance[9]),
               .D5(distance[10]),
               .D6(distance[11])
              );
min6x1 A3(
               //output
               .index(index3),
               .D(D3),
               //inputs
               .D1(distance[12]),
               .D2(distance[13]),
               .D3(distance[14]),
               .D4(distance[15]),
               .D5(distance[16]),
               .D6(distance[17])
              );
min6x1 A4(
               //output
               .index(index4),
               .D(D4),
               //inputs
               .D1(distance[18]),
               .D2(distance[19]),
               .D3(distance[20]),
               .D4(distance[21]),
               .D5(distance[22]),
               .D6(distance[23])
              );
min6x1 A5(
               //output
               .index(index5),
               .D(D5),
               //inputs
               .D1(distance[24]),
               .D2(distance[25]),
               .D3(distance[26]),
               .D4(distance[27]),
               .D5(distance[28]),
               .D6(distance[29])
              );
min6x1 A6(
               //output
               .index(index6),
               .D(D6),
               //inputs
               .D1(distance[30]),
               .D2(distance[31]),
               .D3(distance[32]),
               .D4(distance[33]),
               .D5(distance[34]),
               .D6(distance[35])
              );
min6x1_with_index A7(  //outputs
                           .winner_x(winner_x),
                           .winner_y(winner_y),
                           //inputs
                           .D1(D1),
                           .D2(D2),
                           .D3(D3),
                           .D4(D4),
                           .D5(D5),
                           .D6(D6),
                           .index1(index1),
                           .index2(index2),
                           .index3(index3),
                           .index4(index4),
                           .index5(index5),
                           .index6(index6)
                         );  
///////////////////////////////////////////////////////
wire         [`BIT_WIDTH_DATA-1:0]    D1_x,D2_x,D3_x,D4_x,D5_x,D6_x;
wire         [`BIT_WIDTH_DATA-1:0]    D1_y,D2_y,D3_y,D4_y,D5_y,D6_y;
wire         [`BIT_WIDTH_DATA-1:0]    D1_z,D2_z,D3_z,D4_z,D5_z,D6_z;
max6x1 B1(
           //output
          .D(D1_z),
          .D_x(D1_x),
          .D_y(D1_y),
          //inputs
           .D1(weights1[0]),
           .D1_x(weights2[0]),
           .D1_y(weights3[0]),
           .D2(weights1[1]),
           .D2_x(weights2[1]),
           .D2_y(weights3[1]),
           .D3(weights1[2]),
           .D3_x(weights2[2]),
           .D3_y(weights3[2]),
           .D4(weights1[3]),
           .D4_x(weights2[3]),
           .D4_y(weights3[3]),
           .D5(weights1[4]),
           .D5_x(weights2[4]),
           .D5_y(weights3[4]),
           .D6(weights1[5]),
           .D6_x(weights2[5]),
           .D6_y(weights3[5])
           );
max6x1 B2(
           //output
          .D(D2_z),
          .D_x(D2_x),
          .D_y(D2_y),
          //inputs
           .D1(weights1[6]),
           .D1_x(weights2[6]),
           .D1_y(weights3[6]),
           .D2(weights1[7]),
           .D2_x(weights2[7]),
           .D2_y(weights3[7]),
           .D3(weights1[8]),
           .D3_x(weights2[8]),
           .D3_y(weights3[8]),
           .D4(weights1[9]),
           .D4_x(weights2[9]),
           .D4_y(weights3[9]),
           .D5(weights1[10]),
           .D5_x(weights2[10]),
           .D5_y(weights3[10]),
           .D6(weights1[11]),
           .D6_x(weights2[11]),
           .D6_y(weights3[11])
           );
max6x1 B3(
           //output
          .D(D3_z),
          .D_x(D3_x),
          .D_y(D3_y),
          //inputs
           .D1(weights1[12]),
           .D1_x(weights2[12]),
           .D1_y(weights3[12]),
           .D2(weights1[13]),
           .D2_x(weights2[13]),
           .D2_y(weights3[13]),
           .D3(weights1[14]),
           .D3_x(weights2[14]),
           .D3_y(weights3[14]),
           .D4(weights1[15]),
           .D4_x(weights2[15]),
           .D4_y(weights3[15]),
           .D5(weights1[16]),
           .D5_x(weights2[16]),
           .D5_y(weights3[16]),
           .D6(weights1[17]),
           .D6_x(weights2[17]),
           .D6_y(weights3[17])
           );
max6x1 B4(
           //output
          .D(D4_z),
          .D_x(D4_x),
          .D_y(D4_y),
          //inputs
           .D1(weights1[18]),
           .D1_x(weights2[18]),
           .D1_y(weights3[18]),
           .D2(weights1[19]),
           .D2_x(weights2[19]),
           .D2_y(weights3[19]),
           .D3(weights1[20]),
           .D3_x(weights2[20]),
           .D3_y(weights3[20]),
           .D4(weights1[21]),
           .D4_x(weights2[21]),
           .D4_y(weights3[21]),
           .D5(weights1[22]),
           .D5_x(weights2[22]),
           .D5_y(weights3[22]),
           .D6(weights1[23]),
           .D6_x(weights2[23]),
           .D6_y(weights3[23])
           );
max6x1 B5(
           //output
          .D(D5_z),
          .D_x(D5_x),
          .D_y(D5_y),
          //inputs
           .D1(weights1[24]),
           .D1_x(weights2[24]),
           .D1_y(weights3[24]),
           .D2(weights1[25]),
           .D2_x(weights2[25]),
           .D2_y(weights3[25]),
           .D3(weights1[26]),
           .D3_x(weights2[26]),
           .D3_y(weights3[26]),
           .D4(weights1[27]),
           .D4_x(weights2[27]),
           .D4_y(weights3[27]),
           .D5(weights1[28]),
           .D5_x(weights2[28]),
           .D5_y(weights3[28]),
           .D6(weights1[29]),
           .D6_x(weights2[29]),
           .D6_y(weights3[29])
           );
max6x1 B6(
           //output
          .D(D6_z),
          .D_x(D6_x),
          .D_y(D6_y),
          //inputs
           .D1(weights1[30]),
           .D1_x(weights2[30]),
           .D1_y(weights3[30]),
           .D2(weights1[31]),
           .D2_x(weights2[31]),
           .D2_y(weights3[31]),
           .D3(weights1[32]),
           .D3_x(weights2[32]),
           .D3_y(weights3[32]),
           .D4(weights1[33]),
           .D4_x(weights2[33]),
           .D4_y(weights3[33]),
           .D5(weights1[34]),
           .D5_x(weights2[34]),
           .D5_y(weights3[34]),
           .D6(weights1[35]),
           .D6_x(weights2[35]),
           .D6_y(weights3[35])
           );
max6x1_without_index B7(
               //output
               .D_x(pos_x),
               .D_y(pos_y),
               //inputs
               .D1(D1_z),
               .D1_x(D1_x),
               .D1_y(D1_y),
               .D2(D2_z),
               .D2_x(D2_x),
               .D2_y(D2_y),
               .D3(D3_z),
               .D3_x(D3_x),
               .D3_y(D3_y),
               .D4(D4_z),
               .D4_x(D4_x),
               .D4_y(D4_y),
               .D5(D5_z),
               .D5_x(D5_x),
               .D5_y(D5_y),
               .D6(D6_z),
               .D6_x(D6_x),
               .D6_y(D6_y)
              );
///////////////////////////////////////////////////////
wire          check;
reg    [2:0]  ii,jj;
always
@(posedge clk or posedge load_x)                                     //初始化权值
  begin
    if(init_wts)
    begin
      NC<=12;
      lammda<=11'b01111111111;
      frame_finish<=0;
      count_num<=0;
      state<=3'b001;
      state1<=0;
    end
    else if(load_x&&state==3'b001)
     begin
      case(state1) 
         0:begin 
           state1<=1;
           single_data_finish<=0;
           weights1[0]<=X1;weights2[0]<=X2;weights3[0]<=X3;
           end
         1:begin 
           state1<=2;
           weights1[1]<=X1;weights2[1]<=X2;weights3[1]<=X3;
           end
         2:begin 
           state1<=3;
           //single_data_finish<=1;
           weights1[2]<=X1;weights2[2]<=X2;weights3[2]<=X3;
           end
         3:begin 
           state1<=4;
           weights1[3]<=X1;weights2[3]<=X2;weights3[3]<=X3;
           end