分類のユースケース

3.2 分類のユースケース

小売店には、顧客の行動および購入履歴に関する情報があります。今度は入手可能なデータをもとに、最も収益性の高い製品の販売量および収益の増加につながる、ターゲットとする顧客タイプを分析して特定してほしいという要望があります。このユースケースでは、ランダム・フォレスト・アルゴリズムを使用してそのような顧客を特定する方法を示します。

トピック	リンク
OML4Py GitHubの例	分類のランダム・フォレスト
ランダム・フォレストについて	ランダム・フォレストについて
ランダム・フォレスト	ランダム・フォレスト・アルゴリズム
共有設定	共有設定

3.2.1 データのロード

SHスキーマからデータ・セットにアクセスし、属性を理解するためにデータを探索します。

データの調査

属性名	情報
CUST_ID	顧客のID
EDUCATION	顧客の教育情報
OCCUPATION	顧客の職業
HOUSEHOLD_SIZE	一戸当たりの人数
YRS_RESIDENCE	居住年数
AFFINITY_CARD	顧客がアフィニティ・カードを保有するかどうか
BULK_PACK_DISKETTES	製品。顧客がすでに当該製品を所有しているかどうかを示します。 1は「はい」を意味します。0は「いいえ」を意味します
FLAT_PANEL_MONITOR	製品。顧客がすでに当該製品を所有しているかどうかを示します。 1は「はい」を意味します。0は「いいえ」を意味します
HOME_THEATER_PACKAGE	製品。顧客がすでに当該製品を所有しているかどうかを示します。 1は「はい」を意味します。0は「いいえ」を意味します
BOOKKEEPING_APPLICATION	製品。顧客がすでに当該製品を所有しているかどうかを示します。 1は「はい」を意味します。0は「いいえ」を意味します
PRINTER_SUPPLIES	製品。顧客がすでに当該製品を所有しているかどうかを示します。 1は「はい」を意味します。0は「いいえ」を意味します
Y_BOX_GAMES	製品。顧客がすでに当該製品を所有しているかどうかを示します。 1は「はい」を意味します。0は「いいえ」を意味します
OS_DOC_SET_KANJI	製品。顧客がすでに当該製品を所有しているかどうかを示します。 1は「はい」を意味します。0は「いいえ」を意味します
COMMENTS	顧客からのコメント

SHスキーマのCUSTOMERS表についてさらに学習するには、「SHサンプル・スキーマ」を参照してください。

親トピック: 分類のユースケース

3.2.2 データの探索

データを調べ、データの品質を理解して評価します。このステージでは、データを評価してデータ内のデータ型およびノイズを識別します。欠損値および数値外れ値を探します。

データの理解と準備

OML4Pyを使用してPythonからデータベース・データにアクセスするには、まず、データベース表、ビューまたは問合せを表すoml.DataFrameプロキシ・オブジェクトをPythonに作成する必要があります。SUPPLEMENTARY_DEMOGRAPHICSおよびCUSTOMERSのoml.DataFrameプロキシ・オブジェクトを作成し、同一かつ一意の列の内部結合によってマージします。データを評価してデータ内のデータ型およびノイズを識別します。欠損値(体系的またはランダム)、数値外れ値、またはラベルが一貫していない質的値を探します。

データの準備および理解のために、次のステップを実行します:

%pythonインタプリタ・パラグラフで次のスクリプトを実行して、omlモジュール、Pandaのモジュールをインポートし、表示オプションを設定します:

import pandas as pd
import oml
 
pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 500)
pd.set_option('display.width', 1000)

import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)

