8
7

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

@GeneLab_999

eGPUってなんだ？〜MacユーザーがCUDAの夢を見る前に知るべき真実〜

Posted at

この記事の対象読者

  • Macで機械学習やディープラーニングを始めたい方
  • 「eGPUを買えばMacでもCUDAが使える」と思っている方
  • PyTorchやTensorFlowの環境構築で悩んでいる方
  • Apple SiliconとIntel Macの違いを理解したい方

この記事で得られること

  • eGPUの仕組みと、MacでCUDAが使えない技術的・歴史的背景の理解
  • 自分のMacがeGPUに対応しているか確認するコード
  • Mac環境での機械学習における現実的な代替手段と設定ファイル
  • 「無駄な出費を避ける」ための判断材料

この記事で扱わないこと

  • Windows/LinuxでのeGPUセットアップ手順
  • Hackintoshの構築方法
  • GPUの詳細なハードウェアアーキテクチャ

1. eGPUとの出会い—そして絶望

「MacでCUDAを動かしたい」

RTX 5090を積んだWindows PCを組んだ私は、ふと思った。「Thunderbolt経由でeGPUを繋げば、MacBook Proでもディープラーニングできるんじゃないか？」と。

調べてみると、eGPU（external GPU）という製品が存在する。Razer Core X、Sonnet Breakaway Box、AKiTiO Node Titan...。Thunderbolt 3ケーブル一本で、ノートPCに外付けGPUの演算パワーを追加できる夢のデバイスだ。

「これだ！」と興奮して調査を進めた私を待っていたのは、3つの残酷な現実だった。

  1. Apple Silicon（M1/M2/M3/M4）はeGPUを一切サポートしない
  2. Intel MacでもNVIDIA GPUはmacOS Mojave以降で使えない
  3. CUDAはNVIDIA専用技術なので、AMD GPUでは動かない

つまり、「MacでeGPU経由でCUDA」は、2026年現在ほぼ不可能なのだ。

この記事では、同じ轍を踏もうとしているMacユーザーを救うべく、なぜこの組み合わせが成立しないのかを技術的・歴史的背景から解説する。そして、Macで機械学習をするための現実的な代替手段を提示する。

ここまでで、なぜこの記事が必要なのか理解できたはずだ。次は、eGPUとCUDAの基本概念を整理しよう。

2. 前提知識の確認

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

2.1 eGPU（external GPU）とは

eGPUは「外付けグラフィックスカード」のこと。Thunderbolt 3/4ケーブルを通じて、デスクトップ用のGPUをノートPCに接続する仕組みだ。エンクロージャ（筐体）にGPUを挿し、PCと接続することで、ノートPC単体では得られないグラフィックス性能を実現できる。

2.2 CUDAとは

CUDA（Compute Unified Device Architecture）は、NVIDIAが開発したGPU向け並列コンピューティングプラットフォームだ。PyTorch、TensorFlow、JAXといった主要な機械学習フレームワークは、CUDAを通じてNVIDIA GPUの演算能力を活用する。重要なのは、CUDAはNVIDIA独自の技術であり、AMD GPUやApple Silicon GPUでは動作しないという点だ。

2.3 Thunderboltとは

Thunderboltは、IntelとAppleが共同開発した高速データ転送規格だ。Thunderbolt 3/4は最大40Gbpsの帯域幅を持ち、PCIeトンネリングによってeGPUのような外部デバイスとの通信を可能にする。USB-Cと同じコネクタ形状だが、全く別の規格である点に注意が必要だ。

2.4 Metalとは

Metalは、Appleが開発したグラフィックスおよびGPUコンピューティングAPI（Application Programming Interface）だ。macOS、iOS、iPadOSで動作し、Apple Silicon GPUとAMD GPUをサポートする。CUDAの代替として機能するが、NVIDIAとの互換性は一切ない。

これらの用語が押さえられたら、次に進もう。

3. eGPUが生まれた背景—そしてAppleとNVIDIAの決裂

3.1 eGPUの誕生と普及

eGPUの概念自体は2000年代から存在したが、一般に普及したのはThunderbolt 3が登場した2015年以降だ。Appleは2017年のWWDCでeGPUサポートを正式発表し、macOS High Sierra 10.13.4からIntel Mac + AMD GPUの組み合わせを公式サポートした。

当時、MacBook Proのグラフィックス性能に不満を持つクリエイターやゲーマーにとって、eGPUは救世主だった。

