<jupyter_start><jupyter_text>Tema do Projeto: Espécies da Planta Iris Apresentação dos Dados Neste estudo serão utilizados dados coletados do repositório Kaggle disponibilizados no seguinte link: (https://www.kaggle.com/saurabh00007/iriscsv?select=Iris.csv)Com base neste dataset, será feito um modelo preditivo para identificar as espécies de Iris. Problema a ser resolvido Identificar as três  espécies  da  planta do  Gênero Iris: setosa, virgínica e versicolor Objetivos do ProjetoInstalar e importar bibliotecas apropriadasProcessar os dadosEstabelecer as Variáveis Preditoras e de ClasseRealizar tratamento de atributos categóricos usando o LabelEncoder Escalonar os AtributosDividir a base de dados em Treinamento e TesteTreinar o algoritimo Árvore de DecisãoTestar o algoritmo utilizando a matriz de confusão, a função accuracy_score e a classification_report Importando Bibliotecas e Dados<jupyter_code>! pip install pyod
import pandas as pd  # biblioteca para manipulação de dados
import numpy as np # biblioteca para manipulação de  dados numéricos
import seaborn as sns # biblioteca para otimizar gráficos
import matplotlib.pyplot as plt # biblioteca para geração de gráficos
import plotly.express as px  # biblioteca para geração de gráficos interativos
import sklearn # bilioteca para subsidiar Machine Learning
import plotly.graph_objects as go # para concatenar graficos
from sklearn.preprocessing import StandardScaler #para escalonar variaveis
from sklearn.tree import DecisionTreeClassifier#  para  usar a Arvore de Decisao
from sklearn import tree # para visualizar a arvore
from sklearn.preprocessing import LabelEncoder #para transformar  variaveis
from sklearn.preprocessing import OneHotEncoder #para transformar variaveis
from sklearn.compose import ColumnTransformer #para transformar variaveis
from sklearn.model_selection import train_test_split  #para dividir base de teste e treinamento
from sklearn.metrics import accuracy_score #para avaliar a acurácia
import pickle #para fazer leitura do arquivo
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report
from seaborn.categorical import boxplot
% matplotlib inline
from pyod. models.knn import KNN
from yellowbrick.classifier import ConfusionMatrix
from numpy.ma.core import filled
from IPython.core.pylabtools import figsize

!pip  install plotly --upgrade
from google.colab import files
uploaded = files.upload()<jupyter_output><empty_output><jupyter_text>Processamento dos Dados<jupyter_code>Iris = pd.read_csv ('Iris.csv')
print( ' Este dataset tem %s linhas e %s colunas' % (Iris.shape[0] , Iris.shape[1] ) )
Iris.head(10)
Iris.tail()<jupyter_output><empty_output><jupyter_text>**Acima você pode conferir as primeiras  e últimas  linhas do dataset e o total de linhas e colunas. Como os dados podem causar certa confusão, será alterado o idioma dos cabeçalhos das colunas.**<jupyter_code>Iris.columns = ['ID','ComprimentoCM_Da_Sepala',' LarguraCM_Da_Sepala','ComprimentoCM_Da_Petala','LarguraCM_Da_Petala','Especies']
Iris.head(10)<jupyter_output><empty_output><jupyter_text>**Como não será  necessário utilizar a coluna ID, para a classificação, será utilizada a função drop para exclui-la.**<jupyter_code>Iris = Iris.drop('ID', axis=1)
Iris.tail()<jupyter_output><empty_output><jupyter_text>**Vejamos um Resumo do Dataset**<jupyter_code>Iris.describe()<jupyter_output><empty_output><jupyter_text>**Após este pré-processamento inicial será caracterizado os tipos de variáveis e seus significados.**<jupyter_code>Iris.dtypes<jupyter_output><empty_output><jupyter_text>**Se tem 4 variáveis Numéricas e 1 Categórica, assim classificadas:**ComprimentoCM_Da_Sepala, LarguraCM_Da_Sepala,ComprimentoCM_Da_Petala, LarguraCM_Da_Petala: Numérica ContínuaEspecies : Categórica Nominal **Dicionário de Dados***  ComprimentoCM_Da_Sepala:Comprimento em centímetro da Sépala*   LarguraCM_Da_Sepala:Largura em centímetro da Sépala*   ComprimentoCM_Da_Petala:Comprimento em centímetro da Pétala*   LarguraCM_Da_Petala:Largura em centímetro da Pétala* Especies: Espécies da planta com flor do  gênero Iris  **Prosseguindo o processamento de dados, será analisado se há valores faltantes e inconsistentes**<jupyter_code>Iris.isnull()
Iris.isnull().sum()
Iris.loc[Iris['ComprimentoCM_Da_Sepala']<=0]
Iris.loc[Iris[' LarguraCM_Da_Sepala']<=0]
Iris.loc[Iris['ComprimentoCM_Da_Petala']<=0]
Iris.loc[Iris['LarguraCM_Da_Petala']<=0]
np.unique(Iris['Especies'],return_counts=True)<jupyter_output><empty_output><jupyter_text>**Não foram observados valores inconsistentes  ou  faltantes nos  registros, e,  os  dados  da classe target estão  balanceados. Agora, serão  feitas as  Visualizações gráficas, que  ajudam a identificar,também, existência de valores inconsistentes** Visualizando Gráficos<jupyter_code>Especies = Iris['Especies'].value_counts()
Especies.plot(kind ='pie',autopct='%1.2f%%')<jupyter_output><empty_output><jupyter_text>**Já  se  percebe que existe a mesma quantidade de espécies no dataset.**<jupyter_code>plt.hist(x=Iris['ComprimentoCM_Da_Sepala']);
sns.distplot(Iris[' LarguraCM_Da_Sepala'],color='green');
Iris['ComprimentoCM_Da_Petala'].hist()
Especies = Iris['LarguraCM_Da_Petala'].value_counts()
Especies.plot(kind ='barh',color=['red','green'])<jupyter_output><empty_output><jupyter_text>**Feito as  visualizações acima, percebe-se que  reproduz  os dados  da descrição geral e  que não há  valores inconsistentes.** **Verificando se há  Outliers.**<jupyter_code>sns.boxplot(y='ComprimentoCM_Da_Sepala',data= Iris,color='yellow');
sns.boxplot(y=' LarguraCM_Da_Sepala',data= Iris,color='red');
sns.boxplot( y='ComprimentoCM_Da_Petala',data= Iris,color='blue');
Iris.boxplot( column =['LarguraCM_Da_Petala'], grid = False,color = 'red')<jupyter_output><empty_output><jupyter_text>**Na  Visualização de Largura da Sepala há registros de outlieres. Será feito então uma  análise  mais  refinada usando a  biblioteca pyod.**<jupyter_code>detector = KNN()
detector.fit(Iris.iloc[:,0:4])
previsores = detector.labels_
previsores
np.unique( previsores,return_counts=True)<jupyter_output><empty_output><jupyter_text>**Foram detectados 15 outliers. O número 0 representa a não presença de outliers e o 1 a presença.** **Verificando a confiabilidade dos previsores.**<jupyter_code>confianca_previsoes = detector.decision_scores_
confianca_previsoes
outliers =[]
for i in range(len(previsores)):
   if previsores[i]== 1:
     outliers.append(i)
print(outliers)<jupyter_output>[41, 57, 60, 68, 93, 98, 106, 109, 117, 118, 122, 129, 131, 134, 135]<jupyter_text>**Estes são os indices que se encontram os outliers.Os outliers  não serão tratados neste Projeto.** **Continuando com  a Preparação do banco de dados para uso do Algoritmo.** Dividindo as Variáveis Preditoras e de Classe **Serão criados duas variáveis: a X será a variável preditora e a Y a de classe.**<jupyter_code>X_Iris = Iris.iloc[:,0:4].values
X_Iris
Y_Iris = Iris.iloc[:,4].values
Y_Iris<jupyter_output><empty_output><jupyter_text>Tratando atributos Categóricos com Label Encoder<jupyter_code>label_encoder_Especies = LabelEncoder()
Y_Iris=label_encoder_Especies.fit_transform(Y_Iris)
Y_Iris<jupyter_output><empty_output><jupyter_text>**Agora, será feito o escalonamento dos   valores.** Escalonando os Atributos<jupyter_code>X_Iris[:,0].min()
X_Iris[:,0].max()
X_Iris[:,1].min()
X_Iris[:,1].max()
X_Iris[:,2].min()
X_Iris[:,2].max()
X_Iris[:,3].min()
X_Iris[:,3].max()<jupyter_output><empty_output><jupyter_text>**Será necessário fazer a Padronização dos Valores, pois há valores discrepantes entre si.**<jupyter_code>scaler_Iris = StandardScaler()
X_Iris = scaler_Iris.fit_transform(X_Iris)
X_Iris<jupyter_output><empty_output><jupyter_text>Divisão Base de Treinamento e Teste **Serão criados 4 variáveis , duas para treinamento e 2 para teste**<jupyter_code>X_Iris_treinamento, X_Iris_teste,Y_Iris_treinamento,Y_Iris_teste = train_test_split(X_Iris,Y_Iris, test_size=0.25,random_state=0)<jupyter_output><empty_output><jupyter_text>**Verificando as variáveis criadas.**<jupyter_code>X_Iris_treinamento.shape
X_Iris_teste.shape
Y_Iris_treinamento.shape
Y_Iris_teste.shape<jupyter_output><empty_output><jupyter_text>Agora, o Treinamento e Teste é o  passo seguinte. Treinando o Algoritmo e Testando<jupyter_code>arvore_Iris= DecisionTreeClassifier(criterion='entropy',random_state=0)
arvore_Iris.fit(X_Iris_treinamento, Y_Iris_treinamento)<jupyter_output><empty_output><jupyter_text>**Analisando a importância de cada atributo**<jupyter_code>arvore_Iris.feature_importances_<jupyter_output><empty_output><jupyter_text>**O que se percebe é que o último atributo( larguraCM_Da_Petala) tem maior importância, seguida do ComprimentoCM_Da_Petala. A largura da Sepala teve pouca importancia e o comprimento da Sepala sem significância.** **Fazendo os Testes**<jupyter_code>previsoes= arvore_Iris.predict(X_Iris_teste)
previsoes
Y_Iris_teste<jupyter_output><empty_output><jupyter_text>Métricas de Avaliação **Avaliando a Acurácia**<jupyter_code>accuracy_score (Y_Iris_teste,previsoes)<jupyter_output><empty_output><jupyter_text>**Matriz de Confusão**<jupyter_code>confusion_matrix(Y_Iris_teste,previsoes)
cm = ConfusionMatrix(arvore_Iris)
cm.fit(X_Iris_treinamento, Y_Iris_treinamento)
cm.score(X_Iris_teste,Y_Iris_teste)<jupyter_output><empty_output><jupyter_text>**Avaliando Precisão e Sensibilidade**<jupyter_code>print (classification_report(Y_Iris_teste,previsoes))<jupyter_output>precision    recall  f1-score   support

           0       1.00      1.00      1.00        13
           1       1.00      0.94      0.97        16
           2       0.90      1.00      0.95         9

    accuracy                           0.97        38
   macro avg       0.97      0.98      0.97        38
weighted avg       0.98      0.97      0.97        38<jupyter_text>Visualizando a Árvore<jupyter_code>arvore_Iris.classes_
previsores=['ComprimentoCM_Da_Sepala',' LarguraCM_Da_Sepala','ComprimentoCM_Da_Petala','LarguraCM_Da_Petala']
figura,axis = plt.subplots(nrows=1, ncols=1, figsize=(20,20))
tree.plot_tree(arvore_Iris,feature_names= previsores,class_names=['0','1','2'],filled= True);<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.09231825762778377, 'fraction_numerical': 0.015304620818208575, 'mean_word_length': 7.001569858712716, 'pattern_counts': {'":': 0, '<': 103, '<?xml version=': 0, '>': 99, 'https://': 1, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 7, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '25', 'dir': 'jupyter-structured-clean-dedup', 'id': '149358', 'license': 'MIT', 'n_tokens_mistral': 3919, 'n_tokens_neox': 3794, 'n_words': 839, 'path': 'Projeto_Machine_Learning_Iris3.ipynb', 'repo_name': 'Catia2021/Projeto4_Machine_Learning_Iris', 'size': '10193'}