oml.sync関数を使用して、データベース表SUPPLEMENTARY_DEMOGRAPHICSのプロキシとしてPythonオブジェクトDEMOGRAPHICSを作成します。oml.sync関数は、oml.DataFrameオブジェクトまたはoml.DataFrameオブジェクトのディクショナリを戻します。oml.syncによって戻されるoml.DataFrameオブジェクトは、データベース・オブジェクトのプロキシです。
```
DEMOGRAPHICS = oml.sync(table = "SUPPLEMENTARY_DEMOGRAPHICS", schema = "SH")
z.show(DEMOGRAPHICS.head())
```
shape関数を実行して、oml.DataFrameオブジェクトDEMOの行と列を表示します。
```
print("Shape:",DEMOGRAPHICS.shape)
```
```
(4500, 14)
```
oml.sync関数を使用して、データベース表SH.CUSTOMERSのプロキシとしてPythonオブジェクトCUSTOMERSを作成します。ステップ2と同様、ここではschemaが使用されていません。schema引数を使用すると、Python環境およびプロキシ・オブジェクトを作成するスキーマを指定できます。指定したデータベース・スキーマに一度に存在できるのは、1つの環境のみです。schema=Noneの場合、オブジェクトは現在のユーザーのスキーマ内に作成されます。
```
CUSTOMERS = oml.sync(query = 'SELECT CUST_ID, CUST_GENDER, CUST_MARITAL_STATUS, CUST_YEAR_OF_BIRTH, CUST_INCOME_LEVEL, CUST_CREDIT_LIMIT FROM SH.CUSTOMERS')
z.show(CUSTOMERS.head())
```
shape関数を実行して、oml.DataFrameオブジェクトCUSTOMERSの行と列を表示します。
```
print("Shape:",CUSTOMERS.shape)
```
```
(55500, 6)
```
CUSTOMERS表とDEMOGRAPHICS表を共通列CUST_IDの内部結合によってマージすることで、新しいoml.dataframe CUSTOMER_DATAを作成します。merge関数は、あるoml.dataframeを別のoml.dataframeに結合します。suffixesパラメータは、2つのoml.dataframeの列名が競合する場合に使用します。
```
CUSTOMER_DATA = CUSTOMERS[["CUST_ID", "CUST_INCOME_LEVEL", "CUST_CREDIT_LIMIT"]].merge(DEMOGRAPHICS[["CUST_ID", "HOUSEHOLD_SIZE", "OCCUPATION", "HOME_THEATER_PACKAGE"]], how = "inner", on = 'CUST_ID',suffixes = ["",""])
z.show(CUSTOMER_DATA.head())
```
shape関数を実行して、oml.DataFrameオブジェクトCUSTOMER_DATAの行と列を表示します。
```
print("Shape:", CUSTOMER_DATA.shape)
```
```
(4500, 6)
```
次のスクリプトを実行して、すべての列のデータ型を表示します。
```
print("The datatypes of the column: ","\n")
print(CUSTOMER_DATA.dtypes)
```
欠損値があるかどうかを確認するには、次のスクリプトを実行します。count関数は、各列のNULLでない要素の数を戻し、len関数はデータセット内の行の数を戻します。
```
print("Number of missing values in each column is : \n")
print(len(CUSTOMER_DATA)-CUSTOMER_DATA.count())
```
crosstabメソッドを使用して、データベース内のoml.DataFrameオブジェクトのクロス列分析を実行します。crosstabメソッドは、2つ以上の列のクロス集計を計算します。デフォルトでは、列と集計関数が渡されないかぎり、列の頻度表が計算されます。この例では、crosstab関数はHOME_THEATER_PACKAGEの回答者の分布を表示します。
```
z.show(CUSTOMER_DATA.crosstab('HOME_THEATER_PACKAGE'))
```

収入レベルに応じてHOME_THEATER_PACKAGEに対して顧客がどのように回答するかを把握するには、次のコードを実行します:


z.show(CUSTOMER_DATA.crosstab('CUST_INCOME_LEVEL','HOME_THEATER_PACKAGE').sort_values('count', ascending=False).rename(columns = {'count':'NUM_CUSTOMERS'}))

これで、データの理解およびデータの準備ステージが完了します。

親トピック: 分類のユースケース

3.2.3 モデルの構築

トレーニング・データ・セットを使用してモデルを構築します。oml.rf関数を使用してモデルを構築し、モデル設定を指定します。

分類などの教師あり学習の場合は、モデルを作成する前にデータをトレーニング・データとテスト・データに分割します。データ・セット全体を使用してモデルを構築することはできますが、使用可能な新しいデータ・セットがないかぎり、モデルの検証は困難です。したがって、モデルを評価し、同じデータに対するモデルのパフォーマンスを正確に査定するには、通常、データをトレーニング・データとテスト・データに分割(分離)します。トレーニング・データ・セットを使用してモデルをトレーニングした後、テスト・データ・セットを使用して予測問合せを実行し、モデルの精度をテストします。テスト・データ・セットには、予測する属性の既知の値がすでに含まれています。したがって、モデルの予測が正しいかどうかを簡単に判断できます。

