# Jupyter ML Training

Richten Sie JupyterLab mit GPU-Unterstützung für Machine-Learning-Experimente und Modelltraining ein.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Serveranforderungen

| Parameter | Minimum     | Empfohlen |
| --------- | ----------- | --------- |
| RAM       | 16GB        | 32GB+     |
| VRAM      | 8GB         | 16GB+     |
| Netzwerk  | 200Mbps     | 500Mbps+  |
| Startzeit | 2-3 Minuten | -         |

{% hint style="info" %}
JupyterLab selbst ist schlank. Wählen Sie GPU und RAM basierend auf den Anforderungen Ihrer Trainings-Workloads.
{% endhint %}

## Schnelle Bereitstellung

**Docker-Image:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime
```

**Ports:**

```
22/tcp
8888/http
6006/http
```

**Umgebung:**

```
JUPYTER_TOKEN=Ihr_sicherer_token_hier
```

**Befehl:**

```bash
pip install jupyterlab tensorboard && \
jupyter lab --ip=0.0.0.0 --port=8888 --allow-root --NotebookApp.token='Ihr_sicherer_token_hier'
```

## Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre `http_pub` URL in **Meine Bestellungen**:

1. Gehen Sie zur **Meine Bestellungen** Seite
2. Klicken Sie auf Ihre Bestellung
3. Finden Sie die `http_pub` URL (z. B., `abc123.clorecloud.net`)

Verwenden Sie `https://IHRE_HTTP_PUB_URL` anstelle von `localhost` in den Beispielen unten.

### Überprüfen, ob es funktioniert

```bash
# Überprüfen, ob JupyterLab erreichbar ist
curl https://your-http-pub.clorecloud.net/

# Zugriff mit Token
# https://your-http-pub.clorecloud.net/?token=Ihr_sicherer_token_hier
```

{% hint style="warning" %}
Wenn Sie HTTP 502 erhalten, warten Sie 2-3 Minuten - der Dienst installiert Abhängigkeiten.
{% endhint %}

## Mieten auf CLORE.AI

