How to Fine-Tune an LLM for AI Image Prompting

Name: Image Prompt Mastery
Creator: Rebiha

Writing structured, high-control prompts for AI image generation — camera/lens specification, lighting breakdown, composition, model-specific syntax, and negative constraints.

773 instruction-response pairs
Format JSONL
Pack AI Filmmaking
Dataset $39 one-time

Fine-tune a model on this dataset Preview Dataset

$39 for the dataset. Training is priced separately by model, starting at $47.

What can this kind of fine-tuning teach an LLM?

A general-purpose model may already know some of this subject. Fine-tuning serves a different purpose: it repeatedly demonstrates the kinds of requests, response patterns, terminology, decisions and workflows you want the model to handle more consistently.

For Image Prompt Mastery, the dataset focuses on writing structured, high-control prompts for ai image generation — camera/lens specification, lighting breakdown, composition, model-specific syntax, and negative constraints. Fine-tuning shapes recurring model behavior; it does not turn the model into a live database or guarantee correctness on every new case.

What training data should cover

Useful supervised fine-tuning data should resemble the work you expect the model to perform. This Rebiha dataset's domain definition is organized around 20 coverage areas:

writing a six-part image prompt anatomy: subject, medium, lighting, framing, mood, palette; adapting one concept's prompt across Midjourney V7's short-phrase style vs Stable Diffusion's weighted-keyword style; writing specific, concrete negative prompts instead of vague terms like 'bad quality'; using weighted token syntax like (term:1.3) correctly in diffusion-based models; writing prompts for autoregressive image models where seed and weight syntax don't apply
using an uploaded reference image to anchor a subject's exact likeness instead of describing it in words; breaking down lighting by source — key, fill, rim, ambient — within a single prompt; creating foreground, midground, and background separation through prompt language; using ControlNet-style pose or depth conditioning language to control structure independent of style; troubleshooting a prompt that keeps producing distorted hands or faces
writing a prompt that matches an established visual style across multiple separate generations; choosing aspect ratio and framing language for a specific use case like a poster, hero shot, or social post; writing prompts that avoid common AI-image artifacts like waxy skin, plastic texture, or extra fingers; iterating a weak, vague prompt into a strong, specific one through targeted additions; writing prompts for images that require readable embedded typography
writing a prompt for a commercial use case like a product shot or brand hero image; combining a written prompt with an uploaded reference image for hybrid conditioning; explaining when a subjective descriptor will cause a model to drift and how to make it concrete instead; writing prompts that lock in material realism for fabric, metal, skin, or glass; explaining guidance strength (CFG scale) and how it changes how closely output follows the prompt

How Rebiha prepared the training material

This page contains 773 instruction-response pairs from the existing Rebiha dataset. Its domain definition was designed around the coverage areas above so the training material spans multiple realistic tasks rather than one narrow prompt pattern.

Rebiha's broader dataset workflow uses structured quality review to help identify problems such as contradictions, unsupported claims, unsupported assumptions, calculation errors and other weak training examples. You can inspect real examples on this page before deciding whether the dataset fits your model and use case.

What is in this dataset

773 instruction-response pairs covering writing structured, high-control prompts for ai image generation — camera/lens specification, lighting breakdown, composition, model-specific syntax, and negative constraints. Each pair is a realistic instruction with a full written response, in the JSONL format used for supervised fine-tuning. No synthetic filler, no duplicated rows.

Example pairs

Real rows from the dataset, shown in full.

I'm new to structured prompting for AI image generation. Can you walk me through the six-part anatomy of a strong image prompt, with an example that shows each part clearly?

Think of a prompt as six deliberate control layers. Without structure, the model improvises; with it, you get predictable, editable results. Here's the anatomy and a concrete example that uses all six parts. 1. **Subject** — the main entity, described with enough specificity to anchor identity (species, pose, clothing, action). 2. **Medium** — the artistic or photographic material (oil painting, 35mm film, 3D render, watercolor). 3. **Lighting** — direction, quality, and color temperature (hard rim light, soft overcast, golden hour). 4. **Framing** — camera distance, angle, and lens effect (extreme close-up, low angle, wide 24mm). 5. **Mood** — emotional tone conveyed through atmosphere and expression (melancholic, triumphant, eerie calm). 6. **Palette** — dominant colors or a color scheme (muted teal and rust, high-contrast monochrome). Here is a complete, realistic example prompt that exercises all six: "A weary deep-sea salvage diver kneeling on a rusted ship deck, holding a broken brass chronometer (subject); shot on Kodak Portra 400, 35mm film photograph (medium); single hard tungsten key light from the left with cold blue fill from the ocean mist (lighting); medium shot, eye-level, shot on a 50mm lens at f/2.8 with shallow depth of field (framing); somber, contemplative isolation (mood); desaturated navy, oxidized copper, and bone-white palette (palette)." Write your own prompts in this order. If you drop a part, the model fills it with its own default — usually the weakest choice. Keep each part to a short phrase; don't chain adjectives within a single slot.

