Tweaks for running on Linux

This commit contains a number of tweaks to ensure exporting
quantization and testing inference both work on Linux-based
setups.

* `exportquant.py`: made `np.uint32` data type explicit -- on
  some configurations, the type `int` appears to be bridged by
  `numpy` into `np.int64`, so when the weights are packed, they're
  packed into 8 bytes instead of 4, and when the view is converted
  to `np.uint32` every other entry is just `0x00000000`.
* `BitNetMCU_MNIST_dll.c`: added forward declaration for
  BitMnistInference` and a guard for `__declspec`
  (not supported by gcc)
* `requirements.txt`: Added tensorboard, matplotlib
* Created `Makefile` for compilation on Linux

Author: donn

.gitignore

@@ -18,7 +18,7 @@ backup/
 *.pdf
 # python cache
 __pycache__/
-
-
-
-
+venv/
+# ides
+.vscode/
+.idea/

BitNetMCU_MNIST_dll.c

@@ -13,8 +13,15 @@
  * @return The result of the inference.
  */
 
+uint32_t BitMnistInference(int8_t *input);
+
 #ifdef _DLL
-__declspec(dllexport) uint32_t Inference(int8_t *input) {
+#ifdef WIN32
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT __attribute__((visibility("default")))
+#endif
+EXPORT uint32_t Inference(int8_t *input) {
     return BitMnistInference(input);
 }
 #endif
@@ -63,4 +70,4 @@ uint32_t BitMnistInference(int8_t *input) {
         return ReLUNorm(layer_out, layer_in, L3_outgoing_weights);
     #endif
 
-}
+}

Makefile

@@ -0,0 +1,10 @@
+SOURCES = BitNetMCU_MNIST_dll.c BitNetMCU_inference.c
+HEADERS = BitNetMCU_model.h  BitNetMCU_inference.h
+DLL = Bitnet_inf.dll
+
+$(DLL): $(SOURCES) $(HEADERS)
+	cc -fPIC -shared -o $@ -D _DLL $<
+
+.PHONY: clean
+clean:
+	rm -f $(DLL)

exportquant.py

@@ -69,27 +69,30 @@ def export_to_hfile(quantized_model, filename, runname):
 
             print(f'Layer: {layer} Quantization type: <{quantization_type}>, Bits per weight: {bpw}, Num. incoming: {incoming_weights},  Num outgoing: {outgoing_weights}')
 
+            data_type = np.uint32
+            
             if quantization_type == 'Binary':
                 encoded_weights = np.where(weights == -1, 0, 1)
                 QuantID = 1
             elif quantization_type == '2bitsym': # encoding -1.5 -> 11, -0.5 -> 10, 0.5 -> 00, 1.5 -> 01 (one complement with offset)
-                encoded_weights = ((weights < 0).astype(int) << 1) | (np.floor(np.abs(weights))).astype(int)  # use bitwise operations to encode the weights
+                encoded_weights = ((weights < 0).astype(data_type) << 1) | (np.floor(np.abs(weights))).astype(data_type)  # use bitwise operations to encode the weights
                 QuantID = 2
             elif quantization_type == '4bitsym': 
-                encoded_weights = ((weights < 0).astype(int) << 3) | (np.floor(np.abs(weights))).astype(int)  # use bitwise operations to encode the weights
+                encoded_weights = ((weights < 0).astype(data_type) << 3) | (np.floor(np.abs(weights))).astype(data_type)  # use bitwise operations to encode the weights
                 QuantID = 4
             elif quantization_type == 'FP130': # FP1.3.0 encoding (sign * 2^exp)
-                encoded_weights = ((weights < 0).astype(int) << 3) | (np.floor(np.log2(np.abs(weights)))).astype(int)  
+                encoded_weights = ((weights < 0).astype(data_type) << 3) | (np.floor(np.log2(np.abs(weights)))).astype(data_type)  
                 QuantID = 16 + 4
             else:
                 print(f'Skipping layer {layer} with quantization type {quantization_type} and {bpw} bits per weight. Quantization type not supported.')
 
             # pack bits into 32 bit words
             weight_per_word = 32 // bpw 
             reshaped_array = encoded_weights.reshape(-1, weight_per_word)
-            bit_positions = 32 - bpw - np.arange(weight_per_word) * bpw
-            packed_weights = np.bitwise_or.reduce(reshaped_array << bit_positions, axis=1).view(np.uint32)
-
+            
+            bit_positions = 32 - bpw - np.arange(weight_per_word, dtype=data_type) * bpw
+            packed_weights = np.bitwise_or.reduce(reshaped_array << bit_positions, axis=1).view(data_type)
+            
             # print(f'weights: {weights.shape} {weights.flatten()[0:16]}')
             # print(f'Encoded weights: {encoded_weights.shape} {encoded_weights.flatten()[0:16]}')
             # print(f'Packed weights: {packed_weights.shape} {", ".join(map(lambda x: hex(x), packed_weights.flatten()[0:4]))}')
@@ -338,4 +341,6 @@ def plot_weight_histograms(quantized_model):
     # export the quantized model to a header file
     # export_to_hfile(quantized_model, f'{exportfolder}/{runname}.h')
     export_to_hfile(quantized_model, f'BitNetMCU_model.h',runname)
-    plt.show()
+    
+    if showplots:
+        plt.show()

requirements.txt

@@ -1,4 +1,6 @@
 torch
 torchvision
 numpy
-PyYAML
+PyYAML
+tensorboard
+matplotlib