AI（人工知能）
  └── 機械学習（ML）
        ├── 教師あり学習
        ├── 教師なし学習
        ├── 強化学習
        └── ディープラーニング（DL）
              ├── CNN（画像認識）
              ├── RNN/Transformer（自然言語）
              └── GAN（画像生成）

import numpy as np

# ベクトル（1次元配列）
prices = np.array([3500, 4200, 2800, 5100, 3900])
print(f"平均価格: {prices.mean():.0f}円")    # 3900円
print(f"標準偏差: {prices.std():.0f}円")     # 743円

# 行列（2次元配列）— 機械学習ではデータをこの形で扱う
# 行 = サンプル（各物件）、列 = 特徴量（面積, 築年数, 駅距離）
data = np.array([
    [65, 10, 5],    # 物件A: 65㎡, 築10年, 駅5分
    [80, 3, 8],     # 物件B: 80㎡, 築3年, 駅8分
    [45, 25, 3],    # 物件C: 45㎡, 築25年, 駅3分
])
print(f"データの形状: {data.shape}")  # (3, 3) = 3サンプル × 3特徴量

# ブロードキャスティング — 形状の異なる配列同士の演算
data_normalized = (data - data.mean(axis=0)) / data.std(axis=0)
print(data_normalized)
# これだけで全特徴量が「平均0、標準偏差1」に標準化される

import pandas as pd

# CSVファイルの読み込み（1行で完了）
df = pd.read_csv("housing.csv")

# データの概要を確認
print(df.shape)        # (行数, 列数)
print(df.head())       # 最初の5行を表示
print(df.describe())   # 統計量（平均, 中央値, 標準偏差など）
print(df.info())       # 各列のデータ型と欠損値の数

# 特定の条件でフィルタリング
expensive = df[df["price"] > 5000]
tokyo = df[df["city"] == "東京"]

# グループ集計
city_avg = df.groupby("city")["price"].mean().sort_values(ascending=False)

import matplotlib.pyplot as plt

# 散布図 — 2つの変数の関係を見る
plt.figure(figsize=(8, 5))
plt.scatter(df["area"], df["price"], alpha=0.5, c="steelblue")
plt.xlabel("面積（㎡）")
plt.ylabel("価格（万円）")
plt.title("面積と価格の関係")
plt.grid(True, alpha=0.3)
plt.show()

# ヒストグラム — データの分布を見る
fig, axes = plt.subplots(1, 3, figsize=(15, 4))
for i, col in enumerate(["area", "age", "price"]):
    axes[i].hist(df[col], bins=30, color="steelblue", edgecolor="white")
    axes[i].set_title(col)
plt.tight_layout()
plt.show()

import seaborn as sns

# 相関行列のヒートマップ — 変数間の関係を一目で把握
plt.figure(figsize=(8, 6))
sns.heatmap(df.corr(), annot=True, cmap="coolwarm", center=0)
plt.title("特徴量の相関行列")
plt.show()

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# Step 1: データを訓練用とテスト用に分割
X = df[["area", "age", "distance"]]  # 特徴量
y = df["price"]                       # 予測対象
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Step 2: モデルの学習（fit）
model = LinearRegression()
model.fit(X_train, y_train)

# Step 3: 予測（predict）
predictions = model.predict(X_test)

あなたのPythonコード
    ↓ データ読み込み
  pandas（CSV, Excel → DataFrame）
    ↓ 可視化・探索
  matplotlib / seaborn（グラフ描画）
    ↓ 数値計算
  NumPy（配列演算、線形代数）
    ↓ 機械学習
  scikit-learn（前処理、モデル、評価）
    ↓ ディープラーニング（第9講で紹介）
  PyTorch / TensorFlow

# scikit-learn付属のデータセットで練習
from sklearn.datasets import load_iris
import pandas as pd

iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df["species"] = iris.target

print(df.head())
print(df.describe())
print(df.groupby("species").mean())

import pandas as pd
import numpy as np

# サンプルデータ（欠損値を含む）
df = pd.DataFrame({
    "area": [65, 80, np.nan, 45, 90],
    "age": [10, np.nan, 15, 25, 3],
    "price": [3500, 4200, 3100, np.nan, 5100]
})

# 欠損値の確認
print(df.isnull().sum())
# area     1
# age      1
# price    1

df_dropped = df.dropna()
# 簡単だがデータが減る。欠損が全体の5%以下なら有効

