【コピペOK】ランダムフォレストやLightGBMを簡単に扱える自作クラスを紹介

# アルゴリズムのインポート
from sklearn.ensemble import RandomForestClassifier

# インスタンスの生成
util = GenericClassifierModelUtil(RandomForestClassifier)

# データの読み込み
util.read_csv('nonlinear_classification_data.csv',encoding="utf-8")

# 学習の実行
util.fit(target='正解データ', columns=None,track_learning_curve=True)

# 精度指標の表示
util.evaluate()

# モデルをファイルに保存
util.save_model("./mymodel.pkl")

from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import AdaBoostClassifier
from lightgbm  import LGBMClassifier
from xgboost import XGBClassifier
from catboost import CatBoostClassifier

# インスタンスの生成例
util = GenericClassifierModelUtil(RandomForestClassifier)

from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.ensemble import AdaBoostRegressor
from lightgbm import LGBMRegressor
from xgboost import XGBRegressor
from catboost import CatBoostRegressor

# インスタンスの生成例
util = GenericRegressionModelUtil(RandomForestRegressor)

# アルゴリズムのインポート
from sklearn.ensemble import RandomForestClassifier

# インスタンスの生成（モデルファイルを指定）
util = GenericClassifierModelUtil(RandomForestClassifier,model_path="./mymodel.pkl")

# データの読み込み
util.read_csv('nonlinear_classification_data.csv',encoding="utf-8")

# 予測に使うカラムのみ取り出し
columns = [x for x in util.columns if x != '正解データ']

# 予測の実行
res = util.predict(columns=columns)

print(res)

# アルゴリズムのインポート
from sklearn.ensemble import RandomForestClassifier

# インスタンスの生成
util = GenericClassifierModelUtil(RandomForestClassifier)

# データの読み込み
util.read_csv('nonlinear_classification_data.csv',encoding="utf-8")

# パラメータのサーチ範囲の指定
param_grid = {
    'n_estimators': [100, 200, 500],  # 決定木の数
    'max_depth': [10, 20, 30, None],  # 決定木の最大深さ
    'min_samples_split': [2, 5, 10],  # 内部ノードを分割するために必要な最小サンプル数
    'min_samples_leaf': [1, 2, 4],  # 葉ノードに必要な最小サンプル数
    'bootstrap': [True, False]  # ブートストラップサンプリングの使用
}

# 学習の実行
util.fit_with_grid_search(target='正解データ', columns=None, param_grid=param_grid)

# 精度指標の表示
util.evaluate()

# アルゴリズムのインポート
from sklearn.ensemble import RandomForestClassifier

# インスタンスの生成
util = GenericClassifierModelUtil(RandomForestClassifier)

# データの読み込み
util.read_csv('nonlinear_classification_data.csv',encoding="utf-8")

# 学習の実行
util.fit(target='正解データ', columns=None,track_learning_curve=True)

# 学習曲線の描画
util.plot_learning_curve()

# アルゴリズムのインポート
from sklearn.ensemble import RandomForestClassifier

# インスタンスの生成
util = GenericClassifierModelUtil(RandomForestClassifier)

# データの読み込み
util.read_csv('nonlinear_classification_data.csv',encoding="utf-8")

# 学習の実行
util.fit(target='正解データ', columns=None,track_learning_curve=True)

# 混同行列の描画
util.plot_confusion_matrix()

# 学習曲線の描画
util.plot_roc_curve()

# 使用例
from sklearn.ensemble import RandomForestRegressor

# インスタンスの生成
util = GenericRegressionModelUtil(RandomForestRegressor)

# データの読み込み
util.read_csv('nonlinear_classification_data.csv',encoding='utf-8')

# 学習の実行
util.fit(target='特徴量_1', columns=util.columns)

# 予実の折れ線、散布図、回帰曲線、残渣プロットを描画
util.plot_diagnostics()

# 使用例
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.ensemble import AdaBoostRegressor
from lightgbm import LGBMRegressor
from xgboost import XGBRegressor
from catboost import CatBoostRegressor


# 分類問題用テストデータの読み込み
df = pd.read_csv('nonlinear_regression_data.csv')
param_grid = {
    'n_estimators': [100, 200],
    'max_depth': [None, 10, 20],
    'min_samples_split': [2, 5],
    'min_samples_leaf': [1, 2]
}

