# Ubuntu セットアップ

cursor.html 用
docker stop ubuntu
docker rm ubuntu
docker run --cap-add=SYS_ADMIN --device=/dev/fuse --security-opt apparmor:unconfined -e DISPLAY=host.docker.internal:0.0 -it --name ubuntu ubuntu:24.04 /bin/bash


# 再開したいときはdocker start ubuntu && docker exec -it ubuntu /bin/bash

# Dockerコンテナ環境で「sudoコマンドがインストールされていない場合」にsudoをインストールする（rootユーザとしての実行を前提とする）
if [ -f /.dockerenv ]; then
    if ! command -v sudo &> /dev/null; then
        apt-get update && apt-get install -y sudo
        which sudo > /dev/null 2>&1 || { echo "sudo installation failed"; exit 1; }
    fi
fi

# 環境変数の設定
echo 'PATH=/opt/conda/bin:$PATH' | sudo tee -a /etc/environment
echo 'SHELL=/bin/bash' | sudo tee -a /etc/environment
echo 'TZ=Asia/Tokyo' | sudo tee -a /etc/environment
source /etc/environment

# タイムゾーンの設定
sudo apt-get install -y apt-utils debconf && \
sudo ln -sf /usr/share/zoneinfo/Asia/Tokyo /etc/localtime && \
echo "Asia/Tokyo" | sudo tee /etc/timezone && \
sudo DEBIAN_FRONTEND=noninteractive apt-get install -y tzdata && \
sudo dpkg-reconfigure -f noninteractive tzdata

-----

docker stop ubuntu
docker rm ubuntu
docker run --name ubuntu -it ubuntu:24.04 /bin/bash
docker run --cap-add=SYS_ADMIN --device=/dev/fuse --security-opt apparmor:unconfined --no-sandbox --name ubuntu -it ubuntu:24.04 /bin/bash

# 環境変数の設定
echo 'PATH=/opt/conda/bin:$PATH' | sudo tee -a /etc/environment
echo 'SHELL=/bin/bash' | sudo tee -a /etc/environment
echo 'TZ=Asia/Tokyo' | sudo tee -a /etc/environment
source /etc/environment

# Dockerコンテナ環境で「sudoコマンドがインストールされていない場合」にsudoをインストールする（rootユーザとしての実行を前提とする）
if [ -f /.dockerenv ]; then
    if ! command -v sudo &> /dev/null; then
        apt-get update && apt-get install -y sudo
        which sudo > /dev/null 2>&1 || { echo "sudo installation failed"; exit 1; }
    fi
fi

# システムの更新
sudo apt-get update && sudo apt-get upgrade -y

# タイムゾーンの設定
sudo apt-get install -y apt-utils debconf && \
sudo ln -sf /usr/share/zoneinfo/Asia/Tokyo /etc/localtime && \
echo "Asia/Tokyo" | sudo tee /etc/timezone && \
sudo DEBIAN_FRONTEND=noninteractive apt-get install -y tzdata && \
sudo dpkg-reconfigure -f noninteractive tzdata

# システムパッケージのインストール
sudo apt-get install -y python3 python3-pip python3-dev wget curl git cmake gnupg software-properties-common build-essential

# Miniconda3のインストール
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh && \
    sudo bash Miniconda3-latest-Linux-x86_64.sh -b -p /opt/conda && \
    rm Miniconda3-latest-Linux-x86_64.sh

# ユーザ設定として、condaの初期設定とdev環境の作成
/opt/conda/bin/conda init bash
# 現在のシェルでcondaコマンドを有効化
echo ". /opt/conda/etc/profile.d/conda.sh" | tee -a ~/.bashrc ~/.bash_profile
echo "conda activate dev" | tee -a ~/.bashrc ~/.bash_profile
source ~/.bashrc || source ~/.bash_profile
# .bashrcへの設定追加（重複防止）
grep -q ". /opt/conda/etc/profile.d/conda.sh" ~/.bashrc || echo ". /opt/conda/etc/profile.d/conda.sh" >> ~/.bashrc
# 開発環境の作成
conda create -n dev python=3.12 -y
# パッケージのインストール
conda install -n dev -y numpy pandas matplotlib scikit-learn jupyter pylint pytest black
# 自動アクティベーション設定（重複防止）
grep -q "conda activate dev" ~/.bashrc || echo "conda activate dev" >> ~/.bashrc
# 現在のシェルで環境をアクティベート
conda activate dev

