CUDAコアってなんだ？〜GPU並列処理の心臓部を完全理解〜

┌─────────────────────────────────────────────┐
│                CPU（8コアの例）              │
├─────────────────────────────────────────────┤
│  ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐           │
│  │Core1│ │Core2│ │Core3│ │Core4│           │
│  │     │ │     │ │     │ │     │           │
│  │複雑な│ │複雑な│ │複雑な│ │複雑な│           │
│  │命令OK│ │命令OK│ │命令OK│ │命令OK│           │
│  └─────┘ └─────┘ └─────┘ └─────┘           │
│  ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐           │
│  │Core5│ │Core6│ │Core7│ │Core8│           │
│  │     │ │     │ │     │ │     │           │
│  │分岐  │ │予測  │ │キャ │ │ッシュ│           │
│  │処理OK│ │処理OK│ │大容量│ │高速  │           │
│  └─────┘ └─────┘ └─────┘ └─────┘           │
└─────────────────────────────────────────────┘

特徴：
- コア数は少ない（4〜64個程度）
- 各コアが高性能で複雑な処理が可能
- 分岐予測、投機的実行など高度な機能
- 大容量キャッシュでメモリアクセスを高速化

┌─────────────────────────────────────────────────────────┐
│                GPU（数千CUDAコアの例）                    │
├─────────────────────────────────────────────────────────┤
│  ┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐     │
│  │C1││C2││C3││C4││C5││C6││C7││C8││C9││10││11││12│ ... │
│  └──┘└──┘└──┘└──┘└──┘└──┘└──┘└──┘└──┘└──┘└──┘└──┘     │
│  ┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐     │
│  │13││14││15││16││17││18││19││20││21││22││23││24│ ... │
│  └──┘└──┘└──┘└──┘└──┘└──┘└──┘└──┘└──┘└──┘└──┘└──┘     │
│                    × 数百行 = 数千コア                  │
└─────────────────────────────────────────────────────────┘

特徴：
- コア数が非常に多い（数千〜数万個）
- 各コアは単純な計算しかできない
- 同じ命令を大量のデータに適用（SIMT）
- 複雑な分岐処理は苦手

# CPUでの処理イメージ（逐次処理）
for i in range(10000):
    result[i] = a[i] + b[i]  # 1つずつ順番に計算

# GPUでの処理イメージ（並列処理）
# 10000個のCUDAコアが一斉に「a[自分の担当] + b[自分の担当]」を計算
# → 1回の命令で10000個の計算が完了

┌─────────────────────────────────────────────┐
│              Streaming Multiprocessor (SM)   │
├─────────────────────────────────────────────┤
│  ┌──────────────────────────────────────┐   │
│  │         Warp 0（32スレッド）          │   │
│  │  Thread 0-31 が同じ命令を同時実行     │   │
│  └──────────────────────────────────────┘   │
│  ┌──────────────────────────────────────┐   │
│  │         Warp 1（32スレッド）          │   │
│  │  Thread 32-63 が同じ命令を同時実行    │   │
│  └──────────────────────────────────────┘   │
│              ... 多数のWarp ...             │
└─────────────────────────────────────────────┘

# ニューラルネットワークの基本演算
output = weight_matrix @ input_vector + bias
# これは「掛け算して足す」の繰り返し

# 例：1000×1000の行列同士の掛け算
# = 1,000,000回の「掛けて足す」演算
# CPUで逐次実行：1,000,000ステップ
# GPUで並列実行：数千ステップ（CUDAコア数に依存）

"""
CUDA処理フローの概念図（擬似コード）
実際のCUDAプログラミングではC++を使うことが多いですが、
ここではPythonライクな擬似コードで説明します
"""

# Step 1: CPUからGPUへデータを転送
gpu_data_a = transfer_to_gpu(host_data_a)
gpu_data_b = transfer_to_gpu(host_data_b)

# Step 2: GPU上で並列計算を実行
# → 数千のCUDAコアが一斉に動く
gpu_result = gpu_add_kernel(gpu_data_a, gpu_data_b)

# Step 3: GPUからCPUへ結果を転送
host_result = transfer_to_cpu(gpu_result)

"""
PyTorchでGPUを使う実際のコード例
必要なパッケージ: pip install torch
"""
import torch

# GPUが使えるか確認
print(f"CUDA available: {torch.cuda.is_available()}")
print(f"CUDA device count: {torch.cuda.device_count()}")
if torch.cuda.is_available():
    print(f"CUDA device name: {torch.cuda.get_device_name(0)}")

# データをGPUに転送
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# CPU上でテンソルを作成
a = torch.randn(10000, 10000)
b = torch.randn(10000, 10000)

# GPUに転送（ここでCUDAコアが使える状態になる）
a_gpu = a.to(device)
b_gpu = b.to(device)

# GPUで行列演算（CUDAコアが並列で計算）
result_gpu = torch.matmul(a_gpu, b_gpu)

# 結果をCPUに戻す
result_cpu = result_gpu.to("cpu")

print(f"Result shape: {result_cpu.shape}")

CUDA available: True
CUDA device count: 1
CUDA device name: NVIDIA GeForce RTX 4090
Result shape: torch.Size([10000, 10000])

# Ollamaのインストール（Linux）
curl -fsSL https://ollama.ai/install.sh | sh

# モデルのダウンロードと実行
ollama run llama3.2:3b

# GPU使用状況の確認（別ターミナルで）
nvidia-smi

# 期待される出力例：
# GPU Memory Usage: 3GB / 24GB
# GPU Utilization: 80%

"""
OllamaをPythonから呼び出す例
必要なパッケージ: pip install ollama
"""
import ollama

response = ollama.chat(model='llama3.2:3b', messages=[
    {
        'role': 'user',
        'content': 'CUDAコアって何ですか？簡潔に教えてください。'
    }
])

print(response['message']['content'])

"""
Stable Diffusionで画像を生成する例
必要なパッケージ: pip install diffusers transformers accelerate torch
"""
from diffusers import StableDiffusionPipeline
import torch

# パイプラインの初期化（CUDA使用）
pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16  # FP16で VRAM節約
)
pipe = pipe.to("cuda")  # CUDAコアを使用

# 画像生成
prompt = "a beautiful sunset over mountains, digital art"
image = pipe(prompt, num_inference_steps=30).images[0]

# 保存
image.save("generated_image.png")
print("Image saved!")

"""
簡単なニューラルネットワークの学習例
必要なパッケージ: 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

# デバイス設定
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")

# シンプルなモデル定義
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 256)
        self.fc2 = nn.Linear(256, 10)
    
    def forward(self, x):
        x = x.view(-1, 784)
        x = torch.relu(self.fc1(x))
        return self.fc2(x)

# モデルをGPUに転送
model = SimpleNet().to(device)

# 学習ループ（簡略版）
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

# MNISTデータセットで学習
transform = transforms.ToTensor()
train_data = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(train_data, batch_size=64, shuffle=True)

# 1エポックの学習
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
    data, target = data.to(device), target.to(device)
    optimizer.zero_grad()
    output = model(data)
    loss = criterion(output, target)
    loss.backward()
    optimizer.step()
    
    if batch_idx % 100 == 0:
        print(f"Batch {batch_idx}, Loss: {loss.item():.4f}")

print("Training complete!")