Google Colaboratory

【概要】Google Colaboratoryは、セットアップ不要で無料利用可能なオンラインのJupyter Notebookサービスである。GPU・TPUを含むコンピューティングリソースへのアクセスを提供し、機械学習、データサイエンス、教育に適している。利用にはGoogleアカウントが必要である。他者が公開したノートブックの閲覧のみであれば、Googleアカウントは不要である。

【目次】

Google Colaboratoryとは
Googleアカウントの設定
Google Colaboratoryの基本操作
トラブルシューティング
制限事項と制約
演習
Google Colaboratory操作ガイド
Google Colaboratory実践ガイド

【資料】

PowerPoint版: googlecolab.pptx、PDF版: googlecolab.pdf

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

【サイト内のPython関連主要ページ】

Windows AI支援Python開発環境構築ガイド: 別ページ »で説明
AIエディタ Windsurf の活用: 別ページ »で説明
AIエディタCursorガイド: 別ページ »で説明
Google Colaboratory: 別ページ »で説明
Python（Google Colaboratoryを含む）のまとめ: 別ページ »で説明
機械学習の Python 実現ガイド: 別ページ »で説明
行列計算の Python 実現ガイド: 別ページ »で説明
統計分析のPython での実現ガイド: 別ページ »で説明
音声信号処理の Python 実現ガイド: 別ページ »で説明
カラー画像処理の Python 実現ガイド: 別ページ »で説明
Python 言語によるとても簡単なアドベンチャーゲーム（変数，式，if，while，関数，print，time.sleep, def, global を使用）: 別ページ »で説明
Pythonプログラミング講座：基礎から応用まで（授業資料，全15回）: 別ページ »で説明
Pythonプログラミングの例と実践ガイド: 別ページ »で説明

【外部リソース】

Pythonの公式サイト: https://www.python.org
東京大学の「Pythonプログラミング入門」: https://utokyo-ipp.github.io/IPP_textbook.pdf
ITmedia社の「Pythonチートシート」の記事: https://atmarkit.itmedia.co.jp/ait/articles/2004/20/news015.html

Google Colaboratoryとは

基本概念

ノートブックは、プログラムコードと説明文を組み合わせた文書形式である。セルは、ノートブック内の編集可能な個別の単位である。ランタイムは、プログラムが実際に実行される環境である。

Google Colaboratoryについて

Google ColaboratoryのURLは、https://colab.research.google.com/ である。オンラインのJupyter Notebookサービスであり、セットアップ不要で無料利用可能である。GPU（Graphics Processing Unit、画像処理装置）やTPU（Tensor Processing Unit、機械学習専用プロセッサ）を含むコンピューティングリソースへのアクセスを提供する。機械学習、データサイエンス、教育に適している。利用にはGoogleアカウントが必要である。ただし、他者が公開したノートブックの閲覧のみであれば、Googleアカウントは不要である。

GPU・TPUを使用すると、大量のデータを並列処理でき、機械学習モデルの学習時間を短縮できる。

ノートブックの構造

ノートブックは2種類のセルで構成される。コードセルは、Pythonプログラム、コマンド、実行結果を表示する。テキストセルは、説明文、図表を表示する。

画面構成

Webブラウザ上の画面は、左側メニュー（目次、検索と置換、変数、ファイル）、上部メニューバー、コードセルとテキストセルの追加ボタン、セルの配置エリアで構成される。

対応ブラウザ

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

Google Chrome（最新版）
Firefox（最新版および直前のメジャーバージョン）
Safari（最新版および直前のメジャーバージョン）

最新版の使用を推奨する。

他の開発環境との比較

Jupyter Notebookは、ローカル環境で動作し、セットアップが必要だが、制限はない。VS Codeおよびその派生版（Windsurfなど）は、統合開発環境であり、多言語対応で拡張機能が豊富である。Google Colaboratoryは、クラウド環境で動作し、セットアップが不要で、GPU・TPUを利用できる。

Googleアカウントの設定

Googleアカウントの取得

Googleアカウントは無料で取得できる。登録に必要な情報は、氏名、メールアドレス、パスワード、電話番号（本人確認用）、生年月日、性別である。

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

セキュリティ対策と注意事項は以下の通りである。

二段階認証を設定する
公開ノートブックでは個人情報を記載しない
アカウント乗っ取り防止のため強固なパスワードを使用する
企業や組織での利用時は機密情報の取り扱いに注意する

Googleアカウントについて

Googleアカウントは、Googleが提供するオンラインサービスを利用するためのアカウントである。ユーザーIDとパスワードで構成され、利用者が設定する。Google Colaboratoryを含む各種サービスで利用できる。Gmail、Google Drive、Google Cloudなどのサービスと連携する。

Google ColaboratoryとGoogleアカウント

Google Colaboratoryの利用にはGoogleアカウントが必要である。

