EvalMLとは

import numpy as np
import pandas as pd

from evalml.data_checks import NullDataCheck

X = pd.DataFrame([[1, 2, 3],
                  [0, 4, np.nan],
                  [1, 4, np.nan],
                  [9, 4, np.nan],
                  [8, 6, np.nan]])

null_check = NullDataCheck(pct_null_col_threshold=0.8, pct_null_row_threshold=0.8)
messages = null_check.validate(X)

errors = [message for message in messages if message['level'] == 'error']
warnings = [message for message in messages if message['level'] == 'warning']

for warning in warnings:
    print("Warning:", warning['message'])

for error in errors:
    print("Error:", error['message'])

Warning: Column(s) '2' are 80.0% or more null

import evalml
from evalml.pipelines import BinaryClassificationPipeline
X, y = evalml.demos.load_breast_cancer()

X_train, X_holdout, y_train, y_holdout = evalml.preprocessing.split_data(X, y, problem_type='binary',
                                                                     test_size=0.2, random_seed=0)


pipeline_binary = BinaryClassificationPipeline(component_graph = {
            "Label Encoder": ["Label Encoder", "X", "y"],
            "Imputer": ["Imputer", "X", "Label Encoder.y"],
            "Random Forest Classifier": [
                "Random Forest Classifier",
                "Imputer.x",
                "Label Encoder.y",
            ],
        })
pipeline_binary.fit(X_train, y_train)

pipeline_binary.feature_importance

from evalml.objectives.binary_classification_objective import BinaryClassificationObjective
import pandas as pd

class FraudCost(BinaryClassificationObjective):
    """不正取引により、取引金額プロセス全体の中で失われた金額の割合をスコアリングします"""
    name = "Fraud Cost"
    greater_is_better = False
    score_needs_proba = False
    perfect_score = 0.0

    def __init__(self, retry_percentage=.5, interchange_fee=.02,
                 fraud_payout_percentage=1.0, amount_col='amount'):
        """不正取引のインスタンスを作成します

          引数:
            retry_percentage (float): 拒否された場合にトランザクションを再試行する顧客の割合。0から1の間。デフォルト:0.5。

            interchange_fee (float): 成功した各トランザクションのうち、どれだけ収集できるか。0から1の間。デフォルト:0.02。

            fraud_payout_percentage (float): 収集できない不正取引の割合。0から1の間。デフォルト:1.0。

            amount_col (str): 金額を含むデータの列の名前。デフォルト:"amount"
        """
        self.retry_percentage = retry_percentage
        self.interchange_fee = interchange_fee
        self.fraud_payout_percentage = fraud_payout_percentage
        self.amount_col = amount_col

    def decision_function(self, ypred_proba, threshold=0.0, X=None):
        """予測される確率、しきい値、及び取引金額を含むデータフレームから、トランザクションが不正であるかどうかを判断します。
            引数:
                ypred_proba (pd.Series): 予測される確率
                X (pd.DataFrame): 取引金額を含むデータフレーム
                threshold (float): 取引が不正取引であるかどうかを判断するためのドルのしきい値

            戻り値:
                pd.Series: Xとしきい値を使用し、予測された不正ラベルの系列
        """
        if not isinstance(X, pd.DataFrame):
            X = pd.DataFrame(X)

        if not isinstance(ypred_proba, pd.Series):
            ypred_proba = pd.Series(ypred_proba)

        transformed_probs = (ypred_proba.values * X[self.amount_col])
        return transformed_probs > threshold

    def objective_function(self, y_true, y_predicted, X):
        """予測、真の値、及び取引金額を含むデータフレームから、トランザクションごとに不正に失われた金額を計算します。
            引数:
                y_predicted (pd.Series): 予測される不正ラベル
                y_true (pd.Series): 真の不正取引ラベル
                X (pd.DataFrame): 取引金額を含むデータフレーム

            戻り値:
                float: amount lost to fraud per transaction
        """
        if not isinstance(X, pd.DataFrame):
            X = pd.DataFrame(X)

        if not isinstance(y_predicted, pd.Series):
            y_predicted = pd.Series(y_predicted)

        if not isinstance(y_true, pd.Series):
            y_true = pd.Series(y_true)

        # ユーザーデータの金額列を使用してトランザクションを抽出します
        try:
            transaction_amount = X[self.amount_col]
        except KeyError:
            raise ValueError("`{}` is not a valid column in X.".format(self.amount_col))

        # 不正取引の場合に支払われる金額
        fraud_cost = transaction_amount * self.fraud_payout_percentage

        # 取引のインターチェンジフィー
        interchange_cost = transaction_amount * (1 - self.retry_percentage) * self.interchange_fee

        # 不正取引の欠落のコストを計算する
        false_negatives = (y_true & ~y_predicted) * fraud_cost

        # 手数料で引かれた金額を計算する
        false_positives = (~y_true & y_predicted) * interchange_cost

        loss = false_negatives.sum() + false_positives.sum()

        loss_per_total_processed = loss / transaction_amount.sum()

        return loss_per_total_processed

pip install evalml

conda install -c conda-forge evalml

pip install evalml[complete]            #すべてのアドオン
pip install evalml[prophet]             #時系列のサポートには、FacebookのProphetライブラリでEvalMLを使用
pip install evalml[update_checker]      #新しいEvalMLリリースの自動通知を受信

from evalml.demos import load_weather
X, y = load_weather()
X_train, X_test, y_train, y_test = evalml.preprocessing.split_data(X, y, problem_type='')

from evalml.automl import AutoMLSearch

automl = AutoMLSearch(X_train, y_train, problem_type="time series regression",
                      max_batches=1,
                      problem_configuration={"gap": 0, "max_delay": 7,
                                             "forecast_horizon": 7, "time_index": "Date"},
                      allowed_model_families=["xgboost", "random_forest", "linear_model", "extra_trees",
                                              "decision_tree"]
                      )
automl.search()

import pandas as pd
baseline = automl.get_pipeline(0)
baseline.fit(X_train, y_train)
naive_baseline_preds = baseline.predict_in_sample(X_test, y_test, objective=None,
                                                  X_train=X_train, y_train=y_train)
expected_preds = pd.concat([y_train.iloc[-7:], y_test]).shift(7).iloc[7:]
pd.testing.assert_series_equal(expected_preds, naive_baseline_preds)

pl = automl.best_pipeline
pl.fit(X_train, y_train)
best_pipeline_score = pl.score(X_test, y_test, ['R2'], X_train, y_train)['R2']