3.2 AppleとNVIDIAの蜜月時代

実は、AppleとNVIDIAにはかつて良好な関係があった。2001年、Macintoshは世界で初めてGeForce 3を搭載したプラットフォームだった。2008年のMacBook Proには、NVIDIA製チップセットが採用され、グラフィックス性能の飛躍的向上に貢献した。

3.3 決裂の始まり—ハンダ問題と訴訟

2008年、NVIDIAのGPUに使用された鉛フリーハンダに起因する不良が発生し、大量のMacBook Proが故障した。Appleはリコール対応を強いられ、両社の関係は急速に冷え込んだ。

その後、AppleはGPUの調達先をAMDに切り替え始めた。公式には「AMDの方が電力効率が良い」とされたが、業界ではNVIDIAとの確執が主因と見られている。

3.4 macOS MojaveでのNVIDIAドライバ排除

2018年、macOS Mojave（10.14）がリリースされた際、AppleはNVIDIA Web Driverの署名を拒否した。これにより、サードパーティのNVIDIA GPUはmacOS Mojave以降で完全に使用不能となった。

NVIDIAは自社フォーラムで「Appleがドライバの署名を承認しない」と公式に発表。両社の対立は決定的となった。

3.5 CUDA 10.2が最後のmacOSサポート

2019年11月、NVIDIAは「CUDA 10.2がmacOSをサポートする最後のバージョン」と発表した。これにより、macOSでCUDAを使う道は事実上閉ざされた。

"CUDA 10.2 (Toolkit and NVIDIA driver) is the last release to support macOS for developing and running CUDA applications."
— NVIDIA CUDA Toolkit Release Notes

背景がわかったところで、抽象的な概念から具体的な技術制約に話を進めよう。

4. MacでeGPU + CUDAを使えない3つの壁

4.1 壁①：Apple Silicon（M1/M2/M3/M4）はeGPUを完全に非サポート

Appleの公式サポートページには、明確にこう記載されている。

"To use an eGPU, a Mac with an Intel processor is required."
— Apple Support: Use an external graphics processor with your Mac

Apple Siliconは、CPU、GPU、Neural Engine、メモリを1つのSoC（System on a Chip）に統合したアーキテクチャだ。この統合設計により、外部GPUを追加する余地がアーキテクチャレベルで存在しない。

Mac種別 eGPUサポート
M1/M2/M3/M4 Mac 非対応
Intel Mac (Thunderbolt 3) 対応（AMDのみ）
Intel Mac (Thunderbolt 2以前) 非公式・要ハック

4.2 壁②：Intel MacでもNVIDIA GPUはmacOS Mojave以降で使用不可

仮にIntel Macを持っていても、NVIDIAのeGPUは使えない。理由は前述の通り、AppleがNVIDIA Web Driverの署名を拒否しているからだ。

macOSバージョン NVIDIA GPUサポート
High Sierra (10.13)以前 Web Driver経由で動作
Mojave (10.14)以降 完全に非対応

2026年現在、High Sierraはセキュリティアップデートも終了しており、実用的な選択肢ではない。

4.3 壁③：CUDAはNVIDIA専用—AMD GPUでは動作しない

「じゃあAMD GPUのeGPUを買えばいいのでは？」と思うかもしれない。

確かに、Intel Mac + AMD GPU（例：Radeon RX 6800）の組み合わせはmacOSで公式サポートされている。しかし、CUDAはNVIDIA独自技術であり、AMD GPUでは一切動作しない。

PyTorchやTensorFlowのcuda()や.to("cuda")は、NVIDIA GPUでのみ機能する。AMD GPUでは代わりにROCm（Radeon Open Compute）という別のスタックが必要だが、ROCmはmacOSをサポートしていない。

フレームワーク NVIDIA (CUDA) AMD (ROCm) Apple Silicon (Metal/MPS)
PyTorch 完全サポート Linux版のみ MPSバックエンド
TensorFlow 完全サポート Linux版のみ tensorflow-metal
JAX 完全サポート 実験的 jax-metal

ここまでで、MacでeGPU + CUDAが成立しない理由が明確になった。次は、実際にコードで自分の環境を確認してみよう。

5. 実際に確認してみよう—環境診断スクリプト

5.1 環境構築

以下の手順で診断環境を構築する。

# 仮想環境の作成（推奨）
python3 -m venv egpu-check
source egpu-check/bin/activate

