PJMixers-Dev/Fundus-105K-Formatted-Qwen2.5-Coder-7B-Instruct-Classified

Your primary purpose is classifying text. There are multiple options to choose from: "News", "Review", "Opinion", "Advertising", and "Other".

"News" means the text is reporting on current events in a factual and objective manner. Basically, it's a news article.
"Review" means the text evaluates or critiques a product, service, or creative work.
"Opinion" means the text presents a personal viewpoint or argument on a topic.
"Advertising" means the text is designed to promote or sell a product, service, or idea.
"Other" means the text is random, irrelevant, nonsensical, spam, a how-to, a quiz, a guide, or any information that does not fit into the other categories.

You must reply with a few sentences analyzing the input text on the first line, followed by the classification on the second line (without quotes). Do not provide any other text.

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


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 verify_response_text(text):
    """
    Verifies that the provided text (after stripping) has exactly two nonempty lines,
    and that the second line is either "news" or "junk" (case-insensitive).
    """
    # Strip the text and split into lines, filtering out any empty lines.
    lines = [line.strip() for line in text.strip().splitlines() if line.strip()]

    # Must have exactly 2 nonempty lines.
    if len(lines) != 2:
        return False

    first_line, second_line = lines

    if first_line.strip().endswith(":"):
        return False

    if second_line.lower().replace("classification:", "").replace("\"", "").replace("'", "").strip() in {
        "news", "review", "opinion", "advertising", "other", "how-to"
    }:
        return True
    else:
        print(f"Bad Classification: {second_line.lower().strip()}")
        return False


def create_response(message_log, generation_settings):
    """
    Continuously requests a generation until the response satisfies:
      - The stop reason is either 1 or 2, and
      - The response text consists of exactly 2 nonempty lines with a valid second line.
    Returns the first line (as-is) and the second line in lowercase.
    """
    while True:
        # Generate response text.
        generation_response = requests.post(
            "http://localhost:5001/api/v1/generate",
            json={
                "prompt": message_log,
                **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 not verify_response_text(generation_response):
            print("Proper format not generated. Retrying.")
        else:
            break

    # Use the filtered lines from the verified response.
    lines = [line.strip() for line in generation_response.splitlines() if line.strip()]
    first_line = lines[0].strip()
    second_line = lines[1].lower().replace("classification:", "").replace("\"", "").replace("'", "").strip()

    return first_line, second_line



system_prompt = (
    "Your primary purpose is classifying text. There are multiple options to choose from: \"News\", \"Review\", \"Opinion\", \"Advertising\", and \"Other\".\n\n"
    "\"News\" means the text is reporting on current events in a factual and objective manner. Basically, it's a news article.\n"
    "\"Review\" means the text evaluates or critiques a product, service, or creative work.\n"
    "\"Opinion\" means the text presents a personal viewpoint or argument on a topic.\n"
    "\"Advertising\" means the text is designed to promote or sell a product, service, or idea.\n"
    "\"Other\" means the text is random, irrelevant, nonsensical, spam, a how-to, a quiz, a guide, or any information that does not fit into the other categories.\n\n"
    "You must reply with a few sentences analyzing the input text on the first line, followed by the classification on the second line (without quotes). Do not provide any other text."
)
model_name = "bartowski/Qwen2.5-Coder-7B-Instruct-GGUF/Qwen2.5-Coder-7B-Instruct-Q6_K.gguf"
original_dataset_name = "PJMixers-Dev/Fundus-105K-Formatted"
generation_settings = {
    "max_context_length": 16384,
    "max_length": 512,
    "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|>"
    ]
}

output_parquet_file = (
    "./downloaded_datasets/converted/PJMixers-Dev_Fundus-105K-Formatted-Qwen2.5-Coder-7B-Instruct-Classified.parquet"
)

dataset = load_dataset(original_dataset_name)["train"]

classifications = {
    "news": 0,
    "review": 0,
    "opinion": 0,
    "advertising": 0,
    "other": 0
}

# Load existing output data if available from parquet
# TODO: Load classification counts
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"))
        processed_hashes = {entry["prompt_hash"] for entry in output_data_list}
        for sample in output_data_list:
            classifications[sample["classification"]] += 1
        print(f"Resuming dataset: {len(processed_hashes)}/{len(dataset)}")
    except Exception as e:
        print(f"Error loading parquet file {output_parquet_file}: {e}")
        output_data_list = []
        processed_hashes = set()
else:
    output_data_list = []
    processed_hashes = set()

for sample in tqdm(dataset):
    prompt = (
        f"<|im_start|>system\n"
        f"{system_prompt}<|im_end|>\n"
        f"<|im_start|>user\n"
        f"{'Text Tags: ' + (str(sample['topics']) + '\n\n') if sample['topics'] else ''}"
        f"```md\n"
        f"{sample['text'].strip()}\n"
        f"```<|im_end|>\n"
        f"<|im_start|>assistant\n"
    )
    prompt_hash = str(hashlib.sha256(prompt.encode()).hexdigest())

    # Skip already processed samples
    if prompt_hash in processed_hashes:
        continue

    if get_token_count(prompt) > generation_settings["max_context_length"] - generation_settings["max_length"]:
        print("Too long. Skipping")
        continue

    analysis, classification = create_response(
        prompt,
        generation_settings
    )

    if classification == "how-to":
        classification = "other"

    classifications[classification] += 1

    max_len_classifications = max(len(str(v)) for v in classifications.values())
    print(
        f"|-------------|{'-' * (max_len_classifications + 2)}|---------|\n"
        f"| News        | {classifications['news']:>{max_len_classifications}} | {((classifications['news'] / sum(classifications.values())) * 100):>6.2f}% |\n"
        f"| Review      | {classifications['review']:>{max_len_classifications}} | {((classifications['review'] / sum(classifications.values())) * 100):>6.2f}% |\n"
        f"| Opinion     | {classifications['opinion']:>{max_len_classifications}} | {((classifications['opinion'] / sum(classifications.values())) * 100):>6.2f}% |\n"
        f"| Advertising | {classifications['advertising']:>{max_len_classifications}} | {((classifications['advertising'] / sum(classifications.values())) * 100):>6.2f}% |\n"
        f"| Other       | {classifications['other']:>{max_len_classifications}} | {((classifications['other'] / sum(classifications.values())) * 100):>6.2f}% |\n"
        f"|-------------|{"-" * len(f" {classifications['news']} ")}|---------|"
    )

    output_data_list.append(
        {
            "prompt_hash": prompt_hash,
            "original_dataset_name": original_dataset_name,
            "model_name": model_name,
            "generation_settings": generation_settings,
            "analysis": analysis,
            "classification": classification,
            "topics": sample["topics"],
            "text": sample["text"]
        }
    )

    if len(output_data_list) != 0 and len(output_data_list) % 100 == 0:
        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"
)