Pythonで学ぶ機械学習：Transformerを使ったテキスト生成

機械学習の具体的な問題にPythonを使って、機械学習もPythonも同時に学んでしまいましょう。今回はTransformerを使ったテキスト生成についてまとめました。Transformerは、ChatGPTやBERTの基盤となるモデルで、自然言語処理（Natural Languege Processing, NLP）において非常に重要です。その特徴は、自己注意機構（Self-Attention）によって文の重要な部分にフォーカスできること、並列計算が可能で従来のRNNよりも高速に学習できることです。

この記事では transformers ライブラリおよび Pytorch ライブラリを用います。適宜

pip install transformers torch

などによってダウンロード・インストールしてください。ただしPythonのバージョンによってはうまく実行されないこともあります。場合によっては uv などの仮想環境で対処する必要があります。

テキスト生成の実装

transformers ライブラリを使って、GPT-2 による文章生成を行ってみます。

from transformers import pipeline

# テキスト生成モデル（GPT-2）をロード
generator = pipeline("text-generation", model="gpt2")

# 文章生成
prompt = "The long and winding road that leads to your door"
generated_texts = generator(prompt, max_length=50, num_return_sequences=3)

# 結果表示
for i, text in enumerate(generated_texts):
    print(f"生成された文章 {i+1}:\n{text['generated_text']}\n")

• 生成された文章 1:
  • The long and winding road that leads to your door is just another hurdle in making the journey a true adventure for all of you. Here's the video guide you'll need to navigate the dark tunnel that led into the castle...How do you

• 生成された文章 2:
  • The long and winding road that leads to your door takes you to a great view of Lake Zurich. L.A. The best view of LA, from the back is the spectacular Hotel San Gabriel in the heart of downtown. It

• 生成された文章 3:
  • The long and winding road that leads to your door is called "Equestria and the Kingdom", where you will take in the gorgeous castle scene from Huckleberry Finn who plays the titular king in an episode of "Frozen".

ポイント

• pipeline("text-generation", model="gpt2")
  • GPT-2 を使って文章生成を行う
• generator(prompt, max_length=50, num_return_sequences=3)
  • 最大50単語の文章を3つ生成する

キーワード：機械学習、Python、基礎

Pythonで学ぶ機械学習：主成分分析

機械学習の具体的な問題にPythonを使って、機械学習もPythonも同時に学んでしまいましょう。今回は主成分分析についてまとめました。機械学習では、特徴量が多すぎると計算コストが増えたり、過学習を起こしやすくなったりします。そこで PCA（Principal Component Analysis：主成分分析）を使って、重要な情報を保持しながらデータの次元を削減する方法を学びます。

この記事では scikit-learn（sklearn）ライブラリを用います。適宜

pip install scikit-learn

などによってダウンロード・インストールしてください。

PCAの実装

PCAでは、データの分散が最大になる方向を主成分として抽出し、高次元のデータを低次元（2次元や3次元など）に圧縮します。この手法は、画像圧縮や可視化にも使われます。実装は以下の通りです：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.datasets import load_iris

# データセット（Irisデータ）
data = load_iris()
X = data.data  # 4次元の特徴量
y = data.target  # クラス（0, 1, 2）

# PCAで2次元に圧縮
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# グラフ描画
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='viridis', edgecolors='k')
plt.xlabel("Principal Component 1")
plt.ylabel("Principal Component 2")
plt.title("PCA Reductioin (Iris data)")
plt.colorbar(label="Class")
plt.show()

ポイント

• PCA(n_components=2) で2次元に圧縮
• pca.fit_transform(X) でデータを変換
• 2次元に削減することでデータの構造を可視化できる

PCAの累積寄与率の確認

PCAでは、どれくらいの情報を保持できているかを確認することが重要です。これを累積寄与率（Explained Variance Ratio）を使って確認します。累積寄与率とは、各主成分がデータの情報をどれだけ保持しているかを表す割合で、累積寄与率が90%以上なら十分な情報を保持できていると考えられます。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.datasets import load_iris