# 必要なパッケージのインストール
pip install torch psutil

5.2 診断スクリプト

以下のスクリプトをコピーして実行すると、自分のMac環境でGPUが使えるかどうかを診断できる。

#!/usr/bin/env python3
"""
Mac GPU環境診断スクリプト
使い方: python check_gpu_environment.py
"""

import platform
import subprocess
import sys

def get_mac_chip_info():
    """Macのチップ情報を取得"""
    try:
        result = subprocess.run(
            ["sysctl", "-n", "machdep.cpu.brand_string"],
            capture_output=True,
            text=True
        )
        cpu_brand = result.stdout.strip()
        
        # Apple Silicon判定
        arch = platform.machine()
        is_apple_silicon = arch == "arm64"
        
        return {
            "cpu_brand": cpu_brand,
            "architecture": arch,
            "is_apple_silicon": is_apple_silicon
        }
    except Exception as e:
        return {"error": str(e)}

def check_cuda_availability():
    """CUDA利用可能性をチェック"""
    try:
        import torch
        cuda_available = torch.cuda.is_available()
        cuda_device_count = torch.cuda.device_count() if cuda_available else 0
        cuda_version = torch.version.cuda if cuda_available else None
        
        return {
            "cuda_available": cuda_available,
            "device_count": cuda_device_count,
            "cuda_version": cuda_version
        }
    except ImportError:
        return {"error": "PyTorch not installed"}

def check_mps_availability():
    """MPS (Metal Performance Shaders) 利用可能性をチェック"""
    try:
        import torch
        mps_available = torch.backends.mps.is_available()
        mps_built = torch.backends.mps.is_built()
        
        return {
            "mps_available": mps_available,
            "mps_built": mps_built
        }
    except ImportError:
        return {"error": "PyTorch not installed"}
    except AttributeError:
        return {"mps_available": False, "mps_built": False, "note": "PyTorch version too old"}

def check_egpu_possibility():
    """eGPU利用可能性を判定"""
    mac_info = get_mac_chip_info()
    
    if mac_info.get("is_apple_silicon"):
        return {
            "egpu_possible": False,
            "reason": "Apple Silicon MacはeGPUを一切サポートしていません",
            "recommendation": "MPS (Metal) バックエンドまたはMLXを使用してください"
        }
    else:
        return {
            "egpu_possible": True,
            "reason": "Intel MacはAMD GPUのeGPUをサポートしています",
            "warning": "ただしNVIDIA GPUはmacOS Mojave以降で使用できません",
            "recommendation": "CUDAが必要な場合はBoot Camp (Windows)の使用を検討してください"
        }

def main():
    print("=" * 60)
    print("Mac GPU環境診断レポート")
    print("=" * 60)
    
    # Mac情報
    print("\n【Macハードウェア情報】")
    mac_info = get_mac_chip_info()
    print(f"  CPU: {mac_info.get('cpu_brand', 'Unknown')}")
    print(f"  アーキテクチャ: {mac_info.get('architecture', 'Unknown')}")
    print(f"  Apple Silicon: {'はい' if mac_info.get('is_apple_silicon') else 'いいえ'}")
    
    # CUDA
    print("\n【CUDA (NVIDIA GPU) サポート】")
    cuda_info = check_cuda_availability()
    if "error" in cuda_info:
        print(f"  エラー: {cuda_info['error']}")
    else:
        print(f"  CUDA利用可能: {'はい' if cuda_info['cuda_available'] else 'いいえ'}")
        if cuda_info['cuda_available']:
            print(f"  CUDAバージョン: {cuda_info['cuda_version']}")
            print(f"  検出されたGPU数: {cuda_info['device_count']}")
    
    # MPS
    print("\n【MPS (Metal) サポート】")
    mps_info = check_mps_availability()
    if "error" in mps_info:
        print(f"  エラー: {mps_info['error']}")
    else:
        print(f"  MPS利用可能: {'はい' if mps_info['mps_available'] else 'いいえ'}")
        print(f"  MPSビルド済み: {'はい' if mps_info['mps_built'] else 'いいえ'}")
    
    # eGPU判定
    print("\n【eGPU利用可能性判定】")
    egpu_info = check_egpu_possibility()
    print(f"  eGPU利用可能: {'はい' if egpu_info['egpu_possible'] else 'いいえ'}")
    print(f"  理由: {egpu_info['reason']}")
    if egpu_info.get('warning'):
        print(f"  警告: {egpu_info['warning']}")
    print(f"  推奨: {egpu_info['recommendation']}")
    
    # 結論
    print("\n" + "=" * 60)
    print("【結論】")
    if mac_info.get("is_apple_silicon"):
        print("  あなたのMacはApple Siliconです。")
        print("  eGPU経由でのCUDA利用は不可能です。")
        print("  代替手段: MPS、MLX、クラウドGPU")
    else:
        print("  あなたのMacはIntel Macです。")
        print("  AMD eGPUは使用可能ですが、CUDAは使えません。")
        print("  代替手段: Boot Camp、クラウドGPU")
    print("=" * 60)

