Google Colaboratory

オンラインの Jupyter Notebook サービス．セットアップ不要で無料利用可能．機械学習、データサイエンス、教育に適している．利用には Google アカウントが必要．他者が公開したノートブックの閲覧だけであれば，Google アカウントは必要

目次

PowerPoint 版: googlecolab.docx, PDF 版: googlecolab.pdf

YouTube 動画: https://www.youtube.com/watch?v=Aq7kFzVszVg

Google Colaboratory とは

基本概念

ノートブック：プログラムコードと説明文を組み合わせた文書形式

セル：ノートブック内の編集可能な個別の単位

ランタイム：プログラムが実際に実行される環境

Google Colaboratory について

URL: https://colab.research.google.com/

GPU/TPU の利点：大量のデータを並列処理し、機械学習モデルの学習時間を短縮

ノートブックの構造

ノートブックは 2 種類のセルで構成される

画面構成

Web ブラウザ上の画面構成

対応ブラウザ

Google Colaboratory は以下のブラウザで動作する

注意：最新版を使用する

他の開発環境との比較

Jupyter Notebook：ローカル環境で動作、セットアップが必要、制限なし
VS Code，そのバリエーション（Windsurf など）：統合開発環境、多言語対応、拡張機能豊富
Google Colaboratory：クラウド環境、セットアップ不要、GPU/TPU 利用可能

Google アカウントの設定

Google アカウントの取得

Google アカウントは無料で取得できる

登録に必要な情報

個人情報の取り扱いについて各自で確認し、不安がある場合は取得を控える。

セキュリティ対策と注意事項

Google アカウントについて

Google アカウントは Google が提供するオンラインサービスを利用するためのアカウント

Google Colaboratory と Google アカウント

Google Colaboratory の利用には Google アカウントが必要

Google アカウントで利用できる機能

Google アカウントなしでも利用できる機能

Google アカウント取得手順

  1. Google の Web ページを開く
    https://www.google.com/
  2. 右上のメニューで「アカウント」を選択
  3. 「アカウントを作成する」をクリック
  4. 表示された画面で「自分用」を選択
    ※「ビジネスの管理用」は Google の有料サービス G Suite
  5. 以下の情報を登録
    • 姓、名
    • 希望するメールアドレス ＜ユーザー名＞@gmail.com
    • パスワード（2 か所に入力）
    • 電話番号
    • 生年月日、性別
  6. 本人確認のための電話番号を入力し、「次へ」をクリック
    電話番号はスマートフォンの番号を使用
  7. 本人確認手続きの実行
    電話番号認証により本人確認を行う
    電話番号は 080-1234-5678、090-1234-5678 のように入力する（先頭の 0 を除く）

アカウント取得のまとめ

Google アカウントの取得

注意点

手順

  1. Google の Web ページ https://www.google.com/
  2. 右上のメニューで「アカウント」を選択
  3. 「アカウントを作成する」をクリック
  4. 「自分用」を選択（「ビジネスの管理用」は有料サービス G Suite）
  5. 必要な情報を登録
  6. 本人確認のための電話番号を入力し、その後指示に従う

Google Colaboratory の基本操作

ログイン手順

Google Colaboratory の使用中に「Google へのログインが必要」と表示された場合

  1. 表示されたログイン画面で Google アカウントの ID を入力
  2. パスワードを入力
  3. 必要に応じて二段階認証を実行
  4. ログイン完了後、ノートブックの編集・実行が可能

実行の流れ

ノートブックの基本的な実行の流れ

  1. Web ブラウザで Google Colaboratory にアクセス

    2. https://colab.research.google.com/ にアクセス

  2. Google アカウントでログイン
  3. セルの編集と実行
    • テキストセル：説明文の作成
    • コードセル：Python プログラムの作成と実行
  4. 実行順序：通常は上から下へ順次実行

コードセルとプログラム実行

コードセルでは Python プログラムやシステムコマンドの編集と実行が可能（Google アカウントでのログインが必要）

実行方法

  1. セルを選択する
  2. 実行ボタンをクリックする、または Shift + Enter キーを押す
  3. 実行結果がセルの下に表示される

基本操作の要点

アクセス方法

Web ブラウザから https://colab.research.google.com/ にアクセス

セルの種類

基本操作

バージョン管理

トラブルシューティング

セッション管理

システムの混雑時や長時間実行時に処理が停止し、再開しない場合がある

セッション：Google Colaboratory でコードを実行するための作業環境

対処方法

  1. メニューから「ランタイム」を選択する
  2. 「セッションの管理」をクリックする
  3. アクティブなセッション一覧から「終了」をクリックする
  4. すべてのセッションを終了する
  5. 最初からコードを再実行する

エラー対処法

よくあるエラーと対処法

エラー解決の基本手順

  1. エラーメッセージを最後の行から読む
  2. エラーの種類（SyntaxError、NameError など）を特定する
  3. 「ランタイム」→「すべての出力を表示」でログ全体を確認する
  4. 公式ドキュメント（https://colab.research.google.com/notebooks/）で解決策を検索する

