README.md

---
license: apache-2.0
datasets:
- Minthy/Anime-Art-Multicaptions-v5.0
base_model:
- MuXodious/Qwen3.5-4B-SOMPOA-heresy-v2
tags:
- anime
- prompt
- qwen
---
# Slop Prompt v5

A fine-tuned **Qwen3.5 4B** model for enhancing AI image-generation prompts. It was trained on a multi-format anime-art caption dataset and supports 11 conversion directions between Danbooru tags, short phrases, long descriptive paragraphs, and structured JSON.

## Model variants

| File / folder | Format | Size | Use case |
|---|---|---|---|
| `SlopPrompt-v5/` | Hugging Face Transformers (BF16 `safetensors`, vision-capable) | ~8.9 GB | Python / Transformers / vLLM / TGI / multimodal loaders |
| `SlopPrompt-v5-BF16.gguf` | llama.cpp GGUF BF16 | ~9.7 GB | Maximum-quality local text inference |
| `SlopPrompt-v5-Q8_0.gguf` | llama.cpp GGUF Q8_0 | ~5.1 GB | Fast, memory-efficient local text inference |

Base model: [`MuXodious/Qwen3.5-4B-SOMPOA-heresy-v2`](https://huggingface.co/MuXodious/Qwen3.5-4B-SOMPOA-heresy-v2)

## Dataset credit

Training data derived from **Anime Art Multicaptions v5.0** by Minthy  
https://huggingface.co/datasets/Minthy/Anime-Art-Multicaptions-v5.0

All examples were anonymized: character, artist, source, and copyright names were removed from inputs and targets.

## What the model can do

The model was trained on 11 prompt-conversion modes. Each mode has its own system-prompt instructions. Use the exact system prompt for the direction you want.

| # | Mode | Description |
|---|---|---|
| 1 | `tags -> long` | Danbooru tags → detailed descriptive paragraph |
| 2 | `tags -> short` | Danbooru tags → one short natural-language phrase |
| 3 | `tags -> json` | Danbooru tags → structured JSON |
| 4 | `tags_hallucination -> long` | Incomplete tag list → reconstructed detailed paragraph |
| 5 | `tags_hallucination -> short` | Incomplete tag list → reconstructed short phrase |
| 6 | `tags_hallucination -> json` | Incomplete tag list → reconstructed JSON |
| 7 | `long -> json` | Descriptive paragraph → JSON |
| 8 | `json -> long` | JSON → detailed descriptive paragraph |
| 9 | `long -> short` | Paragraph → short phrase |
| 10 | `json -> short` | JSON → short phrase |
| 11 | `short -> long` | Short phrase → detailed paragraph |

### Training system prompts

Use these as the `system` message for each mode.

```text
Base system prefix (prepended to every mode):
You are a prompt enhancer for AI image generation. Do not include real names of characters, artists, sources, or copyrights in your output. Use generic descriptions instead.
```

| Mode | System instruction appended to the base prefix |
|---|---|
| `tags -> long` | You are given a list of Danbooru tags describing an image. Write a detailed, descriptive paragraph that captures the full scene, characters, clothing, pose, and atmosphere. |
| `tags -> short` | You are given a list of Danbooru tags describing an image. Write a single short natural-language phrase that summarizes the image. |
| `tags -> json` | You are given a list of Danbooru tags describing an image. Convert them into the structured JSON format shown in the reference. |
| `tags_hallucination -> long` | You are given a partial, incomplete list of Danbooru tags. Reconstruct and enhance the missing details, then write a detailed, descriptive paragraph. |
| `tags_hallucination -> short` | You are given a partial, incomplete list of Danbooru tags. Reconstruct the scene and write a single short natural-language phrase. |
| `tags_hallucination -> json` | You are given a partial, incomplete list of Danbooru tags. Reconstruct the missing details and format the result as the structured JSON shown in the reference. |
| `long -> json` | You are given a descriptive paragraph about an image. Convert it into the structured JSON format shown in the reference. |
| `json -> long` | You are given a structured JSON description of an image. Write it out as a detailed, descriptive paragraph. |
| `long -> short` | You are given a descriptive paragraph about an image. Summarize it into a single short natural-language phrase. |
| `json -> short` | You are given a structured JSON description of an image. Summarize it into a single short natural-language phrase. |
| `short -> long` | You are given a short phrase describing an image. Expand it into a detailed, descriptive paragraph. |

## What to expect

- **Strong on the 11 trained directions.** It follows the system prompt, produces fluent English, and keeps outputs free of real names.
- **Cross-language input is understood.** You can write the user message in French, Spanish, etc., and it will usually answer in English as instructed.
- **Hallucination mode invents plausible missing details** from an incomplete tag list.
- **JSON outputs are generally valid** and include keys such as `character`, `background`, `texts`, and `atmosphere`.
- **Output length:** By default it writes one or two paragraphs (~150–250 words) and then stops. For longer outputs, force a minimum token count (see parameters below).
- **Reverse tag extraction (`description -> tags`) was not trained.** If you ask for that, it will usually return short sentences instead of Danbooru tags.

## Vision support

The base model is a multimodal Qwen3.5 checkpoint, and the published Hugging Face folder still contains the original vision encoder weights. You can load it with:

```python
from transformers import AutoModelForImageTextToText, AutoTokenizer

model = AutoModelForImageTextToText.from_pretrained(
    "SlopPrompt-v5",
    trust_remote_code=True,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained("SlopPrompt-v5", trust_remote_code=True)
```

The vision backbone is unchanged from the base model. You can pass images through it, but the model was not specifically fine-tuned for vision-to-prompt tasks.

The GGUF releases are text-only.

## Recommended generation parameters

These settings work well for most modes.

```python
max_new_tokens = 512
temperature = 0.7
top_p = 0.9
repetition_penalty = 1.05
no_repeat_ngram_size = 5
```

For **deterministic** output, set `do_sample=False`.

For **longer** output, set:

```python
min_new_tokens = 400
max_new_tokens = 1536
repetition_penalty = 1.01
no_repeat_ngram_size = 2
```

The model will then produce ~300–400 words before stopping.

## Usage with Hugging Face Transformers

```python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_path = "SlopPrompt-v5"
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    trust_remote_code=True,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)

system = (
    "You are a prompt enhancer for AI image generation. "
    "Do not include real names of characters, artists, sources, or copyrights in your output. "
    "Use generic descriptions instead.\n\n"
    "You are given a partial, incomplete list of Danbooru tags. "
    "Reconstruct and enhance the missing details, then write a detailed, descriptive paragraph."
)
messages = [
    {"role": "system", "content": system},
    {"role": "user", "content": "1girl, loli, at park, night, sitting on bench, dress"},
]

prompt = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=False,  # important for clean output
)
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

outputs = model.generate(
    **inputs,
    max_new_tokens=512,
    temperature=0.7,
    top_p=0.9,
    repetition_penalty=1.05,
    no_repeat_ngram_size=5,
    eos_token_id=tokenizer.eos_token_id,
    pad_token_id=tokenizer.pad_token_id,
)
response = tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(response)
```

## Usage with llama.cpp (GGUF)

The GGUF was verified with a current llama.cpp build. Run it in single-turn mode with reasoning disabled.

```bash
PROMPT='<|im_start|>system
You are a prompt enhancer for AI image generation. Do not include real names of characters, artists, sources, or copyrights in your output. Use generic descriptions instead.

You are given a partial, incomplete list of Danbooru tags. Reconstruct and enhance the missing details, then write a detailed, descriptive paragraph.
<|im_end|>
<|im_start|>user
1girl, loli, at park, night, sitting on bench, dress
<|im_end|>
<|im_start|>assistant
'

llama-cli \
  -m SlopPrompt-v5-Q8_0.gguf \
  -p "$PROMPT" \
  -n 512 \
  -t 16 \
  -ngl 99 \
  --temp 0.7 \
  --top-p 0.9 \
  --repeat-penalty 1.05 \
  --no-display-prompt \
  --no-conversation \
  --single-turn \
  --reasoning off
```

On an RTX-class GPU expect ~200+ tokens/s for Q8_0 and ~150 tokens/s for BF16.

## File layout

```
publish/
├── README.md
├── SlopPrompt-v5/                 # HF Transformers BF16 safetensors (text + vision)
│   ├── config.json
│   ├── generation_config.json
│   ├── chat_template.jinja
│   ├── tokenizer_config.json
│   ├── tokenizer.json
│   └── model.safetensors
├── SlopPrompt-v5-BF16.gguf        # llama.cpp BF16
└── SlopPrompt-v5-Q8_0.gguf        # llama.cpp Q8_0
```

## Limitations

- Trained on English anime-art captions. Other languages may work as input but output is expected to be English.
- Does not reliably perform reverse extraction such as `long -> tags` because that mode was not in the training set.
- May hallucinate extra details in reconstruction/hallucination modes; use a lower temperature or greedy decoding for more conservative outputs.

## Disclaimer

This model generates text based on patterns learned from training data. The authors provide **no guarantees** about accuracy, safety, appropriateness, or fitness for any particular purpose. Outputs may be unexpected, inaccurate, or inconsistent with the provided system prompt. Review and filter outputs before using them in production or for downstream image generation.

## Credits & license

- Base model: [`MuXodious/Qwen3.5-4B-SOMPOA-heresy-v2`](https://huggingface.co/MuXodious/Qwen3.5-4B-SOMPOA-heresy-v2)
- Dataset: [`Minthy/Anime-Art-Multicaptions-v5.0`](https://huggingface.co/datasets/Minthy/Anime-Art-Multicaptions-v5.0)
- Released under the terms of the base model and dataset licenses.