thealper2/dialogpt-small-dailydialog

microsoft/DialoGPT-small fine-tuned on OpenRL/daily_dialog for next-utterance generation in multi-turn open-domain dialogue.

Model details

Input format

Turns are concatenated and separated by the native <|endoftext|> token, which is also used as the padding token:

turn_1 <|endoftext|> turn_2 <|endoftext|> ... turn_k <|endoftext|> response <|endoftext|>

At inference time the prompt ends after the last <|endoftext|> and the model continues with the response. No custom special tokens were introduced, so the embedding matrix is identical in size to the base model's.

Training data

Each dialogue [u1, ..., un] is expanded into n-1 pairs (u1 -> u2, u1+u2 -> u3, ...), preserving chronological order. Empty utterances and dialogues shorter than two turns are dropped. Light detokenisation removes DailyDialog's spaced punctuation and split contractions. The official train/validation/test splits are used as published; the test split is not seen during training.

Training procedure

Loss: causal language-modelling cross-entropy computed on the response tokens only. Context positions and padding positions are set to -100, so the objective is P(response | dialogue_context) rather than plain LM over the whole sequence.

Evaluation

Measured on the held-out DailyDialog test split. Loss and perplexity are token-weighted over response tokens; BLEU/ROUGE/BERTScore are computed over 500 sampled generations against a single reference reply each.

Decoding used for the scored generations: sampling, temperature=0.80, top_k=50, top_p=0.90, repetition_penalty=1.10, max_new_tokens=64.

BLEU and ROUGE measure n-gram overlap with one reference continuation. Open-domain dialogue admits many valid replies, so these scores are weak indicators of conversational quality and are reported for comparability only.

Usage

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "thealper2/dialogpt-small-dailydialog"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)
model.eval()

history = ["Hello! How are you doing today?"]
prompt = "".join(turn + tokenizer.eos_token for turn in history)
inputs = tokenizer(prompt, return_tensors="pt")

with torch.no_grad():
    output = model.generate(
        **inputs,
        max_new_tokens=64,
        do_sample=True,
        temperature=0.80,
        top_k=50,
        top_p=0.90,
        repetition_penalty=1.10,
        no_repeat_ngram_size=3,
        pad_token_id=tokenizer.eos_token_id,
        eos_token_id=tokenizer.eos_token_id,
    )

reply = tokenizer.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(reply.strip())

For multi-turn use, append both the user message and the generated reply to history and rebuild the prompt. Keeping the last ~8 turns is enough for the 1024-token window.

Limitations

• Trained on 11k everyday English conversations; the domain is small talk, and the model has no grounding, retrieval or factual knowledge beyond GPT-2 pre-training.
• Greedy decoding degenerates into short, repetitive replies; sampling with repetition_penalty and no_repeat_ngram_size is recommended.
• No safety filtering or alignment tuning was applied, and biases from GPT-2 pre-training and from DailyDialog carry over.
• DailyDialog is licensed CC BY-NC-SA 4.0, so this fine-tuned checkpoint inherits the non-commercial restriction; the base model itself is MIT licensed.

Reproduction

make install
make train
make evaluate