ホーム » 2021 » 6月

月別アーカイブ: 6月 2021

Alibi Detect 0.7 : 概要

Alibi Detect 0.7 : 概要 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/30/2021 (0.7.0)

* 本ページは、Alibi Detect の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

 

Alibi Detect 0.7 : 概要

Alibi Detect は 外れ値敵対的 そして ドリフト 検知にフォーカスしたオープンソース Python ライブラリです。このパッケージは表形式データ、テキスト、画像と時系列のためのオンラインとオフライン検知の両者をカバーすることが目的です。TensorFlow と PyTorch バックエンドの両者がドリフト検知のためにサポートされます。

プロダクション設定で外れ値と分布を監視する重要性の背景については、論文 Monitoring and explainability of models in production に基づく、Challenges in Deploying and Monitoring Machine Learning Systems ICML 2020 ワークショップからの このトーク をチェックしてください。

 

インストールと使用方法

alibi-detect は PyPI からインストールできます :

pip install alibi-detect

代わりに、開発バージョンをインストールすることもできます :

pip install git+https://github.com/SeldonIO/alibi-detect.git

Prophet 時系列外れ値検知器を利用するには :

pip install alibi-detect[prophet]

API を例示するために VAE 外れ値検知を使用します。

from alibi_detect.od import OutlierVAE
from alibi_detect.utils import save_detector, load_detector

# initialize and fit detector
od = OutlierVAE(threshold=0.1, encoder_net=encoder_net, decoder_net=decoder_net, latent_dim=1024)
od.fit(x_train)

# make predictions
preds = od.predict(x_test)

# save and load detectors
filepath = './my_detector/'
save_detector(od, filepath)
od = load_detector(filepath)

予測は meta と data をキーとする辞書で返されます。meta は検出器のメタデータを含む一方で、data は自身の内に実際の予測を持つ辞書です。それは外れ値、敵対的 or ドリフトスコアと閾値、更にはインスタンスが例えば外れ値であるか否かの予測を含みます。正確な詳細はメソッド間で僅かに異なる可能性がありますので、読者には サポートされるアルゴリズムのタイプ に精通することを勧めます。

Prophet 時系列外れ値検知器 のためのセーブとロード機能は現在 Python 3.6 で issue が起きていますが、Python 3.7 では動作します。

 

サポートされるアルゴリズム

次のテーブルは各アルゴリズムのための推奨ユースケースを示します。カラムの Feature Level (特徴レベル) は検出が特徴レベルで成されるか否かを示します、例えば画像に対してピクセル毎にです。より多くの情報についてはドキュメントと元の論文、そして各々の検出器のためのサンプルへのリンクを持つアルゴリズム参照リストを確認してください。

 

外れ値検知 (Outlier Detection)

 

敵対的検出

 

ドリフト検出

 

TensorFlow と PyTorch サポート

ドリフト検出器は TensorFlow と PyTorch バックエンドをサポートします。けれども Alibi Detect は PyTorch をインストールしません。これをどのように行なうかは PyTorch docs を確認してください。例えば :

from alibi_detect.cd import MMDDrift

cd = MMDDrift(x_ref, backend='tensorflow', p_val=.05)
preds = cd.predict(x)

PyTorch で同じ検出器 :

cd = MMDDrift(x_ref, backend='pytorch', p_val=.05)
preds = cd.predict(x)

 

組込みの前処理ステップ

Alibi Detect はまたランダムに初期化されたエンコーダ、transformers ライブラリを使用する際のドリフトを検出するための事前訓練済のテキスト埋め込み、そして機械学習モデルからの隠れ層の抽出のような様々な前処理ステップも装備しています。これは 共変量と予測された分布シフト のような様々なタイプのドリフトを検出することを可能にします。前処理ステップは再び TensorFlow と PyTorch でサポートされます。

from alibi_detect.cd.tensorflow import HiddenOutput, preprocess_drift

model = # TensorFlow model; tf.keras.Model or tf.keras.Sequential
preprocess_fn = partial(preprocess_drift, model=HiddenOutput(model, layer=-1), batch_size=128)
cd = MMDDrift(x_ref, backend='tensorflow', p_val=.05, preprocess_fn=preprocess_fn)
preds = cd.predict(x)

詳細については example ノートブック (e.g. CIFAR10, 映画レビュー) を確認してください。

 

参照リスト

外れ値検知

 

敵対的検出

 

ドリフト検出

 

データセット

パッケージはまた様々な多様性のために多くのデータセットを簡単に取得できる alibi_detect.datasets の機能も含みます。各データセットについてデータとラベルか、データ、ラベルとオプションのメタデータを持つ Bunch オブジェクトが返されます。例えば :

from alibi_detect.datasets import fetch_ecg

(X_train, y_train), (X_test, y_test) = fetch_ecg(return_X_y=True)

 

シーケンシャル・データと時系列

  • Genome データセット : fetch_genome
    • 分布外分布検出のための尤度率 の一部としてリリースされた、分布外検出のための細菌ゲノム・データセット。オリジナルから TL;DR: データセットは訓練のために 10 in-distribution 細菌クラス、検証のために 60 OOD 細菌クラス、そしてテストのために別の 60 の異なる OOD 細菌クラスからの 250 塩基対のゲノム配列を含みます。訓練、検証とテストセット内にそれぞれ 1, 7 と再び 7 百万のシークエンスがあります。データセットの詳細については、README を確認してください。
      from alibi_detect.datasets import fetch_genome
      
      (X_train, y_train), (X_val, y_val), (X_test, y_test) = fetch_genome(return_X_y=True)
      

  • ECG 5000: fetch_ecg
    • Physionet から元は得られた、5000 ECG。

  • NAB: fetch_nab
    • Numenta 異常値ベンチマーク からの DataFrame 内の単変量時系列。利用可能な時系列を持つリストは alibi_detect.datasets.get_list_nab() を使用して取得できます。使用可能な時系列のリストは、alibi_detect.datasets.get_list_nab()を使用して取得できます。

 

画像

  • CIFAR-10-C: fetch_cifar10c
    • CIFAR-10-C (Hendrycks & Dietterich, 2019) は CIFAR-10 のテストセットを含みますが、異なるレベルの重大度 (= severity) で様々なタイプのノイズ、不鮮明さ (=blur)、輝度 etc. により破損 (= corrupted) そして摂動されていて、CIFAR-10 上で訓練された分類モデルのパフォーマンスの段階的な劣化に繋がります。fetch_cifar10c は任意の severity レベルや corruption タイプを選択することを可能にします。利用可能な corruption タイプを持つリストは alibi_detect.datasets.corruption_types_cifar10c() で取得できます。データセットは堅牢性とドリフトの研究で利用できます。元のデータは ここ で見つけられます。例えば :
      from alibi_detect.datasets import fetch_cifar10c
      
      corruption = ['gaussian_noise', 'motion_blur', 'brightness', 'pixelate']
      X, y = fetch_cifar10c(corruption=corruption, severity=5, return_X_y=True)
      
      

  • 敵対的 CIFAR-10: fetch_attack
    • CIFAR-10 で訓練された ResNet-56 分類器上の敵対的インスタンスをロードします。利用可能な攻撃 : Carlini-Wagner (‘cw’) と SLIDE (‘slide’)。例えば :
      from alibi_detect.datasets import fetch_attack
      
      (X_train, y_train), (X_test, y_test) = fetch_attack('cifar10', 'resnet56', 'cw', return_X_y=True)
      

 

表形式

  • KDD Cup ’99: fetch_kdd
    • 様々なタイプのコンピュータ・ネットワーク侵入を伴うデータセット。fetch_kdd はネットワーク侵入のサブセットをターゲットとして選択したり特定の特徴だけを選択することを可能にします。元のデータは ここ で見つけられます。

 

モデル

外れ値、敵対的あるいはドリフト検出以外で有用であり得るモデル and/or ビルディング・ブロックは alibi_detect.models の下で見つかります。主要な実装は :

  • PixelCNN++: alibi_detect.models.pixelcnn.PixelCNN
  • 変分 Autoencoder: alibi_detect.models.autoencoder.VAE
  • Sequence-to-sequence モデル: alibi_detect.models.autoencoder.Seq2Seq
  • ResNet: alibi_detect.models.resnet
    • CIFAR-10 上の事前訓練済み ResNet-20/32/44 モデルは Google Cloud Bucket 上で見つけることができて次のように取得できます :
      from alibi_detect.utils.fetching import fetch_tf_model
      
      model = fetch_tf_model('cifar10', 'resnet32')
      

 