アルゴリズムの選択

モデルを構築する前に、適切なアルゴリズムを選択します。次のアルゴリズムのいずれかを選択して、分類の問題を解決できます。

デシジョン・ツリー
一般化線形モデル
Naive Bayes
ニューラル・ネットワーク
ランダム・フォレスト
サポート・ベクター・マシン

ここでは、解釈性が重要な問題ではないため、ランダム・フォレスト・アルゴリズムを使用します。ランダム・フォレスト・アルゴリズムは、分類に使用されるアンサンブル手法の一種です。ランダム・フォレストは、多数の独立したデシジョン・ツリーを構築し、複数のデシジョン・ツリーの出力を組み合せて予測します。これらの各デシジョン・ツリーは、入力からランダムなサンプルを使用して構築され、各ツリーは特徴のランダムなサブセットを使用します。これにより、精度を高めながらオーバーフィッティングの問題を回避できます。教師あり学習アルゴリズム(ランダム・フォレスト・モデル)を使用してモデルを構築するには、まずデータをトレーニング・データとテスト・データに分割する必要があります。データを分割した後、トレーニング・データを使用してモデルを構築し、モデルが構築されたら、そのモデルを使用してテスト・データをスコアリングします。

CUSTOMER_DATAデータを、トレーニング・データ・セットにレコードの60%、テスト・データ・セットに40%の割合で分割します。seedパラメータは、ランダム分割に使用されます。splitメソッドは、DataFrameプロキシ・オブジェクトCUSTOMER_DATAによって参照されるデータを2つの新しいDataFrameプロキシ・オブジェクト(trainとtest)に分割します。次のスクリプトを実行します。
```
TRAIN, TEST = CUSTOMER_DATA.split(ratio = (0.6,0.4),seed=1)
TRAIN_X = TRAIN.drop('HOME_THEATER_PACKAGE')
TRAIN_Y = TRAIN['HOME_THEATER_PACKAGE']
TEST_X = TEST
TEST_Y = TEST['HOME_THEATER_PACKAGE']
```
次の文を実行して、testデータセットの数行を表示します。
```
z.show(TRAIN)
```
モデル設定を指定し、HOME_THEATER_PACKAGE属性を予測するためのランダム・フォレスト・モデル・オブジェクトを構築するには、次のスクリプトを実行します。設定は、キーと値またはディクショナリのペアとして指定し、それぞれパラメータ名と値の設定を指しています。ここで指定される設定は、PREP_AUTOとRFOR_NUM_TREESです。ランダム・フォレストでは、デシジョン・ツリー設定を使用して個々のツリー構造が構成されます。fit関数は、トレーニング・データおよびパラメータ設定に従ってRFモデルを構築します。
```
try:
    oml.drop(model = 'MODEL_RF')
except:
    pass
 
settings = {'PREP_AUTO': 'ON',
            'ALGO_NAME': 'ALGO_RANDOM_FOREST',
            'RFOR_NUM_TREES': '25'}
 
rf_mod = oml.rf(**settings)
rf_mod.fit(TRAIN_X, TRAIN_Y, case_id = 'CUST_ID', model_name = 'MODEL_RF')
```
モデル設定のパラメータ:
- RFOR_NUM_TREES: ランダム・フォレストが保持できるツリーの数を示します。
- PREP_AUTO: 完全自動データ準備またはユーザーが指示する一般的なデータ準備を指定するために使用します。デフォルトでは、定数値'PREP_AUTO': PREP_AUTO_ONで有効になっています。あるいは、'PREP_AUTO': 'ON'と指定することもできます。
  
  ノート:
  指定されていないパラメータまたは設定は、システムによって決定されるか、デフォルト値が使用されます。

親トピック: 分類のユースケース

3.2.4 評価

新しいデータでモデルを使用して予測を行う前に、まずモデルの精度を評価する必要があります。モデルは、様々な方法を使用して評価できます。

モデル設定に関する情報

モデルの構築後に生成された様々な統計を調べて、モデルを評価します。統計はモデルの品質を示します。