# データセット（Irisデータ）
data = load_iris()
X = data.data  # 4次元の特徴量

# PCA（すべての主成分を計算）
pca = PCA()
pca.fit(X)

# 寄与率（各主成分の情報量）を取得
explained_variance_ratio = pca.explained_variance_ratio_

# 累積寄与率を計算
cumulative_variance = np.cumsum(explained_variance_ratio)

# グラフ描画
plt.plot(range(1, len(cumulative_variance) + 1),
         cumulative_variance,
         marker='o',
         linestyle='--')
plt.xlabel("Number of PC")
plt.ylabel("EVR")
plt.title("PCA EVR")
plt.grid(True)
plt.show()

ポイント

• pca.explained_variance_ratio_ で各主成分の寄与率を取得
• np.cumsum() で累積寄与率を計算
• 累積寄与率が90%を超える最小の主成分数を確認すると、適切な次元数がわかる

キーワード：機械学習、Python、基礎

Pythonで学ぶ機械学習：サポートベクターマシン

機械学習の具体的な問題にPythonを使って、機械学習もPythonも同時に学んでしまいましょう。今回はサポートベクターマシン（SVM）を使った分類についてまとめました。SVMは、データを分ける最適な境界線（超平面）を見つけるアルゴリズムです。

この記事では scikit-learn（sklearn）ライブラリを用います。適宜

pip install scikit-learn

などによってダウンロード・インストールしてください。

SVMの実装

SVMでは、データを分類するマージン（余白）が最大になるように境界線を決めます。境界線は必ずしも直線である必要はなく、カーネル（kernel）の選択によって、線形分離できないデータも分類可能になります：

• linear（線形）
• rbf（非線形、よく使われる）
• poly（多項式）

ここではまず線形SVMを考えます。実装は以下の通りです：

import numpy as np
from sklearn.svm import SVC

# サンプルデータ（特徴量Xとクラスy）
X = np.array([[1], [2], [3], [6], [7], [8]])  # 特徴量
y = np.array([0, 0, 0, 1, 1, 1])  # クラス（0 or 1）

# モデル作成（線形SVM）
model = SVC(kernel='linear', C=1.0)
model.fit(X, y)

# 予測
X_test = np.array([[4], [5]])  # 新しいデータ
y_pred = model.predict(X_test)

print("予測結果:", y_pred)  # 4と5はどのクラスに分類されるか？

予測結果: [0 1]

ポイント

• SVC (kernel='linear', C=1.0)
  • 線形SVM を使用（kernel='linear'）
  • C はマージンの調整（大きいと誤分類を許さない、小さいと汎化性が高まる）
• model.fit(X, y) で学習
• model.predict(X_test) で分類

SVMの決定境界の可視化

上で扱ったデータセットの分類で、SVMがどのようにクラスを分けているのか、グラフを使って可視化してみます。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVC

# サンプルデータ（特徴量Xとクラスy）
X = np.array([[1], [2], [3], [6], [7], [8]])  # 特徴量
y = np.array([0, 0, 0, 1, 1, 1])  # クラス（0 or 1）

# モデル作成（線形SVM）
model = SVC(kernel='linear', C=1.0)
model.fit(X, y)

# 決定境界を可視化
X_test = np.linspace(0, 9, 100).reshape(-1, 1)  # 0～9の範囲で細かく分割
y_pred = model.predict(X_test)  # 各点の分類結果

# グラフ描画
plt.scatter(X, y, color="blue", label="Data")  # 実際のデータ
plt.scatter(X_test, y_pred,
            color="red", s=5,
            label="SVM classification")  # 予測結果

# タイトルとラベル
plt.title("SVM Decision Boundary")
plt.xlabel("Feature")
plt.ylabel("Class")
plt.legend()
plt.show()