制限事項と制約

実行時間制限

計算資源の制限

禁止されている使用方法

演習

【トピックス】

演習手順

  1. Google Colaboratory のWebページを開く
    https://colab.research.google.com
  2. 「ファイル」で「ノートブックを新規作成」を選択
  3. Google アカウントでのログインが求められたときはログインする
  4. コードセルの新規作成
    メニューの「+ コード」をクリック
  5. コードセルに Python プログラムを記述 
    
x = 100

    説明：変数 x に整数値 100 を代入

  6. コードセルの新規作成
    メニューの「+ コード」をクリック
  7. コードセルに Python プログラムを記述 
    
if x > 20:
  print("big")
else:
  print("small")

    説明：変数 x の値が 20 より大きい場合は "big"、そうでなければ "small" を出力

    記述のポイント

    • if x > 20 の直後に「:」（コロン）
    • else の直後に「:」（コロン）
  8. コードセルの新規作成

    メニューの「+ コード」をクリック

  9. コードセルに Python プログラムを記述 
    # ループ処理
s = 0
for i in [1, 2, 3, 4, 5]:
  s = s + i
print(s)

    説明：リスト [1, 2, 3, 4, 5] の各要素を順番に変数 s に加算し、最終結果（15）を出力

    記述のポイント

    • for i in [1, 2, 3, 4, 5] の直後に「:」（コロン）
    • 字下げ（インデント）は半角スペース 2 つ
  10. コードセルを順次実行し、実行結果を確認

    各コードセルの実行手順

    1. 最初のコードセル（変数代入）の実行ボタンをクリック
    2. 2 番目のコードセル（条件分岐）の実行ボタンをクリック → "big" が出力される
    3. 3 番目のコードセル（ループ処理）の実行ボタンをクリック → "15" が出力される

    注意：セルは上から順番に実行する

Google Colaboratory 操作ガイド

画面操作によるファイルのアップロード

Google Colaboratory へのファイルアップロード方法

  1. 左側メニューから「ファイル」アイコンをクリック
  2. 「アップロード」ボタンをクリック、またはファイルをドラッグ&ドロップ
  3. アップロードされたファイルは一時的に保存され、セッション終了時に削除
Google Colaboratory 操作ガイド

システム環境の確認

基本環境情報の確認

Google Colaboratory（以下、Colab）では、利用可能なハードウェアとソフトウェア環境を事前に確認する。

# システム情報の確認
!cat /proc/version
!free -h         # メモリ使用量の確認
!df -h           # ディスク使用量の確認

GPU・CUDA環境の確認

GPU利用可能性とCUDAバージョンを確認する。2025年6月現在、ColabではCUDA 12.x系が使用されている。

# GPU情報の詳細確認
!nvidia-smi
!nvidia-smi -query-gpu=gpu_name,driver_version,memory.total -format=csv

# CUDAバージョンの確認
!nvcc -version

ライブラリバージョンの確認

機械学習に使用する主要ライブラリのバージョンと GPU 利用可能性を確認する。

import tensorflow as tf
import torch

print(f"TensorFlow: {tf.__version__}")
import keras
print(f"Keras: {keras.__version__}")

# GPU利用可能性の確認
print(f"PyTorch GPU利用可能: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU名: {torch.cuda.get_device_name(0)}")

# TensorFlowでのGPU確認
print(f"TensorFlow GPU: {tf.config.list_physical_devices('GPU')}")

基本操作とマジックコマンド

システムコマンドとパッケージ管理

感嘆符（!）を使用してシェルコマンドを直接実行できる。

# パッケージのインストール
!pip install package_name
!pip install -q package_name  # 出力を抑制

# 条件付きインストール
!pip install package_name --upgrade
!pip list | grep package_name

環境変数とパス設定

プロジェクト固有の設定を行う際に使用する。

import os
import sys

# 環境変数の設定
os.environ['VARIABLE_NAME'] = 'value'

# Pythonパスの追加
sys.path.append('/content/drive/MyDrive/modules')

# 作業ディレクトリの変更
%cd /content/drive/MyDrive/project

bashコマンドの実行

# bashコマンドの実行
%%bash
echo "bashコマンドの実行"

変数の監視と詳細情報

デバッグやコード解析に使用する情報取得方法である。

# 変数の内容確認
%whos      # 詳細な変数一覧
%who_ls    # 変数名のリスト

# 変数の詳細情報
variable_name?   # 簡潔な情報
variable_name??  # 詳細な情報（ソースコードを含む）

Google Driveとファイル操作

Google Driveマウント機能

Google Driveをマウントすることで、クラウドストレージのファイルに直接アクセスできる。

from google.colab import drive

# Google Driveをマウント
drive.mount('/content/drive')

# マウント確認
!ls /content/drive/MyDrive/

# 強制再マウント
drive.mount('/content/drive', force_remount=True)

ファイルアップロード・ダウンロード機能

基本的なファイルアップロード