# ユーザ設定としてJupyterの設定
mkdir -p ~/.jupyter && \
    /opt/conda/envs/dev/bin/jupyter notebook --generate-config && \
    echo "c.NotebookApp.ip = '*'" >> ~/.jupyter/jupyter_notebook_config.py && \
    echo "c.NotebookApp.port = 8888" >> ~/.jupyter/jupyter_notebook_config.py && \
    echo "c.NotebookApp.allow_root = True" >> ~/.jupyter/jupyter_notebook_config.py

# Docker コンテナ環境でない場合に限り、UFW (Uncomplicated Firewall) をインストールして有効化
if [ ! -f /.dockerenv ]; then
    sudo apt-get -y install ufw
    sudo ufw enable
fi

# Docker コンテナ環境でない場合に限り、推奨ドライバのインストール
if [ ! -f /.dockerenv ]; then
    sudo apt install -y ubuntu-drivers-common
    sudo ubuntu-drivers autoinstall
    if ubuntu-drivers devices 2>/dev/null | grep -i nvidia > /dev/null; then
        echo "NVIDIA GPU detected by ubuntu-drivers"
        export ISNVIDIAGPU=True
    else
        echo "No NVIDIA GPU recognized by ubuntu-drivers"
        export ISNVIDIAGPU=False
    fi
fi


# Ubuntu 用のCUDAサポートパッケージと NVIDIA cuDNN をインストール
sudo apt-get update
sudo apt-get install -y nvidia-cuda-toolkit nvidia-cudnn

# NCCL (NVIDIA Collective Communications Library)，NVIDIA Performance Primitives インストール (マルチGPU性能最適化)
sudo add-apt-repository -y ppa:graphics-drivers/ppa
sudo apt-get update
sudo apt-get install -y libnccl2 libnccl-dev libnvjpeg-dev


# GPU性能最適化のための環境変数
export CUDA_DEVICE_ORDER=PCI_BUS_ID
export CUDA_CACHE_DISABLE=0
export CUDA_AUTO_BOOST=1
export CUDA_MODULE_LOADING=LAZY
echo "export CUDA_DEVICE_ORDER=PCI_BUS_ID" >> ~/.bashrc
echo "export CUDA_CACHE_DISABLE=0" >> ~/.bashrc
echo "export CUDA_AUTO_BOOST=1" >> ~/.bashrc
echo "export CUDA_MODULE_LOADING=LAZY" >> ~/.bashrc

# NVIDIA CUDA バージョンの取得と変換
if command -v nvcc &> /dev/null; then
    CUDAVER=$(nvcc --version | grep "release" | awk '{print $6}' | tr -d ',' | tr -d '.')
    echo "Detected CUDA Version: $CUDAVER"
else
    echo "nvcc not found, assuming no CUDA support."
    CUDAVER="CPU"
fi

# PyTorch のインストール
if [[ "$CUDAVER" =~ ^[0-9]+$ ]]; then
    echo "Attempting to install PyTorch for CUDA $CUDAVER"

    # 一度 CPU バージョンをインストールし、利用可能な CUDA バージョンを取得
    python3 -m pip install --no-cache-dir torch
    AVAILABLE_CUDA=$(python3 -c "import torch; print(torch.version.cuda.replace('.', '')) if torch.cuda.is_available() else 'CPU'")

    if [[ "$AVAILABLE_CUDA" =~ ^[0-9]+$ ]]; then
        echo "Detected compatible PyTorch CUDA version: $AVAILABLE_CUDA"
        python3 -m pip install --no-cache-dir torch torchvision torchaudio --index-url "https://download.pytorch.org/whl/cu$AVAILABLE_CUDA"
    else
        echo "No compatible CUDA version detected. Installing CPU version."
        python3 -m pip install --no-cache-dir torch torchvision torchaudio
    fi
else
    echo "No valid CUDA version detected. Installing CPU version of PyTorch."
    python3 -m pip install --no-cache-dir torch torchvision torchaudio
fi

# 追加ライブラリ
python3 -m pip install --no-cache-dir numpy pandas matplotlib seaborn
python3 -m pip install --no-cache-dir psutil

# ディストリビューション ID を取得
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
echo "distribution:"
echo $distribution



# Jupyter 起動テスト
/opt/conda/envs/dev/bin/jupyter notebook --ip=* --port=8888



psp
----------------------------------------------------------

# Windows環境でWSL2+Dockerを使用したGPU性能比較の設定手順

## 1. 前提条件
- Windows 10/11
- WSL2インストール済み
- Docker Desktop for Windowsインストール済み
- NVIDIAグラフィックドライバーインストール済み

## 2. Docker Desktopの設定

### 2.1 Docker DesktopでWSL2統合を有効化
1. Docker Desktopを開く
2. 「設定」 > 「リソース」 > 「WSL統合」を選択
3. 「Ubuntu-24.04」(または使用するWSL2ディストリビューション)を有効化
4. 「Apply & Restart」をクリック