ポイント

• X_test = np.linspace(0, 9, 100).reshape(-1, 1)
  • 細かいテストデータを作成して決定境界を確認する
• plt.scatter(X_test, y_pred, color="red", s=5)
  • 小さい赤点で各点の予測結果を可視化

非線形な分類

上ではカーネルとして線形の場合を考えましたが、非線形な場合も考えてみましょう。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVC

# サンプルデータ（非線形分布）
X = np.array([[1], [2], [3], [7], [8], [9]])  # 特徴量
y = np.array([0, 0, 1, 1, 0, 0])  # クラス（0 or 1）

# モデル作成（非線形SVM: RBFカーネル）
model = SVC(kernel='rbf', C=1.0, gamma='auto')
model.fit(X, y)

# 決定境界を可視化
X_test = np.linspace(0, 10, 100).reshape(-1, 1)  # 0～10の範囲でテストデータ作成
y_pred = model.predict(X_test)  # 各点の分類結果

# グラフ描画
plt.scatter(X, y, color="blue", label="Data")  # 実際のデータ
plt.scatter(X_test, y_pred, color="red", s=5, label="SVM Classification")  # 予測結果

# タイトルとラベル
plt.title("SVM (RBF kernel) Decision Boundary")
plt.xlabel("Feature")
plt.ylabel("Class")
plt.legend()
plt.show()

ポイント

• kernel='rbf' で 非線形分類 に対応
• gamma='auto' で データに応じた適切な曲線を引く

キーワード：機械学習、Python、基礎

Pythonで学ぶ機械学習：ランダムフォレスト

機械学習の具体的な問題にPythonを使って、機械学習もPythonも同時に学んでしまいましょう。今回はランダムフォレスト（Random Forest）を使った分類についてまとめました。ランダムフォレストは決定木を複数組み合わせて、より高精度な分類を実現するアルゴリズムです。ランダムフォレストは過学習を抑えつつ、高い予測精度を得ることができます。

この記事では scikit-learn（sklearn）ライブラリを用います。適宜

pip install scikit-learn

などによってダウンロード・インストールしてください。

ランダムフォレストの実装

ランダムフォレストでは、複数の決定木を作成し、それらの多数決で最終的な予測を決定します。１本の決定木に比べて過学習が起こりにくいという特徴があります。決定木ごとにランダムにデータを選ぶことで、多様性を持たせています。実装は以下の通りです：

from sklearn.ensemble import RandomForestClassifier
import numpy as np

# サンプルデータ（特徴量Xとクラスy）
X = np.array([[1], [2], [3], [6], [7], [8]])  # 特徴量
y = np.array([0, 0, 0, 1, 1, 1])  # クラス（0 or 1）

# モデル作成（決定木を5本使用）
model = RandomForestClassifier(n_estimators=5, max_depth=3, random_state=42)
model.fit(X, y)

# 予測
X_test = np.array([[4], [5]])  # 新しいデータ
y_pred = model.predict(X_test)

print("予測結果:", y_pred)  # 4と5はどのクラスに分類されるか？

予測結果: [0 1]

ポイント

• RandomForestClassifier(n_estimators=5, max_depth=3, random_state=42)
  • 5本の決定木を使い、最大深さ3、ランダムシード42で学習
• model.fit(X, y) で学習
• model.predict(X_test) で分類

特徴量の重要度の可視化

ランダムフォレストでは、各特徴量がどれだけ予測に重要だったのかを数値化することができます。この分析は、どのデータが分類に影響を与えているかを知るうえで役に立ちます。特徴量の重要度は、各決定木でどの特徴がどれだけデータを分割するのに寄与したかを集計することによって測ります。数値がより高いほどより重要な特徴であることが示唆されます。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestClassifier

# サンプルデータ（2つの特徴量を持つ）
X = np.array([[1, 2], [2, 3], [3, 1], [6, 5], [7, 8], [8, 6]])  # 特徴量
y = np.array([0, 0, 0, 1, 1, 1])  # クラス（0 or 1）

# モデル作成（決定木を10本使用）
model = RandomForestClassifier(n_estimators=10, max_depth=3, random_state=42)
model.fit(X, y)

# 特徴量の重要度を取得
feature_importance = model.feature_importances_

# グラフ描画
plt.bar(["Feature 1", "Feature 2"], feature_importance, color=['blue', 'red'])
plt.title("Visualization of Importance")
plt.xlabel("Feature")
plt.ylabel("Importance")
plt.show()

ポイント

• model.feature_importances_ で各特徴量の重要度を取得
• plt.bar() で 棒グラフを作成

キーワード：機械学習、Python、基礎

Pythonで学ぶ機械学習：決定木

機械学習の具体的な問題にPythonを使って、機械学習もPythonも同時に学んでしまいましょう。今回は決定木（Decision Tree）を使った分類についてまとめました。決定木はデータを条件分岐しながら分類するアルゴリズムです。

この記事では scikit-learn（sklearn）ライブラリを用います。適宜

pip install scikit-learn

などによってダウンロード・インストールしてください。

決定木の実装

樹形図（ツリー）構造を用い、特徴量の条件でデータを分類します。条件分岐を繰り返して分類していくので、学習結果を解釈しやすいという特徴があります。木の深さ（max_depth） を適切に制限しないと、過学習が起こってしまう点には注意が必要です。実装は以下の通りです：

from sklearn.tree import DecisionTreeClassifier
import numpy as np

# サンプルデータ（特徴量Xとクラスy）
X = np.array([[1], [2], [3], [6], [7], [8]])  # 特徴量
y = np.array([0, 0, 0, 1, 1, 1])  # クラス（0 or 1）

# モデル作成（最大深さ2）
model = DecisionTreeClassifier(max_depth=2)
model.fit(X, y)

# 予測
X_test = np.array([[4], [5]])  # 新しいデータ
y_pred = model.predict(X_test)

print("予測結果:", y_pred)  # 4と5はどのクラスに分類されるか？

予測結果: [0 1]

ポイント

• DecisionTreeClassifier(max_depth=2)
  • 最大深さ2 の決定木を作成（過学習を防ぐ）
• model.fit(X, y) で学習
• model.predict(X_test) で分類

決定木の可視化

上で扱った分類問題が、決定木（Decision Tree）を利用してどのようなルールによって分類されているのか をグラフで可視化してみます。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeClassifier, plot_tree

# サンプルデータ（特徴量Xとクラスy）
X = np.array([[1], [2], [3], [6], [7], [8]])  # 特徴量
y = np.array([0, 0, 0, 1, 1, 1])  # クラス（0 or 1）

# モデル作成（最大深さ2）
model = DecisionTreeClassifier(max_depth=2)
model.fit(X, y)

# 決定木の可視化
plt.figure(figsize=(8, 5))
plot_tree(model,
          feature_names=["X"],
          class_names=["Class 0", "Class 1"],
          filled=True)
plt.show()

ポイント

• plot_tree(model, feature_names, class_names, filled=True) で 決定木を視覚的に表示
• max_depth=2 で ツリーの深さを制限（過学習を防ぐ）

キーワード：機械学習、Python、基礎

Pythonで学ぶ機械学習：K近傍法

機械学習の具体的な問題にPythonを使って、機械学習もPythonも同時に学んでしまいましょう。今回は分類問題を機械学習を使って解く際によく使われるK近傍法（K-Nearest Neighbors, KNN）についてまとめました。KNNは、新しいデータがどのクラスに属するかを、周囲のデータ（近傍K個）をもとに決定するというアルゴリズムです。

この記事では scikit-learn（sklearn）ライブラリを用います。適宜

pip install scikit-learn