rf_util = GenericRegressionModelUtil(GradientBoostingRegressor,df)
rf_util.fit(target='特徴量_1', columns=df.columns,track_learning_curve=True)
#rf_util.fit_with_grid_search(target='特徴量_1', columns=df.columns, param_grid=param_grid)
rf_util.evaluate()
rf_util.plot_learning_curve()
rf_util.plot_diagnostics()

import pandas as pd
import pickle

class ResourceManager:
    def __init__(self, df=None, model_path=None):
        """
        クラスの初期化メソッド
        :param df: 初期データフレーム (pd.DataFrame)
        :param model_path: モデルファイルのパス (str)
        """
        self.df = None if df is None else df.copy()  # データフレームのコピーを保持
        self.model = None if model_path is None else self.load_model(model_path)  # モデルファイルのパス
        self.columns = []

    def read_csv(self, file_name, encoding="shift-jis"):
        """
        CSVファイルからデータを読み込むメソッド。読み込むと columnsプロパティにカラムがセットされる。
        :param file_name: 読み込むファイルのパス (str)
        :param encoding: ファイルのエンコーディング (str)
        :return: DataFrame, 読み込んだDataFrame
        """
        self.df = pd.read_csv(file_name, encoding=encoding)  # データフレームに読み込み
        self.columns = self.df.columns
        return self.df

    def save_model(self, model_path):
        """
        学習したモデルをファイルに保存するメソッド
        :param model_path: 保存するファイルのパス (str)
        """
        with open(model_path, 'wb') as f:
            pickle.dump(self.model, f)  # モデルをバイナリ形式で保存

    def load_model(self, model_path=None):
        """
        モデルをファイルから読み込むメソッド
        :param model_path: 読み込むファイルのパス (str)
        :return: 読み込んだモデル
        """
        if model_path is None:
            model_path = self.model_path

        with open(model_path, 'rb') as f:
            self.model = pickle.load(f)  # モデルをバイナリ形式で読み込み
        return self.model

import numpy as np
from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score
from sklearn.metrics import roc_curve, auc,accuracy_score, classification_report, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib import rcParams
rcParams['font.family'] = 'Meiryo'

