5. 前処理と特徴量選択¶

import pandas as pd
import numpy as np

# 欠損値を含むサンプルデータ
df = pd.DataFrame({
    'age': [25, 30, np.nan, 35, 40],
    'salary': [300, np.nan, 400, 450, np.nan],
    'city': ['Tokyo', 'Osaka', None, 'Tokyo', 'Fukuoka']
})

# 欠損値の確認
print(df.isnull().sum())
print(df.isnull().mean() * 100)

# 欠損値を含む行を削除
df_dropped = df.dropna()
print(df_dropped)

# 数値列を平均値で補完
df['age'] = df['age'].fillna(df['age'].mean())

# 数値列を中央値で補完
df['salary'] = df['salary'].fillna(df['salary'].median())

# カテゴリ列を最頻値で補完
df['city'] = df['city'].fillna(df['city'].mode()[0])

from sklearn.impute import SimpleImputer

# 平均値で補完
imputer = SimpleImputer(strategy='mean')
df_imputed = imputer.fit_transform(df[['age', 'salary']])

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

import seaborn as sns
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier

# ペンギンデータの読み込みと前処理
penguins = sns.load_dataset('penguins').dropna()
X = penguins[['bill_length_mm', 'bill_depth_mm',
              'flipper_length_mm', 'body_mass_g']]
y = penguins['species']

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

# スケーリングなし
knn = KNeighborsClassifier()
knn.fit(X_train, y_train)
print(f"スケーリングなし: {knn.score(X_test, y_test):.4f}")

# スケーリングあり
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

knn_scaled = KNeighborsClassifier()
knn_scaled.fit(X_train_scaled, y_train)
print(f"スケーリングあり: {knn_scaled.score(X_test_scaled, y_test):.4f}")

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
df['city_encoded'] = le.fit_transform(df['city'])

import pandas as pd

# pandas の get_dummies を使用
df_encoded = pd.get_dummies(df, columns=['city'], drop_first=True)

from sklearn.preprocessing import OneHotEncoder

# scikit-learn の OneHotEncoder を使用
encoder = OneHotEncoder(sparse_output=False, drop='first')
encoded = encoder.fit_transform(df[['city']])

import pandas as pd
from sklearn.preprocessing import OrdinalEncoder

df = pd.DataFrame({
    'education': ['高校', '大学', '大学院', '高校', '大学']
})

# 順序を指定してエンコーディング
encoder = OrdinalEncoder(
    categories=[['高校', '大学', '大学院']]
)
df['education_encoded'] = encoder.fit_transform(
    df[['education']]
)
print(df)

from sklearn.feature_selection import VarianceThreshold

selector = VarianceThreshold(threshold=0.1)
X_selected = selector.fit_transform(X)

import pandas as pd

# 相関行列の計算
correlation = df.corr()

# 目的変数との相関を確認
print(correlation['target'].sort_values(ascending=False))

import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import LabelEncoder

# ペンギンデータの準備
penguins = sns.load_dataset('penguins').dropna()
X = penguins[['bill_length_mm', 'bill_depth_mm',
              'flipper_length_mm', 'body_mass_g']]
le = LabelEncoder()
y = le.fit_transform(penguins['species'])

# ランダムフォレストで特徴量重要度を計算
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X, y)

# 特徴量重要度の表示
importance = pd.Series(
    rf.feature_importances_, index=X.columns
).sort_values(ascending=False)
print(importance.round(4))

# 棒グラフで可視化
importance.plot(kind='barh')
plt.xlabel('特徴量重要度')
plt.title('ランダムフォレストの特徴量重要度')
plt.tight_layout()
plt.show()

import seaborn as sns
import pandas as pd
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.preprocessing import LabelEncoder

# データの準備
penguins = sns.load_dataset('penguins').dropna()
X = penguins[['bill_length_mm', 'bill_depth_mm',
              'flipper_length_mm', 'body_mass_g']]
le = LabelEncoder()
y = le.fit_transform(penguins['species'])

# 上位2つの特徴量を選択
selector = SelectKBest(score_func=f_classif, k=2)
X_selected = selector.fit_transform(X, y)

# 選択された特徴量を確認
selected = X.columns[selector.get_support()]
print(f"選択された特徴量: {list(selected)}")

# 各特徴量のスコア
scores = pd.Series(
    selector.scores_, index=X.columns
).sort_values(ascending=False)
print(f"\n特徴量スコア:")
print(scores.round(2))

import seaborn as sns
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split

# データの準備（欠損値はパイプラインの中で補完する）
penguins = sns.load_dataset("penguins")
X = penguins[["bill_length_mm", "bill_depth_mm",
              "flipper_length_mm", "body_mass_g"]]
y = penguins["species"]

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