統合

Alibi-detect はオープンソース機械学習モデル配備プラットフォーム Seldon Core とモデルサービング・フレームワーク KFServing に統合されています。

 

Citations

(訳注 : 原文 を参照してください。)

 

以上



Prophet 1.0 : 概要

Prophet 1.0 : 概要 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/29/2021 (1.0)

* 本ページは、Prophet の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

Prophet 1.0 : 概要

Prophet は加法モデルに基づき時系列データを予測するための手続きです、そこでは毎年、毎週そして毎日の季節性 (= seasonality) 及び休日の影響による非線形トレンドが適合されます。それは強い季節的影響と幾つかの季節の履歴データを持つ時系列で最善に動作します。Prophet は欠測データとトレンドの変化に対して堅牢で、典型的には外れ値を上手く処理します。

Prophet は Facebook の Core データサイエンス・チーム によりリリースされた オープンソース・ソフトウェア です。ダウンロードのために CRAN と PyPI で利用可能です。

 

重要なリンク

 

Python でインストール

Prophet は PyPi 上ですので、それをインストールするために pip を利用できます。v0.6 以後、Python 2 はもはやサポートされません。v1.0 の時点で、PyPI 上のパッケージ名は “prophet” です ; v1.0 以前はそれは “fbprophet” でした。

# Install pystan with pip before using pip to install prophet
# pystan>=3.0 is currently not supported
pip install pystan==2.19.1.1

pip install prophet

Prophet が持つデフォルトの依存性は pystan です。PyStan はそれ自身の インストール手順 を持ちます。prophet をインストールするために pip を使用する前に pip で pystan をインストールしてください。

 

参考 : PyStan インストール

※ 但し、Anaconda 環境については別途後述されますので併せて読んでください。

PyPI から PyStan をインストールするためには貴方のシステムが要件を満たしていることを確認してください :

  • Python ≥3.7
  • Linux or macOS
  • x86-64 CPU
  • C++ compiler: gcc ≥9.0 or clang ≥10.0.
# gcc 9.x のインストール

sudo add-apt-repository ppa:ubuntu-toolchain-r/test
sudo apt update
sudo apt install g++-9-multilib

# デフォルト設定
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-9 30
sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-9 30
update-alternatives --display gcc

pip で PyStan をインストールします。次のコマンドは PyStan をインストールします :

python3 -m pip install pystan

 

サポートされる Linux ディストリビューション

2 つの公式にサポートされる Linux ディストリビューションがあります :

  • Debian 11
  • Ubuntu 20.04

Users have reported that PyStan works on several other Linux distributions. If you use an unsupported distribution and find that the PyPI wheels do not work, try installing httpstan from source. Once httpstan is installed, PyStan should work.

 

Experimental backend – cmdstanpy

(省略)

 

Anaconda

gcc をセットアップするためには “conda install gcc” を使用します。Prophet をインストールする最も簡単な方法は conda-forge 経由です : “conda install -c conda-forge prophet”

 

Linux

Make sure compilers (gcc, g++, build-essential) and Python development tools (python-dev, python3-dev) are installed. In Red Hat systems, install the packages gcc64 and gcc64-c++. If you are using a VM, be aware that you will need at least 4GB of memory to install prophet, and at least 2GB of memory to use prophet.

 

以上



PyOD 0.8 : Examples : AutoEncoder

