この記事の対象読者

Pythonの基本文法（pip、仮想環境）を理解している方
PyTorchやTensorFlowでGPUを使いたいと考えている方
「CUDAのインストールで何度も失敗した」経験がある方
ローカルでLLMや画像生成AIを動かしたい方

この記事で得られること

CUDA・cuDNN・PyTorchの依存関係が複雑な「本当の理由」の理解
環境構築で失敗しないための具体的な手順とコード
トラブル発生時の原因特定と解決方法
Docker・conda・pip それぞれの使い分け方

この記事で扱わないこと

GPUハードウェアの選び方（RTX 4090 vs A100 など）
CUDA C++によるカーネル開発
クラウドGPU（AWS、GCP、Lambda Labs等）の設定

1. CUDA地獄との出会い

「torch.cuda.is_available() が False を返す...」

ローカルAI開発を始めた人なら、この絶望を一度は経験したことがあるはず。私も例外ではなかった。

RTX 3080を積んだマシンを手に入れ、意気揚々とStable Diffusionを動かそうとした日のこと。公式サイトの通りに pip install torch を実行し、いざ起動。

RuntimeError: CUDA error: no kernel image is available for execution on the device

「え、GPUあるのに？」

そこから始まった3日間の地獄。CUDAをインストールし直し、cuDNNを入れ、PyTorchを再インストール。何度やっても動かない。ググって出てくる情報は断片的で、しかも古い。

最終的に原因は「PyTorchのwheelに含まれるCUDAバージョンと、システムにインストールされたCUDAドライバのバージョン不整合」だった。たった一行のコマンドミスで、丸3日を失ったのだ。

この記事は、過去の自分に送る手紙でもある。「CUDA地獄」の正体を理解し、二度と同じ轍を踏まないための完全ガイドだ。

ここまでで、CUDA地獄がどれほど厄介かイメージできたと思う。次は、この問題を理解するために必要な前提知識を整理しよう。

2. 前提知識の確認

本題に入る前に、この記事で使う用語を整理しておく。

2.1 GPU（Graphics Processing Unit）とは

もともと画像処理用に設計されたプロセッサ。CPUが「少数の複雑な計算を高速に」処理するのに対し、GPUは「大量の単純な計算を並列に」処理することに特化している。ディープラーニングの行列演算と相性が抜群に良い。

2.2 CUDA（Compute Unified Device Architecture）とは

NVIDIAが開発したGPU向けの並列コンピューティングプラットフォーム。簡単に言えば「NVIDIAのGPUで汎用計算をするための仕組み」。CUDAがないと、PyTorchはGPUを認識できない。

2.3 cuDNN（CUDA Deep Neural Network library）とは

NVIDIA製のディープラーニング用ライブラリ。畳み込み演算やRNN、Transformerなど、ニューラルネットワークでよく使う処理を高速化してくれる。PyTorchやTensorFlowの裏側で密かに働いている縁の下の力持ち。

2.4 NVIDIAドライバとは

OSとGPUハードウェアを繋ぐソフトウェア。ドライバのバージョンによって、対応できるCUDAのバージョンが決まる。古いドライバでは新しいCUDAが動かない。

2.5 Compute Capability（CC）とは

GPUアーキテクチャの世代を表す数値。例えばRTX 3000シリーズは 8.6、RTX 4000シリーズは 8.9。PyTorchのwheelは特定のCCに対応しており、古すぎるGPUだとそもそもサポート対象外になる。

これらの用語が押さえられたら、次に進もう。なぜこれらの依存関係がこんなに複雑なのか、その背景を見ていく。

3. なぜCUDA地獄は発生するのか

3.1 4層構造の依存関係

CUDA地獄の根本原因は、4つのレイヤーが相互に依存していることにある。

┌─────────────────────────────────────┐
│  PyTorch / TensorFlow               │  ← アプリケーション層
├─────────────────────────────────────┤
│  cuDNN                              │  ← ライブラリ層
├─────────────────────────────────────┤
│  CUDA Toolkit                       │  ← ランタイム層
├─────────────────────────────────────┤
│  NVIDIA Driver                      │  ← ドライバ層
├─────────────────────────────────────┤
│  GPU Hardware (CC: 8.6 など)        │  ← ハードウェア層
└─────────────────────────────────────┘

