Main Optimizer Error

[Boostedx]

Hi, I am getting this error when building the code.

firmware/nnet_utils/nnet_activation.h:136: Compiler Error: Unable to implement variable 'd_xi_xmax' in registers as requested. You may be taking a pointer or a reference to the variable. make: *** [Makefile:30: myproject-fpga] Error 1 sh: 1: ./myproject-fpga: not found

Please help, how would this error be solved?

Thanks in advance~

[bo3z]

Can you please post more details on the configuration (backend, target device, HLS version etc.), model architecture and size. A full script to re-create the error would be helpful.

[Boostedx]

Yes!, here is the code block for the conversion of the model to hls4ml. for the HLS, I am using Intel HLS compiler version 21.1, I apologize for the messy script, im glad you could help me. Thank you!

`import os
import numpy as np
import hls4ml
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.datasets import mnist
import csv
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
from tensorflow.keras.utils import to_categorical
import hls4ml.utils
import hls4ml.converters
import plotting

Load MNIST dataset

(x_train, y_train), (x_test, y_test) = mnist.load_data()

Normalize data (scale pixel values to [0,1])

x_train, x_test = x_train / 255.0, x_test / 255.0

Convert labels to categorical (one-hot encoding for HLS4ML)

y_train_cat = to_categorical(y_train, 10)
y_test_cat = to_categorical(y_test, 10)

Define a simple neural network model

model = Sequential([
Flatten(input_shape=(28, 28)),
Dense(128, activation='relu'),
Dense(64, activation='relu'),
Dense(10, activation='softmax')
])

Compile the model

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

Train the model

model.fit(x_train, y_train_cat, epochs=5, validation_data=(x_test, y_test_cat))

Extract trained weights and biases from the first Dense layer

trained_weights = model.layers[1].get_weights()[0] # First Dense layer's weights
trained_biases = model.layers[1].get_weights()[1] # First Dense layer's biases

Function to quantize weights to binary {-1, 1} representation

def quantize_weights_binary(weights):
return np.where(weights >= 0, 1, 0).astype(np.int32)

Function to save weights in binary format

def save_weights_bin(weights, filename, bit_mode="8bit"):
with open(filename, 'wb') as f:
flat_weights = weights.flatten()
chunk_size = 8 if bit_mode == "8bit" else 16
byte_size = 1 if bit_mode == "8bit" else 2

    for i in range(0, len(flat_weights), chunk_size):
        chunk = flat_weights[i:i+chunk_size]
        if len(chunk) < chunk_size:
            chunk = np.pad(chunk, (0, chunk_size - len(chunk)), 'constant')

        chunk_int = int("".join(map(str, chunk)), 2)
        f.write(chunk_int.to_bytes(byte_size, byteorder='little'))

Function to save biases in binary and CSV format

def save_biases_sram(biases, bin_filename, csv_filename):
with open(bin_filename, 'wb') as f_bin, open(csv_filename, 'w', newline='') as f_csv:
writer = csv.writer(f_csv)
writer.writerow(["Bias Index", "Bias Value (8-bit)"])

    flat_biases = biases.flatten()
    for idx, bias in enumerate(flat_biases):
        bias_int = int(bias)
        f_bin.write(bias_int.to_bytes(1, byteorder='little'))
        writer.writerow([idx, bias_int])

Function to save ROM address map

def save_rom_address_map(weights, csv_filename, bin_filename, bit_mode="8bit"):
with open(csv_filename, 'w', newline='') as f_csv, open(bin_filename, 'wb') as f_bin:
writer = csv.writer(f_csv)
writer.writerow(["ROM Address (Hex)", "OTP-ROM Array 1 (8-bit 1st Byte)", "OTP-ROM Array 2 (8-bit 2nd Byte)"])

    flat_weights = weights.flatten()
    address = 0
    chunk_size = 8 if bit_mode == "8bit" else 16

    for i in range(0, len(flat_weights), chunk_size):
        chunk = flat_weights[i:i+chunk_size]
        if len(chunk) < chunk_size:
            chunk = np.pad(chunk, (0, chunk_size - len(chunk)), 'constant')

        byte1 = format(int("".join(map(str, chunk[:8])), 2), '08b') if len(chunk) >= 8 else "00000000"
        byte2 = format(int("".join(map(str, chunk[8:])), 2), '08b') if len(chunk) > 8 else "00000000" if bit_mode == "16bit" else ""

        writer.writerow([f"{address:04X}", byte1, byte2])

        f_bin.write(int(byte1, 2).to_bytes(1, byteorder='little'))
        if bit_mode == "16bit":
            f_bin.write(int(byte2, 2).to_bytes(1, byteorder='little'))

        address += 1

Ensure bit order is correct

def check_rom_bit_order():
test_value = 0b11001010
stored_bytes = test_value.to_bytes(1, byteorder='little')
print(f"Stored Order: {' '.join(f'{byte:08b}' for byte in stored_bytes)}")
print("Interpretation: LSB is leftmost" if stored_bytes[0] & 0b00000001 else "Interpretation: MSB is leftmost")

Save binary weights and biases

storage_mode = "16bit"
binary_weights = quantize_weights_binary(trained_weights)
save_weights_bin(binary_weights, f'weights_rom_{storage_mode}.bin', bit_mode=storage_mode)
save_rom_address_map(binary_weights, f'weights_rom_map_{storage_mode}.csv', f'weights_rom_{storage_mode}.bin', bit_mode=storage_mode)
save_biases_sram(trained_biases, 'biases_sram.bin', 'biases_sram.csv')
check_rom_bit_order()

Function to convert model to HLS4ML

Function to convert model to HLS4ML with optimized resource usage

def convert_to_hls4ml(keras_model, x_test, y_test_cat=None, precision='ap_fixed<8, 4>', reuse_factor=4):
output_dir = '/home/renz/hlstest/test3'
os.makedirs(output_dir, exist_ok=True) # Ensure directory exists

# Generate HLS4ML config with resource-optimized settings
hls_config = hls4ml.utils.config_from_keras_model(
    keras_model, 
    granularity='name', 
    default_precision=precision, 
    default_reuse_factor=reuse_factor
)

# Global Strategy for reduced resource usage
hls_config['Model']['Strategy'] = 'Resource'

# Reduce register usage for ReLU layers
for layer in keras_model.layers:
    if "relu" in layer.name.lower():
        hls_config['LayerName'][layer.name] = {
            'Precision': 'ap_fixed<8, 4>',
            'ReuseFactor': 4,
            'Strategy': 'Resource'
        }

# Convert Keras model to HLS4ML model
hls_model = hls4ml.converters.convert_from_keras_model(
    keras_model, 
    hls_config=hls_config,
    output_dir=output_dir, 
    backend='Quartus',
    part='5CSEMA5F31C6'  # Replace with the correct part number if needed
)

hls_model.compile()

return hls_model

Convert the trained model to HLS4ML

hls_model = convert_to_hls4ml(model, x_test, y_test_cat)

Build HLS model with Quartus Synthesis

hls_model.build(synth=True, fpgasynth=True, log_level=2)

Make predictions

y_hls = hls_model.predict(x_test)
y_keras = model.predict(x_test)

Compute accuracy

print("Keras Accuracy: {}".format(accuracy_score(np.argmax(y_test_cat, axis=1), np.argmax(y_keras, axis=1))))
print("hls4ml Accuracy: {}".format(accuracy_score(np.argmax(y_test_cat, axis=1), np.argmax(y_hls, axis=1))))

Define class labels for ROC curve

classes = np.arange(10) # For MNIST (0-9)

Plot ROC curves

plt.figure(figsize=(9, 9))
_ = plotting.makeRoc(y_test_cat, y_keras, classes)
plt.gca().set_prop_cycle(None) # reset the colors
_ = plotting.makeRoc(y_test_cat, y_hls, classes, linestyle='--')

plt.show()
`

[bo3z]

My best guess is that the model is too large and the compiler can't figure out how to place the target variable into registers for this given device. Can you try increasing the ReuseFactor?

Additionally, maybe trying out Intel OneAPI instead of Intel HLS, since HLS has been deprecated and OneAPI should offer better performance?