1. Besuchen Sie [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Nach GPU-Typ, VRAM und Preis filtern
3. Wählen **On-Demand** (Festpreis) oder **Spot** (Gebotspreis)
4. Konfigurieren Sie Ihre Bestellung:
   * Docker-Image auswählen
   * Ports festlegen (TCP für SSH, HTTP für Web-UIs)
   * Umgebungsvariablen bei Bedarf hinzufügen
   * Startbefehl eingeben
5. Zahlung auswählen: **CLORE**, **BTC**, oder **USDT/USDC**
6. Bestellung erstellen und auf Bereitstellung warten

### Zugriff auf Ihren Server

* Verbindungsdetails finden Sie in **Meine Bestellungen**
* Webschnittstellen: Verwenden Sie die HTTP-Port-URL
* SSH: `ssh -p <port> root@<proxy-address>`

## Zugriff auf Jupyter

1. Warten Sie auf die Bereitstellung
2. Finden Sie die Port-Mapping für 8888
3. Öffnen: `http://<proxy>:<port>?token=Ihr_sicherer_token_hier`

## Vorkonfiguriertes ML-Image

Für vollständige ML-Umgebung:

**Image:**

```
jupyter/pytorch-notebook:cuda12-pytorch-2.1.0
```

Oder bauen Sie individuell:

```dockerfile
FROM pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime

RUN pip install --no-cache-dir \
    jupyterlab \
    numpy pandas matplotlib seaborn \
    scikit-learn \
    transformers datasets accelerate \
    tensorboard wandb \
    opencv-python pillow \
    tqdm rich

EXPOSE 8888 6006

CMD ["jupyter", "lab", "--ip=0.0.0.0", "--allow-root"]
```

## Wesentliche Bibliotheken

### Installieren in Jupyter

```python
!pip install transformers datasets accelerate bitsandbytes
!pip install wandb tensorboard
!pip install scikit-learn xgboost lightgbm
!pip install opencv-python albumentations
```

### Erstellen Sie requirements.txt

```

# ML-Frameworks
torch>=2.1.0
torchvision
torchaudio

# NLP
transformers>=4.36.0
datasets
tokenizers
sentencepiece

# Training
accelerate
bitsandbytes
peft
trl

# Überwachung
wandb
tensorboard

# Daten
numpy
pandas
matplotlib
seaborn
scikit-learn

# Computer Vision
opencv-python
pillow
albumentations
```

## Trainingsbeispiele

### PyTorch Bildklassifikation

```python
import torch
import torch.nn as nn
import torchvision
from torchvision import transforms
from torch.utils.data import DataLoader

# GPU prüfen
print(f"GPU: {torch.cuda.get_device_name(0)}")
print(f"Speicher: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")

# Daten laden
transform = transforms.Compose([
    transforms.Resize(224),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

train_data = torchvision.datasets.CIFAR10(
    root='./data', train=True, download=True, transform=transform
)
train_loader = DataLoader(train_data, batch_size=64, shuffle=True, num_workers=4)

# Modell
model = torchvision.models.resnet18(pretrained=True)
model.fc = nn.Linear(512, 10)
model = model.cuda()

# Training
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
criterion = nn.CrossEntropyLoss()

for epoch in range(10):
    model.train()
    for images, labels in train_loader:
        images, labels = images.cuda(), labels.cuda()

        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

    print(f"Epoche {epoch+1}, Verlust: {loss.item():.4f}")

# Modell speichern
torch.save(model.state_dict(), 'model.pth')
```

### HuggingFace Textklassifikation

```python
from transformers import AutoTokenizer, AutoModelForSequenceClassification
from transformers import TrainingArguments, Trainer
from datasets import load_dataset
import numpy as np

# Datensatz laden
dataset = load_dataset("imdb")

# Modell laden
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# Tokenisierung
def tokenize(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True)

tokenized = dataset.map(tokenize, batched=True)

# Training
training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir="./logs",
    logging_steps=100,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized["train"],
    eval_dataset=tokenized["test"],
)

trainer.train()
trainer.save_model("./best_model")
```

### LLM-Feinabstimmung mit LoRA

```python
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from datasets import load_dataset
from trl import SFTTrainer
import torch

# Modell mit 4-Bit-Quantisierung laden
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
)

model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-v0.1",
    quantization_config=bnb_config,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
tokenizer.pad_token = tokenizer.eos_token

# LoRA konfigurieren
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = prepare_model_for_kbit_training(model)
model = get_peft_model(model, lora_config)

# Datensatz laden
dataset = load_dataset("timdettmers/openassistant-guanaco")

# Trainieren
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    dataset_text_field="text",
    max_seq_length=512,
    tokenizer=tokenizer,
    args=TrainingArguments(
        output_dir="./lora_output",
        num_train_epochs=1,
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        learning_rate=2e-4,
        fp16=True,
        logging_steps=10,
        save_steps=100,
    ),
)

trainer.train()
trainer.save_model("./final_lora")
```

## TensorBoard-Integration

### TensorBoard starten

```python
%load_ext tensorboard
%tensorboard --logdir ./logs --port 6006 --bind_all
```

Oder über Terminal:

```bash
tensorboard --logdir ./logs --port 6006 --bind_all &
```

### Trainingsmetriken protokollieren

```python
from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter('./logs')

for epoch in range(epochs):
    # ... Trainingsschleife ...
    writer.add_scalar('Loss/train', train_loss, epoch)
    writer.add_scalar('Loss/val', val_loss, epoch)
    writer.add_scalar('Accuracy/val', accuracy, epoch)

writer.close()
```

## Weights & Biases-Integration

```python
import wandb

wandb.init(project="my-project", name="experiment-1")

# Metriken protokollieren
wandb.log({"loss": loss, "accuracy": acc})

# Modell protokollieren
wandb.save("model.pth")

# Beenden
wandb.finish()
```

## Datenverwaltung

### Datensätze herunterladen

```python

# HuggingFace datasets
from datasets import load_dataset
dataset = load_dataset("squad")

# Kaggle-Datensätze
!pip install kaggle
!kaggle datasets download -d username/dataset-name

# Direkter Download
!wget https://example.com/data.zip
!unzip data.zip
```

### Cloud-Speicher einhängen

```python

# S3
!pip install boto3
import boto3
s3 = boto3.client('s3')
s3.download_file('bucket', 'key', 'local_path')

# Google Cloud
!pip install google-cloud-storage
from google.cloud import storage
client = storage.Client()
bucket = client.bucket('my-bucket')
blob = bucket.blob('data.zip')
blob.download_to_filename('data.zip')
```

## Arbeit speichern

### In externen Speicher speichern

```python

# Modell in S3 speichern
import boto3
s3 = boto3.client('s3',
    aws_access_key_id='IHRE_KEY',
    aws_secret_access_key='IHRE_SECRET'
)
s3.upload_file('model.pth', 'my-bucket', 'models/model.pth')
```

### Vor dem Beenden der Sitzung

```bash

# Wichtige Dateien herunterladen
scp -P <port> root@<host>:/workspace/model.pth ./
scp -P <port> -r root@<host>:/workspace/results/ ./results/
```

## Multi-GPU-Training

```python
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel

# GPUs prüfen
print(f"Verfügbare GPUs: {torch.cuda.device_count()}")

# DataParallel (einfach)
model = nn.DataParallel(model)

# DistributedDataParallel (besser)

# Starten mit: torchrun --nproc_per_node=4 train.py
dist.init_process_group("nccl")
model = DistributedDataParallel(model)
```

## Performance-Tipps

### Speicheroptimierung

```python

# Gradient Checkpointing
model.gradient_checkpointing_enable()

# Mixed Precision
from torch.cuda.amp import autocast, GradScaler
scaler = GradScaler()

with autocast():
    output = model(input)
    loss = criterion(output, target)

scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()
```

### Datenladen

```python

# Schnellere Datenladevorgänge
loader = DataLoader(
    dataset,
    batch_size=64,
    num_workers=8,      # Verwenden Sie mehrere Worker
    pin_memory=True,    # Schnellere Übertragung zur GPU
    prefetch_factor=2   # Prefetch-Batches
)
```

## Fehlerbehebung

## Kostenabschätzung

Typische CLORE.AI-Marktplatztarife (Stand 2024):

| GPU       | Stundensatz | Tagessatz | 4-Stunden-Sitzung |
| --------- | ----------- | --------- | ----------------- |
| RTX 3060  | \~$0.03     | \~$0.70   | \~$0.12           |
| RTX 3090  | \~$0.06     | \~$1.50   | \~$0.25           |
| RTX 4090  | \~$0.10     | \~$2.30   | \~$0.40           |
| A100 40GB | \~$0.17     | \~$4.00   | \~$0.70           |
| A100 80GB | \~$0.25     | \~$6.00   | \~$1.00           |

*Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *auf aktuelle Preise.*

**Geld sparen:**

* Verwenden Sie **Spot** Markt für flexible Workloads (oft 30–50% günstiger)
* Bezahlen mit **CLORE** Token
* Preise bei verschiedenen Anbietern vergleichen


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/training/jupyter-ml-training.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.