I have a concept — a lone robot repairing a neon sign in a rainy alley at night. How should I write this differently for Midjourney V7 versus Stable Diffusion 3.5? What changes about my phrasing strategy?

Midjourney V7 and Stable Diffusion 3.5 treat language very differently. Midjourney is a natural-language, short-phrase model — it prefers a dense, coherent sentence of 10–20 words, and it penalizes keyword dumping. Stable Diffusion is a CLIP-based diffusion model that responds best to explicit, comma-separated keyword lists, because each token is a weighted lever. **For Midjourney V7** — write one flowing, grammatically complete sentence with descriptive clauses. Avoid commas piling up; use 'and' or implicit association. Example: "/imagine A weathered service robot on a ladder adjusting a flickering magenta neon sign in a narrow rain-slicked alley at night, cinematic reflections on wet asphalt, moody cyberpunk atmosphere" Notice the prompt flows as a story of the scene, with the mood and palette implied within the sentence. **For Stable Diffusion 3.5** — break the same concept into weighted keyword groups, separated by commas, with the most important elements first. Example: "lone robot repairing neon sign, rainy alley at night, wet asphalt reflections, magenta and cyan neon glow, cinematic lighting, ultra-detailed, 8k, street photography style, dramatic shadows" In SD3.5, leading keywords like 'lone robot' and 'neon sign' dominate the composition. In Midjourney, the model parses the sentence's grammatical structure to decide importance. Also, Midjourney V7 tends to ignore extra style tags like '8k' or 'ultra-detailed' — they dilute meaning. SD3.5 responds to those as texture boosters. So for a single concept, write two versions — one for each model — rather than reusing the same string.

I keep writing negative prompts like 'bad quality, ugly, deformed, lowres' but my images still look off. How do I write specific, concrete negatives that actually change the output?

Vague negatives like 'bad quality' or 'ugly' are useless because the model doesn't know what those words mean as visual constraints — they're evaluative, not descriptive. You need to name the specific artifact you want to suppress. Write negatives as concrete, observable visual features. Here's a bad negative prompt: "bad quality, ugly, deformed, lowres" The model ignores this because 'ugly' has no visual anchor. Here's a specific negative prompt for a portrait: "extra fingers, six fingers, fused fingers, elongated neck, asymmetrical eyes, distorted face, blurry skin texture, oversaturated colors, harsh flat lighting, cluttered background, text, watermark" Each item is a single, detectable defect. For a landscape, you'd write: "blurry mountains, oversharpened edges, chromatic aberration, lens flare, overcast gray sky, wrong season foliage, power lines, road signs, watermark" Also, pair negatives with positives. If you don't want 'low contrast,' write 'high contrast' in the positive prompt. The model works harder to satisfy a positive than to avoid a negative. A good rule: for every negative you write, ask 'can I visually verify this in the image?' If you can't point to it in a photo, it's too vague. Replace 'bad anatomy' with 'extra limbs, missing ear, asymmetrical pupils.' Replace 'lowres' with 'pixelated edges, blurry details.' The more objects and geometric features you name, the better the sampler avoids them.

Who this is for

Builders who want their fine-tuned model to reliably perform this specific capability, as part of a broader assistant or agent.

Which models this works with

The dataset is plain JSONL, so it works with any instruction-tuned open model. On Rebiha you can train it directly on:

Qwen — Qwen3.8, Qwen3.6, Qwen3.5, Qwen3, Qwen2.5, Qwen2.5-Coder
Granite — Granite 4.1 (3B, 8B, 30B)
OLMo — OLMo 3, OLMo 3.1
GLM — GLM-4
Gemma, Phi, DeepSeek, Mistral, and Llama families

Training uses LoRA, or QLoRA on a 4-bit base for larger models. Your base model's weights are never modified — training produces a separate adapter.

How it works

Pick this dataset and a base model.
Rebiha runs the job on a managed GPU. You set up nothing.
Download your model: a ready-to-run GGUF, plus developer assets (adapter, tokenizer, configs).

Fine-tuning or RAG?

Use RAG when the model needs facts that change — your prices, your documents, today's inventory. Use fine-tuning when you want consistent behavior and structure without prompting for it every time. This dataset teaches the shape of this capability, not facts to look up.

How managed fine-tuning works

Inspect the dataset examples and choose a compatible base model.
Rebiha runs the training job on managed GPU infrastructure using LoRA or QLoRA as appropriate.
Download portable model assets for your own workflow, including the available ready-to-run and developer outputs for the selected training path.

Fine-tuning or RAG?

Use fine-tuning when the objective is recurring behavior: response structure, domain patterns, terminology, workflow, or how the model approaches a class of requests. Use RAG when answers depend on changing or proprietary facts that should be retrieved at request time. The two approaches can also work together.

Know what goes in. Own what comes out.

You can inspect real examples before training, choose the model you want to adapt, and keep portable model assets when training is complete.

Related datasets

General Instruction Following — 978 pairs
Multi-Turn Conversation — 466 pairs
Rewriting & Editing — 854 pairs
Summarization — 781 pairs

Start fine-tuning