phygrid/cuda-pytorch repository overview

# Pull the latest image
docker pull phygrid/cuda-pytorch:latest

# Use as base image in your Dockerfile
FROM phygrid/cuda-pytorch:1.0.0

FROM phygrid/cuda-pytorch:1.0.0

# Copy your models and code
COPY models/ /app/pytorch_models/
COPY src/ /app/src/

# Install additional dependencies
RUN pip install -r requirements.txt

# Override default command
CMD ["python", "inference_server.py"]

# Run interactive container with GPU support
docker run -it --rm \
  --gpus all \
  -v $(pwd):/app/workspace \
  -v $(pwd)/models:/app/pytorch_models \
  -v ~/.cache/huggingface:/app/cache/huggingface \
  -p 8000:8000 \
  phygrid/cuda-pytorch:latest \
  bash

# Run PyTorch inference service
docker run -d \
  --name pytorch-inference \
  --gpus all \
  -p 8000:8000 \
  -v /data/models:/app/pytorch_models \
  -v /data/cache:/app/cache \
  -e PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512 \
  phygrid/cuda-pytorch:latest

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# Load model with GPU support
model_name = "microsoft/DialoGPT-medium"
tokenizer = AutoTokenizer.from_pretrained(model_name, cache_dir="/app/cache/transformers")
model = AutoModelForCausalLM.from_pretrained(model_name, cache_dir="/app/cache/transformers")

# Move to GPU if available
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Inference example
inputs = tokenizer.encode("Hello, how are you?", return_tensors="pt").to(device)
outputs = model.generate(inputs, max_length=50, num_return_sequences=1)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)

import torch
import torch.nn as nn
from torch.utils.data import DataLoader

# Configure for RTX 5090
torch.backends.cudnn.benchmark = True
torch.backends.cuda.matmul.allow_tf32 = True

# Your training code here
model = nn.Sequential(...)
optimizer = torch.optim.AdamW(model.parameters())

# Enable mixed precision training
scaler = torch.cuda.amp.GradScaler()

# Clone repository
git clone https://github.com/phygrid/cuda-pytorch.git
cd cuda-pytorch

# Build image
docker build -t phygrid/cuda-pytorch:custom .

# Build for multiple architectures
docker buildx build --platform linux/amd64,linux/arm64 -t phygrid/cuda-pytorch:custom .

# Test PyTorch setup
docker run --rm phygrid/cuda-pytorch:latest python /app/pytorch_test.py

# Expected output (with GPU):
# PyTorch version: 2.8.0
# Transformers version: 4.36.2
# ✅ CUDA available: NVIDIA GeForce RTX 5090
#    CUDA version: 12.8
#    GPU memory: 32.0 GB
# ✅ Basic tensor operations: OK
# PyTorch setup: OK

# Enable optimal memory allocation
export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512

# Enable TensorFloat-32 for faster training
export TORCH_ALLOW_TF32_CUBLAS_OVERRIDE=1

# Configure for maximum performance
export CUDA_LAUNCH_BLOCKING=0

import torch

# Clear cache periodically
torch.cuda.empty_cache()

# Use gradient checkpointing for large models
model.gradient_checkpointing_enable()

# Enable mixed precision
with torch.cuda.amp.autocast():
    outputs = model(inputs)

# Use memory mapping for large models
model = AutoModelForCausalLM.from_pretrained(
    "large-model",
    torch_dtype=torch.float16,
    device_map="auto",
    low_cpu_mem_usage=True
)

# Clone and setup
git clone https://github.com/phygrid/cuda-pytorch.git
cd cuda-pytorch

# Test build locally
docker build -t phygrid/cuda-pytorch:test .
docker run --rm --gpus all phygrid/cuda-pytorch:test python /app/pytorch_test.py

LABEL org.opencontainers.image.title="Phygrid CUDA PyTorch"
LABEL org.opencontainers.image.description="PyTorch base image for deep learning inference with GPU support"
LABEL org.opencontainers.image.vendor="Phygrid"
LABEL inference.engine="pytorch"
LABEL inference.runtime="pytorch-2.8.0"
LABEL cuda.version="12.8"