### 2.2 Docker DesktopでGPUサポートを有効化
Docker EngineにNVIDIA GPUサポートを追加する：
```json
{
  "features": {"buildkit": true},
  "experimental": true,
  "runtimes": {
    "nvidia": {
      "path": "nvidia-container-runtime",
      "runtimeArgs": []
    }
  }
}
```
Docker Desktopの設定画面から手動で設定する：
1. Docker Desktopを開く
2. 「設定」 > 「Docker Engine」を選択
3. JSONを編集して上記の設定を追加
4. 「Apply & Restart」をクリック

### 2.3 NVIDIAコンテナランタイムの確認
Docker内でGPUを利用できるか確認する．nvidia/cuda:12.2.0-base-ubuntu24.04イメージを使用する．--rmオプションを指定しており，コマンド実行後に，コンテナは自動消去される．

```bash
# NVIDIAコンテナランタイムのテスト
docker run --rm --gpus all nvidia/cuda:12.2.0-base-ubuntu24.04 nvidia-smi
```

## 3. CUDA環境の確認

CUDAとcuDNNが正しく設定されているか確認するために、以下のスクリプトを実行します：

```bash
# cuda-check.sh という名前でファイルを作成
cat > ~/cuda-check.sh << 'EOL'
#!/bin/bash

echo "==== NVIDIA GPU / CUDA / cuDNN 環境チェック ===="

echo -e "\n1. GPUドライバーチェック"
if command -v nvidia-smi &> /dev/null; then
    nvidia-smi
    echo -e "\nGPU詳細情報:"
    nvidia-smi -q | grep "Product Name\|CUDA Version\|Driver Version"
else
    echo "エラー: nvidia-smiが見つかりません。NVIDIAドライバーがインストールされているか確認してください。"
fi


echo -e "\n2. CUDA環境チェック"
if command -v nvcc &> /dev/null; then
    nvcc --version
else
    echo "エラー: nvccが見つかりません。CUDA Toolkitがインストールされているか確認してください。"
fi

echo -e "\n3. cuDNN確認"
if [ -f /usr/include/cudnn.h ]; then
    grep CUDNN_MAJOR -A 2 /usr/include/cudnn.h
elif [ -f /usr/local/cuda/include/cudnn.h ]; then
    grep CUDNN_MAJOR -A 2 /usr/local/cuda/include/cudnn.h
else
    echo "エラー: cudnn.hが見つかりません。cuDNNがインストールされているか確認してください。"
fi

echo -e "\n4. パス設定確認"
echo "LD_LIBRARY_PATH: $LD_LIBRARY_PATH"
echo "PATH: $PATH"

echo -e "\n5. システム情報"
uname -a
lscpu | grep "Model name"
free -h
EOL

# 実行権限を付与して実行
chmod +x ~/cuda-check.sh
~/cuda-check.sh
```

## 4. プロジェクトの設定

### 4.1 Dockerfileの作成
以下のコマンドを実行して，Dockerfileを作成する：