from sklearn.impute import SimpleImputer

imputer = SimpleImputer(strategy="median")  # 中央値で補完
df_filled = pd.DataFrame(
    imputer.fit_transform(df),
    columns=df.columns
)

from sklearn.impute import KNNImputer

knn_imputer = KNNImputer(n_neighbors=5)
df_knn = pd.DataFrame(
    knn_imputer.fit_transform(df),
    columns=df.columns
)

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# 各特徴量が平均0、標準偏差1になる

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
X_normalized = scaler.fit_transform(X)
# 各特徴量が0〜1の範囲になる

# 正しい手順
scaler.fit(X_train)              # 訓練データで統計量を計算
X_train_scaled = scaler.transform(X_train)   # 訓練データを変換
X_test_scaled = scaler.transform(X_test)     # テストデータは同じ統計量で変換

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
df["city_encoded"] = le.fit_transform(df["city"])
# 東京→2, 大阪→0, 福岡→1（アルファベット順）

df_encoded = pd.get_dummies(df, columns=["city"])
# city_大阪, city_東京, city_福岡 の3列が追加される（0 or 1）

# 例：不動産データ
df["price_per_sqm"] = df["price"] / df["area"]      # ㎡単価
df["is_new"] = (df["age"] <= 5).astype(int)          # 築5年以内フラグ
df["walk_minutes"] = df["distance"] / 80             # 駅距離→徒歩分数

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LinearRegression

pipe = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler()),
    ("model", LinearRegression()),
])

# 3ステップを一度に実行
pipe.fit(X_train, y_train)
predictions = pipe.predict(X_test)

# Kaggle Titanicデータの読み込み
url = "https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv"
df = pd.read_csv(url)

# 課題:
# 1. df.isnull().sum() で欠損値を確認
# 2. Age列をmedianで補完
# 3. Sex列をワンホットエンコーディング
# 4. Fare列を標準化

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

# データ作成（面積 → 価格）
np.random.seed(42)
area = np.random.uniform(30, 120, 50)
price = 40 * area + 500 + np.random.normal(0, 300, 50)

X = area.reshape(-1, 1)  # scikit-learnは2次元配列を要求
y = price

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

print(f"傾き（係数）: {model.coef_[0]:.1f}万円/㎡")
print(f"切片: {model.intercept_:.1f}万円")
# 傾き: 40.3万円/㎡ → 面積が1㎡増えるごとに価格が約40万円上がる

# 予測
new_area = np.array([[80]])
predicted_price = model.predict(new_area)
print(f"80㎡の予測価格: {predicted_price[0]:.0f}万円")

# 可視化
plt.scatter(X, y, alpha=0.5, label="実データ")
plt.plot(X, model.predict(X), color="red", label="回帰直線")
plt.xlabel("面積（㎡）")
plt.ylabel("価格（万円）")
plt.legend()
plt.show()

import pandas as pd
from sklearn.model_selection import train_test_split

# 複数の特徴量を持つデータ
df = pd.DataFrame({
    "area": np.random.uniform(30, 120, 200),
    "age": np.random.uniform(0, 40, 200),
    "distance": np.random.uniform(1, 20, 200),
})
df["price"] = 40 * df["area"] - 30 * df["age"] - 50 * df["distance"] + 1000 + np.random.normal(0, 200, 200)

# 特徴量と目的変数
X = df[["area", "age", "distance"]]
y = df["price"]

# 訓練/テスト分割（80:20）
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 学習と予測
model = LinearRegression()
model.fit(X_train, y_train)

# 各特徴量の係数を確認
for name, coef in zip(X.columns, model.coef_):
    print(f"  {name}: {coef:+.1f}")
# area: +39.8  → 面積が1㎡増えると約40万円アップ
# age: -29.7   → 築1年古くなると約30万円ダウン
# distance: -49.5 → 駅1分遠くなると約50万円ダウン

from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

y_pred = model.predict(X_test)