# パイプラインの構築
pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="mean")),  # 1. 欠損値を平均値で補完
    ("scaler", StandardScaler()),                 # 2. 標準化
    ("classifier", KNeighborsClassifier())        # 3. k近傍法で分類
])

# 学習と予測（前処理とモデルが一括で実行される）
pipeline.fit(X_train, y_train)
score = pipeline.score(X_test, y_test)
print(f"パイプラインの精度: {score:.4f}")

import seaborn as sns
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split

# Titanicデータの準備
titanic = sns.load_dataset('titanic')
features = ['age', 'fare', 'pclass', 'sex', 'embarked']
X = titanic[features]
y = titanic['survived']

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

# 数値列とカテゴリ列を定義
numeric_features = ['age', 'fare']
categorical_features = ['pclass', 'sex', 'embarked']

# 数値列の前処理パイプライン
numeric_transformer = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

# カテゴリ列の前処理パイプライン
categorical_transformer = Pipeline([
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('encoder', OneHotEncoder(handle_unknown='ignore'))
])

# ColumnTransformer で統合
preprocessor = ColumnTransformer([
    ('num', numeric_transformer, numeric_features),
    ('cat', categorical_transformer, categorical_features)
])

# 前処理 + モデルのパイプライン
full_pipeline = Pipeline([
    ('preprocessor', preprocessor),
    ('classifier', KNeighborsClassifier())
])

# 学習と評価
full_pipeline.fit(X_train, y_train)
score = full_pipeline.score(X_test, y_test)
print(f"Titanic 生存予測の精度: {score:.4f}")

import seaborn as sns
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import cross_val_score

# データの準備
penguins = sns.load_dataset("penguins").dropna()
X = penguins[["bill_length_mm", "bill_depth_mm",
              "flipper_length_mm", "body_mass_g"]]
y = penguins["species"]

# パイプラインの構築
pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("classifier", KNeighborsClassifier())
])

# 5分割交差検証
scores = cross_val_score(pipeline, X, y, cv=5)
print(f"各フォールドのスコア: {scores.round(4)}")
print(f"平均スコア: {scores.mean():.4f}")
print(f"標準偏差:   {scores.std():.4f}")

from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score

# まずテストデータを分離（最終評価用）
X_trainval, X_test, y_trainval, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 訓練+検証データで交差検証
scores = cross_val_score(pipeline, X_trainval, y_trainval, cv=5)
print(f"交差検証スコア: {scores.mean():.4f}")

# 最終評価はテストデータで 1 回だけ行う
pipeline.fit(X_trainval, y_trainval)
test_score = pipeline.score(X_test, y_test)
print(f"テストスコア:   {test_score:.4f}")

import seaborn as sns
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split

# データの準備
penguins = sns.load_dataset("penguins").dropna()
X = penguins[["bill_length_mm", "bill_depth_mm",
              "flipper_length_mm", "body_mass_g"]]
y = penguins["species"]

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

# パイプラインの構築
pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("classifier", KNeighborsClassifier())
])

# 探索するパラメータの候補（「ステップ名__パラメータ名」で指定）
param_grid = {
    "classifier__n_neighbors": [3, 5, 7, 9, 11],       # k の候補
    "classifier__weights": ["uniform", "distance"]     # 近傍の重み付け方法
}

# GridSearchCV の実行
grid_search = GridSearchCV(
    pipeline,
    param_grid,
    cv=5,
    scoring="accuracy",
    n_jobs=-1
)
grid_search.fit(X_train, y_train)

# 結果の表示
print(f"最適なパラメータ: {grid_search.best_params_}")
print(f"最高スコア（交差検証）: {grid_search.best_score_:.4f}")
print(f"テストスコア: {grid_search.score(X_test, y_test):.4f}")

import seaborn as sns
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier

# データの準備
penguins = sns.load_dataset('penguins').dropna()
X = penguins[['bill_length_mm', 'bill_depth_mm',
              'flipper_length_mm', 'body_mass_g']]
y = penguins['species']

# 比較するモデルの定義
models = {
    'k-NN': KNeighborsClassifier(),
    'Logistic': LogisticRegression(max_iter=1000),
    'Decision Tree': DecisionTreeClassifier(random_state=42),
    'Random Forest': RandomForestClassifier(random_state=42)
}

# 各モデルの交差検証スコアを計算
results = []
for name, model in models.items():
    pipeline = Pipeline([
        ('scaler', StandardScaler()),
        ('classifier', model)
    ])
    scores = cross_val_score(pipeline, X, y, cv=5)
    results.append({
        'Model': name,
        'Mean Score': scores.mean(),
        'Std': scores.std()
    })

# 結果を DataFrame で表示
df_results = pd.DataFrame(results)
df_results = df_results.sort_values(
    'Mean Score', ascending=False
)
print(df_results.round(4).to_string(index=False))