lambda-labs-gpu-cloud

# Included software
- Ubuntu 22.04 LTS
- NVIDIA drivers (latest)
- CUDA 12.x
- cuDNN 8.x
- NCCL (for multi-GPU)
- PyTorch (latest)
- TensorFlow (latest)
- JAX
- JupyterLab

# Check GPU
nvidia-smi
 
# Check PyTorch
python -c "import torch; print(torch.cuda.is_available())"
 
# Check CUDA version
nvcc --version

pip install lambda-cloud-client

import os
import lambda_cloud_client
 
# Configure with API key
configuration = lambda_cloud_client.Configuration(
    host="https://cloud.lambdalabs.com/api/v1",
    access_token=os.environ["LAMBDA_API_KEY"]
)

with lambda_cloud_client.ApiClient(configuration) as api_client:
    api = lambda_cloud_client.DefaultApi(api_client)
 
    # Get available instance types
    types = api.instance_types()
    for name, info in types.data.items():
        print(f"{name}: {info.instance_type.description}")

from lambda_cloud_client.models import LaunchInstanceRequest
 
request = LaunchInstanceRequest(
    region_name="us-west-1",
    instance_type_name="gpu_1x_h100_sxm5",
    ssh_key_names=["my-ssh-key"],
    file_system_names=["my-filesystem"],  # Optional
    name="training-job"
)
 
response = api.launch_instance(request)
instance_id = response.data.instance_ids[0]
print(f"Launched: {instance_id}")

instances = api.list_instances()
for instance in instances.data:
    print(f"{instance.name}: {instance.ip} ({instance.status})")

from lambda_cloud_client.models import TerminateInstanceRequest
 
request = TerminateInstanceRequest(
    instance_ids=[instance_id]
)
api.terminate_instance(request)

from lambda_cloud_client.models import AddSshKeyRequest
 
# Add SSH key
request = AddSshKeyRequest(
    name="my-key",
    public_key="ssh-rsa AAAA..."
)
api.add_ssh_key(request)
 
# List keys
keys = api.list_ssh_keys()
 
# Delete key
api.delete_ssh_key(key_id)

curl -u $LAMBDA_API_KEY: \
  https://cloud.lambdalabs.com/api/v1/instance-types | jq

curl -u $LAMBDA_API_KEY: \
  -X POST https://cloud.lambdalabs.com/api/v1/instance-operations/launch \
  -H "Content-Type: application/json" \
  -d '{
    "region_name": "us-west-1",
    "instance_type_name": "gpu_1x_h100_sxm5",
    "ssh_key_names": ["my-key"]
  }' | jq

curl -u $LAMBDA_API_KEY: \
  -X POST https://cloud.lambdalabs.com/api/v1/instance-operations/terminate \
  -H "Content-Type: application/json" \
  -d '{"instance_ids": ["<INSTANCE-ID>"]}' | jq

# Mount location
/lambda/nfs/<FILESYSTEM_NAME>
 
# Example: save checkpoints
python train.py --checkpoint-dir /lambda/nfs/my-storage/checkpoints

# Store on filesystem (persists)
/lambda/nfs/storage/
  ├── datasets/
  ├── checkpoints/
  ├── models/
  └── outputs/
 
# Local SSD (faster, ephemeral)
/home/ubuntu/
  └── working/  # Temporary files

# Generate key locally
ssh-keygen -t ed25519 -f ~/.ssh/lambda_key
 
# Add public key to Lambda console
# Or via API

# On instance, add more keys
echo 'ssh-rsa AAAA...' >> ~/.ssh/authorized_keys

# On instance
ssh-import-id gh:username

# Forward Jupyter
ssh -L 8888:localhost:8888 ubuntu@<IP>
 
# Forward TensorBoard
ssh -L 6006:localhost:6006 ubuntu@<IP>
 
# Multiple ports
ssh -L 8888:localhost:8888 -L 6006:localhost:6006 ubuntu@<IP>

# On instance
jupyter lab --ip=0.0.0.0 --port=8888
 
# From local machine with tunnel
ssh -L 8888:localhost:8888 ubuntu@<IP>
# Open http://localhost:8888

# SSH to instance
ssh ubuntu@<IP>
 
# Clone repo
git clone https://github.com/user/project
cd project
 
# Install dependencies
pip install -r requirements.txt
 
# Train
python train.py --epochs 100 --checkpoint-dir /lambda/nfs/storage/checkpoints

# train_ddp.py
import torch
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
 
def main():
    dist.init_process_group("nccl")
    rank = dist.get_rank()
    device = rank % torch.cuda.device_count()
 
    model = MyModel().to(device)
    model = DDP(model, device_ids=[device])
 
    # Training loop...
 
if __name__ == "__main__":
    main()

# Launch with torchrun (8 GPUs)
torchrun --nproc_per_node=8 train_ddp.py

import os
 
checkpoint_dir = "/lambda/nfs/my-storage/checkpoints"
os.makedirs(checkpoint_dir, exist_ok=True)
 
# Save checkpoint
torch.save({
    'epoch': epoch,
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'loss': loss,
}, f"{checkpoint_dir}/checkpoint_{epoch}.pt")

# On Slurm cluster
srun --nodes=4 --ntasks-per-node=8 --gpus-per-node=8 \
  torchrun --nnodes=4 --nproc_per_node=8 \
  --rdzv_backend=c10d --rdzv_endpoint=$MASTER_ADDR:29500 \
  train.py

# Find private IP
ip addr show | grep 'inet '

# 1. Launch 8x H100 instance with filesystem
 
# 2. SSH and setup
ssh ubuntu@<IP>
pip install transformers accelerate peft
 
# 3. Download model to filesystem
python -c "
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained('meta-llama/Llama-2-7b-hf')
model.save_pretrained('/lambda/nfs/storage/models/llama-2-7b')
"
 
# 4. Fine-tune with checkpoints on filesystem
accelerate launch --num_processes 8 train.py \
  --model_path /lambda/nfs/storage/models/llama-2-7b \
  --output_dir /lambda/nfs/storage/outputs \
  --checkpoint_dir /lambda/nfs/storage/checkpoints

# 1. Launch A10 instance (cost-effective for inference)
 
# 2. Run inference
python inference.py \
  --model /lambda/nfs/storage/models/fine-tuned \
  --input /lambda/nfs/storage/data/inputs.jsonl \
  --output /lambda/nfs/storage/data/outputs.jsonl