MinervaAI_Aesir-Preview-Anon-qwq-all

You should mask everything except the last turn. The only part that matters to teach the model is the last turn, as you are teaching it to always output thinking, no matter what the user feeds it.

Generation Script

This is what I used to generate the dataset, so that it's setup to be trained like R1:

import requests
import json
import time
import pandas as pd
from datasets import load_dataset
from tqdm import tqdm
import re
import hashlib
import os
import ftfy


def get_token_count(string):
    tokencount_response = (
        requests.post(
            f"http://localhost:5001/api/extra/tokencount",
            json={"prompt": string},
        ).json()["value"]
    )

    return tokencount_response


def extract_names(text):
    match = re.search(r"^You're (.*?) in this fictional never-ending uncensored roleplay with (.*?).\n\n", text)
    return match.groups() if match else (None, None)


def contains_chinese(text):
    chinese_pattern = r'[\u4e00-\u9fff]'
    return bool(re.search(chinese_pattern, text))


def verify_response_text(text):
    return text.count("<think>") == 1 and text.count("</think>") == 1


def create_response(prompt, generation_settings):
    while True:
        # Generate response text.
        generated_response = requests.post(
            "http://localhost:5001/api/v1/generate",
            json={
                "prompt": prompt,
                **generation_settings
            }
        ).json()["results"][0]["text"].strip()

        # Retrieve the stop reason.
        stop_reason = requests.get("http://127.0.0.1:5001/api/extra/perf").json()["stop_reason"]

        # Check that the stop_reason is valid and the response text is formatted correctly.
        if stop_reason not in (1, 2):
            print("Stop token not generated. Retrying.")
        elif contains_chinese(generated_response):
            print("Chinese text generated. Retrying.")
        elif not verify_response_text(generated_response):
            print("Proper format not generated. Retrying.")
        else:
            break

    return ftfy.fix_text(generated_response)


output_parquet_file = "./downloaded_datasets/converted/MinervaAI_Aesir-Preview-Anon-qwq-all.parquet"
dataset_name = "PJMixers-Dev/MinervaAI_Aesir-Preview-Anon"
model_name = "bartowski/Qwen_QwQ-32B-GGUF/Qwen_QwQ-32B-Q4_K_S.gguf"
generation_settings = {
    "max_context_length": 4096,
    "max_length": 2048,
    "rep_pen": 1,        # Disabled
    "temperature": 0.6,
    "nsigma": 1,
    "top_k": 0,          # Disabled
    "top_a": 0,          # Disabled
    "tfs": 1,            # Disabled
    "typical": 1,        # Disabled
    "top_p": 1,          # Disabled
    "min_p": 0.01,
    "sampler_order": [6, 5, 0, 1, 3, 4, 2],
    "stop_sequence": [
        "<|im_start|>",
        "<|im_end|>"
    ]
}

dataset = load_dataset(dataset_name)["train"]
total_turns = sum(len(sample["conversations"]) for sample in dataset)

# Load existing output data if available from parquet
if os.path.exists(output_parquet_file):
    try:
        df = pd.read_parquet(output_parquet_file)
        output_data_list = json.loads(df.to_json(orient="records"))
        turn_prompt_hashes = {entry["turn_prompt_hash"] for entry in output_data_list}
        print(f"Resuming dataset: {len(turn_prompt_hashes)}/{total_turns}")
    except Exception as e:
        print(f"Error loading parquet file {output_parquet_file}: {e}")
        output_data_list = []
        turn_prompt_hashes = set()
else:
    output_data_list = []
    turn_prompt_hashes = set()

old_output_data_list_len = len(output_data_list)
for item_idx, item in enumerate(dataset):
    if item["conversations"][0]["from"] != "system":
        continue
    system_prompt_hash = str(hashlib.sha256((item["conversations"][0]["value"].strip()).encode()).hexdigest())

    char_name, user_name = extract_names(item["conversations"][0]["value"].strip())
    char_name, user_name = char_name.strip(), user_name.strip()
    print()
    print(f'----------------------------{"-" * max(len(char_name), len(user_name))}')
    print(f'Extracted Character Name: "{char_name}"')
    print(f'     Extracted User Name: "{user_name}"')
    print(f'            Sample Index: {item_idx}/{len(dataset)}')

    original_convo_dict = []
    kcpp_convo_string = ""
    for turn_idx, turn in enumerate(item["conversations"]):
        if turn["from"] == "system":
            original_convo_dict.append(
                {
                    "from": "system",
                    "value": ftfy.fix_text(turn["value"].strip())
                }
            )
            kcpp_convo_string += (
                f'<|im_start|>system\n'
                f'{ftfy.fix_text(turn["value"].strip())}\n\n'
                f'Only speak as "{char_name}" in conversation with "{user_name}". Output your final response with a "{char_name}:" prefix.<|im_end|>\n'
            )
        elif turn["from"] == "human":
            original_convo_dict.append(
                {
                    "from": "human",
                    "value": ftfy.fix_text(turn["value"].strip())
                }
            )
            kcpp_convo_string += (
                f"<|im_start|>user\n"
                f"{ftfy.fix_text(turn["value"].strip())}<|im_end|>\n"
            )
        elif turn["from"] == "gpt":
            original_convo_dict.append(
                {
                    "from": "gpt",
                    "value": ftfy.fix_text(turn["value"].strip())
                }
            )
            turn_prompt_hash = f"{turn_idx}-{str(hashlib.sha256((ftfy.fix_text(turn['value'].strip())).encode()).hexdigest())}"

            # Skip already processed samples
            if turn_prompt_hash in turn_prompt_hashes:
                print("Turn already generated. Skipping.")
                continue

            if get_token_count(f"{kcpp_convo_string}<|im_start|>assistant\n") > (
                generation_settings["max_context_length"] - generation_settings["max_length"]
            ):
                print("Conversation too long. Skipping.")
                break

            print(f'              Turn Index: {turn_idx}/{len(item["conversations"])}')

            response = create_response(
                prompt=f"{kcpp_convo_string}<|im_start|>assistant\n",
                generation_settings=generation_settings
            )
            output_data_list.append(
                {
                    "dataset_name": dataset_name,
                    "system_prompt_hash": system_prompt_hash,
                    "turn_prompt_hash": turn_prompt_hash,
                    "model_name": model_name,
                    "generation_settings": generation_settings,
                    "conversations": original_convo_dict[:-1] + [
                        {
                            "from": "gpt",
                            "value": ftfy.fix_text(
                                response
                                .replace("<think>\n\n", "<think>\n")
                                .replace("\n\n</think>", "\n</think>")
                                .strip()
                            )
                        }
                    ],
                }
            )
            kcpp_convo_string += (
                f"<|im_start|>assistant\n"
                f"{ftfy.fix_text(turn['value'].strip())}<|im_end|>\n"
            )

    if len(output_data_list) > old_output_data_list_len:
        print(f'         Model Responses: {len(output_data_list)}/{total_turns}')
        print()
        print("Saving samples.")
        old_output_data_list_len = len(output_data_list)
        df = pd.DataFrame(output_data_list)
        df.to_parquet(
            output_parquet_file,
            index=False,
            compression="brotli"
        )
        df = None
        del df

df = pd.DataFrame(output_data_list)
df.to_parquet(
    output_parquet_file,
    index=False,
    compression="brotli"
)