各レイヤーには「このバージョンと組み合わせて使ってね」という制約がある。そして厄介なことに、この制約は単純な「以上・以下」ではなく、特定の組み合わせのみが動作する。

3.2 バージョン互換性の非対称性

ここが最も混乱を招くポイントだ。

NVIDIAドライバは「前方互換性」がある：

ドライバ 535.xx → CUDA 11.x, 12.0, 12.1, 12.2 すべて動作

PyTorchのwheelは「特定バージョン」に固定：

torch==2.5.1+cu124 → CUDA 12.4用にビルドされている
                   → CUDA 11.8環境では動作しない（かもしれない）

つまり、「最新のドライバを入れておけばOK」というわけではなく、「PyTorchがどのCUDAバージョンでビルドされているか」を意識する必要がある。

3.3 pip install torch の罠

何も考えずに pip install torch を実行すると、PyPIからCPU版がインストールされる。GPU版が欲しい場合は、明示的にCUDAバージョンを指定したURLからインストールする必要がある。

# これはCPU版がインストールされる（罠）
pip install torch

# GPU版はこちら（CUDA 12.4の場合）
pip install torch --index-url https://download.pytorch.org/whl/cu124

この仕様を知らずに「GPUあるのに動かない！」と悩む人が後を絶たない。

3.4 conda と pip の混在問題

conda環境でpipを使うと、依存関係の解決がカオスになる。condaはconda-forgeやnvidiaチャンネルから、pipはPyPIやPyTorch独自のwheelサーバーから取得する。両者の依存関係ツリーは独立しているため、矛盾が発生しやすい。

なぜこんなに複雑なのかが理解できたところで、抽象的な概念から具体的な解決策へと進んでいこう。

4. 依存関係の全体像を把握する

4.1 PyTorch バージョン別 CUDA 対応表（2025年1月時点）

PyTorch	対応CUDA	Python	備考
2.9.0	12.6, 12.8, 13.0	3.9-3.12	Blackwell対応
2.8.0	12.6, 12.8, 12.9	3.9-3.12	最新安定版
2.7.1	11.8, 12.6, 12.8	3.9-3.12	CUDA 11.8最終対応
2.5.1	11.8, 12.1, 12.4	3.9-3.12	広く使われている
2.4.x	11.8, 12.1, 12.4	3.8-3.12	Python 3.8最終

4.2 NVIDIAドライバと対応CUDAの関係

ドライババージョン	対応CUDA（最大）
560.xx 以上	CUDA 12.6
550.xx 以上	CUDA 12.4
535.xx 以上	CUDA 12.2
525.xx 以上	CUDA 12.0
520.xx 以上	CUDA 11.8

重要： ドライバは「前方互換」。新しいドライバは古いCUDAもサポートする。

4.3 GPUアーキテクチャとCompute Capability

アーキテクチャ	CC	代表的なGPU
Blackwell	10.0, 12.0	RTX 5090, 5080
Ada Lovelace	8.9	RTX 4090, 4080, 4070
Ampere	8.6	RTX 3090, 3080, A100
Turing	7.5	RTX 2080, T4
Volta	7.0	V100
Pascal	6.1	GTX 1080, P100

注意： PyTorch 2.5以降、Pascal（CC 6.x）のサポートは縮小傾向。古いGPUを使っている場合は要確認。

依存関係の全体像が掴めたところで、具体的な実装例を見ていこう。

5. 実際に環境を構築してみよう

5.1 現在の環境を確認するスクリプト

まずは自分の環境を正確に把握することから始める。以下のスクリプトをコピペして実行しよう。

"""
GPU環境診断スクリプト
使い方: python check_gpu_env.py
必要なパッケージ: なし（標準ライブラリのみ）
"""
import subprocess
import sys

def run_command(cmd):
    """コマンドを実行して結果を返す"""
    try:
        result = subprocess.run(
            cmd, shell=True, capture_output=True, text=True, timeout=30
        )
        return result.stdout.strip() if result.returncode == 0 else None
    except Exception:
        return None

