<jupyter_start><jupyter_text>Agrupamento Isolation Forest - ExperimentoEste é um componente que treina um modelo Isolation Forest usando [Scikit-learn](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.IsolationForest.html). Scikit-learn é uma biblioteca open source de machine learning que suporta apredizado supervisionado e não supervisionado. Também provê várias ferramentas para ajustes de modelos, pré-processamento de dados, seleção e avaliação de modelos, além de outras funcionalidades.Este notebook apresenta:- como usar o [SDK](https://platiagro.github.io/sdk/) para carregar datasets, salvar modelos e outros artefatos.- como declarar parâmetros e usá-los para criar componentes reutilizáveis.  Declaração de parâmetros e hiperparâmetrosDeclare parâmetros com o botão  na barra de ferramentas.O parâmetro `dataset` identifica os conjuntos de dados. Você pode importar arquivos de dataset com o botão  na barra de ferramentas.<jupyter_code># parâmetros
dataset = "iris.csv" #@param {type:"string"}
max_samples = "auto" #@param {type:"float"}
contamination = 0.1 #@param {type:"float"}
max_features = 1.0 #@param {type:"float"}<jupyter_output><empty_output><jupyter_text>Acesso ao conjunto de dadosO conjunto de dados utilizado nesta etapa será o mesmo carregado através da plataforma.O tipo da variável retornada depende do arquivo de origem:- [pandas.DataFrame](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html) para CSV e compressed CSV: .csv .csv.zip .csv.gz .csv.bz2 .csv.xz- [Binary IO stream](https://docs.python.org/3/library/io.htmlbinary-i-o) para outros tipos de arquivo: .jpg .wav .zip .h5 .parquet etc<jupyter_code>import pandas as pd

df = pd.read_csv(f'/tmp/data/{dataset}')<jupyter_output><empty_output><jupyter_text>Acesso aos metadados do conjunto de dadosUtiliza a função `stat_dataset` do [SDK da PlatIAgro](https://platiagro.github.io/sdk/) para carregar metadados. Por exemplo, arquivos CSV possuem `metadata['featuretypes']` para cada coluna no conjunto de dados (ex: categorical, numerical, or datetime).<jupyter_code>import numpy as np
from platiagro import stat_dataset

metadata = stat_dataset(name=dataset)
featuretypes = metadata["featuretypes"]
featuretypes = np.array(featuretypes)
columns = df.columns.to_numpy()<jupyter_output><empty_output><jupyter_text>Configuração dos atributos<jupyter_code>from platiagro.featuretypes import NUMERICAL

# Selects the indexes of numerical and non-numerical features
numerical_indexes = np.where(featuretypes == NUMERICAL)[0]
non_numerical_indexes = np.where(~(featuretypes == NUMERICAL))[0]

# After the step handle_missing_values, 
# numerical features are grouped in the beggining of the array
numerical_indexes_after_handle_missing_values = \
    np.arange(len(numerical_indexes))
non_numerical_indexes_after_handle_missing_values = \
    np.arange(len(numerical_indexes), len(featuretypes))<jupyter_output><empty_output><jupyter_text>Dividindo o conjunto de dados em treino e testeConjunto de treino: usado para ajustar o modelo.Conjunto de teste: usada para fornecer uma avaliação imparcial de um ajuste de modelo no conjunto de dados de treinamento.<jupyter_code>from sklearn.model_selection import train_test_split

X_train, X_test= train_test_split(df, train_size=0.7)<jupyter_output><empty_output><jupyter_text>Treina modelo usando sklearn.ensemble.IsolationForest<jupyter_code>from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.ensemble import IsolationForest
from sklearn.pipeline import Pipeline
from category_encoders.ordinal import OrdinalEncoder

pipeline = Pipeline(steps=[
            ("handle_missing_values",
             ColumnTransformer(
                [("imputer_mean", SimpleImputer(strategy="mean"), numerical_indexes),
                 ("imputer_mode", SimpleImputer(strategy="most_frequent"), non_numerical_indexes)],
                 remainder="drop")),
            ("handle_categorical_features",
             ColumnTransformer(
                 [("feature_encoder", OrdinalEncoder(), non_numerical_indexes_after_handle_missing_values)],
                 remainder="passthrough")),
            ("estimator", IsolationForest(max_samples=max_samples,
                            contamination=contamination,
                            max_features=max_features))
])

pipeline.fit(X_train)

features_after_pipeline = \
        np.concatenate((columns[numerical_indexes],
                        columns[non_numerical_indexes]))<jupyter_output><empty_output><jupyter_text>Avalia desempenhoNo caso do Isolation Florest, podemos medir o desempenho obtendo a anomalia média.<jupyter_code>from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# Run all except the last step
df_encoded = Pipeline(steps=pipeline.steps[:-1]).transform(X_test)

# Normalization and dimension reduction
df_encoded_std = StandardScaler().fit_transform(df_encoded)
pca = PCA(n_components=2)
reduced = pca.fit_transform(df_encoded_std)

X_pca = pd.DataFrame(reduced, columns=["X", "Y"])

y_pred_test = pipeline.predict(X_test)
X_pca["Anomaly"] = y_pred_test
import matplotlib.pyplot as plt
import seaborn as sns
from platiagro import save_figure

ax = sns.scatterplot(x="X", y="Y", hue="Anomaly", data=X_pca)

ax.set_title("PCA Graph", {"fontweight": 'bold'})

save_figure(figure=plt.gcf())<jupyter_output><empty_output><jupyter_text>Salva métricasUtiliza a função `save_metrics` do [SDK da PlatIAgro](https://platiagro.github.io/sdk/) para salvar métricas. Por exemplo: `accuracy`, `precision`, `r2_score`, `custom_score` etc.<jupyter_code>from platiagro import save_metrics

save_metrics(anomaly_score=y_pred_test)<jupyter_output><empty_output><jupyter_text>Salva alterações no conjunto de dadosO conjunto de dados será salvo (e sobrescrito com as respectivas mudanças) localmente, no container da experimentação, utilizando a função `pandas.DataFrame.to_csv`.<jupyter_code>new_columns = list("Anomaly")

score = pipeline.predict(df)
df_anomaly = df.copy()
df_anomaly["Anomaly"] = score

# save dataset changes
df.to_csv(f'/tmp/data/{dataset}', index=False)<jupyter_output><empty_output><jupyter_text>Salva modelo e outros artefatosUtiliza a função `save_model` do [SDK da PlatIAgro](https://platiagro.github.io/sdk/) para salvar modelos e outros artefatos.Essa função torna estes artefatos disponíveis para o notebook de implantação.<jupyter_code>from platiagro import save_model

save_model(pipeline=pipeline, 
           columns=columns,
           new_columns=new_columns,
           features_after_pipeline=features_after_pipeline)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.0925288216798922, 'fraction_numerical': 0.0020961221739781402, 'mean_word_length': 5.640159045725646, 'pattern_counts': {'":': 1, '<': 41, '<?xml version=': 0, '>': 41, 'https://': 7, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '10', 'dir': 'jupyter-structured-clean-dedup', 'id': '491224', 'license': 'Apache-2.0', 'n_tokens_mistral': 2235, 'n_tokens_neox': 2197, 'n_words': 516, 'path': 'samples/isolation-forest-clustering/Experiment.ipynb', 'repo_name': 'Matheus158257/projects', 'size': '6679'}