ohad204/human-motion

Human Motion Dataset

This dataset contains 4,292 high-quality text-prompted 3D human motion samples, clean RGB videos, and corresponding SMPL motion.

Visual Demo

Dataset Structure

• data.parquet / metadata.jsonl: Metadata index containing:
  • file_name: Path to the RGB video (videos/sample_XXXXX.mp4)
  • prompt: Text description prompt string
  • safetensors_path: Path to associated tensor file (data/sample_XXXXX.safetensors)
• motion_stats.safetensors: Global dataset normalization statistics (motion_mean and motion_std tensors of shape [232]).
• data/*.safetensors: Minimal sample tensor files containing:
  • SMPL_motion: [121, 232] 3D SMPL motion representation (float32, normalized).
• videos/*.mp4: Clean RGB videos (121 frames, 704x1280, 24 FPS).

---

Interpreting SMPL_motion

Each sample contains a SMPL_motion tensor of shape [121, 232], representing a 121-frame motion sequence at 24 FPS (~5 seconds duration).

The 232 features per frame are sliced as follows:

Slice	Feature Name	Dimensions	Description
[:, 0:6]	Global Root Orientation	6	6D rotation vector for global body orientation
[:, 6:132]	Body Joint Rotations	126	21 body joints in 6D rotation format (21 × 6 = 126)
[:, 132:135]	Global Translation (XYZ)	3	Root body translation vector in 3D space
[:, 135:138]	Translation Velocity	3	Frame-to-frame translation velocity
[:, 138:222]	3D Joint Positions	66	22 3D joint Cartesian coordinates (22 × 3 = 66)
[:, 222:232]	SMPL Betas / Shape	10	10 SMPL body shape parameter coefficients

---

Quick Start / Usage

1. Load Metadata & Video

import cv2
import pandas as pd
from datasets import load_dataset

# Load metadata dataset
dataset = load_dataset("parquet", data_files="data.parquet")
sample = dataset["train"][0]

print("Prompt:", sample["prompt"])
print("Video path:", sample["file_name"])

# Load RGB video
cap = cv2.VideoCapture(sample["file_name"])
ret, frame = cap.read()
print("RGB Frame Shape:", frame.shape) # (1280, 704, 3)
cap.release()

2. Decode SMPL_motion & Render SMPL 3D Mesh

The SMPL_motion uses JOINT_NUM=24 joints and 6D rotation encoding. The motion is stored normalized — you load motion_mean and motion_std from motion_stats.safetensors to denormalize.

Motion layout (232 dims):

Slice	Dims	Description
[:, 0:6]	6	Global root orientation (6D rotation)
[:, 6:144]	138	Body pose — 23 joints × 6D rotation
[:, 144:147]	3	Root translation (X, Y, Z)
[:, 147:150]	3	Root velocity
[:, 150:222]	72	Joint positions (24 joints × 3D)
[:, 222:232]	10	SMPL shape betas

import os
import torch
import numpy as np
import smplx
import trimesh
import pyrender
import colorsys
import cv2
from torch.nn import functional as F
from safetensors.torch import load_file

# Must be set before any OpenGL import
os.environ["PYOPENGL_PLATFORM"] = "egl"

SMPL_PATH = "path/to/SMPL_NEUTRAL.pkl"
JOINT_NUM = 24

def rot6d_to_axis_angle(rot6d):
    rot6d = rot6d.view(-1, 3, 2)
    a1, a2 = rot6d[:, :, 0], rot6d[:, :, 1]
    b1 = F.normalize(a1, dim=-1)
    b2 = F.normalize(a2 - torch.einsum('bi,bi->b', b1, a2).unsqueeze(-1) * b1, dim=-1)
    b3 = torch.cross(b1, b2, dim=-1)
    mat = torch.stack((b1, b2, b3), dim=-1)  # [N, 3, 3]
    trace = mat[:, 0, 0] + mat[:, 1, 1] + mat[:, 2, 2]
    angle = torch.acos(torch.clamp((trace - 1) / 2, -1.0, 1.0))
    axis = torch.stack([mat[:, 2, 1]-mat[:, 1, 2],
                        mat[:, 0, 2]-mat[:, 2, 0],
                        mat[:, 1, 0]-mat[:, 0, 1]], dim=-1)
    aa = axis / (2 * torch.sin(angle[:, None]) + 1e-8) * angle[:, None]
    aa[angle < 1e-5] = 0.0
    return aa

def axis_angle_to_mat3x3(aa):
    angle = aa.norm(dim=-1, keepdim=True)
    axis = aa / (angle + 1e-8)
    c, s = torch.cos(angle), torch.sin(angle)
    outer = torch.bmm(axis.unsqueeze(-1), axis.unsqueeze(-2))
    skew = torch.zeros(*aa.shape[:-1], 3, 3, device=aa.device)
    skew[..., 0, 1] = -axis[..., 2]; skew[..., 0, 2] =  axis[..., 1]
    skew[..., 1, 0] =  axis[..., 2]; skew[..., 1, 2] = -axis[..., 0]
    skew[..., 2, 0] = -axis[..., 1]; skew[..., 2, 1] =  axis[..., 0]
    return c.unsqueeze(-1) * torch.eye(3, device=aa.device) + (1-c.unsqueeze(-1)) * outer + s.unsqueeze(-1) * skew

# 1. Load motion & normalization statistics
tensors = load_file("data/sample_00000.safetensors")
stats = load_file("motion_stats.safetensors")

est_latent = tensors["SMPL_motion"]         # [T, 232], normalized
motion_mean = stats["motion_mean"]         # [232]
motion_std = stats["motion_std"]           # [232]

# Denormalize motion
est_motion = est_latent * motion_std + motion_mean
T = est_motion.shape[0]

# 2. Extract motion params
global_orient_aa = rot6d_to_axis_angle(est_motion[:, :6])           # [T, 3]
body_pose_6d     = est_motion[:, 6:6+(JOINT_NUM-1)*6].reshape(-1,6) # [T*23, 6]
body_pose_aa     = rot6d_to_axis_angle(body_pose_6d).reshape(-1, 3)
body_pose_mat    = axis_angle_to_mat3x3(body_pose_aa).reshape(T, JOINT_NUM-1, 3, 3)
transl           = est_motion[:, 6+(JOINT_NUM-1)*6:9+(JOINT_NUM-1)*6]  # [T, 3]
betas            = est_motion[:, -10:]                                  # [T, 10]

# 3. Apply coordinate system correction (MotionX -> SMPL/AMASS)
smplx_root = torch.tensor([[0.0031, -0.3514, 0.0120]])
R_inv = torch.tensor([[-1,0,0],[0,0,-1],[0,-1,0]], dtype=torch.float32).T
global_orient_mat = axis_angle_to_mat3x3(global_orient_aa)  # [T, 3, 3]
global_orient_mat = torch.bmm(R_inv.unsqueeze(0).expand(T,-1,-1), global_orient_mat)
transl = torch.bmm(R_inv.unsqueeze(0).expand(T,-1,-1),
                   (transl + smplx_root).unsqueeze(-1)).squeeze(-1) - smplx_root

# 4. Run SMPL forward pass
smpl_model = smplx.SMPLLayer(model_path=SMPL_PATH, gender='neutral', num_betas=10, batch_size=T)
output = smpl_model(
    global_orient=global_orient_mat.reshape(T, 1, 3, 3),
    body_pose=body_pose_mat,
    transl=transl,
    betas=betas
)
verts_seq = output.vertices.detach().numpy()  # [T, 6890, 3]
faces = smpl_model.faces
print(f"Vertices: {verts_seq.shape}")

# 5. Render with pyrender (upright, centered)
mesh_color = colorsys.hsv_to_rgb(0.6, 0.5, 1.0)
material = pyrender.MetallicRoughnessMaterial(metallicFactor=0.1, alphaMode='OPAQUE',
                                               baseColorFactor=mesh_color)
flip_rot = trimesh.transformations.rotation_matrix(np.radians(180), [1, 0, 0])
flip_mat = flip_rot[:3, :3]

H, W = 1280, 704
focal = float(np.sqrt(W**2 + H**2))
renderer = pyrender.OffscreenRenderer(viewport_width=W, viewport_height=H)

frames = []
for i in range(T):
    verts_f = (flip_mat @ verts_seq[i].T).T          # flip Y-up to screen Y-down
    centroid = (verts_f.min(0) + verts_f.max(0)) / 2
    depth = 3.5 + abs(centroid[2])

    scene = pyrender.Scene(bg_color=(0.12, 0.12, 0.18, 1.0), ambient_light=[0.3, 0.3, 0.3])
    cam_pose = np.eye(4)
    cam_pose[:3, 3] = [centroid[0], centroid[1], centroid[2] + depth]
    scene.add(pyrender.camera.IntrinsicsCamera(fx=focal, fy=focal, cx=W/2, cy=H/2), pose=cam_pose)
    scene.add(pyrender.DirectionalLight(color=[1,1,1], intensity=3.5), pose=cam_pose)

    mesh_t = trimesh.Trimesh(verts_f, faces)
    scene.add(pyrender.Mesh.from_trimesh(mesh_t, material=material))

    color, _ = renderer.render(scene, flags=pyrender.RenderFlags.RGBA)
    frames.append(cv2.cvtColor(color[:, :, :3], cv2.COLOR_RGB2BGR))

renderer.delete()

# 6. Save video
writer = cv2.VideoWriter("/tmp/smpl_render.mp4",
                         cv2.VideoWriter_fourcc(*'mp4v'), 24, (W, H))
for f in frames:
    writer.write(f)
writer.release()
print("Saved to /tmp/smpl_render.mp4")