などによってダウンロード・インストールしてください。

KNNの実装

K は「参照する近くのデータ点の数」であり、例えば K=3 なら、3つの近傍のデータを見て多数決で分類することになります。K の取り方については、小さすぎると過学習、大きすぎると汎化性能の低下が起こり、適切な値に設定する必要があります。実装は以下の通りです：

from sklearn.neighbors import KNeighborsClassifier
import numpy as np

# サンプルデータ（特徴量Xとクラスy）
X = np.array([[1], [2], [3], [6], [7], [8]])  # 特徴量
y = np.array([0, 0, 0, 1, 1, 1])  # クラス（0 or 1）

# モデル作成（K=3のKNN）
model = KNeighborsClassifier(n_neighbors=3)
model.fit(X, y)

# 予測
X_test = np.array([[4], [5]])  # 新しいデータ
y_pred = model.predict(X_test)

print("予測結果:", y_pred)  # 4と5はどのクラスに分類されるか？

予測結果: [0 1]

ポイント

• KNeighborsClassifier(n_neighbors=3) でK=3のKNNモデルを作成
• model.fit(X, y) で学習
• model.predict(X_test) で分類を実施

K近傍法（KNN）の決定境界の可視化

上で扱ったデータセットと、そこから得られたKNN分類モデルがどのような基準で分類しているのか、その境界をグラフで可視化してみます。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassifier

# サンプルデータ（特徴量Xとクラスy）
X = np.array([[1], [2], [3], [6], [7], [8]])  # 特徴量
y = np.array([0, 0, 0, 1, 1, 1])  # クラス（0 or 1）

# モデル作成（K=3のKNN）
model = KNeighborsClassifier(n_neighbors=3)
model.fit(X, y)

# 決定境界を可視化するためのデータ作成
X_test = np.linspace(0, 9, 100).reshape(-1, 1)  # 0～9の範囲で細かく分割
y_pred = model.predict(X_test)  # 各点の分類結果

# グラフ描画
plt.scatter(X, y, color="blue", label="Data")  # 実際のデータ
plt.scatter(X_test, y_pred, color="red", s=5, label="KNN results")  # 予測結果

# タイトルとラベル
plt.title("KNN Decision Boundary")
plt.xlabel("Feature")
plt.ylabel("Class")
plt.legend()
plt.show()

ポイント

• X_test = np.linspace(0, 9, 100).reshape(-1, 1)
  • 0～9の範囲を細かく分割し、決定境界を確認する
• plt.scatter(X_test, y_pred, color="red", s=5)
  • 小さい赤点で各点の予測結果を可視化する

キーワード：機械学習、Python、基礎

Pythonで学ぶ機械学習：ロジスティック回帰

機械学習の具体的な問題にPythonを使って、機械学習もPythonも同時に学んでしまいましょう。今回は分類問題を機械学習を使って解く際によく使われるロジスティック回帰（Logistic Regression）についてまとめました。ロジスティック回帰は、0または1（Yes/Noなど）の2値分類に適しています。

この記事では scikit-learn（sklearn）ライブラリを用います。適宜

pip install scikit-learn

などによってダウンロード・インストールしてください。

ロジスティック回帰の実装

ロジスティック回帰では、次のシグモイド関数の出力を確率として解釈します。

この値が 0.5 未満の場合には０、0.5 以上の場合には１と分類します。問題としては、与えられたデータセットから、パラメタ と の妥当な値を求めることです。実装は以下の通りです：

from sklearn.linear_model import LogisticRegression
import numpy as np

# サンプルデータ（特徴量Xとラベルy）
X = np.array([[1], [2], [3], [4], [5]])  # 特徴量
y = np.array([0, 0, 0, 1, 1])  # クラス（0 or 1）

# モデルの作成と学習
model = LogisticRegression()
model.fit(X, y)

# 予測
x_pred  np.array([[2.5], [3.5], [4.5]])
y_pred = model.predict(x_pred)

