Hive.py

import numpy as np
import conf
import IO2
import Pooling
import Activiation

class Hive():

    def __init__(self, EyerissF, mode="auto"):
        self.mode = mode
        self.EyerissF = EyerissF

    def input(self, Pictures, FilterWeights, PictureNum, FilterWeightNum):

        # check the state, input data must be compressed before
        assert np.ndim(Pictures[0]) == 1
        assert np.ndim(FilterWeights[0]) == 1

        Pictures = self.Decompress(Pictures)
        FilterWeights = self.Decompress(FilterWeights)

        self.Pictures = Pictures
        self.FilterWeights = FilterWeights
        self.PictureNum = PictureNum
        self.FilterWeightNum = FilterWeightNum

    def Conv2LogicalMapping(self):
        Pictures = self.Pictures
        FilterWeights = self.FilterWeights

        if self.PictureNum == 1:
            self.__FmapReuse__(Pictures, FilterWeights)
        elif self.FilterWeightNum == 1:
            self.__FilterReuse__(Pictures, FilterWeights)
        else:
            self.__ChannelAccumulation__(Pictures, FilterWeights)

    def Conv2PhysicalMapping(self):

        FilterWeight = self.FilterWeight
        Picture = self.Picture
        FilterWeight = self.FilterWeight
        x = 0
        t = list()
        while conf.EyerissWidth * x + conf.EyerissWidth + len(FilterWeight) - 1 < len(FilterWeight) + len(Picture) - 1:
            P = Picture[conf.EyerissWidth * x: conf.EyerissWidth * x + conf.EyerissWidth + len(FilterWeight) - 1]
            x = x + 1
            t.append(P)

        P = Picture[conf.EyerissWidth * x:]

        # 判断逻辑矩阵的尾巴，并删除多余的图
        if len(Picture[conf.EyerissWidth * x:]) < len(FilterWeight):
            pass
        else:
            t.append(P)

        self.__SetPhysicalMapping__(t)

    def Relu(self, array):
        if type(array) == type(list()):
            return Activiation.ReluArray(array)
        else:
            return Activiation.Relu(array)

    def Pooling(self, array, activation=1):
        if type(array) == type(list()):
            return Pooling.Pooling(array, activation)
        else:
            return Pooling.MAXPooling(array, activation)

    def Compress(self, NpArray, RateNeed=0):
        if type(NpArray) == type(list()):
            return IO2.CompressArray(NpArray)
        else:
            return IO2.Compress(NpArray, RateNeed)

    def Decompress(self, NpArray):
        if type(NpArray) == type(list()):
            return IO2.DecompressArray(NpArray)
        else:
            return IO2.Decompress(NpArray)

    def Conv2d(self, Pictures=0, FilterWeights=0, PictureNum=0, FilterWeightNum=0):
        if self.mode == "auto":

            # auto mode should compress data inside
            Pictures = self.Compress(Pictures)
            FilterWeights = self.Compress(FilterWeights)

            self.input(Pictures, FilterWeights, PictureNum, FilterWeightNum)
            self.Conv2LogicalMapping()
            self.Conv2PhysicalMapping()
            self.mode = "manual"
            self.Conv2d(0, 0, 0, 0)
            self.mode = "auto"
            self.Reverse()
            return self.Output()

        else:
            map = self.mapping
            self.t = [self.EyerissF.Conv2d(x, self.FilterWeight, self.PictureNum, self.FilterWeightNum) for x in map]
            self.TempPsum = np.vstack(self.t)

    def __SetPicAndFlt__(self, Picture, FilterWeight):
        self.Picture = Picture
        self.FilterWeight = FilterWeight

    def __FmapReuse__(self, Pictures, FilterWeights):

        assert len(Pictures) == 1

        NewArray = list()
        NewArrayLines = list()

        for x in range(0, len(FilterWeights[0])):
            # third, move the next pic NewArray
            for y in range(0, len(FilterWeights[0][0])):
                # second, in the same NewArray do the same operations
                for z in range(0, len(FilterWeights)):
                    # first, write different pics' pixs in a NewArray
                    NewArrayLines.append(FilterWeights[z][x][y])
            NewArray.append(np.hstack(NewArrayLines))
            NewArrayLines.clear()
        FilterWeight = np.array(NewArray)

        self.__SetPicAndFlt__(Pictures[0], FilterWeight)

    def __FilterReuse__(self, Pictures, FilterWeights):
        assert len(FilterWeights) == 1
        l = list()
        line = list()
        for y in range(0, len(Pictures[0])):
            # second move to next line to loop the inner operations
            for x in range(0, len(Pictures)):
                # first combine two lines ,which locate on different pics, to one line
                l.append(Pictures[x][y])
            line.append(np.hstack(l))
            l.clear()
        Picture = np.array(line)
        self.__SetPicAndFlt__(Picture, FilterWeights[0])

    def __SetPhysicalMapping__(self, mapping):
        self.mapping = mapping

    def Reverse(self):
        Psum = self.TempPsum
        if self.PictureNum == 1 and self.FilterWeightNum == 1:
            self.__SetReturnImgs__(Psum)
        if self.PictureNum == 1:
            self.__ReverseFmapReuse__(Psum, self.FilterWeightNum)
        elif self.FilterWeightNum == 1:
            self.__ReverseFilterReuse__(Psum, self.PictureNum)

    def __ReverseFmapReuse__(self, Psum, PsumNum):
        SubMap = np.hsplit(Psum, int(np.shape(Psum)[1] / PsumNum))
        l = []
        m = []
        for x in range(0, PsumNum):
            for y in range(len(SubMap)):
                # [np.newaxis]会使返回的向量为列向量
                l.append(np.transpose(np.array(SubMap[y][:, x])[np.newaxis]))
            m.append(np.hstack(l))
            l = []

        # self.__SetReturnImgs__(np.array(m))
        self.__SetReturnImgs__(m)

    def __ReverseFilterReuse__(self, Psum, PsumNum):
        self.__SetReturnImgs__(list(np.hsplit(Psum, PsumNum)))

    def __SetReturnImgs__(self, ReturnImgs):
        self.ReturnImgs = ReturnImgs

    def Output(self):
        return self.Compress(self.ReturnImgs)

    def FullConnect(self, v1, v2, activation=1):
        return np.array(np.dot(v1, v2) / activation, dtype=int)