# coding: utf-8 import binarybrain as bb import numpy as np # option epoch = 16 mini_batch = 32 file_read = False file_write = True # load data td = bb.load_cifar10() batch_size = len(td['x_train']) print('batch_size =', batch_size) # main network cnv0_sub = bb.Sequential.create() cnv0_sub.add(bb.DenseAffine.create([32])) cnv0_sub.add(bb.BatchNormalization.create()) cnv0_sub.add(bb.ReLU.create()) cnv1_sub = bb.Sequential.create() cnv1_sub.add(bb.DenseAffine.create([32])) cnv1_sub.add(bb.BatchNormalization.create()) cnv1_sub.add(bb.ReLU.create()) cnv2_sub = bb.Sequential.create() cnv2_sub.add(bb.DenseAffine.create([64])) cnv2_sub.add(bb.BatchNormalization.create()) cnv2_sub.add(bb.ReLU.create())
def main(): binary_mode = False epoch = 8 mini_batch = 32 training_modulation_size = 3 inference_modulation_size = 3 # load data td = bb.load_cifar10() batch_size = len(td['x_train']) print('batch_size =', batch_size) ############################ # Learning ############################ # create layer layer_cnv0_affine = bb.DenseAffine.create([32]) layer_cnv0_batchnorm = bb.BatchNormalization.create() layer_cnv0_actibation = bb.ReLU.create() layer_cnv1_affine = bb.DenseAffine.create([32]) layer_cnv1_batchnorm = bb.BatchNormalization.create() layer_cnv1_actibation = bb.ReLU.create() layer_cnv2_affine = bb.DenseAffine.create([64]) layer_cnv2_batchnorm = bb.BatchNormalization.create() layer_cnv2_actibation = bb.ReLU.create() layer_cnv3_affine = bb.DenseAffine.create([64]) layer_cnv3_batchnorm = bb.BatchNormalization.create() layer_cnv3_actibation = bb.ReLU.create() layer_cnv3_affine = bb.DenseAffine.create([512]) layer_cnv3_batchnorm = bb.BatchNormalization.create() layer_cnv3_actibation = bb.ReLU.create() # main network cnv0_sub = bb.Sequential.create() cnv0_sub.add(layer_cnv0_affine) cnv0_sub.add(layer_cnv0_batchnorm) cnv0_sub.add(layer_cnv0_actibation) cnv1_sub = bb.Sequential.create() cnv1_sub.add(layer_cnv1_affine) cnv1_sub.add(layer_cnv1_batchnorm) cnv1_sub.add(layer_cnv1_actibation) cnv2_sub = bb.Sequential.create() cnv2_sub.add(layer_cnv2_affine) cnv2_sub.add(layer_cnv2_batchnorm) cnv2_sub.add(layer_cnv2_actibation) cnv3_sub = bb.Sequential.create() cnv3_sub.add(layer_cnv3_affine) cnv3_sub.add(layer_cnv3_batchnorm) cnv3_sub.add(layer_cnv3_actibation) main_net = bb.Sequential.create() main_net.add(bb.LoweringConvolution.create(cnv0_sub, 3, 3)) main_net.add(bb.LoweringConvolution.create(cnv1_sub, 3, 3)) main_net.add(bb.MaxPooling.create(2, 2)) main_net.add(bb.LoweringConvolution.create(cnv2_sub, 3, 3)) main_net.add(bb.LoweringConvolution.create(cnv3_sub, 3, 3)) main_net.add(bb.MaxPooling.create(2, 2)) main_net.add(bb.DenseAffine.create([512])) main_net.add(bb.BatchNormalization.create()) main_net.add(bb.ReLU.create()) main_net.add(bb.DenseAffine.create([10])) if binary_mode: main_net.add(bb.ReLU.create()) # wrapping with binary modulator net = bb.Sequential.create() net.add( bb.BinaryModulation.create( main_net, training_modulation_size=training_modulation_size)) net.add(bb.Reduce.create(td['t_shape'])) net.set_input_shape(td['x_shape']) # set no binary mode if binary_mode: net.send_command("binary true") else: net.send_command("binary false") # print model information print(net.get_info()) # learning print('\n[learning]') loss = bb.LossSoftmaxCrossEntropy.create() metrics = bb.MetricsCategoricalAccuracy.create() optimizer = bb.OptimizerAdam.create() optimizer.set_variables(net.get_parameters(), net.get_gradients()) runner = bb.Runner(net, "cifar10-dense-cnn", loss, metrics, optimizer) runner.fitting(td, epoch_size=epoch, mini_batch_size=mini_batch, file_read=True, file_write=True)
def main(): # config epoch = 4 mini_batch = 32 training_modulation_size = 3 inference_modulation_size = 3 # load data td = bb.load_cifar10() batch_size = len(td['x_train']) print('batch_size =', batch_size) ############################ # Learning ############################ # create layer layer_sl0 = bb.SparseLut6.create([1024]) layer_sl1 = bb.SparseLut6.create([480]) layer_sl2 = bb.SparseLut6.create([70]) # create network main_net = bb.Sequential.create() main_net.add(layer_sl0) main_net.add(layer_sl1) main_net.add(layer_sl2) # wrapping with binary modulator net = bb.Sequential.create() net.add(bb.BinaryModulation.create(main_net, training_modulation_size=training_modulation_size)) net.add(bb.Reduce.create(td['t_shape'])) net.set_input_shape(td['x_shape']) # set binary mode net.send_command('binary true') # print model information print(net.get_info()) # learning print('\n[learning]') loss = bb.LossSoftmaxCrossEntropy.create() metrics = bb.MetricsCategoricalAccuracy.create() optimizer = bb.OptimizerAdam.create() optimizer.set_variables(net.get_parameters(), net.get_gradients()) runner = bb.Runner(net, "cifar10-sparse-lut6-simple", loss, metrics, optimizer) runner.fitting(td, epoch_size=epoch, mini_batch_size=mini_batch, file_read=True, file_write=True) ################################ # convert to FPGA ################################ print('\n[convert to Binary LUT]') # LUT-network layer_bl0 = bb.BinaryLut6.create(layer_sl0.get_output_shape()) layer_bl1 = bb.BinaryLut6.create(layer_sl1.get_output_shape()) layer_bl2 = bb.BinaryLut6.create(layer_sl2.get_output_shape()) lut_net = bb.Sequential.create() lut_net.add(layer_bl0) lut_net.add(layer_bl1) lut_net.add(layer_bl2) # evaluate network eval_net = bb.Sequential.create() eval_net.add(bb.BinaryModulation.create(lut_net, inference_modulation_size=inference_modulation_size)) eval_net.add(bb.Reduce.create(td['t_shape'])) # set input shape eval_net.set_input_shape(td['x_shape']) # parameter copy print('parameter copy to binary LUT-Network') layer_bl0.import_parameter(layer_sl0) layer_bl1.import_parameter(layer_sl1) layer_bl2.import_parameter(layer_sl2) # evaluate network print('evaluate LUT-Network') lut_runner = bb.Runner(eval_net, "cifar10-binary-lut6-simple", bb.LossSoftmaxCrossEntropy.create(), bb.MetricsCategoricalAccuracy.create()) lut_runner.evaluation(td, mini_batch_size=mini_batch) # write Verilog print('write verilog file') with open('Cifar10LutSimple.v', 'w') as f: f.write('`timescale 1ns / 1ps\n\n') f.write(bb.make_verilog_from_lut('Cifar10LutSimple', [layer_bl0, layer_bl1, layer_bl2]))
def main(): epoch = 4 mini_batch = 32 training_modulation_size = 3 inference_modulation_size = 3 # load data td = bb.load_cifar10() batch_size = len(td['x_train']) print('batch_size =', batch_size) ############################ # Learning ############################ # create layer layer_cnv0_sl0 = bb.SparseLut6Bit.create([192]) layer_cnv0_sl1 = bb.SparseLut6Bit.create([32]) layer_cnv1_sl0 = bb.SparseLut6Bit.create([1152]) layer_cnv1_sl1 = bb.SparseLut6Bit.create([192]) layer_cnv1_sl2 = bb.SparseLut6Bit.create([32]) layer_cnv2_sl0 = bb.SparseLut6Bit.create([2304]) layer_cnv2_sl1 = bb.SparseLut6Bit.create([384]) layer_cnv2_sl2 = bb.SparseLut6Bit.create([64]) layer_cnv3_sl0 = bb.SparseLut6Bit.create([2384]) layer_cnv3_sl1 = bb.SparseLut6Bit.create([384]) layer_cnv3_sl2 = bb.SparseLut6Bit.create([64]) layer_sl4 = bb.SparseLut6Bit.create([18432]) layer_sl5 = bb.SparseLut6Bit.create([3072]) layer_sl6 = bb.SparseLut6Bit.create([512]) layer_sl7 = bb.SparseLut6Bit.create([2160]) layer_sl8 = bb.SparseLut6Bit.create([360]) layer_sl9 = bb.SparseLut6Bit.create([60]) layer_sl10 = bb.SparseLut6Bit.create([10]) # main network cnv0_sub = bb.Sequential.create() cnv0_sub.add(layer_cnv0_sl0) cnv0_sub.add(layer_cnv0_sl1) cnv1_sub = bb.Sequential.create() cnv1_sub.add(layer_cnv1_sl0) cnv1_sub.add(layer_cnv1_sl1) cnv1_sub.add(layer_cnv1_sl2) cnv2_sub = bb.Sequential.create() cnv2_sub.add(layer_cnv2_sl0) cnv2_sub.add(layer_cnv2_sl1) cnv2_sub.add(layer_cnv2_sl2) cnv3_sub = bb.Sequential.create() cnv3_sub.add(layer_cnv3_sl0) cnv3_sub.add(layer_cnv3_sl1) cnv3_sub.add(layer_cnv3_sl2) main_net = bb.Sequential.create() main_net.add(bb.LoweringConvolutionBit.create(cnv0_sub, 3, 3)) main_net.add(bb.LoweringConvolutionBit.create(cnv1_sub, 3, 3)) main_net.add(bb.MaxPoolingBit.create(2, 2)) main_net.add(bb.LoweringConvolutionBit.create(cnv2_sub, 3, 3)) main_net.add(bb.LoweringConvolutionBit.create(cnv3_sub, 3, 3)) main_net.add(bb.MaxPoolingBit.create(2, 2)) main_net.add(layer_sl4) main_net.add(layer_sl5) main_net.add(layer_sl6) main_net.add(layer_sl7) main_net.add(layer_sl8) main_net.add(layer_sl9) main_net.add(layer_sl10) # wrapping with binary modulator net = bb.Sequential.create() net.add( bb.BinaryModulationBit.create( main_net, training_modulation_size=training_modulation_size)) net.add(bb.Reduce.create(td['t_shape'])) net.set_input_shape(td['x_shape']) # set binary mode net.send_command("binary true") # print model information print(net.get_info()) # learning print('\n[learning]') loss = bb.LossSoftmaxCrossEntropy.create() metrics = bb.MetricsCategoricalAccuracy.create() optimizer = bb.OptimizerAdam.create() optimizer.set_variables(net.get_parameters(), net.get_gradients()) runner = bb.Runner(net, "cifar10-sparse-lut6-cnn", loss, metrics, optimizer) runner.fitting(td, epoch_size=epoch, mini_batch_size=mini_batch, file_read=True, file_write=True)