License & Attribution
This repository contains weights or code derived from the SmolVLA foundational architecture developed by Hugging Face and the LeRobot Authors.
- License: Distributed under the https://apache.org.
- Original Model Base: https://huggingface.co/lerobot/smolvla_base
- Copyright Notice: Copyright 2025-2026 Hugging Face & The LeRobot Authors.
- Research paper introducing this model: https://arxiv.org/pdf/2506.01844
This is SmolVLA-Base model cloned from Hugginface "lerobot/smolvla_base" repository.
This was createed for ready-to-use custom model for easy inference during Hackathon challenge.
Script to load model from HuggingFace:
from lerobot.policies.smolvla.modeling_smolvla import SmolVLAPolicy
from lerobot.policies.factory import make_pre_post_processors
import torch
device = "cuda" if torch.cuda.is_available() else "cpu"
# Switch this to your custom Hugging Face model repository or local directory path
my_custom_model_id = "Man1103/SmolVLA-Base-0.45B"
# 2. Load Model instance skeleton onto device
model = SmolVLAPolicy.from_pretrained(my_custom_model_id).to(device)
print("Model successfully loaded!")
Script for loading model specific preprocess and postprocess assets:
# 3. Initialize pre/post-processors using your loaded model config
preprocess, postprocess = make_pre_post_processors(
policy_cfg=model.config, # Passes the structural configuration matrix
pretrained_path=my_custom_model_id # Resolves dataset statistics from your repository
)
print("Model successfully initialized!")
Script to perform random sample inference:
import numpy as np
import pandas as pd
from PIL import Image
import torch
import torchvision.transforms.functional as TF
# 1. Create a dummy image frame (RGB, 256x256 as specified by the model's expected shape)
mock_image = Image.fromarray(np.random.randint(0, 255, (256, 256, 3), dtype=np.uint8))
mock_instruction = "Grasp the red block and place it in the tray."
mock_robot_state = torch.zeros((1, 6)) # Example: 6-DoF robot arm state
# 2. Build the observation map using the EXACT keys the model is looking for
observation_frame = {
"observation.images.camera1": mock_image,
"observation.images.camera2": mock_image,
"observation.images.camera3": mock_image,
"observation.state": mock_robot_state,
"task": mock_instruction
}
# 3. Process and format
processed_observation = preprocess(observation_frame)
# 4. Push tensors to the GPU, add batch dimensions, and convert PIL Images
for key, value in processed_observation.items():
if isinstance(value, Image.Image):
# Convert to tensor (C, H, W) and add batch dimension -> (1, C, H, W)
tensor_val = TF.to_tensor(value).to(device)
processed_observation[key] = tensor_val.unsqueeze(0)
elif isinstance(value, torch.Tensor):
# Ensure tensor values have a batch dimension at index 0
if value.ndim == 1:
processed_observation[key] = value.unsqueeze(0).to(device)
elif value.ndim == 2 and key == "observation.state":
# State is already (1, 6), keep it or make sure it handles batching correctly
processed_observation[key] = value.to(device)
else:
processed_observation[key] = value.to(device)
# 5. Execute VLA Policy Inference
model.eval()
with torch.no_grad():
print("Predicting action sequence with batched streams...")
predicted_action = model.select_action(processed_observation)
final_robot_commands = postprocess(predicted_action)
# 6. Output Result
print("\n--- INFERENCE SUCCESS ---")
print("Predicted Robot Action Matrix shape:", final_robot_commands.shape)
print(f"Final robot command: {final_robot_commands}")
