cozmo-emotion-sft

Cozmo dialogue emotion classifier (SFT)

Supervised fine-tuned (SFT) emotion classifier for human–robot dialogue turns. Predicts one of 6 emotion classes from a paired utterance:

HUMAN: {human_text}
ROBOT: {robot_text}

This repo is the base classifier used by the GRPO LoRA adapter: annamanaseryan/cozmo-emotion-grpo.

Architecture

• Encoder: microsoft/deberta-v3-base
• Head: mean pooling over token embeddings → dropout → linear (6-way)
• Custom module: see modeling_emotion.py (EmotionClassifier)

Not a drop-in AutoModelForSequenceClassification checkpoint. Load with the provided class + best_model.bin.

Labels (class index → description)

Full names are in emotion_labels.yaml.

Files

Install

pip install torch transformers pyyaml huggingface_hub

Usage (SFT only)

import torch
import yaml
from huggingface_hub import hf_hub_download, snapshot_download
from transformers import AutoTokenizer
from modeling_emotion import EmotionClassifier  # download this file from the repo

REPO = "annamanaseryan/cozmo-emotion-sft"
device = "cuda" if torch.cuda.is_available() else "cpu"

# Prefer downloading the whole repo once, then import modeling_emotion from that folder
local = snapshot_download(REPO)
import sys
sys.path.insert(0, local)
from modeling_emotion import EmotionClassifier

with open(f"{local}/emotion_labels.yaml") as f:
    cfg = yaml.safe_load(f)
id2desc = {int(i): d["description"] for i, d in cfg["emotions"].items()}

tokenizer = AutoTokenizer.from_pretrained(local)
model = EmotionClassifier(n_classes=6, model_name="microsoft/deberta-v3-base")
state = torch.load(f"{local}/best_model.bin", map_location="cpu")
model.load_state_dict(state)
model.to(device).eval()

def predict(human: str, robot: str, max_length: int = 256):
    text = f"HUMAN: {human}\nROBOT: {robot}"
    inputs = tokenizer(
        text,
        return_tensors="pt",
        max_length=max_length,
        padding="max_length",
        truncation=True,
    ).to(device)
    with torch.no_grad():
        logits = model(**inputs)
        probs = torch.softmax(logits, dim=-1).cpu().squeeze()
    return {id2desc[i]: float(probs[i]) for i in range(len(probs))}

print(predict("Why is the sky blue?", "because of the light."))

For GRPO (SFT + LoRA)

See the companion adapter repo and inference_example.py there.