mae = mean_absolute_error(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
r2 = r2_score(y_test, y_pred)

print(f"MAE:  {mae:.0f}万円（平均で{mae:.0f}万円ズレる）")
print(f"RMSE: {rmse:.0f}万円")
print(f"R²:   {r2:.3f}（{r2*100:.1f}%の変動を説明できる）")

訓練データのスコア: 0.99（非常に高い）
テストデータのスコア: 0.65（大幅に低い）
→ 過学習の兆候

from sklearn.linear_model import Ridge

ridge = Ridge(alpha=1.0)  # alphaが大きいほど強い正則化
ridge.fit(X_train, y_train)

from sklearn.linear_model import Lasso

lasso = Lasso(alpha=0.1)
lasso.fit(X_train, y_train)

# 係数が0になった特徴量は「不要」と判断された
for name, coef in zip(X.columns, lasso.coef_):
    print(f"  {name}: {coef:+.2f}" + (" ← 除外" if abs(coef) < 0.01 else ""))

from sklearn.datasets import fetch_california_housing

housing = fetch_california_housing()
X = pd.DataFrame(housing.data, columns=housing.feature_names)
y = housing.target

# 課題:
# 1. train_test_splitで8:2に分割
# 2. LinearRegressionで学習
# 3. MAE, RMSE, R²を計算
# 4. Ridge(alpha=1.0)で同じ評価を行い、結果を比較

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report

# 乳がんデータセット（569サンプル、30特徴量、2クラス）
data = load_breast_cancer()
X = data.data
y = data.target  # 0=悪性, 1=良性

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 学習と予測
model = LogisticRegression(max_iter=10000)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print(f"正解率: {accuracy_score(y_test, y_pred):.3f}")

# 確率として出力を得る
probabilities = model.predict_proba(X_test)
print(f"最初のサンプルの確率: 悪性 {probabilities[0][0]:.3f}, 良性 {probabilities[0][1]:.3f}")

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

# Irisデータセットで分類
from sklearn.datasets import load_iris
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X_train, y_train)

print(f"正解率: {accuracy_score(y_test, tree.predict(X_test)):.3f}")

# 決定木の可視化
plt.figure(figsize=(15, 8))
plot_tree(tree, feature_names=iris.feature_names,
          class_names=iris.target_names, filled=True, rounded=True)
plt.show()

# 過学習する決定木
tree_overfit = DecisionTreeClassifier(max_depth=None)  # 深さ制限なし
tree_overfit.fit(X_train, y_train)
print(f"訓練データ正解率: {tree_overfit.score(X_train, y_train):.3f}")  # 1.000
print(f"テストデータ正解率: {tree_overfit.score(X_test, y_test):.3f}")  # 低い

# 過学習を防ぐ
tree_pruned = DecisionTreeClassifier(max_depth=4, min_samples_leaf=5)
tree_pruned.fit(X_train, y_train)
print(f"制限あり テスト正解率: {tree_pruned.score(X_test, y_test):.3f}")  # 改善

from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)
print(f"KNN正解率: {knn.score(X_test, y_test):.3f}")

from sklearn.svm import SVC

svm = SVC(kernel="rbf", C=1.0)
svm.fit(X_train, y_train)
print(f"SVM正解率: {svm.score(X_test, y_test):.3f}")

from sklearn.metrics import classification_report, confusion_matrix

y_pred = model.predict(X_test)
print(classification_report(y_test, y_pred, target_names=data.target_names))

import seaborn as sns

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues",
            xticklabels=data.target_names, yticklabels=data.target_names)
plt.xlabel("予測")
plt.ylabel("実際")
plt.show()

from sklearn.model_selection import cross_val_score

models = {
    "Logistic": LogisticRegression(max_iter=10000),
    "Decision Tree": DecisionTreeClassifier(max_depth=5),
    "KNN": KNeighborsClassifier(n_neighbors=5),
    "SVM": SVC(kernel="rbf"),
}

for name, m in models.items():
    scores = cross_val_score(m, X, y, cv=5, scoring="accuracy")
    print(f"{name:15s}: {scores.mean():.3f} ± {scores.std():.3f}")

import pandas as pd
url = "https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv"
df = pd.read_csv(url)

# 課題:
# 1. 特徴量: Pclass, Sex, Age, Fare を使用
# 2. 前処理: 欠損値補完、ワンホットエンコーディング
# 3. ロジスティック回帰と決定木で分類
# 4. classification_reportで比較

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import accuracy_score

data = load_breast_cancer()
X, y = data.data, data.target

# random_stateを変えるだけで結果が変わる
for seed in [0, 1, 2, 42, 100]:
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=seed)
    model = LogisticRegression(max_iter=10000)
    model.fit(X_train, y_train)
    score = accuracy_score(y_test, model.predict(X_test))
    print(f"seed={seed:3d}: {score:.3f}")