def check_nvidia_driver():
    """NVIDIAドライバのバージョンを確認"""
    output = run_command("nvidia-smi --query-gpu=driver_version --format=csv,noheader")
    if output:
        print(f"[OK] NVIDIA Driver: {output}")
        return output
    else:
        print("[NG] NVIDIA Driver: 検出できません")
        return None

def check_cuda_version():
    """nvidia-smiから対応CUDA バージョンを確認"""
    output = run_command("nvidia-smi --query-gpu=compute_cap --format=csv,noheader")
    cc = output if output else "不明"
    
    # nvidia-smiのヘッダーからCUDAバージョンを取得
    smi_output = run_command("nvidia-smi")
    if smi_output and "CUDA Version:" in smi_output:
        for line in smi_output.split("\n"):
            if "CUDA Version:" in line:
                cuda_ver = line.split("CUDA Version:")[1].strip().split()[0]
                print(f"[OK] 対応CUDA (ドライバ上限): {cuda_ver}")
                print(f"[OK] Compute Capability: {cc}")
                return cuda_ver
    print(f"[--] Compute Capability: {cc}")
    return None

def check_pytorch():
    """PyTorchのインストール状況を確認"""
    try:
        import torch
        print(f"[OK] PyTorch: {torch.__version__}")
        print(f"[OK] CUDA available: {torch.cuda.is_available()}")
        if torch.cuda.is_available():
            print(f"[OK] CUDA version (PyTorch): {torch.version.cuda}")
            print(f"[OK] cuDNN version: {torch.backends.cudnn.version()}")
            print(f"[OK] GPU: {torch.cuda.get_device_name(0)}")
        return True
    except ImportError:
        print("[--] PyTorch: インストールされていません")
        return False

def main():
    print("=" * 50)
    print("GPU環境診断レポート")
    print("=" * 50)
    print(f"\nPython: {sys.version}")
    print()
    
    check_nvidia_driver()
    check_cuda_version()
    print()
    check_pytorch()
    
    print("\n" + "=" * 50)
    print("診断完了")
    print("=" * 50)

if __name__ == "__main__":
    main()

5.2 実行結果の例

上記のスクリプトを実行すると、以下のような出力が得られる：

==================================================
GPU環境診断レポート
==================================================

Python: 3.11.5 (main, Sep 11 2023, 13:54:46) [GCC 11.2.0]

[OK] NVIDIA Driver: 550.54.14
[OK] 対応CUDA (ドライバ上限): 12.4
[OK] Compute Capability: 8.6

[OK] PyTorch: 2.5.1+cu124
[OK] CUDA available: True
[OK] CUDA version (PyTorch): 12.4
[OK] cuDNN version: 90100
[OK] GPU: NVIDIA GeForce RTX 3080

==================================================
診断完了
==================================================

この出力で CUDA available: False が表示された場合、次のセクションの設定ファイルを使って環境を再構築しよう。

5.3 設定ファイルのテンプレート

以下の3種類の設定ファイルを用意した。用途に応じて選択してほしい。

開発環境用（requirements-dev.txt）

# requirements-dev.txt
# 開発環境用 - CUDA 12.4対応
# 使い方: pip install -r requirements-dev.txt --index-url https://download.pytorch.org/whl/cu124

# PyTorch（CUDA 12.4）
--extra-index-url https://download.pytorch.org/whl/cu124
torch==2.5.1
torchvision==0.20.1
torchaudio==2.5.1

# 開発ツール
ipython>=8.0.0
jupyter>=1.0.0
tensorboard>=2.15.0

# デバッグ用
py-spy>=0.3.14
memory-profiler>=0.61.0

本番環境用（requirements-prod.txt）

# requirements-prod.txt
# 本番環境用 - バージョン固定で再現性を確保
# 使い方: pip install -r requirements-prod.txt --index-url https://download.pytorch.org/whl/cu124

# PyTorch（CUDA 12.4）- バージョン完全固定
--extra-index-url https://download.pytorch.org/whl/cu124
torch==2.5.1+cu124
torchvision==0.20.1+cu124
torchaudio==2.5.1+cu124

# 推論用ライブラリ
transformers==4.47.0
accelerate==1.2.1
safetensors==0.4.5

# サーバー
fastapi==0.115.6
uvicorn[standard]==0.34.0

CI/テスト環境用（requirements-test.txt）