ローカルファイルをColabにアップロードするには、以下のコードを使用する。

from google.colab import files

uploaded = files.upload()

実行すると、GUIでファイル選択ダイアログが表示され、ブラウザ経由でファイルを選択できる。

複数ファイルの処理

アップロードされたファイルを種類別に分類して処理する方法を示す。

# 複数ファイルの処理
for filename in uploaded.keys():
    print(f'アップロードされたファイル: {filename}')

image_files = []
for filename in uploaded.keys():
    if filename.lower().endswith(('.jpg', '.jpeg', '.png', '.bmp', '.tiff')):
        image_files.append(filename)

files.upload()の戻り値は辞書形式で、keys()メソッドでファイル名を取得できる。

専用ディレクトリを作成してアップロード

ファイル管理を整理するため、専用ディレクトリを作成してアップロードする方法を示す。

from google.colab import files
import os
import shutil

udir = 'upload'
if os.path.exists(udir):
    shutil.rmtree(udir)
os.makedirs(udir)

uploaded = files.upload()
for fname in uploaded.keys():
    print(f"アップロード完了: {fname}")
ファイルのダウンロード

処理結果をローカルにダウンロードするには、以下のコードを使用する。

from google.colab import files
files.download('filename.txt')

GPU・TPU環境の設定

GPU使用の確認と設定

GPUが利用可能かどうかを確認し、適切に設定する方法は以下の通りである。

# GPU使用確認
import tensorflow as tf
print(f"GPU利用可能: {tf.test.is_gpu_available()}")

# メモリ成長を有効化（メモリエラー防止）
gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
    tf.config.experimental.set_memory_growth(gpus[0], True)

TPU使用時の設定

TPU（Tensor Processing Unit：Googleの機械学習専用プロセッサ）を使用する場合の設定方法を示す。

# TPU接続
try:
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
    tf.config.experimental_connect_to_cluster(tpu)
    tf.tpu.experimental.initialize_tpu_system(tpu)
    strategy = tf.distribute.experimental.TPUStrategy(tpu)
    print(f"TPUノード数: {tpu.num_accelerators()}")
except ValueError:
    print("TPUが見つかりません")

日本語環境の設定

日本語フォントのインストールと設定

Colabでは標準で日本語フォントが含まれていないため、日本語を含むグラフを作成する際は専用の設定が必要である。

簡単な日本語フォント設定

以下のライブラリを使用する方法がある。

import japanize_matplotlib

このライブラリにより、matplotlibで日本語表示が可能になる。

データ保護と継続性の確保

定期的な保存設定

Google Colaboratoryなどのクラウド環境では、一定時間操作がないとセッションが切断されることがある。データやモデルを失わないための対策として、モデルの学習中に定期的に保存する設定方法を以下に示す。

# モデルの定期保存
from tensorflow.keras.callbacks import ModelCheckpoint

checkpoint = ModelCheckpoint(
    '/content/drive/MyDrive/model_checkpoint.h5',
    save_best_only=True,
    save_freq='epoch'
)

model.fit(train_data, epochs=100, callbacks=[checkpoint])

重要データの即座保存

処理結果や重要なデータを即座にGoogle Driveに保存する方法を以下に示す。

# 結果をGoogle Driveに保存
import json
import numpy as np

# 結果辞書の保存
results = {'accuracy': 0.95, 'loss': 0.05}
with open('/content/drive/MyDrive/results.json', 'w') as f:
    json.dump(results, f)

# 処理済みデータの保存
np.save('/content/drive/MyDrive/processed_array.npy', processed_array)

セッション再開時の復旧

セッションが切断された後に作業を再開する際の復旧方法を以下に示す。

# 中断したトレーニングの再開
try:
    model = tf.keras.models.load_model('/content/drive/MyDrive/model_checkpoint.h5')
    print("モデルを復旧しました")
except:
    print("新しいモデルを作成します")
    model = create_new_model()

# データの復旧
try:
    processed_array = np.load('/content/drive/MyDrive/processed_array.npy')
    print("データを復旧しました")
except:
    print("データを再処理します")
    processed_array = preprocess_data()

Google Colaboratory実践ガイド

Google Colaboratoryの基本情報

「Colaboratoryへようこそ」のページのURL：
https://colab.research.google.com/?hl=ja

事前インストール済みライブラリ

NumPy、Pandas、Matplotlib、TensorFlow、PyTorchなど、科学計算・機械学習に必要なライブラリが事前にインストールされている。これらのライブラリは特別な操作を行わずに利用可能である。

追加ライブラリのインストール

事前にインストールされていないライブラリは「!pip」コマンドでインストールできる。なお、インストールしたライブラリは、セッション終了後は使用できなくなるため、再インストールが必要である。

選択基準

Google Colaboratoryが適している場面

Jupyter Notebookが適している場面

基本概念と用語

機械学習の基本概念

正規化（normalization）：データの値を0から1の範囲に変換する処理である。学習の安定化と高速化に寄与する。