```bash
cat > Dockerfile << 'EOF'
FROM ubuntu:24.04

# タイムゾーン設定の回避
ENV DEBIAN_FRONTEND=noninteractive
ENV TZ=Asia/Tokyo

# 必要なパッケージのインストール
RUN apt-get update && apt-get install -y \
    python3 \
    python3-pip \
    python3-dev \
    curl \
    git \
    wget \
    gnupg \
    software-properties-common \
    && rm -rf /var/lib/apt/lists/*

# NVIDIA GPGキーとリポジトリの設定
RUN curl -fsSL https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/3bf863cc.pub | gpg --dearmor -o /usr/share/keyrings/nvidia-archive-keyring.gpg
RUN echo "deb [signed-by=/usr/share/keyrings/nvidia-archive-keyring.gpg] https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/ /" > /etc/apt/sources.list.d/nvidia-cuda.list

# NVIDIAドライバとCUDAのインストール (パフォーマンス最適化のために完全なツールキットをインストール)
RUN apt-get update && apt-get install -y \
    cuda-toolkit-12-2 \
    && rm -rf /var/lib/apt/lists/*

# cuDNNのインストール (ディープラーニング性能向上のため)
RUN apt-get update && apt-get install -y \
    libcudnn8 \
    libcudnn8-dev \
    && rm -rf /var/lib/apt/lists/*

# NCCL (NVIDIA Collective Communications Library) インストール (マルチGPU性能最適化)
RUN apt-get update && apt-get install -y \
    libnccl2 \
    libnccl-dev \
    && rm -rf /var/lib/apt/lists/*

# NVIDIA Performance Primitives
RUN apt-get update && apt-get install -y \
    libnvjpeg-dev \
    && rm -rf /var/lib/apt/lists/*

# 環境変数の設定 (パフォーマンス最適化のためのフラグ)
ENV PATH=/usr/local/cuda/bin:${PATH}
ENV LD_LIBRARY_PATH=/usr/local/cuda/lib64:${LD_LIBRARY_PATH}
# GPU性能最適化のための環境変数
ENV CUDA_DEVICE_ORDER=PCI_BUS_ID
ENV CUDA_CACHE_DISABLE=0
ENV CUDA_AUTO_BOOST=1
ENV CUDA_MODULE_LOADING=LAZY

# PyTorchとその依存関係のインストール (CUDA 12.1に最適化されたバージョン)
RUN pip3 install --no-cache-dir -U pip
RUN pip3 install --no-cache-dir torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# 性能計測用の追加ライブラリ
RUN pip3 install --no-cache-dir numpy pandas matplotlib seaborn
RUN pip3 install --no-cache-dir psutil

# 作業ディレクトリの作成
WORKDIR /app

# アプリケーションのコピー
COPY . /app/
EOF

# GPU-CPU性能比較スクリプトを作成
cat > gpu_cpu_comparison.py << 'EOF'
import torch
import time
import numpy as np

def compare_performance(operation_name, operation_fn, sizes, iterations=10, warmup_iterations=3):
    """
    指定された操作をCPUとGPUで実行し、性能を比較します。

    Args:
        operation_name: 操作の名前
        operation_fn: 実行する操作の関数（入力テンソル、デバイスを引数に取る）
        sizes: テストする入力サイズのリスト
        iterations: 各テストを実行する回数（平均を取るため）
        warmup_iterations: ウォームアップ実行の回数
    """
    print(f"\n===== {operation_name} の性能比較 =====")

    # GPUが利用可能かチェック
    if torch.cuda.is_available():
        print(f"GPU情報: {torch.cuda.get_device_name()}")
        device_gpu = torch.device("cuda")

        # GPUメモリ使用量の確認
        torch.cuda.empty_cache()
        gpu_mem_alloc_start = torch.cuda.memory_allocated(0)
        print(f"初期GPU使用メモリ: {gpu_mem_alloc_start / 1024 / 1024:.2f} MB")
    else:
        print("警告: GPUが利用できません。CPUのみで実行します。")
        device_gpu = None

    device_cpu = torch.device("cpu")

    results = []

    for size in sizes:
        print(f"\nサイズ: {size}")

        # CPU実行時間
        # まずウォームアップ実行
        for i in range(warmup_iterations):
            operation_fn(size, device_cpu)

        # 実際の計測
        cpu_times = []
        for i in range(iterations):
            torch.cuda.synchronize() if torch.cuda.is_available() else None
            start_time = time.time()
            result = operation_fn(size, device_cpu)
            torch.cuda.synchronize() if torch.cuda.is_available() else None
            end_time = time.time()
            cpu_times.append(end_time - start_time)

        avg_cpu_time = sum(cpu_times) / len(cpu_times)
        std_cpu_time = np.std(cpu_times)
        print(f"CPU 平均実行時間: {avg_cpu_time:.6f} 秒 (標準偏差: {std_cpu_time:.6f})")

        # GPU実行時間（利用可能な場合）
        gpu_times = []
        avg_gpu_time = None
        std_gpu_time = None
        speedup = None
        gpu_mem_used = None

        if device_gpu is not None:
            # GPUキャッシュのクリア
            torch.cuda.empty_cache()

            # GPU準備のための初回実行（ウォームアップ）
            for i in range(warmup_iterations):
                operation_fn(size, device_gpu)

            # メモリ使用量の確認
            gpu_mem_alloc_before = torch.cuda.memory_allocated(0)

            # 実際の計測
            for i in range(iterations):
                torch.cuda.synchronize()
                start_time = time.time()
                result = operation_fn(size, device_gpu)
                torch.cuda.synchronize()  # GPUの計算が完了するのを待つ
                end_time = time.time()
                gpu_times.append(end_time - start_time)

            # GPUメモリ使用量
            gpu_mem_alloc_after = torch.cuda.memory_allocated(0)
            gpu_mem_used = (gpu_mem_alloc_after - gpu_mem_alloc_before) / 1024 / 1024  # MB単位

            avg_gpu_time = sum(gpu_times) / len(gpu_times)
            std_gpu_time = np.std(gpu_times)
            print(f"GPU 平均実行時間: {avg_gpu_time:.6f} 秒 (標準偏差: {std_gpu_time:.6f})")
            print(f"GPU メモリ使用量: {gpu_mem_used:.2f} MB")

            # 速度向上率
            speedup = avg_cpu_time / avg_gpu_time
            print(f"速度向上率 (CPU時間/GPU時間): {speedup:.2f}倍")

        # 結果の記録
        results.append({
            "操作": operation_name,
            "サイズ": size,
            "CPU時間(秒)": avg_cpu_time,
            "CPU標準偏差": std_cpu_time,
            "GPU時間(秒)": avg_gpu_time,
            "GPU標準偏差": std_gpu_time,
            "速度向上率": speedup,
            "GPUメモリ使用(MB)": gpu_mem_used
        })

    return results

# テスト用の操作関数
def matrix_multiplication(size, device):
    """行列の乗算操作 (FP32)"""
    matrix1 = torch.randn(size, size, device=device)
    matrix2 = torch.randn(size, size, device=device)
    result = torch.matmul(matrix1, matrix2)
    return result

def matrix_multiplication_fp16(size, device):
    """行列の乗算操作 (FP16 - 半精度浮動小数点)"""
    if device.type == "cuda":
        matrix1 = torch.randn(size, size, dtype=torch.float16, device=device)
        matrix2 = torch.randn(size, size, dtype=torch.float16, device=device)
        result = torch.matmul(matrix1, matrix2)
    else:
        # CPUでは普通のFP32で実行
        matrix1 = torch.randn(size, size, device=device)
        matrix2 = torch.randn(size, size, device=device)
        result = torch.matmul(matrix1, matrix2)
    return result

def matrix_addition(size, device):
    """行列の加算操作"""
    matrix1 = torch.randn(size, size, device=device)
    matrix2 = torch.randn(size, size, device=device)
    result = matrix1 + matrix2
    return result

def neural_network_forward(size, device):
    """ニューラルネットワークの順伝播"""
    # 簡易的なニューラルネットワークを作成
    model = torch.nn.Sequential(
        torch.nn.Linear(size, size * 2),
        torch.nn.ReLU(),
        torch.nn.Linear(size * 2, size)
    ).to(device)

    # 入力データ
    input_data = torch.randn(100, size, device=device)

    # 順伝播
    output = model(input_data)
    return output

def convolution_operation(size, device):
    """畳み込み操作"""
    # 入力データを作成 (バッチサイズ=10, チャネル=3, 高さ=サイズ, 幅=サイズ)
    input_data = torch.randn(10, 3, size, size, device=device)

    # 畳み込み層を作成
    conv_layer = torch.nn.Conv2d(
        in_channels=3,
        out_channels=16,
        kernel_size=3,
        padding=1
    ).to(device)

    # 順伝播
    output = conv_layer(input_data)
    return output

def batch_matrix_multiplication(size, device):
    """バッチ行列乗算"""
    batch_size = 32
    matrix1 = torch.randn(batch_size, size, size, device=device)
    matrix2 = torch.randn(batch_size, size, size, device=device)
    result = torch.bmm(matrix1, matrix2)
    return result

# メイン実行部分
if __name__ == "__main__":
    print("==== GPU対CPU性能比較テスト ====")
    print("PyTorch バージョン:", torch.__version__)
    print("CUDA 利用可能:", torch.cuda.is_available())
    if torch.cuda.is_available():
        print("CUDA バージョン:", torch.version.cuda)
        for i in range(torch.cuda.device_count()):
            print(f"GPU {i}: {torch.cuda.get_device_name(i)}")
            print(f"GPU {i} メモリ総量: {torch.cuda.get_device_properties(i).total_memory / 1024 / 1024 / 1024:.2f} GB")

        # cudnnの確認
        print(f"cuDNN バージョン: {torch.backends.cudnn.version()}")
        print(f"cuDNN enabled: {torch.backends.cudnn.enabled}")
        print(f"cuDNN deterministic: {torch.backends.cudnn.deterministic}")
        print(f"cuDNN benchmark: {torch.backends.cudnn.benchmark}")

        # cudnnの設定を最適化
        torch.backends.cudnn.enabled = True
        torch.backends.cudnn.benchmark = True
        print("\ncuDNN benchmarkモードを有効化しました (畳み込み操作の速度が向上します)")
    else:
        print("警告: GPUが検出されませんでした。ドライバーとCUDAの設定を確認してください。")

    # システム情報
    print("\n==== システム情報 ====")
    import platform
    import psutil
    print(f"OS: {platform.platform()}")
    print(f"Python: {platform.python_version()}")
    print(f"CPU: {platform.processor()}")
    print(f"物理コア数: {psutil.cpu_count(logical=False)}")
    print(f"論理コア数: {psutil.cpu_count(logical=True)}")
    print(f"合計メモリ: {psutil.virtual_memory().total / 1024 / 1024 / 1024:.2f} GB")

    # 結果を格納するリスト
    all_results = []

    # 様々なサイズでテスト
    small_test_sizes = [128, 256, 512]
    medium_test_sizes = [1024, 2048]  # 大きなサイズの場合は必要に応じて調整

    # 行列乗算のテスト (FP32)
    results = compare_performance("行列乗算 (FP32)", matrix_multiplication, small_test_sizes)
    all_results.extend(results)

    # GPU対応の場合、FP16(半精度)でのテスト
    if torch.cuda.is_available():
        results = compare_performance("行列乗算 (FP16 - 半精度)", matrix_multiplication_fp16, small_test_sizes)
        all_results.extend(results)

    # 行列加算のテスト
    results = compare_performance("行列加算", matrix_addition, small_test_sizes)
    all_results.extend(results)

    # バッチ行列乗算のテスト
    results = compare_performance("バッチ行列乗算", batch_matrix_multiplication, small_test_sizes)
    all_results.extend(results)

    # ニューラルネットワークのテスト
    results = compare_performance("ニューラルネットワーク順伝播", neural_network_forward, [128, 256, 512])
    all_results.extend(results)

    # 畳み込み操作のテスト
    results = compare_performance("畳み込み操作", convolution_operation, [64, 128, 256])
    all_results.extend(results)

    # 結果の表示
    print("\n==== 性能比較結果サマリー ====")
    import pandas as pd
    df = pd.DataFrame(all_results)
    pd.set_option("display.max_rows", None)
    pd.set_option("display.width", 200)
    print(df)

    print("\n==== テスト完了 ====")
    print("問題がある場合は以下を確認してください:")
    print("1. nvidia-smiが正常に動作するか")
    print("2. CUDAとPyTorchのバージョンが互換性があるか")
    print("3. Dockerに適切なGPUフラグが設定されているか")
    print("4. cuDNNが正しくインストールされているか")

    # ハードウェア使用率の表示
    print("\n現在のシステムリソース使用状況:")
    print(f"CPU使用率: {psutil.cpu_percent(interval=1)}%")
    print(f"メモリ使用率: {psutil.virtual_memory().percent}%")
    if torch.cuda.is_available():
        for i in range(torch.cuda.device_count()):
            gpu_util = torch.cuda.utilization(i)
            gpu_mem = torch.cuda.memory_allocated(i) / torch.cuda.get_device_properties(i).total_memory * 100
            print(f"GPU {i} 使用率: {gpu_util}%")
            print(f"GPU {i} メモリ使用率: {gpu_mem:.2f}%")
EOF

# 診断用スクリプトを作成
cat > check_cuda_env.sh << 'EOF'
#!/bin/bash
echo "==== Docker コンテナ内 CUDA/GPU 環境チェック ===="

echo -e "\n1. システム情報:"
uname -a
lscpu | grep "Model name"

echo -e "\n2. NVIDIA ドライバー情報:"
if command -v nvidia-smi &> /dev/null; then
    nvidia-smi
else
    echo "警告: nvidia-smiが見つかりません。NVIDIAドライバーがホスト側で適切に設定されているか確認してください。"
fi

echo -e "\n3. CUDA バージョン:"
if command -v nvcc &> /dev/null; then
    nvcc --version
else
    echo "警告: nvccが見つかりません。CUDA Toolkitが正しくインストールされているか確認してください。"
fi

echo -e "\n4. cuDNN バージョン:"
if [ -f /usr/include/cudnn.h ]; then
    grep CUDNN_MAJOR -A 2 /usr/include/cudnn.h
elif [ -f /usr/local/cuda/include/cudnn.h ]; then
    grep CUDNN_MAJOR -A 2 /usr/local/cuda/include/cudnn.h
else
    echo "警告: cudnn.hが見つかりません。cuDNNが正しくインストールされているか確認してください。"
fi

echo -e "\n5. Python & PyTorch 情報:"
python3 -c "import torch; print(\"PyTorch バージョン:\", torch.__version__, \"\nCUDA 利用可能:\", torch.cuda.is_available(), \"\nCUDA バージョン:\", torch.version.cuda if torch.cuda.is_available() else \"N/A\", \"\ncuDNN バージョン:\", torch.backends.cudnn.version() if torch.cuda.is_available() else \"N/A\")"

echo -e "\n6. 環境変数:"
echo "PATH=$PATH"
echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH"

echo -e "\n7. CUDA ライブラリ:"
if [ -d /usr/local/cuda/lib64/ ]; then
    ls -la /usr/local/cuda/lib64/ | grep -E "libcudnn|libnccl"
else
    echo "警告: CUDA ライブラリディレクトリが見つかりません。"
fi

echo -e "\n8. GPU計算能力の確認:"
python3 -c "import torch; [print(f\"GPU {i}: {torch.cuda.get_device_name(i)}, Compute Capability: {torch.cuda.get_device_capability(i)}, Memory: {torch.cuda.get_device_properties(i).total_memory / 1024 / 1024 / 1024:.2f} GB\") for i in range(torch.cuda.device_count())] if torch.cuda.is_available() else print(\"GPUは利用できません\")"

echo "==== 環境チェック完了 ===="
EOF

chmod +x check_cuda_env.sh

# Dockerfileを使用するスクリプト
cat > run_gpu_comparison.sh << 'EOF'
#!/bin/bash
echo "===== GPU vs CPU 性能比較テスト ====="

# スクリプトのあるディレクトリに移動
cd "$(dirname "$0")"

# 環境チェック
echo "1. Dockerが利用可能か確認しています..."
if ! command -v docker &> /dev/null; then
    echo "エラー: Dockerがインストールされていません"
    exit 1
fi

echo "2. GPUサポートが有効か確認しています..."
if ! docker info | grep -i nvidia &> /dev/null; then
    echo "警告: DockerのNVIDIAサポートが検出されませんでした"
    echo "Docker EngineにNVIDIA runtimeが設定されているか確認してください"
fi

echo "3. NVIDIAドライバーを確認しています..."
if ! nvidia-smi &> /dev/null; then
    echo "エラー: NVIDIA GPUが見つからないか、ドライバーが適切に設定されていません"
    echo "nvidia-smiコマンドが失敗しました"
    exit 1
fi

echo "4. Dockerイメージをビルドしています..."
docker build -t gpu-cpu-comparison .

echo "5. GPUサポート付きでコンテナを実行しています..."
echo "==== 実行結果 ===="
docker run --rm --gpus all \
    -e NVIDIA_VISIBLE_DEVICES=all \
    -e NVIDIA_DRIVER_CAPABILITIES=compute,utility \
    gpu-cpu-comparison bash -c "/app/check_cuda_env.sh && python3 /app/gpu_cpu_comparison.py"
EOF
```