# 結果表示
print("予測結果:", y_pred)
print("モデルの精度:", model.score(X, y))

予測結果: [0 0 1]
モデルの精度: 1.0

ポイント

• model.fit(X, y) でモデルを学習
• model.predict(X) で分類結果を取得
• model.score(X, y) で精度を計算（1.0なら完璧な分類）

ロジスティック回帰の決定境界の可視化

上で扱ったデータセットと、そこから得られたロジスティック回帰モデルがどのような基準で分類しているのか、その境界をグラフで可視化してみます。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression

# サンプルデータ（特徴量Xとラベルy）
X = np.array([[1], [2], [3], [4], [5]])  # 特徴量
y = np.array([0, 0, 0, 1, 1])  # クラス（0 or 1）

# モデルの作成と学習
model = LogisticRegression()
model.fit(X, y)

# 予測用データの作成（1～5の範囲で細かく分割）
X_test = np.linspace(0, 6, 100).reshape(-1, 1)
y_prob = model.predict_proba(X_test)[:, 1]  # クラス1の確率

# グラフ描画
plt.scatter(X, y, color="blue", label="Data")  # 実際のデータ
plt.plot(X_test, y_prob,
         color="red",
         linewidth=2,
         label="Logistic Regression")  # 確率曲線

# 決定境界（確率0.5の位置）
plt.axhline(0.5, color="gray", linestyle="--", linewidth=1)
plt.axvline(X_test[np.abs(y_prob - 0.5).argmin()],
            color="green",
            linestyle="--",
            linewidth=1,
            label="Decision Boundary")

# タイトルとラベル
plt.title("Plotting Decision Boundary")
plt.xlabel("Feature")
plt.ylabel("Probability")
plt.legend()
plt.show()

ポイント

• model.predict_proba(X_test)[:, 1] で クラス1の確率 を取得
• plt.plot(X_test, y_prob) で 確率曲線 を描画
• plt.axhline(0.5) と plt.axvline() で 決定境界（クラス0/1の分かれ目） を可視化

キーワード：機械学習、Python、基礎

Pythonで学ぶ機械学習：線形回帰

機械学習の具体的な問題にPythonを使って、機械学習もPythonも同時に学んでしまいましょう。今回は機械学習の基本的な予測モデルである線形回帰についてまとめました。

この記事では scikit-learn（sklearn）ライブラリを用います。適宜

pip install scikit-learn

などによってダウンロード・インストールしてください。

線形回帰モデルの実装

線形回帰モデルは、入力値 に対して予測値 を線形関数

によってモデル化するものです。問題としては、与えられたデータセットからパラメタ と の妥当な値を求めるということになります。

from sklearn.linear_model import LinearRegression
import numpy as np

# サンプルデータ（特徴量Xとターゲットy）
X = np.array([[1], [2], [3], [4], [5]])  # 入力（特徴量）データ
y = np.array([9.8, 20.1, 28.7, 40.8, 50.2])  # 出力（ターゲット）データ

# モデルの作成と学習
model = LinearRegression()
model.fit(X, y)

# 予測
x_pred = np.array([[2.5], [3.5], [4.5]])
y_pred = model.predict(x_pred)

# 結果表示
print("回帰係数（a）:", model.coef_[0])
print("切片（b）:", model.intercept_)
print("予測値:", y_pred)

回帰係数（a）: 10.15
切片（b）: -0.5299999999999976
予測値: [24.845 34.995 45.145]

ポイント

• model.fit(X, y) でデータを学習
• model.coef_ で傾き a、model.intercept_ で切片 b を取得
• model.predict(X) で予測値を計算

線形回帰モデルの可視化

上で扱ったデータセットと、そこから得られた線形回帰モデルを Matplotlib を使って可視化してみます。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