エポック（epoch）：全ての訓練データを1回学習することを1エポックと呼ぶ。多すぎると過学習、少なすぎると学習不足になる。

バッチサイズ（batch size）：一度に処理するデータの数である。大きいと学習が安定するがメモリを多く使用し、小さいと学習が不安定になるが汎化性能が向上する傾向がある。

検証データ（validation data）：学習の進捗を確認するために使用するデータである。訓練には使用しない。過学習の早期発見に使用する。

ドロップアウト（dropout）：学習時に一部のニューロンを無作為に無効化することで、過学習を防ぐ手法である。

ニューラルネットワークの種類

CNN（畳み込みニューラルネットワーク）：画像の特徴を段階的に学習するモデルである。エッジや形などの小さな特徴から始まり、最終的に物体全体を認識する。画像の位置に依存しない特徴抽出が可能で、画像認識タスクで性能を発揮する。

LSTM（長短期記憶）：文章の流れや文脈を理解できるモデルである。単語の順序を考慮した処理が可能である。従来のRNNの勾配消失問題を解決し、長い文章の依存関係を学習できる。

データ処理用語

ワンホットエンコーディング：カテゴリ変数を数値に変換する手法である。例えば、「犬」「猫」「鳥」を[1,0,0]、[0,1,0]、[0,0,1]のような形式に変換する。分類問題で使用される前処理である。

パディング（padding）：文章の長さを揃えるため、短い文章に特別な値を追加する処理である。LSTMは固定長入力を要求するため必要である。

埋め込み層（embedding layer）：単語を数値ベクトルに変換する層である。意味的に類似した単語が近い値を持つよう学習される。

評価指標

シグモイド関数（sigmoid function）：出力を0から1の範囲に変換する関数である。二値分類の確率出力に使用される。

RMSE（平均平方根誤差）：予測精度を表す指標である。実際の値と予測値の差の二乗平均の平方根である。値が小さいほど精度が高く、単位が元データと同じため解釈しやすい。

画像分類プロジェクト

概要

画像分類とは、コンピューターが画像を見て、その内容を自動的に分類する技術である。人間が写真を見て「これは犬」「これは車」と判断するのと同様の処理をコンピューターに行わせる。

CIFAR-10データセットは、10種類の物体（飛行機、車、鳥、猫、鹿、犬、カエル、馬、船、トラック）の32×32ピクセルの画像が60,000枚含まれている。低解像度のため計算が軽く、教育用途に適しているが、実際の画像は高解像度であることに留意する必要がある。

実装例

# CIFAR-10データセットを使用したCNN画像分類システム
!apt-get -qq install -y fonts-ipafont-gothic
!pip install japanize-matplotlib tensorflow keras matplotlib numpy pillow
import japanize_matplotlib

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

# 定数定義
SEED = 42
EPOCHS = 5
BATCH_SIZE = 32
IMG_SIZE = 32
NUM_CLASSES = 10
CLASS_NAMES = ['飛行機', '自動車', '鳥', '猫', '鹿', '犬', 'カエル', '馬', '船', 'トラック']

# 再現性のためのシード設定
np.random.seed(SEED)
tf.random.set_seed(SEED)

def load_and_preprocess_data():
    """CIFAR-10データの読み込みと前処理"""
    (x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()

    # データの正規化
    x_train = x_train.astype('float32') / 255.0
    x_test = x_test.astype('float32') / 255.0

    # ラベルのワンホットエンコーディング
    y_train = keras.utils.to_categorical(y_train, NUM_CLASSES)
    y_test = keras.utils.to_categorical(y_test, NUM_CLASSES)

    return (x_train, y_train), (x_test, y_test)

def build_cnn_model():
    """CNNモデルの構築"""
    model = keras.Sequential([
        layers.Conv2D(32, (3, 3), activation='relu', input_shape=(IMG_SIZE, IMG_SIZE, 3)),
        layers.MaxPooling2D((2, 2)),
        layers.Conv2D(64, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        layers.Conv2D(64, (3, 3), activation='relu'),
        layers.Flatten(),
        layers.Dense(64, activation='relu'),
        layers.Dense(NUM_CLASSES, activation='softmax')
    ])

    model.compile(
        optimizer='adam',
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )
    return model

def visualize_predictions(model, x_test, y_test, num_samples=5):
    """予測結果の可視化"""
    predictions = model.predict(x_test[:num_samples])
    pred_classes = np.argmax(predictions, axis=1)
    true_classes = np.argmax(y_test[:num_samples], axis=1)

    plt.figure(figsize=(15, 3))
    for i in range(num_samples):
        plt.subplot(1, num_samples, i+1)
        plt.imshow(x_test[i])
        plt.title(f'予測: {CLASS_NAMES[pred_classes[i]]}\n実際: {CLASS_NAMES[true_classes[i]]}')
        plt.axis('off')
    plt.tight_layout()
    plt.show()

def plot_training_history(history):
    """学習履歴の可視化"""
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))

    # 精度のプロット
    ax1.plot(history.history['accuracy'], label='訓練精度')
    ax1.plot(history.history['val_accuracy'], label='検証精度')
    ax1.set_title('モデル精度')
    ax1.set_xlabel('エポック')
    ax1.set_ylabel('精度')
    ax1.legend()

    # 損失のプロット
    ax2.plot(history.history['loss'], label='訓練損失')
    ax2.plot(history.history['val_loss'], label='検証損失')
    ax2.set_title('モデル損失')
    ax2.set_xlabel('エポック')
    ax2.set_ylabel('損失')
    ax2.legend()

    plt.tight_layout()
    plt.show()

