def test_data_loops(self): ''' Get data_loops. ''' dls = LocalRegionLayer.data_loops() self.assertEqual(dls[de.FIL], DataDimLoops()) self.assertEqual(dls[de.IFM], DataDimLoops(le.OFM, le.BAT)) self.assertEqual(dls[de.OFM], DataDimLoops(le.OFM, le.BAT)) llayer = LocalRegionLayer(64, 28, 2, 1) player = PoolingLayer(64, 28, 2) self.assertTupleEqual(PoolingLayer.data_loops(), dls) self.assertTupleEqual(llayer.data_loops(), dls) self.assertTupleEqual(player.data_loops(), dls)
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_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 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 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 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_repr(self): ''' __repr__. ''' # pylint: disable=eval-used for l in [ LocalRegionLayer(64, 28, 2, 1), LocalRegionLayer(64, [28, 14], 1, [2, 4]), LocalRegionLayer(64, [28, 14], 1, [2, 4], 7), LocalRegionLayer(64, 28, 1, 4, 7) ]: self.assertIn('LocalRegionLayer', repr(l)) self.assertEqual(eval(repr(l)), l) for l in [ PoolingLayer(64, 28, 2), PoolingLayer(64, 28, 3, strd=2), PoolingLayer(64, [28, 14], [3, 4], strd=[2, 3]) ]: self.assertIn('PoolingLayer', repr(l)) self.assertEqual(eval(repr(l)), l)
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_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_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_valid_args(self): ''' Valid argument. ''' clayer = ConvLayer(3, 64, 28, 3, strd=2) self.assertEqual(clayer.nifm, 3, 'nifm') self.assertEqual(clayer.nofm, 64, 'nofm') self.assertEqual(clayer.hofm, 28, 'hofm') self.assertEqual(clayer.wofm, 28, 'wofm') self.assertEqual(clayer.hfil, 3, 'hfil') self.assertEqual(clayer.wfil, 3, 'wfil') self.assertEqual(clayer.htrd, 2, 'htrd') self.assertEqual(clayer.wtrd, 2, 'wtrd') llayer = LocalRegionLayer(64, 28, 1, 3, strd=2) self.assertEqual(llayer.nofm, 64, 'nofm') self.assertEqual(llayer.hofm, 28, 'hofm') self.assertEqual(llayer.wofm, 28, 'wofm') self.assertEqual(llayer.nreg, 1, 'nreg') self.assertEqual(llayer.hreg, 3, 'hreg') self.assertEqual(llayer.wreg, 3, 'wreg') self.assertEqual(llayer.htrd, 2, 'htrd') self.assertEqual(llayer.wtrd, 2, 'wtrd')
def test_mix_sreg(self): ''' Mix region of n-dimension and h/w-dimension. ''' with self.assertRaisesRegexp(ValueError, 'LocalRegionLayer: .*mix.*'): _ = LocalRegionLayer(64, 28, 2, 2)
def test_invalid_sreg(self): ''' Invalid region size. ''' with self.assertRaisesRegexp(ValueError, 'LocalRegionLayer: .*sreg.*'): _ = LocalRegionLayer(64, 28, 1, [2, 4, 6])
def test_region(self): ''' Get region size. ''' llayer = LocalRegionLayer(64, 28, 2, 1) self.assertEqual(llayer.region_size(), 2) llayer = LocalRegionLayer(64, 28, 1, [2, 4]) self.assertEqual(llayer.region_size(), 2 * 4)
def test_ops(self): ''' Get ops. ''' llayer = LocalRegionLayer(64, 28, 2, 1) self.assertEqual(llayer.ops_per_neuron(), 2) llayer = LocalRegionLayer(64, 28, 1, 3) self.assertEqual(llayer.ops_per_neuron(), 9)