165 lines
5.8 KiB
Python
165 lines
5.8 KiB
Python
"""
|
|
Export TinyCNN PyTorch weights and a test image to HLS headers.
|
|
|
|
Default command:
|
|
python hls_cnn/export_weights.py --model data/models/tiny_cnn.pth --test_image data/processed/val/class_0/10.jpg
|
|
"""
|
|
import argparse
|
|
import os
|
|
import sys
|
|
|
|
import numpy as np
|
|
import torch
|
|
from PIL import Image
|
|
|
|
|
|
def configure_stdio():
|
|
for stream in (sys.stdout, sys.stderr):
|
|
if hasattr(stream, "reconfigure"):
|
|
stream.reconfigure(encoding="utf-8", errors="replace")
|
|
|
|
|
|
configure_stdio()
|
|
|
|
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
|
|
PROJECT_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, ".."))
|
|
PC_TRAINING = os.path.join(PROJECT_ROOT, "pc_training")
|
|
if PC_TRAINING not in sys.path:
|
|
sys.path.insert(0, PC_TRAINING)
|
|
|
|
from tiny_cnn import create_tiny_cnn # noqa: E402
|
|
|
|
|
|
WEIGHT_SCALE = 1024
|
|
LOGIT_SCALE = 1024
|
|
|
|
|
|
def quantize_array(array, scale=WEIGHT_SCALE):
|
|
quantized = np.round(array * scale)
|
|
quantized = np.clip(quantized, -32768, 32767)
|
|
return quantized.astype(np.int16)
|
|
|
|
|
|
def nested_initializer(array, indent=0, line_width=12):
|
|
space = " " * indent
|
|
if array.ndim == 1:
|
|
values = [str(int(value)) for value in array]
|
|
chunks = []
|
|
for idx in range(0, len(values), line_width):
|
|
chunks.append(", ".join(values[idx:idx + line_width]))
|
|
if len(chunks) == 1:
|
|
return "{ " + chunks[0] + " }"
|
|
inner = (",\n" + " " * (indent + 4)).join(chunks)
|
|
return "{\n" + " " * (indent + 4) + inner + "\n" + space + "}"
|
|
|
|
parts = [
|
|
nested_initializer(array[idx], indent=indent + 4, line_width=line_width)
|
|
for idx in range(array.shape[0])
|
|
]
|
|
return "{\n" + " " * (indent + 4) + (",\n" + " " * (indent + 4)).join(parts) + "\n" + space + "}"
|
|
|
|
|
|
def c_array(name, array, c_type="const short", line_width=12):
|
|
dims = "".join(f"[{dim}]" for dim in array.shape)
|
|
return f"{c_type} {name}{dims} = {nested_initializer(array, indent=0, line_width=line_width)};"
|
|
|
|
|
|
def load_model(model_path, num_classes=10):
|
|
checkpoint = torch.load(model_path, map_location="cpu")
|
|
model = create_tiny_cnn(num_classes=num_classes)
|
|
state_dict = checkpoint.get("model_state_dict", checkpoint)
|
|
model.load_state_dict(state_dict)
|
|
model.eval()
|
|
return model, checkpoint
|
|
|
|
|
|
def preprocess_image(image_path, input_size=64):
|
|
image = Image.open(image_path).convert("L")
|
|
image = image.resize((input_size, input_size))
|
|
return np.asarray(image, dtype=np.uint8)
|
|
|
|
|
|
def export_weights(model, output_header):
|
|
state = model.state_dict()
|
|
arrays = {
|
|
"conv1_w": quantize_array(state["features.0.weight"].numpy()),
|
|
"conv1_b": quantize_array(state["features.0.bias"].numpy()),
|
|
"conv2_w": quantize_array(state["features.3.weight"].numpy()),
|
|
"conv2_b": quantize_array(state["features.3.bias"].numpy()),
|
|
"conv3_w": quantize_array(state["features.6.weight"].numpy()),
|
|
"conv3_b": quantize_array(state["features.6.bias"].numpy()),
|
|
"fc_w": quantize_array(state["classifier.weight"].numpy()),
|
|
"fc_b": quantize_array(state["classifier.bias"].numpy()),
|
|
}
|
|
|
|
lines = [
|
|
"#ifndef TINY_CNN_WEIGHTS_H",
|
|
"#define TINY_CNN_WEIGHTS_H",
|
|
"",
|
|
"// Auto-generated from TinyCNN PyTorch checkpoint.",
|
|
f"#define TINY_CNN_WEIGHT_SCALE {WEIGHT_SCALE}",
|
|
f"#define TINY_CNN_LOGIT_SCALE {LOGIT_SCALE}",
|
|
"",
|
|
]
|
|
for name, array in arrays.items():
|
|
lines.append(c_array(name, array))
|
|
lines.append("")
|
|
lines.append("#endif")
|
|
|
|
os.makedirs(os.path.dirname(os.path.abspath(output_header)), exist_ok=True)
|
|
with open(output_header, "w", encoding="utf-8", newline="\n") as file:
|
|
file.write("\n".join(lines))
|
|
print(f"Wrote weights: {output_header}")
|
|
|
|
|
|
def export_test_image(image_path, output_header, input_size=64):
|
|
pixels = preprocess_image(image_path, input_size=input_size)
|
|
lines = [
|
|
"#ifndef TINY_CNN_TEST_IMAGE_H",
|
|
"#define TINY_CNN_TEST_IMAGE_H",
|
|
"",
|
|
f"#define TINY_CNN_TEST_IMAGE_PATH \"{image_path.replace(os.sep, '/')}\"",
|
|
c_array("test_image_u8", pixels, c_type="const unsigned char", line_width=16),
|
|
"",
|
|
"#endif",
|
|
]
|
|
os.makedirs(os.path.dirname(os.path.abspath(output_header)), exist_ok=True)
|
|
with open(output_header, "w", encoding="utf-8", newline="\n") as file:
|
|
file.write("\n".join(lines))
|
|
print(f"Wrote test image: {output_header}")
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description="Export TinyCNN weights for HLS")
|
|
parser.add_argument("--model", default="data/models/tiny_cnn.pth")
|
|
parser.add_argument("--test_image", default="data/processed/val/class_0/10.jpg")
|
|
parser.add_argument("--weights_header", default="hls_cnn/include/tiny_cnn_weights.h")
|
|
parser.add_argument("--test_header", default="hls_cnn/include/tiny_cnn_test_image.h")
|
|
parser.add_argument("--input_size", type=int, default=64)
|
|
parser.add_argument("--num_classes", type=int, default=10)
|
|
args = parser.parse_args()
|
|
|
|
model_path = args.model
|
|
if not os.path.isabs(model_path):
|
|
model_path = os.path.join(PROJECT_ROOT, model_path)
|
|
test_image = args.test_image
|
|
if not os.path.isabs(test_image):
|
|
test_image = os.path.join(PROJECT_ROOT, test_image)
|
|
weights_header = args.weights_header
|
|
if not os.path.isabs(weights_header):
|
|
weights_header = os.path.join(PROJECT_ROOT, weights_header)
|
|
test_header = args.test_header
|
|
if not os.path.isabs(test_header):
|
|
test_header = os.path.join(PROJECT_ROOT, test_header)
|
|
|
|
model, checkpoint = load_model(model_path, num_classes=args.num_classes)
|
|
print(f"Loaded {model_path}")
|
|
print(f"Checkpoint best_acc: {checkpoint.get('best_acc', 'unknown')}")
|
|
|
|
export_weights(model, weights_header)
|
|
export_test_image(test_image, test_header, input_size=args.input_size)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|