# データの読み込みと前処理
(x_train, y_train), (x_test, y_test) = load_and_preprocess_data()

# モデルの構築
model = build_cnn_model()

# モデルの学習
history = model.fit(
    x_train, y_train,
    epochs=EPOCHS,
    batch_size=BATCH_SIZE,
    validation_data=(x_test, y_test),
    verbose=1
)

# 結果の可視化
visualize_predictions(model, x_test, y_test)
plot_training_history(history)

# 最終評価
test_accuracy = model.evaluate(x_test, y_test, verbose=0)[1]
print(f"テスト精度: {test_accuracy:.4f}")
print(f"解釈: 1.0に近いほど予測精度が高く、0.7以上であれば良好とされる")

実行結果の読み方

数値出力の解釈

グラフの読み方

自然言語処理による感情分析プロジェクト

概要

感情分析とは、テキストデータから感情の極性（ポジティブまたはネガティブ）を自動判定する技術である。映画レビューやSNSの投稿などの分析に使用される。

IMDbデータセットは、映画レビューサイトのデータで、「好評価」「低評価」に明確に分類されているため、感情分析の学習に適している。50,000件のレビューからなり、訓練用25,000件、テスト用25,000件に分けられている。英語テキストのため、日本語には直接適用できない点に留意する必要がある。

自然言語処理の特殊概念

単語インデックス：各単語に割り当てられた固有の番号である。コンピューターが文字を数値として処理するための変換である。

実装例

# IMDbレビューデータを使用したLSTM感情分析システム
!apt-get -qq install -y fonts-ipafont-gothic
!pip install japanize-matplotlib tensorflow keras matplotlib numpy pandas scikit-learn
import japanize_matplotlib

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.preprocessing.sequence import pad_sequences
import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

# 定数定義
SEED = 42
EPOCHS = 5
BATCH_SIZE = 32
MAX_WORDS = 10000
MAX_LENGTH = 250
EMBEDDING_DIM = 128
LSTM_UNITS = 64
DROPOUT_RATE = 0.5

# 再現性のためのシード設定
np.random.seed(SEED)
tf.random.set_seed(SEED)

def load_and_preprocess_data():
    """IMDbデータの読み込みと前処理"""
    (x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=MAX_WORDS)

    # パディング処理
    x_train = pad_sequences(x_train, maxlen=MAX_LENGTH)
    x_test = pad_sequences(x_test, maxlen=MAX_LENGTH)

    return (x_train, y_train), (x_test, y_test)

def build_lstm_model():
    """LSTMモデルの構築"""
    model = keras.Sequential([
        layers.Embedding(MAX_WORDS, EMBEDDING_DIM),
        layers.LSTM(LSTM_UNITS, dropout=DROPOUT_RATE, recurrent_dropout=DROPOUT_RATE),
        layers.Dense(1, activation='sigmoid')
    ])

    model.compile(
        optimizer='adam',
        loss='binary_crossentropy',
        metrics=['accuracy']
    )
    return model

def get_word_index():
    """単語インデックスの取得"""
    word_index = keras.datasets.imdb.get_word_index()
    return dict([(value, key) for (key, value) in word_index.items()])

def decode_review(text, reverse_word_index):
    """テキストの復元"""
    return ' '.join([reverse_word_index.get(i-3, '?') for i in text])

def show_predictions(model, x_test, y_test, reverse_word_index, num_samples=5):
    """予測結果の表示"""
    predictions = model.predict(x_test[:num_samples])

    print("予測結果:")
    for i in range(num_samples):
        sentiment = "ポジティブ" if predictions[i][0] > 0.5 else "ネガティブ"
        actual = "ポジティブ" if y_test[i] == 1 else "ネガティブ"
        confidence = predictions[i][0] if predictions[i][0] > 0.5 else 1 - predictions[i][0]
        print(f"レビュー {i+1}: 予測={sentiment} (信頼度: {confidence:.3f}), 実際={actual}")

    print("\nレビュー例:")
    print(decode_review(x_test[0], reverse_word_index))

def plot_training_history(history):
    """学習履歴の可視化"""
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))

    # 精度のプロット
    ax1.plot(history.history['accuracy'], label='訓練精度')
    ax1.plot(history.history['val_accuracy'], label='検証精度')
    ax1.set_title('モデル精度')
    ax1.set_xlabel('エポック')
    ax1.set_ylabel('精度')
    ax1.legend()

    # 損失のプロット
    ax2.plot(history.history['loss'], label='訓練損失')
    ax2.plot(history.history['val_loss'], label='検証損失')
    ax2.set_title('モデル損失')
    ax2.set_xlabel('エポック')
    ax2.set_ylabel('損失')
    ax2.legend()

    plt.tight_layout()
    plt.show()