# 0.939 ~ 0.974 — 同じモデルなのに3%以上のばらつき

from sklearn.model_selection import cross_val_score

model = LogisticRegression(max_iter=10000)
scores = cross_val_score(model, X, y, cv=5, scoring="accuracy")

print(f"各フォールドの正解率: {scores}")
print(f"平均: {scores.mean():.3f} ± {scores.std():.3f}")
# 平均: 0.953 ± 0.012 — ±の小ささが「安定した性能」を示す

from sklearn.model_selection import StratifiedKFold

skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=skf, scoring="accuracy")
print(f"層化CV: {scores.mean():.3f} ± {scores.std():.3f}")

from sklearn.tree import DecisionTreeClassifier
import numpy as np

# 過学習の可視化
train_scores = []
test_scores = []
depths = range(1, 20)

for d in depths:
    tree = DecisionTreeClassifier(max_depth=d, random_state=42)
    # 訓練スコア
    tree.fit(X_train, y_train)
    train_scores.append(tree.score(X_train, y_train))
    # CVスコア
    cv = cross_val_score(tree, X, y, cv=5).mean()
    test_scores.append(cv)

import matplotlib.pyplot as plt

plt.plot(depths, train_scores, "o-", label="訓練スコア")
plt.plot(depths, test_scores, "s-", label="CVスコア")
plt.xlabel("木の深さ（max_depth）")
plt.ylabel("正解率")
plt.legend()
plt.title("学習曲線 — 過学習の検出")
plt.show()

from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC

param_grid = {
    "C": [0.1, 1, 10, 100],
    "kernel": ["rbf", "linear"],
    "gamma": ["scale", "auto"],
}

grid = GridSearchCV(SVC(), param_grid, cv=5, scoring="accuracy", n_jobs=-1)
grid.fit(X, y)

print(f"最良パラメータ: {grid.best_params_}")
print(f"最良スコア: {grid.best_score_:.3f}")

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import uniform, randint

param_dist = {
    "C": uniform(0.1, 100),
    "kernel": ["rbf", "linear"],
    "gamma": uniform(0.001, 1),
}

random_search = RandomizedSearchCV(
    SVC(), param_dist, n_iter=50, cv=5, scoring="accuracy",
    random_state=42, n_jobs=-1
)
random_search.fit(X, y)

print(f"最良パラメータ: {random_search.best_params_}")
print(f"最良スコア: {random_search.best_score_:.3f}")

from sklearn.model_selection import learning_curve

train_sizes, train_scores, test_scores = learning_curve(
    LogisticRegression(max_iter=10000), X, y,
    train_sizes=np.linspace(0.1, 1.0, 10), cv=5
)

plt.plot(train_sizes, train_scores.mean(axis=1), "o-", label="訓練スコア")
plt.plot(train_sizes, test_scores.mean(axis=1), "s-", label="CVスコア")
plt.xlabel("訓練データ数")
plt.ylabel("正解率")
plt.legend()
plt.title("学習曲線 — データ量 vs 性能")
plt.show()

from sklearn.model_selection import TimeSeriesSplit

# 時系列データの場合（未来でテスト）
tscv = TimeSeriesSplit(n_splits=5)
for train_idx, test_idx in tscv.split(X):
    print(f"Train: {train_idx[0]}-{train_idx[-1]}, Test: {test_idx[0]}-{test_idx[-1]}")

from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

data = load_breast_cancer()
X, y = data.data, data.target

# 課題:
# 1. Pipeline(StandardScaler + SVC)を構築
# 2. GridSearchCVでC=[0.1,1,10], kernel=["rbf","linear"]を探索
# 3. 最良パラメータと5分割CVスコアを報告
# 4. 学習曲線を描画し、データ追加の効果を判断

from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score

data = load_breast_cancer()
X, y = data.data, data.target

# 単一の決定木
tree = DecisionTreeClassifier(random_state=42)
print(f"単一決定木: {cross_val_score(tree, X, y, cv=5).mean():.3f}")

# バギング（100本の決定木の多数決）
bagging = BaggingClassifier(
    estimator=DecisionTreeClassifier(),
    n_estimators=100, random_state=42, n_jobs=-1
)
print(f"バギング:    {cross_val_score(bagging, X, y, cv=5).mean():.3f}")

from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(n_estimators=200, max_depth=10, random_state=42, n_jobs=-1)
rf.fit(X, y)

