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')