### 4.2 docker-compose.ymlの作成
複数のコンテナ環境を効率的に管理するためのdocker-compose.ymlを作成します。

```bash
cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  gpu-benchmark:
    build:
      context: .
      dockerfile: Dockerfile
    image: gpu-cpu-comparison
    container_name: gpu-benchmark
    volumes:
      - ./:/app
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    command: python3 /app/gpu_cpu_comparison.py

  cuda-check:
    build:
      context: .
      dockerfile: Dockerfile
    image: gpu-cpu-comparison
    container_name: cuda-check
    volumes:
      - ./:/app
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    command: /app/check_cuda_env.sh

  jupyter:
    build:
      context: .
      dockerfile: Dockerfile
    image: gpu-cpu-comparison
    container_name: jupyter-gpu
    ports:
      - "8888:8888"
    volumes:
      - ./:/app
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    command: >
      bash -c "pip3 install jupyter &&
      jupyter notebook --ip=0.0.0.0 --port=8888 --no-browser --allow-root --NotebookApp.token='gpu-test'"
EOF

# docker-compose使用方法説明スクリプト
cat > run_with_compose.sh << 'EOF'
#!/bin/bash
echo "===== Docker Compose を使用したGPUテスト環境 ====="

# スクリプトのあるディレクトリに移動
cd "$(dirname "$0")"

# 環境チェック
if ! command -v docker-compose &> /dev/null; then
    echo "エラー: docker-composeがインストールされていません"
    exit 1
fi

# 実行方法の説明
echo "以下のコマンドでサービスを実行できます:"
echo "1. ベンチマークテスト: docker-compose run gpu-benchmark"
echo "2. CUDA環境チェック: docker-compose run cuda-check"
echo "3. Jupyter Notebook: docker-compose up jupyter"
echo "   (Jupyter URLは http://localhost:8888 でトークンは 'gpu-test')"
echo ""
echo "すべてのサービスをビルド: docker-compose build"
echo "すべてのサービスを停止: docker-compose down"
EOF

chmod +x run_with_compose.sh
```

