diff --git a/.doctrees/_notebooks/Basic_usage.doctree b/.doctrees/_notebooks/Basic_usage.doctree index 6a6158d..3c5e753 100644 Binary files a/.doctrees/_notebooks/Basic_usage.doctree and b/.doctrees/_notebooks/Basic_usage.doctree differ diff --git a/.doctrees/_notebooks/Tutorial.doctree b/.doctrees/_notebooks/Tutorial.doctree index 39e58f7..547e02d 100644 Binary files a/.doctrees/_notebooks/Tutorial.doctree and b/.doctrees/_notebooks/Tutorial.doctree differ diff --git a/.doctrees/_notebooks/Using_redflag_with_Pandas.doctree b/.doctrees/_notebooks/Using_redflag_with_Pandas.doctree index c134810..cb80080 100644 Binary files a/.doctrees/_notebooks/Using_redflag_with_Pandas.doctree and b/.doctrees/_notebooks/Using_redflag_with_Pandas.doctree differ diff --git a/.doctrees/_notebooks/Using_redflag_with_sklearn.doctree b/.doctrees/_notebooks/Using_redflag_with_sklearn.doctree index 347d3ed..8db6715 100644 Binary files a/.doctrees/_notebooks/Using_redflag_with_sklearn.doctree and b/.doctrees/_notebooks/Using_redflag_with_sklearn.doctree differ diff --git a/.doctrees/changelog.doctree b/.doctrees/changelog.doctree index 1a2edd0..673bc76 100644 Binary files a/.doctrees/changelog.doctree and b/.doctrees/changelog.doctree differ diff --git a/.doctrees/environment.pickle b/.doctrees/environment.pickle index 3e4bdc2..7ae4339 100644 Binary files a/.doctrees/environment.pickle and b/.doctrees/environment.pickle differ diff --git a/.doctrees/redflag.doctree b/.doctrees/redflag.doctree index 63248d3..74d119a 100644 Binary files a/.doctrees/redflag.doctree and b/.doctrees/redflag.doctree differ diff --git a/_images/c0c1962d29e7e150fc708abea8ff668162e08bc30868c49f83ff65489ab29050.png b/_images/c0c1962d29e7e150fc708abea8ff668162e08bc30868c49f83ff65489ab29050.png new file mode 100644 index 0000000..6a31b82 Binary files /dev/null and b/_images/c0c1962d29e7e150fc708abea8ff668162e08bc30868c49f83ff65489ab29050.png differ diff --git a/_images/d7c8d901883c9d1b74e19dacf493c347184637b9408d881e681ee912d6ba0c17.png b/_images/d7c8d901883c9d1b74e19dacf493c347184637b9408d881e681ee912d6ba0c17.png deleted file mode 100644 index de5f7cc..0000000 Binary files a/_images/d7c8d901883c9d1b74e19dacf493c347184637b9408d881e681ee912d6ba0c17.png and /dev/null differ diff --git a/_notebooks/Basic_usage.html b/_notebooks/Basic_usage.html index 3e0580c..459b03d 100644 --- a/_notebooks/Basic_usage.html +++ b/_notebooks/Basic_usage.html @@ -241,7 +241,7 @@
'0.1.dev1+g96ac82d'
+'0.4.0rc1'
<matplotlib.lines.Line2D at 0x7f17ca3f72d0>
+<matplotlib.lines.Line2D at 0x7f8ac0583310>
@@ -630,7 +630,7 @@ Outliers<seaborn.axisgrid.JointGrid at 0x7f17c843d710>
+<seaborn.axisgrid.JointGrid at 0x7f8a8d0d0090>
@@ -689,10 +689,10 @@ Outliers<seaborn.axisgrid.FacetGrid at 0x7f17c838ccd0>
+<seaborn.axisgrid.FacetGrid at 0x7f8a8cfb2e10>
-
+
This truncated normal distribution has no outliers (there are only about 60, compared to the 100 we expect at this confidence level of 99% on this dataset of 10,000 records).
@@ -737,7 +737,7 @@ Clipping<seaborn.axisgrid.FacetGrid at 0x7f17c81c3290>
+<seaborn.axisgrid.FacetGrid at 0x7f8a8d0df310>
@@ -782,7 +782,7 @@ Distribution shape
-Distribution(name='gumbel_r', shape=[], loc=10.040572536302586, scale=4.93432972751726)
+Distribution(name='gumbel_r', shape=[], loc=10.04057253630259, scale=4.93432972751726)
@@ -798,7 +798,7 @@ Distribution shape<seaborn.axisgrid.FacetGrid at 0x7f17c8141590>
+<seaborn.axisgrid.FacetGrid at 0x7f8a8cef7310>
@@ -947,7 +947,7 @@ Feature importance
-array([0.25782719, 0.40422669, 0.272979 , 0.04737446, 0. ])
+array([0.33755287, 0.24960534, 0.36065005, 0.05219174, 0. ])
@@ -974,7 +974,7 @@ Feature importance
-array([1, 2, 0])
+array([2, 0, 1])
@@ -992,7 +992,7 @@ Feature importance
-array([0.08662648, 0.35988089, 0.52122602, 0.03226661, 0. ])
+array([0.0949929 , 0.36926528, 0.51007619, 0.02566563, 0. ])
diff --git a/_notebooks/Tutorial.html b/_notebooks/Tutorial.html
index 67c480a..9a10966 100644
--- a/_notebooks/Tutorial.html
+++ b/_notebooks/Tutorial.html
@@ -292,7 +292,7 @@ A simple ML workflow
-array(['ss', 'ss'], dtype='<U2')
+array(['ms', 'ss'], dtype='<U2')
@@ -318,7 +318,7 @@ A quick look at
-'0.1.dev1+g96ac82d'
+'0.4.0rc1'
@@ -570,7 +570,7 @@ Clipping<seaborn.axisgrid.FacetGrid at 0x7f3a5e8bfa10>
+<seaborn.axisgrid.FacetGrid at 0x7f8051160c10>
@@ -623,7 +623,7 @@ Importance
-array([0.42306126, 0.19836246, 0.31959992, 0.05832766])
+array([0.42250322, 0.16792185, 0.31437961, 0.09519533])
@@ -660,16 +660,18 @@ PipelinesPipeline(steps=[('rf.imbalance', ImbalanceDetector()),
('rf.clip', ClipDetector()),
('rf.correlation', CorrelationDetector()),
+ ('rf.multimodality', MultimodalityDetector()),
('rf.outlier', OutlierDetector()),
('rf.distributions', DistributionComparator()),
('rf.importance', ImportanceDetector()),
('rf.dummy', DummyPredictor())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),
('rf.clip', ClipDetector()),
('rf.correlation', CorrelationDetector()),
+ ('rf.multimodality', MultimodalityDetector()),
('rf.outlier', OutlierDetector()),
('rf.distributions', DistributionComparator()),
('rf.importance', ImportanceDetector()),
- ('rf.dummy', DummyPredictor())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
OutlierDetector()
DistributionComparator()
ImportanceDetector()
DummyPredictor()
+ ('rf.dummy', DummyPredictor())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
MultimodalityDetector()
OutlierDetector()
DistributionComparator()
ImportanceDetector()
DummyPredictor()
We can include this in other pipelines:
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
MultimodalityDetector()
OutlierDetector()
DistributionComparator()
ImportanceDetector()
DummyPredictor()
SVC()
🚩 There are more outliers than expected in the training data (316 vs 31).
🚩 Feature 3 has low importance; check for relevance.
-ℹ️ Dummy classifier scores: {'f1': 0.25488459423559595, 'roc_auc': 0.5} (most_frequent strategy).
+ℹ️ Dummy classifier scores: {'f1': 0.26324448737561057, 'roc_auc': 0.5009389627941475} (stratified strategy).
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
MultimodalityDetector()
OutlierDetector(threshold=3.643721188696941)
DistributionComparator()
ImportanceDetector()
DummyPredictor()
SVC()
🚩 There are more outliers than expected in the data (26 vs 8).
+🚩 Feature 0 has samples that may be clipped.
+🚩 Features 0, 1, 2 have samples that may be correlated.
+🚩 There are more outliers than expected in the data (26 vs 8).
🚩 Feature 2 has a distribution that is different from training.
@@ -960,13 +972,13 @@ Making your own tests
Pipeline(steps=[('detector', - Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f3a5c794f40>, - warning='are negative')), - ('svc', SVC())])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
Pipeline(steps=[('detector', - Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f3a5c794f40>, - warning='are negative')), - ('svc', SVC())])
Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f3a5c794f40>, - warning='are negative')
SVC()
Pipeline(steps=[('detector', + Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f8050fff920>, + message='are negative')), + ('svc', SVC())])
Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f8050fff920>, + message='are negative')
SVC()
The noise feature we added has negative values; the others are all positive, which is what we expect for these data.
(Careful! All standardized features will have negative values.)
diff --git a/_notebooks/Using_redflag_with_Pandas.html b/_notebooks/Using_redflag_with_Pandas.html index a96b665..1056253 100644 --- a/_notebooks/Using_redflag_with_Pandas.html +++ b/_notebooks/Using_redflag_with_Pandas.html @@ -234,7 +234,7 @@redf
-'0.1.dev1+g96ac82d'
+'0.4.0rc1'
@@ -428,8 +428,8 @@ 🚩 Using redf
-{'f1': 0.2346177681289338,
- 'roc_auc': 0.500927788909045,
+{'f1': 0.25070659735756834,
+ 'roc_auc': 0.5002038872861748,
'strategy': 'stratified',
'task': 'classification'}
@@ -461,9 +461,9 @@ 🚩 Using redf
Continuous data suitable for regression
-Outliers: [ 34 35 140 141 142 143 175 532 575 581 583 633 662 757
- 768 769 801 1316 1498 1547 1744 1754 1756 1778 1779 1780 1784 1785
- 1788 1808 1812 2884 2932 2973 2974 3004 3087 3094 3100 3109]
+Outliers: [ 34 35 140 141 142 143 175 532 575 581 583 633 662 768
+ 769 773 801 1316 1498 1547 1744 1754 1756 1778 1779 1780 1784 1788
+ 1808 1812 2884 2932 2973 2974 3004 3087 3100 3109]
Correlated: True
Dummy scores:{'mean': {'mean_squared_error': 47528.78263092096, 'r2': 0.0}}
diff --git a/_notebooks/Using_redflag_with_sklearn.html b/_notebooks/Using_redflag_with_sklearn.html
index 58f24bf..00a2cf2 100644
--- a/_notebooks/Using_redflag_with_sklearn.html
+++ b/_notebooks/Using_redflag_with_sklearn.html
@@ -496,16 +496,18 @@ Using the pre-built Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),
('rf.clip', ClipDetector()),
('rf.correlation', CorrelationDetector()),
+ ('rf.multimodality', MultimodalityDetector()),
('rf.outlier', OutlierDetector()),
('rf.distributions', DistributionComparator()),
('rf.importance', ImportanceDetector()),
('rf.dummy', DummyPredictor())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),
('rf.clip', ClipDetector()),
('rf.correlation', CorrelationDetector()),
+ ('rf.multimodality', MultimodalityDetector()),
('rf.outlier', OutlierDetector()),
('rf.distributions', DistributionComparator()),
('rf.importance', ImportanceDetector()),
- ('rf.dummy', DummyPredictor())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
OutlierDetector()
DistributionComparator()
ImportanceDetector()
DummyPredictor()
+ ('rf.dummy', DummyPredictor())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
MultimodalityDetector()
OutlierDetector()
DistributionComparator()
ImportanceDetector()
DummyPredictor()
We can use this in another pipeline:
@@ -525,26 +527,29 @@ Using the pre-built Pipeline(steps=[('standardscaler', StandardScaler()),
+ ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('standardscaler', StandardScaler()),
('pipeline',
Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),
('rf.clip', ClipDetector()),
('rf.correlation', CorrelationDetector()),
+ ('rf.multimodality', MultimodalityDetector()),
('rf.outlier', OutlierDetector()),
('rf.distributions', DistributionComparator()),
('rf.importance', ImportanceDetector()),
('rf.dummy', DummyPredictor())])),
- ('svc', SVC())])
StandardScaler()
Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),
+ ('svc', SVC())])
StandardScaler()
Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),
('rf.clip', ClipDetector()),
('rf.correlation', CorrelationDetector()),
+ ('rf.multimodality', MultimodalityDetector()),
('rf.outlier', OutlierDetector()),
('rf.distributions', DistributionComparator()),
('rf.importance', ImportanceDetector()),
- ('rf.dummy', DummyPredictor())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
OutlierDetector()
DistributionComparator()
ImportanceDetector()
DummyPredictor()
SVC()
+ ('rf.dummy', DummyPredictor())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
MultimodalityDetector()
OutlierDetector()
DistributionComparator()
ImportanceDetector()
DummyPredictor()
SVC()
During the fit
phase, the redflag
transformers do three things:
@@ -562,12 +567,14 @@ Using the pre-built 🚩 The labels are imbalanced by more than the threshold (0.420 > 0.400). See self.minority_classes_ for the minority classes.
🚩 Features 0, 1 have samples that may be clipped.
🚩 Features 0, 1, 2 have samples that may be correlated.
+🚩 Feature 0 has a multimodal distribution.
+ℹ️ Multimodality detection may not have succeeded for all groups in all features.
🚩 There are more outliers than expected in the training data (349 vs 31).
-ℹ️ Dummy classifier scores: {'f1': 0.2640911585691975, 'roc_auc': 0.5031327741701236} (stratified strategy).
+ℹ️ Dummy classifier scores: {'f1': 0.26659405913468076, 'roc_auc': 0.4986750319488202} (stratified strategy).
Pipeline(steps=[('standardscaler', StandardScaler()),
@@ -575,28 +582,31 @@ Using the pre-built Pipeline(steps=[('standardscaler', StandardScaler()),
+ ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('standardscaler', StandardScaler()),
('pipeline',
Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),
('rf.clip', ClipDetector()),
('rf.correlation', CorrelationDetector()),
+ ('rf.multimodality', MultimodalityDetector()),
('rf.outlier',
OutlierDetector(threshold=3.3682141715600706)),
('rf.distributions', DistributionComparator()),
('rf.importance', ImportanceDetector()),
('rf.dummy', DummyPredictor())])),
- ('svc', SVC())])
StandardScaler()
Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),
+ ('svc', SVC())])
StandardScaler()
Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),
('rf.clip', ClipDetector()),
('rf.correlation', CorrelationDetector()),
+ ('rf.multimodality', MultimodalityDetector()),
('rf.outlier', OutlierDetector(threshold=3.3682141715600706)),
('rf.distributions', DistributionComparator()),
('rf.importance', ImportanceDetector()),
- ('rf.dummy', DummyPredictor())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
OutlierDetector(threshold=3.3682141715600706)
DistributionComparator()
ImportanceDetector()
DummyPredictor()
SVC()
+ ('rf.dummy', DummyPredictor())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
MultimodalityDetector()
OutlierDetector(threshold=3.3682141715600706)
DistributionComparator()
ImportanceDetector()
DummyPredictor()
SVC()
When we pass in data for prediction, redflag
checks the new inputs. There are two categories of check:
@@ -611,7 +621,9 @@ Using the pre-built
-🚩 There are more outliers than expected in the data (30 vs 8).
+🚩 Feature 0 has samples that may be clipped.
+🚩 Features 0, 1, 2 have samples that may be correlated.
+🚩 There are more outliers than expected in the data (30 vs 8).
🚩 Feature 2 has a distribution that is different from training.
@@ -683,14 +695,14 @@ Using the ‘detector’ transformersPipeline(steps=[('standardscaler', StandardScaler()),
+ ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('standardscaler', StandardScaler()),
('imbalancedetector', ImbalanceDetector(threshold=0.5)),
('clipdetector', ClipDetector()),
('outlierdetector',
OutlierDetector(p=0.8, threshold=2.154443705823081)),
('distributioncomparator',
DistributionComparator(threshold=0.25)),
- ('svc', SVC())])
StandardScaler()
ImbalanceDetector(threshold=0.5)
ClipDetector()
OutlierDetector(p=0.8, threshold=2.154443705823081)
DistributionComparator(threshold=0.25)
SVC()
+ ('svc', SVC())])
StandardScaler()
ImbalanceDetector(threshold=0.5)
ClipDetector()
OutlierDetector(p=0.8, threshold=2.154443705823081)
DistributionComparator(threshold=0.25)
SVC()
The test dataset does not trigger the higher threshold for outliers. But with the new lower Wasserstein threshold, the distribution comparison fails for all of the features:
@@ -720,7 +732,7 @@ The imbalance comparator
-RfPipeline(steps=[('imbalancecomparator', ImbalanceComparator())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.RfPipeline(steps=[('imbalancecomparator', ImbalanceComparator())])
ImbalanceComparator()
+RfPipeline(steps=[('imbalancecomparator', ImbalanceComparator())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.RfPipeline(steps=[('imbalancecomparator', ImbalanceComparator())])
ImbalanceComparator()
But during transformation (therefore during prediction or other inference phases), it checks the imbalance is the same:
@@ -731,7 +743,7 @@ The imbalance comparator
🚩 There is a different number of minority classes (2) compared to the training data (4).
-🚩 The minority classes (sandstone, dolomite) are different from those in the training data (sandstone, wackestone, mudstone, dolomite).
+🚩 The minority classes (dolomite, sandstone) are different from those in the training data (sandstone, dolomite, mudstone, wackestone).
array([[ 66.276 , 2359.73324716, 3.591 ],
@@ -767,13 +779,13 @@ Making your own smoke detector
Pipeline(steps=[('detector',
- Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fb633d271a0>,
- warning='are NaNs')),
- ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('detector',
- Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fb633d271a0>,
- warning='are NaNs')),
- ('svc', SVC())])
Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fb633d271a0>,
- warning='are NaNs')
SVC()
+ Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fa95585ff60>,
+ message='are NaNs')),
+ ('svc', SVC())])In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('detector',
+ Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fa95585ff60>,
+ message='are NaNs')),
+ ('svc', SVC())])
Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fa95585ff60>,
+ message='are NaNs')
SVC()
There are no NaNs.
You can use make_detector_pipeline
to combine several tests into a single pipeline.
@@ -799,31 +811,31 @@ Making your own smoke detectorPipeline(steps=[('standardscaler', StandardScaler()),
('pipeline',
Pipeline(steps=[('detector-1',
- Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fb633d26160>,
- warning='fail custom func '
+ Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fa95585f240>,
+ message='fail custom func '
'has_nans()')),
('detector-2',
- Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fb633d26de0>,
- warning='fail custom func '
+ Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fa95585f420>,
+ message='fail custom func '
'has_outliers()'))])),
- ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('standardscaler', StandardScaler()),
+ ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('standardscaler', StandardScaler()),
('pipeline',
Pipeline(steps=[('detector-1',
- Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fb633d26160>,
- warning='fail custom func '
+ Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fa95585f240>,
+ message='fail custom func '
'has_nans()')),
('detector-2',
- Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fb633d26de0>,
- warning='fail custom func '
+ Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fa95585f420>,
+ message='fail custom func '
'has_outliers()'))])),
- ('svc', SVC())])
StandardScaler()
Pipeline(steps=[('detector-1',
- Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fb633d26160>,
- warning='fail custom func has_nans()')),
+ ('svc', SVC())])
StandardScaler()
Pipeline(steps=[('detector-1',
+ Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fa95585f240>,
+ message='fail custom func has_nans()')),
('detector-2',
- Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fb633d26de0>,
- warning='fail custom func has_outliers()'))])
Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fb633d26160>,
- warning='fail custom func has_nans()')
Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fb633d26de0>,
- warning='fail custom func has_outliers()')
SVC()
+ Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fa95585f420>,
+ message='fail custom func has_outliers()'))])Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fa95585f240>,
+ message='fail custom func has_nans()')
Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7fa95585f420>,
+ message='fail custom func has_outliers()')
SVC()
diff --git a/_sources/_notebooks/Basic_usage.ipynb.txt b/_sources/_notebooks/Basic_usage.ipynb.txt
index 2299851..cd3026c 100644
--- a/_sources/_notebooks/Basic_usage.ipynb.txt
+++ b/_sources/_notebooks/Basic_usage.ipynb.txt
@@ -1 +1 @@
-{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# \ud83d\udea9 Basic usage\n", "\n", "**Welcome to `redflag`.** It's still early days for this library, but there are a few things you can do:\n", "\n", "- Outlier detection\n", "- Clipping detection\n", "- Imbalance metrics (for labels and any other categorical variables)\n", "- Distribution shape\n", "- Identical distribution assumption\n", "- Independence assumption\n", "- Feature importance metrics"]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/plain": ["'0.1.11.dev54+gf3190f3.d20230904'"]}, "execution_count": 1, "metadata": {}, "output_type": "execute_result"}], "source": ["import redflag as rf\n", "\n", "rf.__version__"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Load some data"]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [{"data": {"text/html": ["\n", "\n", "\n", " \n", " \n", " \n", " count \n", " mean \n", " std \n", " min \n", " 25% \n", " 50% \n", " 75% \n", " max \n", " \n", " \n", " \n", " \n", " Depth \n", " 3966.0 \n", " 882.674555 \n", " 40.150056 \n", " 784.402800 \n", " 858.012000 \n", " 888.339600 \n", " 913.028400 \n", " 963.320400 \n", " \n", " \n", " RelPos \n", " 3966.0 \n", " 0.524999 \n", " 0.286375 \n", " 0.010000 \n", " 0.282000 \n", " 0.531000 \n", " 0.773000 \n", " 1.000000 \n", " \n", " \n", " Marine \n", " 3966.0 \n", " 1.325013 \n", " 0.589539 \n", " 0.000000 \n", " 1.000000 \n", " 1.000000 \n", " 2.000000 \n", " 2.000000 \n", " \n", " \n", " GR \n", " 3966.0 \n", " 64.367899 \n", " 28.414603 \n", " 12.036000 \n", " 45.311250 \n", " 64.840000 \n", " 78.809750 \n", " 200.000000 \n", " \n", " \n", " ILD \n", " 3966.0 \n", " 5.240308 \n", " 3.190416 \n", " 0.340408 \n", " 3.169567 \n", " 4.305266 \n", " 6.664234 \n", " 32.136605 \n", " \n", " \n", " DeltaPHI \n", " 3966.0 \n", " 3.469088 \n", " 4.922310 \n", " -21.832000 \n", " 1.000000 \n", " 3.292500 \n", " 6.124750 \n", " 18.600000 \n", " \n", " \n", " PHIND \n", " 3966.0 \n", " 13.008807 \n", " 6.936391 \n", " 0.550000 \n", " 8.196250 \n", " 11.781500 \n", " 16.050000 \n", " 52.369000 \n", " \n", " \n", " PE \n", " 3966.0 \n", " 3.686427 \n", " 0.815113 \n", " 0.200000 \n", " 3.123000 \n", " 3.514500 \n", " 4.241750 \n", " 8.094000 \n", " \n", " \n", " Facies \n", " 3966.0 \n", " 4.471004 \n", " 2.406180 \n", " 1.000000 \n", " 2.000000 \n", " 4.000000 \n", " 6.000000 \n", " 9.000000 \n", " \n", " \n", " LATITUDE \n", " 3966.0 \n", " 37.632575 \n", " 0.299398 \n", " 37.180732 \n", " 37.356426 \n", " 37.500380 \n", " 37.910583 \n", " 38.063373 \n", " \n", " \n", " LONGITUDE \n", " 3966.0 \n", " -101.294895 \n", " 0.230454 \n", " -101.646452 \n", " -101.389189 \n", " -101.325130 \n", " -101.106045 \n", " -100.987305 \n", " \n", " \n", " ILD_log10 \n", " 3966.0 \n", " 0.648860 \n", " 0.251542 \n", " -0.468000 \n", " 0.501000 \n", " 0.634000 \n", " 0.823750 \n", " 1.507000 \n", " \n", " \n", " RHOB \n", " 3966.0 \n", " 2288.861692 \n", " 218.038459 \n", " 1500.000000 \n", " 2201.007475 \n", " 2342.202051 \n", " 2434.166399 \n", " 2802.871147 \n", " \n", " \n", "
\n", ""], "text/plain": [" count mean std min 25% \\\n", "Depth 3966.0 882.674555 40.150056 784.402800 858.012000 \n", "RelPos 3966.0 0.524999 0.286375 0.010000 0.282000 \n", "Marine 3966.0 1.325013 0.589539 0.000000 1.000000 \n", "GR 3966.0 64.367899 28.414603 12.036000 45.311250 \n", "ILD 3966.0 5.240308 3.190416 0.340408 3.169567 \n", "DeltaPHI 3966.0 3.469088 4.922310 -21.832000 1.000000 \n", "PHIND 3966.0 13.008807 6.936391 0.550000 8.196250 \n", "PE 3966.0 3.686427 0.815113 0.200000 3.123000 \n", "Facies 3966.0 4.471004 2.406180 1.000000 2.000000 \n", "LATITUDE 3966.0 37.632575 0.299398 37.180732 37.356426 \n", "LONGITUDE 3966.0 -101.294895 0.230454 -101.646452 -101.389189 \n", "ILD_log10 3966.0 0.648860 0.251542 -0.468000 0.501000 \n", "RHOB 3966.0 2288.861692 218.038459 1500.000000 2201.007475 \n", "\n", " 50% 75% max \n", "Depth 888.339600 913.028400 963.320400 \n", "RelPos 0.531000 0.773000 1.000000 \n", "Marine 1.000000 2.000000 2.000000 \n", "GR 64.840000 78.809750 200.000000 \n", "ILD 4.305266 6.664234 32.136605 \n", "DeltaPHI 3.292500 6.124750 18.600000 \n", "PHIND 11.781500 16.050000 52.369000 \n", "PE 3.514500 4.241750 8.094000 \n", "Facies 4.000000 6.000000 9.000000 \n", "LATITUDE 37.500380 37.910583 38.063373 \n", "LONGITUDE -101.325130 -101.106045 -100.987305 \n", "ILD_log10 0.634000 0.823750 1.507000 \n", "RHOB 2342.202051 2434.166399 2802.871147 "]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}], "source": ["import pandas as pd\n", "\n", "df = pd.read_csv('https://geocomp.s3.amazonaws.com/data/Panoma_training_data.csv')\n", "\n", "# Look at the transposed summary: each column in the DataFrame is a row here.\n", "df.describe().T"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Categorical or continuous?"]}, {"cell_type": "markdown", "metadata": {}, "source": ["It's fairly easy to tell if a column is numeric or not, but harder to decide if it's continuous or categorical. We can use `is_continuous()` to check if a feature (or the target) is continuous. It uses heuristics and is definitely not foolproof. `redflag` uses it internally sometimes to decide how to treat a feature or target."]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": [" Well Name ... False\n", " Depth ... True\n", " Formation ... False\n", " RelPos ... True\n", " Marine ... False\n", " GR ... True\n", " ILD ... True\n", " DeltaPHI ... True\n", " PHIND ... True\n", " PE ... True\n", " Facies ... False\n", " LATITUDE ... True\n", " LONGITUDE ... False\n", " ILD_log10 ... True\n", " Lithology ... False\n", " RHOB ... True\n", " Mineralogy ... False\n", " Siliciclastic ... False\n"]}], "source": ["for col in df.columns:\n", " print(f\"{col:>20s} ... {rf.is_continuous(df[col])}\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["These are all correct."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Imbalance metrics\n", "\n", "First, we'll look at measuring imbalance in the target using `rf.class_imbalance()`. For binary targets, the metric is imbalace ratio (ratio between majority and minority class). For multiclass targets, the metric is imbalance degree [(Ortigosa-Hernandez et al, 2017)](https://doi.org/10.1016/j.patrec.2017.08.002), a single-value measure that explains (a) how many minority classes there are and (b) how skewed the supports are."]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [{"data": {"text/plain": ["3.378593040846633"]}, "execution_count": 4, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.imbalance_degree(df['Lithology'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["To interpret this number, split it into two parts:\n", "\n", "- The integer part, 3, is equal to $m - 1$, where $m$ is the number of minority classes.\n", "- The fractional part, 0.378..., is a measure of the amount of imbalance, where 0 means the dataset is balanced perfectly and 0.999... is really bad.\n", "\n", "If the imbalance degree is -1 then there are no minority classes and all the classes have equal support.\n", "\n", "In general, this statistic is more informative than the commonly used 'imbalance ratio' (`rf.imbalance_ratio()`), which is the ratio of support in the maximum majority class to that in the minimum minority class, with no regard for the support of the other classes."]}, {"cell_type": "markdown", "metadata": {}, "source": ["We can get the minority classes, which are those with fewer samples than expected. These are returned in order, smallest first:"]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [{"data": {"text/plain": ["array(['dolomite', 'sandstone', 'mudstone', 'wackestone'], dtype='"]}, "execution_count": 8, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["ax = df['Lithology'].value_counts().plot(kind='bar')\n", "\n", "# Add a line at the expectation level, which is the same for all classes.\n", "ax.axhline(e[0] * len(df), c='r')"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Outliers\n", "\n", "The `get_outliers()` function detects outliers, returning the indices of outlier points."]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([ 301, 302, 303, 415, 416, 417, 418, 799, 896, 897, 898,\n", " 899, 996, 997, 1843, 1844, 2278, 2279, 2280, 2638, 2639, 2640,\n", " 2641, 2642, 2643, 2920, 2921, 2922, 3070, 3071, 3074, 3075, 3076,\n", " 3079, 3080, 3081, 3580, 3581, 3582, 3583])"]}, "execution_count": 9, "metadata": {}, "output_type": "execute_result"}], "source": ["outliers = rf.get_outliers(df['GR'])\n", "outliers"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We can see where these lie in the distribution:"]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n"]}, {"data": {"text/plain": [""]}, "execution_count": 10, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["import seaborn as sns\n", "\n", "sns.kdeplot(df['GR'])\n", "sns.rugplot(df.loc[outliers, 'GR'], c='C1', lw=5, alpha=0.5)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["By default it uses an [**isolation forest**](https://scikit-learn.org/stable/modules/outlier_detection.html#isolation-forest) to detect the outliers at the 99% confidence level, but you can also opt to use **local outlier factor**, **elliptic envelope**, or **Mahalanobis distance**, setting the confidence level to choose how many outliers you will see, or (equivalently) setting the `threshold` to the number of standard deviations away from the mean you regard as signal.\n", "\n", "The function accepts univariate or multivariate data:"]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n"]}, {"data": {"text/plain": [""]}, "execution_count": 11, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["features = ['GR', 'PE']\n", "\n", "outliers = rf.get_outliers(df[features], method='mah', threshold=5)\n", "\n", "sns.jointplot(data=df, x='GR', y='PE', hue=rf.index_to_bool(outliers, n=len(df)))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["A helper function can compute the number of expected outliers, given the dataset size and assuming a Gaussian distribution of samples."]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["We have 80 outliers, but expect:\n"]}, {"data": {"text/plain": ["44"]}, "execution_count": 12, "metadata": {}, "output_type": "execute_result"}], "source": ["print(f\"We have {len(outliers)} outliers, but expect:\")\n", "rf.expected_outliers(*df[features].shape, threshold=3)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["So we have more than expected — because the distribution of GR has a lot of clipped samples at a value of 200. A dataset with truncated tails will have fewer than expected outliers; we can test this directly with the `has_outliers()` function, which compares the results of `expected_outliers()` with `get_outliers()`:"]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [{"data": {"text/plain": ["100"]}, "execution_count": 13, "metadata": {}, "output_type": "execute_result"}], "source": ["import numpy as np\n", "\n", "data = np.random.normal(size=10_000)\n", "\n", "rf.expected_outliers(len(data), d=1, p=0.99)"]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": ["# Truncate\n", "data = data[(-2.5 < data) & (data < 2.5)]"]}, {"cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", "The figure layout has changed to tight\n"]}, {"data": {"text/plain": [""]}, "execution_count": 15, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAHqCAYAAAAgWrY5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAkW0lEQVR4nO3df2yV5f3/8VcLtFDa01qkpy2/BBRLEWRDhKOOCNZWZCCh8auGYTUMXdMyoY5pNwTEOQxzxakFdMHishEYyVBkBIFSIBktYg2THxaEYeranpbJ2gNkPS2n5/vH1vPxCBzacjj31fb5SE7COfdVzvucqE/Pfd+9T5jX6/UKAAAYJ9zqAQAAwJURaQAADEWkAQAwFJEGAMBQRBoAAEMRaQAADEWkAQAwFJEGAMBQRFqS1+uVy+US13UBAJiESEs6f/68YmNjdf78eatHAQDAh0gDAGAoIg0AgKGINAAAhiLSAAAYikgDAGAoIg0AgKGINAAAhiLSAAAYikgDAGAoIg0AgKGINAAAhiLSAAAYikgDAGAoIg0AgKGINAAAhiLSAAAYikgDAGAoIg0AgKGINAAAhiLSAAAYqqfVAwDoWoaPSFFNddU11yUlD9DpkxUhmAjovIg0gKCqqa7SjIKd11y3NS89BNMAnRu7uwEAMBSRBgDAUEQaAABDEWkAAAxFpAEAMBSRBgDAUEQaAABDEWkAAAxFpAEAMBSRBgDAUEQaAABDEWkAAAxFpAEAMBSRBgDAUEQaAABDEWkAAAxFpAEAMBSRBgDAUJZGetmyZQoLC/O7paSk+LY3NjYqJydH/fr1U3R0tDIzM1VbW+v3d1RWVmratGmKiopSQkKCFi1apEuXLoX6pQAAEHQ9rR5g1KhR2r17t+9+z57/N9LChQv117/+VZs3b1ZsbKxyc3M1a9Ys/e1vf5MkeTweTZs2TYmJiTpw4IBqamr05JNPqlevXvr1r38d8tcCAEAwWR7pnj17KjEx8bLHGxoatG7dOm3YsEFTpkyRJBUVFWnkyJEqKyvTxIkTtXPnTh0/fly7d++W3W7X2LFj9corr+iFF17QsmXLFBEREeqXAwBA0Fh+TPrLL79UcnKyhg0bptmzZ6uyslKSVF5erubmZqWlpfnWpqSkaPDgwSotLZUklZaWavTo0bLb7b41GRkZcrlcOnbs2FWf0+12y+Vy+d0AADCNpZGeMGGC1q9frx07dmjNmjU6c+aMfvCDH+j8+fNyOp2KiIhQXFyc38/Y7XY5nU5JktPp9At06/bWbVezYsUKxcbG+m6DBg0K7gsDACAILN3dPXXqVN+fx4wZowkTJmjIkCH685//rD59+tyw583Pz1deXp7vvsvlItQAAONYvrv72+Li4jRixAidOnVKiYmJampqUn19vd+a2tpa3zHsxMTEy872br1/pePcrSIjI2Wz2fxuAACYxqhIX7hwQadPn1ZSUpLGjRunXr16qbi42Lf9xIkTqqyslMPhkCQ5HA4dOXJEdXV1vjW7du2SzWZTampqyOcHACCYLN3d/bOf/UzTp0/XkCFDVF1draVLl6pHjx564oknFBsbq7lz5yovL0/x8fGy2WyaP3++HA6HJk6cKElKT09Xamqq5syZo5UrV8rpdGrx4sXKyclRZGSklS8NMMrwESmqqa4KuCYpeYBOn6wI0UQA2sLSSP/zn//UE088oW+++Ub9+/fXfffdp7KyMvXv31+StGrVKoWHhyszM1Nut1sZGRlavXq17+d79Oihbdu2KTs7Ww6HQ3379lVWVpaWL19u1UsCjFRTXaUZBTsDrtmalx6iaQC0laWR3rhxY8DtvXv3VmFhoQoLC6+6ZsiQIdq+fXuwRwMAwHJGHZMGAAD/h0gDAGAoIg0AgKGINAAAhiLSAAAYikgDAGAoIg0AgKGINAAAhiLSAAAYytIrjgHoXNpyDfDGRneIpgG6PiINoM3acg3wTdmTQjQN0PWxuxsAAEMRaQAADMXubqCT4zgx0HURacBQbYmv9N8A/7/V+wKu4Tgx0DkRacBQbTlJSyLAQFfGMWkAAAzFJ2kAkiR3U7OiomMCrgn1se227PJPSh6g0ycrQjQREFpEGoAkqcXj0YyCkoBrQr1rvS27/LfmpYdoGiD02N0NAIChiDQAAIYi0gAAGIpIAwBgKCINAIChiDQAAIYi0gAAGIpIAwBgKCINAIChiDQAAIYi0gAAGIpIAwBgKCINAIChiDQAAIYi0gAAGIpIAwBgKCINAIChiDQAAIbqafUAALond1OzoqJjAq5pbHSHaBrATEQagCVaPB7NKCgJuGZT9qQQTQOYid3dAAAYikgDAGAoIg0AgKGINAAAhiLSAAAYikgDAGAoIg0AgKGINAAAhiLSAAAYikgDAGAoIg0AgKGINAAAhiLSAAAYikgDAGAoIg0AgKGINAAAhiLSAAAYikgDAGAoIg0AgKF6Wj0AAFwPd1OzoqJjAq5JSh6g0ycrQjQREDxEGkCn1uLxaEZBScA1W/PSQzQNEFzs7gYAwFBEGgAAQxFpAAAMRaQBADAUkQYAwFBEGgAAQxFpAAAMRaQBADAUkQYAwFDGRPq1115TWFiYFixY4HussbFROTk56tevn6Kjo5WZmana2lq/n6usrNS0adMUFRWlhIQELVq0SJcuXQrx9AAABJ8RkT506JDeeecdjRkzxu/xhQsX6qOPPtLmzZu1b98+VVdXa9asWb7tHo9H06ZNU1NTkw4cOKD3339f69ev15IlS0L9EgAACDrLI33hwgXNnj1bv//973XTTTf5Hm9oaNC6detUUFCgKVOmaNy4cSoqKtKBAwdUVlYmSdq5c6eOHz+uP/7xjxo7dqymTp2qV155RYWFhWpqarLqJQEAEBSWRzonJ0fTpk1TWlqa3+Pl5eVqbm72ezwlJUWDBw9WaWmpJKm0tFSjR4+W3W73rcnIyJDL5dKxY8dC8wIAALhBLP0WrI0bN+qzzz7ToUOHLtvmdDoVERGhuLg4v8ftdrucTqdvzbcD3bq9ddvVuN1uud1u332Xy9XRlwAAwA1jWaS//vprPffcc9q1a5d69+4d0udesWKFXn755ZA+J/Btw0ekqKa6KuCaxkZ3wO0Auj7LIl1eXq66ujp9//vf9z3m8Xi0f/9+vf322/r444/V1NSk+vp6v0/TtbW1SkxMlCQlJibqk08+8ft7W8/+bl1zJfn5+crLy/Pdd7lcGjRoUDBeFtAmNdVVmlGwM+CaTdmTQjQNAFNZdkz6gQce0JEjR3T48GHf7a677tLs2bN9f+7Vq5eKi4t9P3PixAlVVlbK4XBIkhwOh44cOaK6ujrfml27dslmsyk1NfWqzx0ZGSmbzeZ3AwDANJZ9ko6JidEdd9zh91jfvn3Vr18/3+Nz585VXl6e4uPjZbPZNH/+fDkcDk2cOFGSlJ6ertTUVM2ZM0crV66U0+nU4sWLlZOTo8jIyJC/JgAAgsnSE8euZdWqVQoPD1dmZqbcbrcyMjK0evVq3/YePXpo27Ztys7OlsPhUN++fZWVlaXly5dbODUAAMFhVKT37t3rd793794qLCxUYWHhVX9myJAh2r59+w2eDACA0LP896QBAMCVEWkAAAxFpAEAMBSRBgDAUEQaAABDEWkAAAxFpAEAMBSRBgDAUEQaAABDEWkAAAxFpAEAMBSRBgDAUEZ9wQYAWGX4iBTVVFddc11S8gCdPlkRgokAIg0AkqSa6irNKNh5zXVb89JDMA3wX0QaQJfnbmpWVHRMwDWNje4QTQO0HZEG0OW1eDyaUVAScM2m7EkhmgZoO04cAwDAUEQaAABDsbsbCLK2nCXM8U8AbUGkgSBry1nCHP8E0Bbs7gYAwFBEGgAAQxFpAAAMRaQBADAUkQYAwFBEGgAAQxFpAAAMRaQBADAUkQYAwFBEGgAAQxFpAAAMRaQBADAUkQYAwFBEGgAAQxFpAAAMRaQBADAUkQYAwFBEGgAAQxFpAAAM1dPqAQCgM3E3NSsqOibgmqTkATp9siJEE6ErI9IA0A4tHo9mFJQEXLM1Lz1E06CrY3c3AACGItIAABiKSAMAYCgiDQCAoYg0AACGItIAABiKSAMAYCgiDQCAobiYCQAEGVclQ7AQaQAIMq5KhmBhdzcAAIYi0gAAGIpIAwBgKCINAIChiDQAAIYi0gAAGIpfwQLaYfiIFNVUVwVc09joDtE0ALo6Ig20Q011lWYU7Ay4ZlP2pBBNA6CrY3c3AACGItIAABiKSAMAYCgiDQCAoYg0AACGItIAABiKSAMAYCgiDQCAoYg0AACG4opjwP9wyU8AprE00mvWrNGaNWv01VdfSZJGjRqlJUuWaOrUqZKkxsZGPf/889q4caPcbrcyMjK0evVq2e12399RWVmp7OxslZSUKDo6WllZWVqxYoV69uT/P9A+XPITgGks3d09cOBAvfbaayovL9enn36qKVOm6JFHHtGxY8ckSQsXLtRHH32kzZs3a9++faqurtasWbN8P+/xeDRt2jQ1NTXpwIEDev/997V+/XotWbLEqpcEAEDQWPpxc/r06X73X331Va1Zs0ZlZWUaOHCg1q1bpw0bNmjKlCmSpKKiIo0cOVJlZWWaOHGidu7cqePHj2v37t2y2+0aO3asXnnlFb3wwgtatmyZIiIirHhZAAAEhTEnjnk8Hm3cuFEXL16Uw+FQeXm5mpublZaW5luTkpKiwYMHq7S0VJJUWlqq0aNH++3+zsjIkMvl8n0aBwCgs+pQpIcNG6Zvvvnmssfr6+s1bNiwdv1dR44cUXR0tCIjI/WTn/xEW7ZsUWpqqpxOpyIiIhQXF+e33m63y+l0SpKcTqdfoFu3t267GrfbLZfL5XcDAMA0HYr0V199JY/Hc9njbrdbVVWBz479rttvv12HDx/WwYMHlZ2draysLB0/frwjY7XZihUrFBsb67sNGjTohj4fAAAd0a5j0lu3bvX9+eOPP1ZsbKzvvsfjUXFxsW655ZZ2DRAREaFbb71VkjRu3DgdOnRIv/vd7/TYY4+pqalJ9fX1fp+ma2trlZiYKElKTEzUJ5984vf31dbW+rZdTX5+vvLy8nz3XS4XoQYAGKddkZ45c6YkKSwsTFlZWX7bevXqpVtuuUW//e1vr2uglpYWud1ujRs3Tr169VJxcbEyMzMlSSdOnFBlZaUcDockyeFw6NVXX1VdXZ0SEhIkSbt27ZLNZlNqaupVnyMyMlKRkZHXNScAADdauyLd0tIiSRo6dKgOHTqkm2+++bqePD8/X1OnTtXgwYN1/vx5bdiwQXv37vV9Sp87d67y8vIUHx8vm82m+fPny+FwaOLEiZKk9PR0paamas6cOVq5cqWcTqcWL16snJwcIgwA6PQ69CtYZ86cCcqT19XV6cknn1RNTY1iY2M1ZswYffzxx3rwwQclSatWrVJ4eLgyMzP9LmbSqkePHtq2bZuys7PlcDjUt29fZWVlafny5UGZDwAAK3X496SLi4tVXFysuro63yfsVu+9916b/o5169YF3N67d28VFhaqsLDwqmuGDBmi7du3t+n5AADoTDoU6ZdfflnLly/XXXfdpaSkJIWFhQV7LgAAur0ORXrt2rVav3695syZE+x5AADA/3To96Sbmpp0zz33BHsWAADwLR2K9I9//GNt2LAh2LMAAIBv6dDu7sbGRr377rvavXu3xowZo169evltLygoCMpwAAB0Zx2K9Oeff66xY8dKko4ePeq3jZPIAAAIjg5FuqSkJNhzAACA7zDmqyoBAIC/Dn2Snjx5csDd2nv27OnwQAAA4L86FOnW49GtmpubdfjwYR09evSyL94AAAAd06FIr1q16oqPL1u2TBcuXLiugQAAwH8F9Zj0j370ozZftxsAAAQW1EiXlpaqd+/ewfwrAQDotjq0u3vWrFl+971er2pqavTpp5/qpZdeCspgAAB0dx2KdGxsrN/98PBw3X777Vq+fLnS09ODMhgAAN1dhyJdVFQU7DkAAMB3dCjSrcrLy/XFF19IkkaNGqXvfe97QRkKAAB0MNJ1dXV6/PHHtXfvXsXFxUmS6uvrNXnyZG3cuFH9+/cP5owAAHRLHTq7e/78+Tp//ryOHTumc+fO6dy5czp69KhcLpd++tOfBntGAAC6pQ59kt6xY4d2796tkSNH+h5LTU1VYWEhJ44BABAkHfok3dLSctl3SEtSr1691NLSct1DAQCADkZ6ypQpeu6551RdXe17rKqqSgsXLtQDDzwQtOEAAOjOOhTpt99+Wy6XS7fccouGDx+u4cOHa+jQoXK5XHrrrbeCPSMAAN1Sh45JDxo0SJ999pl2796tiooKSdLIkSOVlpYW1OEAoKtyNzUrKjom4Jqk5AE6fbIiRBPBRO2K9J49e5Sbm6uysjLZbDY9+OCDevDBByVJDQ0NGjVqlNauXasf/OAHN2RYAOgqWjwezSgoCbhmax4n4nZ37drd/cYbb2jevHmy2WyXbYuNjdWzzz6rgoKCoA0HAEB31q5I//3vf9dDDz101e3p6ekqLy+/7qEAAEA7I11bW3vFX71q1bNnT509e/a6hwIAAO2M9IABA3T06NGrbv/888+VlJR03UMBAIB2Rvrhhx/WSy+9pMbGxsu2/ec//9HSpUv1wx/+MGjDAQDQnbXr7O7FixfrL3/5i0aMGKHc3FzdfvvtkqSKigoVFhbK4/Hol7/85Q0ZFACA7qZdkbbb7Tpw4ICys7OVn58vr9crSQoLC1NGRoYKCwtlt9tvyKDA9Rg+IkU11VUB1zQ2ukM0DQC0TbsvZjJkyBBt375d//73v3Xq1Cl5vV7ddtttuummm27EfEBQ1FRXaUbBzoBrNmVPCtE0ANA2HbrimCTddNNNGj9+fDBnAQAA39Kha3cDAIAbj0gDAGAoIg0AgKE6fEwaAHBj8U1ZINIAYCi+KQvs7gYAwFBEGgAAQxFpAAAMRaQBADAUkQYAwFBEGgAAQxFpAAAMRaQBADAUkQYAwFBEGgAAQxFpAAAMRaQBADAUkQYAwFBEGgAAQxFpAAAMRaQBADAUkQYAwFBEGgAAQxFpAAAMRaQBADAUkQYAwFBEGgAAQxFpAAAMRaQBADAUkQYAwFBEGgAAQxFpAAAMRaQBADAUkQYAwFBEGgAAQ1ka6RUrVmj8+PGKiYlRQkKCZs6cqRMnTvitaWxsVE5Ojvr166fo6GhlZmaqtrbWb01lZaWmTZumqKgoJSQkaNGiRbp06VIoXwoAAEFnaaT37dunnJwclZWVadeuXWpublZ6erouXrzoW7Nw4UJ99NFH2rx5s/bt26fq6mrNmjXLt93j8WjatGlqamrSgQMH9P7772v9+vVasmSJFS8JAICg6Wnlk+/YscPv/vr165WQkKDy8nJNmjRJDQ0NWrdunTZs2KApU6ZIkoqKijRy5EiVlZVp4sSJ2rlzp44fP67du3fLbrdr7NixeuWVV/TCCy9o2bJlioiIsOKlAQBw3Yw6Jt3Q0CBJio+PlySVl5erublZaWlpvjUpKSkaPHiwSktLJUmlpaUaPXq07Ha7b01GRoZcLpeOHTsWwukBAAguSz9Jf1tLS4sWLFige++9V3fccYckyel0KiIiQnFxcX5r7Xa7nE6nb823A926vXXblbjdbrndbt99l8sVrJcBAEDQGPNJOicnR0ePHtXGjRtv+HOtWLFCsbGxvtugQYNu+HMCANBeRkQ6NzdX27ZtU0lJiQYOHOh7PDExUU1NTaqvr/dbX1tbq8TERN+a757t3Xq/dc135efnq6GhwXf7+uuvg/hqAAAIDksj7fV6lZubqy1btmjPnj0aOnSo3/Zx48apV69eKi4u9j124sQJVVZWyuFwSJIcDoeOHDmiuro635pdu3bJZrMpNTX1is8bGRkpm83mdwOAzsjd1Kyo6JiAt+EjUqweEx1k6THpnJwcbdiwQR9++KFiYmJ8x5BjY2PVp08fxcbGau7cucrLy1N8fLxsNpvmz58vh8OhiRMnSpLS09OVmpqqOXPmaOXKlXI6nVq8eLFycnIUGRlp5csDgBuuxePRjIKSgGu25qWHaBoEm6WRXrNmjSTp/vvv93u8qKhITz31lCRp1apVCg8PV2ZmptxutzIyMrR69Wrf2h49emjbtm3Kzs6Ww+FQ3759lZWVpeXLl4fqZQAAcENYGmmv13vNNb1791ZhYaEKCwuvumbIkCHavn17MEcDAMByRpw4BgAALmfM70kD3zV8RIpqqqsCrklKHqDTJytCNBEAhBaRhrFqqqs0o2BnwDWcEAOgK2N3NwAAhiLSAAAYikgDAGAoIg0AgKE4cQydWuslEa+lsdF9zTUAYBoijU6tLZdElKRN2ZNCMA0ABBe7uwEAMBSRBgDAUEQaAABDEWkAAAxFpAEAMBSRBgDAUEQaAABDEWkAAAxFpAEAMBSRBgDAUEQaAABDEWkAAAzFF2wAQBfX1m+LS0oeoNMnK0IwEdqKSANAF9fWb4vbmpcegmnQHuzuBgDAUEQaAABDEWkAAAxFpAEAMBSRBgDAUEQaAABDEWkAAAxFpAEAMBSRBgDAUEQaAABDEWkAAAzFtbthieEjUlRTXRVwTWOjO0TTAICZiDQsUVNdpRkFOwOu2ZQ9KUTTAICZ2N0NAIChiDQAAIYi0gAAGIpj0gg6TgoDgOAg0gg6TgoDgOBgdzcAAIYi0gAAGIpIAwBgKCINAIChiDQAAIYi0gAAGIpIAwBgKCINAIChiDQAAIYi0gAAGIpIAwBgKCINAIChiDQAAIYi0gAAGIpIAwBgKL5PGgAgSXI3NSsqOibgmkueFvXsEfjzXVLyAJ0+WRHM0botIg0AkCS1eDyaUVAScM2m7EmatWZ/wDVb89KDOVa3xu5uAAAMRaQBADAUkQYAwFAck0a7DB+RoprqqoBrGhvdIZoGALo2Io12qamu0oyCnQHXbMqeFKJpAKBrY3c3AACGItIAABiKSAMAYCgiDQCAoYg0AACGItIAABiKSAMAYChLI71//35Nnz5dycnJCgsL0wcffOC33ev1asmSJUpKSlKfPn2UlpamL7/80m/NuXPnNHv2bNlsNsXFxWnu3Lm6cOFCCF8FAAA3hqWRvnjxou68804VFhZecfvKlSv15ptvau3atTp48KD69u2rjIwMNTY2+tbMnj1bx44d065du7Rt2zbt379fzzzzTKheAgAAN4ylVxybOnWqpk6desVtXq9Xb7zxhhYvXqxHHnlEkvSHP/xBdrtdH3zwgR5//HF98cUX2rFjhw4dOqS77rpLkvTWW2/p4Ycf1uuvv67k5OSQvRYAAILN2GPSZ86ckdPpVFpamu+x2NhYTZgwQaWlpZKk0tJSxcXF+QItSWlpaQoPD9fBgwev+ne73W65XC6/GwAApjE20k6nU5Jkt9v9Hrfb7b5tTqdTCQkJftt79uyp+Ph435orWbFihWJjY323QYMGBXl6AACun7GRvpHy8/PV0NDgu3399ddWjwQAwGWMjXRiYqIkqba21u/x2tpa37bExETV1dX5bb906ZLOnTvnW3MlkZGRstlsfjcAAExjbKSHDh2qxMREFRcX+x5zuVw6ePCgHA6HJMnhcKi+vl7l5eW+NXv27FFLS4smTJgQ8pkBAAgmS8/uvnDhgk6dOuW7f+bMGR0+fFjx8fEaPHiwFixYoF/96le67bbbNHToUL300ktKTk7WzJkzJUkjR47UQw89pHnz5mnt2rVqbm5Wbm6uHn/8cc7sBgB0epZG+tNPP9XkyZN99/Py8iRJWVlZWr9+vX7+85/r4sWLeuaZZ1RfX6/77rtPO3bsUO/evX0/86c//Um5ubl64IEHFB4erszMTL355pshfy0AAASbpZG+//775fV6r7o9LCxMy5cv1/Lly6+6Jj4+Xhs2bLgR4wEAYCljj0kDANDdEWkAAAxl6e5uAEDX425qVlR0TMA1SckDdPpkRYgm6ryIdDcwfESKaqqrAq7hXxgAwdLi8WhGQUnANVvz0kM0TedGpLuBmuoqzSjYGXAN/8IAgHk4Jg0AgKGINAAAhiLSAAAYimPSkNS2szElqbHRHYJpAAASkcb/tOVsTEnalD0pBNMAACR2dwMAYCwiDQCAoYg0AACGItIAABiKSAMAYCgiDQCAoYg0AACGItIAABiKSAMAYCgiDQCAobgsKAAg5NryfQFJyQN0+mRFiCYyE5EGAIRcW74vYGteeoimMRe7uwEAMBSRBgDAUOzu7uSGj0hRTXVVwDV8BzSAzqit33PflY9dE+lOrqa6SjMKdgZcw3dAA+iM2vo991352DW7uwEAMBSRBgDAUEQaAABDEWkAAAxFpAEAMBSRBgDAUEQaAABDEWkAAAxFpAEAMBSRBgDAUFwW1GBclxsAujcibTCuyw0A3Ru7uwEAMBSRBgDAUEQaAABDEWkAAAxFpAEAMBRndwMAOjV3U7OiomMCrklKHqDTJytCNFHwEGkAQKfW4vFoRkFJwDWbcyd3ypATaQBAl9eWkG/NSw/RNG3HMWkAAAxFpAEAMBS7uy3CdbkBANdCpC3CdbkBwCwmniVOpAEAkJknl3FMGgAAQxFpAAAMRaQBADAUx6SDrC1nbUucuQ0AuDYiHWRtOWtb4sxtAMC1sbsbAABDEWkAAAxFpAEAMBSRBgDAUEQaAABDEWkAAAxFpAEAMBSRBgDAUEQaAABDEWkAAAxFpAEAMBSRBgDAUEQaAABDdZlIFxYW6pZbblHv3r01YcIEffLJJ1aPBADAdekSkd60aZPy8vK0dOlSffbZZ7rzzjuVkZGhuro6q0cDAKDDukSkCwoKNG/ePD399NNKTU3V2rVrFRUVpffee8/q0QAA6LCeVg9wvZqamlReXq78/HzfY+Hh4UpLS1NpaekVf8btdsvtdvvuNzQ0SJJcLtd1z+P1etX8n4ttWXjtdaatMXGmrjx3V35tJs7Ulefuyq8txM/n9XqD0opWMTExCgsLC/iEnVpVVZVXkvfAgQN+jy9atMh79913X/Fnli5d6pXEjRs3bty4WXpraGgI2LhO/0m6I/Lz85WXl+e739LSonPnzqlfv36B/4+mk3K5XBo0aJC+/vpr2Ww2q8cxHu9X+/B+tQ/vV/t09fcrJiYm4PZOH+mbb75ZPXr0UG1trd/jtbW1SkxMvOLPREZGKjIy0u+xuLi4GzWiMWw2W5f8h/xG4f1qH96v9uH9ap/u+n51+hPHIiIiNG7cOBUXF/sea2lpUXFxsRwOh4WTAQBwfTr9J2lJysvLU1ZWlu666y7dfffdeuONN3Tx4kU9/fTTVo8GAECHdYlIP/bYYzp79qyWLFkip9OpsWPHaseOHbLb7VaPZoTIyEgtXbr0sl38uDLer/bh/Wof3q/26e7vV5jX6/VaPQQAALhcpz8mDQBAV0WkAQAwFJEGAMBQRBoAAEMR6W7mq6++0ty5czV06FD16dNHw4cP19KlS9XU1GT1aMZ69dVXdc899ygqKqpbXPSmvfia2LbZv3+/pk+fruTkZIWFhemDDz6weiSjrVixQuPHj1dMTIwSEhI0c+ZMnThxwuqxQo5IdzMVFRVqaWnRO++8o2PHjmnVqlVau3atfvGLX1g9mrGampr06KOPKjs72+pRjMPXxLbdxYsXdeedd6qwsNDqUTqFffv2KScnR2VlZdq1a5eam5uVnp6uixfb8IUbXQi/ggX95je/0Zo1a/SPf/zD6lGMtn79ei1YsED19fVWj2KMCRMmaPz48Xr77bcl/fdqf4MGDdL8+fP14osvWjyducLCwrRlyxbNnDnT6lE6jbNnzyohIUH79u3TpEmTrB4nZPgkDTU0NCg+Pt7qMdDJtH5NbFpamu+xa31NLNBRrV8p3N3+W0Wku7lTp07prbfe0rPPPmv1KOhk/vWvf8nj8Vx2ZT+73S6n02nRVOiKWlpatGDBAt1777264447rB4npIh0F/Hiiy8qLCws4K2iosLvZ6qqqvTQQw/p0Ucf1bx58yya3Bodeb8AWCMnJ0dHjx7Vxo0brR4l5LrEtbshPf/883rqqacCrhk2bJjvz9XV1Zo8ebLuuecevfvuuzd4OvO09/3C5TryNbFAe+Xm5mrbtm3av3+/Bg4caPU4IUeku4j+/furf//+bVpbVVWlyZMna9y4cSoqKlJ4ePfbodKe9wtX9u2viW09Aar1a2Jzc3OtHQ6dntfr1fz587Vlyxbt3btXQ4cOtXokSxDpbqaqqkr333+/hgwZotdff11nz571bePTz5VVVlbq3LlzqqyslMfj0eHDhyVJt956q6Kjo60dzmJ8TWzbXbhwQadOnfLdP3PmjA4fPqz4+HgNHjzYwsnMlJOTow0bNujDDz9UTEyM7zyH2NhY9enTx+LpQsiLbqWoqMgr6Yo3XFlWVtYV36+SkhKrRzPCW2+95R08eLA3IiLCe/fdd3vLysqsHslIJSUlV/znKCsry+rRjHS1/04VFRVZPVpI8XvSAAAYqvsdjAQAoJMg0gAAGIpIAwBgKCINAIChiDQAAIYi0gAAGIpIAwBgKCINAIChiDQAAIYi0gAAGIpIAwBgKCINAICh/j+iQWRJJ2Q9YwAAAABJRU5ErkJggg==", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["sns.displot(data)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This truncated normal distribution has no outliers (there are only about 60, compared to the 100 we expect at this confidence level of 99% on this dataset of 10,000 records)."]}, {"cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [{"data": {"text/plain": ["False"]}, "execution_count": 16, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.has_outliers(data, p=0.99)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Clipping\n", "\n", "If a feature has been clipped, it will have multiple instances at its min and/or max value. There are legitimate reasons why this might happen, for example the feature may be naturally bounded (e.g. porosity is always greater than 0), or the feature may have been deliberately clipped as part of the data preparation process."]}, {"cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [{"data": {"text/plain": ["True"]}, "execution_count": 17, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.is_clipped(df['GR'])"]}, {"cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", "The figure layout has changed to tight\n"]}, {"data": {"text/plain": [""]}, "execution_count": 18, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["import seaborn as sns\n", "\n", "sns.displot(df['GR'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Distribution shape\n", "\n", "Tries to guess the shape of the distribution from the following set from `scipy.stats`:\n", "\n", "- `'norm'`\n", "- `'cosine'`\n", "- `'expon'`\n", "- `'exponpow'`\n", "- `'gamma'`\n", "- `'gumbel_l'`\n", "- `'gumbel_r'`\n", "- `'powerlaw'`\n", "- `'triang'`\n", "- `'trapz'`\n", "- `'uniform'`\n", "\n", "The name is returned, along with the shape parameters (if any), location and scale.\n", "\n", "In spite of the outliers, we find that the distribution of GR values is nearly normal:"]}, {"cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [{"data": {"text/plain": ["Distribution(name='norm', shape=[], loc=64.36789939485628, scale=28.411020184908292)"]}, "execution_count": 19, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.best_distribution(df['GR'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["In contrast, the PHIND data is skewed andbest modeled by the [Gumbel distribution](https://en.wikipedia.org/wiki/Gumbel_distribution)."]}, {"cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [{"data": {"text/plain": ["Distribution(name='gumbel_r', shape=[], loc=10.040572536302586, scale=4.93432972751726)"]}, "execution_count": 20, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.best_distribution(df['PHIND'])"]}, {"cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", "The figure layout has changed to tight\n"]}, {"data": {"text/plain": [""]}, "execution_count": 21, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["sns.displot(df['PHIND'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Identical distribution assumption\n", "\n", "We'd often like to test the implicit assumption that our data are 'identically distributed' across various groups, with respect to both the labels and the features.\n", "\n", "`redflag.wasserstein()` facilitates calculating the first Wasserstein distance (aka earth-mover's distance) between groups, e.g. between train and test datasets. It returns a score for each feature; scores greater than 1 can be interpreted as substantial differences in the distribution."]}, {"cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[0.25985545, 0.28404634, 0.49139232, 0.33701782],\n", " [0.22736457, 0.13473663, 0.33672956, 0.20969657],\n", " [0.41216725, 0.34568777, 0.39729747, 0.48092099],\n", " [0.0801856 , 0.10675027, 0.13740318, 0.10325295],\n", " [0.19913347, 0.21828753, 0.26995735, 0.33063277],\n", " [0.24612402, 0.23889923, 0.26699721, 0.2350674 ],\n", " [0.20666445, 0.44112543, 0.16229232, 0.63527036],\n", " [0.18187639, 0.34992043, 0.19400917, 0.74988182],\n", " [0.31761526, 0.27206283, 0.30255291, 0.24779581]])"]}, "execution_count": 22, "metadata": {}, "output_type": "execute_result"}], "source": ["wells = df['Well Name']\n", "features = ['GR', 'RHOB', 'ILD_log10', 'PE']\n", "\n", "w = rf.wasserstein(df[features], groups=wells, standardize=True)\n", "w"]}, {"cell_type": "markdown", "metadata": {}, "source": ["You could plot this as a heatmap:"]}, {"cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [{"data": {"text/plain": [""]}, "execution_count": 23, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["sns.heatmap(w, yticklabels=np.unique(wells), xticklabels=features)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This shows us that the distributions of the PE log in well indices 6 and 7 are somewhat different and may be anomalous. It also suggests that the CROSS H CATTLE well is different from the others."]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Already split out group arrays\n", "\n", "If you have groups that are already split out, e.g. train and test datasets:"]}, {"cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": ["from sklearn.model_selection import train_test_split\n", "from sklearn.preprocessing import StandardScaler\n", "\n", "X_train, X_ = train_test_split(df[features], test_size=0.4, random_state=42)\n", "\n", "# NOTE: We're doing a random split here for illustration purposes only.\n", "# This is not a valid way to split the dataset, because rows are not indepedent.\n", "X_val, X_test = train_test_split(X_, test_size=0.5, random_state=42)\n", "\n", "# The data should be standardized to compare Wasserstein distance between features.\n", "scaler = StandardScaler()\n", "X_train = scaler.fit_transform(X_train)\n", "X_val = scaler.transform(X_val)\n", "X_test = scaler.transform(X_test)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["In this case, you can pass them into the function as a list or tuple:"]}, {"cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[0.03860982, 0.02506236, 0.04321734, 0.03437337],\n", " [0.04402681, 0.02528225, 0.0385111 , 0.05694201],\n", " [0.04388196, 0.049464 , 0.05560379, 0.04002712]])"]}, "execution_count": 25, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.wasserstein([X_train, X_val, X_test])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The numbers are all quite low because we sampled randomly from the data."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Independence assumption\n", "\n", "If a feature is correlated to lagged (shifted) versions of itself, then the dataset may be ordered by that feature, or the records may not be independent. If several features are correlated to themselves, then the data instances may not be independent."]}, {"cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [{"data": {"text/plain": ["True"]}, "execution_count": 26, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.is_correlated(df['GR'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This is order-dependent. That is, shuffling the data removes the correlation, but does not mean the records are independent."]}, {"cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [{"data": {"text/plain": ["False"]}, "execution_count": 27, "metadata": {}, "output_type": "execute_result"}], "source": ["gr = df['GR'].to_numpy(copy=True)\n", "np.random.shuffle(gr)\n", "rf.is_correlated(gr)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Feature importance\n", "\n", "We'd like to know which features are the most important.\n", "\n", "`redflag` trains a series of models on your data, assessing which features are most important. It then normalizes and averages the results. \n", "\n", "To serve as a 'control', let's add a column of small random numbers that we know is not useful. We'd expect this column to come out with very low importance (i.e. close to zero)."]}, {"cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": ["df['Random'] = np.random.normal(scale=0.1, size=len(df))\n", "df['Constant'] = -1"]}, {"cell_type": "markdown", "metadata": {}, "source": ["First, a **classification task**. Imagine we're trying to predict lithology from well logs. Which are the most important logs?"]}, {"cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([0.27546362, 0.3060072 , 0.32892693, 0.08960226, 0. ])"]}, "execution_count": 29, "metadata": {}, "output_type": "execute_result"}], "source": ["features = ['GR', 'ILD_log10', 'PE', 'Random', 'Constant']\n", "\n", "X = df[features]\n", "y = df['Lithology']\n", "\n", "importances = rf.feature_importances(X, y, random_state=13)\n", "importances"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This tells us that the most important features are, in order: PE, ILD, GR, with the random and constant variables unsurprisingly useless.\n", "\n", "There's a function to help us decide which are the least important features; it returns the indices of the least useful features, in order (least useful first):"]}, {"cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([4, 3])"]}, "execution_count": 31, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.least_important_features(importances)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["And a complementary function reporting the most important:"]}, {"cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([2, 1, 0])"]}, "execution_count": 32, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.most_important_features(importances)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now we'll look at a **regression task**. We'll try to predict RHOB from the other logs (including the dummy variables). The function guesses that this is a regression task:"]}, {"cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([0.08375883, 0.36240187, 0.52059484, 0.03324445, 0. ])"]}, "execution_count": 33, "metadata": {}, "output_type": "execute_result"}], "source": ["features = ['GR', 'ILD_log10', 'PE', 'Random', 'Constant']\n", "\n", "X = df[features]\n", "y = df['RHOB']\n", "\n", "rf.feature_importances(X, y)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The most predictive features are PE and ILD, with GR substantially less important. Again, the random and constant variables are the least important feature."]}], "metadata": {"kernelspec": {"display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.5"}, "vscode": {"interpreter": {"hash": "3ad933181bd8a04b432d3370b9dc3b0662ad032c4dfaa4e4f1596c548f763858"}}}, "nbformat": 4, "nbformat_minor": 4}
\ No newline at end of file
+{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# \ud83d\udea9 Basic usage\n", "\n", "**Welcome to `redflag`.** It's still early days for this library, but there are a few things you can do:\n", "\n", "- Outlier detection\n", "- Clipping detection\n", "- Imbalance metrics (for labels and any other categorical variables)\n", "- Distribution shape\n", "- Identical distribution assumption\n", "- Independence assumption\n", "- Feature importance metrics"]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/plain": ["'0.3.1.dev18+g743d11f.d20230927'"]}, "execution_count": 1, "metadata": {}, "output_type": "execute_result"}], "source": ["import redflag as rf\n", "\n", "rf.__version__"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Load some data"]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [{"data": {"text/html": ["\n", "\n", "\n", " \n", " \n", " \n", " count \n", " mean \n", " std \n", " min \n", " 25% \n", " 50% \n", " 75% \n", " max \n", " \n", " \n", " \n", " \n", " Depth \n", " 3966.0 \n", " 882.674555 \n", " 40.150056 \n", " 784.402800 \n", " 858.012000 \n", " 888.339600 \n", " 913.028400 \n", " 963.320400 \n", " \n", " \n", " RelPos \n", " 3966.0 \n", " 0.524999 \n", " 0.286375 \n", " 0.010000 \n", " 0.282000 \n", " 0.531000 \n", " 0.773000 \n", " 1.000000 \n", " \n", " \n", " Marine \n", " 3966.0 \n", " 1.325013 \n", " 0.589539 \n", " 0.000000 \n", " 1.000000 \n", " 1.000000 \n", " 2.000000 \n", " 2.000000 \n", " \n", " \n", " GR \n", " 3966.0 \n", " 64.367899 \n", " 28.414603 \n", " 12.036000 \n", " 45.311250 \n", " 64.840000 \n", " 78.809750 \n", " 200.000000 \n", " \n", " \n", " ILD \n", " 3966.0 \n", " 5.240308 \n", " 3.190416 \n", " 0.340408 \n", " 3.169567 \n", " 4.305266 \n", " 6.664234 \n", " 32.136605 \n", " \n", " \n", " DeltaPHI \n", " 3966.0 \n", " 3.469088 \n", " 4.922310 \n", " -21.832000 \n", " 1.000000 \n", " 3.292500 \n", " 6.124750 \n", " 18.600000 \n", " \n", " \n", " PHIND \n", " 3966.0 \n", " 13.008807 \n", " 6.936391 \n", " 0.550000 \n", " 8.196250 \n", " 11.781500 \n", " 16.050000 \n", " 52.369000 \n", " \n", " \n", " PE \n", " 3966.0 \n", " 3.686427 \n", " 0.815113 \n", " 0.200000 \n", " 3.123000 \n", " 3.514500 \n", " 4.241750 \n", " 8.094000 \n", " \n", " \n", " Facies \n", " 3966.0 \n", " 4.471004 \n", " 2.406180 \n", " 1.000000 \n", " 2.000000 \n", " 4.000000 \n", " 6.000000 \n", " 9.000000 \n", " \n", " \n", " LATITUDE \n", " 3966.0 \n", " 37.632575 \n", " 0.299398 \n", " 37.180732 \n", " 37.356426 \n", " 37.500380 \n", " 37.910583 \n", " 38.063373 \n", " \n", " \n", " LONGITUDE \n", " 3966.0 \n", " -101.294895 \n", " 0.230454 \n", " -101.646452 \n", " -101.389189 \n", " -101.325130 \n", " -101.106045 \n", " -100.987305 \n", " \n", " \n", " ILD_log10 \n", " 3966.0 \n", " 0.648860 \n", " 0.251542 \n", " -0.468000 \n", " 0.501000 \n", " 0.634000 \n", " 0.823750 \n", " 1.507000 \n", " \n", " \n", " RHOB \n", " 3966.0 \n", " 2288.861692 \n", " 218.038459 \n", " 1500.000000 \n", " 2201.007475 \n", " 2342.202051 \n", " 2434.166399 \n", " 2802.871147 \n", " \n", " \n", "
\n", ""], "text/plain": [" count mean std min 25% \\\n", "Depth 3966.0 882.674555 40.150056 784.402800 858.012000 \n", "RelPos 3966.0 0.524999 0.286375 0.010000 0.282000 \n", "Marine 3966.0 1.325013 0.589539 0.000000 1.000000 \n", "GR 3966.0 64.367899 28.414603 12.036000 45.311250 \n", "ILD 3966.0 5.240308 3.190416 0.340408 3.169567 \n", "DeltaPHI 3966.0 3.469088 4.922310 -21.832000 1.000000 \n", "PHIND 3966.0 13.008807 6.936391 0.550000 8.196250 \n", "PE 3966.0 3.686427 0.815113 0.200000 3.123000 \n", "Facies 3966.0 4.471004 2.406180 1.000000 2.000000 \n", "LATITUDE 3966.0 37.632575 0.299398 37.180732 37.356426 \n", "LONGITUDE 3966.0 -101.294895 0.230454 -101.646452 -101.389189 \n", "ILD_log10 3966.0 0.648860 0.251542 -0.468000 0.501000 \n", "RHOB 3966.0 2288.861692 218.038459 1500.000000 2201.007475 \n", "\n", " 50% 75% max \n", "Depth 888.339600 913.028400 963.320400 \n", "RelPos 0.531000 0.773000 1.000000 \n", "Marine 1.000000 2.000000 2.000000 \n", "GR 64.840000 78.809750 200.000000 \n", "ILD 4.305266 6.664234 32.136605 \n", "DeltaPHI 3.292500 6.124750 18.600000 \n", "PHIND 11.781500 16.050000 52.369000 \n", "PE 3.514500 4.241750 8.094000 \n", "Facies 4.000000 6.000000 9.000000 \n", "LATITUDE 37.500380 37.910583 38.063373 \n", "LONGITUDE -101.325130 -101.106045 -100.987305 \n", "ILD_log10 0.634000 0.823750 1.507000 \n", "RHOB 2342.202051 2434.166399 2802.871147 "]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}], "source": ["import pandas as pd\n", "\n", "df = pd.read_csv('https://geocomp.s3.amazonaws.com/data/Panoma_training_data.csv')\n", "\n", "# Look at the transposed summary: each column in the DataFrame is a row here.\n", "df.describe().T"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Categorical or continuous?"]}, {"cell_type": "markdown", "metadata": {}, "source": ["It's fairly easy to tell if a column is numeric or not, but harder to decide if it's continuous or categorical. We can use `is_continuous()` to check if a feature (or the target) is continuous. It uses heuristics and is definitely not foolproof. `redflag` uses it internally sometimes to decide how to treat a feature or target."]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": [" Well Name ... False\n", " Depth ... True\n", " Formation ... False\n", " RelPos ... True\n", " Marine ... False\n", " GR ... True\n", " ILD ... True\n", " DeltaPHI ... True\n", " PHIND ... True\n", " PE ... True\n", " Facies ... False\n", " LATITUDE ... True\n", " LONGITUDE ... False\n", " ILD_log10 ... True\n", " Lithology ... False\n", " RHOB ... True\n", " Mineralogy ... False\n", " Siliciclastic ... False\n"]}], "source": ["for col in df.columns:\n", " print(f\"{col:>20s} ... {rf.is_continuous(df[col])}\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["These are all correct."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Imbalance metrics\n", "\n", "First, we'll look at measuring imbalance in the target using `rf.class_imbalance()`. For binary targets, the metric is imbalace ratio (ratio between majority and minority class). For multiclass targets, the metric is imbalance degree [(Ortigosa-Hernandez et al, 2017)](https://doi.org/10.1016/j.patrec.2017.08.002), a single-value measure that explains (a) how many minority classes there are and (b) how skewed the supports are."]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [{"data": {"text/plain": ["3.378593040846633"]}, "execution_count": 4, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.imbalance_degree(df['Lithology'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["To interpret this number, split it into two parts:\n", "\n", "- The integer part, 3, is equal to $m - 1$, where $m$ is the number of minority classes.\n", "- The fractional part, 0.378..., is a measure of the amount of imbalance, where 0 means the dataset is balanced perfectly and 0.999... is really bad.\n", "\n", "If the imbalance degree is -1 then there are no minority classes and all the classes have equal support.\n", "\n", "In general, this statistic is more informative than the commonly used 'imbalance ratio' (`rf.imbalance_ratio()`), which is the ratio of support in the maximum majority class to that in the minimum minority class, with no regard for the support of the other classes."]}, {"cell_type": "markdown", "metadata": {}, "source": ["We can get the minority classes, which are those with fewer samples than expected. These are returned in order, smallest first:"]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [{"data": {"text/plain": ["array(['dolomite', 'sandstone', 'mudstone', 'wackestone'], dtype='"]}, "execution_count": 8, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["ax = df['Lithology'].value_counts().plot(kind='bar')\n", "\n", "# Add a line at the expectation level, which is the same for all classes.\n", "ax.axhline(e[0] * len(df), c='r')"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Outliers\n", "\n", "The `get_outliers()` function detects outliers, returning the indices of outlier points."]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([ 301, 302, 303, 415, 416, 417, 418, 799, 896, 897, 898,\n", " 899, 996, 997, 1843, 2278, 2279, 2280, 2638, 2639, 2640, 2641,\n", " 2642, 2643, 2920, 2921, 2922, 3070, 3071, 3074, 3075, 3076, 3078,\n", " 3079, 3080, 3212, 3580, 3581, 3582, 3583])"]}, "execution_count": 9, "metadata": {}, "output_type": "execute_result"}], "source": ["outliers = rf.get_outliers(df['GR'])\n", "outliers"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We can see where these lie in the distribution:"]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n"]}, {"data": {"text/plain": [""]}, "execution_count": 10, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "iVBORw0KGgoAAAANSUhEUgAAAlEAAAGwCAYAAACJjDBkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABk/klEQVR4nO3de1xUdf4/8NfMwMxwv8MAIqCQpCIoCqKWtbGi2RZdds0uml/TdnPdiq72LW1rf1marV3czK20vmWarbllZhFWliIqindRFEWE4SLCwHCf+fz+GGZsEhVG4MwMr+fjMQ/1nM+ceQ+j8PJz3udzZEIIASIiIiLqErnUBRARERE5IoYoIiIiIhswRBERERHZgCGKiIiIyAYMUUREREQ2YIgiIiIisgFDFBEREZENXKQuwJkZjUaUlpbCy8sLMplM6nKIiIioE4QQqKurQ1hYGOTyS883MUT1oNLSUkREREhdBhEREdngzJkz6Nev3yX3M0T1IC8vLwCmD8Hb21viaoiIiKgzdDodIiIiLD/HL4UhqgeZT+F5e3szRBERETmYK7XisLGciIiIyAYMUUREREQ2YIgiIiIisgFDFBEREZENGKKIiIiIbMAQRURERGQDhigiIiIiGzBEEREREdmAIYqIiIjIBgxRRERERDZgiCIiIiKyAUMUERERkQ0YooiIiIhswBBFREREZAOGKCIiIiIbMEQRERER2YAhioiIiMgGDFFERERENmCIIiIiIrIBQxQRERGRDRiiiIiIiGzAEEVERERkA4YoIiIiIhswRBERERHZgCGKiIiIyAYMUUREREQ2YIgiIiIisgFDFBEREZENGKKIiIiIbOAidQFEJJ2WNiMOnK1BXVMb2gwCo6L84ePuKnVZREQOQfKZqGXLliEqKgpqtRopKSnYuXPnZcevW7cOcXFxUKvViI+Px6ZNm6z2r1+/HhMmTEBAQABkMhny8/Ot9p86dQoymazDx7p16yzjOtq/Zs2abnvfRFLbX1KDm9/8GXe+k4MHVu7Cgx/txrhXt+CN74+jrqlV6vKIiOyepCFq7dq1yMzMxIIFC7Bnzx4kJCQgPT0dFRUVHY7fvn07pk6dipkzZ2Lv3r3IyMhARkYGDh48aBmj1+sxbtw4vPrqqx0eIyIiAmVlZVaPv//97/D09MSkSZOsxq5cudJqXEZGRre9dyIprdh6Arf/azsKK+rhrXbBkDBv9Pd3R11zG/75/TFMfvMXnK1plLpMIiK7JhNCCKlePCUlBaNGjcLbb78NADAajYiIiMDcuXPxzDPPXDR+ypQp0Ov12Lhxo2Xb6NGjkZiYiOXLl1uNPXXqFKKjo7F3714kJiZeto7hw4djxIgReP/99y3bZDIZvvjii6sKTjqdDj4+PqitrYW3t7fNxyHqTtlHyjHzw90AgFuGheKl24bCz0MJo1Hg6wNleOWbozhb04h+fm74dNZoRPi7S1wxEVHv6uzPb8lmolpaWpCXl4e0tLQLxcjlSEtLQ05OTofPycnJsRoPAOnp6Zcc3xl5eXnIz8/HzJkzL9o3Z84cBAYGIjk5GR988AGulDebm5uh0+msHkT2pKKuCU99vh8AMGNsFN6+ZwT8PJQAALlchj8khOHzv6QiOtADJecbcfeKHaiqb5ayZCIiuyVZiKqqqoLBYEBISIjV9pCQEGi12g6fo9VquzS+M95//31ce+21GDNmjNX2F198EZ999hmysrJw55134uGHH8Zbb7112WMtXLgQPj4+lkdERITNdRF1NyEEnly3H+f0LYjTeOGZSXEdjgv1ccOa2aMRHeiBszWNePrz/Vf8DwQRUV8keWO5lBobG7F69eoOZ6Gef/55jB07FsOHD8fTTz+Np556CosXL77s8ebNm4fa2lrL48yZMz1VOlGXZR0ux0/HKqFykeOtqcOhclFccmyItxrv3DcCShc5so9W4OPc4l6slIjIMUgWogIDA6FQKFBeXm61vby8HBqNpsPnaDSaLo2/ks8//xwNDQ2YNm3aFcempKSgpKQEzc2XPrWhUqng7e1t9SCyB0IILP/pBABg5rhoxIZ4XfE5cRpvPDPRNFv1j42HUVhR16M1EhE5GslClFKpRFJSErKzsy3bjEYjsrOzkZqa2uFzUlNTrcYDQFZW1iXHX8n777+PW2+9FUFBQVccm5+fDz8/P6hUKptei0hKu0+fx57iGihd5HhgbFSnn/fAmChcFxuI5jYjXtx4pOcKJCJyQJIutpmZmYnp06dj5MiRSE5OxtKlS6HX6zFjxgwAwLRp0xAeHo6FCxcCAB555BGMHz8eS5YsweTJk7FmzRrs3r0bK1assByzuroaxcXFKC0tBQAUFBQAMM1i/XrGqrCwEFu3br1onSkA+Oqrr1BeXo7Ro0dDrVYjKysLL7/8Mp544oke+1oQ9aTlP5pmoe4c0Q/BXupOP08ul+EfGUOR9vpP2HqsEj8dq8T4a678nw4ior5A0p6oKVOm4LXXXsP8+fORmJiI/Px8bN682dI8XlxcjLKyMsv4MWPGYPXq1VixYgUSEhLw+eefY8OGDRg6dKhlzJdffonhw4dj8uTJAIC7774bw4cPv2gJhA8++AD9+vXDhAkTLqrL1dUVy5YtQ2pqKhITE/Huu+/i9ddfx4IFC3riy0DUo46V1yH7aAVkMmD29QO6/PzIAA9MS40CACzcdAQGI5vMiYgAideJcnZcJ4rswQtfHsKq7acwcYgGy+9PsukYNQ0tuH7RD9A1teHVO+MxZVT/bq6SiMh+2P06UUTU8wxGgY37TbO5U0bZvuSGr7sSc38XCwB4+4dCtBmM3VIfEZEjY4gicmK5J8+hqr4Zvu6uGBsTeFXHum90JPzcXXGmuhHfHiq/8hOIiJwcQxSRE/tqv+kCi0lDNVC6XN0/dzelAve390at+PkkF+Akoj6PIYrISbW0GfHNQdNq/n8YFtYtx5yWGgmlixz7ztRg9+nz3XJMIiJHxRBF5KS2FVahpqEVgZ4qpAwI6JZjBnqqcOeIfgCAd3862S3HJCJyVAxRRE7KfCrvlmGhUMhl3XbcB6+LBgBkHy1HaU1jtx2XiMjRMEQROSGjUeDHgkoApn6o7jQwyBMp0f4QAvhi79luPTYRkSNhiCJyQgdLa1Gtb4GnygUjIv26/fh/HGlaLmHd7jNsMCeiPoshisgJbT1mmoUaMzAAroru/2c+aagG7koFTp1rQB4bzImoj2KIInJCW49VAQCu76H73HmoXHBzfCgA4PO8kh55DSIie8cQReRk6ppasafYNDvUkzcLvivJdJXexv1laGwx9NjrEBHZK4YoIiez/cQ5tBkFogM9EOHv3mOvkxzljwh/N9Q3tyH7KFcwJ6K+hyGKyMmY+6Guj72627xciVwus5zS421giKgvYogiciJCCGw93h6ievBUnln6ENPyCT8crUBzG0/pEVHfwhBF5ERKzjfiTHUjXOQyjO6mVcovJ7GfL4K9VKhvbsP2E+d6/PWIiOwJQxSRE9l1qhoAMCTcBx4qlx5/PblcZpmN+u6Qtsdfj4jInjBEETkRc4hKjur+BTYv5UKIKofByIU3iajvYIgiciI7i0whalSUf6+9ZsoAf/i4ueKcvoULbxJRn8IQReQkztU340SlHkDvhihXhRw3xQUDAL4/wqv0iKjvYIgichK7TplmgWKDPeHnoezV176hPUSZl1cgIuoLGKKInIS5H2pUdO/NQpmNiwmETAYc1dahoq6p11+fiEgKDFFETmK3pam890OUv4cSQ8K8AQDbCqt6/fWJiKTAEEXkBPTNbThYqgMgzUwUAFwXa1rc8+djDFFE1DcwRBE5gfwzNTAYBcJ81Aj3dZOkhutiTLeZ+bmwCkJwqQMicn4MUUROYG+xqal8RGTvrQ/1W0lRflC7ylFZ14yC8jrJ6iAi6i0MUUROIP9MDQAgMcJXshpULgqkRJtuNcNTekTUFzBEETk4IYQlRA3v7ytpLdfFXjilR0Tk7BiiiBxcyflGVNW3wEUuw5AwH0lrGTPQFKLyTlWjzWCUtBYiop7GEEXk4MyzUNeGekPtqpC0lkEaL3ipXaBvMeBIGfuiiMi5MUQROTh76IcyU8hlSGpvbjcv/klE5KwYoogcnD2FKODCffsYoojI2TFEETmwVoMRB8/WAgASJW4qN0uOvhCiuF4UETkzhigiB3a0rA7NbUZ4qV0QHeAhdTkAgPhwHygVclTVt+DUuQapyyEi6jEMUUQOLL+kBoDpVJ5cLpO2mHZqVwUSIkxXCe4q4ik9InJeDFFEDmx/ez9UQj9fSev4rZHsiyKiPoAhisiBHWjvh4rvJ+36UL+VzBBFRH0AQxSRg2pqNeB4RT0AUx+SPRkR6QeZDDh1rgGVdc1Sl0NE1CMkD1HLli1DVFQU1Go1UlJSsHPnzsuOX7duHeLi4qBWqxEfH49NmzZZ7V+/fj0mTJiAgIAAyGQy5OfnX3SMG264ATKZzOrx5z//2WpMcXExJk+eDHd3dwQHB+PJJ59EW1vbVb9fou5ypEwHg1EgwEOJUB+11OVY8XFzxcAgTwDA/va+LSIiZyNpiFq7di0yMzOxYMEC7NmzBwkJCUhPT0dFRUWH47dv346pU6di5syZ2Lt3LzIyMpCRkYGDBw9axuj1eowbNw6vvvrqZV971qxZKCsrszwWLVpk2WcwGDB58mS0tLRg+/bt+PDDD7Fq1SrMnz+/e944UTc4WKoDAAwJ94FMZh9N5b9m7tPaV1IrbSFERD1E0hD1+uuvY9asWZgxYwYGDx6M5cuXw93dHR988EGH49944w1MnDgRTz75JK699lq89NJLGDFiBN5++23LmPvvvx/z589HWlraZV/b3d0dGo3G8vD29rbs++6773D48GF8/PHHSExMxKRJk/DSSy9h2bJlaGlp6Z43T3SVDraHk/hw7yuMlEZi+xV6+9qb34mInI1kIaqlpQV5eXlWYUculyMtLQ05OTkdPicnJ+eicJSenn7J8ZfzySefIDAwEEOHDsW8efPQ0HBhPZucnBzEx8cjJCTE6nV0Oh0OHTp0yWM2NzdDp9NZPYh6iqWp3M76ocwS2ldQ31dSw0U3icgpuUj1wlVVVTAYDFZBBQBCQkJw9OjRDp+j1Wo7HK/Varv02vfccw8iIyMRFhaG/fv34+mnn0ZBQQHWr19/2dcx77uUhQsX4u9//3uXaiGyRVOrAcfKTTf4HWqnISpO4w2lQo6ahlYUVzcg0k4WAyUi6i6ShSgpzZ492/L7+Ph4hIaG4qabbsKJEycwcOBAm487b948ZGZmWv6s0+kQERFxVbUSdeRYeR3ajAJ+7q4I93WTupwOKV3kuDbMG/vO1CD/TA1DFBE5HclO5wUGBkKhUKC8vNxqe3l5OTQaTYfP0Wg0XRrfWSkpKQCAwsLCy76Oed+lqFQqeHt7Wz2IeoL5VN5QO20qN0tsX79qP5vLicgJSRailEolkpKSkJ2dbdlmNBqRnZ2N1NTUDp+TmppqNR4AsrKyLjm+s8zLIISGhlpe58CBA1ZXCWZlZcHb2xuDBw++qtci6g4HfxWi7JmlL4rN5UTkhCQ9nZeZmYnp06dj5MiRSE5OxtKlS6HX6zFjxgwAwLRp0xAeHo6FCxcCAB555BGMHz8eS5YsweTJk7FmzRrs3r0bK1assByzuroaxcXFKC0tBQAUFBQAgOUqvBMnTmD16tW4+eabERAQgP379+Oxxx7D9ddfj2HDhgEAJkyYgMGDB+P+++/HokWLoNVq8dxzz2HOnDlQqVS9+SUi6pC9N5WbmUPUwdJatBqMcFVIvjQdEVG3kfQ72pQpU/Daa69h/vz5SExMRH5+PjZv3mxp4i4uLkZZWZll/JgxY7B69WqsWLECCQkJ+Pzzz7FhwwYMHTrUMubLL7/E8OHDMXnyZADA3XffjeHDh2P58uUATDNg33//PSZMmIC4uDg8/vjjuPPOO/HVV19ZjqFQKLBx40YoFAqkpqbivvvuw7Rp0/Diiy/2xpeF6LJa2owo0Jqayu09REUHeMBL7YKmVqOlEZ6IyFnIBK897jE6nQ4+Pj6ora1lfxR1m4Nna3HLW7/Ax80V+fN/b9c9UQBw73s7sK3wHF65Ix53J/eXuhwioivq7M9vzq0TOZgLTeXedh+gAGBImGm27FAp100jIufCEEXkYA44SFO52ZAw0//iDpXyCj0ici4MUUQO5pCDNJWbDQ41haij2joYjOweICLnwRBF5EBaDUYccZCmcrMBQZ5Qu8rR0GLAqXN6qcshIuo2DFFEDuRYeR1a2ozwUrugv7+71OV0ikIuQ5zGfEqPfVFE5DwYoogcyKGzphAyNMy+Vyr/LfZFEZEzYogiciCWRTb7OcapPDPzFXqHORNFRE6EIYrIgTjalXlmF2aidODSdETkLBiiiBxEm8GII2Xm03mOtXjrII0XFHIZqvUt0OqapC6HiKhbMEQROYjCyno0txnhqXJBVICH1OV0idpVgYFBpprNfV1ERI6OIYrIQRwoMZ3KGxLmDbnccZrKzbhyORE5G4YoIgdx0MEW2fwtc1/UUS1DFBE5B4YoIgfhqFfmmQ3SeAEACtoXCyUicnQMUUQOwGAUONzeVG4+LeZozCGq6JwejS0GiashIrp6DFFEDuBEZT2aWo3wUCowINCxmsrNgjxV8PdQQgjgeAVno4jI8TFEETmAC03lPg7ZVA4AMpkMce2zUUd5So+InABDFJEDcNRFNn/LfErvaBlDFBE5PoYoIgdgvufc0HDHWmTzt8wzUQXlvEKPiBwfQxSRnTMYhWVtJUdd3sBskMYUAnmFHhE5A4YoIjtXVFWPhhYD3JUKDAjylLqcq3JNiCdkMqCqvgWVdc1Sl0NEdFUYoojsnLkfanCoNxQO2lRu5q50QaS/OwDORhGR42OIIrJzB9vvNefoTeVmluZyrlxORA6OIYrIzjnLlXlmceyLIiInwRBFZMeMRoHDTtJUbsa1oojIWTBEEdmxonN61De3Qe0qx8Agx1yp/LeuaQ9RhRX1MBqFxNUQEdmOIYrIjh1sP5V3bag3XBTO8c810t8drgoZGlsNOFvTKHU5REQ2c47vykROyhyinOVUHgC4KOQYEGhaqqGwsl7iaoiIbMcQRWTHnK2p3CwmpD1ElTNEEZHjYogislNGo8Chs87VVG4WG2wKUccr2FxORI6LIYrIThVXN6CuuQ1KFzligh17pfLfirGEKM5EEZHjYogislMHftVU7uokTeVmscHtV+iV10MIXqFHRI7Jub4zEzmRC03l3hJX0v2iAt2hkMtQ19yGch3voUdEjokhishO7SupAeB8/VAAoHJRIDLAdA+9Qp7SIyIHxRBFZIcMRoEDJaaZqMQIP4mr6RlsLiciR8cQRWSHTlTWQ99igLtS4XRN5Wbmvig2lxORo2KIIrJD+WdqAJhO5SnkMmmL6SGxXCuKiByc5CFq2bJliIqKglqtRkpKCnbu3HnZ8evWrUNcXBzUajXi4+OxadMmq/3r16/HhAkTEBAQAJlMhvz8fKv91dXVmDt3LgYNGgQ3Nzf0798ff/vb31BbW2s1TiaTXfRYs2ZNt7xnoivZ1x6iEiN8Ja2jJw0MMoWoYxV1vEKPiBySpCFq7dq1yMzMxIIFC7Bnzx4kJCQgPT0dFRUVHY7fvn07pk6dipkzZ2Lv3r3IyMhARkYGDh48aBmj1+sxbtw4vPrqqx0eo7S0FKWlpXjttddw8OBBrFq1Cps3b8bMmTMvGrty5UqUlZVZHhkZGd3yvomuJL+PhCiZDKhpaMU5fYvU5RARdZlMSPhfwJSUFIwaNQpvv/02AMBoNCIiIgJz587FM888c9H4KVOmQK/XY+PGjZZto0ePRmJiIpYvX2419tSpU4iOjsbevXuRmJh42TrWrVuH++67D3q9Hi4uLgBMM1FffPHFVQUnnU4HHx8f1NbWwtvb+S5Tp57R1GrAkAXfwmAU2P7M7xDm6yZ1ST3m+kU/oLi6AWtmj8boAQFSl0NEBKDzP78lm4lqaWlBXl4e0tLSLhQjlyMtLQ05OTkdPicnJ8dqPACkp6dfcnxnmb9I5gBlNmfOHAQGBiI5ORkffPDBFU85NDc3Q6fTWT2IuupQaS0MRoEgLxVCfdRSl9OjYrlyORE5MMlCVFVVFQwGA0JCQqy2h4SEQKvVdvgcrVbbpfGdreOll17C7Nmzrba/+OKL+Oyzz5CVlYU777wTDz/8MN56663LHmvhwoXw8fGxPCIiImyui/qu/DOm/ryEfr6QyZyzqdzswo2IucwBETkelysPcV46nQ6TJ0/G4MGD8cILL1jte/755y2/Hz58OPR6PRYvXoy//e1vlzzevHnzkJmZaXV8BinqqgtN5c63yOZvcZkDInJkks1EBQYGQqFQoLy83Gp7eXk5NBpNh8/RaDRdGn85dXV1mDhxIry8vPDFF1/A1dX1suNTUlJQUlKC5uZL36JCpVLB29vb6kHUVeam8mH9fCWtozfwRsRE5MgkC1FKpRJJSUnIzs62bDMajcjOzkZqamqHz0lNTbUaDwBZWVmXHH8pOp0OEyZMgFKpxJdffgm1+sp9J/n5+fDz84NKperSaxF1RUVdE4qrGyCTAYn9faUup8eZQ1RlXTNqG1olroaIqGskPZ2XmZmJ6dOnY+TIkUhOTsbSpUuh1+sxY8YMAMC0adMQHh6OhQsXAgAeeeQRjB8/HkuWLMHkyZOxZs0a7N69GytWrLAcs7q6GsXFxSgtLQUAFBQUADDNYmk0GkuAamhowMcff2zVAB4UFASFQoGvvvoK5eXlGD16NNRqNbKysvDyyy/jiSee6M0vD/VBe06fBwAMCvGCt/rys6POwFPlgjAfNUprm1BYWYekSH+pSyIi6jRJQ9SUKVNQWVmJ+fPnQ6vVIjExEZs3b7Y0jxcXF0MuvzBZNmbMGKxevRrPPfccnn32WcTGxmLDhg0YOnSoZcyXX35pCWEAcPfddwMAFixYgBdeeAF79uxBbm4uACAmJsaqnqKiIkRFRcHV1RXLli3DY489BiEEYmJi8Prrr2PWrFk99rUgAoC89hCVFOmc98vrSEyIF0prm3C8vJ4hiogciqTrRDk7rhNFXXX7v7Zhb3EN/jklAbcP7yd1Ob3ipY2H8f4vRZg5LhrP3zJY6nKIiOx/nSgistbUasDBs6blDZL6950ZGa4VRUSOiiGKyE4cOFuLVoNpkc0If+ddpfy3YrlWFBE5KIYoIjux+1R7P1R/P6dfZPPXYoJMa0WV1jahvrlN4mqIiDqPIYrITpibykdG9Z2mcgDwcXdFkJdp6ZATPKVHRA6EIYrIDgghsKfYFKJG9KEr88zYF0VEjoghisgOnKzSo1rfApWLHEPDnP92L79lXnTzRCVDFBE5DoYoIjuQc+IcAGBEfz8oXfreP8uBQe0hijNRRORA+t53ayI7lHPSFKJGDwiQuBJpmENUIWeiiMiBMEQRSUwIgdz2EJU6sI+GqGAPAEDxuQa0GowSV0NE1DkMUUQSK6yoR1W9qR8qIaLv9UMBgMZbDQ+lAm1GgdPnGqQuh4ioUxiiiCRmPpU3MsoPKheFxNVIQyaTYSCby4nIwTBEEUnM3FSe2kf7ocwszeUMUUTkIBiiiCRkNArs6ONN5WYDg0x9UYW8Qo+IHARDFJGEjlXU4XxDK9xcFRjWz1fqciR1YSZKL3ElRESdwxBFJKFthRf6ofri+lC/Zl5w82RFPYQQEldDRHRlffu7NpHEfiyoAABcHxskcSXS6x/gDoVchrrmNlTWNUtdDhHRFTFEEUmkscWA3KJqAMANgxiiVC4K9Pd3B8BFN4nIMTBEEUkk52QVWtqMCPd1s5zK6uvMzeW8/QsROQKGKCKJ/HC0EoBpFkomk0lcjX1gczkRORKGKCIJCCHw4zFTP9QNg4IlrsZ+cK0oInIkDFFEEjhZpceZ6kYoFXKM6aP3y+uIZdVyns4jIgfAEEUkgR8LTKfyRkX7wUPlInE19sPcE1Va2wR9c5vE1RARXR5DFJEEvj9cDgC44Rqeyvs1X3clAj2VAICiKvZFEZF9sylEnTx5srvrIOozquqbkVtkWmRz4lCNxNXYnwHtfVG8/QsR2TubQlRMTAxuvPFGfPzxx2hqaurumoic2uaDWhgFMKyfDyLa10WiC9hcTkSOwqYQtWfPHgwbNgyZmZnQaDR46KGHsHPnzu6ujcgpbTpQBgC4OT5U4krsk3nNLIYoIrJ3NoWoxMREvPHGGygtLcUHH3yAsrIyjBs3DkOHDsXrr7+OysrK7q6TyClU1Tdjx0nTqbzJDFEdurDgJnuiiMi+XVVjuYuLC+644w6sW7cOr776KgoLC/HEE08gIiIC06ZNQ1lZWXfVSeQUvj3EU3lXYj6dV1Slh8HIGxETkf26qhC1e/duPPzwwwgNDcXrr7+OJ554AidOnEBWVhZKS0tx2223dVedRE7h6/08lXcl4b5uULnI0WIw4kx1g9TlEBFdkk0L1Lz++utYuXIlCgoKcPPNN+Ojjz7CzTffDLnclMmio6OxatUqREVFdWetRA7tbE0jcngq74rkchkGBHniSJkOJyrrERXoIXVJREQdsmkm6p133sE999yD06dPY8OGDbjlllssAcosODgY77//frcUSeQM1u46AyGAMQMDeCrvCthcTkSOwKaZqKysLPTv3/+i4CSEwJkzZ9C/f38olUpMnz69W4okcnRtBiM+23UGAHB3cn+Jq7F/bC4nIkdg00zUwIEDUVVVddH26upqREdHX3VRRM7mp2OV0Oqa4OfuivQhIVKXY/e4VhQROQKbQpQQHV8xU19fD7VafVUFETmjT3cWAwDuSuoHlYtC4mrsnzlEFVbWX/L7DRGR1Lp0Oi8zMxMAIJPJMH/+fLi7X+jrMBgMyM3NRWJiYrcWSOToztY0YsvRCgA8lddZ0YEekMmAmoZWVOtbEOCpkrokIqKLdClE7d27F4BpJurAgQNQKpWWfUqlEgkJCXjiiSe6t0IiB7f8xxMwtjeUm2dY6PLclAqE+7qh5HwjTlTqGaKIyC51KUT98MMPAIAZM2bgjTfegLe3d48UReQstLVNWNveUD73d7ESV+NYYoI920NUPZKj/aUuh4joIjb1RK1cubLbAtSyZcsQFRUFtVqNlJSUK96Db926dYiLi4NarUZ8fDw2bdpktX/9+vWYMGECAgICIJPJkJ+ff9ExmpqaMGfOHAQEBMDT0xN33nknysvLrcYUFxdj8uTJcHd3R3BwMJ588km0tbVd9fulvmX5TyfQYjAiOcofowcwCHSFpbm8gs3lRGSfOj0Tdccdd2DVqlXw9vbGHXfccdmx69ev79Qx165di8zMTCxfvhwpKSlYunQp0tPTUVBQgODg4IvGb9++HVOnTsXChQtxyy23YPXq1cjIyMCePXswdOhQAIBer8e4cePwpz/9CbNmzerwdR977DF8/fXXWLduHXx8fPDXv/4Vd9xxB7Zt2wbA1N81efJkaDQabN++HWVlZZg2bRpcXV3x8ssvd+q9EVXomiwN5Y+kxUImk0lckWP5dXM5EZE9kolOXvoyY8YMvPnmm/Dy8sKMGTMuO3blypWdevGUlBSMGjUKb7/9NgDAaDQiIiICc+fOxTPPPHPR+ClTpkCv12Pjxo2WbaNHj0ZiYiKWL19uNfbUqVOIjo7G3r17rZrda2trERQUhNWrV+Ouu+4CABw9ehTXXnstcnJyMHr0aHzzzTe45ZZbUFpaipAQ0+Xoy5cvx9NPP43KykqrXrDL0el08PHxQW1tLU999kFPfb4Pn+0uQVKkHz7/cypDVBflnjyHKSt2IMLfDT8/9TupyyGiPqSzP787PRP162DU2ZB0OS0tLcjLy8O8efMs2+RyOdLS0pCTk9Phc3JycixXCJqlp6djw4YNnX7dvLw8tLa2Ii0tzbItLi4O/fv3t4SonJwcxMfHWwKU+XX+8pe/4NChQxg+fHiHx25ubkZzc7PlzzqdrtN1kXPZfqIKn+0uAQDMmxTHAGWDge2rlpecb0RTqwFqVy4NQUT2xaaeqMbGRjQ0XLgx6OnTp7F06VJ89913nT5GVVUVDAaDVVABgJCQEGi12g6fo9VquzT+UsdQKpXw9fW95HEu9TrmfZeycOFC+Pj4WB4RERGdroucR1OrAc+uPwAAuG90f4yMYi+ULQI8lPB1d4UQQFEVVy4nIvtjU4i67bbb8NFHHwEAampqkJycjCVLluC2227DO++8060FOpJ58+ahtrbW8jhz5ozUJZEEXvu2AKfONSDEW4WnJsZJXY7DkslkXLmciOyaTSFqz549uO666wAAn3/+OTQaDU6fPo2PPvoIb775ZqeOERgYCIVCcdFVceXl5dBoNB0+R6PRdGn8pY7R0tKCmpqaSx7nUq9j3ncpKpUK3t7eVg/qW9buKsZ7vxQBAF68bSi81a4SV+TYeA89IrJnNoWohoYGeHl5AQC+++473HHHHZDL5Rg9ejROnz7dqWMolUokJSUhOzvbss1oNCI7OxupqakdPic1NdVqPGC6GfKlxnckKSkJrq6uVscpKChAcXGx5Tipqak4cOAAKioqrF7H29sbgwcP7vRrUd+y9Vglnv3iIADgb7+LQfqQzod76hiv0CMie9alxTbNYmJisGHDBtx+++349ttv8dhjjwEAKioqujT7kpmZienTp2PkyJFITk7G0qVLodfrLVf/TZs2DeHh4Vi4cCEA4JFHHsH48eOxZMkSTJ48GWvWrMHu3buxYsUKyzGrq6tRXFyM0tJSAKaABJhmkDQaDXx8fDBz5kxkZmbC398f3t7emDt3LlJTUzF69GgAwIQJEzB48GDcf//9WLRoEbRaLZ577jnMmTMHKhVXTqaL/Tf/LJ7+z34YjAK3Dw/HY7+/RuqSnALXiiIiuyZssG7dOuHq6irkcrn4/e9/b9n+8ssvi4kTJ3bpWG+99Zbo37+/UCqVIjk5WezYscOyb/z48WL69OlW4z/77DNxzTXXCKVSKYYMGSK+/vprq/0rV64UAC56LFiwwDKmsbFRPPzww8LPz0+4u7uL22+/XZSVlVkd59SpU2LSpEnCzc1NBAYGiscff1y0trZ26b3V1tYKAKK2trZLzyPHoWtsEQv+e1BEPr1RRD69UcxYuVM0tbZJXZbTKKqsF5FPbxSDntskDAaj1OUQUR/R2Z/fnV4n6re0Wi3KysqQkJAAudx0VnDnzp3w9vZGXBybaQGuE+XMzlQ34Iu9Z/H+L0WobWwFAPz1xhg89vtroJBzOYPu0mYwYvD8b9FiMOKXp29EPz/3Kz+JiOgqdfs6Ub9lPj32a8nJybYejsjuGI0CpbWNOH2uAWeqG3DmfAOKqxtx8Gyt1SX3A4I88L83X4ubrg25zNHIFi4KOaIC3XGsvB4nKvUMUURkV2wKUXq9Hq+88gqys7NRUVEBo9Fotf/kyZPdUhxRbxJC4EhZHTYf0uKX45Uo0NZB32LocKyLXIYR/f1w7+j+uGVYGGefetDAIE8cK69HYUU9xl8TJHU5REQWNoWoBx98ED/99BPuv/9+hIaGcjVmcmhCCGw9XoXF3x7FwbPWq8y7KmSI8HdHhJ87+vubHgOCPJAc7Q8vLl/QK7hWFBHZK5tC1DfffIOvv/4aY8eO7e56iHpVha4Jj6/bh5+PVwEAVC5yjL8mCL8fHILECF9EBXrAVWHTSiDUTQYGm9eKYogiIvtiU4jy8/ODvz9vZUGOLe90Nf7y8R5U1DVDqZDj/tRIzLkxBv4enbvBNPWOmCDTmnQnKrngJhHZF5v+i/3SSy9h/vz5VvfPI3Ik3x7S4u4VO1BR14zYYE988+h1eP6WwQxQdmhA+6rlVfXNqG1olbgaIqILbJqJWrJkCU6cOIGQkBBERUXB1dW6N2TPnj3dUhxRT9heWIW5q/ei1SAwcYgGS/6UAA+VzReqUg/zULkg1EeNstomFFbWIynST+qSiIgA2BiiMjIyurkMot6xv6QGsz7ajRaDEelDQvD2PcPhwp4nuzcwyBNltU04wRBFRHbEphC1YMGC7q6DqMfVNLTgLx/vgb7FgLExAXjjbgYoRzEwyAO/FFbxCj0isis2/wSpqanBe++9h3nz5qG6uhqA6TTe2bNnu604ou4ihMDT/9mPszWNiApwx/L7kqB2VUhdFnVSTLD5HnpsLici+2HTTNT+/fuRlpYGHx8fnDp1CrNmzYK/vz/Wr1+P4uJifPTRR91dJ9FV+b8dp/HtoXK4KmR4a+oIrvHkYMxrRZ3kTBQR2RGbZqIyMzPxwAMP4Pjx41Cr1ZbtN998M7Zu3dptxRF1hzPVDXh50xEAwLxJ1yK+n4/EFVFXDWyfiTpd3YCWNuMVRhMR9Q6bQtSuXbvw0EMPXbQ9PDwcWq32qosi6i5CCMz/70E0tRqROiAAM8ZGSV0S2SDYSwVPlQsMRoHT53hKj4jsg00hSqVSQafTXbT92LFjCAriva3Ifmw+qMUPBZVQKuT4x+1DeYsiByWTyTCwfb0oNpcTkb2wKUTdeuutePHFF9Haalr4TiaTobi4GE8//TTuvPPObi2QyFb65jb8/avDAIA/jx9g6ashx2Q+pVfI278QkZ2wKUQtWbIE9fX1CAoKQmNjI8aPH4+YmBh4eXnh//2//9fdNRLZZMXWk9DqmtDf3x0P3xgjdTl0lWKDTbd/OVbOEEVE9sGmq/N8fHyQlZWFbdu2Yd++faivr8eIESOQlpbW3fUR2aSirgn//vkkAOCpiYO4nIETiG2fiTrOmSgishNdDlFGoxGrVq3C+vXrcerUKchkMkRHR0Oj0UAIwZ4TsgtvZh9HQ4sBCf18MDk+VOpyqBtcE2K+EXE9DEYBhZzfa4hIWl06nSeEwK233ooHH3wQZ8+eRXx8PIYMGYLTp0/jgQcewO23395TdRJ1WlGVHp/uPAMAeGbStQz2TqKfnxvUrnK0tBl5hR4R2YUuzUStWrUKW7duRXZ2Nm688UarfVu2bEFGRgY++ugjTJs2rVuLJOqKN74/BoNR4MZBQUgdGCB1OdRN5HIZYoI9cfCsDscr6jGAFwoQkcS6NBP16aef4tlnn70oQAHA7373OzzzzDP45JNPuq04oq46WVmPL/eVAgAenzBI4mqou13T3lx+vLxO4kqIiLoYovbv34+JEydecv+kSZOwb9++qy6KyFZvbymEUQBp1wZjaDhXJnc2MSGm2SdeoUdE9qBLIaq6uhohISGX3B8SEoLz589fdVFEtiiq0mNDvukG2I/cdI3E1VBPsMxE8Qo9IrIDXQpRBoMBLi6XbqNSKBRoa2u76qKIbLHsB9Ms1O/ignl/PCf12yv0iIik1KXGciEEHnjgAahUqg73Nzc3d0tRRF1VVtuIDXtNs1Bzf8eFNZ2V+Qq9plbTFXpsLiciKXUpRE2fPv2KY3hlHklh5bZTaDMKpET7Y3h/P6nLoR7CK/SIyJ50KUStXLmyp+ogspmuqRWrc4sBAA+NHyBxNdTTYoO9TCGqvA7pQzRSl0NEfZhN984jsief5hajvrkNscGeuOGaYKnLoR4Wyyv0iMhOMESRQ2tpM+KDbUUAgFnXD4CctwJxetdYbkTMtaKISFoMUeTQ/pt/FuW6ZoR4q3BbYpjU5VAvGKS5cIVeq8EocTVE1JcxRJHDEkLg3z+fBADMGBsNlYtC4oqoN/Tzc4OnygWtBoGTlbyHHhFJhyGKHNaPBZU4Vl4PT5UL7knpL3U51EtkMhmuae+LOqrVSVwNEfVlDFHksN7degIAMDU5At5qV4mrod4UF+oNACjQsi+KiKTDEEUOaX9JDXacrIaLXIYZY6OlLod6WVx7XxRDFBFJiSGKHNLKbacAAH9ICEOYr5u0xVCvG9R++5ejDFFEJCGGKHI4FbombNxfCgCYMTZK2mJIEnEa0+m8szWN0DW1SlwNEfVVDFHkcD7ecRqtBoGRkX4Y1s9X6nJIAj7urtB4qwEAxzgbRUQSsYsQtWzZMkRFRUGtViMlJQU7d+687Ph169YhLi4OarUa8fHx2LRpk9V+IQTmz5+P0NBQuLm5IS0tDcePH7fs//HHHyGTyTp87Nq1CwBw6tSpDvfv2LGj+78A1GlNrQZ80n6LF/ZC9W3m9aJ4So+IpCJ5iFq7di0yMzOxYMEC7NmzBwkJCUhPT0dFRUWH47dv346pU6di5syZ2Lt3LzIyMpCRkYGDBw9axixatAhvvvkmli9fjtzcXHh4eCA9PR1NTU0AgDFjxqCsrMzq8eCDDyI6OhojR460er3vv//ealxSUlLPfTHoir7aV4pz+haE+aiRPiRE6nJIQmwuJyKpSR6iXn/9dcyaNQszZszA4MGDsXz5cri7u+ODDz7ocPwbb7yBiRMn4sknn8S1116Ll156CSNGjMDbb78NwDQLtXTpUjz33HO47bbbMGzYMHz00UcoLS3Fhg0bAABKpRIajcbyCAgIwH//+1/MmDEDMpn1bUMCAgKsxrq6XvpS+ubmZuh0OqsHdR8hhKWh/P7UKLgoJP/rSxIaxBBFRBKT9KdQS0sL8vLykJaWZtkml8uRlpaGnJycDp+Tk5NjNR4A0tPTLeOLioqg1Wqtxvj4+CAlJeWSx/zyyy9x7tw5zJgx46J9t956K4KDgzFu3Dh8+eWXl30/CxcuhI+Pj+URERFx2fHUNTuLqnG4TAe1qxxTk/m17esunM7TQQghcTVE1BdJGqKqqqpgMBgQEmJ9WiYkJARarbbD52i12suON//alWO+//77SE9PR79+/SzbPD09sWTJEqxbtw5ff/01xo0bh4yMjMsGqXnz5qG2ttbyOHPmzCXHUteZZ6FuH94Pvu5KaYshycUEe8JVIYOuqQ1naxqlLoeI+iAXqQuQWklJCb799lt89tlnVtsDAwORmZlp+fOoUaNQWlqKxYsX49Zbb+3wWCqVCiqVqkfr7avOVDfgu8OmEMxlDQgAVC4KxAR74UiZDodLdejn5y51SUTUx0g6ExUYGAiFQoHy8nKr7eXl5dBoNB0+R6PRXHa8+dfOHnPlypUICAi4ZDD6tZSUFBQWFl5xHHW/j3JOwSiA62IDcU37QotEg9tv/3K4jP2HRNT7JA1RSqUSSUlJyM7OtmwzGo3Izs5Gampqh89JTU21Gg8AWVlZlvHR0dHQaDRWY3Q6HXJzcy86phACK1euxLRp0y7bMG6Wn5+P0NDQTr8/6h6NLQZ8trsEAPDAmChpiyG7MjjMFKIOlTJEEVHvk/x0XmZmJqZPn46RI0ciOTkZS5cuhV6vtzR5T5s2DeHh4Vi4cCEA4JFHHsH48eOxZMkSTJ48GWvWrMHu3buxYsUKAKY7vD/66KP4xz/+gdjYWERHR+P5559HWFgYMjIyrF57y5YtKCoqwoMPPnhRXR9++CGUSiWGDx8OAFi/fj0++OADvPfeez341aCOfLW/FLWNrejn54YbBgVLXQ7ZkSHtIeowQxQRSUDyEDVlyhRUVlZi/vz50Gq1SExMxObNmy2N4cXFxZDLL0yYjRkzBqtXr8Zzzz2HZ599FrGxsdiwYQOGDh1qGfPUU09Br9dj9uzZqKmpwbhx47B582ao1Wqr137//fcxZswYxMXFdVjbSy+9hNOnT8PFxQVxcXFYu3Yt7rrrrh74KtDlfLLjNADg3pRIKOSyK4ymvuTa0Au3f6lpaOEFB0TUq2SC1wb3GJ1OBx8fH9TW1sLb21vqchzS/pIa3Pr2NigVcuTM+x0CPNm4T9auW7QFZ6obsXpWCsYMDJS6HCJyAp39+c3VCsmufdw+CzUpXsMARR2yNJfzlB4R9TKGKLJbtQ2t+HJfKQDgvtGREldD9mpwqA8Ahigi6n0MUWS3/rOnBE2tRsRpvDAy0k/qcshOWZrLucwBEfUyhiiyS0IIfJzb3lA+OvKiexoSmZmXOSisqEdTq0HiaoioL2GIIruUc+IcTlbq4aFU4Pbh4VKXQ3Ys1EcNP3dXtBkFjpfXS10OEfUhDFFkl8yzUBnDw+GpknwlDrJjMpkMQ8NNfVH7z9ZIWwwR9SkMUWR3KnRN+O6Q6bY9bCinzohvD1EHSmolroSI+hKGKLI76/JK0GYUSIr0syymSHQ5w/r5AgD2MUQRUS9iiCK7IoTA53mm++RNGRUhcTXkKBIiTDNRx8rr0NjC5nIi6h0MUWRXdp8+j6IqPdyVCkyO582eqXM03moEeqpgMAoudUBEvYYhiuzKut1nAACT40PhwYZy6iSZTIaEfu3N5SU10hZDRH0GQxTZDX1zG77eXwYA+ONInsqjrjH3Re1nXxQR9RKGKLIbmw6UQd9iQFSAO0ZFcYVy6pphnIkiol7GEEV2Y0P+WQDAXUn9uEI5dZk5RJ2s0qOuqVXiaoioL2CIIrtQrmvC9hPnAAC3JXKFcuq6AE8Vwn3dIARw8Cyby4mo5zFEkV34al8phACSIv0Q4e8udTnkoMyzUft4So+IegFDFNmFL/eVAgBuSwyTuBJyZIkRvgCAvcXnpS2EiPoEhiiS3MnKeuwvqYVCLuPaUHRVkiJNFyTkna6BEELiaojI2TFEkeTMs1DXxQYiwFMlcTXkyIaG+8BVIUNVfTPOVDdKXQ4ROTmGKJKUEIKn8qjbqF0VGNp+M+K84mqJqyEiZ8cQRZI6XlGPk5V6KBVypF0bInU55ASS+ptO6e05XSNtIUTk9BiiSFLfHNACMJ3K81K7SlwNOYMLfVFsLieinsUQRZLafMgUoiYO1UhcCTmLEe0h6qhWh/rmNomrISJnxhBFkjl9To8jZToo5DKeyqNuE+KtRrivG4wC2HemRupyiMiJMUSRZDYfNM1CjR7gDz8PpcTVkDPhKT0i6g0MUSSZbw6aT+VxbSjqXuYQtZshioh6EEMUSUJb24T8MzWQyYD0wTyVR91rZFT7TNSparQZjBJXQ0TOiiGKJPFDQQUAIKGfL4K91RJXQ87mWo03fNxcoW8x4GApb0ZMRD2DIYokseWoKUT9Li5Y4krIGcnlMiRH+wMAdpw8J3E1ROSsGKKo1zW3GbCtsAoAQxT1nNEDAgAwRBFRz2GIol6Xe7IaDS0GBHupMCTMW+pyyEmltoeoXUXsiyKinsEQRb3OfCrvxkHBkMlkEldDzipO48W+KCLqUQxR1KuEEJam8ht5Ko96kFwuQwr7ooioBzFEUa86WaXH6XMNcFXIMC42UOpyyMmxL4qIehJDFPWqHwsqAQAp0QHwVLlIXA05u9G/6otqZV8UEXUzhijqVb8cN4Wo6zgLRb0gTuMFP3dTX1Q+76NHRN3MLkLUsmXLEBUVBbVajZSUFOzcufOy49etW4e4uDio1WrEx8dj06ZNVvuFEJg/fz5CQ0Ph5uaGtLQ0HD9+3GpMVFQUZDKZ1eOVV16xGrN//35cd911UKvViIiIwKJFi7rnDfdRLW1G5BZVAwBP5VGvkMtlGBcbBADYeqxS4mqIyNlIHqLWrl2LzMxMLFiwAHv27EFCQgLS09NRUVHR4fjt27dj6tSpmDlzJvbu3YuMjAxkZGTg4MGDljGLFi3Cm2++ieXLlyM3NxceHh5IT09HU1OT1bFefPFFlJWVWR5z58617NPpdJgwYQIiIyORl5eHxYsX44UXXsCKFSt65gvRB+wtPo+GFgMCPJS4VsOlDah3XN8e2BmiiKjbCYklJyeLOXPmWP5sMBhEWFiYWLhwYYfj//SnP4nJkydbbUtJSREPPfSQEEIIo9EoNBqNWLx4sWV/TU2NUKlU4tNPP7Vsi4yMFP/85z8vWde//vUv4efnJ5qbmy3bnn76aTFo0KBOv7fa2loBQNTW1nb6Oc5sybdHReTTG8Xc1XukLoX6EG1to4h8eqOIemajOFfffOUnEFGf19mf35LORLW0tCAvLw9paWmWbXK5HGlpacjJyenwOTk5OVbjASA9Pd0yvqioCFqt1mqMj48PUlJSLjrmK6+8goCAAAwfPhyLFy9GW1ub1etcf/31UCqVVq9TUFCA8+c7vjN8c3MzdDqd1YMu+Ll9lfJxMTyVR70nxFuNOI0XhAB+af87SETUHSQNUVVVVTAYDAgJCbHaHhISAq1W2+FztFrtZcebf73SMf/2t79hzZo1+OGHH/DQQw/h5ZdfxlNPPXXF1/n1a/zWwoUL4ePjY3lERERc8r33NbWNrdjX3tjLfijqbddfw74oIup+ffYa88zMTMvvhw0bBqVSiYceeggLFy6ESqWy6Zjz5s2zOq5Op2OQarfj5DkYBTAgyANhvm5Sl0N9zPWxQVix9SR+Pl4JIQRXyieibiHpTFRgYCAUCgXKy8uttpeXl0Oj0XT4HI1Gc9nx5l+7ckwASElJQVtbG06dOnXZ1/n1a/yWSqWCt7e31YNMtvFUHkloZJQf1K5ylOuaUVBeJ3U5ROQkJA1RSqUSSUlJyM7OtmwzGo3Izs5Gampqh89JTU21Gg8AWVlZlvHR0dHQaDRWY3Q6HXJzcy95TADIz8+HXC5HcHCw5XW2bt2K1tZWq9cZNGgQ/Pz8uv5m+7icE6YVo8cMZIii3qd2VVhuSJx9pOMrf4mIukryJQ4yMzPx73//Gx9++CGOHDmCv/zlL9Dr9ZgxYwYAYNq0aZg3b55l/COPPILNmzdjyZIlOHr0KF544QXs3r0bf/3rXwEAMpkMjz76KP7xj3/gyy+/xIEDBzBt2jSEhYUhIyMDgKlpfOnSpdi3bx9OnjyJTz75BI899hjuu+8+S0C65557oFQqMXPmTBw6dAhr167FG2+8YXW6jjqnqr4ZxyvqAcByLzOi3pY22NTT+P2R8iuMJCLqHMl7oqZMmYLKykrMnz8fWq0WiYmJ2Lx5s6WJu7i4GHL5haw3ZswYrF69Gs899xyeffZZxMbGYsOGDRg6dKhlzFNPPQW9Xo/Zs2ejpqYG48aNw+bNm6FWqwGYTrutWbMGL7zwApqbmxEdHY3HHnvMKiD5+Pjgu+++w5w5c5CUlITAwEDMnz8fs2fP7qWvjPPIPWlaYDNO4wU/D+UVRhP1jLRrQ/C/XxxE/pkaVNQ1IdhLLXVJROTgZEIIIXURzkqn08HHxwe1tbV9uj/q+Q0H8X87TuOBMVF44dYhUpdDfdhtb/+CfSW1eOWOeNyd3F/qcojITnX257fkp/PI+eUWmfqhzDeDJZJK2rU8pUdE3YchinpUVX0zjpWzH4rsg7kv6ufjVWhsMUhcDRE5OoYo6lE7i9gPRfYjTuOFcF83NLcZuXo5EV01hijqUTtO8lQe2Q+ZTIbft89GfXuo4zsPEBF1FkMU9SjzlXmjB/BUHtmHSUNNi+V+d0iLljajxNUQkSNjiKIeU9PQYlkdelQUQxTZh5FR/gjyUkHX1GZZSZ+IyBYMUdRj8k6fBwAMDPJAgKdt9yMk6m4KuQw3t89GbdxfJnE1ROTIGKKox+w6ZQpRnIUie3NzfCgA4LvDPKVHRLZjiKIes/uUqR8qKZL3GiT7MjLKH8FeKtQ1teGXwkqpyyEiB8UQRT2iqdWA/SW1ADgTRfZHIZdZZqN4So+IbMUQRT3iwNlatBiMCPRUITLAXepyiC4yeZgpRGUdKkdTKxfeJKKuY4iiHrHb0g/lB5lMJnE1RBdL6u+HcF831DW3IeswbwNDRF3HEEU9wtwPNZKn8shOyeUyZAwPAwBs2HtW4mqIyBExRFG3MxoFdp++MBNFZK9uH94PAPDTsUqcq2+WuBoicjQMUdTtCivrUdvYCnelAoNDvaUuh+iSYoI9MayfD9qMgg3mRNRlDFHU7Xa1n8pLjPCFi4J/xci+3T48HACwnqf0iKiL+BOOup25qZz9UOQI/pAQBoVchn1nalBYUSd1OUTkQBiiqNuZZ6LYD0WOINBThRsHBQMAPttdInE1RORIGKKoW2lrm1ByvhFyGTC8P0MUOYYpoyIAAP/JK+FtYIio0xiiqFvtPm2ahRoc5g1PlYvE1RB1zo2DghDspcI5fQu2HOWaUUTUOQxR1K0s/VCR7Icix+GikOPOJNNyB2t2nZG4GiJyFAxR1K0u9EMxRJFj+dNI0ym9rccqUVrTKHE1ROQIGKKo29Q1teJImQ4AMJJN5eRgogM9MHqAP4yCs1FE1DkMUdRt9hbXwCiACH83hHirpS6HqMvuTYkEAKzZWYxWAxvMiejyGKKo21jul8d+KHJQ6UM0CPRUoaKumTclJqIrYoiibrOT/VDk4JQuckxNNvVGfbzjtMTVEJG9Y4iibtHSZsTe4hoAQHI0+6HIcU1N7g+5DNh+4hxXMCeiy2KIom5xsLQWzW1G+HsoMTDIU+pyiGwW5uuGtGtDAAD/l8PZKCK6NIYo6ha7isz9UH6QyWQSV0N0daalRgEA1uWVoLaxVdpiiMhuMURRt+D6UORMxsYE4JoQTzS0GPAZlzsgoktgiKKrZjQK7D5tWql8VDRDFDk+mUyG/xkbDQBYtf0U2rjcARF1gCGKrlphZT1qGlrh5qrAkDBvqcsh6hYZw8Ph76HE2ZpGLndARB1iiKKrtrO9H2p4f1+4KvhXipyD2lWBe1P6AwDe+6VI4mqIyB7xJx5dtd3shyIndf/oSCgVcuSdPm/5e05EZMYQRVdt1ylTP1Qy+6HIyQR7q3HHiHAAwPKfTkhcDRHZG4YouipnaxpxtqYRCrkMiRG+UpdD1O1mXz8AMhnw/ZEKHCvn4ptEdAFDFF0V8/pQQ8O84aFykbgaou43IMgTE4doAHA2iois2UWIWrZsGaKioqBWq5GSkoKdO3dedvy6desQFxcHtVqN+Ph4bNq0yWq/EALz589HaGgo3NzckJaWhuPHj1v2nzp1CjNnzkR0dDTc3NwwcOBALFiwAC0tLVZjZDLZRY8dO3Z075t3cFwfivqCP48fCAD4Mr8UJecbJK6GiOyF5CFq7dq1yMzMxIIFC7Bnzx4kJCQgPT0dFRUVHY7fvn07pk6dipkzZ2Lv3r3IyMhARkYGDh48aBmzaNEivPnmm1i+fDlyc3Ph4eGB9PR0NDU1AQCOHj0Ko9GId999F4cOHcI///lPLF++HM8+++xFr/f999+jrKzM8khKSuqZL4SDsoQo9kORE0uI8MW4mEC0GQX+9SNno4jIRCaEEFIWkJKSglGjRuHtt98GABiNRkRERGDu3Ll45plnLho/ZcoU6PV6bNy40bJt9OjRSExMxPLlyyGEQFhYGB5//HE88cQTAIDa2lqEhIRg1apVuPvuuzusY/HixXjnnXdw8uRJAKaZqOjoaOzduxeJiYmdei/Nzc1obm62/Fmn0yEiIgK1tbXw9na+9ZPO61sw/KUsAEDec2kI8FRJXBFRz9lZVI0/vZsDV4UMPzxxA/r5uUtdEhH1EJ1OBx8fnyv+/JZ0JqqlpQV5eXlIS0uzbJPL5UhLS0NOTk6Hz8nJybEaDwDp6emW8UVFRdBqtVZjfHx8kJKScsljAqag5e9/8WzKrbfeiuDgYIwbNw5ffvnlZd/PwoUL4ePjY3lERERcdryjy2tfpXxgkAcDFDm95Gh/jBkYgFYDZ6OIyETSEFVVVQWDwYCQkBCr7SEhIdBqtR0+R6vVXna8+deuHLOwsBBvvfUWHnroIcs2T09PLFmyBOvWrcPXX3+NcePGISMj47JBat68eaitrbU8zpxx7ntumU/lcWkD6iseuSkWALBu9xn2RhER+vzlVGfPnsXEiRPxxz/+EbNmzbJsDwwMRGZmpuXPo0aNQmlpKRYvXoxbb721w2OpVCqoVH1nRmZne4gaGckQRX1DyoAAjBkYgO0nzuHN7ONYdFeC1CURkYQknYkKDAyEQqFAebn1fanKy8uh0Wg6fI5Go7nsePOvnTlmaWkpbrzxRowZMwYrVqy4Yr0pKSkoLCy84ri+oKGlDQfP1gLgTBT1LY9PGAQA+DyvhOtGEfVxkoYopVKJpKQkZGdnW7YZjUZkZ2cjNTW1w+ekpqZajQeArKwsy/jo6GhoNBqrMTqdDrm5uVbHPHv2LG644QYkJSVh5cqVkMuv/KXIz89HaGhol96js9pZVI1Wg0C4rxv6+blJXQ5Rr0mK9EP6kBAYBbBoc4HU5RCRhCQ/nZeZmYnp06dj5MiRSE5OxtKlS6HX6zFjxgwAwLRp0xAeHo6FCxcCAB555BGMHz8eS5YsweTJk7FmzRrs3r3bMpMkk8nw6KOP4h//+AdiY2MRHR2N559/HmFhYcjIyABwIUBFRkbitddeQ2VlpaUe82zVhx9+CKVSieHDhwMA1q9fjw8++ADvvfdeb31p7FrOiXMAgLExAZDJZBJXQ9S7nkyPQ9bhcnx/pBy7T1VjJNdJI+qTJA9RU6ZMQWVlJebPnw+tVovExERs3rzZ0hheXFxsNUs0ZswYrF69Gs899xyeffZZxMbGYsOGDRg6dKhlzFNPPQW9Xo/Zs2ejpqYG48aNw+bNm6FWqwGYZq4KCwtRWFiIfv36WdXz6xUfXnrpJZw+fRouLi6Ii4vD2rVrcdddd/Xkl8NhbDtRBQAYGxMocSVEvS8m2BNTRkXg051n8I+vj2D9X8ZALud/Joj6GsnXiXJmnV1nwtHUNJjWhxIC2PnsTQj2VktdElGvq9A14cbXfoS+xYDX/piAu5L6XflJROQQHGKdKHJMO06egxBAbLAnAxT1WcHeavytfcmDV745Cl1Tq8QVEVFvY4iiLttWaO6H4qk86ttmjI3GgEAPVNU3483vj1/5CUTkVBiiqMvM/VCpAwMkroRIWkoXOZ7/w2AAwMrtp3CotFbiioioNzFEUZdoa5twslIPuQwYPYAhiujGQcG4OV4Dg1Hgqc/3o81glLokIuolDFHUJVuPmZaDiO/nCx83V4mrIbIPL9w6BD5urjhUqsO/fy6Suhwi6iUMUdQlW45WAABuHBQkcSVE9iPYS43nbzGd1vvn98dwnCuZE/UJDFHUaS1tRvxSaOqHunFQsMTVENmXO0eEY/w1QWhpM2Lup3vR1GqQuiQi6mEMUdRpu09Vo765DYGeKsSH+0hdDpFdkclkWPzHYQj0VOKotg4LNx2RuiQi6mEMUdRp5lN5NwwK4urMRB0I9lLjtT8mAAA+zDmNzQfLJK6IiHoSQxR12pYCcz8UT+URXcoNg4Ix67poAMDjn+1DgZb9UUTOiiGKOuX0OT1OVuqhkMtw3TVcZJPocp6aGIfUAQHQtxjw4Ee7cF7fInVJRNQDGKKoU8yn8kZG+sFbzaUNiC7HVSHHv+4dgQh/N5ypbsTs/9uNxhY2mhM5G4Yo6pRvDmgBAL8fHCJxJUSOwc9DifemjYKXygW7Tp3Hw5/koZULcRI5FYYouiJtbRN2na4GANwcHypxNUSOY5DGCx/MGAW1qxw/FFTisbX5XNGcyIkwRNEVbTpQBiGApEg/hPm6SV0OkUMZFeWPd+5Lgotcho37y/DwJ3u4hhSRk2CIoivauL8UADCZs1BENrlxUDCW35cEpYsc3x0ux8wPd6GuqVXqsojoKjFE0WWdrWnEnuIayGQ8lUd0NdIGh2DVA6PgrlRgW+E53PGv7Sg+1yB1WUR0FRii6LI27TctFjgq0h8aH7XE1RA5tjExgVgzezSCvVQ4XlGPW5f9YrmpNxE5HoYouiQhBDbknwUA3JLAWSii7jCsny++mjsOCf18UNPQimkf7MTCTUfQ0saGcyJHwxBFl7S/pBaHSnVQKuS4ZViY1OUQOY0QbzXWPpSK+0dHAgDe3XoSGcu24UBJrcSVEVFXMETRJX2SexoAcHO8Bv4eSomrIXIualcFXsoYinfvT4KvuysOl+mQ8a9teHnTEdQ3t0ldHhF1AkMUdai2sRVf7jNdlXdf+/+Wiaj7pQ/RIOux8bhlWCgMRoEVW0/ixtd+xGe7z8BgFFKXR0SXwRBFHfpiTwmaWo0YFOKFpEg/qcshcmpBXiq8fc8IvD99JKIC3FFZ14ynPt+P37/+E/6TV8IFOonsFEMUXUQIgU9yiwEA947uD5lMJnFFRH3DTdeG4NvHrse8SXHwdXfFySo9Hl+3D79b8hPW7ipm8zmRnZEJIThf3EN0Oh18fHxQW1sLb29vqcvptG8PafHQ/+XBQ6lAzrM38YbDRBKob27D/+Wcxns/n8Q5fQsAINhLhbtHReDu5P68ewBRD+rsz2+GqB7kiCHKaBS4+c2fcVRbh7/eGIMn0gdJXRJRn9bQ0obVucV4d+tJVNY1AwBkMmB0dABuSwxD2uAQBHqqJK6SyLkwRNkBRwxRmw6Y7u3lpXLBz0/fCF93XpVHZA9a2oz47rAWH+84jR0nqy3bZTIgMcIXqQMCMKK/H0ZE+vFqWqKr1Nmf3y69WBPZOYNR4J9ZxwAA/zMumgGKyI4oXUzrtd0yLAxnqhvw1f5SbDpQhoNnddhbXIO9xTWWsdGBHkjo54OBQZ6IDvLAgEBPRAd6wE2pkO4NEDkhhiiyWLOrGMcr6uGtdsHM66KlLoeILiHC3x0P3xCDh2+Igba2CT8dq8DuU+exp/g8TlTqUVRlevxWmI8aA4I8MSDIA7HBnhgY7InYYC8Eeip5AQldkq6pFXtOn8fe4hpoa5twTt8MQIZATyVCfdwwKtoPI/r7Qe3a90I6T+f1IEc6nVdyvgHp/9wKfYsB828ZjP8ZxxBF5IhqGlqw90wNDpfqUFSlx8nKepys0qOmofWSz/F1d8XQMB8M6+eDYf18kRDhA423msGqDzMYBbYeq8Qnuaex5WgFrrRkmdJFjgmDQzA1uT9SBwRALnfsvzvsibIDjhKihBCY9sFO/Hy8CiMj/bD2oVQoHPwfABFZO69vwcmqepyo1ONEZT1OVNTjeEU9zlQ3dPgDMthLhaRIP8tjSJgPlC5cFcdmzXVAaT4QEAOcKwTCEgGVV9ePoysDct8F6suB6zIBpSdwaD0w5A7AuxP3OG2uA05vN/0+csxFNVTWNeOLHUdxYNdP2KILgx6mq0AjA9wxMtIf0YHu8PdQYdzWPyFcfwTHZLGY7vIKKtovegCAOI0XHp8wCGnXBjtsEGdPFHXaRzmn8fPxKqhc5Fh01zAGKCIn5OehRJKHP5Ii/a22N7UaUFhRj/0ltdhfUoN9JbU4Vl6HirpmfHNQi28OagGYZhoS+vlgRKQfktob2HlVYBe06IFTvwBqH9OvgbG2hSh9JXD8O0BfBcT/EfAIBI5+DURd17kQ1aIHirYCAkBoAqDyghACO05W45Pc0/j2kBa+hmrc67IXh9UhuGFkNO5J6Y+BQZ7Wx/m2CABwrewMcp+9CYdKdVizqxgb9pbiqLYOsz7ajcQIXzyVPghjYgK7/j4dBENUH/fdIS3+/tUhAMCT6YMw4Lf/UIjIqaldFRga7oOh4T64J6U/AKCxxYADZ2uRd/o88k6beq2q9S3Ydeo8dp06b3luPz83XBPihdgQT1wTbPo13NcN/h7ssXIE5xta8MW+InySexonKi/00MWH+2BCgAZ/njgOav/wKx5HJpNhaLgP/hEejycnxOHdrSewctsp5J+pwT3v5WJsTACeSo9DQoRvD74baTBE9WF5p6sx99O9MArg7lERmMk+KCIC4KZUIDnaH8nRplkrIQSKqvSWQJV3+jyOldej5HwjSs43YsvRCqvnKxVyBHmpoPFRI8BDCU+VC9xVCnioXOChdLHMdptzlgwyy++NQsBoFDAY238vBAxGAaPAr35vGmMOanKZDHIZIJfLIIPph7pcZtouk1n/GTAtF9HcZkBzmxHNrabftxjMv794X3Obsf05RhiMAh6/ei+eKhfLn73U7dvUpu1eahd4qlzhqXaBr6EW/fTNaK1rgldLG0RzK5RuRrgqZL0aOCt0zTivrUNRVT3+vvVnlBl9AQDuSgUyhofj3pT+GOLVCOw+CNjQKO7j7oqnJsbhgbFR+NcPJ/BJ7mlsKzyH2wq34eZ4DZ6Y4Fz/WWeI6qP+m38WT/9nP5rbjPhdXDD+kTGU/3Mkog7JZLL2q/o88ceREQCA2oZWHNHqcLy8DsfK63G8og6FFXpU1TejxWDE2ZpGnK1plLjyntHYakBVfUuXnhOE87jX5TQ2/7ILE11O4pMffkIl/CCXASoXBdSucqhcFFC5yqH+za+/3h7ddgJ/1DXD09CG7Ucq4OIlkNjQgpKzOhjbauCikEEIoLnNgPpmAyp0TSirbUKBtg6Hy3SoryrBLJdKAAJtRoEhYd64O7k/MhLD4GW+O0Xd1X9uwV5qvHDrEDx4XTT+mXUc6/eWYNMBLb49VI4/jYzAIzfFQuOjvurXkRpDVB9T19SK17OOYeW2UwCA8dcE4e17hsNFwYZRIuo8H3dXjB4QgNEDAqy2t7QZUVHXhHJdMyp0TTinb0FDSxvqmw1oaG6DvsUAo1FAQEAIU2sOgPbfCyhkMtPMklwGhdw8yySDQn5htsk8BjA9xzxLJYRp1qyjP5vHCQGoXOSmcKKQQ+WqMP3Z5UJYUSrkF8LLb7bLZTLoW9qgb25DfXMbGloMqG9u/3NTG+pb2n9t/3Nd+6+qpia4NSmg/M0ta43CFMoaWw0ALn0FpVkcyvA7ZTOErA0rtxWhGufwgrIOL3y+D0dRe8XnB8uAYE8V+vm747Pfj0Z0dEynPm9b9fNzx5I/JWDW9dFYvLkA2Ucr8OnOYnyedwa3JYbjweuiEaex3wuvrsQuQtSyZcuwePFiaLVaJCQk4K233kJycvIlx69btw7PP/88Tp06hdjYWLz66qu4+eabLfuFEFiwYAH+/e9/o6amBmPHjsU777yD2NhYy5jq6mrMnTsXX331FeRyOe6880688cYb8PS8MM24f/9+zJkzB7t27UJQUBDmzp2Lp556qme+CD2srqkVn+eV4K0thahuvw/XnBsHIvP3g9hITkTdRukiRz8/d/Tzc5e6FPtSpwV2H8NDcWMhjp7HnxNuRLNbMJpbTacLmy7xa3ObAU2tRjS3GtDUZoTHOSP8jynh1qLAyCh/VBg84HHeBeEebqgTbmgzmm5SrXZVwM1VgSAvFUK81YgJ9sS1od5I9G2Ez94jpvQa2Hun1eI03nj/gVHYWVSN174twM5T1fg8rwSf55VgWD8f3DmiH34/OMTh7gkpeYhau3YtMjMzsXz5cqSkpGDp0qVIT09HQUEBgoODLxq/fft2TJ06FQsXLsQtt9yC1atXIyMjA3v27MHQoUMBAIsWLcKbb76JDz/8ENHR0Xj++eeRnp6Ow4cPQ602TR/ee++9KCsrQ1ZWFlpbWzFjxgzMnj0bq1evBmC6vHHChAlIS0vD8uXLceDAAfzP//wPfH19MXv27N77Atno1z0MPx2rRNbhcjS33wF+QKAHnrvlWvwuLkTiKomI+h4ZZFC7KqB2cwXcuniD9zI9oFUDeldkpsWars7b7IP3J44EQodd+fl1WtuK7ibJ0f747M+p2FN8Hu/9fBLfHSpvvzK0Fgu+PIQ4jRdGDwhAYoQvBod5IzLAHSoX+13EU/J1olJSUjBq1Ci8/fbbAACj0YiIiAjMnTsXzzzzzEXjp0yZAr1ej40bN1q2jR49GomJiVi+fDmEEAgLC8Pjjz+OJ554AgBQW1uLkJAQrFq1CnfffTeOHDmCwYMHY9euXRg5ciQAYPPmzbj55ptRUlKCsLAwvPPOO/jf//1faLVaKJWm258888wz2LBhA44ePdqp99YT60QJIfDF3rNoajX9T6Wp/X8pTa0GnNe3oFrfgrM1jTh9rqF9eviCAUEe+J+x0ZgyKgKuPH1HRNR76rTA7pVA3GTTkgQjZwBemq4fp2w/8MWfTUsc3L68PUQ9A0x8pfMhavtbppmosXM7rsFc6+VqfDEEMDYBcjUwv7zr76Pdufpm/De/FBv3l2LvmRr8NpHIZUCojxsCPJUI8FDC30OFAE/TxQpurgqolQpMGRnR7WuYOcQ6US0tLcjLy8O8efMs2+RyOdLS0pCTk9Phc3JycpCZmWm1LT09HRs2bAAAFBUVQavVIi0tzbLfx8cHKSkpyMnJwd13342cnBz4+vpaAhQApKWlQS6XIzc3F7fffjtycnJw/fXXWwKU+XVeffVVnD9/Hn5+fhfV1tzcjObmCwuO1daazk/rdLoufFWu7MnVO9BquHL2dXWRY2ioN4ZH+mHC4GAMCfOBTCZDo74eztnuSURkp+rqAH0TUFdv+lVXBwgbTnnW1QONbUCTAajTA0Y10Nhq2u7RiZ81dXWAvtkUoi5Vg7nWy9XYZDQ1mMmMwFX8jHMFcNewANw1LADV+hbknjyH/JIaHCipxYnKeuibDDjT1IAzl8lpE6/x7vbZKvPP7SvNM0kaoqqqqmAwGBASYn1aKSQk5JKzPVqttsPxWq3Wst+87XJjfnuq0MXFBf7+/lZjoqOjLzqGeV9HIWrhwoX4+9//ftH2iIiIDt9LbzgJ4EsAF1dFRES978Xf/HoV5t/6qz98b8MBllxhf2dqrAMW+tjw2t0neGnPHbuurg4+Ppd+f5L3RDmTefPmWc2SGY1GVFdXIyAgoNeXD9DpdIiIiMCZM2fs+pYzfQ0/F/vEz8U+8XOxX87+2QghUFdXh7CwsMuOkzREBQYGQqFQoLzcep6uvLwcGk3H52E1Gs1lx5t/LS8vR2hoqNWYxMREy5iKCuvF4dra2lBdXW11nI5e59ev8VsqlQoqlfVtEHx9fTsc21u8vb2d8i+4o+PnYp/4udgnfi72y5k/m8vNQJlJ2l2sVCqRlJSE7Oxsyzaj0Yjs7GykpqZ2+JzU1FSr8QCQlZVlGR8dHQ2NRmM1RqfTITc31zImNTUVNTU1yMvLs4zZsmULjEYjUlJSLGO2bt2K1tZWq9cZNGhQh6fyiIiIqI8REluzZo1QqVRi1apV4vDhw2L27NnC19dXaLVaIYQQ999/v3jmmWcs47dt2yZcXFzEa6+9Jo4cOSIWLFggXF1dxYEDByxjXnnlFeHr6yv++9//iv3794vbbrtNREdHi8bGRsuYiRMniuHDh4vc3Fzxyy+/iNjYWDF16lTL/pqaGhESEiLuv/9+cfDgQbFmzRrh7u4u3n333V74qly92tpaAUDU1tZKXQr9Cj8X+8TPxT7xc7Ff/GxMJA9RQgjx1ltvif79+wulUimSk5PFjh07LPvGjx8vpk+fbjX+s88+E9dcc41QKpViyJAh4uuvv7babzQaxfPPPy9CQkKESqUSN910kygoKLAac+7cOTF16lTh6ekpvL29xYwZM0RdXZ3VmH379olx48YJlUolwsPDxSuvvNK9b7wHNTU1iQULFoimpiapS6Ff4edin/i52Cd+LvaLn42J5OtEERERETkirrhIREREZAOGKCIiIiIbMEQRERER2YAhioiIiMgGDFFOaNmyZYiKioJarUZKSgp27twpdUl9ygsvvACZTGb1iIuLs+xvamrCnDlzEBAQAE9PT9x5550XLexK3WPr1q34wx/+gLCwMMhkMss9Ns2EEJg/fz5CQ0Ph5uaGtLQ0HD9+3GpMdXU17r33Xnh7e8PX1xczZ85EfX19L74L53Olz+WBBx646N/QxIkTrcbwc+l+CxcuxKhRo+Dl5YXg4GBkZGSgoKDAakxnvn8VFxdj8uTJcHd3R3BwMJ588km0tbX15lvpNQxRTmbt2rXIzMzEggULsGfPHiQkJCA9Pf2iFdqpZw0ZMgRlZWWWxy+//GLZ99hjj+Grr77CunXr8NNPP6G0tBR33HGHhNU6L71ej4SEBCxbtqzD/YsWLcKbb76J5cuXIzc3Fx4eHkhPT0dTU5NlzL333otDhw4hKysLGzduxNatWzF79uzeegtO6UqfCwBMnDjR6t/Qp59+arWfn0v3++mnnzBnzhzs2LEDWVlZaG1txYQJE6DX6y1jrvT9y2AwYPLkyWhpacH27dvx4YcfYtWqVZg/f74Ub6nnSbzEAnWz5ORkMWfOHMufDQaDCAsLEwsXLpSwqr5lwYIFIiEhocN9NTU1wtXVVaxbt86y7ciRIwKAyMnJ6aUK+yYA4osvvrD82Wg0Co1GIxYvXmzZVlNTI1Qqlfj000+FEEIcPnxYABC7du2yjPnmm2+ETCYTZ8+e7bXandlvPxchhJg+fbq47bbbLvkcfi69o6KiQgAQP/30kxCic9+/Nm3aJORyuWXBbCGEeOedd4S3t7dobm7u3TfQCzgT5URaWlqQl5eHtLQ0yza5XI60tDTk5ORIWFnfc/z4cYSFhWHAgAG49957UVxcDADIy8tDa2ur1WcUFxeH/v378zPqZUVFRdBqtVafhY+PD1JSUiyfRU5ODnx9fTFy5EjLmLS0NMjlcuTm5vZ6zX3Jjz/+iODgYAwaNAh/+ctfcO7cOcs+fi69o7a2FgDg7+8PoHPfv3JychAfH4+QkBDLmPT0dOh0Ohw6dKgXq+8dDFFOpKqqCgaDweovLwCEhIRAq9VKVFXfk5KSglWrVmHz5s145513UFRUhOuuuw51dXXQarVQKpUX3Zian1HvM3+9L/fvRavVIjg42Gq/i4sL/P39+Xn1oIkTJ+Kjjz5CdnY2Xn31Vfz000+YNGkSDAYDAH4uvcFoNOLRRx/F2LFjMXToUADo1PcvrVbb4b8p8z5n4yJ1AUTOZtKkSZbfDxs2DCkpKYiMjMRnn30GNzc3CSsjcgx333235ffx8fEYNmwYBg4ciB9//BE33XSThJX1HXPmzMHBgwet+jnpYpyJciKBgYFQKBQXXSlRXl4OjUYjUVXk6+uLa665BoWFhdBoNGhpaUFNTY3VGH5Gvc/89b7cvxeNRnPRRRltbW2orq7m59WLBgwYgMDAQBQWFgLg59LT/vrXv2Ljxo344Ycf0K9fP8v2znz/0mg0Hf6bMu9zNgxRTkSpVCIpKQnZ2dmWbUajEdnZ2UhNTZWwsr6tvr4eJ06cQGhoKJKSkuDq6mr1GRUUFKC4uJifUS+Ljo6GRqOx+ix0Oh1yc3Mtn0VqaipqamqQl5dnGbNlyxYYjUakpKT0es19VUlJCc6dO4fQ0FAA/Fx6ihACf/3rX/HFF19gy5YtiI6Ottrfme9fqampOHDggFXIzcrKgre3NwYPHtw7b6Q3Sd3ZTt1rzZo1QqVSiVWrVonDhw+L2bNnC19fX6srJahnPf744+LHH38URUVFYtu2bSItLU0EBgaKiooKIYQQf/7zn0X//v3Fli1bxO7du0VqaqpITU2VuGrnVFdXJ/bu3Sv27t0rAIjXX39d7N27V5w+fVoIIcQrr7wifH19xX//+1+xf/9+cdttt4no6GjR2NhoOcbEiRPF8OHDRW5urvjll19EbGysmDp1qlRvySlc7nOpq6sTTzzxhMjJyRFFRUXi+++/FyNGjBCxsbGiqanJcgx+Lt3vL3/5i/Dx8RE//vijKCsrszwaGhosY670/autrU0MHTpUTJgwQeTn54vNmzeLoKAgMW/ePCneUo9jiHJCb731lujfv79QKpUiOTlZ7NixQ+qS+pQpU6aI0NBQoVQqRXh4uJgyZYooLCy07G9sbBQPP/yw8PPzE+7u7uL2228XZWVlElbsvH744QcB4KLH9OnThRCmZQ6ef/55ERISIlQqlbjppptEQUGB1THOnTsnpk6dKjw9PYW3t7eYMWOGqKurk+DdOI/LfS4NDQ1iwoQJIigoSLi6uorIyEgxa9asi/4jyM+l+3X0mQAQK1eutIzpzPevU6dOiUmTJgk3NzcRGBgoHn/8cdHa2trL76Z3yIQQordnv4iIiIgcHXuiiIiIiGzAEEVERERkA4YoIiIiIhswRBERERHZgCGKiIiIyAYMUUREREQ2YIgiIiIisgFDFBEREZENGKKIiIiIbMAQRUR0CVqtFo888ghiYmKgVqsREhKCsWPH4p133kFDQwMAICoqCjKZDDKZDO7u7oiPj8d7770nceVE1BtcpC6AiMgenTx5EmPHjoWvry9efvllxMfHQ6VS4cCBA1ixYgXCw8Nx6623AgBefPFFzJo1Cw0NDVi3bh1mzZqF8PBwTJo0SeJ3QUQ9iffOIyLqwMSJE3Ho0CEcPXoUHh4eF+0XQkAmkyEqKgqPPvooHn30Ucu+gIAATJ8+Ha+//novVkxEvY2n84iIfuPcuXP47rvvMGfOnA4DFADIZLKLthmNRvznP//B+fPnoVQqe7pMIpIYQxQR0W8UFhZCCIFBgwZZbQ8MDISnpyc8PT3x9NNPW7Y//fTT8PT0hEqlwl133QU/Pz88+OCDvV02EfUyhigiok7auXMn8vPzMWTIEDQ3N1u2P/nkk8jPz8eWLVuQkpKCf/7zn4iJiZGwUiLqDWwsJyL6jZiYGMhkMhQUFFhtHzBgAADAzc3NantgYCBiYmIQExODdevWIT4+HiNHjsTgwYN7rWYi6n2ciSIi+o2AgAD8/ve/x9tvvw29Xt+l50ZERGDKlCmYN29eD1VHRPaCIYqIqAP/+te/0NbWhpEjR2Lt2rU4cuQICgoK8PHHH+Po0aNQKBSXfO4jjzyCr776Crt37+7Fiomot3GJAyKiSygrK8PLL7+Mr7/+GiUlJVCpVBg8eDD++Mc/4uGHH4a7u3uHSxwApiUS5HI5Nm3aJE3xRNTjGKKIiIiIbMDTeUREREQ2YIgiIiIisgFDFBEREZENGKKIiIiIbMAQRURERGQDhigiIiIiGzBEEREREdmAIYqIiIjIBgxRRERERDZgiCIiIiKyAUMUERERkQ3+PzQC3cp1Z36uAAAAAElFTkSuQmCC", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["import seaborn as sns\n", "\n", "sns.kdeplot(df['GR'])\n", "sns.rugplot(df.loc[outliers, 'GR'], c='C1', lw=5, alpha=0.5)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["By default it uses an [**isolation forest**](https://scikit-learn.org/stable/modules/outlier_detection.html#isolation-forest) to detect the outliers at the 99% confidence level, but you can also opt to use **local outlier factor**, **elliptic envelope**, or **Mahalanobis distance**, setting the confidence level to choose how many outliers you will see, or (equivalently) setting the `threshold` to the number of standard deviations away from the mean you regard as signal.\n", "\n", "The function accepts univariate or multivariate data:"]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n"]}, {"data": {"text/plain": [""]}, "execution_count": 11, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["features = ['GR', 'PE']\n", "\n", "outliers = rf.get_outliers(df[features], method='mah', threshold=5)\n", "\n", "sns.jointplot(data=df, x='GR', y='PE', hue=rf.index_to_bool(outliers, n=len(df)))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["A helper function can compute the number of expected outliers, given the dataset size and assuming a Gaussian distribution of samples."]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["We have 80 outliers, but expect:\n"]}, {"data": {"text/plain": ["44"]}, "execution_count": 12, "metadata": {}, "output_type": "execute_result"}], "source": ["print(f\"We have {len(outliers)} outliers, but expect:\")\n", "rf.expected_outliers(*df[features].shape, threshold=3)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["So we have more than expected — because the distribution of GR has a lot of clipped samples at a value of 200. A dataset with truncated tails will have fewer than expected outliers; we can test this directly with the `has_outliers()` function, which compares the results of `expected_outliers()` with `get_outliers()`:"]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [{"data": {"text/plain": ["100"]}, "execution_count": 13, "metadata": {}, "output_type": "execute_result"}], "source": ["import numpy as np\n", "\n", "data = np.random.normal(size=10_000)\n", "\n", "rf.expected_outliers(len(data), d=1, p=0.99)"]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": ["# Truncate\n", "data = data[(-2.5 < data) & (data < 2.5)]"]}, {"cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", "The figure layout has changed to tight\n"]}, {"data": {"text/plain": [""]}, "execution_count": 15, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["sns.displot(data)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This truncated normal distribution has no outliers (there are only about 60, compared to the 100 we expect at this confidence level of 99% on this dataset of 10,000 records)."]}, {"cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [{"data": {"text/plain": ["False"]}, "execution_count": 16, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.has_outliers(data, p=0.99)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Clipping\n", "\n", "If a feature has been clipped, it will have multiple instances at its min and/or max value. There are legitimate reasons why this might happen, for example the feature may be naturally bounded (e.g. porosity is always greater than 0), or the feature may have been deliberately clipped as part of the data preparation process."]}, {"cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [{"data": {"text/plain": ["True"]}, "execution_count": 17, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.is_clipped(df['GR'])"]}, {"cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", "The figure layout has changed to tight\n"]}, {"data": {"text/plain": [""]}, "execution_count": 18, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["import seaborn as sns\n", "\n", "sns.displot(df['GR'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Distribution shape\n", "\n", "Tries to guess the shape of the distribution from the following set from `scipy.stats`:\n", "\n", "- `'norm'`\n", "- `'cosine'`\n", "- `'expon'`\n", "- `'exponpow'`\n", "- `'gamma'`\n", "- `'gumbel_l'`\n", "- `'gumbel_r'`\n", "- `'powerlaw'`\n", "- `'triang'`\n", "- `'trapz'`\n", "- `'uniform'`\n", "\n", "The name is returned, along with the shape parameters (if any), location and scale.\n", "\n", "In spite of the outliers, we find that the distribution of GR values is nearly normal:"]}, {"cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [{"data": {"text/plain": ["Distribution(name='norm', shape=[], loc=64.36789939485628, scale=28.411020184908292)"]}, "execution_count": 19, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.best_distribution(df['GR'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["In contrast, the PHIND data is skewed andbest modeled by the [Gumbel distribution](https://en.wikipedia.org/wiki/Gumbel_distribution)."]}, {"cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [{"data": {"text/plain": ["Distribution(name='gumbel_r', shape=[], loc=10.040572536302586, scale=4.93432972751726)"]}, "execution_count": 20, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.best_distribution(df['PHIND'])"]}, {"cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", "use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", "The figure layout has changed to tight\n"]}, {"data": {"text/plain": [""]}, "execution_count": 21, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["sns.displot(df['PHIND'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Identical distribution assumption\n", "\n", "We'd often like to test the implicit assumption that our data are 'identically distributed' across various groups, with respect to both the labels and the features.\n", "\n", "`redflag.wasserstein()` facilitates calculating the first Wasserstein distance (aka earth-mover's distance) between groups, e.g. between train and test datasets. It returns a score for each feature; scores greater than 1 can be interpreted as substantial differences in the distribution."]}, {"cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[0.25985545, 0.28404634, 0.49139232, 0.33701782],\n", " [0.22736457, 0.13473663, 0.33672956, 0.20969657],\n", " [0.41216725, 0.34568777, 0.39729747, 0.48092099],\n", " [0.0801856 , 0.10675027, 0.13740318, 0.10325295],\n", " [0.19913347, 0.21828753, 0.26995735, 0.33063277],\n", " [0.24612402, 0.23889923, 0.26699721, 0.2350674 ],\n", " [0.20666445, 0.44112543, 0.16229232, 0.63527036],\n", " [0.18187639, 0.34992043, 0.19400917, 0.74988182],\n", " [0.31761526, 0.27206283, 0.30255291, 0.24779581]])"]}, "execution_count": 22, "metadata": {}, "output_type": "execute_result"}], "source": ["wells = df['Well Name']\n", "features = ['GR', 'RHOB', 'ILD_log10', 'PE']\n", "\n", "w = rf.wasserstein(df[features], groups=wells, standardize=True)\n", "w"]}, {"cell_type": "markdown", "metadata": {}, "source": ["You could plot this as a heatmap:"]}, {"cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [{"data": {"text/plain": [""]}, "execution_count": 23, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["sns.heatmap(w, yticklabels=np.unique(wells), xticklabels=features)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This shows us that the distributions of the PE log in well indices 6 and 7 are somewhat different and may be anomalous. It also suggests that the CROSS H CATTLE well is different from the others."]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Already split out group arrays\n", "\n", "If you have groups that are already split out, e.g. train and test datasets:"]}, {"cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": ["from sklearn.model_selection import train_test_split\n", "from sklearn.preprocessing import StandardScaler\n", "\n", "X_train, X_ = train_test_split(df[features], test_size=0.4, random_state=42)\n", "\n", "# NOTE: We're doing a random split here for illustration purposes only.\n", "# This is not a valid way to split the dataset, because rows are not indepedent.\n", "X_val, X_test = train_test_split(X_, test_size=0.5, random_state=42)\n", "\n", "# The data should be standardized to compare Wasserstein distance between features.\n", "scaler = StandardScaler()\n", "X_train = scaler.fit_transform(X_train)\n", "X_val = scaler.transform(X_val)\n", "X_test = scaler.transform(X_test)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["In this case, you can pass them into the function as a list or tuple:"]}, {"cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[0.03860982, 0.02506236, 0.04321734, 0.03437337],\n", " [0.04402681, 0.02528225, 0.0385111 , 0.05694201],\n", " [0.04388196, 0.049464 , 0.05560379, 0.04002712]])"]}, "execution_count": 25, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.wasserstein([X_train, X_val, X_test])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The numbers are all quite low because we sampled randomly from the data."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Independence assumption\n", "\n", "If a feature is correlated to lagged (shifted) versions of itself, then the dataset may be ordered by that feature, or the records may not be independent. If several features are correlated to themselves, then the data instances may not be independent."]}, {"cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [{"data": {"text/plain": ["True"]}, "execution_count": 26, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.is_correlated(df['GR'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This is order-dependent. That is, shuffling the data removes the correlation, but does not mean the records are independent."]}, {"cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [{"data": {"text/plain": ["False"]}, "execution_count": 27, "metadata": {}, "output_type": "execute_result"}], "source": ["gr = df['GR'].to_numpy(copy=True)\n", "np.random.shuffle(gr)\n", "rf.is_correlated(gr)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Feature importance\n", "\n", "We'd like to know which features are the most important.\n", "\n", "`redflag` trains a series of models on your data, assessing which features are most important. It then normalizes and averages the results. \n", "\n", "To serve as a 'control', let's add a column of small random numbers that we know is not useful. We'd expect this column to come out with very low importance (i.e. close to zero)."]}, {"cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": ["df['Random'] = np.random.normal(scale=0.1, size=len(df))\n", "df['Constant'] = -1"]}, {"cell_type": "markdown", "metadata": {}, "source": ["First, a **classification task**. Imagine we're trying to predict lithology from well logs. Which are the most important logs?"]}, {"cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([0.28547027, 0.28342166, 0.32686674, 0.09151957, 0. ])"]}, "execution_count": 29, "metadata": {}, "output_type": "execute_result"}], "source": ["features = ['GR', 'ILD_log10', 'PE', 'Random', 'Constant']\n", "\n", "X = df[features]\n", "y = df['Lithology']\n", "\n", "importances = rf.feature_importances(X, y, random_state=13)\n", "importances"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This tells us that the most important features are, in order: PE, ILD, GR, with the random and constant variables unsurprisingly useless.\n", "\n", "There's a function to help us decide which are the least important features; it returns the indices of the least useful features, in order (least useful first):"]}, {"cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([4, 3])"]}, "execution_count": 30, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.least_important_features(importances)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["And a complementary function reporting the most important:"]}, {"cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([2, 0, 1, 3])"]}, "execution_count": 31, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.most_important_features(importances)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now we'll look at a **regression task**. We'll try to predict RHOB from the other logs (including the dummy variables). The function guesses that this is a regression task:"]}, {"cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([0.08772211, 0.35620195, 0.53119438, 0.02488155, 0. ])"]}, "execution_count": 32, "metadata": {}, "output_type": "execute_result"}], "source": ["features = ['GR', 'ILD_log10', 'PE', 'Random', 'Constant']\n", "\n", "X = df[features]\n", "y = df['RHOB']\n", "\n", "rf.feature_importances(X, y)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The most predictive features are PE and ILD, with GR substantially less important. Again, the random and constant variables are the least important feature."]}], "metadata": {"kernelspec": {"display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.5"}, "vscode": {"interpreter": {"hash": "3ad933181bd8a04b432d3370b9dc3b0662ad032c4dfaa4e4f1596c548f763858"}}}, "nbformat": 4, "nbformat_minor": 4}
\ No newline at end of file
diff --git a/_sources/_notebooks/Tutorial.ipynb.txt b/_sources/_notebooks/Tutorial.ipynb.txt
index 2a08767..4f29c4a 100644
--- a/_sources/_notebooks/Tutorial.ipynb.txt
+++ b/_sources/_notebooks/Tutorial.ipynb.txt
@@ -1 +1 @@
-{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# Tutorial\n", "\n", "We're going to look at some features of `redflag`, a library for helping find problems in machine learning pipelines.\n", "\n", "You'll need the following packages to run the code in this tutorial:\n", "\n", "- `redflag`\n", "- `pandas`\n", "- `seaborn`\n", "\n", "\n", "## A simple ML workflow\n", "\n", "First, let's see how we can burn ourselves:"]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/plain": ["array(['ss', 'ss', 'ss', 'ms', 'ms', 'ss'], dtype='\n", "\n", "\n", " \n", " \n", " \n", " Well Name \n", " Depth \n", " Formation \n", " RelPos \n", " Marine \n", " GR \n", " ILD \n", " DeltaPHI \n", " PHIND \n", " PE \n", " Facies \n", " LATITUDE \n", " LONGITUDE \n", " ILD_log10 \n", " Lithology \n", " RHOB \n", " Mineralogy \n", " Siliciclastic \n", " \n", " \n", " \n", " \n", " 0 \n", " SHRIMPLIN \n", " 851.3064 \n", " A1 SH \n", " 1.000 \n", " 1 \n", " 77.45 \n", " 4.613176 \n", " 9.9 \n", " 11.915 \n", " 4.6 \n", " 3.0 \n", " 37.978076 \n", " -100.987305 \n", " 0.664 \n", " siltstone \n", " 2393.499945 \n", " siliciclastic \n", " True \n", " \n", " \n", " 1 \n", " SHRIMPLIN \n", " 851.4588 \n", " A1 SH \n", " 0.979 \n", " 1 \n", " 78.26 \n", " 4.581419 \n", " 14.2 \n", " 12.565 \n", " 4.1 \n", " 3.0 \n", " 37.978076 \n", " -100.987305 \n", " 0.661 \n", " siltstone \n", " 2416.119814 \n", " siliciclastic \n", " True \n", " \n", " \n", " 2 \n", " SHRIMPLIN \n", " 851.6112 \n", " A1 SH \n", " 0.957 \n", " 1 \n", " 79.05 \n", " 4.549881 \n", " 14.8 \n", " 13.050 \n", " 3.6 \n", " 3.0 \n", " 37.978076 \n", " -100.987305 \n", " 0.658 \n", " siltstone \n", " 2404.576056 \n", " siliciclastic \n", " True \n", " \n", " \n", " 3 \n", " SHRIMPLIN \n", " 851.7636 \n", " A1 SH \n", " 0.936 \n", " 1 \n", " 86.10 \n", " 4.518559 \n", " 13.9 \n", " 13.115 \n", " 3.5 \n", " 3.0 \n", " 37.978076 \n", " -100.987305 \n", " 0.655 \n", " siltstone \n", " 2393.249071 \n", " siliciclastic \n", " True \n", " \n", " \n", " 4 \n", " SHRIMPLIN \n", " 851.9160 \n", " A1 SH \n", " 0.915 \n", " 1 \n", " 74.58 \n", " 4.436086 \n", " 13.5 \n", " 13.300 \n", " 3.4 \n", " 3.0 \n", " 37.978076 \n", " -100.987305 \n", " 0.647 \n", " siltstone \n", " 2382.602601 \n", " siliciclastic \n", " True \n", " \n", " \n", "
\n", ""], "text/plain": [" Well Name Depth Formation RelPos Marine GR ILD DeltaPHI \\\n", "0 SHRIMPLIN 851.3064 A1 SH 1.000 1 77.45 4.613176 9.9 \n", "1 SHRIMPLIN 851.4588 A1 SH 0.979 1 78.26 4.581419 14.2 \n", "2 SHRIMPLIN 851.6112 A1 SH 0.957 1 79.05 4.549881 14.8 \n", "3 SHRIMPLIN 851.7636 A1 SH 0.936 1 86.10 4.518559 13.9 \n", "4 SHRIMPLIN 851.9160 A1 SH 0.915 1 74.58 4.436086 13.5 \n", "\n", " PHIND PE Facies LATITUDE LONGITUDE ILD_log10 Lithology \\\n", "0 11.915 4.6 3.0 37.978076 -100.987305 0.664 siltstone \n", "1 12.565 4.1 3.0 37.978076 -100.987305 0.661 siltstone \n", "2 13.050 3.6 3.0 37.978076 -100.987305 0.658 siltstone \n", "3 13.115 3.5 3.0 37.978076 -100.987305 0.655 siltstone \n", "4 13.300 3.4 3.0 37.978076 -100.987305 0.647 siltstone \n", "\n", " RHOB Mineralogy Siliciclastic \n", "0 2393.499945 siliciclastic True \n", "1 2416.119814 siliciclastic True \n", "2 2404.576056 siliciclastic True \n", "3 2393.249071 siliciclastic True \n", "4 2382.602601 siliciclastic True "]}, "execution_count": 5, "metadata": {}, "output_type": "execute_result"}], "source": ["import pandas as pd\n", "\n", "df = pd.read_csv('https://geocomp.s3.amazonaws.com/data/Panoma_training_data.csv')\n", "\n", "df.head()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["For later use, I'm going to add a spurious column to the data:"]}, {"cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": ["import numpy as np\n", "\n", "rng = np.random.default_rng(42)\n", "\n", "df['Noise'] = rng.normal(size=len(df))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Imbalance metrics\n", "\n", "`redflag` has some algorithms for various tasks, such as:\n", "\n", "- Imbalance metrics\n", "- Flagging data problems\n", "- Outlier detection\n", "- Distribution shape\n", "- Feature importance\n", "\n", "Let's look at imbalance first."]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [{"data": {"text/plain": ["3.378593040846633"]}, "execution_count": 7, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.imbalance_degree(df['Lithology'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["To interpret this number, split it into two parts:\n", "\n", "- The integer part, 3, is equal to $m - 1$, where $m$ is the number of minority classes.\n", "- The fractional part, 0.378..., is a measure of the amount of imbalance, where 0 means the dataset is balanced perfectly and 0.999... is really bad.\n", "\n", "If the imbalance degree is -1 then there are no minority classes and all the classes have equal support.\n", "\n", "In general, this statistic is more informative than the commonly used 'imbalance ratio' (`rf.imbalance_ratio()`), which is the ratio of support in the maximum majority class to that in the minimum minority class, with no regard for the support of the other classes."]}, {"cell_type": "markdown", "metadata": {}, "source": ["We can get the minority classes, which are those with fewer samples than expected. These are returned in order, smallest first:"]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [{"data": {"text/plain": ["array(['dolomite', 'sandstone', 'mudstone', 'wackestone'], dtype='"]}, "execution_count": 10, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["import seaborn as sns\n", "\n", "sns.displot(df['GR'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Independence assumption\n", "\n", "If a feature is correlated to lagged (shifted) versions of itself, then the dataset may be ordered by that feature, or the records may not be independent. If several features are correlated to themselves, then the data instances may not be independent."]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"data": {"text/plain": ["True"]}, "execution_count": 11, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.is_correlated(df['GR'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This is order-dependent. That is, shuffling the data removes the correlation:"]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [{"data": {"text/plain": ["False"]}, "execution_count": 12, "metadata": {}, "output_type": "execute_result"}], "source": ["import numpy as np\n", "\n", "gr = df['GR'].to_numpy(copy=True)\n", "np.random.shuffle(gr)\n", "rf.is_correlated(gr)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["But this does not mean the records are independent — the only way around this issue is to split the data differently."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Importance\n", "\n", "We might like to see which of our features are more useful. There's a function for that:"]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([0.42028113, 0.2001267 , 0.3180724 , 0.06151976])"]}, "execution_count": 13, "metadata": {}, "output_type": "execute_result"}], "source": ["features = ['GR', 'RHOB', 'PE', 'Noise']\n", "\n", "rf.feature_importances(df[features], df['Lithology'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["As we'd hope, the `'Noise'` attribute is shown to be not very useful."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Pipelines"]}, {"cell_type": "markdown", "metadata": {}, "source": ["To make things as easy as possible, it would be nice to have some smoke alarms in the pipeline. Redflag has some prebuilt smoke alarms, and you can also make your own.\n", "\n", "Redflag's smoke alarms won't be able to catch everything, however. For example if the data are shuffled and/or randomly sampled in a split, it might be very hard to spot self-correlation. I'm not sure how to alert the user to that kind of error, other than by potentially providing a wrapped version of `train_test_split()`.\n", "\n", "Anyway, let's split our data in a sensible way: by well."]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": ["features = ['GR', 'RHOB', 'PE', 'Noise']\n", "test_wells = ['CRAWFORD', 'STUART']\n", "\n", "test_flag = df['Well Name'].isin(test_wells)\n", "\n", "X_test = df.loc[test_flag, features]\n", "y_test = df.loc[test_flag, 'Lithology']\n", "X_train = df.loc[~test_flag, features]\n", "y_train = df.loc[~test_flag, 'Lithology']"]}, {"cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [{"data": {"text/html": ["Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
OutlierDetector()
DistributionComparator()
ImportanceDetector()
"], "text/plain": ["Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector())])"]}, "execution_count": 15, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.pipeline"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We can include this in other pipelines:"]}, {"cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [{"data": {"text/html": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector())])),\n", " ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector())])),\n", " ('svc', SVC())])
StandardScaler()
Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
OutlierDetector()
DistributionComparator()
ImportanceDetector()
SVC()
"], "text/plain": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector())])),\n", " ('svc', SVC())])"]}, "execution_count": 16, "metadata": {}, "output_type": "execute_result"}], "source": ["from sklearn.pipeline import make_pipeline\n", "\n", "pipe = make_pipeline(StandardScaler(), rf.pipeline, SVC())\n", "pipe"]}, {"cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["\ud83d\udea9 The labels are imbalanced by more than the threshold (0.420 > 0.400). See self.minority_classes_ for the minority classes.\n", "\ud83d\udea9 Features 0, 1 have samples that may be clipped.\n", "\ud83d\udea9 Features 0, 1, 2 have samples that may be correlated.\n", "\ud83d\udea9 There are more outliers than expected in the training data (316 vs 31).\n", "\ud83d\udea9 Feature 3 has low importance; check for relevance.\n"]}, {"data": {"text/html": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier',\n", " OutlierDetector(threshold=3.643721188696941)),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector())])),\n", " ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier',\n", " OutlierDetector(threshold=3.643721188696941)),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector())])),\n", " ('svc', SVC())])
StandardScaler()
Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector(threshold=3.643721188696941)),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
OutlierDetector(threshold=3.643721188696941)
DistributionComparator()
ImportanceDetector()
SVC()
"], "text/plain": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier',\n", " OutlierDetector(threshold=3.643721188696941)),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector())])),\n", " ('svc', SVC())])"]}, "execution_count": 17, "metadata": {}, "output_type": "execute_result"}], "source": ["pipe.fit(X_train, y_train)"]}, {"cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["\ud83d\udea9 Feature 0 has samples that may be clipped.\n", "\ud83d\udea9 Features 0, 1, 2 have samples that may be correlated.\n", "\ud83d\udea9 There are more outliers than expected in the data (26 vs 8).\n", "\ud83d\udea9 Feature 2 has a distribution that is different from training.\n"]}, {"data": {"text/plain": ["array(['siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'sandstone', 'wackestone',\n", " 'wackestone', 'wackestone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'limestone', 'limestone', 'limestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'siltstone', 'siltstone', 'siltstone', 'mudstone', 'mudstone',\n", " 'mudstone', 'mudstone', 'mudstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'mudstone', 'wackestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'wackestone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'mudstone', 'wackestone', 'wackestone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'wackestone', 'wackestone', 'wackestone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'wackestone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'wackestone', 'limestone', 'siltstone', 'siltstone',\n", " 'siltstone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'mudstone', 'wackestone', 'wackestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'siltstone', 'limestone', 'mudstone', 'mudstone', 'wackestone',\n", " 'wackestone', 'wackestone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'siltstone', 'siltstone', 'siltstone', 'mudstone', 'mudstone',\n", " 'mudstone', 'mudstone', 'mudstone', 'mudstone', 'mudstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'wackestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'wackestone', 'wackestone', 'sandstone', 'sandstone',\n", " 'sandstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'wackestone', 'wackestone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'wackestone', 'wackestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'limestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'sandstone', 'sandstone', 'sandstone', 'sandstone',\n", " 'sandstone', 'sandstone', 'sandstone', 'sandstone', 'sandstone',\n", " 'sandstone', 'sandstone', 'sandstone', 'sandstone', 'sandstone',\n", " 'sandstone', 'siltstone', 'siltstone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'wackestone',\n", " 'wackestone', 'wackestone', 'siltstone', 'siltstone', 'sandstone',\n", " 'siltstone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'limestone',\n", " 'wackestone', 'limestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'limestone', 'limestone', 'limestone', 'wackestone',\n", " 'wackestone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'sandstone',\n", " 'siltstone', 'siltstone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'siltstone', 'wackestone', 'mudstone', 'sandstone',\n", " 'sandstone', 'sandstone', 'limestone', 'siltstone', 'siltstone',\n", " 'mudstone', 'mudstone', 'mudstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'wackestone', 'wackestone', 'wackestone', 'siltstone',\n", " 'siltstone', 'siltstone', 'sandstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'wackestone', 'wackestone', 'wackestone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'wackestone',\n", " 'wackestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'limestone', 'limestone', 'wackestone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'mudstone', 'limestone', 'mudstone', 'mudstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'mudstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone'], dtype=object)"]}, "execution_count": 18, "metadata": {}, "output_type": "execute_result"}], "source": ["pipe.predict(X_test)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Making your own tests"]}, {"cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["\ud83d\udea9 Feature 3 has samples that are negative.\n"]}, {"data": {"text/html": ["Pipeline(steps=[('detector',\n", " Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f5de3dbeca0>,\n", " warning='are negative')),\n", " ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('detector',\n", " Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f5de3dbeca0>,\n", " warning='are negative')),\n", " ('svc', SVC())])
Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f5de3dbeca0>,\n", " warning='are negative')
SVC()
"], "text/plain": ["Pipeline(steps=[('detector',\n", " Detector(func=. at 0x7f5de3dbeca0>,\n", " warning='are negative')),\n", " ('svc', SVC())])"]}, "execution_count": 20, "metadata": {}, "output_type": "execute_result"}], "source": ["from redflag import Detector\n", "\n", "def has_negative(x) -> bool:\n", " \"\"\"Returns True, i.e. triggers, if any samples are negative.\"\"\"\n", " return any(x < 0)\n", "\n", "negative_detector = Detector(has_negative, \"are negative\")\n", "\n", "pipe = make_pipeline(negative_detector, SVC()) # NB, no standardization.\n", "pipe.fit(X_train, y_train)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The noise feature we added has negative values; the others are all positive, which is what we expect for these data.\n", "\n", "(Careful! All standardized features will have negative values.)"]}], "metadata": {"kernelspec": {"display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.12"}, "vscode": {"interpreter": {"hash": "3ad933181bd8a04b432d3370b9dc3b0662ad032c4dfaa4e4f1596c548f763858"}}}, "nbformat": 4, "nbformat_minor": 4}
\ No newline at end of file
+{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# Tutorial\n", "\n", "We're going to look at some features of `redflag`, a library for helping find problems in machine learning pipelines.\n", "\n", "You'll need the following packages to run the code in this tutorial:\n", "\n", "- `redflag`\n", "- `pandas`\n", "- `seaborn`\n", "\n", "\n", "## A simple ML workflow\n", "\n", "First, let's see how we can burn ourselves:"]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/plain": ["array(['ss', 'ss', 'ss', 'ms', 'ms', 'ss'], dtype='\n", "\n", "\n", " \n", " \n", " \n", " Well Name \n", " Depth \n", " Formation \n", " RelPos \n", " Marine \n", " GR \n", " ILD \n", " DeltaPHI \n", " PHIND \n", " PE \n", " Facies \n", " LATITUDE \n", " LONGITUDE \n", " ILD_log10 \n", " Lithology \n", " RHOB \n", " Mineralogy \n", " Siliciclastic \n", " \n", " \n", " \n", " \n", " 0 \n", " SHRIMPLIN \n", " 851.3064 \n", " A1 SH \n", " 1.000 \n", " 1 \n", " 77.45 \n", " 4.613176 \n", " 9.9 \n", " 11.915 \n", " 4.6 \n", " 3.0 \n", " 37.978076 \n", " -100.987305 \n", " 0.664 \n", " siltstone \n", " 2393.499945 \n", " siliciclastic \n", " True \n", " \n", " \n", " 1 \n", " SHRIMPLIN \n", " 851.4588 \n", " A1 SH \n", " 0.979 \n", " 1 \n", " 78.26 \n", " 4.581419 \n", " 14.2 \n", " 12.565 \n", " 4.1 \n", " 3.0 \n", " 37.978076 \n", " -100.987305 \n", " 0.661 \n", " siltstone \n", " 2416.119814 \n", " siliciclastic \n", " True \n", " \n", " \n", " 2 \n", " SHRIMPLIN \n", " 851.6112 \n", " A1 SH \n", " 0.957 \n", " 1 \n", " 79.05 \n", " 4.549881 \n", " 14.8 \n", " 13.050 \n", " 3.6 \n", " 3.0 \n", " 37.978076 \n", " -100.987305 \n", " 0.658 \n", " siltstone \n", " 2404.576056 \n", " siliciclastic \n", " True \n", " \n", " \n", " 3 \n", " SHRIMPLIN \n", " 851.7636 \n", " A1 SH \n", " 0.936 \n", " 1 \n", " 86.10 \n", " 4.518559 \n", " 13.9 \n", " 13.115 \n", " 3.5 \n", " 3.0 \n", " 37.978076 \n", " -100.987305 \n", " 0.655 \n", " siltstone \n", " 2393.249071 \n", " siliciclastic \n", " True \n", " \n", " \n", " 4 \n", " SHRIMPLIN \n", " 851.9160 \n", " A1 SH \n", " 0.915 \n", " 1 \n", " 74.58 \n", " 4.436086 \n", " 13.5 \n", " 13.300 \n", " 3.4 \n", " 3.0 \n", " 37.978076 \n", " -100.987305 \n", " 0.647 \n", " siltstone \n", " 2382.602601 \n", " siliciclastic \n", " True \n", " \n", " \n", "
\n", ""], "text/plain": [" Well Name Depth Formation RelPos Marine GR ILD DeltaPHI \\\n", "0 SHRIMPLIN 851.3064 A1 SH 1.000 1 77.45 4.613176 9.9 \n", "1 SHRIMPLIN 851.4588 A1 SH 0.979 1 78.26 4.581419 14.2 \n", "2 SHRIMPLIN 851.6112 A1 SH 0.957 1 79.05 4.549881 14.8 \n", "3 SHRIMPLIN 851.7636 A1 SH 0.936 1 86.10 4.518559 13.9 \n", "4 SHRIMPLIN 851.9160 A1 SH 0.915 1 74.58 4.436086 13.5 \n", "\n", " PHIND PE Facies LATITUDE LONGITUDE ILD_log10 Lithology \\\n", "0 11.915 4.6 3.0 37.978076 -100.987305 0.664 siltstone \n", "1 12.565 4.1 3.0 37.978076 -100.987305 0.661 siltstone \n", "2 13.050 3.6 3.0 37.978076 -100.987305 0.658 siltstone \n", "3 13.115 3.5 3.0 37.978076 -100.987305 0.655 siltstone \n", "4 13.300 3.4 3.0 37.978076 -100.987305 0.647 siltstone \n", "\n", " RHOB Mineralogy Siliciclastic \n", "0 2393.499945 siliciclastic True \n", "1 2416.119814 siliciclastic True \n", "2 2404.576056 siliciclastic True \n", "3 2393.249071 siliciclastic True \n", "4 2382.602601 siliciclastic True "]}, "execution_count": 5, "metadata": {}, "output_type": "execute_result"}], "source": ["import pandas as pd\n", "\n", "df = pd.read_csv('https://geocomp.s3.amazonaws.com/data/Panoma_training_data.csv')\n", "\n", "df.head()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["For later use, I'm going to add a spurious column to the data:"]}, {"cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": ["import numpy as np\n", "\n", "rng = np.random.default_rng(42)\n", "\n", "df['Noise'] = rng.normal(size=len(df))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Imbalance metrics\n", "\n", "`redflag` has some algorithms for various tasks, such as:\n", "\n", "- Imbalance metrics\n", "- Flagging data problems\n", "- Outlier detection\n", "- Distribution shape\n", "- Feature importance\n", "\n", "Let's look at imbalance first."]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [{"data": {"text/plain": ["3.378593040846633"]}, "execution_count": 7, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.imbalance_degree(df['Lithology'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["To interpret this number, split it into two parts:\n", "\n", "- The integer part, 3, is equal to $m - 1$, where $m$ is the number of minority classes.\n", "- The fractional part, 0.378..., is a measure of the amount of imbalance, where 0 means the dataset is balanced perfectly and 0.999... is really bad.\n", "\n", "If the imbalance degree is -1 then there are no minority classes and all the classes have equal support.\n", "\n", "In general, this statistic is more informative than the commonly used 'imbalance ratio' (`rf.imbalance_ratio()`), which is the ratio of support in the maximum majority class to that in the minimum minority class, with no regard for the support of the other classes."]}, {"cell_type": "markdown", "metadata": {}, "source": ["We can get the minority classes, which are those with fewer samples than expected. These are returned in order, smallest first:"]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [{"data": {"text/plain": ["array(['dolomite', 'sandstone', 'mudstone', 'wackestone'], dtype='"]}, "execution_count": 10, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["import seaborn as sns\n", "\n", "sns.displot(df['GR'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Independence assumption\n", "\n", "If a feature is correlated to lagged (shifted) versions of itself, then the dataset may be ordered by that feature, or the records may not be independent. If several features are correlated to themselves, then the data instances may not be independent."]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"data": {"text/plain": ["True"]}, "execution_count": 11, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.is_correlated(df['GR'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This is order-dependent. That is, shuffling the data removes the correlation:"]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [{"data": {"text/plain": ["False"]}, "execution_count": 12, "metadata": {}, "output_type": "execute_result"}], "source": ["import numpy as np\n", "\n", "gr = df['GR'].to_numpy(copy=True)\n", "np.random.shuffle(gr)\n", "rf.is_correlated(gr)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["But this does not mean the records are independent — the only way around this issue is to split the data differently."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Importance\n", "\n", "We might like to see which of our features are more useful. There's a function for that:"]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([0.41495144, 0.20256686, 0.3156612 , 0.0668205 ])"]}, "execution_count": 13, "metadata": {}, "output_type": "execute_result"}], "source": ["features = ['GR', 'RHOB', 'PE', 'Noise']\n", "\n", "rf.feature_importances(df[features], df['Lithology'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["As we'd hope, the `'Noise'` attribute is shown to be not very useful."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Pipelines"]}, {"cell_type": "markdown", "metadata": {}, "source": ["To make things as easy as possible, it would be nice to have some smoke alarms in the pipeline. Redflag has some prebuilt smoke alarms, and you can also make your own.\n", "\n", "Redflag's smoke alarms won't be able to catch everything, however. For example if the data are shuffled and/or randomly sampled in a split, it might be very hard to spot self-correlation. I'm not sure how to alert the user to that kind of error, other than by potentially providing a wrapped version of `train_test_split()`.\n", "\n", "Anyway, let's split our data in a sensible way: by well."]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": ["features = ['GR', 'RHOB', 'PE', 'Noise']\n", "test_wells = ['CRAWFORD', 'STUART']\n", "\n", "test_flag = df['Well Name'].isin(test_wells)\n", "\n", "X_test = df.loc[test_flag, features]\n", "y_test = df.loc[test_flag, 'Lithology']\n", "X_train = df.loc[~test_flag, features]\n", "y_train = df.loc[~test_flag, 'Lithology']"]}, {"cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [{"data": {"text/html": ["Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.multimodality', MultimodalityDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.multimodality', MultimodalityDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
MultimodalityDetector()
OutlierDetector()
DistributionComparator()
ImportanceDetector()
DummyPredictor()
"], "text/plain": ["Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.multimodality', MultimodalityDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])"]}, "execution_count": 15, "metadata": {}, "output_type": "execute_result"}], "source": ["rf.pipeline"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We can include this in other pipelines:"]}, {"cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [{"data": {"text/html": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.multimodality', MultimodalityDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])),\n", " ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.multimodality', MultimodalityDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])),\n", " ('svc', SVC())])
StandardScaler()
Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.multimodality', MultimodalityDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
MultimodalityDetector()
OutlierDetector()
DistributionComparator()
ImportanceDetector()
DummyPredictor()
SVC()
"], "text/plain": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.multimodality', MultimodalityDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])),\n", " ('svc', SVC())])"]}, "execution_count": 16, "metadata": {}, "output_type": "execute_result"}], "source": ["from sklearn.pipeline import make_pipeline\n", "\n", "pipe = make_pipeline(StandardScaler(), rf.pipeline, SVC())\n", "pipe"]}, {"cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["\ud83d\udea9 The labels are imbalanced by more than the threshold (0.420 > 0.400). See self.minority_classes_ for the minority classes.\n", "\ud83d\udea9 Features 0, 1 have samples that may be clipped.\n", "\ud83d\udea9 Features 0, 1, 2 have samples that may be correlated.\n", "\ud83d\udea9 Feature 0 has a multimodal distribution.\n", "\u26a0\ufe0f Multimodality detection may not have succeeded for all groups in all features.\n", "\ud83d\udea9 There are more outliers than expected in the training data (316 vs 31).\n", "\ud83d\udea9 Feature 3 has low importance; check for relevance.\n", "\u2139\ufe0f Dummy classifier scores: {'f1': 0.2777104337392946, 'roc_auc': 0.5013219070647543} (stratified strategy).\n"]}, {"data": {"text/html": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.multimodality', MultimodalityDetector()),\n", " ('rf.outlier',\n", " OutlierDetector(threshold=3.643721188696941)),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])),\n", " ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.multimodality', MultimodalityDetector()),\n", " ('rf.outlier',\n", " OutlierDetector(threshold=3.643721188696941)),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])),\n", " ('svc', SVC())])
StandardScaler()
Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.multimodality', MultimodalityDetector()),\n", " ('rf.outlier', OutlierDetector(threshold=3.643721188696941)),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
MultimodalityDetector()
OutlierDetector(threshold=3.643721188696941)
DistributionComparator()
ImportanceDetector()
DummyPredictor()
SVC()
"], "text/plain": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.multimodality', MultimodalityDetector()),\n", " ('rf.outlier',\n", " OutlierDetector(threshold=3.643721188696941)),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])),\n", " ('svc', SVC())])"]}, "execution_count": 17, "metadata": {}, "output_type": "execute_result"}], "source": ["pipe.fit(X_train, y_train)"]}, {"cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["\ud83d\udea9 Feature 0 has samples that may be clipped.\n", "\ud83d\udea9 Features 0, 1, 2 have samples that may be correlated.\n", "\ud83d\udea9 There are more outliers than expected in the data (26 vs 8).\n", "\ud83d\udea9 Feature 2 has a distribution that is different from training.\n"]}, {"data": {"text/plain": ["array(['siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'sandstone', 'wackestone',\n", " 'wackestone', 'wackestone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'limestone', 'limestone', 'limestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'siltstone', 'siltstone', 'siltstone', 'mudstone', 'mudstone',\n", " 'mudstone', 'mudstone', 'mudstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'mudstone', 'wackestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'wackestone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'mudstone', 'wackestone', 'wackestone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'wackestone', 'wackestone', 'wackestone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'wackestone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'wackestone', 'limestone', 'siltstone', 'siltstone',\n", " 'siltstone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'mudstone', 'wackestone', 'wackestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'siltstone', 'limestone', 'mudstone', 'mudstone', 'wackestone',\n", " 'wackestone', 'wackestone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'siltstone', 'siltstone', 'siltstone', 'mudstone', 'mudstone',\n", " 'mudstone', 'mudstone', 'mudstone', 'mudstone', 'mudstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'wackestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'wackestone', 'wackestone', 'sandstone', 'sandstone',\n", " 'sandstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'wackestone', 'wackestone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'wackestone', 'wackestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'limestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'sandstone', 'sandstone', 'sandstone', 'sandstone',\n", " 'sandstone', 'sandstone', 'sandstone', 'sandstone', 'sandstone',\n", " 'sandstone', 'sandstone', 'sandstone', 'sandstone', 'sandstone',\n", " 'sandstone', 'siltstone', 'siltstone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'wackestone',\n", " 'wackestone', 'wackestone', 'siltstone', 'siltstone', 'sandstone',\n", " 'siltstone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'limestone',\n", " 'wackestone', 'limestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'limestone', 'limestone', 'limestone', 'wackestone',\n", " 'wackestone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'sandstone',\n", " 'siltstone', 'siltstone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'siltstone', 'wackestone', 'mudstone', 'sandstone',\n", " 'sandstone', 'sandstone', 'limestone', 'siltstone', 'siltstone',\n", " 'mudstone', 'mudstone', 'mudstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'wackestone', 'wackestone', 'wackestone', 'siltstone',\n", " 'siltstone', 'siltstone', 'sandstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'wackestone',\n", " 'wackestone', 'wackestone', 'wackestone', 'wackestone',\n", " 'wackestone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'wackestone', 'wackestone', 'wackestone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'limestone', 'limestone',\n", " 'limestone', 'limestone', 'limestone', 'limestone', 'wackestone',\n", " 'wackestone', 'limestone', 'limestone', 'limestone', 'limestone',\n", " 'limestone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'limestone', 'limestone', 'wackestone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'mudstone', 'limestone', 'mudstone', 'mudstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'mudstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone'], dtype=object)"]}, "execution_count": 18, "metadata": {}, "output_type": "execute_result"}], "source": ["pipe.predict(X_test)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Making your own tests"]}, {"cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["\ud83d\udea9 Feature 3 has samples that are negative.\n"]}, {"data": {"text/html": ["Pipeline(steps=[('detector',\n", " Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7efc26efbf60>,\n", " message='are negative')),\n", " ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('detector',\n", " Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7efc26efbf60>,\n", " message='are negative')),\n", " ('svc', SVC())])
Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7efc26efbf60>,\n", " message='are negative')
SVC()
"], "text/plain": ["Pipeline(steps=[('detector',\n", " Detector(func=. at 0x7efc26efbf60>,\n", " message='are negative')),\n", " ('svc', SVC())])"]}, "execution_count": 19, "metadata": {}, "output_type": "execute_result"}], "source": ["from redflag import Detector\n", "\n", "def has_negative(x) -> bool:\n", " \"\"\"Returns True, i.e. triggers, if any samples are negative.\"\"\"\n", " return any(x < 0)\n", "\n", "negative_detector = Detector(has_negative, \"are negative\")\n", "\n", "pipe = make_pipeline(negative_detector, SVC()) # NB, no standardization.\n", "pipe.fit(X_train, y_train)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The noise feature we added has negative values; the others are all positive, which is what we expect for these data.\n", "\n", "(Careful! All standardized features will have negative values.)"]}], "metadata": {"kernelspec": {"display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.5"}, "vscode": {"interpreter": {"hash": "3ad933181bd8a04b432d3370b9dc3b0662ad032c4dfaa4e4f1596c548f763858"}}}, "nbformat": 4, "nbformat_minor": 4}
\ No newline at end of file
diff --git a/_sources/_notebooks/Using_redflag_with_sklearn.ipynb.txt b/_sources/_notebooks/Using_redflag_with_sklearn.ipynb.txt
index 2917fe7..7713912 100644
--- a/_sources/_notebooks/Using_redflag_with_sklearn.ipynb.txt
+++ b/_sources/_notebooks/Using_redflag_with_sklearn.ipynb.txt
@@ -1 +1 @@
-{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# \ud83d\udea9 Using `redflag` with `sklearn`\n", "\n", "As well as using `redflag`'s functions directly (see `Basic_usage.ipynb`), `redflag` has some `sklearn` transformers that you can use to detect possible issues in your data. \n", "\n", "\u26a0\ufe0f **Note that these transformers do not transform your data, they only raise warnings (red flags) if they find issues.**\n", "\n", "Let's load some example data:"]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/html": ["\n", "\n", "\n", " \n", " \n", " \n", " count \n", " mean \n", " std \n", " min \n", " 25% \n", " 50% \n", " 75% \n", " max \n", " \n", " \n", " \n", " \n", " Depth \n", " 3966.0 \n", " 882.674555 \n", " 40.150056 \n", " 784.402800 \n", " 858.012000 \n", " 888.339600 \n", " 913.028400 \n", " 963.320400 \n", " \n", " \n", " RelPos \n", " 3966.0 \n", " 0.524999 \n", " 0.286375 \n", " 0.010000 \n", " 0.282000 \n", " 0.531000 \n", " 0.773000 \n", " 1.000000 \n", " \n", " \n", " Marine \n", " 3966.0 \n", " 1.325013 \n", " 0.589539 \n", " 0.000000 \n", " 1.000000 \n", " 1.000000 \n", " 2.000000 \n", " 2.000000 \n", " \n", " \n", " GR \n", " 3966.0 \n", " 64.367899 \n", " 28.414603 \n", " 12.036000 \n", " 45.311250 \n", " 64.840000 \n", " 78.809750 \n", " 200.000000 \n", " \n", " \n", " ILD \n", " 3966.0 \n", " 5.240308 \n", " 3.190416 \n", " 0.340408 \n", " 3.169567 \n", " 4.305266 \n", " 6.664234 \n", " 32.136605 \n", " \n", " \n", " DeltaPHI \n", " 3966.0 \n", " 3.469088 \n", " 4.922310 \n", " -21.832000 \n", " 1.000000 \n", " 3.292500 \n", " 6.124750 \n", " 18.600000 \n", " \n", " \n", " PHIND \n", " 3966.0 \n", " 13.008807 \n", " 6.936391 \n", " 0.550000 \n", " 8.196250 \n", " 11.781500 \n", " 16.050000 \n", " 52.369000 \n", " \n", " \n", " PE \n", " 3966.0 \n", " 3.686427 \n", " 0.815113 \n", " 0.200000 \n", " 3.123000 \n", " 3.514500 \n", " 4.241750 \n", " 8.094000 \n", " \n", " \n", " Facies \n", " 3966.0 \n", " 4.471004 \n", " 2.406180 \n", " 1.000000 \n", " 2.000000 \n", " 4.000000 \n", " 6.000000 \n", " 9.000000 \n", " \n", " \n", " LATITUDE \n", " 3966.0 \n", " 37.632575 \n", " 0.299398 \n", " 37.180732 \n", " 37.356426 \n", " 37.500380 \n", " 37.910583 \n", " 38.063373 \n", " \n", " \n", " LONGITUDE \n", " 3966.0 \n", " -101.294895 \n", " 0.230454 \n", " -101.646452 \n", " -101.389189 \n", " -101.325130 \n", " -101.106045 \n", " -100.987305 \n", " \n", " \n", " ILD_log10 \n", " 3966.0 \n", " 0.648860 \n", " 0.251542 \n", " -0.468000 \n", " 0.501000 \n", " 0.634000 \n", " 0.823750 \n", " 1.507000 \n", " \n", " \n", " RHOB \n", " 3966.0 \n", " 2288.861692 \n", " 218.038459 \n", " 1500.000000 \n", " 2201.007475 \n", " 2342.202051 \n", " 2434.166399 \n", " 2802.871147 \n", " \n", " \n", "
\n", ""], "text/plain": [" count mean std min 25% \\\n", "Depth 3966.0 882.674555 40.150056 784.402800 858.012000 \n", "RelPos 3966.0 0.524999 0.286375 0.010000 0.282000 \n", "Marine 3966.0 1.325013 0.589539 0.000000 1.000000 \n", "GR 3966.0 64.367899 28.414603 12.036000 45.311250 \n", "ILD 3966.0 5.240308 3.190416 0.340408 3.169567 \n", "DeltaPHI 3966.0 3.469088 4.922310 -21.832000 1.000000 \n", "PHIND 3966.0 13.008807 6.936391 0.550000 8.196250 \n", "PE 3966.0 3.686427 0.815113 0.200000 3.123000 \n", "Facies 3966.0 4.471004 2.406180 1.000000 2.000000 \n", "LATITUDE 3966.0 37.632575 0.299398 37.180732 37.356426 \n", "LONGITUDE 3966.0 -101.294895 0.230454 -101.646452 -101.389189 \n", "ILD_log10 3966.0 0.648860 0.251542 -0.468000 0.501000 \n", "RHOB 3966.0 2288.861692 218.038459 1500.000000 2201.007475 \n", "\n", " 50% 75% max \n", "Depth 888.339600 913.028400 963.320400 \n", "RelPos 0.531000 0.773000 1.000000 \n", "Marine 1.000000 2.000000 2.000000 \n", "GR 64.840000 78.809750 200.000000 \n", "ILD 4.305266 6.664234 32.136605 \n", "DeltaPHI 3.292500 6.124750 18.600000 \n", "PHIND 11.781500 16.050000 52.369000 \n", "PE 3.514500 4.241750 8.094000 \n", "Facies 4.000000 6.000000 9.000000 \n", "LATITUDE 37.500380 37.910583 38.063373 \n", "LONGITUDE -101.325130 -101.106045 -100.987305 \n", "ILD_log10 0.634000 0.823750 1.507000 \n", "RHOB 2342.202051 2434.166399 2802.871147 "]}, "execution_count": 1, "metadata": {}, "output_type": "execute_result"}], "source": ["import pandas as pd\n", "\n", "df = pd.read_csv('https://geocomp.s3.amazonaws.com/data/Panoma_training_data.csv')\n", "\n", "# Look at the transposed summary: each column in the DataFrame is a row here.\n", "df.describe().T"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Note that the features (e.g. GR, RHOB) are not **independent** records; they are correlated to themselves in depth.\n", "\n", "Furthermore, some of these features are clipped, e.g. the GR feature is clipped at a max value of 200:"]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["/home/matt/miniconda3/envs/redflag/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", " if pd.api.types.is_categorical_dtype(vector):\n", "/home/matt/miniconda3/envs/redflag/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", " with pd.option_context('mode.use_inf_as_na', True):\n"]}, {"data": {"text/plain": [""]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["import seaborn as sns\n", "\n", "sns.histplot(df['GR'])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We will split this dataset by group (well name):"]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": ["features = ['GR', 'RHOB', 'PE']\n", "\n", "test_wells = ['CRAWFORD', 'STUART']\n", "\n", "test_flag = df['Well Name'].isin(test_wells)\n", "\n", "X_test = df.loc[test_flag, features]\n", "y_test = df.loc[test_flag, 'Lithology']\n", "\n", "X_train = df.loc[~test_flag, features]\n", "y_train = df.loc[~test_flag, 'Lithology']"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## The `redflag` detector classes\n", "\n", "There are two main kinds of object: **detectors** and **comparators**.\n", "\n", "**Detectors** look for problems in your training and/or subsequent (e.g. validation, test, or production) data and are mostly unsupervised. There are several detectors:\n", "\n", "- `ClipDetector()` — looks for features that have been clipped.\n", "- `CorrelationDetector()` — looks for features that are correlated to themselves, which indicates that the data are likely not IID (in particular, not independent).\n", "- `UnivariateOutlierDetector()` — looks for outliers, considering each feature separately. Usually, you probably want to use `OutlierDetector` instead.\n", "- `MultivariateOutlierDetector()` — looks for outliers, considering all the features together. Usually, you probably want to use `OutlierDetector` instead.\n", "\n", "The following detectors only run during training. In other words, they examine your data during model fitting, but do not look at data during subsequent calls to `predict` or `score`, etc.\n", "\n", "- `ImportanceDetector()` — looks at feature importance. Runs during `fit` only. \n", "- `ImbalanceDetector()` — looks for class imbalance in `y`. Runs during `fit` only. In other words, it can find class imbalance in the training data, but does not look at data during subsequent calls to `predict` or `score`, etc.\n", "\n", "Finally, one detector is a bit different from the others because it runs in unsupervised mode on the training data, but in supervised mode on subsequent data. In other words, it can find outliers in the training data (based on some threshold), then it uses the statistics of the training data to decide what is an outlier in the subsequent data:\n", "\n", "- `OutlierDetector()` — looks for outliers. Runs during `fit` and `transform`. \n", "\n", "**Comparators** are fully supervised. They learn things about your data during training, then look at subsequent (e.g. validation, test, or production) data and compare. They will not triger during model fitting, only during `predict` or `score`:\n", "\n", "- `DistributionComparator()` — checks that the distributions of the features are similar to those seen during training.\n", "- `ImbalanceComparator()`— checks that any class imbalance is similar to that seen during training. (Does not trigger if the training data is imbalanced; use `ImbalanceDetector` for that.) Note that this comparator does not work in ordinary `sklearn.pipeline.Pipeline` objects; use `redflag.RfPipeline` instead.\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Using the pre-built `redflag` pipeline\n", "\n", "There is a [`sklearn.pipeline.Pipeline`](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html) you can use, containing most of the detectors. To find out why one is not included, and why, read on.\n", "\n", "The `ImbalanceComparator`, is not compatible with ordinary `Pipeline` objects, because it requires `y` (class imbalance comparison only works on the target vector). An `RfPipeline` object is available to use with this comparator... but it will not work as part of another ordinary `Pipeline`, so if you compose a multi-pipeline pipeline, make sure to use `RfPipeline` for all of it. Please note there is also a `make_rf_pipeline()` function that works just like `make_pipeline`, but it uses `RfPipeline` instead.\n", "\n", "For now, we'll carry on with the standard `sklearn` pipeline. "]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [{"data": {"text/html": ["Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
OutlierDetector()
DistributionComparator()
ImportanceDetector()
DummyPredictor()
"], "text/plain": ["Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])"]}, "execution_count": 4, "metadata": {}, "output_type": "execute_result"}], "source": ["import redflag as rf\n", "\n", "rf.pipeline"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We can use this in another pipeline:"]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [{"data": {"text/html": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])),\n", " ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])),\n", " ('svc', SVC())])
StandardScaler()
Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
OutlierDetector()
DistributionComparator()
ImportanceDetector()
DummyPredictor()
SVC()
"], "text/plain": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector()),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])),\n", " ('svc', SVC())])"]}, "execution_count": 5, "metadata": {}, "output_type": "execute_result"}], "source": ["from sklearn.pipeline import make_pipeline\n", "from sklearn.preprocessing import StandardScaler\n", "from sklearn.svm import SVC\n", "\n", "pipe = make_pipeline(StandardScaler(), rf.pipeline, SVC())\n", "pipe"]}, {"cell_type": "markdown", "metadata": {}, "source": ["During the `fit` phase, the `redflag` transformers do three things:\n", "\n", "- Check the target `y` for imbalance (if it is categorical).\n", "- Check the input features `X` for issues like clipping and self-correlation.\n", "- Learn the input feature distributions for later comparison."]}, {"cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["\ud83d\udea9 The labels are imbalanced by more than the threshold (0.420 > 0.400). See self.minority_classes_ for the minority classes.\n", "\ud83d\udea9 Features 0, 1 have samples that may be clipped.\n", "\ud83d\udea9 Features 0, 1, 2 have samples that may be correlated.\n", "\ud83d\udea9 There are more outliers than expected in the training data (349 vs 31).\n", "\u2139\ufe0f Dummy classifier scores: {'f1': 0.2693620698279881, 'roc_auc': 0.49979504678008513} (stratified strategy).\n"]}, {"data": {"text/html": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier',\n", " OutlierDetector(threshold=3.3682141715600706)),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])),\n", " ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier',\n", " OutlierDetector(threshold=3.3682141715600706)),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])),\n", " ('svc', SVC())])
StandardScaler()
Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier', OutlierDetector(threshold=3.3682141715600706)),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])
ImbalanceDetector()
ClipDetector()
CorrelationDetector()
OutlierDetector(threshold=3.3682141715600706)
DistributionComparator()
ImportanceDetector()
DummyPredictor()
SVC()
"], "text/plain": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('rf.imbalance', ImbalanceDetector()),\n", " ('rf.clip', ClipDetector()),\n", " ('rf.correlation', CorrelationDetector()),\n", " ('rf.outlier',\n", " OutlierDetector(threshold=3.3682141715600706)),\n", " ('rf.distributions', DistributionComparator()),\n", " ('rf.importance', ImportanceDetector()),\n", " ('rf.dummy', DummyPredictor())])),\n", " ('svc', SVC())])"]}, "execution_count": 6, "metadata": {}, "output_type": "execute_result"}], "source": ["pipe.fit(X_train, y_train)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["When we pass in data for prediction, `redflag` checks the new inputs. There are two categories of check:\n", "\n", "- Check for first-order issues, e.g. for clipping, or self-correlation.\n", "- Compare statistics to the training data, e.g. to compare the distribution of the data or look for outliers."]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["\ud83d\udea9 There are more outliers than expected in the data (30 vs 8).\n", "\ud83d\udea9 Feature 2 has a distribution that is different from training.\n"]}, {"data": {"text/plain": ["array(['siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone',\n", " 'siltstone', 'siltstone', 'siltstone', 'siltstone', 'siltstone'],\n", " dtype=object)"]}, "execution_count": 7, "metadata": {}, "output_type": "execute_result"}], "source": ["y_pred = pipe.predict(X_test)\n", "y_pred[:20]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["But you can't pass arguments to the elements of `redflag_pipeline` components yet, for example to change the sensitivity of the `DistributionComparator`. To do that, use them separately. That is, instantiate the detector components how you want them, and make a pipeline out of the components."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Using the 'detector' transformers\n", "\n", "Let's construct a pipeline from `redflag`'s transformers directly.\n", "\n", "Let's drop the clipped records of the GR log."]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": ["df = df.loc[df['GR'] < 200]\n", "\n", "test_flag = df['Well Name'].isin(test_wells)\n", "\n", "X_test = df.loc[test_flag, features]\n", "y_test = df.loc[test_flag, 'Lithology']\n", "\n", "X_train = df.loc[~test_flag, features]\n", "y_train = df.loc[~test_flag, 'Lithology']"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We know all this data is correlated to itself, so we can leave that check out.\n", "\n", "We don't think the class imbalance is too troubling, so we raise the threshold on that.\n", "\n", "We'll lower the confidence level of the outlier detector to 80% (i.e. we expect 20% of the data points will likely qualify as outliers). This might still trigger the detector in the training data.\n", "\n", "Finally, we'll lower the threshold for the distribution comparison. This is the minimum Wasserstein distance required to trigger the warning.\n", "\n", "So here's the new pipeline:"]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": ["pipe = make_pipeline(StandardScaler(),\n", " rf.ImbalanceDetector(threshold=0.5),\n", " rf.ClipDetector(),\n", " rf.OutlierDetector(p=0.80),\n", " rf.DistributionComparator(threshold=0.25),\n", " SVC())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Remember, feature 0 is no longer clipped, and the correlation detection is not being run. So we expect to see only the outlier issue, and the clipping issue with the RHOB column:"]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["\ud83d\udea9 Feature 1 has samples that may be clipped.\n", "\ud83d\udea9 There are more outliers than expected in the training data (839 vs 626).\n"]}, {"data": {"text/html": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('imbalancedetector', ImbalanceDetector(threshold=0.5)),\n", " ('clipdetector', ClipDetector()),\n", " ('outlierdetector',\n", " OutlierDetector(p=0.8, threshold=2.154443705823081)),\n", " ('distributioncomparator',\n", " DistributionComparator(threshold=0.25)),\n", " ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('imbalancedetector', ImbalanceDetector(threshold=0.5)),\n", " ('clipdetector', ClipDetector()),\n", " ('outlierdetector',\n", " OutlierDetector(p=0.8, threshold=2.154443705823081)),\n", " ('distributioncomparator',\n", " DistributionComparator(threshold=0.25)),\n", " ('svc', SVC())])
StandardScaler()
ImbalanceDetector(threshold=0.5)
ClipDetector()
OutlierDetector(p=0.8, threshold=2.154443705823081)
DistributionComparator(threshold=0.25)
SVC()
"], "text/plain": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('imbalancedetector', ImbalanceDetector(threshold=0.5)),\n", " ('clipdetector', ClipDetector()),\n", " ('outlierdetector',\n", " OutlierDetector(p=0.8, threshold=2.154443705823081)),\n", " ('distributioncomparator',\n", " DistributionComparator(threshold=0.25)),\n", " ('svc', SVC())])"]}, "execution_count": 10, "metadata": {}, "output_type": "execute_result"}], "source": ["pipe.fit(X_train, y_train)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The test dataset does not trigger the higher threshold for outliers. But with the new lower Wasserstein threshold, the distribution comparison fails for all of the features:"]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["\ud83d\udea9 Features 0, 1, 2 have distributions that are different from training.\n"]}], "source": ["y_pred = pipe.predict(X_test)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## The imbalance comparator\n", "\n", "As mentioned, the `ImbalanceComparator`, is not compatible with ordinary `Pipeline` objects, because it requires `y` (class imbalance comparison only works on the target vector). An `RfPipeline` object is available to use with this comparator... but it will not work as part of another ordinary `Pipeline` (for the same reason: `y` will not be passed into it), so if you compose a multi-pipeline pipeline, make sure to use `RfPipeline` for all of it.\n", "\n", "There is also a `make_rf_pipeline()` function that works just like `make_pipeline`, but it uses `RfPipeline` instead.\n", "\n", "Let's use it to check whether the imbalance in our test data is similar to the imbalance in the training data. When fitting a model, the comparator will never trigger:"]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [{"data": {"text/html": ["RfPipeline(steps=[('imbalancecomparator', ImbalanceComparator())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.RfPipeline(steps=[('imbalancecomparator', ImbalanceComparator())])
ImbalanceComparator()
"], "text/plain": ["RfPipeline(steps=[('imbalancecomparator', ImbalanceComparator())])"]}, "execution_count": 12, "metadata": {}, "output_type": "execute_result"}], "source": ["pipe = rf.make_rf_pipeline(rf.ImbalanceComparator())\n", "\n", "pipe.fit(X_train, y_train)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["But during transformation (therefore during prediction or other inference phases), it checks the imbalance is the same:"]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["\ud83d\udea9 There is a different number of minority classes (2) compared to the training data (4).\n", "\ud83d\udea9 The minority classes (sandstone, dolomite) are different from those in the training data (sandstone, dolomite, wackestone, mudstone).\n"]}, {"data": {"text/plain": ["array([[ 66.276 , 2359.73324716, 3.591 ],\n", " [ 77.252 , 2354.54679144, 3.341 ],\n", " [ 82.899 , 2330.35783664, 3.064 ],\n", " ...,\n", " [ 90.49 , 2193.06953439, 3.168 ],\n", " [ 90.975 , 2192.32922081, 3.154 ],\n", " [ 90.108 , 2176.62535394, 3.125 ]])"]}, "execution_count": 13, "metadata": {}, "output_type": "execute_result"}], "source": ["pipe.transform(X_test, y_test)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Making your own smoke detector"]}, {"cell_type": "markdown", "metadata": {}, "source": ["You can pass a detection function to a generic `Detector`, along with a warning to emit when it is triggered:"]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [{"data": {"text/html": ["Pipeline(steps=[('detector',\n", " Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f048e184ae0>,\n", " warning='are NaNs')),\n", " ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('detector',\n", " Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f048e184ae0>,\n", " warning='are NaNs')),\n", " ('svc', SVC())])
Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f048e184ae0>,\n", " warning='are NaNs')
SVC()
"], "text/plain": ["Pipeline(steps=[('detector',\n", " Detector(func=. at 0x7f048e184ae0>,\n", " warning='are NaNs')),\n", " ('svc', SVC())])"]}, "execution_count": 14, "metadata": {}, "output_type": "execute_result"}], "source": ["from redflag import Detector\n", "import numpy as np\n", "\n", "def has_nans(x) -> bool:\n", " \"\"\"Returns True, i.e. triggers, if any samples are NaN.\"\"\"\n", " return any(np.isnan(x))\n", "\n", "negative_detector = Detector(has_nans, \"are NaNs\")\n", "\n", "pipe = make_pipeline(negative_detector, SVC())\n", "pipe.fit(X_train, y_train)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["There are no NaNs.\n", "\n", "You can use `make_detector_pipeline` to combine several tests into a single pipeline."]}, {"cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["\ud83d\udea9 Features 0, 2 have samples that fail custom func has_outliers().\n"]}, {"data": {"text/html": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('detector-1',\n", " Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f048fe86c00>,\n", " warning='fail custom func '\n", " 'has_nans()')),\n", " ('detector-2',\n", " Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f048e1844a0>,\n", " warning='fail custom func '\n", " 'has_outliers()'))])),\n", " ('svc', SVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('detector-1',\n", " Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f048fe86c00>,\n", " warning='fail custom func '\n", " 'has_nans()')),\n", " ('detector-2',\n", " Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f048e1844a0>,\n", " warning='fail custom func '\n", " 'has_outliers()'))])),\n", " ('svc', SVC())])
StandardScaler()
Pipeline(steps=[('detector-1',\n", " Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f048fe86c00>,\n", " warning='fail custom func has_nans()')),\n", " ('detector-2',\n", " Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f048e1844a0>,\n", " warning='fail custom func has_outliers()'))])
Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f048fe86c00>,\n", " warning='fail custom func has_nans()')
Detector(func=<function BaseRedflagDetector.__init__.<locals>.<lambda> at 0x7f048e1844a0>,\n", " warning='fail custom func has_outliers()')
SVC()
"], "text/plain": ["Pipeline(steps=[('standardscaler', StandardScaler()),\n", " ('pipeline',\n", " Pipeline(steps=[('detector-1',\n", " Detector(func=. at 0x7f048fe86c00>,\n", " warning='fail custom func '\n", " 'has_nans()')),\n", " ('detector-2',\n", " Detector(func=. at 0x7f048e1844a0>,\n", " warning='fail custom func '\n", " 'has_outliers()'))])),\n", " ('svc', SVC())])"]}, "execution_count": 15, "metadata": {}, "output_type": "execute_result"}], "source": ["from redflag import make_detector_pipeline\n", "\n", "def has_outliers(x):\n", " \"\"\"Returns True, i.e. triggers, if any samples are negative.\"\"\"\n", " return any(abs(x) > 5)\n", "\n", "detectors = make_detector_pipeline([has_nans, has_outliers])\n", "\n", "pipe = make_pipeline(StandardScaler(), detectors, SVC())\n", "pipe.fit(X_train, y_train)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## What to do about the warnings\n", "\n", "If one of the detectors triggers, what should you do? Here are some ideas:\n", "\n", "\n", "### `ImbalanceDetector` and `ImbalanceComparator`\n", "\n", "- Check `rf.class_counts(y)` to see the support for each class in the dataset.\n", "- Check `rf.minority_classes(y)` to see which classes are considered 'minority'.\n", "\n", "This detector does not run during `transform`, only during `fit`. Usually, we don't worry about imbalance in data we are predicting on. If this is a concern for you, you can use `fit` on it (and make a GitHub Issue about it, because we could add an option to run during transform as well).\n", "\n", "\n", "### `ClipDetector`\n", "\n", "- Make sure the clipping values seem reasonable and do not lose a lot of dynamic range in the data (e.g. don't clip daily temperatures for Europe at 0 and 25 deg C).\n", "- Check that the clipped data cannot be dealt with in some other way (e.g. you can attenuate very large values with a log transformation, if it makes sense in your data).\n", "- Check that the clipped data should not simply be dropped from the dataset (e.g. if there are only a few values out of many, or if the other features also look suspicious for those records).\n", "\n", "You may or may not be concerned about clipping. You may want to try training your models with and without the clipped records, to see if they make a difference to the model performance. I'm not aware of any research on this.\n", "\n", "\n", "### `CorrelationDetector`\n", "\n", "If the data is correlated to shifted versions of itself, e.g. because the data points are contiguous in time or space (daily temperature records, spatial measurements of rock properties, etc), then the so-called [IID assumption](https://en.wikipedia.org/wiki/Independent_and_identically_distributed_random_variables) fails. In particular, your records are not independent. One of the big pitfalls with non-independent data is randomly splitting the data into train and test sets — you must not do this, it will result in information leakage and thus over-optimistic model evaulation. Instead, you should split the data using contiguous groups (date ranges, patient ID, borehole, or similar).\n", "\n", "\n", "### `OutlierDetector`\n", "\n", "There are a lot of ways of looking for outliers in data. The outlier detector only implements one strategy:\n", "\n", "- Learn the robust location and covariance of the training data (you can think of these as outlier-insensitive, multi-dimensional analogs to mean and variance in a single random variable).\n", "- As with the Gaussian distribution, we expect a certain number of samples to fall far from the centre of this distribution. For example, we expect 99.7% of values to be within 3 standard deviations of the mean.\n", "- So, given a confidence level like 99.7%, `redflag` counts how many values are more than 3 SD's away. If there are more than expected (e.g. we expect 3 samples out of 1000), the detector is triggered.\n", "- The default confidence level is 99% (you expect 1% of the data to be noise), but you can change it.\n", "\n", "So the location and covariance are learned from the training data; the detector then runs on the training data and on future datasets during the prediction phase (test, val, and in production).\n", "\n", "If the detector is triggered, you should check which samples are considered outliers with `rf.get_outliers(method='mah', p=0.99)` (without your value for `p`). This function returns the _indices_ of the outlier samples. You can also use `rf.expected_outliers(*X.shape, p=0.99)` to check how many outliers you'd expect in the dataset, for a given value of `p`/.\n", "\n", "You can check other methods, such as `iso` (isolation forest) to see if those also consider those samples to be outliers or not. If you think the samples are okay, you should keep them. If you think they are noise, you could remove them — but remember your model will not 'know' about these kinds of data points in the future and you should therefore remove them from future datasets too, before making predictions on them.\n", "\n", "\n", "### `DistributionComparator`\n", "\n", "Here's what this thing does:\n", "\n", "- When you call `fit` (e.g. during training), the detector learns the empirical, binned distributions of your features, one at a time. No warnings can be emitted during fitting, you are only learning the distributions.\n", "- When you call `transform` (e.g. during evaluation, testing, or in production), the detector compares the distributions in the data to those that were learned during fitting.\n", "- The comparison uses the [1-Wasserstein distance](https://en.wikipedia.org/wiki/Wasserstein_metric), or \"earth mover's distance\". Each feature is compared in turn; it is not a multivariate treatment. (If you'd like to see such a thing, please make a GitHub Issue, or have a crack at implementing it!)\n", "- If the distance is more than the threshold, 1 by default, the warning is triggered.\n", "\n", "If this detector triggers, it's a sign that you may have violated the 'identical distribution' part of the [IID assumption](https://en.wikipedia.org/wiki/Independent_and_identically_distributed_random_variables). You should examine the distributions of the features in the training data vs the current data that triggered the detector. For example, you can do this visually with something like Seaborn's `displot` or `kdeplot` functions.\n", "\n", "A small difference, especially on just a few features, might just result from natural variance in the data and you may decide to ignore it. A large difference may be a result of forgetting to scale the data using the scaling parameters learned from the training data. A large difference could also result from trying to apply the model to a new 'domain', e.g. a new geographic location, set of patients, or type of widget. \n", "\n", "If you're in the model selection phase, it's possible that a different train/test split will give more comparable distributions.\n", "\n", "\n", "### `ImportanceDetector`\n", "\n", "This detector checks for both \"too important\" features and \"not important enough\" features, using thresholds you provide and some heuristics.\n", "\n", "One or two very important features might indicate leakage: check that the features do not carry unintended information about the thing you are trying to predict. In particular, they should not carry information that will not be available to the model in production at prediction time. The classic example is trying to predict medical diagnosis using a patient number that contains encoded information about the patient's diagnosis.\n", "\n", "On the other hand, features with very low importance may not be useful to your model. If dimensionality is an issue, or the model is easily distracted by noise, you might improve performance by dropping one or more of these non-useful features. You will probably also improve the explainability of the model, which is often a desirable property."]}], "metadata": {"kernelspec": {"display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.5"}}, "nbformat": 4, "nbformat_minor": 4}
\ No newline at end of file
+{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# \ud83d\udea9 Using `redflag` with `sklearn`\n", "\n", "As well as using `redflag`'s functions directly (see `Basic_usage.ipynb`), `redflag` has some `sklearn` transformers that you can use to detect possible issues in your data. \n", "\n", "\u26a0\ufe0f **Note that these transformers do not transform your data, they only raise warnings (red flags) if they find issues.**\n", "\n", "Let's load some example data:"]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/html": ["\n", "\n", "\n", " \n", " \n", " \n", " count \n", " mean \n", " std \n", " min \n", " 25% \n", " 50% \n", " 75% \n", " max \n", " \n", " \n", " \n", " \n", " Depth \n", " 3966.0 \n", " 882.674555 \n", " 40.150056 \n", " 784.402800 \n", " 858.012000 \n", " 888.339600 \n", " 913.028400 \n", " 963.320400 \n", " \n", " \n", " RelPos \n", " 3966.0 \n", " 0.524999 \n", " 0.286375 \n", " 0.010000 \n", " 0.282000 \n", " 0.531000 \n", " 0.773000 \n", " 1.000000 \n", " \n", " \n", " Marine \n", " 3966.0 \n", " 1.325013 \n", " 0.589539 \n", " 0.000000 \n", " 1.000000 \n", " 1.000000 \n", " 2.000000 \n", " 2.000000 \n", " \n", " \n", " GR \n", " 3966.0 \n", " 64.367899 \n", " 28.414603 \n", " 12.036000 \n", " 45.311250 \n", " 64.840000 \n", " 78.809750 \n", " 200.000000 \n", " \n", " \n", " ILD \n", " 3966.0 \n", " 5.240308 \n", " 3.190416 \n", " 0.340408 \n", " 3.169567 \n", " 4.305266 \n", " 6.664234 \n", " 32.136605 \n", " \n", " \n", " DeltaPHI \n", " 3966.0 \n", " 3.469088 \n", " 4.922310 \n", " -21.832000 \n", " 1.000000 \n", " 3.292500 \n", " 6.124750 \n", " 18.600000 \n", " \n", " \n", " PHIND \n", " 3966.0 \n", " 13.008807 \n", " 6.936391 \n", " 0.550000 \n", " 8.196250 \n", " 11.781500 \n", " 16.050000 \n", " 52.369000 \n", " \n", " \n", " PE \n", " 3966.0 \n", " 3.686427 \n", " 0.815113 \n", " 0.200000 \n", " 3.123000 \n", " 3.514500 \n", " 4.241750 \n", " 8.094000 \n", " \n", " \n", " Facies \n", " 3966.0 \n", " 4.471004 \n", " 2.406180 \n", " 1.000000 \n", " 2.000000 \n", " 4.000000 \n", " 6.000000 \n", " 9.000000 \n", " \n", " \n", " LATITUDE \n", " 3966.0 \n", " 37.632575 \n", " 0.299398 \n", " 37.180732 \n", " 37.356426 \n", " 37.500380 \n", " 37.910583 \n", " 38.063373 \n", " \n", " \n", " LONGITUDE \n", " 3966.0 \n", " -101.294895 \n", " 0.230454 \n", " -101.646452 \n", " -101.389189 \n", " -101.325130 \n", " -101.106045 \n", " -100.987305 \n", " \n", " \n", " ILD_log10 \n", " 3966.0 \n", " 0.648860 \n", " 0.251542 \n", " -0.468000 \n", " 0.501000 \n", " 0.634000 \n", " 0.823750 \n", " 1.507000 \n", " \n", " \n", " RHOB \n", " 3966.0 \n", " 2288.861692 \n", " 218.038459 \n", " 1500.000000 \n", " 2201.007475 \n", " 2342.202051 \n", " 2434.166399 \n", " 2802.871147 \n", " \n", " \n", "
\n", ""], "text/plain": [" count mean std min 25% \\\n", "Depth 3966.0 882.674555 40.150056 784.402800 858.012000 \n", "RelPos 3966.0 0.524999 0.286375 0.010000 0.282000 \n", "Marine 3966.0 1.325013 0.589539 0.000000 1.000000 \n", "GR 3966.0 64.367899 28.414603 12.036000 45.311250 \n", "ILD 3966.0 5.240308 3.190416 0.340408 3.169567 \n", "DeltaPHI 3966.0 3.469088 4.922310 -21.832000 1.000000 \n", "PHIND 3966.0 13.008807 6.936391 0.550000 8.196250 \n", "PE 3966.0 3.686427 0.815113 0.200000 3.123000 \n", "Facies 3966.0 4.471004 2.406180 1.000000 2.000000 \n", "LATITUDE 3966.0 37.632575 0.299398 37.180732 37.356426 \n", "LONGITUDE 3966.0 -101.294895 0.230454 -101.646452 -101.389189 \n", "ILD_log10 3966.0 0.648860 0.251542 -0.468000 0.501000 \n", "RHOB 3966.0 2288.861692 218.038459 1500.000000 2201.007475 \n", "\n", " 50% 75% max \n", "Depth 888.339600 913.028400 963.320400 \n", "RelPos 0.531000 0.773000 1.000000 \n", "Marine 1.000000 2.000000 2.000000 \n", "GR 64.840000 78.809750 200.000000 \n", "ILD 4.305266 6.664234 32.136605 \n", "DeltaPHI 3.292500 6.124750 18.600000 \n", "PHIND 11.781500 16.050000 52.369000 \n", "PE 3.514500 4.241750 8.094000 \n", "Facies 4.000000 6.000000 9.000000 \n", "LATITUDE 37.500380 37.910583 38.063373 \n", "LONGITUDE -101.325130 -101.106045 -100.987305 \n", "ILD_log10 0.634000 0.823750 1.507000 \n", "RHOB 2342.202051 2434.166399 2802.871147 "]}, "execution_count": 1, "metadata": {}, "output_type": "execute_result"}], "source": ["import pandas as pd\n", "\n", "df = pd.read_csv('https://geocomp.s3.amazonaws.com/data/Panoma_training_data.csv')\n", "\n", "# Look at the transposed summary: each column in the DataFrame is a row here.\n", "df.describe().T"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Note that the features (e.g. GR, RHOB) are not **independent** records; they are correlated to themselves in depth.\n", "\n", "Furthermore, some of these features are clipped, e.g. the GR feature is clipped at a max value of 200:"]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["/home/matt/miniconda3/envs/redflag/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", " if pd.api.types.is_categorical_dtype(vector):\n", "/home/matt/miniconda3/envs/redflag/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", " with pd.option_context('mode.use_inf_as_na', True):\n"]}, {"data": {"text/plain": [""]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": ["
.
-
-0.2.0, 4 September 2023#
+
+0.2.0, 4 September 2023#
Moved to something more closely resembling semantic versioning, which is the main reason this is version 0.2.0.
Builds and tests on Python 3.11 have been successful, so now supporting this version.
@@ -317,8 +329,8 @@ 0.1.1, 31 January 2022
-0.1.0, 30 January 2022#
+
+0.1.0, 30 January 2022#
Early release.
@@ -373,15 +385,16 @@ 0.1.0, 30 January 2022
- Changelog
-- 0.3.0, 21 September 2023
-- 0.2.0, 4 September 2023
+- 0.4.0, 28 September 2023
+- 0.3.0, 21 September 2023
+- 0.2.0, 4 September 2023
- 0.1.10, 21 November 2022
- 0.1.9, 25 August 2022
- 0.1.8, 8 July 2022
- 0.1.3 to 0.1.7, 9–11 February 2022
- 0.1.2, 1 February 2022
- 0.1.1, 31 January 2022
-- 0.1.0, 30 January 2022
+- 0.1.0, 30 January 2022
diff --git a/genindex.html b/genindex.html
index e160735..6b08353 100644
--- a/genindex.html
+++ b/genindex.html
@@ -246,6 +246,8 @@ B
C