How to Train an LLM on Cloud GPU: Step-by-Step Python Guide 2026
QLoRA fine-tuning with HuggingFace Transformers and EU compute

# Create a virtual environment
python -m venv llm-env
source llm-env/bin/activate  # Linux/macOS
# llm-env\Scripts\activate  # Windows

# Install dependencies
pip install transformers==4.40.0 \
            datasets==2.19.0 \
            peft==0.10.0 \
            bitsandbytes==0.43.0 \
            accelerate==0.29.0 \
            trl==0.8.6 \
            ghostnexus>=0.5.0

# dataset_prep.py
from datasets import Dataset
import json

# Load your data (JSONL format)
# Each line: {"instruction": "...", "input": "...", "output": "..."}
def load_dataset_from_jsonl(path: str) -> Dataset:
    records = []
    with open(path) as f:
        for line in f:
            records.append(json.loads(line.strip()))
    return Dataset.from_list(records)

def format_alpaca(example: dict) -> dict:
    """Format as instruction-following prompt."""
    if example.get("input"):
        prompt = (
            f"### Instruction:\n{example['instruction']}\n\n"
            f"### Input:\n{example['input']}\n\n"
            f"### Response:\n{example['output']}"
        )
    else:
        prompt = (
            f"### Instruction:\n{example['instruction']}\n\n"
            f"### Response:\n{example['output']}"
        )
    return {"text": prompt}

dataset = load_dataset_from_jsonl("data/train.jsonl")
dataset = dataset.map(format_alpaca)
dataset.save_to_disk("data/formatted")
print(f"Dataset ready: {len(dataset)} examples")

# train.py — QLoRA fine-tuning with HuggingFace
import torch
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    TrainingArguments,
)
from datasets import load_from_disk
from peft import LoraConfig, get_peft_model, TaskType
from trl import SFTTrainer

# ── Configuration ──────────────────────────────────────────────
BASE_MODEL = "mistralai/Mistral-7B-v0.3"    # or meta-llama/Meta-Llama-3-8B
OUTPUT_DIR = "/tmp/output"
DATASET_PATH = "/tmp/data/formatted"

QLORA_CONFIG = LoraConfig(
    r=16,                    # rank — higher = more params, better quality
    lora_alpha=32,           # scaling factor
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM,
)

BNB_CONFIG = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

TRAINING_ARGS = TrainingArguments(
    output_dir=OUTPUT_DIR,
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,      # effective batch = 16
    learning_rate=2e-4,
    fp16=False,
    bf16=True,                           # A100/H100 — use bf16
    logging_steps=25,
    save_steps=200,
    warmup_ratio=0.03,
    lr_scheduler_type="cosine",
    report_to="none",
)

# ── Load model and tokenizer ────────────────────────────────────
tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"

model = AutoModelForCausalLM.from_pretrained(
    BASE_MODEL,
    quantization_config=BNB_CONFIG,
    device_map="auto",
    trust_remote_code=True,
)
model.config.use_cache = False
model = get_peft_model(model, QLORA_CONFIG)
model.print_trainable_parameters()

# ── Train ───────────────────────────────────────────────────────
dataset = load_from_disk(DATASET_PATH)

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    tokenizer=tokenizer,
    args=TRAINING_ARGS,
    packing=False,
)

trainer.train()
trainer.model.save_pretrained(OUTPUT_DIR)
tokenizer.save_pretrained(OUTPUT_DIR)
print("Training complete. Model saved to", OUTPUT_DIR)

# submit_job.py
import ghostnexus as gn

# Authenticate (set GHOSTNEXUS_API_KEY env var or pass api_key=)
gn.configure(api_key="your_api_key_here")

job = gn.Job(
    script="train.py",
    files={
        "data/formatted": "./local_data/formatted",   # upload dataset
    },
    gpu="a100-80gb",          # or "rtx-4090", "h100-sxm"
    region="eu-west",         # GDPR-compliant EU routing
    timeout_hours=4,
    env={
        "HF_TOKEN": "hf_...",          # HuggingFace token for model download
        "TRANSFORMERS_CACHE": "/tmp/hf_cache",
    },
    result_paths=["/tmp/output"],      # download on completion
)

print(f"Job submitted: ${job.id}")
print(f"Estimated cost: ${job.estimated_cost_usd}")

# Wait and stream logs
for log_line in job.stream_logs():
    print(log_line, end="")

# Download results
job.download_results("./local_output")
print(f"Final cost: ${job.cost_usd}")
print(f"Audit log: ${job.audit_log_url}")   # AI Act compliance record

# merge_and_export.py
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
import torch

BASE_MODEL = "mistralai/Mistral-7B-v0.3"
ADAPTER_PATH = "./local_output"
MERGED_OUTPUT = "./merged_model"

print("Loading base model...")
base_model = AutoModelForCausalLM.from_pretrained(
    BASE_MODEL,
    torch_dtype=torch.float16,
    device_map="cpu",
)

print("Loading adapters and merging...")
model = PeftModel.from_pretrained(base_model, ADAPTER_PATH)
model = model.merge_and_unload()

print("Saving merged model...")
model.save_pretrained(MERGED_OUTPUT)
AutoTokenizer.from_pretrained(ADAPTER_PATH).save_pretrained(MERGED_OUTPUT)
print("Done. Merged model at:", MERGED_OUTPUT)