## 5. トラブルシューティング

WSL2とDocker間の連携に関する一般的な問題と解決策を以下にまとめます。

```bash
cat > troubleshooting.md << 'EOF'
# WSL2+Docker+GPU環境のトラブルシューティング

## 一般的な問題と解決策

### 1. GPU使用時のメモリリーク問題
**症状**: WSL2上でGPUを使用した後、メモリが解放されない
**解決策**:
- WSLを一時的に終了して再起動する:
  ```
  wsl --shutdown
  ```
- WSL2のメモリ制限を設定する。以下の内容で`%UserProfile%\.wslconfig`ファイルを作成:
  ```
  [wsl2]
  memory=8GB
  swap=4GB
  ```

### 2. CUDA関連エラー
**症状**: `CUDA error: no CUDA-capable device is detected`
**解決策**:
1. NVIDIAドライバーの再インストール
2. Docker DesktopでGPUサポートが有効化されているか確認:



書いている途中




<h2 id="S07">7．Miniconda3を使用したUbuntu開発環境の構築手順と解説</h2>

<p>
次は，Ubuntu 24.04のコンテナで，Python環境を構築している．Miniconda3を用いてPython 3.12環境を作成し，NumPy，Pandas等の科学技術計算ライブラリを導入している．Jupyter NotebookをPort 8888で起動するよう設定し，開発環境としてcmake，git等の基本ツールも導入している．
<p>
以下の手順の2, 3のコマンドは，コンテナ内で実行すること．

<h3>1．Ubuntu 24.04 コンテナの作成と実行</h3>
<div class="kbd"><code><pre>
docker run --name myubuntu --restart unless-stopped -p 8888:8888 -it ubuntu:24.04 /bin/bash
</pre></code></div>

<div class="center-aligned">
<img src="./12.png">
</div>

<p>各オプションの説明：</p>
<ul>
<li><code>--name myubuntu</code>：コンテナに識別用の名前を付与する</li>
<li><code>--restart unless-stopped</code>：明示的に停止しない限り，クラッシュ時に自動的に再起動する</li>
<li><code>-it</code>：対話的な操作を可能にし（<code>-i</code>），疑似TTY（端末）を割り当てる（<code>-t</code>）</li>
<li><code>-p 8888:8888</code>： Jupyter Notebook のためにポート8888のマッピングを行う
<li><code>ubuntu:24.04</code>：使用するベースイメージである</li>
<li><code>/bin/bash</code>：コンテナ起動時に実行するコマンドである</li>
</ul>

<p>
以下の手順の2, 3のコマンドは，コンテナ内で実行すること．

<h3>2．Miniconda3のインストールと環境設定</h3>
<p>コンテナ内で以下のコマンドを実行する：</p>
<div class="kbd"><code><pre>
# 必要な基本ツールのインストール
apt update && apt upgrade -y
apt install -y wget curl git cmake build-essential
rm -rf /var/lib/apt/lists/*

# Miniconda3のダウンロードとインストール
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh -b -p /opt/conda
rm Miniconda3-latest-Linux-x86_64.sh

# PATHの設定
/opt/conda/bin/conda init
. /opt/conda/etc/profile.d/conda.sh
echo ". /opt/conda/etc/profile.d/conda.sh" >> ~/.bashrc

# condaの初期設定
source ~/.bashrc

# 開発環境用のconda環境作成
conda create -n dev python=3.12 -y

# 開発環境のアクティベート
conda activate dev

# 開発ツールのインストール
conda install -y numpy pandas matplotlib scikit-learn jupyter pylint pytest black
echo "conda activate dev" >> ~/.bashrc

# Jupyter Notebookの設定
jupyter notebook --generate-config
echo "c.NotebookApp.ip = '*'" >> ~/.jupyter/jupyter_notebook_config.py
echo "c.NotebookApp.port = 8888" >> ~/.jupyter/jupyter_notebook_config.py
echo "c.NotebookApp.allow_root = True" >> ~/.jupyter/jupyter_notebook_config.py
</pre></code></div>
<p>解説：</p>
<ul>
<li>Miniconda3は，最小限のAnaconda配布版である</li>
<li><code>conda</code>コマンドによる環境管理が可能である</li>
<li>Python 3.12を指定した仮想環境（dev）を作成する</li>
<li>科学技術計算やデータ分析に必要なパッケージを含める</li>
</ul>

<h3>3．環境の確認</h3>

<ul>
<li> Pythonバージョンの確認

<div class="kbd"><code><pre>
python --version
</pre></code></div>

<div class="center-aligned">
<img src="./14.png">
</div>

<li> conda環境の確認

<div class="kbd"><code><pre>
conda info
</pre></code></div>

<div class="center-aligned">
<img src="./15.png">
</div>

<li> conda環境の確認

<div class="kbd"><code><pre>
conda env list
</pre></code></div>

<div class="center-aligned">
<img src="./.png">
</div>

<li>インストールされたパッケージの確認

<div class="kbd"><code><pre>
conda list
</pre></code></div>
</ul>