updating layers to be compatible with HLS backend testing

fpgaconvnet_optimiser/models/layers/BufferLayer.py

@@ -33,14 +33,13 @@ def __init__(
             rows: int,
             cols: int,
             channels: int,
-            coarse_in: int,
-            coarse_out: int,
+            coarse: int,
             ctrledge,
             drop_mode   =True,
             data_width  =16,
         ):
         # initialise parent class
-        super().__init__([rows],[cols],[channels],[coarse_in],[coarse_out])
+        super().__init__([rows],[cols],[channels],[coarse],[coarse])
 
         #ctrledge links to exit condition layer
         self.ctrledge = ctrledge
@@ -62,8 +61,8 @@ def layer_info(self,parameters,batch_size=1):
         parameters.rows_out     = self.rows_out(0)
         parameters.cols_out     = self.cols_out(0)
         parameters.channels_out = self.channels_out(0)
-        parameters.coarse_in    = self.coarse_in
-        parameters.coarse_out   = self.coarse_out
+        parameters.coarse_in    = self.coarse_in[0]
+        parameters.coarse_out   = self.coarse_in[0]
 
     ## UPDATE MODULES ##
     def update(self):
@@ -87,10 +86,10 @@ def resource(self):
 
         # Total
         return {
-            "LUT"  :  buff_rsc['LUT']*self.coarse_in,
-            "FF"   :  buff_rsc['FF']*self.coarse_in,
-            "BRAM" :  buff_rsc['BRAM']*self.coarse_in,
-            "DSP" :   buff_rsc['DSP']*self.coarse_in,
+            "LUT"  :  buff_rsc['LUT']*self.coarse_in[0],
+            "FF"   :  buff_rsc['FF']*self.coarse_in[0],
+            "BRAM" :  buff_rsc['BRAM']*self.coarse_in[0],
+            "DSP" :   buff_rsc['DSP']*self.coarse_in[0],
         }
 
     def visualise(self,name):
@@ -105,26 +104,25 @@ def visualise(self,name):
 
         return cluster, nodes_in, nodes_out
 
-    def functional_model(self, data, ctrl_drop):
+    def functional_model(self, data, ctrl_drop, batch_size=1): #TODO implement batch size
         #Buffer is not an ONNX or pytorch op
         # check input dimensionality
-        assert data.shape[0] == self.rows_in(0)    , "ERROR (data): invalid row dimension"
-        assert data.shape[1] == self.cols_in(0)    , "ERROR (data): invalid column dimension"
-        assert data.shape[2] == self.channels_in(0), "ERROR (data): invalid channel dimension"
-
-        out = np.zeros((
-            self.rows,
-            self.cols,
-            self.channels),dtype=float)
-
-        if self.drop_mode: #non-inverted
-            if ctrl_drop:
-                return out
-            else:
-                return data #pass through
-        else: #inverted
-            if not ctrl_drop:
-                return out
-            else:
-                return data #pass through
-
+        assert data.shape[0] == batch_size          , "ERROR: invalid mismatched batch"
+        assert data.shape[1] == self.rows_in(0)     , "ERROR: invalid row dimension"
+        assert data.shape[2] == self.cols_in(0)     , "ERROR: invalid column dimension"
+        assert data.shape[3] == self.channels_in(0) , "ERROR: invalid channel dimension"
+
+        data_out=[]
+        for b, ctrl in zip(data, ctrl_drop):
+            if self.drop_mode: #non-inverted
+                if ctrl == 1.0:
+                    continue
+                else:
+                    data_out.append(b) #pass through
+            else: #inverted
+                if not ctrl == 1.0:
+                    continue
+                else:
+                    data_out.append(b) #pass through
+
+        return np.asarray(data_out)

fpgaconvnet_optimiser/models/layers/Layer.py

