你在算法的使用上有什么绝活？

int matrixdot (){ int * a = malloc ( 1024 * 512 * sizeof ( int )); int * b = malloc ( 512 * 1024 * sizeof ( int )); int * c = malloc ( 1024 * 1024 * sizeof ( int )); memset ( a , 1 , 1024 * 512 * sizeof ( int )); memset ( b , 2 , 512 * 1024 * sizeof ( int )); int i , j , k ; for ( i = 0 ; i < 1024 ; i ++ ){ int ai = 512 * i ; int ci = 1024 * i ; for ( j = 0 ; j < 1024 ; j ++ ){ int bi = 0 ; int cc = 0 ; for ( k = 0 ; k < 512 ; k ++ ){ cc += a [ ai ++ ] * b [ bi ]; bi += 1024 ; } c [ ci ++ ] = cc ; } } } int main ( int argc , char ** argv ){ struct timeval tv1 , tv2 ; gettimeofday ( & tv1 , NULL ); matrixdot (); gettimeofday ( & tv2 , NULL ); long ds = tv2 . tv_sec - tv1 . tv_sec ; long dus = tv2 . tv_usec - tv1 . tv_usec ; long ss = ds * 1000 + dus / 1000 ; printf ( "cost time:%ldms \n " , ss ); exit ( 0 ); }

import numpy as np import time t1 = time . time () a = np . arange ( 0 , 1024 * 512 ). reshape ( 1024 , 512 ) b = np . arange ( 0 , 512 * 1024 ). reshape ( 512 , 1024 ) c = np . dot ( a , b ) t2 = time . time () dt = t2 - t1 dt = round ( dt * 1000 ) print ( "dt:{0}, c.shape{1}" . format ( dt , c . shape ))

void matrixdot_single ( void * data ){ struct thdata * thdata = data ; int i , j , k ; int * a = thdata -> a . data ; int * b = thdata -> b . data ; int * c = thdata -> c ; for ( i = thdata -> cindex ; i < thdata -> cend ; i ++ ){ int ai = thdata -> a . column * i ; int ci = thdata -> b . column * i ; for ( j = 0 ; j < thdata -> b . column ; j ++ ){ int bi = 0 ; int cc = 0 ; for ( k = 0 ; k < thdata -> a . column ; k ++ ){ cc += a [ ai ++ ] * b [ bi ]; bi += thdata -> b . column ; } c [ ci ++ ] = cc ; } } * thdata -> finish = 1 ; } int matrixdot_threads (){ pthread_t * thread ; int * a = malloc ( 1024 * 512 * sizeof ( int )); int * b = malloc ( 512 * 1024 * sizeof ( int )); int * c = malloc ( 1024 * 1024 * sizeof ( int )); memset ( a , 1 , 1024 * 512 * sizeof ( int )); memset ( b , 2 , 512 * 1024 * sizeof ( int )); struct thdata * thd = malloc ( 16 * sizeof ( struct thdata )); memset ( thd , 0 , 16 * sizeof ( struct thdata )); int * finish = malloc ( 16 * sizeof ( int )); memset ( finish , 0 , 16 * sizeof ( int )); int i = 0 ; for ( i = 0 ; i < 16 ; i ++ ){ struct thdata * thdi = thd + i ; thdi -> a . data = a ; thdi -> a . row = 1024 ; thdi -> a . column = 512 ; thdi -> b . data = b ; thdi -> b . row = 512 ; thdi -> b . column = 1024 ; thdi -> c = c ; thdi -> cindex = i * 64 ; thdi -> cend = ( i + 1 ) * 64 ; thdi -> finish = finish + i ; } for ( i = 0 ; i < 16 ; i ++ ){ pthread_create ( & thread , NULL , matrixdot_single , thd + i ); } while ( 1 ){ int count = 0 ; int * fsh = finish ; for ( i = 0 ; i < 16 ; i ++ ){ if ( !* fsh ){ break ; } fsh ++ ; count ++ ; } if ( count == 16 ){ break ; } usleep ( 1000 ); } }