ランダム・フォレスト・モデル・オブジェクトで使用可能なモデル詳細(モデル設定、係数、適合詳細など)を確認するために、次のスクリプトを実行します。
```
rf_mod
```
次に示すように、個別に表示して確認することもできます。
次のスクリプトを実行して、モデルのグローバル統計を表示します。
```
z.show(rf_mod.global_stats)
```
次のスクリプトを実行して、rf_modモデルの属性重要度を表示します。
```
z.show(rf_mod.importance)
```

スコア

ここでは、モデルを使用してテスト・ケースに対して予測を行い、混合マトリックス、リフト・チャート、ゲイン・チャート、ROC曲線チャートなどの手法を使用してモデルを評価します。

テスト・データに対して予測を行い、スコアを元のデータに一意に関連付けることができるように、CASE_IDをサプリメンタル列として追加します。これを行うには、次のスクリプトを実行します:

# Set the case ID attribute
case_id = 'CUST_ID'
# Gather the Predictions
RES_DF = rf_mod.predict(TEST_X, supplemental_cols = TEST_X)
# Additionally collect the PROBABILITY_OF_0 and PROBABILITY_OF_1
RES_PROB = rf_mod.predict_proba(TEST_X, supplemental_cols = TEST_X[case_id])
# Join the entire result into RES_DF
RES_DF = RES_DF.merge(RES_PROB, how = "inner", on = case_id, suffixes = ["", ""])

モデルを評価するには、予測とターゲット列を含むプロキシ・オブジェクトoml.Dataframeをevaluate_modelという名前のユーザー定義関数に渡します。標準メトリックを使用してモデルを評価します。分類の例では、次を使用してモデルを評価できます:

混同マトリックス: テスト・データにおける実際の分類に関して行われた正確な予測と不正確な予測の数とタイプを表したものです。これは、n×nのマトリックスで、nはクラスの数です。
リフト・チャート: 2項分類にのみ適用され、ポジティブ・クラスの指定を必要とします。ランダムに生成された予測と比較して、分類モデルの予測がどの程度信頼できるかを計算したものです。
ROC曲線チャート: 2項分類に適用され、ポジティブ・クラスの指定を必要とします。これらは、分類モデルにおいて予測値と実際のターゲット値を比較するためのメトリックです。

次のスクリプトを実行して、メトリックおよびチャートを生成します:

def evaluate_model(pred_data='', settings_name={''}, name='', target=''):
    """Evaluate the models by passing an proxy oml.Dataframe containing Predictions
    and the target column,
    The Settings name (for the charts), 
    The name of the model used (for the charts),
    Supply the target column name for evaluation
    for computing the confusion matrix with the test dataset"""
    import oml
    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.metrics import auc
    from sklearn.metrics import roc_curve

    conf_matrix = pred_data.crosstab(target,'PREDICTION',pivot=True)

    # Extract Statistics from the Confusion Matrix
    cf_local = conf_matrix.pull()
    TN = int(cf_local[cf_local[target]==0]['count_(0)'])
    FN = int(cf_local[cf_local[target]==0]['count_(1)'])
    TP = int(cf_local[cf_local[target]==1]['count_(1)'])
    FP = int(cf_local[cf_local[target]==1]['count_(0)'])
    TPR = TP/(TP+FN)
    FPR = FP/(FP+TN)
    TNR = TN/(TN+FP)
    FNR = FN/(FN+TP)
    Precision = TP/(TP+FP)
    Accuracy = (TP+TN)/(TP+TN+FP+FN)
    NPV = TN/(FN+TN)
    DetectionRate = TN/(FN+TN)
    BalancedAccuracy = (TPR+TNR)/2

    # Estimated AUC via Triangle (not very precise) could be
    # AUC = (1/2)*FPR*TPR + (1/2)*(1-FPR)*(1-TPR) + (1-FPR)*TPR
    # Compute real AUC using roc_curve by loading the
    # data locally and using the roc_curve() function
    pred_local = pred_data.pull()
    fpr, tpr, _ = roc_curve(pred_local[[target]],pred_local[['PROBABILITY_OF_1']])
    AUC = auc(fpr, tpr)
    opt_index = np.argmax(tpr - fpr)
    FPR_OPT = fpr[opt_index]
    TPR_OPT = tpr[opt_index]
    F1Score = 2*Precision*TPR/(Precision+TPR)
    MathewsCorrCoef = ((TP*TN)-(FP*FN))/((TP+FP)*(TP+FN)*(TN+FP)*(TN+FN))**0.5

    # Store all statistics to export
    statistics = {'Algorithm' : name,
                'Algorithm_setting' : settings_name,
                'TN' : TN,
                'TP' : TP,
                'FP' : FP,
                'FN' : FN,
                'TPR' : TPR,
                'FPR' : FPR,
                'TNR' : TNR,
                'FNR' : FNR,
                'Precision' : Precision,
                'Accuracy' : Accuracy,
                'NPV' : NPV,
                'DetectionRate' : DetectionRate,
                'BalancedAccuracy' : BalancedAccuracy,
                'AUC' : AUC,
                'F1Score' : F1Score,
                'MathewsCorrCoef' : MathewsCorrCoef
                }
    # Nice round stats for printing to screen
    TOTAL = TP+TN+FP+FN
    TN_P = round((TN/TOTAL*100),2)
    FP_P = round((FP/TOTAL*100),2)
    FN_P = round((FN/TOTAL*100),2)
    TP_P = round((TP/TOTAL*100),2)
    # Print the output nicely on Zeppelin native Table
    print("%table CONFUSION MATRIX\tPREDICTED 0\tPREDICTED 1\nACTUAL 0\t"+
        "True Negative: "+str(TN)+" ("+str(TN_P)+"%)\t"+
        "False Positive: "+str(FP)+" ("+str(FP_P)+"%)\nACTUAL 1\t"+
        "False Negative: "+str(FN)+" ("+str(FN_P)+"%)\t"+
        "True Positive: "+str(TP)+" ("+str(TP_P)+"%)\n"+
        "Accuracy: "+str(round(Accuracy*100,4))+"%\t"+
        "AUC: "+str(round(AUC,4))+"\t"+
        "F1Score: "+str(round(F1Score,4))
        )

    # Multiple Charts for Evaluation
    fig, axes = plt.subplots(nrows=1, ncols=4,figsize=[22,5])
    ax1, ax2, ax3, ax4 = axes.flatten()
    fig.suptitle('Evaluation of the '+str(name)+' Model, with settings: '+str(settings_name), size=16)

    # Statistics
    ax1.axis('off')

    # Function to return rounded numbers if the string is float, return
    # integers otherwise and return characters if not a number
    def round_if_float(content):
        try:
            val = float(content)
        except ValueError:
            return(content)
        else:
            if val.is_integer():
                return(int(content))
            else:
                return(round(float(content),4))

    for num, name in enumerate(statistics):
        ax1.text(0.01, 
        (-num*0.06+0.94),
        "{0}: {1}".format(name,round_if_float(statistics[name])),
        ha='left', 
        va='bottom', 
        fontsize=12)

    # Produce Lift Chart
    ax2.set_title('Lift Chart')
    data = pred_local.sort_values(by='PROBABILITY_OF_1', ascending=False)
    data['row_id'] = range(0,0+len(data))
    data['decile'] = ( data['row_id'] / (len(data)/10) ).astype(int)
    lift = data.groupby('decile')[target].agg(['count','sum'])
    lift.columns = ['count', target]
    lift['decile'] = range(1,11)

    data_ideal = pred_local.sort_values(by=target, ascending=False)
    data_ideal['row_id'] = range(0,0+len(data))
    data_ideal['decile'] = ( data_ideal['row_id'] / (len(data_ideal)/10) ).astype(int)
    lift_ideal = data_ideal.groupby('decile')[target].agg(['count','sum'])
    lift_ideal.columns = ['count', 'IDEAL']
    lift['IDEAL']=lift_ideal['IDEAL']

    ax2.bar(lift['decile'],lift['IDEAL']/lift['count'],
    color='darkorange', label='Ideal')
    ax2.bar(lift['decile'],lift[target]/lift['count'],
    color='blue', alpha=0.6, label='Model')
    ax2.axhline((lift[target]/lift['count']).mean(), 
    color='grey', linestyle='--', label='Avg TARGET')
    ax2.set_ylim(0,1.15)
    ax2.set_xlabel('Decile', size=13)
    ax2.set_ylabel('Percent of Actual Targets', size=13)
    # Print labels.
    for dec in lift['decile']:
        ax2.text(dec, lift[lift.decile==dec][target]/lift[lift.decile==dec]['count'] + 0.05, 
        ("%.0f" % int(round((lift[(lift.decile==dec)][target]/lift[lift.decile==dec]['count'])*100,0)))+"%",
        ha='center', va='bottom')
    ax2.legend(loc="upper right")

    # Produce Gains Chart
    ax3.set_title('Distributions of Predictions')
    pred_local[pred_local[target]==1]['PROBABILITY_OF_1'].rename("Target = 1").plot(kind='density', bw_method=0.1, grid=True, ax=ax3)
    pred_local[pred_local[target]==0]['PROBABILITY_OF_1'].rename("Target = 0").plot(kind='density', bw_method=0.1, grid=True, ax=ax3)
    ax3.axvline(.5, color='grey', linestyle='--', label='Cutoff at 0.5')
    ax3.set_xlim([0,1])
    ax3.set_xlabel('Probability of 1', size=13)
    ax3.set_ylabel('Density', size=13)
    ax3.legend(loc="upper right")

    # ROC curve Chart
    ax4.set_title('ROC Curve')
    ax4.plot(fpr, tpr, color='blue', lw=2, label='ROC curve')
    ax4.plot(FPR_OPT, TPR_OPT,  color='orange', markersize=6)
    ax4.plot([0, 1], [0, 1], lw=2, linestyle='--', color='grey', label='Random guess')
    ax4.annotate('Optimal Cutoff:\nTPR: '+str(round(TPR_OPT,2))+' FPR: '+str(round(FPR_OPT,2)),
                fontsize=11, xy=(FPR_OPT, TPR_OPT), xycoords='data', xytext=(0.98, 0.54), 
                textcoords='data', 
                arrowprops=dict(facecolor='gray', shrink=0.1, width=2,
                                connectionstyle='arc3, rad=0.3'), 
                horizontalalignment='right', verticalalignment='top')
    ax4.annotate('AUC ='+str(round(AUC,4)), xy=(0.5, 0.35), 
                xycoords='axes fraction', size=13)
    ax4.annotate('Precision ='+str(round(Precision,4)), xy=(0.45, 0.3), 
                xycoords='axes fraction', size=13)
    ax4.annotate('Recall ='+str(round(TPR,4)), xy=(0.4, 0.25), 
                xycoords='axes fraction', size=13)
    ax4.annotate('Accuracy ='+str(round(Accuracy,4)), xy=(0.35, 0.2),
                xycoords='axes fraction', size=13)
    ax4.annotate('F1 Score ='+str(round(F1Score,4)), xy=(0.3, 0.15), 
                xycoords='axes fraction', size=13)
    ax4.set_xlim([-0.02, 1.02])
    ax4.set_ylim([0.0, 1.02])
    ax4.set_xlabel('False Positive Rate', size=13)
    ax4.set_ylabel('True Positive Rate', size=13) 
    ax4.legend(loc="lower right")

    return(statistics, pred_local)
    
_ = evaluate_model(pred_data=RES_DF, settings_name='Num Trees:25,Sampling Ratio:0.5', name='Random Forest', target='HOME_THEATER_PACKAGE')

HOME_THEATER_PACKAGEに0.5を上回る確率で回答した顧客の結果を表示します。表示するRES_DFデータセットの列を選択します。これを行うには、次のスクリプトを実行します:
```
z.show(RES_DF[RES_DF['PROBABILITY_OF_1'] > 0.5])
```
次のスクリプトを実行して、rf_modのモデル精度を取得します。score関数は、テスト・データとターゲット・テスト・データに対して予測を行い、平均精度を算出します。
```
print("RF accuracy score = {:.2f}".format(rf_mod.score(TEST_X, TEST_Y)))
```
```
RF accuracy score = 0.68
```
精度は0.68で、つまり結果の約68%が正しく予測されています。

結論として、HOME_THEATER_PACKAGEを購入する見込みがある顧客の識別に成功しました。この予測は、ターゲット顧客に対してホーム・シアター・パッケージを販促し、オファーするのに役立ちます。

親トピック: 分類のユースケース