scores = cross_val_score(rf, X, y, cv=5)
print(f"Random Forest: {scores.mean():.3f} ± {scores.std():.3f}")

import pandas as pd
import matplotlib.pyplot as plt

importances = pd.Series(rf.feature_importances_, index=data.feature_names)
top10 = importances.nlargest(10)

top10.plot(kind="barh", color="steelblue")
plt.xlabel("重要度")
plt.title("Random Forest — 特徴量重要度 Top10")
plt.tight_layout()
plt.show()

from sklearn.model_selection import GridSearchCV

param_grid = {
    "n_estimators": [100, 200],
    "max_depth": [5, 10, None],
    "min_samples_leaf": [1, 3, 5],
}

grid = GridSearchCV(RandomForestClassifier(random_state=42),
                    param_grid, cv=5, scoring="accuracy", n_jobs=-1)
grid.fit(X, y)
print(f"最良パラメータ: {grid.best_params_}")
print(f"最良スコア: {grid.best_score_:.3f}")

from sklearn.ensemble import GradientBoostingClassifier

gb = GradientBoostingClassifier(
    n_estimators=200, learning_rate=0.1, max_depth=3, random_state=42
)
scores = cross_val_score(gb, X, y, cv=5)
print(f"Gradient Boosting: {scores.mean():.3f} ± {scores.std():.3f}")

from xgboost import XGBClassifier

xgb = XGBClassifier(
    n_estimators=200, learning_rate=0.1, max_depth=4,
    use_label_encoder=False, eval_metric="logloss",
    random_state=42, n_jobs=-1
)
scores = cross_val_score(xgb, X, y, cv=5)
print(f"XGBoost: {scores.mean():.3f} ± {scores.std():.3f}")

from lightgbm import LGBMClassifier

lgbm = LGBMClassifier(n_estimators=200, learning_rate=0.1, random_state=42, n_jobs=-1)
scores = cross_val_score(lgbm, X, y, cv=5)
print(f"LightGBM: {scores.mean():.3f} ± {scores.std():.3f}")

from sklearn.ensemble import StackingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC

estimators = [
    ("rf", RandomForestClassifier(n_estimators=100, random_state=42)),
    ("xgb", XGBClassifier(n_estimators=100, use_label_encoder=False,
                          eval_metric="logloss", random_state=42)),
    ("svm", SVC(kernel="rbf", probability=True)),
]

stacking = StackingClassifier(
    estimators=estimators,
    final_estimator=LogisticRegression(max_iter=10000),
    cv=5
)
scores = cross_val_score(stacking, X, y, cv=5)
print(f"Stacking: {scores.mean():.3f} ± {scores.std():.3f}")

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score

data = load_breast_cancer()
X, y = data.data, data.target

# 課題:
# 1. 以下のモデルを5分割CVで比較
#    - LogisticRegression, DecisionTree, RandomForest, XGBoost, LightGBM
# 2. 特徴量重要度Top5をRandomForestとXGBoostで比較
# 3. RandomForestでGridSearchCVを実行し最良パラメータを報告

from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
import numpy as np

# 人工データ（3つのクラスタ）
X, y_true = make_blobs(n_samples=300, centers=3, cluster_std=1.0, random_state=42)

# K-meansでクラスタリング
kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
y_pred = kmeans.fit_predict(X)

# 可視化
plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap="viridis", alpha=0.6)
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1],
            c="red", marker="X", s=200, label="中心点")
plt.legend()
plt.title("K-means クラスタリング結果")
plt.show()

inertias = []
K_range = range(1, 10)

for k in K_range:
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    km.fit(X)
    inertias.append(km.inertia_)

plt.plot(K_range, inertias, "o-")
plt.xlabel("クラスタ数 K")
plt.ylabel("イナーシャ（クラスタ内二乗和）")
plt.title("エルボー法 — 最適なKの決定")
plt.show()

from sklearn.metrics import silhouette_score

for k in range(2, 7):
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = km.fit_predict(X)
    score = silhouette_score(X, labels)
    print(f"K={k}: シルエットスコア = {score:.3f}")

from sklearn.cluster import DBSCAN
from sklearn.datasets import make_moons

# 三日月形のデータ（K-meansでは分離不可能）
X_moons, _ = make_moons(n_samples=300, noise=0.05, random_state=42)

# DBSCAN
db = DBSCAN(eps=0.2, min_samples=5)
labels = db.fit_predict(X_moons)