if __name__ == "__main__":
    main()

5.3 実行結果の例

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

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

【Macハードウェア情報】
  CPU: Apple M3 Pro
  アーキテクチャ: arm64
  Apple Silicon: はい

【CUDA (NVIDIA GPU) サポート】
  CUDA利用可能: いいえ

【MPS (Metal) サポート】
  MPS利用可能: はい
  MPSビルド済み: はい

【eGPU利用可能性判定】
  eGPU利用可能: いいえ
  理由: Apple Silicon MacはeGPUを一切サポートしていません
  推奨: MPS (Metal) バックエンドまたはMLXを使用してください

============================================================
【結論】
  あなたのMacはApple Siliconです。
  eGPU経由でのCUDA利用は不可能です。
  代替手段: MPS、MLX、クラウドGPU
============================================================

5.4 よくあるエラーと対処法

エラー 原因 対処法
ModuleNotFoundError: No module named 'torch' PyTorch未インストール pip install torch を実行
AttributeError: module 'torch.backends' has no attribute 'mps' PyTorchバージョンが古い pip install --upgrade torch を実行
MPS利用可能だがモデルが動かない macOSバージョンが古い macOS 12.3以上にアップグレード

基本的な環境確認ができたので、次は実践的なユースケースごとの代替手段を見ていこう。

6. ユースケース別ガイド—Macで機械学習をする現実的な方法

eGPU + CUDAが使えないことはわかった。では、Macユーザーはどうすればいいのか？ユースケース別に具体的な代替手段を紹介する。

6.1 ユースケース1：LLMのローカル推論（Ollama、llama.cpp）

想定読者: ローカルでLLMを動かしたい、プライバシーを重視する方

推奨構成: MLX + Ollama

Apple Siliconの統合メモリは、大規模モデルのロードに有利だ。M3 Maxの128GB RAMなら、量子化された70Bモデルもローカルで動作する。

環境設定ファイル（開発用）

# config.development.yaml - MLX-LM開発環境用
# このままコピーして使える設定ファイル

environment:
  name: "mlx-llm-dev"
  python_version: "3.11"

model:
  name: "mlx-community/Llama-3.2-3B-Instruct-4bit"
  quantization: "4bit"
  max_tokens: 2048
  temperature: 0.7

hardware:
  device: "mps"  # Apple Silicon GPU
  memory_limit_gb: 24  # 開発時は控えめに

logging:
  level: "DEBUG"
  file: "./logs/dev.log"

環境設定ファイル（本番用）

# config.production.yaml - MLX-LM本番環境用
# このままコピーして使える設定ファイル

environment:
  name: "mlx-llm-prod"
  python_version: "3.11"

model:
  name: "mlx-community/Llama-3.2-3B-Instruct-4bit"
  quantization: "4bit"
  max_tokens: 4096
  temperature: 0.3  # 安定性重視

hardware:
  device: "mps"
  memory_limit_gb: 64  # 本番はRAMをフル活用

logging:
  level: "INFO"
  file: "/var/log/mlx-llm/app.log"

環境設定ファイル（テスト用）

# config.test.yaml - MLX-LMテスト環境用
# CI/CDで使用する軽量設定

environment:
  name: "mlx-llm-test"
  python_version: "3.11"

model:
  name: "mlx-community/Llama-3.2-1B-Instruct-4bit"  # 軽量モデル
  quantization: "4bit"
  max_tokens: 256
  temperature: 0.0  # 再現性重視

hardware:
  device: "cpu"  # CI環境はCPUのみの場合も
  memory_limit_gb: 8

logging:
  level: "WARNING"
  file: "./test_logs/test.log"

サンプルコード

#!/usr/bin/env python3
"""
MLX-LMを使ったLLM推論サンプル
必要なパッケージ: pip install mlx-lm pyyaml
"""