PyOD 0.8 : Examples : AutoEncoder (解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/28/2021 (0.8.9)

* 本ページは、PyOD の以下のドキュメントとサンプルを参考にして作成しています:


* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

PyOD 0.8 : Examples : AutoEncoder

完全なサンプル : examples/auto_encoder_example.py

 

合成データの生成

pyod.utils.data.generate_data() でサンプルデータを生成します :

from pyod.utils.data import generate_data

contamination = 0.1  # percentage of outliers
n_train = 20000  # number of training points
n_test = 2000  # number of testing points
n_features = 300  # number of features

# Generate sample data
X_train, y_train, X_test, y_test = generate_data(
    n_train=n_train,
    n_test=n_test,
    n_features=n_features,
    contamination=contamination,
    random_state=42)

X_train, y_train の shape と値を確認します :

print(X_train.shape)
print(y_train.shape)
(20000, 300)
(20000,)
X_train[:10]
array([[6.43365854, 5.5091683 , 5.04469788, ..., 4.98920813, 6.08796866,
        5.65703627],
       [6.98114644, 4.97019307, 7.24011768, ..., 4.13407401, 4.17437525,
        7.14246591],
       [6.96879306, 5.29747338, 5.29666367, ..., 5.97531553, 6.40414268,
        5.8399228 ],
       ...,
       [5.13676552, 6.62890142, 6.14075622, ..., 5.42330645, 5.68013833,
        7.49193446],
       [6.09141558, 5.30143243, 7.09624952, ..., 6.32592813, 7.31717914,
        7.4945297 ],
       [5.74924769, 6.76427622, 7.10854915, ..., 6.38070765, 6.23367069,
        6.3011638 ]])
y_train[:10]
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

 

モデル訓練

pyod.models.auto_encoder.AutoEncoder 検出器をインポートして初期化し、そしてモデルを適合させます。

オートエンコーダ (AE) は有用なデータ表現を教師なしで学習するためのニューラルネットワークの一種です。PCA と同様に、再構築エラーを計算することによりデータの外れ値オブジェクトを検出するために使用できるでしょう。

参照 :

  • Charu C Aggarwal. Outlier analysis. In Data mining, 75–79. Springer, 2015.
from pyod.models.auto_encoder import AutoEncoder

# train AutoEncoder detector
clf_name = 'AutoEncoder'
clf = AutoEncoder(epochs=30, contamination=contamination)
clf.fit(X_train)
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense (Dense)                (None, 300)               90300     
_________________________________________________________________
dropout (Dropout)            (None, 300)               0         
_________________________________________________________________
dense_1 (Dense)              (None, 300)               90300     
_________________________________________________________________
dropout_1 (Dropout)          (None, 300)               0         
_________________________________________________________________
dense_2 (Dense)              (None, 64)                19264     
_________________________________________________________________
dropout_2 (Dropout)          (None, 64)                0         
_________________________________________________________________
dense_3 (Dense)              (None, 32)                2080      
_________________________________________________________________
dropout_3 (Dropout)          (None, 32)                0         
_________________________________________________________________
dense_4 (Dense)              (None, 32)                1056      
_________________________________________________________________
dropout_4 (Dropout)          (None, 32)                0         
_________________________________________________________________
dense_5 (Dense)              (None, 64)                2112      
_________________________________________________________________
dropout_5 (Dropout)          (None, 64)                0         
_________________________________________________________________
dense_6 (Dense)              (None, 300)               19500     
=================================================================
Total params: 224,612
Trainable params: 224,612
Non-trainable params: 0
_________________________________________________________________
None
Epoch 1/30
563/563 [==============================] - 2s 3ms/step - loss: 3.9799 - val_loss: 1.6536
Epoch 2/30
563/563 [==============================] - 1s 2ms/step - loss: 1.3378 - val_loss: 1.2611
Epoch 3/30
563/563 [==============================] - 1s 2ms/step - loss: 1.1653 - val_loss: 1.1830
Epoch 4/30
563/563 [==============================] - 1s 2ms/step - loss: 1.1163 - val_loss: 1.1421
Epoch 5/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0902 - val_loss: 1.1188
Epoch 6/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0745 - val_loss: 1.1108
Epoch 7/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0609 - val_loss: 1.0937
Epoch 8/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0519 - val_loss: 1.0851
Epoch 9/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0439 - val_loss: 1.0823
Epoch 10/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0372 - val_loss: 1.0715
Epoch 11/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0309 - val_loss: 1.0658
Epoch 12/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0247 - val_loss: 1.0612
Epoch 13/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0193 - val_loss: 1.0576
Epoch 14/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0158 - val_loss: 1.0543
Epoch 15/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0129 - val_loss: 1.0523
Epoch 16/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0103 - val_loss: 1.0495
Epoch 17/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0081 - val_loss: 1.0476
Epoch 18/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0062 - val_loss: 1.0460
Epoch 19/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0045 - val_loss: 1.0445
Epoch 20/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0031 - val_loss: 1.0433
Epoch 21/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0019 - val_loss: 1.0422
Epoch 22/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0008 - val_loss: 1.0413
Epoch 23/30
563/563 [==============================] - 1s 2ms/step - loss: 1.0001 - val_loss: 1.0405
Epoch 24/30
563/563 [==============================] - 1s 2ms/step - loss: 0.9993 - val_loss: 1.0399
Epoch 25/30
563/563 [==============================] - 1s 2ms/step - loss: 0.9987 - val_loss: 1.0394
Epoch 26/30
563/563 [==============================] - 1s 2ms/step - loss: 0.9982 - val_loss: 1.0389
Epoch 27/30
563/563 [==============================] - 1s 2ms/step - loss: 0.9978 - val_loss: 1.0386
Epoch 28/30
563/563 [==============================] - 1s 2ms/step - loss: 0.9975 - val_loss: 1.0383
Epoch 29/30
563/563 [==============================] - 1s 2ms/step - loss: 0.9972 - val_loss: 1.0380
Epoch 30/30
563/563 [==============================] - 1s 2ms/step - loss: 0.9969 - val_loss: 1.0378
AutoEncoder(batch_size=32, contamination=0.1, dropout_rate=0.2, epochs=30,
      hidden_activation='relu', hidden_neurons=[64, 32, 32, 64],
      l2_regularizer=0.1,
      loss=,
      optimizer='adam', output_activation='sigmoid', preprocessing=True,
      random_state=None, validation_size=0.1, verbose=1)

訓練データの予測ラベルと外れ値スコアを取得します :

y_train_pred = clf.labels_  # binary labels (0: inliers, 1: outliers)
y_train_scores = clf.decision_scores_  # raw outlier scores
y_train_pred
array([0, 0, 0, ..., 1, 1, 1])
y_train_scores[:10]
array([7.71661709, 8.3933272 , 8.03062351, 8.3012123 , 7.29930043,
       7.8202035 , 8.25040261, 7.89435037, 8.68701496, 7.54829144])

 

予測と評価

先に正解ラベルを確認しておきます :

y_test
array([0., array([0., 0., 0., ..., 1., 1., 1.])

テストデータ上で予測を行ないます :

y_test_pred = clf.predict(X_test)  # outlier labels (0 or 1)
y_test_scores = clf.decision_function(X_test)  # outlier scores
y_test_pred
array([0, 0, 0, ..., 1, 1, 1])
y_test_scores[:10]
array([7.88748478, 7.4678574 , 7.68665623, 7.7947202 , 7.81147175,
       7.44892412, 7.35455911, 7.74632114, 7.46644309, 8.08000442])

ROC と Precision @ Rank n pyod.utils.data.evaluate_print() を使用して予測を評価します。

from pyod.utils.data import evaluate_print
# evaluate and print the results
print("\nOn Training Data:")
evaluate_print(clf_name, y_train, y_train_scores)
print("\nOn Test Data:")
evaluate_print(clf_name, y_test, y_test_scores)
On Training Data:
AutoEncoder ROC:1.0, precision @ rank n:1.0

On Test Data:
AutoEncoder ROC:1.0, precision @ rank n:1.0
 

以上



PyOD 0.8 : Examples : Isolation Forest

PyOD 0.8 : Examples : Isolation Forest (解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/28/2021 (0.8.9)

* 本ページは、PyOD の以下のドキュメントとサンプルを参考にして作成しています:


* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

 

PyOD 0.8 : Examples : Isolation Forest

完全なサンプル : examples/iforest_example.py

 

合成データの生成と可視化

pyod.utils.data.generate_data() でサンプルデータを生成します :

from pyod.utils.data import generate_data

contamination = 0.1  # percentage of outliers
n_train = 200  # number of training points
n_test = 100  # number of testing points

X_train, y_train, X_test, y_test = generate_data(
    n_train=n_train, n_test=n_test,
    n_features=2,
    contamination=contamination,
    random_state=42
)

X_train, y_train の shape と値を確認します :

print(X_train.shape)
print(y_train.shape)
(200, 2)
(200,)
X_train[:10]
array([[6.43365854, 5.5091683 ],
       [5.04469788, 7.70806466],
       [5.92453568, 5.25921966],
       [5.29399075, 5.67126197],
       [5.61509076, 6.1309285 ],
       [6.18590347, 6.09410578],
       [7.16630941, 7.22719133],
       [4.05470826, 6.48127032],
       [5.79978164, 5.86930893],
       [4.82256361, 7.18593123]])
y_train[:200]
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1.,
       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

X_train の分布を可視化します :

import matplotlib.pyplot as plt
 
plt.scatter(X_train[:, 0], X_train[:, 1])

訓練データを可視化します :

import seaborn as sns
sns.set_style("dark")

from mpl_toolkits.mplot3d import Axes3D

X0 = X_train[:, 0]
X1 = X_train[:, 1]
Y = y_train

fig = plt.figure()
ax = Axes3D(fig)

ax.set_title("synthesized data")
 
ax.set_xlabel("X0")
ax.set_ylabel("X1")
ax.set_zlabel("Y")
 
ax.plot(X0, X1, Y, marker="o",linestyle='None')

 

モデル訓練

pyod.models.iforest.IForest 検出器をインポートして初期化し、そしてモデルを適合させます。

scikit-learn Isolation Forest のより多くの機能を持つラッパーです。

IsolationForest は、特徴をランダムに選択してから選択された特徴の最大値と最小値の間の分割値 (= split value) をランダムに選択することにより観測を「分離 (= isolate)」します。

参照 :

  • Fei Tony Liu, Kai Ming Ting, and Zhi-Hua Zhou. Isolation forest. In Data Mining, 2008. ICDM’08. Eighth IEEE International Conference on, 413–422. IEEE, 2008.
  • Fei Tony Liu, Kai Ming Ting, and Zhi-Hua Zhou. Isolation-based anomaly detection. ACM Transactions on Knowledge Discovery from Data (TKDD), 6(1):3, 2012.

再帰的分割 (= partitioning) は木構造で表されますので、サンプルを分離するために必要な分割の数はルートノードから終端ノードへのパスの長さに等しいです。

そのようなランダムツリーの森 (= forest) に渡り平均された、このパスの長さは正常性と決定関数の尺度です。

ランダム分割は異常値のためには著しく短いパスを生成します。そのため、ランダムツリーの森が特定のサンプルのために短いパスの長さを集合的に生成するとき、それらは異常である可能性が高くなります。

from pyod.models.iforest import IForest

clf_name = 'IForest'
clf = IForest()
clf.fit(X_train)
IForest(behaviour='old', bootstrap=False, contamination=0.1, max_features=1.0,
    max_samples='auto', n_estimators=100, n_jobs=1, random_state=None,
    verbose=0)

訓練データの予測ラベルと外れ値スコアを取得します :

y_train_pred = clf.labels_  # binary labels (0: inliers, 1: outliers)
y_train_scores = clf.decision_scores_  # raw outlier scores
y_train_pred
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,
       0, 1])
y_train_scores[-40:]
array([-0.1846575 , -0.17420279, -0.16454624, -0.18313387,  0.00184097,
       -0.16721463, -0.20881165, -0.12698201, -0.20432723, -0.19229842,
       -0.18207002, -0.10462056, -0.21048142, -0.17633758, -0.18314583,
       -0.17556592, -0.17987594, -0.20584378, -0.19802026, -0.15455344,
        0.03418722,  0.05486257,  0.06756084,  0.04571578,  0.07418781,
       -0.01109817,  0.03804931,  0.05553404,  0.11342275,  0.03541737,
       -0.06930148,  0.04314033,  0.20286855,  0.08323074,  0.09318281,
        0.14768482,  0.13077218,  0.03692   , -0.03166733,  0.11722839])

 

予測と評価

先に正解ラベルを確認しておきます :

y_test
array([0., array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

テストデータ上で予測を行ないます :

y_test_pred = clf.predict(X_test)  # outlier labels (0 or 1)
y_test_scores = clf.decision_function(X_test)  # outlier scores
y_test_pred
aarray([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1])
y_test_scores[-40:]
array([-0.12997412, -0.20032257, -0.17450527, -0.17089002, -0.10767756,
       -0.13952181, -0.01800938, -0.14394372, -0.07613799, -0.15948458,
       -0.19488334, -0.14925167, -0.20239421, -0.09349558, -0.1980245 ,
       -0.10904396, -0.19059866, -0.00824005, -0.20500567, -0.1781156 ,
       -0.1023197 , -0.20947508, -0.19867088, -0.13209401, -0.11648015,
       -0.02002286, -0.17712404, -0.0594405 , -0.20782814, -0.20041835,
        0.0692155 ,  0.08597497,  0.0822211 ,  0.1060188 , -0.01362171,
        0.00519536,  0.08507602,  0.11226714,  0.07143067,  0.07464685])

ROC と Precision @ Rank n pyod.utils.data.evaluate_print() を使用して予測を評価します。

from pyod.utils.data import evaluate_print
# evaluate and print the results
print("\nOn Training Data:")
evaluate_print(clf_name, y_train, y_train_scores)
print("\nOn Test Data:")
evaluate_print(clf_name, y_test, y_test_scores)
On Training Data:
IForest ROC:0.9944, precision @ rank n:0.85

On Test Data:
IForest ROC:0.9978, precision @ rank n:0.9

総ての examples に含まれる visualize 関数により可視化を生成します :

from pyod.utils.example import visualize
 
visualize(clf_name, X_train, y_train, X_test, y_test, y_train_pred,
          y_test_pred, show_figure=True, save_figure=False)

 

以上



PyOD 0.8 : Examples : 局所外れ値因子 (LOF)

PyOD 0.8 : Examples : 局所外れ値因子 (LOF) (解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/28/2021 (0.8.9)

* 本ページは、PyOD の以下のドキュメントとサンプルを参考にして作成しています:


* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

 

PyOD 0.8 : Examples : 局所外れ値因子 (LOF)

完全なサンプル : examples/lof_example.py

 

合成データの生成と可視化

pyod.utils.data.generate_data() でサンプルデータを生成します :

from pyod.utils.data import generate_data

contamination = 0.1  # percentage of outliers
n_train = 200  # number of training points
n_test = 100  # number of testing points

X_train, y_train, X_test, y_test = generate_data(
    n_train=n_train, n_test=n_test,
    n_features=2,
    contamination=contamination,
    random_state=42
)

X_train, y_train の shape と値を確認します :

print(X_train.shape)
print(y_train.shape)
(200, 2)
(200,)
X_train[:10]
array([[6.43365854, 5.5091683 ],
       [5.04469788, 7.70806466],
       [5.92453568, 5.25921966],
       [5.29399075, 5.67126197],
       [5.61509076, 6.1309285 ],
       [6.18590347, 6.09410578],
       [7.16630941, 7.22719133],
       [4.05470826, 6.48127032],
       [5.79978164, 5.86930893],
       [4.82256361, 7.18593123]])
y_train[:200]
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1.,
       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

X_train の分布を可視化します :

import matplotlib.pyplot as plt
 
plt.scatter(X_train[:, 0], X_train[:, 1])

訓練データを可視化します :

import seaborn as sns
sns.set_style("dark")

from mpl_toolkits.mplot3d import Axes3D

X0 = X_train[:, 0]
X1 = X_train[:, 1]
Y = y_train

fig = plt.figure()
ax = Axes3D(fig)

ax.set_title("synthesized data")
 
ax.set_xlabel("X0")
ax.set_ylabel("X1")
ax.set_zlabel("Y")
 
ax.plot(X0, X1, Y, marker="o",linestyle='None')

 

モデル訓練

pyod.models.lof.LOF 検出器をインポートして初期化し、そしてモデルを適合させます。

scikit-learn LOF クラスのより多くの機能を持つラッパーです。局所外れ値因子 (LOF) を使用する教師なし外れ値検知です。

各サンプルの異常スコアは局所外れ値因子と呼ばれます。それは、与えられたサンプルのその近傍に関する密度の局所的な偏差を測定します。 異常スコアが周囲の近傍に関してオブジェクトがどの程度孤立しているかに依存するという点で局所的です。より正確には、局所性は k-近傍により与えられ、その距離は局所密度を推定するために使用されます。サンプルの局所密度をその近傍の局所密度と比較することで、近傍よりも実質的に低い密度を持つサンプルを識別できます。これらは外れ値と考えられます。

参照 :

  • Markus M Breunig, Hans-Peter Kriegel, Raymond T Ng, and Jörg Sander. Lof: identifying density-based local outliers. In ACM sigmod record, volume 29, 93–104. ACM, 2000.
from pyod.models.lof import LOF

clf_name = 'LOF'
clf = LOF()
clf.fit(X_train)
LOF(algorithm='auto', contamination=0.1, leaf_size=30, metric='minkowski',
  metric_params=None, n_jobs=1, n_neighbors=20, p=2)

訓練データの予測ラベルと外れ値スコアを取得します :

y_train_pred = clf.labels_  # binary labels (0: inliers, 1: outliers)
y_train_scores = clf.decision_scores_  # raw outlier scores
y_train_pred
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,
       1, 1])
y_train_scores[-40:]
array([1.0373351 , 1.23270679, 1.09265586, 1.12859822, 1.74295089,
       1.26432797, 1.00387583, 1.32265673, 1.02052867, 1.04926256,
       1.22713433, 1.23132147, 0.95678759, 1.18736669, 1.1196501 ,
       1.22407483, 1.04189977, 0.98252058, 1.01734905, 1.1686789 ,
       2.37922022, 3.21589785, 2.42579873, 2.08097629, 4.79209747,
       3.38198835, 4.6689984 , 2.09441517, 2.88382391, 2.30676828,
       1.91029513, 3.07594268, 4.99950821, 4.45338669, 3.49185524,
       2.30079596, 5.32646346, 3.01951984, 2.92084825, 3.84004143])

 

予測と評価

先に正解ラベルを確認しておきます :

y_test
array([0., array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

テストデータ上で予測を行ないます :

y_test_pred = clf.predict(X_test)  # outlier labels (0 or 1)
y_test_scores = clf.decision_function(X_test)  # outlier scores
y_test_pred
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
y_test_scores[-40:]
array([4.24565000e+00, 4.22664796e-01, 2.20854837e+00, 3.19271455e+00,
       5.28318116e+00, 4.89035191e+00, 9.00245383e+00, 3.36891011e+00,
       6.41160123e+00, 3.70486129e+00, 8.97553458e-01, 3.23785753e+00,
       3.55922222e-01, 6.19169925e+00, 7.27336532e-01, 3.88522610e+00,
       1.08105367e+00, 1.42204980e+01, 6.55858782e-01, 1.46394676e+00,
       3.95907542e+00, 1.06528255e-01, 6.75944610e-01, 4.94017438e+00,
       5.62629894e+00, 8.14443303e+00, 1.92662344e+00, 7.81555289e+00,
       1.17055228e-01, 6.62232486e-01, 9.36051952e+01, 1.76344612e+02,
       1.03037866e+02, 2.51116697e+02, 1.79382377e+01, 2.37451925e+01,
       1.80881699e+02, 1.72118668e+02, 1.27494937e+02, 6.26970512e+01])

ROC と Precision @ Rank n pyod.utils.data.evaluate_print() を使用して予測を評価します。

from pyod.utils.data import evaluate_print
# evaluate and print the results
print("\nOn Training Data:")
evaluate_print(clf_name, y_train, y_train_scores)
print("\nOn Test Data:")
evaluate_print(clf_name, y_test, y_test_scores)
On Training Data:
LOF ROC:0.9997, precision @ rank n:0.95

On Test Data:
LOF ROC:1.0, precision @ rank n:1.0

総ての examples に含まれる visualize 関数により可視化を生成します :

from pyod.utils.example import visualize
 
visualize(clf_name, X_train, y_train, X_test, y_test, y_train_pred,
          y_test_pred, show_figure=True, save_figure=False)

 

以上



PyOD 0.8 : Examples : 最小共分散行列式 (MCD)

PyOD 0.8 : Examples : 最小共分散行列式 (MCD) (解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/27/2021 (0.8.9)

* 本ページは、PyOD の以下のドキュメントとサンプルを参考にして作成しています:


* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

 

PyOD 0.8 : Examples : 最小共分散行列式 (MCD)

完全なサンプル : examples/mcd_example.py

 

合成データの生成と可視化

pyod.utils.data.generate_data() でサンプルデータを生成します :

from pyod.utils.data import generate_data

contamination = 0.1  # percentage of outliers
n_train = 200  # number of training points
n_test = 100  # number of testing points

X_train, y_train, X_test, y_test = generate_data(
    n_train=n_train, n_test=n_test,
    n_features=2,
    contamination=contamination,
    random_state=42
)

X_train, y_train の shape と値を確認します :

print(X_train.shape)
print(y_train.shape)
(200, 2)
(200,)
X_train[:10]
array([[6.43365854, 5.5091683 ],
       [5.04469788, 7.70806466],
       [5.92453568, 5.25921966],
       [5.29399075, 5.67126197],
       [5.61509076, 6.1309285 ],
       [6.18590347, 6.09410578],
       [7.16630941, 7.22719133],
       [4.05470826, 6.48127032],
       [5.79978164, 5.86930893],
       [4.82256361, 7.18593123]])
y_train[:200]
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1.,
       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

X_train の分布を可視化します :

import matplotlib.pyplot as plt
 
plt.scatter(X_train[:, 0], X_train[:, 1])

訓練データを可視化します :

import seaborn as sns
sns.set_style("dark")

from mpl_toolkits.mplot3d import Axes3D

X0 = X_train[:, 0]
X1 = X_train[:, 1]
Y = y_train

fig = plt.figure()
ax = Axes3D(fig)

ax.set_title("synthesized data")
 
ax.set_xlabel("X0")
ax.set_ylabel("X1")
ax.set_zlabel("Y")
 
ax.plot(X0, X1, Y, marker="o",linestyle='None')

 

モデル訓練

pyod.models.mcd.MCD 検出器をインポートして初期化し、そしてモデルを適合させます。

最小共分散行列式 (MCD) を使用したガウス分布データセット内の外れ値を検出します : 共分散の堅牢な推定器です。

最小共分散行列式・共分散推定器はガウス分布データ上で適用されますが、単峰性の対称な分布からドローされたデータ上でも関連性がある可能性があります。それは多峰なデータで使用されることを意味していません (MinCovDet オブジェクトを適合させるために使用されるアルゴリズムはそのような場合には失敗する傾向にあります)。多峰なデータセットを処理するためには射影追跡法を考慮するべきです。

最初に最小共分散行列式モデルを適合させてからデータの外れ値の degree として Mahalanobis 距離を計算します。

参照 :

  • Johanna Hardin and David M Rocke. Outlier detection in the multiple cluster setting using the minimum covariance determinant estimator. Computational Statistics & Data Analysis, 44(4):625–638, 2004.
  • Peter J Rousseeuw and Katrien Van Driessen. A fast algorithm for the minimum covariance determinant estimator. Technometrics, 41(3):212–223, 1999.
from pyod.models.mcd import MCD

clf_name = 'MCD'
clf = MCD()
clf.fit(X_train)
MCD(assume_centered=False, contamination=0.1, random_state=None,
  store_precision=True, support_fraction=None)

訓練データの予測ラベルと外れ値スコアを取得します :

y_train_pred = clf.labels_  # binary labels (0: inliers, 1: outliers)
y_train_scores = clf.decision_scores_  # raw outlier scores
y_train_pred
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,
       1, 1])
y_train_scores[-40:]
array([4.24565000e+00, 4.22664796e-01, 2.20854837e+00, 3.19271455e+00,
       5.28318116e+00, 4.89035191e+00, 9.00245383e+00, 3.36891011e+00,
       6.41160123e+00, 3.70486129e+00, 8.97553458e-01, 3.23785753e+00,
       3.55922222e-01, 6.19169925e+00, 7.27336532e-01, 3.88522610e+00,
       1.08105367e+00, 1.42204980e+01, 6.55858782e-01, 1.46394676e+00,
       3.95907542e+00, 1.06528255e-01, 6.75944610e-01, 4.94017438e+00,
       5.62629894e+00, 8.14443303e+00, 1.92662344e+00, 7.81555289e+00,
       1.17055228e-01, 6.62232486e-01, 9.36051952e+01, 1.76344612e+02,
       1.03037866e+02, 2.51116697e+02, 1.79382377e+01, 2.37451925e+01,
       1.80881699e+02, 1.72118668e+02, 1.27494937e+02, 6.26970512e+01])

 

予測と評価

先に正解ラベルを確認しておきます :

y_test
array([0., array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

テストデータ上で予測を行ないます :

y_test_pred = clf.predict(X_test)  # outlier labels (0 or 1)
y_test_scores = clf.decision_function(X_test)  # outlier scores
y_test_pred
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
y_test_scores[-40:]
array([ 5.9045124 , -2.01938422, -0.04809363,  1.579808  ,  7.29815783,
        2.75891915, 10.63424239,  1.69629951,  8.35181013,  3.87787154,
       -1.22952342,  2.30787057, -1.92598485,  8.78137251, -1.42671526,
        2.98254633, -1.05400309, 16.91238411, -1.38842923, -1.34779231,
        3.67815253, -1.95072358, -1.54857191,  3.38326885,  8.77706568,
       12.33489833, -0.87534863,  8.73047852, -1.9340466 , -1.4348534 ,
       26.06172492, 25.58479044, 25.93969245, 25.377791  , 22.11729834,
       23.73896701, 25.48826792, 26.29453172, 25.55043239, 25.38483225])

ROC と Precision @ Rank n pyod.utils.data.evaluate_print() を使用して予測を評価します。

from pyod.utils.data import evaluate_print
# evaluate and print the results
print("\nOn Training Data:")
evaluate_print(clf_name, y_train, y_train_scores)
print("\nOn Test Data:")
evaluate_print(clf_name, y_test, y_test_scores)
On Training Data:
MCD ROC:0.9986, precision @ rank n:0.95

On Test Data:
MCD ROC:1.0, precision @ rank n:1.0

総ての examples に含まれる visualize 関数により可視化を生成します :

from pyod.utils.example import visualize
 
visualize(clf_name, X_train, y_train, X_test, y_test, y_train_pred,
          y_test_pred, show_figure=True, save_figure=False)

 

以上



PyOD 0.8 : Examples : One Class SVM

PyOD 0.8 : Examples : One Class SVM (解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/27/2021 (0.8.9)

* 本ページは、PyOD の以下のドキュメントとサンプルを参考にして作成しています:


* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

 

PyOD 0.8 : Examples : One Class SVM

完全なサンプル : examples/ocsvm_example.py

 

合成データの生成と可視化

pyod.utils.data.generate_data() でサンプルデータを生成します :

from pyod.utils.data import generate_data

contamination = 0.1  # percentage of outliers
n_train = 200  # number of training points
n_test = 100  # number of testing points

X_train, y_train, X_test, y_test = generate_data(
    n_train=n_train, n_test=n_test,
    n_features=2,
    contamination=contamination,
    random_state=42
)

X_train, y_train の shape と値を確認します :

print(X_train.shape)
print(y_train.shape)
(200, 2)
(200,)
X_train[:10]
array([[6.43365854, 5.5091683 ],
       [5.04469788, 7.70806466],
       [5.92453568, 5.25921966],
       [5.29399075, 5.67126197],
       [5.61509076, 6.1309285 ],
       [6.18590347, 6.09410578],
       [7.16630941, 7.22719133],
       [4.05470826, 6.48127032],
       [5.79978164, 5.86930893],
       [4.82256361, 7.18593123]])
y_train[:200]
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1.,
       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

X_train の分布を可視化します :

import matplotlib.pyplot as plt
 
plt.scatter(X_train[:, 0], X_train[:, 1])

訓練データを可視化します :

import seaborn as sns
sns.set_style("dark")

from mpl_toolkits.mplot3d import Axes3D

X0 = X_train[:, 0]
X1 = X_train[:, 1]
Y = y_train

fig = plt.figure()
ax = Axes3D(fig)

ax.set_title("synthesized data")
 
ax.set_xlabel("X0")
ax.set_ylabel("X1")
ax.set_zlabel("Y")
 
ax.plot(X0, X1, Y, marker="o",linestyle='None')

 

モデル訓練

pyod.models.ocsvm.OCSVM 検出器をインポートして初期化し、そしてモデルを適合させます。

より多くの機能を持つ scikit-learn one-class SVM クラスのラッパーです。教師なし外れ値検知です。

高次元分布のサポートを推定します。実装は libsvm に基づいています。

参照 :

パラメータ

  • kernel (string, optional (default=’rbf’)) :
    アルゴリズムで使用されるカーネル・タイプを指定します。それは ‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’ の一つか callable でなければなりません。何も指定されない場合には、’rbf’ が使用されます。callable が与えられた場合にはカーネル行列を事前計算するために使用されます。
from pyod.models.ocsvm import OCSVM

clf_name = 'OneClassSVM'
clf = OCSVM()
clf.fit(X_train)
OCSVM(cache_size=200, coef0=0.0, contamination=0.1, degree=3, gamma='auto',
   kernel='rbf', max_iter=-1, nu=0.5, shrinking=True, tol=0.001,
   verbose=False)

訓練データの予測ラベルと外れ値スコアを得ます :

y_train_pred = clf.labels_  # binary labels (0: inliers, 1: outliers)
y_train_scores = clf.decision_scores_  # raw outlier scores
y_train_pred
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,
       1, 1])
y_train_scores[-40:]
array([-0.78857197,  1.82421735,  0.52516778,  1.36053899, 15.95268822,
        2.4715799 , -1.98421762,  4.78992561, -1.49198395, -1.6983532 ,
        1.03366291,  3.6321792 , -2.00333481,  0.1132708 ,  1.1528244 ,
        1.47166268, -0.72974317, -1.55079259, -1.2506018 ,  1.15327899,
       23.92572607, 24.79414184, 24.02938483, 23.69938998, 25.22054002,
       22.76152076, 24.99977021, 23.81604268, 25.31886731, 24.14355787,
       13.71471089, 24.11178588, 25.36021672, 25.26198196, 25.20689073,
       25.25618027, 25.36017907, 24.76715117, 21.52711931, 25.30266924])

 

予測と評価

先に正解ラベルを確認しておきます :

y_test
array([0., array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

テストデータ上で予測を行ないます :

y_test_pred = clf.predict(X_test)  # outlier labels (0 or 1)
y_test_scores = clf.decision_function(X_test)  # outlier scores
y_test_pred
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
y_test_scores[-40:]
array([ 5.9045124 , -2.01938422, -0.04809363,  1.579808  ,  7.29815783,
        2.75891915, 10.63424239,  1.69629951,  8.35181013,  3.87787154,
       -1.22952342,  2.30787057, -1.92598485,  8.78137251, -1.42671526,
        2.98254633, -1.05400309, 16.91238411, -1.38842923, -1.34779231,
        3.67815253, -1.95072358, -1.54857191,  3.38326885,  8.77706568,
       12.33489833, -0.87534863,  8.73047852, -1.9340466 , -1.4348534 ,
       26.06172492, 25.58479044, 25.93969245, 25.377791  , 22.11729834,
       23.73896701, 25.48826792, 26.29453172, 25.55043239, 25.38483225])

ROC と Precision @ Rank n pyod.utils.data.evaluate_print() を使用して予測を評価します。

from pyod.utils.data import evaluate_print
# evaluate and print the results
print("\nOn Training Data:")
evaluate_print(clf_name, y_train, y_train_scores)
print("\nOn Test Data:")
evaluate_print(clf_name, y_test, y_test_scores)
On Training Data:
OneClassSVM ROC:0.9992, precision @ rank n:0.95

On Test Data:
OneClassSVM ROC:1.0, precision @ rank n:1.0

総ての examples に含まれる visualize 関数により可視化を生成します :

from pyod.utils.example import visualize
 
visualize(clf_name, X_train, y_train, X_test, y_test, y_train_pred,
          y_test_pred, show_figure=True, save_figure=False)

 

以上



PyOD 0.8 : Examples : 主成分分析 (PCA)

PyOD 0.8 : Examples : 主成分分析 (PCA) (解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/27/2021 (0.8.9)

* 本ページは、PyOD の以下のドキュメントとサンプルを参考にして作成しています:


* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

 

PyOD 0.8 : Examples : 主成分分析 (PCA)

完全なサンプル : examples/pca_example.py

 

合成データの生成と可視化

pyod.utils.data.generate_data() でサンプルデータを生成します :

from pyod.utils.data import generate_data

contamination = 0.1  # percentage of outliers
n_train = 200  # number of training points
n_test = 100  # number of testing points

X_train, y_train, X_test, y_test = generate_data(
    n_train=n_train, n_test=n_test,
    contamination=contamination,
    random_state=42
)

※ ここでは特徴次元はデフォルトの 2 です。特徴次元 20 の場合についての試行は後述します。

X_train, y_train の shape と値を確認します :

print(X_train.shape)
print(y_train.shape)
(200, 2)
(200,)
X_train[:10]
array([[6.43365854, 5.5091683 ],
       [5.04469788, 7.70806466],
       [5.92453568, 5.25921966],
       [5.29399075, 5.67126197],
       [5.61509076, 6.1309285 ],
       [6.18590347, 6.09410578],
       [7.16630941, 7.22719133],
       [4.05470826, 6.48127032],
       [5.79978164, 5.86930893],
       [4.82256361, 7.18593123]])
y_train[:200]
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1.,
       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

X_train の分布を可視化します :

import matplotlib.pyplot as plt
 
plt.scatter(X_train[:, 0], X_train[:, 1])

訓練データを可視化します :

import seaborn as sns
sns.set_style("dark")

from mpl_toolkits.mplot3d import Axes3D

X0 = X_train[:, 0]
X1 = X_train[:, 1]
Y = y_train

fig = plt.figure()
ax = Axes3D(fig)

ax.set_title("synthesized data")
 
ax.set_xlabel("X0")
ax.set_ylabel("X1")
ax.set_zlabel("Y")
 
ax.plot(X0, X1, Y, marker="o",linestyle='None')

 

モデル訓練

pyod.models.pca.PCA 検出器をインポートして初期化し、そしてモデルを適合させます。

主成分分析 (PCA) は外れ値の検出で利用できます。PCA はデータの特異値分解を使用してそれを低い次元空間に射影する線形次元削減です。

この手続きでは、データの共分散行列を固有値に関連する固有ベクトルと呼ばれる直交ベクトルに分解できます。高い固有値を持つ固有ベクトルはデータの殆どの分散を捕捉します。

従って、k 個の固有ベクトルから構成される低次元超平面はデータの殆どの分散を捕捉できます。けれども、外れ値は通常のデータポイントとは異なります、これは小さい固有値を持つ固有ベクトルにより構築される超平面上でより明瞭です。

従って、外れ値スコアは総ての固有ベクトル上のサンプルの射影された距離の合計として得られます。

参照 :

  • Charu C Aggarwal. Outlier analysis. In Data mining, 75–79. Springer, 2015.
  • Mei-Ling Shyu, Shu-Ching Chen, Kanoksri Sarinnapakorn, and LiWu Chang. A novel anomaly detection scheme based on principal component classifier. Technical Report, MIAMI UNIV CORAL GABLES FL DEPT OF ELECTRICAL AND COMPUTER ENGINEERING, 2003.

Score(X) = 選択された固有ベクトルにより構築された超平面への各サンプル間の加重ユークリッド距離の合計

パラメータ

  • n_components (int, float, None or string) :
    保持するコンポーネント数。n_components が設定されない場合は総てのコンポーネントが保持されます :

    
    n_components == min(n_samples, n_features)
    

    if n_components == ‘mle’ and svd_solver == ‘full’, Minka’s MLE is used to guess the dimension if 0 < n_components < 1 and svd_solver == ‘full’, select the number of components such that the amount of variance that needs to be explained is greater than the percentage specified by n_components n_components cannot be equal to n_features for svd_solver == ‘arpack’.

from pyod.models.pca import PCA

# train PCA detector
clf_name = 'PCA'
clf = PCA(n_components=2)
clf.fit(X_train)
PCA(contamination=0.1, copy=True, iterated_power='auto', n_components=2,
  n_selected_components=None, random_state=None, standardization=True,
  svd_solver='auto', tol=0.0, weighted=True, whiten=False)

訓練データの予測ラベルと外れ値スコアを得ます :

y_train_pred = clf.labels_  # binary labels (0: inliers, 1: outliers)
y_train_scores = clf.decision_scores_  # raw outlier scores
y_train_pred
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,
       0, 1])
y_train_scores[-40:]
array([ 9.4994967 ,  3.94506562,  9.70037971,  7.10016104,  8.3342693 ,
        5.20726666,  8.11879309,  7.09219081,  5.44404213,  8.13218023,
        4.1753126 , 11.30291142,  7.36028157,  6.47889712,  7.32111209,
        4.12430086,  9.53767094,  6.33863943,  7.44694126, 10.67688223,
       25.72127613, 26.62078588, 27.79438442, 30.53234151, 14.3121138 ,
        7.91069136, 12.34639345, 31.09120751, 34.48202163, 23.1528089 ,
        4.1915978 , 26.00171686, 30.43968531, 26.19059534, 32.35826934,
       37.28140553, 20.85589507, 22.29007341,  6.49340959, 32.82450057])

 

予測と評価

先に正解ラベルを確認しておきます :

y_test
array([0., array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

テストデータ上で予測を行ないます :

y_test_pred = clf.predict(X_test)  # outlier labels (0 or 1)
y_test_scores = clf.decision_function(X_test)  # outlier scores
y_test_pred
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
       0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1])
y_test_scores[-40:]
array([ 6.69788191,  8.10098946,  8.67589057,  4.03525639,  8.5173794 ,
       10.96951547, 13.39103421,  8.18804283, 10.88109875,  5.59854489,
        7.53977442,  8.51968901,  8.38421841,  8.98014699,  8.94552673,
       11.34805156,  8.33270878,  5.0861882 ,  6.08032842,  9.06872924,
       11.39917594,  6.67302445,  8.90946919, 10.3204397 ,  7.93996933,
       12.09701831,  9.18744095, 12.94755026,  6.66488304,  8.06232909,
       16.92393289, 28.21976824, 18.02857594, 33.10880243,  7.56515099,
        8.78663414, 28.21833459, 26.55191181, 24.05195145, 15.23121808])

ROC と Precision @ Rank n pyod.utils.data.evaluate_print() を使用して予測を評価します。

from pyod.utils.data import evaluate_print
# evaluate and print the results
print("\nOn Training Data:")
evaluate_print(clf_name, y_train, y_train_scores)
print("\nOn Test Data:")
evaluate_print(clf_name, y_test, y_test_scores)
On Training Data:
PCA ROC:0.8964, precision @ rank n:0.8

On Test Data:
PCA ROC:0.9033, precision @ rank n:0.8

総ての examples に含まれる visualize 関数により可視化を生成します :

from pyod.utils.example import visualize
 
visualize(clf_name, X_train, y_train, X_test, y_test, y_train_pred,
          y_test_pred, show_figure=True, save_figure=False)

 

特徴次元 20 の場合

from pyod.utils.data import generate_data

contamination = 0.1  # percentage of outliers
n_train = 200  # number of training points
n_test = 100  # number of testing points

X_train, y_train, X_test, y_test = generate_data(
    n_train=n_train, n_test=n_test,
    n_features=20,
    contamination=contamination,
    random_state=42
)
print(X_train.shape)
print(y_train.shape)
(200, 20)
(200,)
from pyod.models.pca import PCA

# train PCA detector
clf_name = 'PCA'
clf = PCA(n_components=3)
clf.fit(X_train)
PCA(contamination=0.1, copy=True, iterated_power='auto', n_components=3,
  n_selected_components=None, random_state=None, standardization=True,
  svd_solver='auto', tol=0.0, weighted=True, whiten=False)
y_train_pred = clf.labels_  # binary labels (0: inliers, 1: outliers)
y_train_scores = clf.decision_scores_  # raw outlier scores
y_test_pred = clf.predict(X_test)  # outlier labels (0 or 1)
y_test_scores = clf.decision_function(X_test)  # outlier scores
from pyod.utils.data import evaluate_print
# evaluate and print the results
print("\nOn Training Data:")
evaluate_print(clf_name, y_train, y_train_scores)
print("\nOn Test Data:")
evaluate_print(clf_name, y_test, y_test_scores)
On Training Data:
PCA ROC:1.0, precision @ rank n:1.0

On Test Data:
PCA ROC:1.0, precision @ rank n:1.0
 

以上



PyOD 0.8 : Examples : k 近傍法 & マハラノビス距離

PyOD 0.8 : Examples : k 近傍法 & マハラノビス距離 (解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/26/2021 (0.8.9)

* 本ページは、PyOD の以下のドキュメントとサンプルを参考にして作成しています:


* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

 

PyOD 0.8 : Examples : k 近傍法 & マハラノビス距離

完全なサンプル : examples/knn_example.py

 

合成データの生成と可視化

pyod.utils.data.generate_data() でサンプルデータを生成します :

from pyod.utils.data import generate_data

contamination = 0.1  # percentage of outliers
n_train = 200  # number of training points
n_test = 100  # number of testing points

X_train, y_train, X_test, y_test = generate_data(
    n_train=n_train, n_test=n_test, contamination=contamination)

X_train, y_train の shape と値を確認します :

print(X_train.shape)
print(y_train.shape)
(200, 2)
(200,)
X_train[:10]
array([[3.08501648, 4.75998393],
       [4.13746077, 2.48731972],
       [3.79049305, 4.04812774],
       [3.96338469, 4.22143522],
       [4.2801191 , 3.74372575],
       [3.71259428, 3.50012167],
       [5.01925935, 3.85152323],
       [4.30397021, 4.26818773],
       [4.31568536, 3.33965944],
       [3.29025478, 4.32274734]])
y_train[:200]
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1.,
       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

X_train の分布を可視化します :

import matplotlib.pyplot as plt
 
plt.scatter(X_train[:, 0], X_train[:, 1])

訓練データを可視化します :

import seaborn as sns
sns.set_style("dark")

from mpl_toolkits.mplot3d import Axes3D

X0 = X_train[:, 0]
X1 = X_train[:, 1]
Y = y_train

fig = plt.figure()
ax = Axes3D(fig)

ax.set_title("synthesized data")
 
ax.set_xlabel("X0")
ax.set_ylabel("X1")
ax.set_zlabel("Y")
 
ax.plot(X0, X1, Y, marker="o",linestyle='None')

 

モデル訓練

pyod.models.knn.KNN 検出器をインポートして初期化し、そしてモデルを適合させます。

外れ値検知のための kNN クラス。観測について、その k-th 近傍への距離は外れ値スコアとして見なせるでしょう。それは密度を測定する方法としても見なせるでしょう。

参照 :

  • Fabrizio Angiulli and Clara Pizzuti. Fast outlier detection in high dimensional spaces. In European Conference on Principles of Data Mining and Knowledge Discovery, 15–27. Springer, 2002.
  • Sridhar Ramaswamy, Rajeev Rastogi, and Kyuseok Shim. Efficient algorithms for mining outliers from large data sets. In ACM Sigmod Record, volume 29, 427–438. ACM, 2000.

パラメータ

  • method (str, optional (default=’largest’)) – {‘largest’, ‘mean’, ‘median’}
    • largest : k-th 近傍への距離を外れ値スコアとして使用します。
    • mean : 総ての k 近傍への平均を外れ値スコアとして使用します。
    • median : k 近傍への距離の中央値を外れ値スコアとして使用します。

  • algorithm ({‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, optional) –
    近傍を計算するために使用されるアルゴリズム :
    • ’ball_tree’ は BallTree を使用します。
    • ’kd_tree’ は KDTree を使用します。
    • ’brute’ は brute-force 探索を使用します。
    • ’auto’ は fit() メソッドに渡される値を基に最も適切なアルゴリズムを決定することを試みます。

     
    Note: fitting on sparse input will override the setting of this parameter, using brute force.

    Deprecated since version 0.74: algorithm is deprecated in PyOD 0.7.4 and will not be possible in 0.7.6. It has to use BallTree for consistency.

  • metric (string or callable, default ‘minkowski’) –
    距離計算のために使用するメトリック。scikit-learn か scipy.spatial.distance からの任意のメトリックが使用できます。

  • metric_params (dict, optional (default = None)) –
    metric 関数のための追加のキーワード引数。
from pyod.models.knn import KNN   # kNN detector

# train kNN detector
clf_name = 'KNN'
clf = KNN()
clf.fit(X_train)
KNN(algorithm='auto', contamination=0.1, leaf_size=30, method='largest',
  metric='minkowski', metric_params=None, n_jobs=1, n_neighbors=5, p=2,
  radius=1.0)

訓練データの予測ラベルと外れ値スコアを得ます :

y_train_pred = clf.labels_  # binary labels (0: inliers, 1: outliers)
y_train_scores = clf.decision_scores_  # raw outlier scores
print(y_train_pred)
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
y_train_scores[-40:]
[0.15962472 0.26404758 0.13328626 0.27473931 0.23961003 0.21293019
 0.1147517  0.49774753 0.197176   0.06412986 0.19258264 0.24692469
 0.1676141  0.25805756 0.1975197  0.13500727 0.2091096  0.18331466
 0.25338522 0.23136406 2.38800616 1.9625473  2.10956911 1.8785871
 2.50824404 1.9625473  1.88282016 3.259813   3.05440905 3.36664091
 1.65463831 2.00754852 3.53083084 3.53970455 1.50144057 1.72388028
 2.54678179 3.11133259 2.19112764 1.8785871 ]

 

予測と評価

正解ラベルを確認しておきます :

y_test
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

テストデータ上の予測を行ないます :

y_test_pred = clf.predict(X_test)  # outlier labels (0 or 1)
y_test_scores = clf.decision_function(X_test)  # outlier scores
print(y_test.shape)
y_test_pred
(100,)
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1]
y_test_scores[-40:]
array([0.11599486, 0.1838938 , 0.22545484, 0.25303069, 0.19073255,
       0.16952675, 0.27454715, 0.12097446, 0.0909775 , 0.21331808,
       0.13385247, 0.25456906, 0.10869875, 0.13823526, 0.17606727,
       0.19224746, 0.16799589, 0.1532144 , 0.1298472 , 0.30639764,
       0.17532533, 0.22670677, 0.16088692, 0.36243913, 0.17956828,
       0.16300276, 0.08101652, 0.06396358, 0.15957843, 0.62192607,
       3.20652008, 1.97393657, 1.56580327, 1.81336178, 1.54919456,
       2.1308944 , 3.48636464, 2.24250892, 1.87019016, 4.78982494])

ROC と Precision @ Rank n pyod.utils.data.evaluate_print() を使用して予測を評価します。

from pyod.utils.data import evaluate_print
# evaluate and print the results
print("\nOn Training Data:")
evaluate_print(clf_name, y_train, y_train_scores)
print("\nOn Test Data:")
evaluate_print(clf_name, y_test, y_test_scores)
On Training Data:
KNN ROC:1.0, precision @ rank n:1.0

On Test Data:
KNN ROC:1.0, precision @ rank n:1.0

総ての examples に含まれる visualize 関数により可視化を生成します :

from pyod.utils.example import visualize
 
visualize(clf_name, X_train, y_train, X_test, y_test, y_train_pred,
          y_test_pred, show_figure=True, save_figure=False)

 

マハラノビス距離

完全なサンプル : examples/knn_mahalanobis_example.py

import numpy as np
from pyod.models.knn import KNN   # kNN detector

# mahalanobis 距離で kNN 検出器を訓練します。
clf_name = 'KNN (mahalanobis distance)'

# calculate covariance for mahalanobis distance
X_train_cov = np.cov(X_train, rowvar=False)
clf = KNN(algorithm='auto', metric='mahalanobis',
              metric_params={'V': X_train_cov})
clf.fit(X_train)
KNN(algorithm='auto', contamination=0.1, leaf_size=30, method='largest',
  metric='mahalanobis',
  metric_params={'V': array([[0.21822, 0.10856],
       [0.10856, 0.223  ]])},
  n_jobs=1, n_neighbors=5, p=2, radius=1.0)

訓練データの予測ラベルと外れ値スコアを得ます :

y_train_pred = clf.labels_  # binary labels (0: inliers, 1: outliers)
y_train_scores = clf.decision_scores_  # raw outlier scores
print(y_train_pred)
[0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1
 1 1 0 1 1 0 1 1 1 1 1 1 1 0 1]
y_train_scores[-40:]
array([0.58912848, 0.22380705, 0.27005879, 0.41356956, 0.23698991,
       0.26675444, 0.27765579, 0.24205096, 0.15355571, 0.27200349,
       0.26733088, 0.482192  , 0.33874355, 0.25996079, 0.24774249,
       0.1813697 , 0.1223033 , 0.27511716, 0.24852299, 0.20297293,
       1.55753928, 0.80804895, 0.75640102, 1.68413991, 1.63928778,
       1.52363689, 1.4012431 , 0.39888351, 1.36453714, 1.83193458,
       0.66176039, 1.1324612 , 1.33748243, 1.78087079, 1.07614616,
       1.3230474 , 1.37426469, 2.69424388, 0.22668787, 1.22162625])

正解ラベルを確認しておきます :

y_test
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

テストデータ上の予測を行ないます :

y_test_pred = clf.predict(X_test)  # outlier labels (0 or 1)
y_test_scores = clf.decision_function(X_test)  # outlier scores
print(y_test.shape)
y_test_pred
(100,)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1])
y_test_scores[-40:]
array([0.21432376, 0.33171001, 0.26295913, 0.18968928, 0.22568313,
       0.43079372, 0.43806264, 0.23698662, 0.56936528, 0.18924124,
       0.20143916, 0.13164876, 0.19035343, 0.28210869, 0.28090227,
       0.32447241, 0.27397147, 0.34668418, 0.29735364, 0.40047555,
       0.7764035 , 0.17145197, 0.38620828, 0.23455709, 0.17468498,
       0.20520947, 0.27625286, 0.18357644, 0.26571843, 0.20382472,
       0.73291695, 1.48326151, 1.04781778, 1.58587852, 1.25507347,
       1.65691819, 0.8926622 , 0.68944944, 1.6565503 , 0.96213366])

ROC と Precision @ Rank n pyod.utils.data.evaluate_print() を使用して予測を評価します。

from pyod.utils.data import evaluate_print
# evaluate and print the results
print("\nOn Training Data:")
evaluate_print(clf_name, y_train, y_train_scores)
print("\nOn Test Data:")
evaluate_print(clf_name, y_test, y_test_scores)
On Training Data:
KNN (mahalanobis distance) ROC:0.9594, precision @ rank n:0.85

On Test Data:
KNN (mahalanobis distance) ROC:0.9889, precision @ rank n:0.8

総ての examples に含まれる visualize 関数により可視化を生成します :

from pyod.utils.example import visualize
 
visualize(clf_name, X_train, y_train, X_test, y_test, y_train_pred,
          y_test_pred, show_figure=True, save_figure=False)

 

以上



PyOD 0.8 : 外れ値検知 101

PyOD 0.8 : 外れ値検知 101 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/26/2021 (0.8.9)

* 本ページは、PyOD の以下のドキュメントの一部を翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

PyOD 0.8 : 外れ値検知 101

外れ値検知はサンプルの分布が与えられたとき異常であると考えられるかもしれない観測を識別するタスクとして広く参照されます。分布に属する任意の観測は inlier として参照され、任意の中心から離れた (= outlying) ポイントは外れ値として参照されます。

機械学習のコンテキストでは、このタスクのために 3 つの一般的なアプローチがあります :

 

1. 教師なし外れ値検知

  • (ラベル付けされていない) 訓練データは正常と異常な観測の両者を含みます。
  • モデルは fitting プロセスの間に外れ値を識別します
  • このアプローチは、外れ値がデータの低密度領域に存在するポイントとして定義されるとき に取られます。
  • 高密度領域に属さない任意の新しい観測は外れ値と考えられます。

 

2. 半教師あり Novelty (= 新規性) 検知

  • 訓練データは正常な動作を記述する観測だけから成ります。
  • モデルは訓練データ上で fit されてから新しい観測を評価するために使用されます。
  • このアプローチは、外れ値が訓練データの分布とは異なるポイントとして定義されるとき に取られます。
  • 閾値内の訓練データとは異なる任意の新しい観測は、それらが高密度領域を形成する場合でさえも、外れ値として考えられます。

 

3. 教師あり外れ値分類

  • 総ての観測のための正解ラベル (inlier vs 外れ値) は既知です。
  • モデルは不均衡な訓練データ上で fit されてから新しい観測を分類するために使用されます。
  • このアプローチは正解が利用可能であるときに取られてそして外れ値が訓練セットと同じ分布に従うことを仮定しています。
  • 任意の新しい観測はモデルを使用して分類されます。

PyOD で見つかるアルゴリズムは最初の 2 つのアプローチにフォーカスしています、これらは訓練データがどのように定義されるか、そしてモデル出力がどのように解釈されるかという点で異なります。更に学習することに関心があれば、関連する書籍、論文、動画とツールボックスのための Anomaly Detection Resources ページを参照してください。

 

以上



ClassCat® Chatbot

人工知能開発支援
クラスキャットは 人工知能研究開発支援 サービスを提供しています :
  • テクニカルコンサルティングサービス
  • 実証実験 (プロトタイプ構築)
  • アプリケーションへの実装
  • 人工知能研修サービス
◆ お問合せ先 ◆
クラスキャット
セールス・インフォメーション
E-Mail:sales-info@classcat.com