Googleアカウントで利用できる機能は以下の通りである。

ノートブックの新規作成、編集、保存、公開
Pythonプログラムの編集、実行
システム操作コマンド（!pip、%cdなど）の実行
ファイルのアップロード、ダウンロード

Googleアカウントなしで利用できる機能は、他者が公開したノートブックの閲覧である。

Googleアカウント取得手順

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

アカウント取得のまとめ

Googleアカウントは無料で取得可能である。必要な登録情報は、氏名、メールアドレス、パスワード、電話番号（本人確認用）、生年月日、性別である。Googleのオンラインサービス（Google Colaboratoryなど）で利用可能である。

手順は以下の通りである。

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

Google Colaboratoryの基本操作

ログイン手順

Google Colaboratoryの使用中に「Googleへのログインが必要」と表示された場合、以下の手順でログインする。

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

実行の流れ

ノートブックの基本的な実行の流れは以下の通りである。

WebブラウザでGoogle Colaboratoryにアクセスする（https://colab.research.google.com/ にアクセスする）
Googleアカウントでログインする
セルの編集と実行を行う
- テキストセルでは説明文を作成する
- コードセルではPythonプログラムを作成し実行する
実行順序は通常、上から下へ順次実行する

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

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

実行方法は以下の通りである。

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

基本操作の要点

アクセス方法は、Webブラウザから https://colab.research.google.com/ にアクセスする。

セルの種類は以下の通りである。

コードセルはPythonプログラムの編集と実行用である
テキストセルは説明文、図表の表示用である

基本操作について、前提条件はGoogleアカウントでのログインが必要である。主な操作は、セルの編集、実行、新規ノートブックの作成である。保存機能は、Google Driveに自動保存される。実行方法は、「ランタイム」メニューから「すべてのセルを実行」で一括実行が可能である。

バージョン管理について、Google Driveで変更履歴が自動保存される。複数人での共同編集ができる。編集中は他の編集者の変更がリアルタイムで反映される。

トラブルシューティング

セッション管理

システムの混雑時や長時間実行時に処理が停止し、再開しない場合がある。セッションは、Google Colaboratoryでコードを実行するための作業環境である。

対処方法は以下の通りである。

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

エラー対処法

よくあるエラーと対処法は以下の通りである。

ライブラリインストールエラーは、!pip install ライブラリ名でインストールする
メモリ不足エラーは、「ランタイム」から「ファクトリーリセット」で環境を初期化する
ファイル読み込みエラーは、ファイルパスとファイル名を確認する

エラー解決の基本手順は以下の通りである。

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

制限事項と制約

実行時間制限

無料版では最大12時間の実行時間制限がある（利用状況により変動する）。Colab Pro+では、十分なコンピュートユニットがある場合、最大24時間の連続実行が可能である。

計算資源の制限

CPUはIntel Xeonプロセッサである（コア数は変動する）。メモリは標準メモリプロファイル（無料版）、高メモリプロファイル（有料版、利用状況による）である。ストレージは約100GBの一時ディスク容量である。GPU・TPUは種類が時期により変動する（無料版では制限がある）。

禁止されている使用方法

以下の使用方法は禁止されている。

ファイルホスティング、メディア配信
トレントダウンロード、P2Pファイル共有
リモートプロキシへの接続
暗号通貨のマイニング
サービス拒否攻撃の実行
パスワードクラッキング
複数アカウントによる制限回避
ディープフェイクの作成
SSHシェル、リモートデスクトップの使用（無料版）
チェストレーニング（無料版）
分散コンピューティングワーカーの実行（無料版）

演習

トピックスは以下の通りである。

Google Colaboratory
コードセルの作成
Pythonプログラムの実行

演習手順

Google ColaboratoryのWebページを開く（https://colab.research.google.com）
「ファイル」で「ノートブックを新規作成」を選択する

Googleアカウントでのログインが求められたときはログインする

コードセルを新規作成する（メニューの「+ コード」をクリックする）

コードセルにPythonプログラムを記述する
```
x = 100
```
変数xに整数値100を代入する。

コードセルを新規作成する（メニューの「+ コード」をクリックする）

コードセルにPythonプログラムを記述する
```
if x > 20:
  print("big")
else:
  print("small")
```
変数xの値が20より大きい場合は"big"、そうでなければ"small"を出力する。

記述のポイントは以下の通りである。
- if x > 20の直後に「:」（コロン）を記述する
- elseの直後に「:」（コロン）を記述する
コードセルを新規作成する（メニューの「+ コード」をクリックする）

コードセルに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つである
コードセルを順次実行し、実行結果を確認する
各コードセルの実行手順は以下の通りである。
1. 最初のコードセル（変数代入）の実行ボタンをクリックする
2. 2番目のコードセル（条件分岐）の実行ボタンをクリックする（"big"が出力される）
3. 3番目のコードセル（ループ処理）の実行ボタンをクリックする（"15"が出力される）
セルは上から順番に実行する。