import yaml
from pathlib import Path

def load_config(config_path: str = "config.development.yaml") -> dict:
    """設定ファイルを読み込む"""
    with open(config_path, "r") as f:
        return yaml.safe_load(f)

def run_inference(prompt: str, config: dict) -> str:
    """MLX-LMで推論を実行"""
    from mlx_lm import load, generate
    
    model_name = config["model"]["name"]
    max_tokens = config["model"]["max_tokens"]
    temperature = config["model"]["temperature"]
    
    print(f"モデルをロード中: {model_name}")
    model, tokenizer = load(model_name)
    
    print(f"推論実行中...")
    response = generate(
        model,
        tokenizer,
        prompt=prompt,
        max_tokens=max_tokens,
        temp=temperature
    )
    
    return response

def main():
    # 設定ファイルの読み込み
    config_path = Path("config.development.yaml")
    if not config_path.exists():
        print("設定ファイルが見つかりません。デフォルト設定を使用します。")
        config = {
            "model": {
                "name": "mlx-community/Llama-3.2-1B-Instruct-4bit",
                "max_tokens": 256,
                "temperature": 0.7
            }
        }
    else:
        config = load_config(str(config_path))
    
    # 推論実行
    prompt = "Pythonでフィボナッチ数列を生成する関数を書いてください。"
    response = run_inference(prompt, config)
    print(f"\n応答:\n{response}")

if __name__ == "__main__":
    main()

6.2 ユースケース2：PyTorchでのモデル訓練

想定読者: 自作モデルを訓練したい研究者・学生

推奨構成: PyTorch + MPS (Metal Performance Shaders)

PyTorch 1.12以降、MPSバックエンドが正式サポートされた。CUDAほどの性能は出ないが、CPUよりは大幅に高速だ。

サンプルコード

#!/usr/bin/env python3
"""
PyTorch MPS バックエンドでのモデル訓練サンプル
必要なパッケージ: pip install torch torchvision
"""

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

def get_device():
    """利用可能な最適なデバイスを取得"""
    if torch.cuda.is_available():
        return torch.device("cuda")
    elif torch.backends.mps.is_available():
        return torch.device("mps")
    else:
        return torch.device("cpu")

class SimpleCNN(nn.Module):
    """シンプルなCNNモデル"""
    def __init__(self, num_classes: int = 10):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 7 * 7, 128),
            nn.ReLU(),
            nn.Linear(128, num_classes),
        )
    
    def forward(self, x):
        x = self.features(x)
        x = self.classifier(x)
        return x

def train_one_epoch(model, dataloader, criterion, optimizer, device):
    """1エポックの訓練を実行"""
    model.train()
    total_loss = 0.0
    correct = 0
    total = 0
    
    for batch_idx, (data, target) in enumerate(dataloader):
        data, target = data.to(device), target.to(device)
        
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        
        total_loss += loss.item()
        _, predicted = output.max(1)
        total += target.size(0)
        correct += predicted.eq(target).sum().item()
        
        if batch_idx % 100 == 0:
            print(f"  Batch {batch_idx}: Loss={loss.item():.4f}")
    
    accuracy = 100.0 * correct / total
    avg_loss = total_loss / len(dataloader)
    return avg_loss, accuracy

def main():
    # デバイス設定
    device = get_device()
    print(f"使用デバイス: {device}")
    
    # データセット準備
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
    ])
    
    train_dataset = datasets.MNIST(
        root="./data",
        train=True,
        download=True,
        transform=transform
    )
    
    train_loader = DataLoader(
        train_dataset,
        batch_size=64,
        shuffle=True
    )
    
    # モデル、損失関数、オプティマイザの設定
    model = SimpleCNN().to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    
    # 訓練実行
    num_epochs = 3
    for epoch in range(num_epochs):
        print(f"\nEpoch {epoch + 1}/{num_epochs}")
        loss, accuracy = train_one_epoch(
            model, train_loader, criterion, optimizer, device
        )
        print(f"  平均損失: {loss:.4f}, 精度: {accuracy:.2f}%")
    
    # モデル保存
    torch.save(model.state_dict(), "model_mps.pth")
    print("\nモデルを保存しました: model_mps.pth")

if __name__ == "__main__":
    main()

6.3 ユースケース3：どうしてもCUDAが必要な場合

想定読者: 特定のCUDA専用ライブラリ（cuDNN、TensorRT等）が必須の方