# データの読み込みと前処理
(x_train, y_train), (x_test, y_test) = load_and_preprocess_data()

print(f"訓練データサイズ: {len(x_train)}")
print(f"テストデータサイズ: {len(x_test)}")
print(f"レビュー例の長さ: {len(x_train[0])}")

# モデルの構築
model = build_lstm_model()

# モデルの学習
history = model.fit(
    x_train, y_train,
    epochs=EPOCHS,
    batch_size=BATCH_SIZE,
    validation_data=(x_test, y_test),
    verbose=1
)

# 単語インデックスの取得
reverse_word_index = get_word_index()

# 結果の表示
show_predictions(model, x_test, y_test, reverse_word_index)
plot_training_history(history)

# 最終評価
test_accuracy = model.evaluate(x_test, y_test, verbose=0)[1]
print(f"\nテスト精度: {test_accuracy:.4f}")
print(f"解釈: 0.8以上であれば実用的な感情分析性能とされる")

実行結果の読み方

数値出力の解釈

グラフの読み方

時系列データ予測システムの構築

概要

時系列予測とは、時間とともに変化するデータから未来の値を予測する技術である。株価、売上、気温などの予測に使用される。

本例では、実際の株価データを使用して予測を行う。株価は経済情勢や企業業績など多くの要因に影響されるため、完全な予測は困難であることを理解しておく必要がある。

時系列分析の特殊概念

時系列データ：時間順に並んだデータである。

逆正規化：正規化されたデータを元の範囲に戻す処理である。予測結果を実際の価格として解釈するために必要である。

シーケンス化：過去の一定期間のデータから未来の値を予測するため、データを時系列の組み合わせに変換する処理である。期間が短すぎると情報不足、長すぎると計算負荷が増大する。

実装例

# 株価データを使用したLSTM時系列予測システム
!apt-get -qq install -y fonts-ipafont-gothic
!pip install japanize-matplotlib yfinance tensorflow keras matplotlib numpy pandas scikit-learn
import japanize_matplotlib

import yfinance as yf
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error
import warnings
warnings.filterwarnings('ignore')

# 定数定義
SEED = 42
TICKER_SYMBOL = "AAPL"
PERIOD = "2y"
SEQUENCE_LENGTH = 60
EPOCHS = 10
BATCH_SIZE = 32
TRAIN_RATIO = 0.8
LSTM_UNITS = [50, 50]
DENSE_UNITS = 25

# 再現性のためのシード設定
np.random.seed(SEED)
tf.random.set_seed(SEED)

def fetch_stock_data(ticker, period):
    """株価データの取得"""
    try:
        ticker_obj = yf.Ticker(ticker)
        stock_data = ticker_obj.history(period=period)
        df = pd.DataFrame({'price': stock_data['Close']})
        return df
    except Exception as e:
        print(f"データ取得エラー: {e}")
        return None

def create_sequences(data, seq_length):
    """時系列データの作成"""
    X, y = [], []
    for i in range(len(data) - seq_length):
        X.append(data[i:(i + seq_length), 0])
        y.append(data[i + seq_length, 0])
    return np.array(X), np.array(y)

def build_lstm_model(seq_length):
    """LSTMモデルの構築"""
    model = keras.Sequential([
        layers.LSTM(LSTM_UNITS[0], return_sequences=True, input_shape=(seq_length, 1)),
        layers.LSTM(LSTM_UNITS[1], return_sequences=False),
        layers.Dense(DENSE_UNITS),
        layers.Dense(1)
    ])

    model.compile(optimizer='adam', loss='mean_squared_error')
    return model

def prepare_plot_data(scaled_data, train_pred, test_pred, seq_length):
    """プロット用データの準備"""
    train_plot = np.empty_like(scaled_data)
    train_plot[:, :] = np.nan
    train_plot[seq_length:len(train_pred)+seq_length, :] = train_pred

    test_plot = np.empty_like(scaled_data)
    test_plot[:, :] = np.nan
    test_start_idx = len(train_pred) + seq_length
    test_end_idx = test_start_idx + len(test_pred)
    test_plot[test_start_idx:test_end_idx, :] = test_pred

    return train_plot, test_plot

def plot_results(scaled_data, train_plot, test_plot, scaler):
    """結果の可視化"""
    plt.figure(figsize=(15, 6))
    plt.plot(scaler.inverse_transform(scaled_data), label='実際の価格', linewidth=2)
    plt.plot(train_plot, label='訓練予測', alpha=0.7)
    plt.plot(test_plot, label='テスト予測', alpha=0.7)
    plt.title('株価予測結果', fontsize=14)
    plt.xlabel('日数')
    plt.ylabel('価格')
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.show()