class GenericClassifierModelUtil(ResourceManager):
    def __init__(self, mode_cls,df=None, model_path=None):
        """
        クラスの初期化メソッド
        :param model_cls:分類で使うモデルのクラス
        :param df: 初期データフレーム (pd.DataFrame)
        :param model_path: モデルファイルのパス (str)
        """
        super().__init__(df, model_path)
        self.model_cls = mode_cls
        self.X_train = []
        self.X_test = []
        self.y_train = []
        self.y_test = []
        self.y_pred = []
        self.params = {}
        self.history = []

    def fit(self, target, columns=None, params={}, test_size=0.2, random_state=42, track_learning_curve=False, split_method='split'):
        """
        モデルを学習し、レポートを出力するメソッド
        :param target: str, 予測対象となるターゲット列名
        :param columns: list of str, 使用する特徴量の列名のリスト。ターゲットが含まれていても無視する。省略時は self.columnsが使われる。
        :param params: dict, optional (default={}), ランダムフォレストのハイパーパラメータ
        :param test_size: float, optional (default=0.2), テストデータの割合
        :param random_state: int, optional (default=42), 乱数シード
        :param track_learning_curve: bool, optional (default=False), 学習曲線の履歴を取るかどうか
        :param split_method: str, optional (default='split'), データ分割方法 ('split' または 'cross_val')
        """

        if columns is not None:
            self.columns = columns

        X = self.df[[col for col in self.columns if col != target]]
        y = self.df[target]

        self.params = params
        self.track_learning_curve = track_learning_curve
        self.split_method = split_method

        if split_method == 'split':
            self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(X, y, test_size=test_size, random_state=random_state)
        elif split_method == 'cross_val':
            self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(X, y, test_size=test_size, random_state=random_state)
            self.cross_val_scores = cross_val_score(self.model_cls(**params, random_state=random_state), X, y, cv=5)

        self.model = self.model_cls(random_state=random_state, **params)
        
        if track_learning_curve:
            # 学習履歴を保存するリスト
            self.history = {'train_sizes': [], 'train_scores': [], 'val_scores': []}

            # 異なるサイズのトレーニングセットでモデルを再学習
            train_sizes = np.linspace(0.1, 1.0, 10, endpoint=False)  # 1.0 未満の最大値
            for train_size in train_sizes:
                X_train_sub, _, y_train_sub, _ = train_test_split(self.X_train, self.y_train, train_size=train_size, random_state=random_state)
                self.model.fit(X_train_sub, y_train_sub)
                
                # トレーニングスコアと検証スコアを計算
                train_score = accuracy_score(y_train_sub, self.model.predict(X_train_sub))
                val_score = accuracy_score(self.y_test, self.model.predict(self.X_test))
                
                # スコアを保存
                self.history['train_sizes'].append(len(X_train_sub))
                self.history['train_scores'].append(train_score)
                self.history['val_scores'].append(val_score)
        else:
            # モデルをトレーニング
            self.model.fit(self.X_train, self.y_train)

        self.y_pred = self.model.predict(self.X_test)
        
        return self.model

    def predict(self, columns = None, df = None):
        """
        学習済みモデルを用いて予測を行うメソッド
        :param columns: list, 予測に使うカラム名のリスト。省略すると self.columns の全てのカラムが使われる。
        :param df: pd.DataFrame, 予測対象の特徴量データフレーム
        :return: np.ndarray, 予測結果
        """
        columns = self.columns if columns is None else columns
        X = self.df[columns] if df is None else df
        
        return self.model.predict(X)

    def fit_with_grid_search(self, target, columns, param_grid, test_size=0.2, random_state=42):
        """
        グリッドサーチを使用してハイパーパラメータをチューニングし、最適なモデルを見つけるメソッド。
        :param target: str, 予測対象となるターゲット列名
        :param columns: list of str, 使用する特徴量の列名のリスト。ターゲットが含まれていても無視する。None指定時は self.columnsが使われる。
        :param param_grid: dict, グリッドサーチで試すハイパーパラメータの辞書
        :param test_size: float, optional (default=0.2), テストデータの割合
        :param random_state: int, optional (default=42), 乱数シード
        """

        if columns is not None:
            self.columns = columns

        X = self.df[[col for col in self.columns if col != target]]
        y = self.df[target]

        self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(X, y, test_size=test_size, random_state=random_state)
        self.model = self.model_cls(random_state=random_state)
        grid_search = GridSearchCV(estimator=self.model, param_grid=param_grid, cv=5, scoring='accuracy', n_jobs=-1)
        grid_search.fit(self.X_train, self.y_train)

        self.model = grid_search.best_estimator_
        self.params = grid_search.best_params_
        best_score = grid_search.best_score_
        self.y_pred = self.model.predict(self.X_test)

        print(f'最適なハイパーパラメータ: {self.params}')
        print(f'グリッドサーチの最適なスコア: {best_score}')

        return self.model

    def evaluate(self):
        """
        分類モデルの評価指標を計算して出力するメソッド
        :param y_test: np.ndarray, テストデータの真のラベル
        :param y_pred: np.ndarray, 予測結果のラベル
        """
        accuracy = accuracy_score(self.y_test, self.y_pred)
        report = classification_report(self.y_test, self.y_pred, target_names=[str(i) for i in range(len(np.unique(self.y_test)))])
        cm = confusion_matrix(self.y_test, self.y_pred)

        print(f'正解率: {accuracy}')
        print('混同行列:')
        print(cm)
        print('分類レポート:')
        print(report)


    def plot_confusion_matrix(self,class_names = [], file_name = None):
        """
        混同行列をプロットする関数。

        引数:
        cm : numpy.ndarray
            混同行列を表す2次元配列。
        class_names : list of str, optional
            クラス名のリスト。省略すると連番が表示される
        file_name : str, optional
            ファイル名が指定された場合、プロットはファイルに保存されます。
            指定されない場合、プロットは画面に表示されます。
        """
        plt.figure(figsize=(10, 7))
        cm = confusion_matrix(self.y_test, self.y_pred)
        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=class_names, yticklabels=class_names)
        plt.xlabel('予測ラベル')
        plt.ylabel('実際のラベル')
        plt.title('混同行列')

        if file_name:
            plt.savefig(file_name)
        else:
            plt.show()
        plt.close()

    def plot_learning_curve(self, file_name = None):
        """
        学習履歴をプロットするメソッド

        引数:
        file_name : str, optional
            ファイル名が指定された場合、プロットはファイルに保存されます。
            指定されない場合、プロットは画面に表示されます。
        """
        if not self.track_learning_curve:
            print("学習曲線の履歴を取るように設定されていません。")
            return
        
        plt.figure()
        plt.plot(self.history['train_sizes'], self.history['train_scores'], 'o-', color="r", label="トレーニングスコア")
        plt.plot(self.history['train_sizes'], self.history['val_scores'], 'o-', color="g", label="検証スコア")
        plt.title("学習曲線")
        plt.xlabel("トレーニング例数")
        plt.ylabel("スコア")
        plt.legend(loc="best")
        plt.grid()

        if file_name:
            plt.savefig(file_name)
        else:
            plt.show()
        plt.close()

    def plot_roc_curve(self, file_name = None):
        """
        ROC曲線をプロットするメソッド
        
        引数:
        file_name : str, optional
            ファイル名が指定された場合、プロットはファイルに保存されます。
            指定されない場合、プロットは画面に表示されます。
        """
        y_pred_proba = self.model.predict_proba(self.X_test)
        fpr = {}
        tpr = {}
        roc_auc = {}

        for i in range(len(np.unique(self.y_test))):
            fpr[i], tpr[i], _ = roc_curve(self.y_test, y_pred_proba[:, i], pos_label=i)
            roc_auc[i] = auc(fpr[i], tpr[i])

        plt.figure(figsize=(8, 6))
        for i in range(len(np.unique(self.y_test))):
            plt.plot(fpr[i], tpr[i], lw=2, label='クラス {0} (AUC = {1:0.2f})'.format(i, roc_auc[i]))

        plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
        plt.xlim([0.0, 1.0])
        plt.ylim([0.0, 1.05])
        plt.xlabel('偽陽性率')
        plt.ylabel('真陽性率')
        plt.title('ROC曲線')
        plt.legend(loc="lower right")
        plt.grid(alpha=0.3)

        if file_name:
            plt.savefig(file_name)
        else:
            plt.show()
        plt.close()