# サンプルデータ
X = np.array([[1], [2], [3], [4], [5]])  # 特徴量
y = np.array([9.8, 20.1, 28.7, 40.8, 50.2])  # 出力データ

# モデルの作成と学習
model = LinearRegression()
model.fit(X, y)

# グラフ描画
plt.scatter(X, y, color="blue", label="Data")  # 実際のデータ点
plt.plot(X, y_pred, color="red", linewidth=2, label="Linear Regression")  # 予測直線

# タイトルとラベル
plt.title("Visualization of Linear Regression")
plt.xlabel("Feature")
plt.ylabel("Target")
plt.legend()
plt.show()

ポイント

• plt.scatter(X, y) で元データを青い点で描画
• plt.plot(X, y_pred) で回帰直線を赤線で描画

キーワード：機械学習、Python、基礎

Pythonで学ぶ機械学習：データ処理

機械学習の具体的な問題にPythonを使って、機械学習もPythonも同時に学んでしまいましょう。今回は機械学習の精度を高めるうえで重要となる、データ処理についてまとめました。

この記事では scikit-learn（sklearn）ライブラリを用います。適宜

pip install scikit-learn

などによってダウンロード・インストールしてください。

データの前処理（標準化）

scikit-learn を使って標準化（Standardization）を行ってみます。標準化とは、データのスケールを調整して、平均値が 0、標準偏差が 1 となるようにすることです。これにより、それぞれ異なるスケールの特徴量を均一化することができ、モデルの学習がスムーズになります。

from sklearn.preprocessing import StandardScaler
import numpy as np

# サンプルデータ（身長・体重）
data = np.array([[160, 55], [170, 65], [180, 75]])

# 標準化
scaler = StandardScaler()
standardized_data = scaler.fit_transform(data)

print("標準化後のデータ:")
print(standardized_data)

標準化後のデータ:
[[-1.22474487 -1.22474487]
 [ 0.          0.        ]
 [ 1.22474487  1.22474487]]

ポイント

• StandardScaler( ).fit_transform(data) でデータを標準化。
• すべての特徴量の平均が0、標準偏差が1になるよう変換。

学習用・テスト用データへの分割

機械学習の学習過程では、データを学習用（train）とテスト用（test）に分割することが必要になります。ここではデータをランダムにシャッフルしたうえで、８：２の割合で学習用と訓練用に分割してみます。

from sklearn.model_selection import train_test_split
import numpy as np