推奨構成: クラウドGPU（AWS、GCP、Lambda Labs）

ローカルでCUDAが使えないなら、クラウドに頼るしかない。以下に主要なクラウドGPUサービスを比較する。

サービス GPU 時間単価目安 特徴
AWS EC2 (p4d.24xlarge) A100 x8 $32.77/h 大規模訓練向け
Google Colab Pro+ A100/V100 $49.99/月 手軽、Jupyter統合
Lambda Labs RTX 4090 $0.80/h コスパ良好
Paperspace RTX 4000 $0.45/h 低価格帯

サンプルコード（SSH経由でリモートGPUを使用）

#!/usr/bin/env python3
"""
リモートGPUサーバーでのジョブ実行スクリプト
必要なパッケージ: pip install paramiko
"""

import paramiko
import os
from pathlib import Path

def run_remote_training(
    host: str,
    username: str,
    key_path: str,
    script_path: str,
    remote_dir: str = "/home/ubuntu/training"
) -> str:
    """リモートサーバーで訓練スクリプトを実行"""
    
    # SSH接続
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    
    private_key = paramiko.RSAKey.from_private_key_file(key_path)
    ssh.connect(hostname=host, username=username, pkey=private_key)
    
    try:
        # スクリプトをアップロード
        sftp = ssh.open_sftp()
        remote_script = f"{remote_dir}/train.py"
        sftp.put(script_path, remote_script)
        sftp.close()
        
        # リモートで実行
        command = f"cd {remote_dir} && python train.py"
        stdin, stdout, stderr = ssh.exec_command(command)
        
        output = stdout.read().decode()
        errors = stderr.read().decode()
        
        if errors:
            print(f"Errors:\n{errors}")
        
        return output
        
    finally:
        ssh.close()

def main():
    # 設定（環境変数から読み込み）
    host = os.environ.get("GPU_SERVER_HOST", "gpu.example.com")
    username = os.environ.get("GPU_SERVER_USER", "ubuntu")
    key_path = os.environ.get("GPU_SERVER_KEY", "~/.ssh/id_rsa")
    
    print(f"リモートサーバーに接続: {username}@{host}")
    
    output = run_remote_training(
        host=host,
        username=username,
        key_path=os.path.expanduser(key_path),
        script_path="./train_cuda.py"
    )
    
    print(f"実行結果:\n{output}")

if __name__ == "__main__":
    main()

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

7. 学習ロードマップ

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

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

  1. PyTorch公式チュートリアル（MPS対応）を試す

  2. OllamaをインストールしてローカルLLMを体験

  3. Google Colabで無料GPUを使ってみる

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

  1. MLXフレームワークを本格的に学ぶ

  2. Hugging Face TransformersのMPS対応を活用

  3. AWS/GCPのGPUインスタンスを使いこなす

    • Spot Instanceを活用してコストを抑える技術を習得

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

  1. Metal Performance Shadersの内部実装を理解

  2. PyTorchのMPSバックエンドにコントリビュート

8. まとめ

この記事では、eGPUの概念と、MacユーザーがCUDAを使えない技術的・歴史的背景を解説した。

押さえるべきポイント

  1. Apple Silicon（M1/M2/M3/M4）はeGPUを一切サポートしない
  2. Intel MacでもNVIDIA GPUはmacOS Mojave以降で使用不可
  3. CUDAはNVIDIA専用技術。AMD GPUやApple Silicon GPUでは動作しない
  4. 代替手段はMPS、MLX、クラウドGPU

私の所感

正直なところ、「MacでCUDA」の組み合わせを夢見たユーザーの一人として、この現実は辛い。AppleとNVIDIAの確執は、技術的な問題というよりビジネス上の対立に起因しており、ユーザーが割を食っている形だ。

しかし、Apple SiliconのMPS/MLXエコシステムは急速に進化している。2024年のベンチマークでは、MLXがPyTorch MPSを多くの操作で上回り、一部の操作ではCUDA GPUに匹敵する性能を見せている。

「MacでCUDA」を諦めて、「MacでMetal」に軸足を移すのが、2026年現在の現実的な選択だろう。

eGPUを買う前にこの記事を読んでくれたあなたは、少なくとも無駄な出費を避けられたはずだ。その分の予算を、クラウドGPUの利用料や、Apple Silicon Macのメモリ増設に充ててほしい。

参考文献

8
7
3

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
Sign upLogin
8
7

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?