def test_ops(self): ''' Get ops. ''' clayer = ConvLayer(3, 64, [28, 14], 3, strd=2) self.assertEqual(clayer.ops_per_neuron(), 3 * 3 * 3, 'ConvLayer: ops_per_neurons') self.assertEqual(clayer.total_ops(), 3 * 3 * 28 * 14 * 3 * 64, 'ConvLayer: total_ops')
def test_add_unmatch_prev(self): ''' Modifier add unmatch prevs. ''' network = Network('test_net') network.set_input(InputLayer(3, 224)) network.add('c1', ConvLayer(3, 64, 224, 3)) with self.assertRaisesRegexp(ValueError, 'Network: .*c1.*p1.*mismatch fmap.*'): network.add('p1', PoolingLayer(64, 7, 2)) self.assertEqual(len(network), 1) with self.assertRaisesRegexp(ValueError, 'Network: .*c1.*c2.*mismatch fmap.*'): network.add('c2', ConvLayer(64, 128, 220, 3)) self.assertEqual(len(network), 1) with self.assertRaisesRegexp(ValueError, 'Network: .*merge.*c1.*p1.*'): network.add('p1', PoolingLayer(32, 7, 32)) self.assertEqual(len(network), 1) with self.assertRaisesRegexp(ValueError, 'Network: .*merge.*c1.*c2.*'): network.add('c2', ConvLayer(32, 128, 224, 3)) self.assertEqual(len(network), 1) network.add('c2', ConvLayer(64, 128, 224, 3)) with self.assertRaisesRegexp(ValueError, r'Network: .*merge.*c1\s*c2.*p1.*'): network.add('p1', PoolingLayer(128, 7, 32), prevs=('c1', 'c2')) self.assertEqual(len(network), 2)
def _total_part_size(self, part, layerkey='PAR'): ''' Get the total partitioned data size. ''' layer = self.layer[layerkey] nifm = util.idivc(layer.nifm, part.size(pe.INPP)) * part.size(pe.INPP) nofm = util.idivc(layer.nofm, part.size(pe.OUTP)) * part.size(pe.OUTP) hofm = util.idivc(layer.hofm, part.dim(pe.OFMP).h) * part.dim(pe.OFMP).h wofm = util.idivc(layer.wofm, part.dim(pe.OFMP).w) * part.dim(pe.OFMP).w batch_size = util.idivc(self.batch_size, part.size(pe.BATP)) \ * part.size(pe.BATP) full_layer = ConvLayer(nifm, nofm, (hofm, wofm), (layer.hfil, layer.wfil), (layer.htrd, layer.wtrd)) filter_size = full_layer.total_filter_size() ifmap_size = full_layer.total_ifmap_size(batch_size) ofmap_size = full_layer.total_ofmap_size(batch_size) self.assertGreaterEqual(filter_size, layer.total_filter_size()) self.assertLess(filter_size, layer.total_filter_size() * 1.2 * 1.2) self.assertGreaterEqual(ofmap_size, layer.total_ofmap_size(self.batch_size)) self.assertLess( ofmap_size, layer.total_ofmap_size(self.batch_size) * 1.2 * 1.2 * 1.2) self.assertGreaterEqual(ifmap_size, layer.total_ifmap_size(self.batch_size)) return filter_size, ifmap_size, ofmap_size
def test_add_same_key(self): ''' Modifier add same key. ''' network = Network('test_net') network.set_input(InputLayer(3, 224)) network.add('c1', ConvLayer(3, 64, 224, 3)) with self.assertRaisesRegexp(KeyError, 'Network: .*c1.*'): network.add('c1', ConvLayer(64, 128, 224, 3))
def test_input_layer(self): ''' Get input layer. ''' clayer = ConvLayer(3, 64, [28, 14], 3, strd=2) inlayer = clayer.input_layer() self.assertIsInstance(inlayer, Layer) self.assertEqual(inlayer.nofm, 3, 'ConvLayer: input_layer: nofm') self.assertEqual(inlayer.hofm, (28 - 1) * 2 + 3, 'ConvLayer: input_layer: hofm') self.assertEqual(inlayer.wofm, (14 - 1) * 2 + 3, 'ConvLayer: input_layer: wofm')
def test_nexts_input(self): ''' Get nexts input layer. ''' nexts = self.network.nexts(self.network.INPUT_LAYER_KEY) self.assertTupleEqual(nexts, ('c1',)) self.network.add('c2', ConvLayer(3, 3, 224, 1), prevs=self.network.INPUT_LAYER_KEY) self.network.add('c3', ConvLayer(6, 4, 224, 1), prevs=(self.network.INPUT_LAYER_KEY, 'c2')) nexts = self.network.nexts(self.network.INPUT_LAYER_KEY) self.assertTupleEqual(nexts, ('c1', 'c2', 'c3'))
def setUp(self): self.alex_net = import_network('alex_net') self.vgg_net = import_network('vgg_net') net = Network('simple') net.set_input_layer(InputLayer(4, 2)) net.add('1', ConvLayer(4, 4, 2, 1)) net.add('2', ConvLayer(4, 4, 2, 1)) # Two more layers to avoid single-segment case. net.add('a1', ConvLayer(4, 1, 1, 1, strd=2)) net.add('a2', ConvLayer(1, 1, 1, 1)) self.simple_net = net net = Network('complex') net.set_input_layer(InputLayer(8, 8)) net.add('1', ConvLayer(8, 8, 8, 1)) net.add('2a', ConvLayer(8, 8, 8, 1), prevs=('1', )) net.add('3a', ConvLayer(8, 8, 8, 1)) net.add('2b', ConvLayer(8, 8, 8, 1), prevs=('1', )) net.add('3b', ConvLayer(8, 8, 8, 1)) net.add('4', ConvLayer(16, 8, 8, 1), prevs=('3a', '3b')) self.complex_net = net self.map_strategy = MapStrategyEyeriss self.resource = Resource( proc_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.PROC), dram_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.DRAM), src_data_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.DRAM), dst_data_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(1, 1), type=NodeRegion.DRAM), dim_array=PhyDim2(16, 16), size_gbuf=128 * 1024 // 2, # 128 kB size_regf=512 // 2, # 512 B array_bus_width=float('inf'), dram_bandwidth=float('inf'), no_time_mux=False, ) self.cost = Cost(mac_op=1, mem_hier=(200, 6, 2, 1), noc_hop=0, idl_unit=0) self.options = Option()
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 test_hash(self): ''' Get hash. ''' l1 = Layer(2, 12) l2 = Layer(2, 12) self.assertEqual(hash(l1), hash(l2)) l1 = ConvLayer(2, 12, 56, 3) l2 = ConvLayer(2, 12, 56, 3) self.assertEqual(hash(l1), hash(l2)) l1 = PoolingLayer(12, 14, 2) l2 = PoolingLayer(12, 14, 2) self.assertEqual(hash(l1), hash(l2))
def test_firsts_ext(self): ''' Get firsts with external layers. ''' self.network.add_ext('e0', InputLayer(3, 224)) self.network.add('c2', ConvLayer(3, 3, 224, 1), prevs=('e0',)) self.network.add('c3', ConvLayer(67, 3, 224, 1), prevs=('e0', 'c1')) self.network.add('c4', ConvLayer(6, 3, 224, 1), prevs=(self.network.INPUT_LAYER_KEY, 'e0',)) firsts = self.network.firsts() self.assertIn('c2', firsts) self.assertNotIn('c3', firsts) self.assertIn('c4', firsts)
def test_firsts(self): ''' Get firsts. ''' firsts = self.network.firsts() self.assertTupleEqual(firsts, ('c1',)) self.network.add('c2', ConvLayer(3, 3, 224, 1), prevs=self.network.INPUT_LAYER_KEY) self.network.add('c3', ConvLayer(6, 4, 224, 1), prevs=(self.network.INPUT_LAYER_KEY, 'c2')) firsts = self.network.firsts() self.assertTupleEqual(firsts, ('c1', 'c2')) self.assertIn('c1', firsts) self.assertNotIn('c3', firsts)
def test_eq(self): ''' Whether eq. ''' l1 = Layer(2, 12) l2 = Layer(2, 12) self.assertEqual(l1, l2) l1 = ConvLayer(2, 12, 56, 3) l2 = ConvLayer(2, 12, 56, 3) self.assertEqual(l1, l2) l1 = PoolingLayer(12, 14, 2) l2 = PoolingLayer(12, 14, 2) self.assertEqual(l1, l2) _ = l1 == 4
def test_ifmap(self): ''' Get ifmap. ''' clayer = ConvLayer(3, 64, [28, 14], 3, strd=2) inlayer = clayer.input_layer() self.assertIsInstance(inlayer, Layer) self.assertEqual(inlayer.nofm, clayer.nifm, 'ConvLayer: nifm') self.assertEqual(inlayer.hofm, clayer.hifm, 'ConvLayer: hifm') self.assertEqual(inlayer.wofm, clayer.wifm, 'ConvLayer: wifm') llayer = LocalRegionLayer(64, 28, 1, 3, strd=2) inlayer = llayer.input_layer() self.assertIsInstance(inlayer, Layer) self.assertEqual(inlayer.nofm, llayer.nifm, 'LocalRegionLayer: nifm') self.assertEqual(inlayer.hofm, llayer.hifm, 'LocalRegionLayer: hifm') self.assertEqual(inlayer.wofm, llayer.wifm, 'LocalRegionLayer: wifm')
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_part_layer(self): ''' Get part_layer. ''' batch_size = 16 layer = ConvLayer(32, 128, 28, 3) p_layer, p_batch_size, p_occ = self.ps1.part_layer(layer, batch_size) self.assertGreaterEqual(p_layer.hofm * self.ps1.dim(pe.OFMP).h, layer.hofm, 'part_layer: Conv: hofm') self.assertGreaterEqual(p_layer.wofm * self.ps1.dim(pe.OFMP).w, layer.wofm, 'part_layer: Conv: wofm') self.assertGreaterEqual(p_layer.nofm * self.ps1.size(pe.OUTP), layer.nofm, 'part_layer: Conv: nofm') self.assertGreaterEqual(p_layer.nifm * self.ps1.size(pe.INPP), layer.nifm, 'part_layer: Conv: nifm') self.assertGreaterEqual(p_batch_size * self.ps1.size(pe.BATP), 16, 'part_layer: Conv: batch_size') self.assertAlmostEqual(p_occ, 1. * (32 * 128 * 28 * 28 * 16) / (4 * 22 * 10 * 28 * 4 * self.ps1.size())) layer = PoolingLayer(128, 112, 2) p_layer, p_batch_size, p_occ = self.ps2.part_layer(layer, batch_size) self.assertGreaterEqual(p_layer.hofm * self.ps2.dim(pe.OFMP).h, layer.hofm, 'part_layer: Pooling: hofm') self.assertGreaterEqual(p_layer.wofm * self.ps2.dim(pe.OFMP).w, layer.wofm, 'part_layer: Pooling: wofm') self.assertGreaterEqual(p_layer.nofm * self.ps2.size(pe.OUTP), layer.nofm, 'part_layer: Pooling: nofm') self.assertGreaterEqual(p_layer.nifm, p_layer.nofm, 'part_layer: Pooling: nifm') self.assertGreaterEqual(p_batch_size * self.ps2.size(pe.BATP), 16, 'part_layer: Pooling: batch_size') self.assertAlmostEqual(p_occ, 1. * (128 * 112 * 112 * 16) / (32 * 23 * 23 * 2 * self.ps2.size()))
def setUp(self): self.layers = {} self.layers['BASE'] = ConvLayer(8, 16, 28, 3) self.layers['POOL'] = PoolingLayer(16, 28, 2) self.layers['LR'] = LocalRegionLayer(16, 28, nreg=3, sreg=1) self.batch_size = 4 self.cost = Cost(mac_op=1, mem_hier=(200, 6, 2, 1), noc_hop=50, unit_static=50) self.resource = Resource( proc_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(4, 4), type=NodeRegion.PROC), data_regions=(NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(4, 1), type=NodeRegion.DATA),), dim_array=PhyDim2(16, 16), size_gbuf=65536, size_regf=64) self.options = Option(partition_hybrid=True, partition_batch=True, partition_ifmaps=True, ntops=10) self.ifmap_layouts = {} part = PartitionScheme(order=(pe.INPP, pe.BATP, pe.OUTP, pe.OFMP), pdims=((1, 2), (2, 1), (1, 2), (2, 1))) for wlkey in self.layers: self.ifmap_layouts[wlkey] = partition.get_ofmap_layout( self.layers[wlkey].input_layer(), self.batch_size, part, self.resource.src_data_region())
def test_set_input_type(self): ''' Modifier set_input type. ''' network = Network('test_net') with self.assertRaisesRegexp(TypeError, 'Network: .*input_layer.*'): network.set_input(Layer(3, 24)) with self.assertRaisesRegexp(TypeError, 'Network: .*input_layer.*'): network.set_input(ConvLayer(3, 8, 24, 3))
def test_ifmap_size(self): ''' Get ifmap size. ''' clayer = ConvLayer(3, 64, [28, 14], 3, strd=2) self.assertEqual(clayer.ifmap_size(2), ((28 - 1) * 2 + 3) * ((14 - 1) * 2 + 3) * 2, 'ConvLayer: ifmap_size') self.assertEqual(clayer.total_ifmap_size(2), ((28 - 1) * 2 + 3) * ((14 - 1) * 2 + 3) * 3 * 2, 'ConvLayer: total_ifmap_size') llayer = LocalRegionLayer(64, 28, 1, 3, strd=2) self.assertEqual(llayer.ifmap_size(2), ((28 - 1) * 2 + 3)**2 * 2, 'LocalRegionLayer: ifmap_size') self.assertEqual(llayer.total_ifmap_size(2), ((28 - 1) * 2 + 3)**2 * 64 * 2, 'LocalRegionLayer: total_ifmap_size')
def test_match_io_fmap_range(self): ''' ofmap and ifmap range match. ''' for wlkey in self.layers: layer = self.layers[wlkey] for dnkey in self.dim_nodes: for part in self._gen_partition(wlkey=wlkey, dnkey=dnkey, optkey='NOINPP'): for pidx in part.gen_pidx(): ofr = partition.part_layer_ofmap_range( layer, self.batch_size, part, pidx) ifr = partition.part_layer_ifmap_range( layer, self.batch_size, part, pidx) self.assertEqual(ofr.size('b'), ifr.size('b')) if isinstance(layer, ConvLayer): ol = ConvLayer(nifm=ifr.size('n'), nofm=ofr.size('n'), sofm=(ofr.size('h'), ofr.size('w')), sfil=(layer.hfil, layer.wfil), strd=(layer.htrd, layer.wtrd)) il = ol.input_layer() self.assertEqual(il.nofm, ifr.size('n')) elif isinstance(layer, LocalRegionLayer): nofm_beg, nofm_end = ofr.beg_end('n')[0] nifm_beg, nifm_end = ifr.beg_end('n')[0] self.assertEqual(nifm_beg, max(0, \ nofm_beg - layer.nreg // 2)) self.assertEqual(nifm_end, min(layer.nifm, \ nofm_end + layer.nreg - layer.nreg // 2)) ol = LocalRegionLayer( nofm=ofr.size('n'), sofm=(ofr.size('h'), ofr.size('w')), nreg=layer.nreg, sreg=(layer.hreg, layer.wreg), strd=(layer.htrd, layer.wtrd)) il = ol.input_layer() self.assertEqual(il.hofm, ifr.size('h')) self.assertEqual(il.wofm, ifr.size('w'))
def test_add_ext_invalid_type(self): ''' Modifier add_ext invalid type. ''' network = Network('test_net') with self.assertRaisesRegex(TypeError, 'Network: .*external layer.*'): network.add_ext('e0', Layer(3, 24)) with self.assertRaisesRegex(TypeError, 'Network: .*external layer.*'): network.add_ext('e0', ConvLayer(3, 8, 24, 3))
def test_add_no_prev(self): ''' Modifier add no prevs. ''' network = Network('test_net') network.set_input(InputLayer(3, 224)) network.add('c1', ConvLayer(3, 64, 224, 3)) with self.assertRaisesRegexp(KeyError, 'Network: .*prev.*p1.*'): network.add('p1', PoolingLayer(64, 7, 32), prevs='p1')
def test_filter_size(self): ''' Get filter size. ''' clayer = ConvLayer(3, 64, [28, 14], 3) self.assertEqual(clayer.filter_size(2), 3 * 3 * 2, 'filter_size') self.assertEqual(clayer.total_filter_size(2), 3 * 3 * 3 * 64 * 2, 'total_filter_size') clayer = ConvLayer(3, 64, [28, 14], [3, 1]) self.assertEqual(clayer.filter_size(2), 3 * 1 * 2, 'filter_size') self.assertEqual(clayer.total_filter_size(2), 3 * 1 * 3 * 64 * 2, 'total_filter_size')
def setUp(self): self.layers = {} self.layers['BASE'] = ConvLayer(8, 16, 28, 3) self.layers['POOL'] = PoolingLayer(16, 28, 2) self.layers['LR'] = LocalRegionLayer(16, 28, nreg=3, sreg=1) self.batch_size = 4 self.cost = Cost(mac_op=1, mem_hier=(200, 6, 2, 1), noc_hop=50, idl_unit=50) self.none_cstr = SchedulingConstraint() self.cstr = SchedulingConstraint(topofm=1, topbat=self.batch_size) self.resource = Resource( proc_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(4, 4), type=NodeRegion.PROC), dram_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(4, 1), type=NodeRegion.DRAM), src_data_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(4, 1), type=NodeRegion.DRAM), dst_data_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(4, 1), 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) self.options = Option(partition_hybrid=True, partition_batch=True, partition_ifmaps=True, ntops=10) self.ifmap_layouts = {} part = PartitionScheme(order=(pe.INPP, pe.BATP, pe.OUTP, pe.OFMP), pdims=((1, 2), (2, 1), (1, 2), (2, 1))) for wlkey in self.layers: input_layer = self.layers[wlkey].input_layer() self.ifmap_layouts[wlkey] = 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=(self.resource.src_data_region, ), parts=(part.projection(self.resource.src_data_region, appl2frng=True), )) self.sched_seq = (2, 0, 1)
def test_prevs_ext_next(self): ''' Get prevs next layer of an external layer. ''' self.network.add_ext('e0', InputLayer(3, 224)) self.network.add('n', ConvLayer(6, 3, 224, 1), prevs=(self.network.INPUT_LAYER_KEY, 'e0')) prevs = self.network.prevs('n') self.assertTupleEqual(prevs, (None, 'e0'))
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_prevs_first(self): ''' Get prevs first layer. ''' self.network.add('c2', ConvLayer(3, 3, 224, 1), prevs=self.network.INPUT_LAYER_KEY) prevs = self.network.prevs('c1') self.assertTupleEqual(prevs, (None,)) prevs = self.network.prevs('c2') self.assertTupleEqual(prevs, (None,))
def test_prev_layers_first(self): ''' Get prev_layers first layer. ''' self.network.add('c2', ConvLayer(3, 3, 224, 1), prevs=self.network.INPUT_LAYER_KEY) self.network.add('c3', ConvLayer(3, 4, 224, 1), prevs=(self.network.INPUT_LAYER_KEY, 'c2')) prevs, symbol = self.network.prev_layers('c1') self.assertTupleEqual(prevs, (None, )) self.assertEqual(symbol, '|') prevs, symbol = self.network.prev_layers('c2') self.assertTupleEqual(prevs, (None, )) self.assertEqual(symbol, '|') prevs, symbol = self.network.prev_layers('c3') self.assertTupleEqual(prevs, (None, 'c2')) self.assertEqual(symbol, '+')
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 test_ofmap_size(self): ''' Get ofmap size. ''' clayer = ConvLayer(3, 64, [28, 14], 3) self.assertEqual(clayer.ofmap_size(), 28 * 14, 'ofmap_size') self.assertEqual(clayer.ofmap_size(2), 28 * 14 * 2, 'ofmap_size') self.assertEqual(clayer.total_ofmap_size(), 28 * 14 * 64, 'total_ofmap_size') self.assertEqual(clayer.total_ofmap_size(2), 28 * 14 * 64 * 2, 'total_ofmap_size')