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
