EvoSpikeNet NVIDIA NGC Jupyter Notebook セットアップガイド

[!NOTE] 最新の実装状況は 機能実装ステータス (Remaining Functionality) を参照してください。

このガイドでは、NVIDIA NGCの事前構築済みJupyter Notebookコンテナを使用してEvoSpikeNetを実行する方法を説明します。

概要

NVIDIA NGCは、CUDA、cuDNN、ディープラーニングフレームワークがプリインストールされた最適化されたコンテナを提供します。PyTorch Jupyter Notebookコンテナをベースとして、その上にEvoSpikeNetをインストールします。

前提条件

• CUDAをサポートするNVIDIA GPU
• Dockerがインストールされていること
• NGCアカウント（オプションですが、最新イメージには推奨）
• 最低16GBのRAMを推奨

クイックスタート

1. リポジトリのクローン

git clone https://github.com/moonlight-tech/EvoSpikeNet.git
cd EvoSpikeNet

2. 環境設定

NGC固有の設定のための.envファイルを作成します：

# NGC設定
NGC_PYTORCH_TAG=26.01-py3
NGC_BASE_IMAGE=nvcr.io/nvidia/pytorch:${NGC_PYTORCH_TAG}

# Jupyter設定
JUPYTER_PORT=8888
JUPYTER_TOKEN=evospikenet-ngc

# EvoSpikeNet設定
EVOSPIKENET_API_KEY=your-api-key-here
BUILD_TARGET=development
ENABLE_GPU=true

3. NGCコンテナでの起動

# NGCベースのノートブックをビルドして実行
docker-compose -f docker-compose.ngc.yml up -d ngc-notebook

# またはフルスタック実行（API/DBサービスも必要な場合）
docker-compose -f docker-compose.ngc.yml --profile full up -d

4. Jupyter Notebookへのアクセス

ブラウザで以下のURLにアクセスしてください：http://localhost:8888

トークンを使用：evospikenet-ngc（またはJUPYTER_TOKENで設定した値）

設定ファイル

Dockerfile.ngc

このDockerfileはNGC PyTorchコンテナを拡張し、EvoSpikeNetの依存関係を追加します。

docker-compose.ngc.yml

NGCコンテナ専用に特化したDocker Compose設定です。

利用可能なNGCイメージ

NVIDIA NGCは複数のPyTorch Jupyterコンテナを提供しています：

• nvcr.io/nvidia/pytorch:26.01-py3 - 最新の安定版
• nvcr.io/nvidia/pytorch:25.12-py3 - 前のバージョン
• nvcr.io/nvidia/pytorch:24.01-py3 - LTSバージョン

CUDAドライバーの互換性に基づいて適切なタグを選択してください。

GPUメモリ要件

• 最小: 8GB GPU RAM
• 推奨: 16GB+ GPU RAM
• 大規模トレーニング用: 24GB+ GPU RAM

トラブルシューティング

コンテナが起動しない場合

GPUの利用可能性を確認：

nvidia-smi
docker run --rm --gpus all nvidia/cuda:11.0-base nvidia-smi

Jupyterが読み込まれない場合

コンテナログを確認：

docker-compose -f docker-compose.ngc.yml logs ngc-notebook

インポートエラー

すべての依存関係がインストールされていることを確認：

docker-compose -f docker-compose.ngc.yml exec ngc-notebook pip list | grep torch

高度な使用方法

カスタムNGCイメージ

異なるNGCイメージを使用するには、.envファイルのNGC_BASE_IMAGEを変更してください。

開発モード

ライブコードリロードでの開発用：

docker-compose -f docker-compose.ngc.yml up -d ngc-dev

フルスタックデプロイメント

NGCで完全なEvoSpikeNetスタックを実行：

# すべてのサービスを開始
docker-compose -f docker-compose.ngc.yml --profile full up -d

# 起動されるサービス:
# - ngc-notebook: NGC PyTorchを使用したJupyter (port 8888)
# - api: FastAPIバックエンド (port 8000)
# - frontend: Web UI (port 8050)
# - postgres: データベース
# - milvus: ベクトルデータベース
# - elasticsearch: 検索エンジン
# - zenoh-router: 分散メッセージング