func main (){ ss : = time . Now () A : = make ([] int , 1024 * 512 ) B : = make ([] int , 512 * 1024 ) C : = make ([] int , 1024 * 1024 ) ch : = make ( chan int , 32 ) for r : = 0 ; r < 32 ; r ++ { go func ( start , end int , a , b , c [] int ){ for i : = start ; i < end ; i ++ { ai : = a [ i * 512 : ] ci : = c [ i * 1024 : ] for j : = 0 ; j < 1024 ; j ++ { bi : = 0 cc : = 0 for k : = 0 ; k < 512 ; k ++ { cc += ai [ k ] * b [ bi ] bi += 1024 } ci [ j ] = cc } } ch <- 1 }( r * 32 , ( r + 1 ) * 32 , A , B , C ) } count : = 0 for count < 32 { select { case <- ch : count ++ } } es : = time . Now () cost : = es . Sub ( ss ) log . Println ( "cost time:" , cost ) }

x_train , y_train , x_test , y_test , err := mnist . LoadMnistData ( "" , true ) log . Println ( "load data finished" ) if err != nil { log . Fatal ( "load mnist data failed" ) } x_train . DevideFloat ( 255 ) x_test . DevideFloat ( 255 ) model := model . Sequential ([] layers . Layer { layers . Conv2D ( 64 , [] int { 5 , 5 }, "relu" , [] int { 1 , 1 }, "valid" , [] int { 28 , 28 , 1 }, algo . InitMatrixWithNormal ()), layers . MaxPool2D ([] int { 2 , 2 }), layers . Flatten (), layers . Dense ( 20 , "relu" , algo . InitMatrixWithRandom ( - 1.0 , 1.0 )), layers . Dropout ( 0.2 ), layers . Dense ( 10 , "softmax" , algo . InitMatrixWithRandom ( - 1.0 , 1.0 )), }) model . Compile ( "adam" , "sparse_categorical_crossentropy" , [] string { "accuracy" }) model . Fit ( x_train , y_train , 625 , 5 ) model . Evaluate ( x_test , y_test )

func ( ml * multiLayer ) Forward () error { if false { log . Println ( "multiLayer Forward" ) } for _ , layer := range ml . layers { err := layer . Forward () if err != nil { return err } } return nil } func ( ml * multiLayer ) Backward () error { if false { log . Println ( "multiLayer Backward" ) } for _ , layer := range ml . layers_back { err := layer . Backward () if err != nil { return err } } return nil } func ( ml * multiLayer ) Update ( args * network . UpdateArgs ) error { if false { log . Println ( "multiLayer Update" ) } for _ , layer := range ml . layers { err := layer . Update ( args ) if err != nil { return err } } return nil }

ch := make ( chan int , m ) for i := 0 ; i < m ; i ++ { go func ( index int ){ ai := a [ index * k :( index + 1 ) * k ] for j := 0 ; j < n ; j ++ { wi := b [ j * k : ( j + 1 ) * k ] var v float64 for h := 0 ; h < k ; h ++ { v = v + ai [ h ] * wi [ h ] } c [ index * n + j ] = v + bias [ j ] } ch <- index }( i ) } rc := 0 for rc < m { select { case <- ch : rc ++ } }

x_train , y_train , x_test , y_test , err := mnist . LoadMnistData ( "" , true ) log . Println ( "load data finished" ) if err != nil { log . Fatal ( "load mnist data failed" ) } x_train . DevideFloat ( 255 ) x_test . DevideFloat ( 255 ) model := model . Sequential ([] layers . Layer { layers . Conv2D ( 64 , [] int { 5 , 5 }, "relu" , [] int { 1 , 1 }, "valid" , [] int { 28 , 28 , 1 }, algo . InitMatrixWithNormal ()), layers . MaxPool2D ([] int { 2 , 2 }), layers . Flatten (), layers . Dense ( 20 , "relu" , algo . InitMatrixWithRandom ( - 1.0 , 1.0 )), layers . Dropout ( 0.2 ), layers . Dense ( 10 , "softmax" , algo . InitMatrixWithRandom ( - 1.0 , 1.0 )), }) model . Compile ( "adam" , "sparse_categorical_crossentropy" , [] string { "accuracy" }) model . Fit ( x_train , y_train , 625 , 5 ) model . Evaluate ( x_test , y_test )

