def test_fclayer(self): ''' FCLayer init. ''' flayer = FCLayer(2048, 4096, sfil=2) self.assertEqual(flayer.total_ofmap_size(), 4096, 'FCLayer: ofmap_size') self.assertEqual(flayer.filter_size(), 4, 'FCLayer: filter_size') self.assertEqual(flayer.total_filter_size(), 2048 * 4096 * 4, 'FCLayer: filter_size')
def test_add(self): ''' Modifier add. ''' self.assertEqual(len(self.network), 3) self.network.add('f2', FCLayer(64, 2000, 7), prevs='p1') self.network.add('f3', FCLayer(3000, 1000), prevs=('f1', 'f2')) self.network.add('f4', FCLayer(1000, 1000), prevs=('f1', 'f3')) self.assertEqual(len(self.network), 6)
def add_lstm_cell(network, name, size, xin, cin=None, hin=None): ''' Add a LSTM cell named `name` to the `network`, with the dimension `size`. `xin`, `cin`, `hin` are the layers' names whose outputs are x_t, C_{t-1}, h_{t-1}, respectively. Return the layers' names whose outputs are C_t, h_t. ''' from nn_dataflow.core import Network from nn_dataflow.core import InputLayer, FCLayer, EltwiseLayer if not isinstance(network, Network): raise TypeError('add_lstm_cell: network must be a Network instance.') if cin is None: cin = '{}_cinit'.format(name) network.add_ext(cin, InputLayer(size, 1)) if hin is None: hin = '{}_hinit'.format(name) network.add_ext(hin, InputLayer(size, 1)) if (cin not in network) or (hin not in network) or (xin not in network): raise ValueError('add_lstm_cell: cin {}, hin {}, xin {} must all be ' 'in the network.'.format(cin, hin, xin)) def gate_name(gate): ''' Name of a gate. ''' return '{}_{}gate'.format(name, gate) # Candidate. cand_name = '{}_cand'.format(name) prevs = (hin, xin) if hin else (xin, ) network.add(cand_name, FCLayer(len(prevs) * size, size), prevs=prevs) # Three gates. prevs = (hin, xin) if hin else (xin, ) for g in ['i', 'f', 'o']: network.add(gate_name(g), FCLayer(len(prevs) * size, size), prevs=prevs) # C_t. cout_name = '{}_cout'.format(name) cout_f_name = cout_name + '_f' prevs = (cin, gate_name('f')) if cin else (gate_name('f'), ) network.add(cout_f_name, EltwiseLayer(size, 1, len(prevs)), prevs=prevs) cout_i_name = cout_name + '_i' prevs = (cand_name, gate_name('i')) network.add(cout_i_name, EltwiseLayer(size, 1, 2), prevs=prevs) prevs = (cout_i_name, cout_f_name) network.add(cout_name, EltwiseLayer(size, 1, 2), prevs=prevs) # h_t. hout_name = '{}_hout'.format(name) prevs = (cout_name, gate_name('o')) network.add(hout_name, EltwiseLayer(size, 1, 2), prevs=prevs) return cout_name, hout_name
def MLP_network(input_size, hiden_fc1, hiden_fc2, hiden_fc3, output_size): NN = Network('MLP_L') NN.set_input(InputLayer(input_size, 1)) NN.add('fc1', FCLayer(input_size, hiden_fc1)) NN.add('fc2', FCLayer(hiden_fc1, hiden_fc2)) NN.add('fc3', FCLayer(hiden_fc2, hiden_fc3)) NN.add('fc4', FCLayer(hiden_fc3, output_size)) return NN
def test_prevs(self): ''' Get prevs. ''' self.network.add('f2', FCLayer(64, 2000, 7), prevs='p1') self.network.add('f3', FCLayer(3000, 1000), prevs=('f1', 'f2')) prevs = self.network.prevs('f1') self.assertTupleEqual(prevs, ('p1',)) prevs = self.network.prevs('f2') self.assertTupleEqual(prevs, ('p1',)) prevs = self.network.prevs('f3') self.assertTupleEqual(prevs, ('f1', 'f2'))
def test_data_loops(self): ''' Get data_loops. ''' dls = ConvLayer.data_loops() self.assertEqual(dls[de.FIL], DataDimLoops(le.IFM, le.OFM)) self.assertEqual(dls[de.IFM], DataDimLoops(le.IFM, le.BAT)) self.assertEqual(dls[de.OFM], DataDimLoops(le.OFM, le.BAT)) clayer = ConvLayer(3, 64, [28, 14], 3, strd=2) flayer = FCLayer(2048, 4096, sfil=2) self.assertTupleEqual(FCLayer.data_loops(), dls) self.assertTupleEqual(clayer.data_loops(), dls) self.assertTupleEqual(flayer.data_loops(), dls)
def setUp(self): self.layers = {} self.layers['BASE'] = ConvLayer(64, 64, 28, 3) self.layers['FC'] = FCLayer(4096, 1000, 6) self.layers['POOL'] = PoolingLayer(32, 7, 3, strd=2) self.layers['LR'] = LocalRegionLayer(32, 7, nreg=5, sreg=1) # With irregular nifm/nofm. self.layers['IRR'] = ConvLayer(255, 383, 13, 3) # With small numbers of fmaps. self.layers['SM'] = ConvLayer(5, 3, 13, 3) # Super small networks. No partitioning schemes. self.layers['SSM1'] = ConvLayer(1, 1, 2, 3) self.layers['SSM2'] = FCLayer(2, 2) self.layers['SSM3'] = PoolingLayer(1, 2, 2) self.batch_size = 8 self.dim_nodes = {} self.dim_nodes['BASE'] = PhyDim2(4, 4) self.dim_nodes['LG'] = PhyDim2(10, 10) self.dim_nodes['PRIME'] = PhyDim2(3, 3) self.options = {} # Irrelevant options. optdict = {'ntops': 10000} self.options['BASE'] = Option(partition_hybrid=True, partition_batch=True, partition_ifmaps=True, **optdict) self.options['NOBATP'] = Option(partition_hybrid=True, partition_batch=False, partition_ifmaps=True, **optdict) self.options['NOINPP'] = Option(partition_hybrid=True, partition_batch=True, partition_ifmaps=False, **optdict) self.options['NOHYB'] = Option(partition_hybrid=False, partition_batch=True, partition_ifmaps=False, **optdict) self.options['ACCFWD'] = Option(partition_hybrid=True, partition_batch=True, partition_ifmaps=True, hw_access_forwarding=True, **optdict) self.options['BUFSHR'] = Option(partition_hybrid=True, partition_batch=True, partition_ifmaps=True, hw_gbuf_sharing=True, **optdict)
def setUp(self): # AlexNet. self.convlayers = OrderedDict() self.convlayers['conv1'] = ConvLayer(3, 96, 55, 11, 4) self.convlayers['conv2'] = ConvLayer(48, 256, 27, 5) self.convlayers['conv3'] = ConvLayer(256, 384, 13, 3) self.convlayers['conv4'] = ConvLayer(192, 384, 13, 3) self.convlayers['conv5'] = ConvLayer(192, 256, 13, 3) self.fclayers = {} self.fclayers['fc1'] = FCLayer(256, 4096, 6) self.fclayers['fc2'] = FCLayer(4096, 4096) self.fclayers['fc3'] = FCLayer(4096, 1000) # LocalRegionLayer. self.lrlayers = {} self.lrlayers['pool1'] = PoolingLayer(64, 7, 2) self.lrlayers['pool2'] = PoolingLayer(29, 13, 3) self.lrlayers['pool3'] = PoolingLayer(32, 7, 2, strd=3) self.lrlayers['lr1'] = LocalRegionLayer(32, 7, nreg=5, sreg=1) self.lrlayers['lr2'] = LocalRegionLayer(32, 7, nreg=5, sreg=1, strd=2) # Fake layers. self.fake_layers = {} # With irregular nifm/nofm. self.fake_layers['IRR'] = ConvLayer(255, 383, 13, 3) # With small numbers of fmaps. self.fake_layers['SM'] = ConvLayer(5, 3, 13, 3) # With large FIL height. self.fake_layers['LGFIL'] = ConvLayer(64, 64, 13, 22) # Resource. self.resource = {} proc_region = NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.PROC) data_region = NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.DRAM) # Eyeriss, ISSCC'16, JSSC'17. self.resource['BASE'] = Resource(proc_region=proc_region, dram_region=data_region, src_data_region=data_region, dst_data_region=data_region, dim_array=PhyDim2(12, 14), size_gbuf=108 * 1024, size_regf=520, array_bus_width=float('inf'), dram_bandwidth=float('inf'), no_time_mux=False)
def setUp(self): ''' Set up. ''' self.network = Network('test_net') self.network.set_input(InputLayer(3, 224)) self.network.add('c1', ConvLayer(3, 64, 224, 3)) self.network.add('p1', PoolingLayer(64, 7, 32)) self.network.add('f1', FCLayer(64, 1000, 7))
def test_next_layers(self): ''' Get next_layers. ''' self.network.add('f2', FCLayer(64, 2000, 7), prevs='p1') self.network.add('f3', FCLayer(3000, 1000), prevs=('f1', 'f2')) self.network.add('f4', FCLayer(1000, 1000), prevs=('f1', 'f3')) nexts = self.network.next_layers('p1') self.assertTupleEqual(nexts, ('f1', 'f2')) nexts = self.network.next_layers('f1') self.assertTupleEqual(nexts, ('f3', 'f4')) nexts = self.network.next_layers('f2') self.assertTupleEqual(nexts, ('f3', )) nexts = self.network.next_layers('f3') self.assertTupleEqual(nexts, ('f4', ))
def test_len(self): ''' Accessor len. ''' self.assertEqual(len(self.network), 3) network = Network('test_net') self.assertEqual(len(network), 0) network.set_input(InputLayer(3, 224)) self.assertEqual(len(network), 0) network.add('c1', ConvLayer(3, 4, 224, 1)) self.assertEqual(len(network), 1) self.network.add('f2', FCLayer(64, 2000, 7), prevs='p1') self.assertEqual(len(self.network), 4) self.network.add('f3', FCLayer(3000, 1000), prevs=('f1', 'f2')) self.assertEqual(len(self.network), 5) self.network.add('f4', FCLayer(1000, 1000), prevs=('f1', 'f3')) self.assertEqual(len(self.network), 6)
def test_contains(self): ''' Whether contains. ''' self.assertIn('c1', self.network) self.assertIn('p1', self.network) self.assertIn('f1', self.network) self.assertNotIn('f2', self.network) self.network.add('f2', FCLayer(64, 2000, 7), prevs='p1') self.assertIn('f2', self.network)
def test_last_layers(self): ''' Get last_layers. ''' lasts = self.network.last_layers() self.assertTupleEqual(lasts, ('f1', )) self.network.add('f2', FCLayer(64, 2000, 7), prevs='p1') lasts = self.network.last_layers() self.assertTupleEqual(lasts, ('f1', 'f2'))
def test_ext_layer(self): ''' With external layers. ''' network = self.alex_net network.add_ext('e0', InputLayer(4, 1)) network.add('l1', FCLayer(1000, 4)) network.add('l2', FCLayer(8, 4), prevs=('e0', 'l1')) batch_size = 16 options = Option(sw_gbuf_bypass=(True, True, True), sw_solve_loopblocking=True) nnd = NNDataflow(network, batch_size, self.resource, self.cost, self.map_strategy) tops, _ = nnd.schedule_search(options) self.assertTrue(tops)
def test_repr(self): ''' __repr__. ''' # pylint: disable=eval-used for l in [ ConvLayer(3, 64, [28, 14], [3, 1]), ConvLayer(3, 64, [28, 14], 3, strd=[7, 5]), ConvLayer(3, 64, 28, 3, strd=7), ConvLayer(3, 64, 28, 3) ]: self.assertIn('ConvLayer', repr(l)) self.assertEqual(eval(repr(l)), l) for l in [ FCLayer(2048, 4096), FCLayer(100, 300, 7), FCLayer(100, 300, [7, 3]) ]: self.assertIn('FCLayer', repr(l)) self.assertEqual(eval(repr(l)), l)
def test_next_layers_last(self): ''' Get next_layers first layer. ''' nexts = self.network.next_layers('f1') self.assertTupleEqual(nexts, (None, )) self.network.add('f2', FCLayer(64, 2000, 7), prevs='p1') nexts = self.network.next_layers('f1') self.assertTupleEqual(nexts, (None, )) nexts = self.network.next_layers('f2') self.assertTupleEqual(nexts, (None, ))
def test_prev_layers(self): ''' Get prev_layers. ''' self.network.add('f2', FCLayer(64, 2000, 7), prevs='p1') self.network.add('f3', FCLayer(3000, 1000), prevs=('f1', 'f2')) self.network.add('f4', FCLayer(1000, 1000), prevs=('f1', 'f3')) prevs, symbol = self.network.prev_layers('f1') self.assertTupleEqual(prevs, ('p1', )) self.assertEqual(symbol, '|') prevs, symbol = self.network.prev_layers('f2') self.assertTupleEqual(prevs, ('p1', )) self.assertEqual(symbol, '|') prevs, symbol = self.network.prev_layers('f3') self.assertTupleEqual(prevs, ('f1', 'f2')) self.assertEqual(symbol, '|') prevs, symbol = self.network.prev_layers('f4') self.assertTupleEqual(prevs, ('f1', 'f3')) self.assertEqual(symbol, '+')
def setUp(self): super(TestPipelineSegmentTiming, self).setUp() self.net1 = self.net['net1'] self.net4 = self.net['net4'] self.netlr = Network('net1') self.netlr.set_input_layer(InputLayer(10, 1)) self.netlr.add('0p1', PoolingLayer(10, 1, 1)) self.netlr.add('0p2', PoolingLayer(10, 1, 1)) self.netlr.add('0p3', PoolingLayer(10, 1, 1)) self.netlr.add('1', FCLayer(10, 20))
def test_is_valid_padding_sifm(self): ''' is_valid_padding_sifm. ''' clayer = ConvLayer(3, 64, [28, 14], [3, 1], [2, 4]) self.assertTrue(clayer.is_valid_padding_sifm([28 * 2, 14 * 4])) self.assertTrue(clayer.is_valid_padding_sifm([27 * 2 + 3, 13 * 4 + 1])) self.assertFalse(clayer.is_valid_padding_sifm([28, 14])) self.assertFalse(clayer.is_valid_padding_sifm([28 * 2, 14])) self.assertTrue(clayer.is_valid_padding_sifm([27 * 2 + 3, 13 * 4 + 3])) flayer = FCLayer(2048, 4096, sfil=2) self.assertTrue(flayer.is_valid_padding_sifm(2)) self.assertTrue(flayer.is_valid_padding_sifm(1)) self.assertTrue(flayer.is_valid_padding_sifm([1, 2])) llayer = LocalRegionLayer(64, 28, 2, 1) self.assertTrue(llayer.is_valid_padding_sifm(28)) self.assertFalse(llayer.is_valid_padding_sifm(28 - 1)) self.assertFalse(llayer.is_valid_padding_sifm(28 + 1)) player = PoolingLayer(64, 28, [2, 3], strd=[3, 2]) self.assertTrue(player.is_valid_padding_sifm([28 * 3, 28 * 2])) self.assertTrue(player.is_valid_padding_sifm([27 * 3 + 2, 27 * 2 + 3]))
def test_vertex_no_merge_lr(self): ''' LocalRegionLayer has no previous layer to merge with. ''' net = Network('tmp_net') net.set_input_layer(InputLayer(30, 1)) net.add('0', PoolingLayer(30, 1, 1)) net.add('1', FCLayer(30, 40)) net.add('1p', PoolingLayer(40, 1, 1)) ilp = self._make_ilp(net) for layer in net: vidx = ilp.dag_vertex_dict[layer] self.assertIn(layer, ilp.dag_vertex_list[vidx]) # Layer is named by topological order. self.assertTrue(layer.startswith(str(vidx)))
def setUp(self): self.network = Network('test_net') self.network.set_input(InputLayer(3, 224)) self.network.add('c1', ConvLayer(3, 64, 224, 3)) self.network.add('p1', PoolingLayer(64, 7, 32), prevs='c1') self.network.add('p2', PoolingLayer(64, 7, 32), prevs='c1') self.network.add('f1', FCLayer(64, 1000, 7), prevs=['p1', 'p2']) self.batch_size = 4 self.input_layout = partition.get_ofmap_layout( self.network.input_layer(), self.batch_size, PartitionScheme(order=range(pe.NUM), pdims=[(1, 1)] * pe.NUM), NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(2, 1), type=NodeRegion.DATA)) self.c1res = SchedulingResult( dict_loop=OrderedDict([('cost', 1.), ('time', 2.), ('ops', 4.), ('access', [[7, 8, 9]] * me.NUM), ]), dict_part=OrderedDict([('cost', 0.5), ('total_nhops', [4, 5, 6]), ('num_nodes', 4), ]), ofmap_layout=partition.get_ofmap_layout( self.network['c1'], self.batch_size, PartitionScheme(order=range(pe.NUM), pdims=[(1, 1)] * pe.NUM), NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 2), type=NodeRegion.DATA))) self.pres = SchedulingResult( dict_loop=OrderedDict([('cost', 0.1), ('time', 0.05), ('ops', 0.1), ('access', [[.7, .8, .9]] * me.NUM), ]), dict_part=OrderedDict([('cost', 0.5), ('total_nhops', [.4, .5, .6]), ('num_nodes', 2), ]), ofmap_layout=partition.get_ofmap_layout( self.network['p1'], self.batch_size, PartitionScheme(order=range(pe.NUM), pdims=[(1, 1)] * pe.NUM), NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 2), type=NodeRegion.DATA))) self.dtfl = NNDataflowScheme(self.network, self.input_layout) self.dtfl['c1'] = self.c1res self.dtfl['p1'] = self.pres self.dtfl['p2'] = self.pres
# With residual shortcut. if i == 0: NN.add('conv4_br', ConvLayer(512, 1024, 14, 1, 2), prevs=(RES_PREV, )) RES_PREV = 'conv4_br' NN.add('conv4_{}_res'.format(i), EltwiseLayer(1024, 14, 2), prevs=(RES_PREV, 'conv4_{}_c'.format(i))) RES_PREV = 'conv4_{}_res'.format(i) for i in range(3): NN.add( 'conv5_{}_a'.format(i), ConvLayer(1024, 512, 7, 1, 2) if i == 0 else ConvLayer( 2048, 512, 7, 1)) NN.add('conv5_{}_b'.format(i), ConvLayer(512, 512, 7, 3)) NN.add('conv5_{}_c'.format(i), ConvLayer(512, 2048, 7, 1)) # With residual shortcut. if i == 0: NN.add('conv5_br', ConvLayer(1024, 2048, 7, 1, 2), prevs=(RES_PREV, )) RES_PREV = 'conv5_br' NN.add('conv5_{}_res'.format(i), EltwiseLayer(2048, 7, 2), prevs=(RES_PREV, 'conv5_{}_c'.format(i))) RES_PREV = 'conv5_{}_res'.format(i) NN.add('pool5', PoolingLayer(2048, 1, 7)) NN.add('fc', FCLayer(2048, 1000))
NN.add('pool4', PoolingLayer(832, 7, 3, strd=2), prevs=_PREVS) _PREVS = ('pool4', ) # Inception 5. _PREVS = add_inception(NN, '5a', 7, 832, 256, 160, 320, 32, 128, 128, prevs=_PREVS) _PREVS = add_inception(NN, '5b', 7, 832, 384, 192, 384, 48, 128, 128, prevs=_PREVS) NN.add('pool5', PoolingLayer(1024, 1, 7), prevs=_PREVS) NN.add('fc', FCLayer(1024, 1000))
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the BSD-3 License for more details. You should have received a copy of the Modified BSD-3 License along with this program. If not, see <https://opensource.org/licenses/BSD-3-Clause>. """ from nn_dataflow.core import Network from nn_dataflow.core import InputLayer, FCLayer from nn_dataflow.nns import add_lstm_cell ''' LSTM for phoneme classification. Graves and Schmidhuber, 2005 ''' NN = Network('PHONEME') NN.set_input_layer(InputLayer(26, 1)) # Input. NN.add('We', FCLayer(26, 140), prevs=(NN.INPUT_LAYER_KEY, )) # LSTM. C, H = add_lstm_cell(NN, 'cell', 140, 'We') # Output. NN.add('Wd', FCLayer(140, 61), prevs=(H, ))
If you use this program in your research, we request that you reference the TETRIS paper ("TETRIS: Scalable and Efficient Neural Network Acceleration with 3D Memory", in ASPLOS'17. April, 2017), and that you send us a citation of your work. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the BSD-3 License for more details. You should have received a copy of the Modified BSD-3 License along with this program. If not, see <https://opensource.org/licenses/BSD-3-Clause>. """ from nn_dataflow.core import Network from nn_dataflow.core import InputLayer, FCLayer ''' MLP-L PRIME, 2016 ''' NN = Network('MLP-L') NN.set_input(InputLayer(784, 1)) NN.add('fc1', FCLayer(784, 1500)) NN.add('fc2', FCLayer(1500, 1000)) NN.add('fc3', FCLayer(1000, 500)) NN.add('fc4', FCLayer(500, 10))
def setUp(self): self.net = {} net = Network('net1') # Linear. net.set_input_layer(InputLayer(10, 1)) net.add('0', FCLayer(10, 20)) net.add('1', FCLayer(20, 30)) net.add('1p', PoolingLayer(30, 1, 1)) net.add('2', FCLayer(30, 40)) net.add('3', FCLayer(40, 50)) self.net[net.net_name] = net net = Network('net2') # Long linear. net.set_input_layer(InputLayer(1, 1)) for idx in range(16): net.add(str(idx), FCLayer(1, 1)) self.net[net.net_name] = net net = Network('net3') # Fork. # /0-2\ /6- 7- 8\ # x 4-5 12 # \1-3/ \9-10-11/ net.set_input_layer(InputLayer(1, 1)) net.add('0', FCLayer(1, 1), prevs=net.INPUT_LAYER_KEY) net.add('1', FCLayer(1, 1), prevs=net.INPUT_LAYER_KEY) net.add('2', FCLayer(2, 1), prevs=('0', '1')) net.add('2p', PoolingLayer(1, 1, 1)) net.add('3', FCLayer(2, 1), prevs=('0', '1')) net.add('4', FCLayer(2, 1), prevs=('2p', '3')) net.add('5', FCLayer(1, 1)) net.add('5p', PoolingLayer(1, 1, 1)) net.add('6', FCLayer(1, 1), prevs='5p') net.add('7', FCLayer(1, 1)) net.add('8', FCLayer(1, 1)) net.add('9', FCLayer(1, 1), prevs='5p') net.add('10', FCLayer(1, 1)) net.add('11', FCLayer(1, 1)) net.add('12', FCLayer(2, 1), prevs=('8', '11')) self.net[net.net_name] = net net = Network('net4') # Complex fork. # /5 \ # 0-1-2-3-4-6-7-8-10-14 # \9/ # \11-12 / # \13 / net.set_input_layer(InputLayer(1, 1)) net.add('0', FCLayer(1, 1)) net.add('1', FCLayer(1, 1)) net.add('2', FCLayer(1, 1)) net.add('3', FCLayer(1, 1)) net.add('4', FCLayer(1, 1)) net.add('5', FCLayer(1, 1), prevs='4') net.add('6', FCLayer(1, 1), prevs='4') net.add('7', FCLayer(1, 1)) net.add('8', FCLayer(1, 1), prevs='7') net.add('9', FCLayer(1, 1), prevs='7') net.add('10', FCLayer(1, 1)) net.add('10p', PoolingLayer(2, 1, 1), prevs=('8', '10')) net.add('11', PoolingLayer(1, 1, 1), prevs='4') net.add('12', FCLayer(1, 1)) net.add('13', PoolingLayer(1, 1, 1), prevs='4') net.add('14', FCLayer(5, 1), prevs=('5', '10p', '12', '13')) self.net[net.net_name] = net net = Network('net5') # Corner cases. # ----\ # //1-2\ 7-8\ # 0-3-4-x 10-11-12 # \ \5/ 9 / \__/ # 6--/ net.set_input_layer(InputLayer(1, 1)) net.add('0', FCLayer(1, 1)) net.add('1', FCLayer(1, 1), prevs='0') net.add('2', FCLayer(1, 1)) net.add('3', FCLayer(1, 1), prevs='0') net.add('4', FCLayer(1, 1), prevs='3') net.add('5', FCLayer(1, 1), prevs='3') net.add('6', FCLayer(1, 1), prevs='0') net.add('7', FCLayer(5, 1), prevs=('0', '2', '4', '5', '6')) net.add('8', FCLayer(1, 1)) net.add('9', FCLayer(5, 1), prevs=('0', '2', '4', '5', '6')) net.add('10', FCLayer(2, 1), prevs=('8', '9')) net.add('11', FCLayer(1, 1)) net.add('12', FCLayer(2, 1), prevs=('10', '11')) self.net[net.net_name] = net net = Network('net6') # Fmap sizes. net.set_input_layer(InputLayer(1, 24)) net.add('0', ConvLayer(1, 1, 24, 3)) net.add('1', ConvLayer(1, 1, 12, 3, strd=2)) net.add('1p', PoolingLayer(1, 6, 2)) net.add('2', ConvLayer(1, 1, 6, 3)) net.add('3', ConvLayer(1, 1, 6, 3, strd=4), prevs=('0')) self.net[net.net_name] = net net = Network('net7') # Topological order: see a visited vertex again. # /--- # 0-1-\\ # \2--2p net.set_input_layer(InputLayer(1, 1)) net.add('0', FCLayer(1, 1)) net.add('1', FCLayer(1, 1), prevs='0') net.add('2', FCLayer(1, 1), prevs='0') net.add('2p', PoolingLayer(3, 1, 1), prevs=('0', '1', '2')) self.net[net.net_name] = net net = Network('net8') # Forward to the middle. # /-\ # 0-1-2-2p-4-4p # \-3------/ net.set_input_layer(InputLayer(1, 1)) net.add('0', FCLayer(1, 1)) net.add('1', FCLayer(1, 1), prevs='0') net.add('2', FCLayer(1, 1), prevs='1') net.add('2p', PoolingLayer(2, 1, 1), prevs=('1', '2')) net.add('3', FCLayer(1, 1), prevs='0') net.add('4', FCLayer(2, 1), prevs='2p') net.add('4p', PoolingLayer(2, 1, 1), prevs=('3', '4')) self.net[net.net_name] = net net = Network('net9') # Previous layers include input and others. net.set_input_layer(InputLayer(1, 1)) net.add('0', FCLayer(1, 1)) net.add('1', FCLayer(2, 1), prevs=(net.INPUT_LAYER_KEY, '0')) self.net[net.net_name] = net # Real networks. for net_name in all_networks(): self.net[net_name] = import_network(net_name) self.batch_size = 16 self.resource = Resource( proc_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(8, 8), type=NodeRegion.PROC), dram_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(8, 8), type=NodeRegion.DRAM), src_data_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(8, 4), type=NodeRegion.DRAM), dst_data_region=NodeRegion(origin=PhyDim2(0, 4), dim=PhyDim2(8, 4), type=NodeRegion.DRAM), dim_array=PhyDim2(16, 16), size_gbuf=65536, size_regf=64, array_bus_width=float('inf'), dram_bandwidth=float('inf'), no_time_mux=False) part = PartitionScheme(order=range(pe.NUM), pdims=[(1, 1)] * pe.NUM) self.ofmap_layout = DataLayout( frngs=(FmapRange((0, 0, 0, 0), (2, 4, 16, 16)), ), regions=(NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.DRAM), ), parts=(part, ))
Copyright (C) 2016-2020 by Tsinghua University and The Board of Trustees of Stanford University This program is free software: you can redistribute it and/or modify it under the terms of the Modified BSD-3 License as published by the Open Source Initiative. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the BSD-3 License for more details. You should have received a copy of the Modified BSD-3 License along with this program. If not, see <https://opensource.org/licenses/BSD-3-Clause>. """ from nn_dataflow.core import Network from nn_dataflow.core import InputLayer, FCLayer ''' MLP-S PRIME, 2016 ''' NN = Network('MLP-S') NN.set_input_layer(InputLayer(784, 1)) NN.add('fc1', FCLayer(784, 500)) NN.add('fc2', FCLayer(500, 250)) NN.add('fc3', FCLayer(250, 10))
NN = Network('AlexNet') NN.set_input(InputLayer(3, 224)) NN.add('conv1_a', ConvLayer(3, 48, 55, 11, 4), prevs=(NN.INPUT_LAYER_KEY,)) NN.add('conv1_b', ConvLayer(3, 48, 55, 11, 4), prevs=(NN.INPUT_LAYER_KEY,)) NN.add('pool1_a', PoolingLayer(48, 27, 3, strd=2), prevs=('conv1_a',)) NN.add('pool1_b', PoolingLayer(48, 27, 3, strd=2), prevs=('conv1_b',)) # Norm layer is ignored. NN.add('conv2_a', ConvLayer(48, 128, 27, 5), prevs=('pool1_a',)) NN.add('conv2_b', ConvLayer(48, 128, 27, 5), prevs=('pool1_b',)) NN.add('pool2_a', PoolingLayer(128, 13, 3, strd=2), prevs=('conv2_a',)) NN.add('pool2_b', PoolingLayer(128, 13, 3, strd=2), prevs=('conv2_b',)) # Norm layer is ignored. NN.add('conv3_a', ConvLayer(256, 192, 13, 3), prevs=('pool2_a', 'pool2_b')) NN.add('conv3_b', ConvLayer(256, 192, 13, 3), prevs=('pool2_a', 'pool2_b')) NN.add('conv4_a', ConvLayer(192, 192, 13, 3), prevs=('conv3_a',)) NN.add('conv4_b', ConvLayer(192, 192, 13, 3), prevs=('conv3_b',)) NN.add('conv5_a', ConvLayer(192, 128, 13, 3), prevs=('conv4_a',)) NN.add('conv5_b', ConvLayer(192, 128, 13, 3), prevs=('conv4_b',)) NN.add('pool3_a', PoolingLayer(128, 6, 3, strd=2), prevs=('conv5_a',)) NN.add('pool3_b', PoolingLayer(128, 6, 3, strd=2), prevs=('conv5_b',)) NN.add('fc1', FCLayer(256, 4096, 6), prevs=('pool3_a', 'pool3_b')) NN.add('fc2', FCLayer(4096, 4096)) NN.add('fc3', FCLayer(4096, 1000))
NN = Network('VGG') NN.set_input_layer(InputLayer(3, 224)) NN.add('conv1', ConvLayer(3, 64, 224, 3)) NN.add('conv2', ConvLayer(64, 64, 224, 3)) NN.add('pool1', PoolingLayer(64, 112, 2)) NN.add('conv3', ConvLayer(64, 128, 112, 3)) NN.add('conv4', ConvLayer(128, 128, 112, 3)) NN.add('pool2', PoolingLayer(128, 56, 2)) NN.add('conv5', ConvLayer(128, 256, 56, 3)) NN.add('conv6', ConvLayer(256, 256, 56, 3)) NN.add('conv7', ConvLayer(256, 256, 56, 3)) NN.add('pool3', PoolingLayer(256, 28, 2)) NN.add('conv8', ConvLayer(256, 512, 28, 3)) NN.add('conv9', ConvLayer(512, 512, 28, 3)) NN.add('conv10', ConvLayer(512, 512, 28, 3)) NN.add('pool4', PoolingLayer(512, 14, 2)) NN.add('conv11', ConvLayer(512, 512, 14, 3)) NN.add('conv12', ConvLayer(512, 512, 14, 3)) NN.add('conv13', ConvLayer(512, 512, 14, 3)) NN.add('pool5', PoolingLayer(512, 7, 2)) NN.add('fc1', FCLayer(512, 4096, 7)) NN.add('fc2', FCLayer(4096, 4096)) NN.add('fc3', FCLayer(4096, 1000))
def setUp(self): self.network = Network('test_net') self.network.set_input_layer(InputLayer(3, 224)) self.network.add('c1', ConvLayer(3, 64, 224, 3)) self.network.add('p1', PoolingLayer(64, 7, 32), prevs='c1') self.network.add('p2', PoolingLayer(64, 7, 32), prevs='c1') self.network.add('f1', FCLayer(128, 1000, 7), prevs=['p1', 'p2']) self.batch_size = 4 input_layer = self.network.input_layer() self.input_layout = DataLayout( frngs=(FmapRange((0, 0, 0, 0), FmapPosition(b=self.batch_size, n=input_layer.nofm, h=input_layer.hofm, w=input_layer.wofm)), ), regions=(NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(2, 1), type=NodeRegion.DRAM), ), parts=(PartitionScheme(order=range(pe.NUM), pdims=[(1, 1)] * pe.NUM), )) c1_layer = self.network['c1'] self.c1res = SchedulingResult( scheme=OrderedDict([ ('cost', 1.5), ('time', 200.), ('ops', 4.), ('num_nodes', 4), ('cost_op', 0.5), ('cost_access', 1.), ('cost_noc', 0), ('cost_static', 0), ('proc_time', 200), ('bus_time', 0), ('dram_time', 0), ('access', [[7, 8, 9]] * me.NUM), ('remote_gbuf_access', [0] * 3), ('total_nhops', [4, 5, 6]), ('fetch', [[1, 1, 1], [2, 2, 2]]), ('ti', [2, 2, 3]), ('to', [1, 2, 3]), ('tb', [1, 2, 3]), ('tvals', [[2, 1, 1], [2, 2, 2], [3, 3, 3]]), ('orders', [range(3)] * 2), ]), ofmap_layout=DataLayout( frngs=(FmapRange( (0, 0, 0, 0), FmapPosition(b=self.batch_size, n=c1_layer.nofm, h=c1_layer.hofm, w=c1_layer.wofm)), ), regions=(NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 2), type=NodeRegion.DRAM), ), parts=(PartitionScheme(order=range(pe.NUM), pdims=[(1, 1)] * pe.NUM), )), sched_seq=(0, 0, 0)) p1_layer = self.network['p1'] self.p1res = SchedulingResult( scheme=OrderedDict([ ('cost', 0.6), ('time', 5), ('ops', 0.1), ('num_nodes', 2), ('cost_op', 0.1), ('cost_access', 0.5), ('cost_noc', 0), ('cost_static', 0), ('proc_time', 5), ('bus_time', 0), ('dram_time', 0), ('access', [[.7, .8, .9]] * me.NUM), ('remote_gbuf_access', [0] * 3), ('total_nhops', [.4, .5, .6]), ('fetch', [[1, 1, 1], [2, 2, 2]]), ('ti', [2, 2, 3]), ('to', [1, 2, 3]), ('tb', [1, 2, 3]), ('tvals', [[2, 1, 1], [2, 2, 2], [3, 3, 3]]), ('orders', [range(3)] * 2), ]), ofmap_layout=DataLayout( frngs=(FmapRange( (0, 0, 0, 0), FmapPosition(b=self.batch_size, n=p1_layer.nofm, h=p1_layer.hofm, w=p1_layer.wofm)), ), regions=(NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 2), type=NodeRegion.DRAM), ), parts=(PartitionScheme(order=range(pe.NUM), pdims=[(1, 1)] * pe.NUM), )), sched_seq=(0, 1, 0)) self.p2res = SchedulingResult(scheme=self.p1res.scheme, ofmap_layout=self.p1res.ofmap_layout, sched_seq=(0, 2, 0)) self.dtfl = NNDataflowScheme(self.network, self.input_layout) self.dtfl['c1'] = self.c1res self.dtfl['p1'] = self.p1res self.dtfl['p2'] = self.p2res