クラウド環境でのデプロイメント

NGC Container Registry へのイメージのプッシュ

カスタマイズしたEvoSpikeNet NGCイメージをNVIDIA NGC Container Registryにプッシュして、クラウド環境で利用できるようにします。

1. イメージのビルド

# EvoSpikeNetリポジトリのルートディレクトリで実行
docker build -f Dockerfile.ngc -t evospikenet-ngc:latest .

# または特定のNGC PyTorchバージョンを指定
docker build -f Dockerfile.ngc \
  --build-arg NGC_PYTORCH_TAG=26.01-py3 \
  -t evospikenet-ngc:26.01 .

2. NGC Registry へのログイン

# NGC APIキーを使用してログイン
docker login nvcr.io

# Username: $oauthtoken
# Password: <your-ngc-api-key>

NGC APIキーは NGC Dashboard で生成できます。

3. イメージのタグ付けとプッシュ

# NGC組織名とイメージ名でタグ付け
docker tag evospikenet-ngc:latest nvcr.io/<your-org>/evospikenet:latest
docker tag evospikenet-ngc:latest nvcr.io/<your-org>/evospikenet:26.01

# NGC Registryにプッシュ
docker push nvcr.io/<your-org>/evospikenet:latest
docker push nvcr.io/<your-org>/evospikenet:26.01

AWS での実行

EC2 インスタンス（GPU対応）での実行

# NVIDIA Container Toolkitがインストールされている前提
# NGC イメージをプルして実行
docker run --gpus all -d \
  -p 8888:8888 \
  -v /home/ubuntu/evospikenet-data:/home/appuser/app/saved_models \
  -e JUPYTER_TOKEN=your-secure-token \
  -e EVOSPIKENET_API_KEY=your-api-key \
  --name evospikenet-ngc \
  nvcr.io/<your-org>/evospikenet:latest \
  jupyter lab --ip=0.0.0.0 --port=8888 --no-browser \
    --ServerApp.token=your-secure-token \
    --ServerApp.allow_origin='*'

# ログの確認
docker logs -f evospikenet-ngc

Amazon ECS での実行

ECSタスク定義の例（JSON）:

{
  "family": "evospikenet-ngc",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["EC2"],
  "containerDefinitions": [
    {
      "name": "evospikenet",
      "image": "nvcr.io/<your-org>/evospikenet:latest",
      "memory": 16384,
      "cpu": 4096,
      "essential": true,
      "portMappings": [
        {
          "containerPort": 8888,
          "protocol": "tcp"
        }
      ],
      "environment": [
        {"name": "JUPYTER_TOKEN", "value": "your-secure-token"},
        {"name": "EVOSPIKENET_API_KEY", "value": "your-api-key"},
        {"name": "NVIDIA_VISIBLE_DEVICES", "value": "all"}
      ],
      "resourceRequirements": [
        {
          "type": "GPU",
          "value": "1"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/evospikenet-ngc",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "ecs"
        }
      }
    }
  ]
}

Azure での実行

Azure Container Instances（GPU対応）での実行

# Azure CLIでコンテナを作成
az container create \
  --resource-group evospikenet-rg \
  --name evospikenet-ngc \
  --image nvcr.io/<your-org>/evospikenet:latest \
  --cpu 4 \
  --memory 16 \
  --gpu-count 1 \
  --gpu-sku V100 \
  --ports 8888 \
  --dns-name-label evospikenet-ngc \
  --environment-variables \
    JUPYTER_TOKEN=your-secure-token \
    EVOSPIKENET_API_KEY=your-api-key \
    NVIDIA_VISIBLE_DEVICES=all \
  --restart-policy OnFailure

# コンテナのステータス確認
az container show \
  --resource-group evospikenet-rg \
  --name evospikenet-ngc \
  --query "{Status:instanceView.state,IP:ipAddress.ip,Ports:ipAddress.ports}" \
  --output table

# ログの確認
az container logs \
  --resource-group evospikenet-rg \
  --name evospikenet-ngc