def plot_training_history(history):
    """学習履歴の可視化"""
    plt.figure(figsize=(8, 4))
    plt.plot(history.history['loss'], label='訓練損失')
    plt.plot(history.history['val_loss'], label='検証損失')
    plt.title('モデル損失')
    plt.xlabel('エポック')
    plt.ylabel('損失')
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.show()

# データの取得
df = fetch_stock_data(TICKER_SYMBOL, PERIOD)
if df is None:
    exit()

print(f"データサイズ: {len(df)}")
print(df.head())

# データの正規化
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(df['price'].values.reshape(-1, 1))

# 時系列データの準備
X, y = create_sequences(scaled_data, SEQUENCE_LENGTH)

# 訓練・テストデータの分割
train_size = int(len(X) * TRAIN_RATIO)
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]

# データの形状変更（LSTM用）
X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))

# モデルの構築
model = build_lstm_model(SEQUENCE_LENGTH)

# モデルの学習
history = model.fit(
    X_train, y_train,
    batch_size=BATCH_SIZE,
    epochs=EPOCHS,
    validation_data=(X_test, y_test),
    verbose=1
)

# 予測の実行
train_predictions = model.predict(X_train)
test_predictions = model.predict(X_test)

# 予測結果の逆正規化
train_predictions = scaler.inverse_transform(train_predictions)
test_predictions = scaler.inverse_transform(test_predictions)
y_train_actual = scaler.inverse_transform(y_train.reshape(-1, 1))
y_test_actual = scaler.inverse_transform(y_test.reshape(-1, 1))

# プロット用データの準備
train_plot, test_plot = prepare_plot_data(scaled_data, train_predictions, test_predictions, SEQUENCE_LENGTH)

# 結果の可視化
plot_results(scaled_data, train_plot, test_plot, scaler)

# 精度の計算
train_rmse = np.sqrt(mean_squared_error(y_train_actual, train_predictions))
test_rmse = np.sqrt(mean_squared_error(y_test_actual, test_predictions))

print(f'訓練RMSE: {train_rmse:.2f}')
print(f'テストRMSE: {test_rmse:.2f}')
print(f'解釈: RMSE値が小さいほど予測精度が高く、テストRMSEが訓練RMSEより大きいのは正常である')

# 学習履歴の表示
plot_training_history(history)

実行結果の読み方

数値出力の解釈

グラフの読み方

データの可視化・分析プロジェクト

概要

データ分析とは、データに含まれる傾向やパターンを発見し、有用な情報を抽出する技術である。

Irisデータセットは、アヤメの花の測定データであり、統計学・機械学習の教材として広く使用されている。データが整理済みで欠損値がないため、データ分析の基本手法を学ぶのに適しているが、実際のデータはより複雑であることに留意する必要がある。

データ分析の特殊概念

基本統計量：平均、標準偏差、最大値、最小値などのデータの基本的な特徴を表す数値である。

ヒストグラム：データの分布を表示するグラフである。

散布図：2つの変数の関係を点で表示するグラフである。

箱ひげ図（box plot）：データの分布を四分位数で表示するグラフである。

相関係数：2つの変数間の関係の強さを-1から1の値で表す指標である。線形関係のみを測定するため、非線形関係は検出できない。

ヒートマップ：数値データを色の濃淡で表現したグラフである。多変数間の関係を把握できる。

実装例

# Irisデータセットの統計分析・可視化システム
!apt-get -qq install -y fonts-ipafont-gothic
!pip install japanize-matplotlib matplotlib numpy pandas seaborn scipy scikit-learn
import japanize_matplotlib

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_iris
from IPython.display import Javascript, display
import warnings
warnings.filterwarnings('ignore')

# 出力セルの高さ制限を増加
display(Javascript('''
google.colab.output.setIframeHeight(0, true, {maxHeight: 5000})
'''))

# 定数定義
SEED = 42
SPECIES_NAMES = ['setosa', 'versicolor', 'virginica']
FEATURE_NAMES_JP = ['がく片の長さ', 'がく片の幅', '花弁の長さ', '花弁の幅']

# 再現性のためのシード設定
np.random.seed(SEED)

def load_iris_data():
    """Irisデータの読み込み"""
    iris = load_iris()
    df = pd.DataFrame(iris.data, columns=iris.feature_names)
    df['species'] = iris.target_names[iris.target]
    return df

def display_basic_info(df):
    """基本情報の表示"""
    print("=== データセット基本情報 ===")
    print(f"データサイズ: {df.shape}")
    print(f"欠損値: {df.isnull().sum().sum()}")
    print(f"数値特徴量: {len(df.select_dtypes(include=[np.number]).columns)}")
    print(f"カテゴリ特徴量: {len(df.select_dtypes(include=['object']).columns)}")
    print()
    print("データ例:")
    print(df.head())
    print()
    print("基本統計量:")
    print(df.describe())

