<jupyter_start><jupyter_text>**Conhecendo o dataset**<jupyter_code>#encontrando as "estatísticas" do dataset
df_carros.describe()
#encontrando a matriz de correlação entre alguns dados
plt.rcParams["figure.figsize"] = [16, 9]
matriz_correlacao=df_carros[['mpg','cylinders','hp','time-to-60']].corr()
sns.heatmap(matriz_correlacao, annot=True)  #realiza o plot da matriz de correlação
plt.show()
#plotando alguns gráficos
df_carros['cylinders'].hist(bins=3);  #histograma
#plotando o scatterplot
cmap = sns.cubehelix_palette(dark=.2, light=.9, as_cmap=True) #definindo as cores para serem utilizadas
sns.scatterplot(x="hp", y="mpg", hue="cylinders", data=df_carros, palette=cmap); # realizando o plot do gráfico<jupyter_output><empty_output><jupyter_text>**Identificando possíveis outliers**<jupyter_code>#realizando o plot do boxplot
df_carros[['hp']].boxplot()
df_carros[['time-to-60']].boxplot()<jupyter_output><empty_output><jupyter_text>**Inicalizando o PCA**<jupyter_code>#Normalização com média 0 e desvio 1
normaliza = StandardScaler() #objeto para a normalização
X_std=normaliza.fit_transform(df_carros) #aplica a normalização
X_std
#inicalizando o objeto PCA
pca = PCA(n_components=7)  #instancia o objeto
principalComponents = pca.fit_transform(X_std) #aplica a identificação do pca
#plot das componentes principais
features = range(pca.n_components_)
plt.bar(features, pca.explained_variance_ratio_, color='black');
plt.xlabel('PCA características (autovetores vetores)')
plt.ylabel('% de variância')
plt.title("Componentes Principais")
plt.xticks(features);

#plot cumulativo das variâncias explicadas
pca.explained_variance_ratio_

plt.plot(range(1,8),pca.explained_variance_ratio_.cumsum(), marker='o', linestyle='--') #plot dos valores acumulados para os dados
plt.xlabel('Número de Componentes')
plt.ylabel('Variância Acumulada')
plt.title("Componentes Principais - Acumulada")
#criando o dataset com as componentes
PCA_components = pd.DataFrame(principalComponents)
PCA_components.head(10)
PCA_components.shape
#realizando o plot em duas dimensões (componentes 1 e 2 )
plt.scatter(PCA_components[0], PCA_components[1], alpha=.4, color='black')
plt.xlabel('PCA 1')
plt.ylabel('PCA 2');
#aplicando o curva do cootovelo para encontrar o número de clusters
ks = range(1, 10)
inertias = []
for k in ks:
    # Cria o obeto para modelo kmens para os testes
    model = KMeans(n_clusters=k)
    
    # Aplica nas componentes selecionadas (3 componentes)
    model.fit(PCA_components.iloc[:,:3])
    
    # Adiciona os valores para a distância (agitação)
    inertias.append(model.inertia_)
    
plt.plot(ks, inertias, '-o', color='black')
plt.xlabel('Numero de Cluster, k')
plt.ylabel('Distâncias')
plt.xticks(ks)
plt.show()
#---------------------------------------------------------------------------
# implementando o K-means com 3 clusters 
#---------------------------------------------------------------------------
k_means_pca=KMeans(n_clusters=3)
k_means_pca.fit(PCA_components.iloc[:,:3])


#df com os dados iniciais e de cada uma das componentes
df_segment_pca_kmeans=pd.concat([df_carros.reset_index(drop=True),PCA_components.iloc[:,:3]],axis=1)
df_segment_pca_kmeans.columns.values[-3:]=['Componente 1','Componente 2','Componente 3']
df_segment_pca_kmeans['Seguimento no Kmeans']=k_means_pca.labels_


df_segment_pca_kmeans.head()
#adicionando um dicionário para cada um dos seguimentos
df_segment_pca_kmeans['Cluster']=df_segment_pca_kmeans['Seguimento no Kmeans'].map({0:'C1',
                     1:'C2',
                     2:'C3'})

df_segment_pca_kmeans.head()
#plotando os resultados
x_axis=df_segment_pca_kmeans['Componente 2']
y_axis=df_segment_pca_kmeans['Componente 1']
sns.scatterplot(x_axis,y_axis,hue=df_segment_pca_kmeans['Cluster'],palette=['g','r','c'])
plt.title('Segmentação Utilizando PCA e K-means')
plt.show()<jupyter_output><empty_output><jupyter_text>**Árvore de Decisão**<jupyter_code>#importando as bibliotecas
from sklearn.tree import DecisionTreeClassifier # importa o classificador árvore de decisão
from sklearn import metrics #importa as métricas para avaliação
#preparando o dataset
df_carros_arvore=pd.read_csv('cars.csv')
#transformando os dados para numéricos
df_carros_arvore['cubicinches']=pd.to_numeric(df_carros_arvore['cubicinches'], errors='coerce')
df_carros_arvore['weightlbs']=pd.to_numeric(df_carros_arvore['weightlbs'], errors='coerce')
#retirando os valores nulos
df_carros_arvore.dropna(inplace=True)
#mostrando o dataset
df_carros_arvore.head()
#adicionando a coluna de classificação
df_carros_arvore['is_efficient']=df_carros_arvore['mpg'].map(lambda x: 1 if x>25 else 0)
df_carros_arvore.head()
df_carros_arvore.info()
#definindo as entradas e as saídas
entradas_arvore=df_carros_arvore[['cylinders'	,'cubicinches'	,'hp'	,'weightlbs'	,'time-to-60']]
saidas_arvore=df_carros_arvore['is_efficient']
#realiza a divisão dos dados entre treinamento e teste
from sklearn.model_selection import train_test_split   # função que realiza a divisão do dataset
X_train, X_test, y_train, y_test = train_test_split(entradas_arvore, saidas_arvore, test_size=0.30)# divide 20% para teste
# Cria o objeto de classificação através do 
clf = DecisionTreeClassifier()

# Realiza o treinamento do classificador
clf = clf.fit(X_train,y_train)

#Realiza a previsão de classificaçao 
y_pred = clf.predict(X_test)
#constroi a matriz de confusão para comparar o modelo criado
from sklearn.metrics import classification_report, confusion_matrix
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))
#Avaliando o modelo 

#realiza o plot da matriz de confusão
matriz_confusao = confusion_matrix(y_test, y_pred)
from mlxtend.plotting import plot_confusion_matrix

fig, ax = plot_confusion_matrix(conf_mat=matriz_confusao)
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13776559287183002, 'fraction_numerical': 0.009766963673749143, 'mean_word_length': 6.126984126984127, 'pattern_counts': {'":': 0, '<': 17, '<?xml version=': 0, '>': 18, 'https://': 0, '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': '4', 'dir': 'jupyter-structured-clean-dedup', 'id': '518509', 'license': 'MIT', 'n_tokens_mistral': 2266, 'n_tokens_neox': 2168, 'n_words': 449, 'path': 'aula_interativa_1_TPD_bootcamp Mod 4.ipynb', 'repo_name': 'Adrianacms/Bootcamp_IGTI', 'size': '5836'}