Azure Kubernetes Service (AKS) での実行

デプロイメントマニフェスト（evospikenet-ngc-deployment.yaml）:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: evospikenet-ngc
spec:
  replicas: 1
  selector:
    matchLabels:
      app: evospikenet-ngc
  template:
    metadata:
      labels:
        app: evospikenet-ngc
    spec:
      containers:
      - name: evospikenet
        image: nvcr.io/<your-org>/evospikenet:latest
        ports:
        - containerPort: 8888
        env:
        - name: JUPYTER_TOKEN
          valueFrom:
            secretKeyRef:
              name: evospikenet-secrets
              key: jupyter-token
        - name: EVOSPIKENET_API_KEY
          valueFrom:
            secretKeyRef:
              name: evospikenet-secrets
              key: api-key
        resources:
          limits:
            nvidia.com/gpu: 1
            memory: "16Gi"
            cpu: "4"
          requests:
            nvidia.com/gpu: 1
            memory: "8Gi"
            cpu: "2"
        volumeMounts:
        - name: models-storage
          mountPath: /home/appuser/app/saved_models
      volumes:
      - name: models-storage
        persistentVolumeClaim:
          claimName: evospikenet-models-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: evospikenet-ngc-service
spec:
  type: LoadBalancer
  ports:
  - port: 8888
    targetPort: 8888
  selector:
    app: evospikenet-ngc

デプロイ手順:

# Secretの作成
kubectl create secret generic evospikenet-secrets \
  --from-literal=jupyter-token=your-secure-token \
  --from-literal=api-key=your-api-key

# デプロイ
kubectl apply -f evospikenet-ngc-deployment.yaml

# ステータス確認
kubectl get pods -l app=evospikenet-ngc
kubectl get svc evospikenet-ngc-service

Google Cloud Platform (GCP) での実行

Compute Engine（GPU対応VM）での実行

# GCEインスタンスにSSH接続後、NVIDIA Container Toolkitがインストールされている前提
# NGC イメージを実行
docker run --gpus all -d \
  -p 8888:8888 \
  -v /mnt/disks/evospikenet-data:/home/appuser/app/saved_models \
  -e JUPYTER_TOKEN=your-secure-token \
  -e EVOSPIKENET_API_KEY=your-api-key \
  --name evospikenet-ngc \
  nvcr.io/<your-org>/evospikenet:latest \
  jupyter lab --ip=0.0.0.0 --port=8888 --no-browser \
    --ServerApp.token=your-secure-token

# ファイアウォールルールの設定（初回のみ）
gcloud compute firewall-rules create allow-jupyter \
  --allow tcp:8888 \
  --source-ranges 0.0.0.0/0 \
  --description "Allow Jupyter access"

Google Kubernetes Engine (GKE) での実行

# GKEクラスタの作成（GPU対応）
gcloud container clusters create evospikenet-cluster \
  --accelerator type=nvidia-tesla-v100,count=1 \
  --machine-type n1-standard-4 \
  --num-nodes 2 \
  --zone us-central1-a

# NVIDIA GPU device pluginのインストール
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

# Secretの作成
kubectl create secret generic evospikenet-secrets \
  --from-literal=jupyter-token=your-secure-token \
  --from-literal=api-key=your-api-key

# EvoSpikeNetのデプロイ
kubectl run evospikenet-ngc \
  --image=nvcr.io/<your-org>/evospikenet:latest \
  --port=8888 \
  --limits='nvidia.com/gpu=1' \
  --env="JUPYTER_TOKEN=your-secure-token" \
  --env="EVOSPIKENET_API_KEY=your-api-key"

# サービスの公開
kubectl expose pod evospikenet-ngc \
  --type=LoadBalancer \
  --port=8888 \
  --target-port=8888

# 外部IPの確認
kubectl get service evospikenet-ngc

Kubernetes での高度なデプロイメント

プロダクション対応のKubernetesマニフェスト（evospikenet-production.yaml）:

apiVersion: v1
kind: Namespace
metadata:
  name: evospikenet

---
apiVersion: v1
kind: ConfigMap
metadata:
  name: evospikenet-config
  namespace: evospikenet