def create_comprehensive_plots(df):
    """包括的な可視化"""
    fig, axes = plt.subplots(3, 2, figsize=(15, 18))

    # 1. ヒストグラム
    axes[0, 0].set_title('がく片の長さ分布', fontsize=12)
    for species in df['species'].unique():
        subset = df[df['species'] == species]
        axes[0, 0].hist(subset['sepal length (cm)'], alpha=0.7, label=species, bins=15)
    axes[0, 0].set_xlabel('長さ (cm)')
    axes[0, 0].set_ylabel('頻度')
    axes[0, 0].legend()
    axes[0, 0].grid(True, alpha=0.3)

    # 2. 散布図
    axes[0, 1].set_title('がく片の長さ vs 幅', fontsize=12)
    for species in df['species'].unique():
        subset = df[df['species'] == species]
        axes[0, 1].scatter(subset['sepal length (cm)'], subset['sepal width (cm)'],
                          label=species, alpha=0.7, s=60)
    axes[0, 1].set_xlabel('がく片の長さ (cm)')
    axes[0, 1].set_ylabel('がく片の幅 (cm)')
    axes[0, 1].legend()
    axes[0, 1].grid(True, alpha=0.3)

    # 3. 箱ひげ図
    axes[1, 0].set_title('種別の花弁長さ比較', fontsize=12)
    df.boxplot(column='petal length (cm)', by='species', ax=axes[1, 0])
    axes[1, 0].set_xlabel('種')
    axes[1, 0].set_ylabel('花弁の長さ (cm)')
    axes[1, 0].grid(True, alpha=0.3)

    # 4. 相関行列ヒートマップ
    axes[1, 1].set_title('特徴量間の相関', fontsize=12)
    correlation_matrix = df.select_dtypes(include=[np.number]).corr()
    sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', center=0,
                ax=axes[1, 1], fmt='.3f')

    # 5. 花弁の散布図
    axes[2, 0].set_title('花弁の長さ vs 幅', fontsize=12)
    for species in df['species'].unique():
        subset = df[df['species'] == species]
        axes[2, 0].scatter(subset['petal length (cm)'], subset['petal width (cm)'],
                          label=species, alpha=0.7, s=60)
    axes[2, 0].set_xlabel('花弁の長さ (cm)')
    axes[2, 0].set_ylabel('花弁の幅 (cm)')
    axes[2, 0].legend()
    axes[2, 0].grid(True, alpha=0.3)

    # 6. 特徴量分布の violin plot
    axes[2, 1].set_title('特徴量分布の比較', fontsize=12)
    df_melted = df.melt(id_vars=['species'], var_name='feature', value_name='value')
    sns.violinplot(data=df_melted, x='species', y='value', ax=axes[2, 1])
    axes[2, 1].set_xlabel('種')
    axes[2, 1].set_ylabel('測定値')
    axes[2, 1].tick_params(axis='x', rotation=45)

    plt.tight_layout()
    plt.show()

def calculate_correlation_stats(df):
    """相関統計の計算"""
    correlation_matrix = df.select_dtypes(include=[np.number]).corr()

    # 最大相関係数の計算
    upper_triangle = correlation_matrix.where(
        np.triu(np.ones(correlation_matrix.shape), k=1).astype(bool)
    )
    max_corr = upper_triangle.abs().max().max()

    # 最大相関のペア
    max_corr_idx = upper_triangle.abs().stack().idxmax()

    return correlation_matrix, max_corr, max_corr_idx

def display_analysis_summary(df, correlation_matrix, max_corr, max_corr_idx):
    """分析結果サマリーの表示"""
    print("\n=== 分析結果サマリー ===")
    print(f"最大相関係数: {max_corr:.3f}")
    print(f"最大相関ペア: {max_corr_idx[0]} - {max_corr_idx[1]}")
    print()

    # 各種の基本統計
    print("種別統計:")
    for species in df['species'].unique():
        subset = df[df['species'] == species]
        print(f"{species}: {len(subset)}件")

    print()
    print("相関解釈:")
    print("- 相関係数の絶対値が0.7以上: 強い相関")
    print("- 相関係数の絶対値が0.3-0.7: 中程度の相関")
    print("- 相関係数の絶対値が0.3未満: 弱い相関")

# データの読み込み
df = load_iris_data()

# 基本情報の表示
display_basic_info(df)

# 包括的な可視化
create_comprehensive_plots(df)

# 相関統計の計算
correlation_matrix, max_corr, max_corr_idx = calculate_correlation_stats(df)

# 分析結果サマリーの表示
display_analysis_summary(df, correlation_matrix, max_corr, max_corr_idx)

実行結果の読み方

数値出力の解釈

グラフの読み方

学習結果の共通評価方法

精度評価の共通指標

訓練精度と検証精度の関係：

損失値の推移：

各タスクの性能基準

画像分類（CIFAR-10）：テスト精度0.7以上で良好、0.5未満は学習失敗の可能性

感情分析（IMDb）：テスト精度0.8以上で実用的、0.6未満は学習パラメータの見直しが必要

時系列予測（株価）：テストRMSEが訓練RMSEの2倍未満であれば正常、2倍以上は過学習の可能性