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
Esempio n. 2
0
    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')