data:
  LOG_LEVEL: "INFO"
  PYTHONPATH: "/home/appuser/app"
  TZ: "Asia/Tokyo"

---
apiVersion: v1
kind: Secret
metadata:
  name: evospikenet-secrets
  namespace: evospikenet
type: Opaque
stringData:
  jupyter-token: "your-secure-token-here"
  api-key: "your-secure-api-key-here"

---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: evospikenet-models-pvc
  namespace: evospikenet
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 100Gi
  storageClassName: standard

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: evospikenet-ngc
  namespace: evospikenet
spec:
  replicas: 1
  selector:
    matchLabels:
      app: evospikenet-ngc
  template:
    metadata:
      labels:
        app: evospikenet-ngc
    spec:
      containers:
      - name: evospikenet
        image: nvcr.io/<your-org>/evospikenet:latest
        imagePullPolicy: Always
        ports:
        - containerPort: 8888
          name: jupyter
        env:
        - name: JUPYTER_TOKEN
          valueFrom:
            secretKeyRef:
              name: evospikenet-secrets
              key: jupyter-token
        - name: EVOSPIKENET_API_KEY
          valueFrom:
            secretKeyRef:
              name: evospikenet-secrets
              key: api-key
        envFrom:
        - configMapRef:
            name: evospikenet-config
        resources:
          limits:
            nvidia.com/gpu: 1
            memory: "32Gi"
            cpu: "8"
          requests:
            nvidia.com/gpu: 1
            memory: "16Gi"
            cpu: "4"
        volumeMounts:
        - name: models-storage
          mountPath: /home/appuser/app/saved_models
        - name: logs-storage
          mountPath: /home/appuser/app/logs
        livenessProbe:
          httpGet:
            path: /login
            port: 8888
          initialDelaySeconds: 60
          periodSeconds: 30
          timeoutSeconds: 10
          failureThreshold: 3
        readinessProbe:
          httpGet:
            path: /login
            port: 8888
          initialDelaySeconds: 30
          periodSeconds: 10
          timeoutSeconds: 5
          failureThreshold: 3
      volumes:
      - name: models-storage
        persistentVolumeClaim:
          claimName: evospikenet-models-pvc
      - name: logs-storage
        emptyDir: {}
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-tesla-v100  # GPU対応ノードを選択

---
apiVersion: v1
kind: Service
metadata:
  name: evospikenet-ngc-service
  namespace: evospikenet
spec:
  type: LoadBalancer
  ports:
  - port: 8888
    targetPort: 8888
    protocol: TCP
    name: jupyter
  selector:
    app: evospikenet-ngc

---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: evospikenet-ngc-hpa
  namespace: evospikenet
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: evospikenet-ngc
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

デプロイ手順:

# マニフェストの適用
kubectl apply -f evospikenet-production.yaml

# デプロイメントの確認
kubectl get all -n evospikenet

# ログの確認
kubectl logs -n evospikenet -l app=evospikenet-ngc -f

# 外部IPの取得
kubectl get svc -n evospikenet evospikenet-ngc-service

本番環境のセキュリティ設定

環境変数のセキュアな管理

# Kubernetes Secretsの使用
kubectl create secret generic evospikenet-secrets \
  --from-literal=jupyter-token=$(openssl rand -base64 32) \
  --from-literal=api-key=$(openssl rand -base64 32) \
  --namespace evospikenet

# AWS Secrets Managerの使用（ECS/EKS）
aws secretsmanager create-secret \
  --name evospikenet/jupyter-token \
  --secret-string $(openssl rand -base64 32)

aws secretsmanager create-secret \
  --name evospikenet/api-key \
  --secret-string $(openssl rand -base64 32)

HTTPSの有効化

Nginx Ingress Controllerを使用した例:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: evospikenet-ingress
  namespace: evospikenet
  annotations:
    kubernetes.io/ingress.class: nginx
    cert-manager.io/cluster-issuer: letsencrypt-prod
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
  tls:
  - hosts:
    - evospikenet.yourdomain.com
    secretName: evospikenet-tls
  rules:
  - host: evospikenet.yourdomain.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: evospikenet-ngc-service
            port:
              number: 8888