plt.scatter(X_moons[:, 0], X_moons[:, 1], c=labels, cmap="viridis")
plt.title("DBSCAN — 非球状クラスタの検出")
plt.show()
print(f"検出クラスタ数: {len(set(labels)) - (1 if -1 in labels else 0)}")
print(f"ノイズ点数: {(labels == -1).sum()}")

from sklearn.decomposition import PCA
from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import StandardScaler

data = load_breast_cancer()
X = StandardScaler().fit_transform(data.data)  # 30次元

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

plt.scatter(X_pca[:, 0], X_pca[:, 1], c=data.target, cmap="coolwarm", alpha=0.6)
plt.xlabel(f"PC1 ({pca.explained_variance_ratio_[0]:.1%})")
plt.ylabel(f"PC2 ({pca.explained_variance_ratio_[1]:.1%})")
plt.title("PCA — 乳がんデータを2次元に圧縮")
plt.colorbar(label="0=悪性, 1=良性")
plt.show()

pca_full = PCA().fit(X)
cumsum = np.cumsum(pca_full.explained_variance_ratio_)

plt.plot(range(1, len(cumsum) + 1), cumsum, "o-")
plt.axhline(y=0.95, color="red", linestyle="--", label="95%ライン")
plt.xlabel("主成分の数")
plt.ylabel("累積寄与率")
plt.legend()
plt.title("累積寄与率 — 必要な次元数の決定")
plt.show()

n_95 = np.argmax(cumsum >= 0.95) + 1
print(f"95%の情報を保持するには {n_95} 次元（元は {X.shape[1]} 次元）")

from sklearn.manifold import TSNE

tsne = TSNE(n_components=2, perplexity=30, random_state=42)
X_tsne = tsne.fit_transform(X)

plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=data.target, cmap="coolwarm", alpha=0.6)
plt.title("t-SNE — 非線形な次元削減")
plt.colorbar(label="0=悪性, 1=良性")
plt.show()

from sklearn.datasets import make_blobs

# 模擬顧客データ（購買金額 × 購買頻度）
np.random.seed(42)
customers = np.vstack([
    np.random.normal([100, 2], [30, 1], (100, 2)),    # 低額・低頻度
    np.random.normal([300, 8], [50, 2], (80, 2)),      # 中額・高頻度
    np.random.normal([500, 3], [40, 1], (50, 2)),      # 高額・低頻度
])

# 標準化 → K-means
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(customers)

kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
segments = kmeans.fit_predict(X_scaled)

plt.scatter(customers[:, 0], customers[:, 1], c=segments, cmap="viridis")
plt.xlabel("購買金額（月額）")
plt.ylabel("購買頻度（回/月）")
plt.title("顧客セグメンテーション")
plt.show()

from sklearn.datasets import load_iris

iris = load_iris()
X = iris.data  # ラベル（iris.target）は使わない

# 課題:
# 1. K-meansでK=3にクラスタリングし、真のラベルと比較
# 2. エルボー法で最適なKを検証
# 3. PCAで2次元に圧縮し、クラスタを可視化
# 4. t-SNEでも可視化し、PCAの結果と比較

入力: x1, x2, x3
  ↓
重み付き和: z = w1*x1 + w2*x2 + w3*x3 + b
  ↓
活性化関数: y = f(z)
  ↓
出力: 0 or 1

import numpy as np

# パーセプトロンを手動実装
def perceptron(x, w, b):
    z = np.dot(x, w) + b
    return 1 if z > 0 else 0

# ANDゲート
w = np.array([0.5, 0.5])
b = -0.7
print(f"AND(0,0)={perceptron([0,0], w, b)}")  # 0
print(f"AND(1,0)={perceptron([1,0], w, b)}")  # 0
print(f"AND(0,1)={perceptron([0,1], w, b)}")  # 0
print(f"AND(1,1)={perceptron([1,1], w, b)}")  # 1

from sklearn.neural_network import MLPClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

data = load_breast_cancer()
X, y = data.data, data.target

# MLPClassifier（隠れ層2つ: 64ニューロン → 32ニューロン）
mlp_pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("mlp", MLPClassifier(hidden_layer_sizes=(64, 32), max_iter=500,
                          random_state=42)),
])

scores = cross_val_score(mlp_pipe, X, y, cv=5)
print(f"MLP: {scores.mean():.3f} ± {scores.std():.3f}")