@@ -50,7 +50,7 @@ def __init__(
         ports_out: int
             number of ports out of the layer
         coarse_in: list int
-            number of parallel streams per port into the layer.    
+            number of parallel streams per port into the layer.
         coarse_out: list int
             number of parallel streams per port out of the layer.
         data_width: int
@@ -165,7 +165,7 @@ def rate_in(self, port_index):
 
         Returns
         -------
-        float 
+        float
             rate of words into layer. As a fraction of a
             clock cycle.
 
@@ -183,8 +183,8 @@ def rate_out(self, port_index):
 
         Returns
         -------
-        float 
-            rate of words out of the layer. As a fraction 
+        float
+            rate of words out of the layer. As a fraction
             of a clock cycle.
 
             default is 1.0
@@ -196,7 +196,7 @@ def streams_in(self, port_index):
         """
         Returns
         -------
-        int 
+        int
             number of parallel streams into the layer.
         """
         assert(port_index < self.ports_in)
@@ -206,7 +206,7 @@ def streams_out(self, port_index):
         """
         Returns
         -------
-        int 
+        int
             number of parallel streams out of the layer.
         """
         assert(port_index < self.ports_out)
@@ -221,14 +221,14 @@ def workload_in(self, port_index):
 
         Returns
         -------
-        int 
+        int
             workload into layer from port `index` for a single
-            featuremap. This is calculated by 
+            featuremap. This is calculated by
             `rows_in()*cols_in()*channels_in()`.
         """
         assert(port_index < self.ports_in)
         return self.rows_in(port_index) * self.cols_in(port_index) * self.channels_in(port_index)
-        
+
     def workload_out(self, port_index):
         """
         Parameters
@@ -238,9 +238,9 @@ def workload_out(self, port_index):
 
         Returns
         -------
-        int 
-            workload out of layer from port `index` for a 
-            single featuremap. This is calculated by 
+        int
+            workload out of layer from port `index` for a
+            single featuremap. This is calculated by
             `rows_out()*cols_out()*channels_out()`.
         """
         assert(port_index < self.ports_out)
@@ -250,17 +250,17 @@ def size_in(self, port_index):
         """
         Returns
         -------
-        int 
+        int
             workload in per stream.
         """
         assert(port_index < self.ports_in)
         return self.rows_in(port_index) * self.cols_in(port_index) * int( self.channels_in(port_index) / self.streams_in(port_index) )
-        
+
     def size_out(self, port_index):
         """
         Returns
         -------
-        int 
+        int
             workload out per stream.
         """
         assert(port_index < self.ports_out)
@@ -270,23 +270,23 @@ def width_in(self):
         """
         Returns
         -------
-        int 
+        int
             data width in
         """
         return self.data_width
-    
+
     def width_out(self):
         """
         Returns
         -------
-        int 
+        int
             data width out
-        """ 
+        """
         return self.data_width
 
     def get_latency(self):
-        latency_in  = max([ abs(self.workload_in(i)/(self.rate_in(i)*self.streams_in(i) )) for i in self.ports_in ])
-        latency_out = max([ abs(self.workload_out(i)/(self.rate_out(i)*self.streams_out(i))) for i in self.ports_out ])
+        latency_in  = max([ abs(self.workload_in(i)/(self.rate_in(i)*self.streams_in(i) )) for i in range(self.ports_in) ])
+        latency_out = max([ abs(self.workload_out(i)/(self.rate_out(i)*self.streams_out(i))) for i in range(self.ports_out) ])
         return max(latency_in,latency_out)
 
     def pipeline_depth(self):
@@ -306,7 +306,7 @@ def resource(self):
     def static_power(self):
         return 0
 
-    def dynamic_power(self, freq, rate): 
+    def dynamic_power(self, freq, rate):
         return 0
 
     def power(self,freq,rate):
@@ -334,7 +334,7 @@ def load_coef(self):
         #             os.path.dirname(__file__),
         #             "../../coefficients/{}_rsc_coef.npy".format(module))
         #     )
-        
+
 
     def update(self):
         pass
@@ -361,7 +361,7 @@ def layer_info_dict(self):
         parameter = fpgaconvnet_pb2.parameter()
         self.layer_info(parameter)
         # convert to dictionary
-        return MessageToDict(parameter, preserving_proto_field_name=True) 
+        return MessageToDict(parameter, preserving_proto_field_name=True)
 
     def visualise(self,name): # TODO
         cluster = pydot.Cluster(name,label=name)
@@ -372,7 +372,7 @@ def visualise(self,name): # TODO
         return cluster, "_".join([name,"edge"]), "_".join([name,"edge"])
 
     def functional_model(self,data,batch_size=1): # TODO: just leave empty
-        return 
+        return
 
     def balance_module_rates(self,rate_graph):
 
@@ -400,6 +400,6 @@ def balance_module_rates(self,rate_graph):
         return rate_graph
 
     def get_factors(self, n):
-        return list(set(reduce(list.__add__, 
+        return list(set(reduce(list.__add__,
                     ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
 

fpgaconvnet_optimiser/models/layers/SoftMaxCmpLayer.py

@@ -128,17 +128,27 @@ def visualise(self,name):
 
         return cluster, nodes_in, nodes_out
 
-    def functional_model(self, data, threshold):
-
-        assert data.shape[0] == self.rows    , "ERROR (data): invalid row dimension"
-        assert data.shape[1] == self.cols    , "ERROR (data): invalid column dimension"
-        assert data.shape[2] == self.channels, "ERROR (data): invalid channel dimension"
-
-        pk = softmax_layer(torch.from_numpy(data)).detach()
-        #get max value
-        top1 = torch.max(torch.from_numpy(data))
-        #True = early exit, drop buffered data
-        if top1 > threshold:
-            return 1.0
-        else:
-            return 0.0
+    def functional_model(self, data, batch_size=1):
+
+        assert data.shape[0] == self.rows_in(0)    , "ERROR (data): invalid row dimension"
+        assert data.shape[1] == self.cols_in(0)    , "ERROR (data): invalid column dimension"
+        assert data.shape[2] == self.channels_in(0), "ERROR (data): invalid channel dimension"
+
+        softmax_layer = torch.nn.Softmax(dim=-1)
+        out = np.zeros((batch_size, 3))
+        for b in range(batch_size):
+            pk = softmax_layer(torch.from_numpy(data)).detach()
+            #get max value
+            top1 = torch.max(torch.from_numpy(data))
+            #True = early exit, drop buffered data
+            if top1 > self.threshold:
+                out[b][0] = 1.0
+                out[b][1] = 1.0
+                out[b][2] = 1.0
+                #return 1.0
+            else:
+                out[b][0] = 0.0
+                out[b][1] = 0.0
+                out[b][2] = 0.0
+                #return 0.0
+        return out

fpgaconvnet_optimiser/models/layers/SplitLayer.py

@@ -160,17 +160,16 @@ def functional_model(self, data, batch_size=1):
 
 
         out = np.ndarray((
-            self.rows,
-            self.cols,
-            self.channels,
-            self.coarse),dtype=float)
+            self.rows_in(0),
+            self.cols_in(0),
+            self.channels_in(0),
+            self.ports_out),dtype=float)
 
         for index,_ in np.ndenumerate(out):
             out[index] = data[
               index[0],
               index[1],
-              index[2],
-              index[3]]
+              index[2]]
 
         return out
 

fpgaconvnet_optimiser/models/modules/Buffer.py

@@ -79,7 +79,7 @@ def rsc(self):
 
         bram_buffer = 0
         if bram_buffer_size >= 512: #taken from Accum.py modules
-            bram_buffer = math.ceil( (bram_acc_buffer_size)/18000)
+            bram_buffer = math.ceil( (bram_buffer_size)/18000)
         return {
           "LUT"  : 0, #int(np.dot(self.utilisation_model(), self.rsc_coef[0])),
           "BRAM" : bram_buffer,
@@ -99,12 +99,12 @@ def functional_model(self, data, ctrl_drop):
             self.channels),dtype=float)
 
         if self.drop_mode: #non-inverted
-            if ctrl_drop:
-                return out
+            if ctrl_drop == 1.0:
+                return
             else:
                 return data #pass through
         else: #inverted
-            if not ctrl_drop:
-                return out
+            if not ctrl_drop == 1.0:
+                return
             else:
                 return data #pass through

fpgaconvnet_optimiser/models/modules/Compare.py

@@ -86,8 +86,6 @@ def functional_model(self, exp_max_set, exp_sum_set):
         #assert data.shape[1] == self.cols    , "ERROR: invalid column dimension"
         #assert data.shape[2] == self.channels, "ERROR: invalid channel dimension"
         out = []
-        print(exp_max_set, exp_sum_set)
-        print(self.threshold)
         thr_set = np.array(exp_sum_set) * self.threshold
         for (exp_max, thr) in zip(exp_max_set, thr_set):
             if self.cmp_type == 'gt':
@@ -110,3 +108,4 @@ def functional_model(self, exp_max_set, exp_sum_set):
                     out.append( 1.0)
                 else:
                     out.append( 0.0)
+        return np.array(out)