Google Colaboratory操作ガイド

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

Google Colaboratoryへのファイルアップロード方法は以下の通りである。

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

システム環境の確認

基本環境情報の確認

利用可能なハードウェアとソフトウェア環境を事前に確認する。

# システム情報の確認
!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()

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

複数ファイルの処理

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

# 複数ファイルの処理
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で日本語表示が可能になる。

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

定期的な保存設定

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

# モデルの定期保存
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以上であれば良好とされる")

実行結果の読み方

数値出力の解釈について、テスト精度は0.0から1.0の範囲で表示される。1.0に近いほど予測精度が高くなる。0.7以上であれば良好とされる。0.5未満の場合は学習が失敗している可能性がある。

グラフの読み方について、予測結果表示では5枚の画像について予測ラベルと実際のラベルが表示される。正解している場合は予測が成功している。学習履歴グラフでは、訓練精度と検証精度の線が両者とも近い値で上昇していれば正常な学習である。検証精度が訓練精度より大幅に低い場合は過学習の可能性がある。検証精度が上昇しない場合はエポック数を増やすか学習率を調整する。訓練損失と検証損失の線が両者とも減少傾向にあれば学習が進行している。検証損失が上昇に転じた場合は過学習の兆候である。損失が減少しない場合はパラメータの再調整が必要である。

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

概要

感情分析とは、テキストデータから感情の極性（ポジティブまたはネガティブ）を自動判定する技術である。映画レビューや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以上であれば実用的な感情分析性能とされる")

実行結果の読み方

数値出力の解釈について、データサイズでは訓練用とテスト用のデータ件数が表示される。予測結果では、予測ラベル（ポジティブまたはネガティブ）と実際のラベルが比較表示される。信頼度は0.0から1.0の範囲で、1.0に近いほど予測に確信がある。0.8以上であれば信頼度が高いとされる。0.5に近い場合は判断が曖昧で、モデルの改良が必要である。テスト精度は全体的な予測精度である。感情分析では0.8以上であれば実用的とされる。0.6未満の場合は学習パラメータの見直しが必要である。

グラフの読み方について、学習履歴グラフは画像分類と同様に、訓練精度と検証精度、訓練損失と検証損失の推移を確認する。自然言語処理では学習に時間がかかるため、エポック数を増やすことで精度が向上する場合がある。

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

概要

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

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

時系列分析の特殊概念

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

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

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

実装例

# 株価データを使用した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)

実行結果の読み方

数値出力の解釈について、データサイズでは使用するデータの件数が表示される。RMSE値について、訓練RMSEは訓練データに対する予測誤差である。テストRMSEはテストデータに対する予測誤差である。値が小さいほど予測精度が高くなる。テストRMSEが訓練RMSEより大きくなるのは正常である。テストRMSEが訓練RMSEの2倍以上の場合は過学習の可能性がある。

グラフの読み方について、時系列予測グラフでは実際の価格（青線）は元の時系列データである。訓練予測（オレンジ線）は訓練期間での予測結果である。実際値に近いほど学習が成功している。テスト予測（緑線）は未知データでの予測結果である。実際値との乖離が小さいほど予測性能が良い。学習損失グラフでは、訓練損失と検証損失が共に減少していれば正常な学習である。検証損失が上昇に転じた場合は学習を停止するタイミングである。

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

概要

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

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)

実行結果の読み方

数値出力の解釈について、基本統計量は平均、標準偏差、最大値、最小値などデータの基本的な特徴である。外れ値の存在や分布の偏りを確認できる。相関係数は-1.0から1.0の範囲で、絶対値が0.7以上であれば強い相関があるとされる。0に近い場合は関係性が弱いことを示す。

グラフの読み方について、ヒストグラムでは各特徴量の分布形状を確認する。正規分布に近いか、偏りがあるかを判断する。散布図では2つの特徴量間の関係を視覚的に確認する。点が直線状に並んでいれば相関がある。箱ひげ図ではグループ間の特徴量の違いを比較する。箱の位置や大きさで分布の差を判断する。ヒートマップでは色の濃淡で相関の強さを表示する。赤は正の相関、青は負の相関を示す。

学習結果の共通評価方法

精度評価の共通指標

訓練精度と検証精度の関係について、両者が近い値で上昇している場合は正常な学習である。検証精度が訓練精度より大幅に低い場合は過学習の可能性がある。検証精度が上昇しない場合は学習パラメータの調整が必要である。

損失値の推移について、訓練損失と検証損失が共に減少している場合は正常な学習進行である。検証損失が上昇に転じた場合は過学習の兆候であり、学習停止のタイミングである。損失が減少しない場合はパラメータの再調整が必要である。

各タスクの性能基準

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

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

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