import matplotlib.pyplot as plt

x = np.linspace(-5, 5, 100)

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
axes[0].plot(x, 1 / (1 + np.exp(-x)))
axes[0].set_title("Sigmoid")
axes[1].plot(x, np.tanh(x))
axes[1].set_title("tanh")
axes[2].plot(x, np.maximum(0, x))
axes[2].set_title("ReLU")
for ax in axes:
    ax.grid(True, alpha=0.3)
    ax.axhline(y=0, color="k", linewidth=0.5)
    ax.axvline(x=0, color="k", linewidth=0.5)
plt.tight_layout()
plt.show()

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# MNISTデータセット（手書き数字 0-9、28x28ピクセル）
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

train_data = datasets.MNIST("./data", train=True, download=True, transform=transform)
test_data = datasets.MNIST("./data", train=False, transform=transform)

train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = DataLoader(test_data, batch_size=1000)

class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.layers = nn.Sequential(
            nn.Linear(28 * 28, 128),    # 入力: 784ピクセル → 128ニューロン
            nn.ReLU(),
            nn.Dropout(0.2),             # 過学習防止
            nn.Linear(128, 64),          # 128 → 64
            nn.ReLU(),
            nn.Linear(64, 10),           # 64 → 10クラス（0-9）
        )

    def forward(self, x):
        x = self.flatten(x)
        return self.layers(x)

model = SimpleNet()
print(model)
# パラメータ数を確認
total = sum(p.numel() for p in model.parameters())
print(f"総パラメータ数: {total:,}")  # 約109,386

criterion = nn.CrossEntropyLoss()  # 多クラス分類の損失関数
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 学習
for epoch in range(5):
    model.train()
    total_loss = 0
    for batch_x, batch_y in train_loader:
        optimizer.zero_grad()        # 勾配リセット
        output = model(batch_x)      # 順伝播
        loss = criterion(output, batch_y)  # 損失計算
        loss.backward()              # 逆伝播（勾配計算）
        optimizer.step()             # パラメータ更新
        total_loss += loss.item()
    print(f"Epoch {epoch+1}: Loss = {total_loss/len(train_loader):.4f}")

model.eval()
correct = 0
total = 0
with torch.no_grad():  # 推論時は勾配計算不要
    for batch_x, batch_y in test_loader:
        output = model(batch_x)
        predicted = output.argmax(dim=1)
        correct += (predicted == batch_y).sum().item()
        total += batch_y.size(0)

print(f"テスト正解率: {correct/total:.3f}")
# 約 0.975 — 3層のシンプルなネットワークで97.5%

# 課題:
# 1. 上のSimpleNetをGoogle Colabで実行（GPUランタイムを選択）
# 2. 隠れ層を(256, 128, 64)に変更して精度を比較
# 3. Dropout率を0.5に変更して過学習への影響を確認
# 4. エポック数を10に増やして学習曲線を描画

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

# Kaggle Spaceship Titanic（CSVを直接読み込み）
train = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/spaceship-titanic/train.csv")

print(f"データ形状: {train.shape}")
print(f"\n各列の型:\n{train.dtypes}")
print(f"\n欠損値:\n{train.isnull().sum()}")
print(f"\n先頭5行:")
train.head()

# 目的変数の分布
print(f"転送された: {train['Transported'].sum()}")
print(f"転送されなかった: {(~train['Transported']).sum()}")
# ほぼ均等 → 不均衡問題ではない