func LoadMnistData ( path string , gz bool )( tensor . Tensor , tensor . Tensor , tensor . Tensor , tensor . Tensor , error ){ log . Println ( "start to load mnist data" ) origin_folder := "http://yann.lecun.com/exdb/mnist/" idx3_train_image_name := "train-images-idx3-ubyte" idx3_train_label_name := "train-labels-idx1-ubyte" idx3_test_image_name := "t10k-images-idx3-ubyte" idx3_test_label_name := "t10k-labels-idx1-ubyte" //train train_image_num , train_image_row , train_image_column , pixels , err := tools . ReadIdx3Image ( origin_folder , idx3_train_image_name , path , gz ) if err != nil { return nil , nil , nil , nil , err } log . Printf ( "load mnist image, num:%d, row:%d, column:%d, pixel length:%d\n" , train_image_num , train_image_row , train_image_column , len ( pixels )) train_labels , err := tools . ReadIdx3Label ( origin_folder , idx3_train_label_name , path , gz ) if err != nil { return nil , nil , nil , nil , err } log . Printf ( "load mnist label, labels length:%d\n" , len ( train_labels )) train_image_matrix := & tensor . Matrix {} train_image_matrix . Init2DImage ( train_image_row , train_image_column , 1 , train_image_num , pixels ) train_label_matrix := & tensor . Matrix {} train_label_matrix . Init classificationLabel ( 0 , 9 , len ( train_labels ), train_labels ) //test test_image_num , test_image_row , test_image_column , pixels , err := tools . ReadIdx3Image ( origin_folder , idx3_test_image_name , path , gz ) if err != nil { return nil , nil , nil , nil , err } test_labels , err := tools . ReadIdx3Label ( origin_folder , idx3_test_label_name , path , gz ) if err != nil { return nil , nil , nil , nil , err } test_image_matrix := & tensor . Matrix {} test_image_matrix . Init2DImage ( test_image_row , test_image_column , 1 , test_image_num , pixels ) test_label_matrix := & tensor . Matrix {} test_label_matrix . Init classificationLabel ( 0 , 9 , len ( test_labels ), test_labels ) log . Printf ( "train x size:%d, y size:%d\n" , len ( train_image_matrix . Data ), len ( train_label_matrix . Data )) return train_image_matrix , train_label_matrix , test_image_matrix , test_label_matrix , nil }

type Layer interface { Init () InitialData ( net * network . Net ) Forward () error Backward () error Update ( args * network . UpdateArgs ) error BeforeForwardBackwardUpdate () error AfterForwardBackwardUpdate () error LinkNext ( next Layer ) error }

type Tensor interface { GetNum () int DevideFloat ( num float64 ) error }

type Matrix struct { Shape TensorShape MatrixType WhichMatrixType num int channel int step int viewSize int spaceSize int shapeSize int sampleSize int stepIndex int stepOneLine bool LabelNum int data [] float64 delta [] float64 dataint [] int DataRaw [] float64 DeltaRaw [] float64 DataIntRaw [] int Data [] float64 Delta [] float64 DataInt [] int IdWords map [ int ] rune }

type Model struct { layers [] layers . Layer inputLayer layers . Layer costLayer layers . Layer outLayer layers . Layer train_input tensor . Tensor train_label tensor . Tensor test_input tensor . Tensor test_label tensor . Tensor batchSize int epochs int net * network . Net optimizer string loss string metrics [] string }

type Net struct { State ModelState Epochs int BatchSize int InputNum int TestNum int RunNum int Step int Iter int BatchIndex int BatchTimes int CurBatchSize int ArgsLearning LearningArgs Policy LearningRatePolicy }

func Sequential ( layers [] layers . Layer ) * Model func ( model * Model ) Compile ( optimizer string , loss string , metrics [] string ) func ( model * Model ) Fit ( data tensor . Tensor , label tensor . Tensor , batchSize int , epochs int ){ model . LayerInit () model . Train () } func ( model * Model ) Evaluate ( data tensor . Tensor , label tensor . Tensor ){ model . evaluate () } func ( model * Model ) Predict ( data tensor . Tensor ) tensor . Tensor { return model . predict () }

func Im2Col_cpu ( data_im [] float64 , channels int , height int , width int , ker_height int , ker_width int , height_stride int , width_stride int , height_pad int , width_pad int , height_col int , width_col int , channels_col int , data_col [] float64 ){ for c := 0 ; c < channels_col ; c ++ { var w_offset int = c % ker_width var h_offset int = ( c / ker_width ) % ker_height var c_im int = ( c / ker_width ) / ker_height for h := 0 ; h < height_col ; h ++ { for w := 0 ; w < width_col ; w ++ { var im_row int = h_offset + h * height_stride - height_pad var im_col int = w_offset + w * width_stride - width_pad var col_index int = ( c * height_col + h ) * width_col + w if im_row < 0 || im_col < 0 || im_row >= height || im_col >= width { data_col [ col_index ] = 0 } else { imindex := im_col + width * ( im_row + height * c_im ) data_col [ col_index ] = data_im [ imindex ] } } } } }

func gemm_nn ( m int , n int , k int , alpha float64 , a [] float64 , lda int , b [] float64 , ldb int , c [] float64 , ldc int ){ for i1 := 0 ; i1 < m ; i1 ++ { for i2 := 0 ; i2 < k ; i2 ++ { a_part := alpha * a [ i1 * lda + i2 ] for i3 := 0 ; i3 < n ; i3 ++ { c [ i1 * ldc + i3 ] = c [ i1 * ldc + i3 ] + a_part * b [ i2 * ldb + i3 ] } } } }

for i := 0 ; i < curbatchsize ; i ++ { var c [] float64 = layer . output . Data [ i * out_channel_size :] go func ( index int ){ b := layer . ctldata . Data [ index * ctlSampleSize : ] algo . Im2Col_cpu ( input . Data [ index * img_channel_size :], channel , img_height , img_width , ker_height , ker_width , height_stride , width_stride , height_pad , width_pad , height_col , width_col , channels_col , b ) algo . Gemm ( false , false , m , n , k , 1 , a , k , b , n , 1 , c , n ) ch <- index }( i ) }

func ( layer * lstmLayer ) Backward () error { if false { log . Println ( "lstmLayer Backward" ) } input := layer . input input_real := layer . inputReal input_shape := input . Shape step := input_shape . Step batch := input_shape . Num input_channel := input_shape . Channel input_real_channel := input_real . Shape . Channel //hide state memH := layer . memH //cell state memC := layer . memC units := layer . hiddenUnits ldf := layer . outputF ldi := layer . outputI ldg := layer . outputG ldo := layer . outputO dth := layer . dataTH input_real . Step ( step - 1 ) memC . Step ( step - 1 ) memH . Step ( step - 1 ) dth . Step ( step - 1 ) for s := step - 1 ; s >= 0 ; { //forward数据部分 ldfd := ldf . Data ldid := ldi . Data ldgd := ldg . Data ldod := ldo . Data dthd := dth . Data //回传误差部分 ldft := ldf . Delta ldit := ldi . Delta ldgt := ldg . Delta ldot := ldo . Delta dtht := dth . Delta //cell state mmct := memC . Delta //hide state mmht := memH . Delta s -- if s >= 0 { memC . Step ( s ) memH . Step ( s ) dth . Step ( s ) } mmht_prev := memH . Delta mmct_prev := memC . Delta mmcd_prev := memC . Data for i := 0 ; i < batch ; i ++ { uints_index := i * units mht := mmht [ uints_index :] tht := dtht [ uints_index :] thd := dthd [ uints_index :] ctt := mmct [ uints_index :] ctt_prev := mmct_prev [ uints_index :] ctd_prev := mmcd_prev [ uints_index :] //output gate layer output zod := ldod [ uints_index :] zot := ldot [ uints_index :] //input data layer output zgd := ldgd [ uints_index :] zgt := ldgt [ uints_index :] //input gate layer output zid := ldid [ uints_index :] zit := ldit [ uints_index :] //forget gate layer output zfd := ldfd [ uints_index :] zft := ldft [ uints_index :] for k := 0 ; k < units ; k ++ { mhtk := mht [ k ] tht [ k ] = mhtk * zod [ k ] thdk := thd [ k ] //cell state delta cttk := tht [ k ] * ( 1 - thdk * thdk ) ctt [ k ] = cttk //output delta zot [ k ] = mhtk * thdk //zit input gate delta //zgt data delta zit [ k ] = cttk * zgd [ k ] zgt [ k ] = cttk * zid [ k ] if s >= 0 { zft [ k ] = cttk * ctd_prev [ k ] } //cell state prev delta ctt_prev [ k ] = cttk * zfd [ k ] } } err := layer . layerF . Backward () if err != nil { log . Println ( "layer f backward error" ) return err } err = layer . layerI . Backward () if err != nil { log . Println ( "layer i backward error" ) return err } err = layer . layerG . Backward () if err != nil { log . Println ( "layer g backward error" ) return err } err = layer . layerO . Backward () if err != nil { log . Println ( "layer o backward error" ) return err } if s < 0 { break } real_step_delta := input_real . Delta for i := 0 ; i < batch ; i ++ { uints_index := i * units mht := mmht_prev [ uints_index :] real_input_delta := real_step_delta [ i * input_real_channel :] k2 := input_channel for j := 0 ; j < units ; j ++ { mht [ j ] += real_input_delta [ k2 ] k2 ++ } } input_real . Step ( s ) } input_delta := input . DeltaRaw input_real_delta := input_real . DeltaRaw for s := 0 ; s < step ; s ++ { real_step_delta := input_real_delta [ s * batch * input_real_channel :] input_step_delta := input_delta [ s * batch * input_channel :] for i := 0 ; i < batch ; i ++ { real_delta := real_step_delta [ i * input_real_channel :] ipt_delta := input_step_delta [ i * input_channel :] for k := 0 ; k < input_channel ; k ++ { ipt_delta [ k ] = real_delta [ k ] } } } return nil } 复制

func ( layer * lstmLayer ) Update ( args * network . UpdateArgs ) error { if false { log . Println ( "lstmLayer Update" ) } err := layer . layerF . Update ( args ) if err != nil { log . Fatal ( "lstm layer update error, layerf update error" ) return err ; } err = layer . layerI . Update ( args ) if err != nil { log . Fatal ( "lstm layer update error, layerf update error" ) return err ; } err = layer . layerG . Update ( args ) if err != nil { log . Fatal ( "lstm layer update error, layerf update error" ) return err ; } err = layer . layerO . Update ( args ) if err != nil { log . Fatal ( "lstm layer update error, layerf update error" ) return err ; } return nil }

func ( layer * layerIntl ) LinkNext ( next Layer ) error { rn := next . getFirstLayerIfInMulti () rn . SetInput ( layer . GetOutput ()) currentType := layer . GetLayerType () if rn . needInputFlattened () { if ! layer . flattened { return errors . New ( "the prev layer of dropout should be flatten or dense" ) } } layer . setNext ( rn , rn . GetLayerType ()) rn . setPrev ( layer . layer , currentType ) return nil }

func ( layer * softmaxLayer ) LinkNext ( next Layer ) error { err := layer . layerIntl . LinkNext ( next ) if err != nil { return err } if next . GetLayerType () == LayerTypeCrossEntropy { layer . backwardInNext = true next . bindBackwardWithPrev () } return nil }

if layer . backwardInNext { layer . output . InitOutputSpaceWithoutDelta ( input . Shape , input . DeltaRaw ) }

model := model . Sequential ([] layers . Layer { layers . Embedding ( hotSize , hiddenUnits , algo . InitMatrixWithRandom ( - 1.0 , 1.0 )), layers . Lstm ( hiddenUnits ), layers . Lstm ( hiddenUnits ), layers . Dense ( hotSize , "softmax" , algo . InitMatrixWithRandom ( - 1.0 , 1.0 )), })