# サンプルデータ（特徴量Xとターゲットy）
X = np.array([[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])
y = np.array([10, 20, 30, 40, 50, 60, 70, 80, 90, 100])

# データを8:2に分割（80%を訓練用、20%をテスト用）
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 結果を表示
print("学習用データ:", X_train.flatten())
print("テスト用データ:", X_test.flatten())

学習用データ: [ 6  1  8  3 10  5  4  7]
テスト用データ: [9 2]

ポイント

• train_test_split(X, y, test_size=0.2, random_state=42)
  • test_size=0.2 → 20%をテスト用にする
  • random_state=42 → 乱数シードを固定（再現性のため）

キーワード：機械学習、Python、基礎

Pythonで学ぶ機械学習：準備

機械学習の具体的な問題にPythonを使って、機械学習もPythonも同時に学んでしまいましょう。今回は応用先である機械学習を見据えて、Pythonの使い方のやや発展的な内容をまとめました。

NumPyのブロードキャスト

NumPyはAI開発に欠かせないライブラリで、高速な数値計算を可能にします。その中でも「ブロードキャスト」は、異なる形状の配列同士を自動的に拡張して演算する強力な機能です。

import numpy as np

A = np.array([[1, 2, 3], [4, 5, 6]])  # 2×3行列
B = np.array([10, 20, 30])  # 1×3行列（1次元）

C = A + B  # ブロードキャスト適用
print(C)

[[11 22 33]
 [14 25 36]]

ポイント

• B は A に自動拡張され、各行に [10, 20, 30] が足される。
• 明示的なループなしで、高速かつ簡潔に演算できる。　

確認　

X = np.array([[1], [2], [3]])  # 3×1行列
Y = np.array([10, 20, 30])  # 1×3行列
Z = X * Y
print(Z)

[[10 20 30]
 [20 40 60]
 [30 60 90]]

NumPyのベクトル化と高速計算

AIの計算処理では、forループを使わずにベクトル化（vectorization）することで高速化が可能です。通常のPythonループと比較して、NumPyのベクトル化を用いると計算が大幅に速くなります。

import numpy as np
import time

# 100万個のランダムデータ
size = 10**6
A = np.random.rand(size)
B = np.random.rand(size)

# 通常のforループ
start = time.time()
C_loop = [A[i] * B[i] for i in range(size)]
end = time.time()
print(f"Forループ: {end - start:.5f} 秒")

# NumPyのベクトル化
start = time.time()
C_vec = A * B  # 一括演算
end = time.time()
print(f"NumPyベクトル化: {end - start:.5f} 秒")

Forループ: 0.97325 秒
NumPyベクトル化: 0.01121 秒

ポイント

• forループはPythonのインタプリタが1つ1つ計算するため遅い。
• NumPyはC言語で実装されており、内部で最適化されているため高速。

Pandasによるデータ処理の基本

AI開発では大量のデータを扱うことが多いため、Pandasを使ったデータ処理が重要です。

Pandasの基本操作

まず、簡単なデータフレームを作成してみます。

import pandas as pd

# サンプルデータ
data = {
    "名前": ["Alice", "Bob", "Charlie"],
    "年齢": [25, 30, 35],
    "スコア": [85, 90, 95]
}

df = pd.DataFrame(data)

print(df)

        名前  年齢  スコア
0    Alice  25   85
1      Bob  30   90
2  Charlie  35   95

データの基本操作

print(df.head(2))  # 先頭2行を表示
print(df["年齢"].mean())  # 年齢の平均を計算
print(df[df["スコア"] > 88])  # スコアが88以上の人を抽出

      名前  年齢  スコア
0  Alice  25   85
1    Bob  30   90
30.0
        名前  年齢  スコア
1      Bob  30   90
2  Charlie  35   95

ポイント

• DataFrame は表形式のデータを効率よく扱える。
• .mean() で平均値、df[df["スコア"] > 88] で条件抽出が可能。

Matplotlibでデータの可視化

AI開発ではデータの傾向を理解するために可視化が重要です。ここでは Matplotlib を使って基本的なグラフを作成します。

import matplotlib.pyplot as plt

# サンプルデータ
x = [1, 2, 3, 4, 5]
y = [10, 20, 25, 30, 40]

# 折れ線グラフを描画
plt.plot(x, y, marker="o", linestyle="-", color="b", label="score")

# タイトル・ラベル
plt.title("record")
plt.xlabel("n-th trial")
plt.ylabel("score")

# 凡例を追加
plt.legend()

# グラフを表示
plt.show()

ポイント

• plt.plot(x, y) で折れ線グラフを描画。
• marker="o" でデータポイントを丸で強調。
• plt.legend() で凡例を追加。

Seabornで高度なデータ可視化

Matplotlib だけでなく、Seaborn を使うとより美しく分かりやすいデータ可視化ができます。

Seabornの基本

まずは Seaborn を使ってヒストグラム（データの分布）を描画してみます：

import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt

# サンプルデータ（正規分布に従うランダムデータ）
data = np.random.randn(1000)

# ヒストグラムを描画
sns.histplot(data, bins=30, kde=True)

# タイトルを追加
plt.title("distribution")
plt.show()

ポイント

• sns.histplot(data, bins=30, kde=True)
  • ヒストグラム（bins=30 で30区分に分割）
  • kde=True で確率密度関数を重ねる

キーワード：機械学習、Python、基礎