ネットワークポリシー

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: evospikenet-network-policy
  namespace: evospikenet
spec:
  podSelector:
    matchLabels:
      app: evospikenet-ngc
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: evospikenet
    ports:
    - protocol: TCP
      port: 8888
  egress:
  - to:
    - namespaceSelector: {}
    ports:
    - protocol: TCP
      port: 443
    - protocol: TCP
      port: 80

モニタリングとログ

Prometheus メトリクスの設定

apiVersion: v1
kind: Service
metadata:
  name: evospikenet-metrics
  namespace: evospikenet
  labels:
    app: evospikenet-ngc
  annotations:
    prometheus.io/scrape: "true"
    prometheus.io/port: "9090"
    prometheus.io/path: "/metrics"
spec:
  selector:
    app: evospikenet-ngc
  ports:
  - name: metrics
    port: 9090
    targetPort: 9090

ログ集約（Fluentd経由でElasticsearchへ）

apiVersion: v1
kind: ConfigMap
metadata:
  name: fluentd-config
  namespace: evospikenet
data:
  fluent.conf: |
    <source>
      @type tail
      path /home/appuser/app/logs/*.log
      pos_file /var/log/fluentd-evospikenet.pos
      tag evospikenet.*
      <parse>
        @type json
      </parse>
    </source>

    <match evospikenet.**>
      @type elasticsearch
      host elasticsearch.logging.svc.cluster.local
      port 9200
      logstash_format true
      logstash_prefix evospikenet
    </match>

コスト最適化

スケジューリングによる自動停止・起動

AWS Lambda + EventBridge を使用した例:

import boto3

def lambda_handler(event, context):
    ecs = boto3.client('ecs')

    action = event.get('action', 'stop')
    cluster = 'evospikenet-cluster'
    service = 'evospikenet-ngc-service'

    if action == 'start':
        # サービスのタスク数を1に設定
        ecs.update_service(
            cluster=cluster,
            service=service,
            desiredCount=1
        )
    elif action == 'stop':
        # サービスのタスク数を0に設定
        ecs.update_service(
            cluster=cluster,
            service=service,
            desiredCount=0
        )

    return {'statusCode': 200, 'body': f'Service {action}ped'}

スポットインスタンス/プリエンプティブルVMの使用

GKE でのスポットVMの使用:

gcloud container node-pools create evospikenet-spot-pool \
  --cluster=evospikenet-cluster \
  --spot \
  --accelerator type=nvidia-tesla-v100,count=1 \
  --machine-type=n1-standard-4 \
  --num-nodes=2 \
  --zone=us-central1-a

パフォーマンス最適化

GPU利用

NGCコンテナはNVIDIA GPU用に最適化されています。GPU使用率を監視：

import torch
print(f"CUDA available: {torch.cuda.is_available()}")
print(f"GPU count: {torch.cuda.device_count()}")
print(f"Current GPU: {torch.cuda.get_device_name()}")

メモリ管理

大規模モデル用にPyTorchメモリ設定を調整：

import torch
torch.cuda.set_per_process_memory_fraction(0.8)  # GPUメモリの80%を使用

マルチGPU設定

クラウド環境で複数GPUを使用する場合：

import torch
import torch.nn as nn

# DataParallelの使用
if torch.cuda.device_count() > 1:
    model = nn.DataParallel(model)
    print(f"Using {torch.cuda.device_count()} GPUs")

model.to('cuda')

セキュリティに関する注意事項

• 本番環境ではデフォルトのJupyterトークンを変更してください
• EvoSpikeNetサービスには強力なAPIキーを使用してください
• 本番デプロイメントではネットワーク分離を検討してください

サポート

NGC固有の問題については、以下を参照してください： - NVIDIA NGC ドキュメント - PyTorch NGC コンテナ

EvoSpikeNetの問題については、メインレポジトリのドキュメントを確認してください。 /Users/maoki/Documents/GitHub/EvoSpikeNet/docs/NGC_JUPYTER_SETUP.md