Jupyter ML-Training

Richten Sie JupyterLab mit GPU-Unterstützung für ML-Training auf Clore.ai ein

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

Alle Beispiele können auf GPU-Servern ausgeführt werden, die über CLORE.AI Marketplace.

Serveranforderungen

Parameter

Minimum

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:

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:

Gehen Sie zur Meine Bestellungen Seite
Klicken Sie auf Ihre Bestellung
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

# Ü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

Wenn Sie HTTP 502 erhalten, warten Sie 2-3 Minuten - der Dienst installiert Abhängigkeiten.

Mieten auf CLORE.AI

Besuchen Sie CLORE.AI Marketplace
Nach GPU-Typ, VRAM und Preis filtern
Wählen On-Demand (Festpreis) oder Spot (Gebotspreis)
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
Zahlung auswählen: CLORE, BTC, oder USDT/USDC
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

Warten Sie auf die Bereitstellung
Finden Sie die Port-Mapping für 8888
Ö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:

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

!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

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

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

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

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

Oder über Terminal:

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

Trainingsmetriken protokollieren

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

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


# 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


# 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


# 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


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

Multi-GPU-Training

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


# 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


# 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 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

VorherigeÜberblick NächsteDreamBooth

Zuletzt aktualisiert vor 1 Tag

War das hilfreich?

hashtagServeranforderungen

hashtagSchnelle Bereitstellung

hashtagZugriff auf Ihren Dienst

hashtagÜberprüfen, ob es funktioniert

hashtagMieten auf CLORE.AI

hashtagZugriff auf Ihren Server

hashtagZugriff auf Jupyter

hashtagVorkonfiguriertes ML-Image

hashtagWesentliche Bibliotheken

hashtagInstallieren in Jupyter

hashtagErstellen Sie requirements.txt

hashtagTrainingsbeispiele

hashtagPyTorch Bildklassifikation

hashtagHuggingFace Textklassifikation

hashtagLLM-Feinabstimmung mit LoRA

hashtagTensorBoard-Integration

hashtagTensorBoard starten

hashtagTrainingsmetriken protokollieren

hashtagWeights & Biases-Integration

hashtagDatenverwaltung

hashtagDatensätze herunterladen

hashtagCloud-Speicher einhängen

hashtagArbeit speichern

hashtagIn externen Speicher speichern

hashtagVor dem Beenden der Sitzung

hashtagMulti-GPU-Training

hashtagPerformance-Tipps

hashtagSpeicheroptimierung

hashtagDatenladen

hashtagFehlerbehebung

hashtagKostenabschätzung

Serveranforderungen

Schnelle Bereitstellung

Zugriff auf Ihren Dienst

Überprüfen, ob es funktioniert

Mieten auf CLORE.AI

Zugriff auf Ihren Server

Zugriff auf Jupyter

Vorkonfiguriertes ML-Image

Wesentliche Bibliotheken

Installieren in Jupyter

Erstellen Sie requirements.txt

Trainingsbeispiele

PyTorch Bildklassifikation

HuggingFace Textklassifikation

LLM-Feinabstimmung mit LoRA

TensorBoard-Integration

TensorBoard starten

Trainingsmetriken protokollieren

Weights & Biases-Integration

Datenverwaltung

Datensätze herunterladen

Cloud-Speicher einhängen

Arbeit speichern

In externen Speicher speichern

Vor dem Beenden der Sitzung

Multi-GPU-Training

Performance-Tipps

Speicheroptimierung

Datenladen

Fehlerbehebung

Kostenabschätzung