def tf_model_to_arduino_code(inp_model, sub_X, sub_y, code):
"""
This function converts a trained TensorFlow model into an Arduino-compatible code
for forward propagation. The model's weights, biases, and activation functions
are extracted, and Arduino code is generated to represent the model for use on
an embedded system.
Inputs:
- inp_model: Trained TensorFlow model (Keras model) whose layers and weights
will be used for forward propagation.
- sub_X: Input data (not used in the function directly, but likely required
for the context or future extension).
- sub_y: Output data (not used directly, similar to `sub_X`).
- code: Template code (as a string) that will be modified and returned,
with model weights, biases, and activation functions.
Outputs:
- code2: Arduino code with initialized model weights, biases, and forward
propagation logic embedded.
"""
init_code="""
#include <math.h>
#include <Arduino.h>
#include <avr/pgmspace.h> // Include the PROGMEM functions
INIT_1
// Activation function///////////////
float sigmoid (float x){
return 1./(1.+exp(-x));
}
float relu (float x){
return max(x,0.);
}
float tanh_ (float x){
// make difference between tanh of C++ and tanh_ the activation func
return tanh(x);
}
float linear(float x){
return x;
}
///// You can add other activation function ////
void print_arr(float arr[], int N) {
Serial.print("[");
for (int i = 0; i < N; i++) {
Serial.print(arr[i],4);
if (i < N-1) {
Serial.print(",");
}
}
Serial.print("]");
}
void propagation(const float *WTf, float *VEC, const float *B,float *out, int M, int N, float (*act_func)(float)) {
// Perform matrix-vector multiplication and activation
for (int i = 0; i < M; ++i) {
out[i] = pgm_read_float_near(&B[i]);
for (int j = 0; j < N; ++j) {
out[i] += pgm_read_float_near(&WTf[i * N + j]) * VEC[j];
}
out[i] = act_func(out[i]);
}
}
void setup() {
Serial.begin(115200);
}
void loop() {
unsigned long timestart;
unsigned long timeend;
float Xi[dimX];
INIT_2
Serial.println("Cal_Ardui,Expected,Delta_time(us)");
for (int l=0;l<Nv;l++){
for(int j = 0; j<dimX;j++){
Xi[j]=pgm_read_float_near(&X[l*dimX+j]);
}
LOOP_
for (int k=0;k<M__final;k++){
Serial.print(OUTPUT__final[k],6);
Serial.print(" , ");
Serial.print(pgm_read_float_near(&y[l]),6);
Serial.print(" , ");
Serial.println(timeend-timestart);
}
}
Serial.println("====The End=====");
while(1);
}
"""
WTfs = [] # List to store flattened weight matrices for each layer
Bs = [] # List to store bias vectors for each layer
acts = [] # List to store activation functions for each layer
INIT = "" # String to hold the initialization section of Arduino code
# Loop through each layer of the model
for i, layer in enumerate(inp_model.layers):
W, B = layer.get_weights() # Get weights and biases for the current layer
WTf = W.T.flatten() # Flatten the weight matrix and store it
actfun = layer.activation.__name__ # Get the activation function name
WTfs.append(WTf) # Append flattened weights to the list
Bs.append(B) # Append biases to the list
acts.append(actfun) # Append activation function name to the list
print("Layer", i, "W shape", W.shape, "Bias shape", B.shape, "Activation Function", actfun)
# Define dimensions of weight matrix W
M, N = W.T.shape
# Get shape of the input data X (not used directly in the function)
xshape = X.shape
NvdimX = "const int Nv = " + str(xshape[0]) + ";\nconst int dimX = " + str(xshape[1]) + ";\n"
# Convert X and y to Arduino-compatible format and store as strings
Xystr = "\n/////// Xy ////// \nconst float X [] PROGMEM = " + array_to_arduino(X.flatten()) + ";\n\n" + \
"const float y[] PROGMEM = " + array_to_arduino(y.flatten()) + " ;\n\n"
initstr = "" # String to hold initialization section for each layer
# Loop through each layer again to generate initialization strings for weights and biases
for i, layer in enumerate(inp_model.layers):
W, B = layer.get_weights() # Get weights and biases for the current layer
M, N = W.T.shape # Get dimensions of the weight matrix
WTf = W.T.flatten() # Flatten the weights
# Prepare the Arduino code initialization for this layer
Mstr = "const int M" + str(i) + " = " + str(M) + " ;"
Nstr = "const int N" + str(i) + " = " + str(N) + " ;"
WTfstr = "const float WTf" + str(i) + "[] PROGMEM = " + str(WTf.tolist()).replace("[", "{").replace("]", "}") + " ;"
Bstr = "const float BIAS" + str(i) + "[] PROGMEM= " + str(B.tolist()).replace("[", "{").replace("]", "}") + " ;"
Outstr = "float OUTPUT" + str(i) + "[" + str(M) + "] ;"
layerstr = "// Layer" + str(i) + " init \n" + Nstr + "\n" + Mstr + "\n" + WTfstr + "\n" + Bstr + "\n" + Outstr
# Append the layer initialization to the overall initialization string
initstr += layerstr + "\n\n"
# Define the forward propagation logic in Arduino code
prostr = "\n///////// Forward Propagation ////////////\ntimestart=micros();\n"
funcstr = "propagation(WTf_, VEC, BIAS_, OUTPUT_, M_, N_, activation); // Layer_\n"
# Generate forward propagation code for each layer
for i, layer in enumerate(inp_model.layers):
W, B = layer.get_weights() # Get weights and biases
M, N = W.T.shape # Get dimensions of the weight matrix
WTf = W.T.flatten() # Flatten the weights
actfunc = layer.activation.__name__ # Get activation function name
actfunc = actfunc.replace('tanh', 'tanh_') # Replace 'tanh' with 'tanh_' for Arduino compatibility
prostr += funcstr.replace("_", str(i)) \
.replace('activation', actfunc) \
.replace("VEC", "OUTPUT" + str(i - 1)) \
.replace("OUTPUT-1", "Xi")
# Final Arduino code section
prostr += "timeend=micros();"
# Replace placeholders in the code template with the generated code
code2 = code.replace("INIT_1", NvdimX + initstr + Xystr)
code2 = code2.replace("INIT_2", "")
code2 = code2.replace("LOOP_", prostr)
code2 = code2.replace("__final", str(i)) # Replace the final placeholder with the last layer index
return code2 # Return the generated Arduino code