import pandas as pd
import numpy as np
from scipy.stats import norm
from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_percentage_error, mean_absolute_error
import matplotlib.pyplot as plt
from matplotlib import rcParams
rcParams['font.family'] = 'Meiryo'

class GenericRegressionModelUtil(ResourceManager):
    def __init__(self, model_cls,df=None, model_path=None):
        """
        クラスの初期化メソッド
        :param model_cls:回帰で使うモデルのクラス
        :param df: 初期データフレーム (pd.DataFrame)
        :param model_path: モデルファイルのパス (str)
        """
        super().__init__(df, model_path)
        self.model_cls = model_cls
        self.X_train = []
        self.X_test = []
        self.y_train = []
        self.y_test = []
        self.y_pred = []
        self.params = {}
        self.history = []

    def fit(self, target, columns=None, params={}, test_size=0.2, random_state=42, track_learning_curve=False, split_method='split'):
        """
        モデルを学習し、レポートを出力するメソッド
        :param target: str, 予測対象となるターゲット列名
        :param columns: list of str, 使用する特徴量の列名のリスト。ターゲットが含まれていても無視する。省略時は self.columns が使われる。
        :param params: dict, optional (default={}), ランダムフォレストのハイパーパラメータ
        :param test_size: float, optional (default=0.2), テストデータの割合
        :param random_state: int, optional (default=42), 乱数シード
        :param track_learning_curve: bool, optional (default=False), 学習曲線の履歴を取るかどうか
        :param split_method: str, optional (default='split'), データ分割方法 ('split' または 'cross_val')
        """
        if columns is not None:
            self.columns = columns

        X = self.df[[col for col in self.columns if col != target]]
        y = self.df[target]

        self.params = params
        self.track_learning_curve = track_learning_curve
        self.split_method = split_method

        if split_method == 'split':
            self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(X, y, test_size=test_size, random_state=random_state)
        elif split_method == 'cross_val':
            self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(X, y, test_size=test_size, random_state=random_state)
            self.cross_val_scores = cross_val_score(self.model_cls(**params, random_state=random_state), X, y, cv=5)

        self.model = self.model_cls(random_state=random_state, **params)
        
        if track_learning_curve:
            # 学習履歴を保存するリスト
            self.history = {'train_sizes': [], 'train_scores': [], 'val_scores': []}

            # 異なるサイズのトレーニングセットでモデルを再学習
            train_sizes = np.linspace(0.1, 1.0, 10, endpoint=False)  # 1.0 未満の最大値
            for train_size in train_sizes:
                X_train_sub, _, y_train_sub, _ = train_test_split(self.X_train, self.y_train, train_size=train_size, random_state=random_state)
                self.model.fit(X_train_sub, y_train_sub)
                
                # トレーニングスコアと検証スコアを計算
                train_score = r2_score(y_train_sub, self.model.predict(X_train_sub))
                val_score = r2_score(self.y_test, self.model.predict(self.X_test))
                
                # スコアを保存
                self.history['train_sizes'].append(len(X_train_sub))
                self.history['train_scores'].append(train_score)
                self.history['val_scores'].append(val_score)
        else:
            # モデルをトレーニング
            self.model.fit(self.X_train, self.y_train)

        self.y_pred = self.model.predict(self.X_test)
        
        return self.model

    def predict(self, columns = None, df = None):
        """
        学習済みモデルを用いて予測を行うメソッド
        :param columns: list, 予測に使うカラム名のリスト。省略するとself.columnsの全てのカラムが使われる。
        :param df: pd.DataFrame, 予測対象の特徴量データフレーム
        :return: np.ndarray, 予測結果
        """
        columns = self.columns if columns is None else columns
        X = self.df[columns] if df is None else df
        
        return self.model.predict(X)

    def fit_with_grid_search(self, target, columns, param_grid, test_size=0.2, random_state=42):
        """
        グリッドサーチを使用してハイパーパラメータをチューニングし、最適なモデルを見つけるメソッド
        :param target: str, 予測対象となるターゲット列名
        :param columns: list of str, 使用する特徴量の列名のリスト。ターゲットが含まれていても無視する。None を指定すると self.columnsが使われる。
        :param param_grid: dict, グリッドサーチで試すハイパーパラメータの辞書
        :param test_size: float, optional (default=0.2), テストデータの割合
        :param random_state: int, optional (default=42), 乱数シード
        """

        if columns is not None:
            self.columns = columns

        X = self.df[[col for col in self.columns if col != target]]
        y = self.df[target]

        self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(X, y, test_size=test_size, random_state=random_state)
        self.model = self.model_cls(random_state=random_state)
        grid_search = GridSearchCV(estimator=self.model, param_grid=param_grid, cv=5, scoring='r2', n_jobs=-1)
        grid_search.fit(self.X_train, self.y_train)

        self.model = grid_search.best_estimator_
        self.params = grid_search.best_params_
        best_score = grid_search.best_score_
        self.y_pred = self.model.predict(self.X_test)

        print(f'最適なハイパーパラメータ: {self.params}')
        print(f'グリッドサーチの最適なスコア: {best_score}')

        return self.model

    def evaluate(self):
        """
        回帰モデルの評価指標を計算して出力するメソッド
        """
        # モデルの精度を評価する
        mse = mean_squared_error(self.y_test, self.y_pred)
        rmse = np.sqrt(mse)  # RMSE
        mae = mean_absolute_error(self.y_test, self.y_pred)
        r2 = r2_score(self.y_test, self.y_pred)
        mape = mean_absolute_percentage_error(self.y_test, self.y_pred)

        # 統計情報を表示
        print(f'{self.y_test}の統計情報:')
        print(f'最小値(Min): {self.y_test.min()}')
        print(f'最大値(Max): {self.y_test.max()}')
        print(f'平均値(Mean): {self.y_test.mean()}')
        print(f'標準偏差(Std): {self.y_test.std()}')
        print(f'分散(Var): {self.y_test.var()}')

        # 精度指標を出力する
        print(f'平均絶対誤差 (Mean Absolute Error): {mae}')
        print(f'平均二乗誤差 (Mean Squared Error): {mse}')
        print(f'ルート平均二乗誤差 (Root Mean Squared Error): {rmse}')
        print(f'平均絶対パーセンテージ誤差 (MAPE): {mape}')
        print(f'決定係数 (R^2 Score): {r2}')

        # 特徴量の重要度を表示する
        feature_importances = self.model.feature_importances_
        importance_df = pd.DataFrame({'特徴量 (Feature)': self.columns, '重要度 (Importance)': feature_importances})
        importance_df = importance_df.sort_values(by='重要度 (Importance)', ascending=False)
        print("\n特徴量の重要度:")
        print(importance_df)

    def plot_learning_curve(self,file_name = None):
        """
        学習履歴をプロットするメソッド

        引数:
        file_name : str, optional
            ファイル名が指定された場合、プロットはファイルに保存されます。
            指定されない場合、プロットは画面に表示されます。
        """

        if not self.track_learning_curve:
            print("学習曲線の履歴を取るように設定されていません。")
            return
        
        plt.figure()
        plt.plot(self.history['train_sizes'], self.history['train_scores'], 'o-', color="r", label="トレーニングスコア")
        plt.plot(self.history['train_sizes'], self.history['val_scores'], 'o-', color="g", label="検証スコア")
        plt.title("学習曲線")
        plt.xlabel("トレーニング例数")
        plt.ylabel("スコア")
        plt.legend(loc="best")
        plt.grid()

        if file_name:
            plt.savefig(file_name)
        else:
            plt.show()
        plt.close()

    def plot_diagnostics(self, file_name = None):
        """
        予実の折れ線、散布図、回帰曲線、残渣プロットを描画するメソッド

        引数:
        file_name : str, optional
            ファイル名が指定された場合、プロットはファイルに保存されます。
            指定されない場合、プロットは画面に表示されます。
        """

        # 残差の計算
        residuals = self.y_test - self.y_pred

        fig, axs = plt.subplots(1, 4, figsize=(18, 5))

        # 実際の値と予測値の折れ線グラフ
        axs[0].plot(self.y_test.values, label='実際の値 (Actual)', linestyle='-', marker=None)
        axs[0].plot(self.y_pred, label='予測値 (Predicted)', color='red', linestyle='-', marker=None)
        axs[0].set_xlabel('サンプルインデックス (Sample Index)')
        axs[0].set_ylabel('値 (Value)')
        axs[0].set_title('実際の値 VS 予測値\n(Comparison of Actual and Predicted Values)')
        axs[0].legend()

        # 実際の値と予測値の散布図
        axs[1].scatter(self.y_test, self.y_pred, alpha=0.3, label='予測値 (Predicted)')
        axs[1].plot([self.y_test.min(), self.y_test.max()], [self.y_test.min(), self.y_test.max()], 'r--', label='対角線 (y=x)')

        # 回帰線の計算
        slope, intercept = np.polyfit(self.y_test, self.y_pred, 1)
        r2 = r2_score(self.y_test, self.y_pred)
        axs[1].plot(self.y_test, slope * self.y_test + intercept, color='blue', linestyle='-', linewidth=2, label=f'回帰線 (y={slope:.2f}x + {intercept:.2f}, $R^2$={r2:.2f})')
        
        axs[1].set_xlabel('実際の値 (Actual)')
        axs[1].set_ylabel('予測値 (Predicted)')
        axs[1].set_title('実際の値 vs 予測値\n(Actual vs Predicted)')
        axs[1].legend()

        # 残差プロット
        axs[2].scatter(self.y_pred, residuals, alpha=0.3, label='残差 (Residuals)')
        axs[2].hlines(y=0, xmin=self.y_pred.min(), xmax=self.y_pred.max(), linestyles='dashed', label='y=0')
        
        # 残差の平均と標準偏差を計算
        residuals_mean = np.mean(residuals)
        residuals_std = np.std(residuals)
        
        # y_pred をソートし、それに対応する範囲を再計算
        sorted_indices = np.argsort(self.y_pred)
        sorted_y_pred = self.y_pred[sorted_indices]
        sorted_upper = residuals_mean + residuals_std
        sorted_lower = residuals_mean - residuals_std

        axs[2].axhline(y=residuals_mean, color='blue', linestyle='--', label=f'平均 (Mean): {residuals_mean:.2f}')
        # 標準偏差の範囲を水色で塗りつぶし
        axs[2].fill_between(
            sorted_y_pred,  # ソートされた予測値
            sorted_lower,   # 下限 (固定値)
            sorted_upper,   # 上限 (固定値)
            color='lightblue',
            alpha=0.4,
            label=f'標準偏差 (Std): {residuals_std:.2f}'
        )

        axs[2].set_xlabel('予測値 (Predicted)')
        axs[2].set_ylabel('残差 (Residuals)')
        axs[2].set_title('残差プロット\n(Residual Plot)')
        axs[2].legend()

        # 残差のヒストグラム
        axs[3].hist(residuals, bins=30, edgecolor='k', density=True, alpha=0.6, color='g')

        # 残差のヒストグラムに正規分布曲線を追加
        xmin, xmax = axs[3].get_xlim()
        x = np.linspace(xmin, xmax, 100)
        p = norm.pdf(x, residuals_mean, residuals_std)
        axs[3].plot(x, p, 'k', linewidth=2)
        
        axs[3].set_xlabel('残差 (Residuals)')
        axs[3].set_ylabel('頻度 (Frequency)')
        axs[3].set_title('残差のヒストグラム\n(Histogram of Residuals)')

        plt.tight_layout()

        if file_name:
            plt.savefig(file_name)
        else:
            plt.show()
        plt.close()