# requirements-test.txt
# CI/テスト環境用 - CPU版で高速にテスト
# 使い方: pip install -r requirements-test.txt

# PyTorch（CPU版 - CI環境ではGPU不要な場合が多い）
--extra-index-url https://download.pytorch.org/whl/cpu
torch==2.5.1
torchvision==0.20.1
torchaudio==2.5.1

# テストツール
pytest>=8.0.0
pytest-cov>=4.1.0
pytest-xdist>=3.5.0

# 型チェック
mypy>=1.8.0

Docker用（Dockerfile）

# Dockerfile
# NVIDIA公式イメージをベースにした本番環境用
# ビルド: docker build -t myapp:cuda .
# 実行: docker run --gpus all myapp:cuda

FROM nvidia/cuda:12.4.0-cudnn-runtime-ubuntu22.04

# タイムゾーン設定（インタラクティブ入力を回避）
ENV DEBIAN_FRONTEND=noninteractive
ENV TZ=Asia/Tokyo

# システムパッケージ
RUN apt-get update && apt-get install -y \
    python3.11 \
    python3.11-venv \
    python3-pip \
    git \
    && rm -rf /var/lib/apt/lists/*

# Python設定
RUN ln -sf /usr/bin/python3.11 /usr/bin/python
WORKDIR /app

# PyTorchインストール
RUN pip install --no-cache-dir \
    torch==2.5.1 \
    torchvision==0.20.1 \
    torchaudio==2.5.1 \
    --index-url https://download.pytorch.org/whl/cu124

# アプリケーションコード
COPY . .
RUN pip install --no-cache-dir -r requirements-prod.txt

# ヘルスチェック
HEALTHCHECK --interval=30s --timeout=10s \
    CMD python -c "import torch; assert torch.cuda.is_available()"

CMD ["python", "main.py"]

docker-compose用（docker-compose.yml）

# docker-compose.yml
# 使い方: docker compose up -d

services:
  app:
    build: .
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - NVIDIA_DRIVER_CAPABILITIES=compute,utility
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    volumes:
      - ./data:/app/data
      - ./models:/app/models
    ports:
      - "8000:8000"
    restart: unless-stopped

基本的な使い方をマスターしたので、次はより実践的なユースケースを見ていこう。

6. よくあるエラーと対処法

エラーメッセージ	原因	対処法
`torch.cuda.is_available()` が `False`	CPU版PyTorchがインストールされている	`--index-url https://download.pytorch.org/whl/cu124` を付けて再インストール
`CUDA error: no kernel image is available`	GPUのCompute Capabilityに対応していないPyTorch	PyTorchのバージョンを確認、CCに対応したビルドを使用
`CUDA out of memory`	GPUメモリ不足	バッチサイズを小さく、`torch.cuda.empty_cache()` を呼ぶ、`torch_dtype=torch.float16` を使用
`libcudnn.so: cannot open shared object file`	cuDNNがインストールされていない	`conda install cudnn` または Docker使用を推奨
`CUDA driver version is insufficient`	ドライバが古い	NVIDIAドライバを更新（550.xx以上推奨）
`RuntimeError: CUDA error: invalid device ordinal`	指定したGPU番号が存在しない	`CUDA_VISIBLE_DEVICES` 環境変数を確認
`ImportError: libcublas.so.12`	CUDAライブラリのパスが通っていない	`LD_LIBRARY_PATH` を設定、または Docker使用

ユースケースが把握できたところで、この記事を読んだ後の学習パスを確認しよう。

7. ユースケース別ガイド

7.1 ユースケース1: Stable Diffusionをローカルで動かしたい

想定読者: 画像生成AIを自分のPCで試したい人
推奨構成: RTX 3060以上、VRAM 8GB以上、CUDA 12.4
サンプルコード:

"""
Stable Diffusion 環境構築スクリプト
使い方: python setup_sd.py
"""
import subprocess
import sys

def setup_stable_diffusion():
    """Stable Diffusion用の環境を構築する"""
    
    # PyTorch（CUDA 12.4）をインストール
    subprocess.check_call([
        sys.executable, "-m", "pip", "install",
        "torch==2.5.1", "torchvision==0.20.1",
        "--index-url", "https://download.pytorch.org/whl/cu124"
    ])
    
    # diffusers関連をインストール
    subprocess.check_call([
        sys.executable, "-m", "pip", "install",
        "diffusers>=0.31.0",
        "transformers>=4.47.0",
        "accelerate>=1.2.0",
        "safetensors>=0.4.0",
        "xformers>=0.0.28"  # メモリ効率化
    ])
    
    print("セットアップ完了！")

def test_generation():
    """動作確認用の画像生成テスト"""
    import torch
    from diffusers import StableDiffusionPipeline
    
    # GPU確認
    if not torch.cuda.is_available():
        raise RuntimeError("CUDAが利用できません")
    
    print(f"GPU: {torch.cuda.get_device_name(0)}")
    print(f"VRAM: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")
    
    # パイプライン読み込み（float16でメモリ節約）
    pipe = StableDiffusionPipeline.from_pretrained(
        "runwayml/stable-diffusion-v1-5",
        torch_dtype=torch.float16,
        safety_checker=None
    ).to("cuda")
    
    # メモリ効率化
    pipe.enable_attention_slicing()
    
    # テスト生成
    image = pipe("a photo of an astronaut riding a horse on mars").images[0]
    image.save("test_output.png")
    print("test_output.png に保存しました")

if __name__ == "__main__":
    setup_stable_diffusion()
    test_generation()

7.2 ユースケース2: LLMをローカルで推論したい

想定読者: ChatGPT風のAIを自分のPCで動かしたい人
推奨構成: RTX 4070以上、VRAM 12GB以上、CUDA 12.4
サンプルコード:

"""
ローカルLLM推論スクリプト
使い方: python local_llm.py
必要VRAM: 8GB以上（量子化モデル使用時）
"""
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

def setup_llm(model_name: str = "microsoft/phi-2"):
    """
    ローカルLLMをセットアップする
    
    Args:
        model_name: HuggingFaceのモデル名
    
    Returns:
        model, tokenizer のタプル
    """
    # GPU確認
    if not torch.cuda.is_available():
        raise RuntimeError("CUDAが利用できません")
    
    device = "cuda"
    print(f"使用GPU: {torch.cuda.get_device_name(0)}")
    
    # 量子化設定（VRAMが少ない場合）
    vram_gb = torch.cuda.get_device_properties(0).total_memory / 1024**3
    
    if vram_gb < 12:
        print(f"VRAM {vram_gb:.1f}GB: 4bit量子化を使用")
        quantization_config = BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_compute_dtype=torch.float16
        )
    else:
        print(f"VRAM {vram_gb:.1f}GB: float16を使用")
        quantization_config = None
    
    # トークナイザー読み込み
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token
    
    # モデル読み込み
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        quantization_config=quantization_config,
        torch_dtype=torch.float16,
        device_map="auto",
        trust_remote_code=True
    )
    
    return model, tokenizer

def generate_response(model, tokenizer, prompt: str, max_length: int = 200):
    """テキスト生成を行う"""
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=max_length,
            do_sample=True,
            temperature=0.7,
            top_p=0.9,
            pad_token_id=tokenizer.pad_token_id
        )
    
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return response

if __name__ == "__main__":
    model, tokenizer = setup_llm("microsoft/phi-2")
    
    prompt = "Pythonでフィボナッチ数列を計算する関数を書いてください。"
    response = generate_response(model, tokenizer, prompt)
    print(response)

7.3 ユースケース3: 機械学習モデルの学習を高速化したい

想定読者: 自分のデータでモデルを学習させたい人
推奨構成: RTX 3080以上、VRAM 10GB以上、CUDA 12.4
サンプルコード:

"""
GPU活用のベストプラクティス - 学習高速化
使い方: python train_with_gpu.py
"""
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset
from torch.cuda.amp import autocast, GradScaler
import time

def create_dummy_data(n_samples: int = 10000, n_features: int = 100):
    """ダミーデータを生成"""
    X = torch.randn(n_samples, n_features)
    y = torch.randint(0, 10, (n_samples,))
    return X, y

def train_with_mixed_precision(model, train_loader, epochs: int = 10):
    """
    Mixed Precision Training（AMP）を使った高速学習
    
    float16とfloat32を自動で切り替え、メモリ使用量と計算時間を削減
    """
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = model.to(device)
    
    criterion = nn.CrossEntropyLoss()
    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
    
    # AMP用のスケーラー
    scaler = GradScaler()
    
    print(f"Training on: {device}")
    print(f"Mixed Precision: Enabled")
    
    start_time = time.time()
    
    for epoch in range(epochs):
        model.train()
        total_loss = 0.0
        
        for batch_idx, (data, target) in enumerate(train_loader):
            data, target = data.to(device), target.to(device)
            
            optimizer.zero_grad()
            
            # autocastブロック内でfloat16を自動適用
            with autocast():
                output = model(data)
                loss = criterion(output, target)
            
            # スケーリングしてバックプロパゲーション
            scaler.scale(loss).backward()
            scaler.step(optimizer)
            scaler.update()
            
            total_loss += loss.item()
        
        avg_loss = total_loss / len(train_loader)
        print(f"Epoch {epoch+1}/{epochs}, Loss: {avg_loss:.4f}")
    
    elapsed = time.time() - start_time
    print(f"\n学習完了: {elapsed:.2f}秒")
    
    return model

class SimpleModel(nn.Module):
    """シンプルな分類モデル"""
    def __init__(self, n_features: int = 100, n_classes: int = 10):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(n_features, 256),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(128, n_classes)
        )
    
    def forward(self, x):
        return self.layers(x)

if __name__ == "__main__":
    # GPU情報表示
    if torch.cuda.is_available():
        print(f"GPU: {torch.cuda.get_device_name(0)}")
        print(f"VRAM: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")
    else:
        print("警告: GPUが利用できません")
    
    # データ準備
    X, y = create_dummy_data(n_samples=50000, n_features=100)
    dataset = TensorDataset(X, y)
    train_loader = DataLoader(dataset, batch_size=256, shuffle=True, num_workers=4, pin_memory=True)
    
    # モデル作成と学習
    model = SimpleModel(n_features=100, n_classes=10)
    trained_model = train_with_mixed_precision(model, train_loader, epochs=10)
    
    # モデル保存
    torch.save(trained_model.state_dict(), "model.pth")
    print("model.pth に保存しました")

8. 学習ロードマップ

この記事を読んだ後、次のステップとして以下をおすすめする。

初級者向け（まずはここから）

PyTorch公式チュートリアル - 基本的なテンソル操作から学べる
NVIDIA CUDA インストールガイド - 公式の手順を一度読んでおく
PyTorch Previous Versions - バージョン別のインストールコマンド一覧

中級者向け（実践に進む）

nvidia-docker - コンテナでのGPU利用をマスター
PyTorch Profiler - パフォーマンスボトルネックの特定
HuggingFace Accelerate - 分散学習やmixed precisionを簡単に

上級者向け（さらに深く）

CUDA C++ Programming Guide - CUDAの内部動作を理解
PyTorch Internals - PyTorchの拡張方法
triton-lang - カスタムGPUカーネルを書く

9. まとめ

この記事では、CUDA地獄について以下を解説した：

CUDA地獄の正体は「4層の依存関係」と「バージョン互換性の複雑さ」
環境診断スクリプトで現状を正確に把握することが第一歩
Docker、conda、pip それぞれに適した使い方がある
トラブルシューティング表で素早く原因を特定できる

私の所感

正直なところ、CUDA周りの複雑さはNVIDIAとPyTorchコミュニティの「技術的負債」だと思っている。CUDAがプロプライエタリであること、PyTorchのwheelがCUDAバージョンごとにビルドされていること、そしてpipとcondaの依存関係解決が別々に動くこと。これらが絡み合って「地獄」を生み出している。

とはいえ、この複雑さの裏側には「GPU計算を可能な限り高速化したい」という開発者たちの執念がある。一度環境が整えば、CPUの何十倍もの速度でモデルを動かせる恩恵を受けられる。

最終的なおすすめは「Docker一択」だ。環境構築の再現性が担保され、他のプロジェクトとの依存関係衝突も防げる。ローカル開発でも nvidia-docker を使えば、CUDA地獄とおさらばできる。

この記事が、過去の私と同じように苦しんでいる誰かの助けになれば幸いだ。

参考文献