# 数値特徴量の分布
numeric_cols = ["Age", "RoomService", "FoodCourt", "ShoppingMall", "Spa", "VRDeck"]
fig, axes = plt.subplots(2, 3, figsize=(15, 8))
for i, col in enumerate(numeric_cols):
    ax = axes[i // 3, i % 3]
    train[col].hist(bins=30, ax=ax, color="steelblue", edgecolor="white")
    ax.set_title(col)
plt.tight_layout()
plt.show()

# カテゴリ特徴量と目的変数の関係
cat_cols = ["HomePlanet", "CryoSleep", "Destination", "VIP"]
fig, axes = plt.subplots(1, 4, figsize=(18, 4))
for i, col in enumerate(cat_cols):
    pd.crosstab(train[col], train["Transported"], normalize="index").plot(
        kind="bar", ax=axes[i], stacked=True
    )
    axes[i].set_title(col)
    axes[i].legend(["Not Transported", "Transported"])
plt.tight_layout()
plt.show()

# Cabinからデッキ・サイドを抽出
train[["Deck", "CabinNum", "Side"]] = train["Cabin"].str.split("/", expand=True)

# 消費合計を特徴量として追加
spend_cols = ["RoomService", "FoodCourt", "ShoppingMall", "Spa", "VRDeck"]
train["TotalSpend"] = train[spend_cols].sum(axis=1)
train["NoSpend"] = (train["TotalSpend"] == 0).astype(int)

# PassengerIdからグループ情報を抽出
train["GroupId"] = train["PassengerId"].str.split("_").str[0]
train["GroupSize"] = train.groupby("GroupId")["GroupId"].transform("count")
train["IsAlone"] = (train["GroupSize"] == 1).astype(int)

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer

# 使用する特徴量を定義
num_features = ["Age", "RoomService", "FoodCourt", "ShoppingMall",
                "Spa", "VRDeck", "TotalSpend", "GroupSize"]
cat_features = ["HomePlanet", "CryoSleep", "Destination", "VIP",
                "Deck", "Side", "NoSpend", "IsAlone"]

# 数値特徴量: 中央値補完 → 標準化
num_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler()),
])

# カテゴリ特徴量: 最頻値補完 → ワンホットエンコーディング
cat_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(handle_unknown="ignore", sparse_output=False)),
])

# ColumnTransformerで統合
preprocessor = ColumnTransformer([
    ("num", num_pipeline, num_features),
    ("cat", cat_pipeline, cat_features),
])

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier

X = train[num_features + cat_features]
y = train["Transported"].astype(int)

models = {
    "Logistic": LogisticRegression(max_iter=1000),
    "RandomForest": RandomForestClassifier(n_estimators=200, random_state=42),
    "XGBoost": XGBClassifier(n_estimators=200, use_label_encoder=False,
                             eval_metric="logloss", random_state=42),
    "LightGBM": LGBMClassifier(n_estimators=200, random_state=42, verbose=-1),
}

results = {}
for name, model in models.items():
    pipe = Pipeline([
        ("preprocessor", preprocessor),
        ("model", model),
    ])
    scores = cross_val_score(pipe, X, y, cv=5, scoring="accuracy")
    results[name] = scores
    print(f"{name:15s}: {scores.mean():.4f} ± {scores.std():.4f}")

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import uniform, randint

# LightGBMのチューニング（例）
param_dist = {
    "model__n_estimators": randint(100, 500),
    "model__learning_rate": uniform(0.01, 0.3),
    "model__max_depth": randint(3, 10),
    "model__num_leaves": randint(20, 100),
    "model__min_child_samples": randint(5, 50),
}

best_pipe = Pipeline([
    ("preprocessor", preprocessor),
    ("model", LGBMClassifier(random_state=42, verbose=-1)),
])

search = RandomizedSearchCV(
    best_pipe, param_dist, n_iter=50, cv=5,
    scoring="accuracy", random_state=42, n_jobs=-1
)
search.fit(X, y)

print(f"最良スコア: {search.best_score_:.4f}")
print(f"最良パラメータ:")
for k, v in search.best_params_.items():
    print(f"  {k}: {v}")

# チューニング済みモデルの特徴量重要度
best_model = search.best_estimator_

# 前処理後の特徴量名を取得
ohe = best_model.named_steps["preprocessor"].named_transformers_["cat"].named_steps["encoder"]
cat_names = ohe.get_feature_names_out(cat_features).tolist()
feature_names = num_features + cat_names

importances = pd.Series(
    best_model.named_steps["model"].feature_importances_,
    index=feature_names
).nlargest(15)

importances.plot(kind="barh", color="steelblue")
plt.xlabel("重要度")
plt.title("LightGBM — 特徴量重要度 Top15")
plt.tight_layout()
plt.show()

from sklearn.metrics import classification_report, confusion_matrix

# 最終評価（全データでの交差検証）
from sklearn.model_selection import cross_val_predict

y_pred = cross_val_predict(search.best_estimator_, X, y, cv=5)
print(classification_report(y, y_pred, target_names=["Not Transported", "Transported"]))

# 混同行列
cm = confusion_matrix(y, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues",
            xticklabels=["Not", "Transported"],
            yticklabels=["Not", "Transported"])
plt.xlabel("予測")
plt.ylabel("実際")
plt.title("混同行列")
plt.show()