<jupyter_start><jupyter_text>Análise de Dados com PythonNeste notebook, utilizaremos dados de automóveis para analisar a influência das características de um carro em seu preço, tentando posteriormente prever qual será o preço de venda de um carro. Utilizaremos como fonte de dados um arquivo .csv com dados já tratados em outro notebook. Caso você tenha dúvidas quanto a como realizar o tratamento dos dados, dê uma olhada no meu repositório Learn-Pandas<jupyter_code>import pandas as pd
import numpy as np
df = pd.read_csv('clean_auto_df.csv')
df.head()<jupyter_output><empty_output><jupyter_text>Utilizando visualização de dados para verificar padrões de características individuais<jupyter_code># Importando as bibliotecas "Matplotlib" e "Seaborn
# utilizando "%matplotlib inline" para plotar o gráfico dentro do notebook.
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline<jupyter_output>Bad key savefig.frameon in file /home/anderson/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle, line 421 ('savefig.frameon : True')
You probably need to get an updated matplotlibrc file from
https://github.com/matplotlib/matplotlib/blob/v3.3.4/matplotlibrc.template
or from the matplotlib source distribution

Bad key verbose.level in file /home/anderson/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle, line 472 ('verbose.level  : silent      # one of silent, helpful, debug, debug-annoying')
You probably need to get an updated matplotlibrc file from
https://github.com/matplotlib/matplotlib/blob/v3.3.4/matplotlibrc.template
or from the matplotlib source distribution

Bad key verbose.fileo in file /home/anderson/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle, line 473 ('verbose.fileo  : sys.stdout  # a log filename, sys.stdout or sys.stderr')
You probably need to get an upd[...]<jupyter_text>Como escolher o método de visualização correto?  Ao visualizar variáveis individuais, é importante primeiro entender com que tipo de variável você está lidando. Isso nos ajudará a encontrar o método de visualização correto para essa variável. Por exemplo, podemos calcular a correlação entre variáveis do tipo "int64" ou "float64" usando o método "corr":<jupyter_code>df.corr()<jupyter_output><empty_output><jupyter_text>Os elementos diagonais são sempre um; (estudaremos isso, mais precisamente a correlação de Pearson no final do notebook)<jupyter_code># se quisermos verificar a correlação de apenas algumas colunas

df[['bore', 'stroke', 'compression-ratio', 'horsepower']].corr()<jupyter_output><empty_output><jupyter_text>Variáveis numéricas contínuas:  Variáveis numéricas contínuas são variáveis que podem conter qualquer valor dentro de algum intervalo. Variáveis numéricas contínuas podem ter o tipo "int64" ou "float64". Uma ótima maneira de visualizar essas variáveis é usando gráficos de dispersão com linhas ajustadas.  Para começar a compreender a relação (linear) entre uma variável individual e o preço. Podemos fazer isso usando "regplot", que plota o gráfico de dispersão mais a linha de regressão ajustada para os dados.   Relação linear positiva Vamos encontrar o gráfico de dispersão de "engine-size" e "price"<jupyter_code># Engine size as potential predictor variable of price
sns.regplot(x="engine-size", y="price", data=df)
plt.ylim(0,)<jupyter_output><empty_output><jupyter_text>Note que conforme o tamanho do motor aumenta, o preço sobe: isso indica uma correlação direta positiva entre essas duas variáveis. O tamanho do motor parece um bom preditor de preço, já que a linha de regressão é quase uma linha diagonal perfeita.<jupyter_code># Podemos examinar a correlação entre 'engine-size' e 'price' e ver que é aproximadamente 0,87
df[["engine-size", "price"]].corr()<jupyter_output><empty_output><jupyter_text>Relação linear Negativa<jupyter_code># city-mpg também pode ser um bom preditor para a variável price: 
sns.regplot(x="city-mpg", y="price", data=df)<jupyter_output><empty_output><jupyter_text>À medida que o city-mpg sobe, o preço desce: isso indica uma relação inversa / negativa entre essas duas variáveis, podendo ser um indicador de preço.<jupyter_code>df[['city-mpg', 'price']].corr()<jupyter_output><empty_output><jupyter_text>Relação linear neutra (ou fraca)<jupyter_code>sns.regplot(x="peak-rpm", y="price", data=df)<jupyter_output><empty_output><jupyter_text>A variável peak-rpm não parece ser um bom preditor do preço, pois a linha de regressão está próxima da horizontal. Além disso, os pontos de dados estão muito dispersos e distantes da linha ajustada, apresentando grande variabilidade. Portanto, não é uma variável confiável.<jupyter_code>df[['peak-rpm','price']].corr()<jupyter_output><empty_output><jupyter_text>Variáveis categóricas:  Essas são variáveis que descrevem uma 'característica' de uma unidade de dados e são selecionadas a partir de um pequeno grupo de categorias. As variáveis categóricas podem ser do tipo "objeto" ou "int64". Uma boa maneira de visualizar variáveis categóricas é usar boxplots.<jupyter_code>sns.boxplot(x="body-style", y="price", data=df)<jupyter_output><empty_output><jupyter_text>Vemos que as distribuições de preço entre as diferentes categorias de body-style têm uma sobreposição significativa e, portanto, body-style não seria um bom preditor de preço. Vamos examinar a "engine-location" e o "price" do motor:<jupyter_code>sns.boxplot(x="engine-location", y="price", data=df)<jupyter_output><empty_output><jupyter_text>Aqui, vemos que a distribuição de preço entre essas duas categorias de localização do motor, dianteira e traseira, são distintas o suficiente para considerar a localização do motor como um bom indicador de preço em potencial.<jupyter_code># drive-wheels
sns.boxplot(x="drive-wheels", y="price", data=df)<jupyter_output><empty_output><jupyter_text>Aqui vemos que a distribuição de preço entre as diferentes categorias de drive-wheels difere e podem ser um indicador de preço.   Estatística Descritiva   Vamos primeiro dar uma olhada nas variáveis usando um método de descrição.  A função  describe  calcula automaticamente estatísticas básicas para todas as variáveis contínuas. Quaisquer valores NaN são automaticamente ignorados nessas estatísticas. Isso mostrará:       a contagem dessa variável        a média        o desvio padrão (std)        o valor mínimo        o IQR (intervalo interquartil: 25%, 50% e 75%)        o valor máximo<jupyter_code>df.describe()
# A configuração padrão de "describe" ignora variáveis do tipo de objeto. 
# Podemos aplicar o método "describe" nas variáveis do tipo 'objeto' da seguinte forma:
df.describe(include=['object'])<jupyter_output><empty_output><jupyter_text>Value CountsA contagem de valores é uma boa maneira de entender quantas unidades de cada característica / variável temos. Podemos aplicar o método "value_counts" na coluna 'drive-wheels'. Não se esqueça que o método "value_counts" só funciona na série Pandas, não nos Dataframes Pandas. Por isso, incluímos apenas um colchete "df ['drive-wheels']" e não dois colchetes "df [['drive-wheels']]".<jupyter_code>df['drive-wheels'].value_counts()
# nós podemos converter a série para um dataframe:

df['drive-wheels'].value_counts().to_frame()
drive_wheels_counts = df['drive-wheels'].value_counts().to_frame()
drive_wheels_counts.rename(columns={'drive-wheels': 'value_counts'}, inplace=True)
drive_wheels_counts
# vamos renomear o index para 'drive-wheels':

drive_wheels_counts.index.name = 'drive-wheels'
drive_wheels_counts
# repetindo o processo para engine-location
engine_loc_counts = df['engine-location'].value_counts().to_frame()
engine_loc_counts.rename(columns={'engine-location': 'value_counts'}, inplace=True)
engine_loc_counts.index.name = 'engine-location'
engine_loc_counts.head()<jupyter_output><empty_output><jupyter_text>Agrupando O método "groupby" agrupa os dados por categorias diferentes. Os dados são agrupados com base em uma ou várias variáveis e a análise é realizada nos grupos individuais.  Por exemplo, vamos agrupar pela variável "drive-wheels". Vemos que existem 3 categorias diferentes de rodas motrizes.<jupyter_code>df['drive-wheels'].unique()<jupyter_output><empty_output><jupyter_text>Se quisermos saber, em média, qual tipo de drive-wheels é mais valiosa, podemos agrupar "drive-wheels" e depois fazer a média delas.  Podemos selecionar as colunas 'drive-wheels', 'body-style' e 'price' e, em seguida, atribuí-las à variável "df_group_one".<jupyter_code>df_group_one = df[['drive-wheels','body-style','price']]
# Podemos então calcular o preço médio para cada uma das diferentes categorias de dados
df_group_one = df_group_one.groupby(['drive-wheels'],as_index=False).mean()
df_group_one<jupyter_output><empty_output><jupyter_text>Pelos nossos dados, parece que os veículos com tração traseira são, em média, os mais caros, enquanto as 4 rodas e as rodas dianteiras têm preços aproximadamente iguais.  Você também pode agrupar com várias variáveis. Por exemplo, vamos agrupar por 'drive-wheels' e 'body-style'. Isso agrupa o dataframe pelas combinações exclusivas 'drive-wheels' e 'body-style'. Podemos armazenar os resultados na variável 'grouped_test1'.<jupyter_code>df_gptest = df[['drive-wheels','body-style','price']]
grouped_test1 = df_gptest.groupby(['drive-wheels','body-style'],as_index=False).mean()
grouped_test1<jupyter_output><empty_output><jupyter_text>Esses dados agrupados são muito mais fáceis de visualizar quando transformados em uma tabela dinâmica. Uma tabela dinâmica é como uma planilha do Excel, com uma variável ao longo da coluna e outra ao longo da linha. Podemos converter o dataframe em uma tabela dinâmica usando o método "pivô" para criar uma tabela dinâmica a partir dos grupos.Nesse caso, deixaremos a variável da 	drive-wheels como as linhas da tabela e giraremos no estilo do corpo para se tornar as colunas da tabela:<jupyter_code>grouped_pivot = grouped_test1.pivot(index='drive-wheels',columns='body-style')
grouped_pivot<jupyter_output><empty_output><jupyter_text>As vezes não teremos dados para algumas das células pivô. Podemos preencher essas células ausentes com o valor 0, mas qualquer outro valor também pode ser usado. Deve ser mencionado que a falta de dados é um assunto bastante complexo...<jupyter_code>grouped_pivot = grouped_pivot.fillna(0) #fill missing values with 0
grouped_pivot
df_gptest2 = df[['body-style','price']]
grouped_test_bodystyle = df_gptest2.groupby(['body-style'],as_index= False).mean()
grouped_test_bodystyle<jupyter_output><empty_output><jupyter_text>Visualização dos dadosVamos usar um mapa de calor para visualizar a relação entre body-style e price.<jupyter_code>import matplotlib.pyplot as plt
%matplotlib inline 
plt.pcolor(grouped_pivot, cmap='RdBu')
plt.colorbar()
plt.show()<jupyter_output><empty_output><jupyter_text>O mapa de calor representa a variável alvo (price) proporcional à cor em relação às variáveis 'drive-wheels' e 'body-style' nos eixos vertical e horizontal, respectivamente. Isso nos permite visualizar como o preço está relacionado a 'drive-wheels' e 'body-style'.  Os rótulos padrão não transmitem informações úteis para nós. Vamos mudar isso:<jupyter_code>fig, ax = plt.subplots()
im = ax.pcolor(grouped_pivot, cmap='RdBu')

#label names
row_labels = grouped_pivot.columns.levels[1]
col_labels = grouped_pivot.index

#move ticks and labels to the center
ax.set_xticks(np.arange(grouped_pivot.shape[1]) + 0.5, minor=False)
ax.set_yticks(np.arange(grouped_pivot.shape[0]) + 0.5, minor=False)

#insert labels
ax.set_xticklabels(row_labels, minor=False)
ax.set_yticklabels(col_labels, minor=False)

#rotate label if too long
plt.xticks(rotation=90)

fig.colorbar(im)
plt.show()<jupyter_output><empty_output><jupyter_text>A visualização é muito importante na ciência de dados e os pacotes de visualização oferecem grande liberdade A principal questão que queremos responder neste notebook é "Quais são as principais características que têm mais impacto no preço do carro?".  Para obter uma melhor medida das características importantes, olhamos para a correlação dessas variáveis com o preço do carro, em outras palavras: como o preço do carro depende dessa variável?  Correlação e Causalidade   Correlação : uma medida da extensão da interdependência entre as variáveis.   Causalidade : a relação entre causa e efeito entre duas variáveis.  É importante saber a diferença entre os dois e que a correlação não implica causalidade. Determinar a correlação é muito mais simples do que determinar a causalidade, pois a causalidade pode exigir experimentação independente.   Correlação de Pearson  A Correlação de Pearson mede a dependência linear entre duas variáveis X e Y.  O coeficiente resultante é um valor entre -1 e 1 inclusive, onde:        1 : Correlação linear positiva total.        0 : Sem correlação linear, as duas variáveis provavelmente não se afetam.        -1 : Correlação linear negativa total.  Correlação de Pearson é o método padrão da função "corr". Como antes, podemos calcular a Correlação de Pearson das variáveis 'int64' ou 'float64'.<jupyter_code>df.corr()<jupyter_output><empty_output><jupyter_text>P-value :P-value é o valor da probabilidade de que a correlação entre essas duas variáveis seja estatisticamente significativa. Normalmente, escolhemos um nível de significância de 0.05, o que significa que temos 95% de confiança de que a correlação entre as variáveis é significativa. Por convenção, quando o      o valor de p é $       o valor p é $       o valor p é $       o valor p é $> $ 0.1: não há evidências de que a correlação seja significativa.<jupyter_code># Podemos obter essas informações usando o módulo "stats" da biblioteca "scipy"

from scipy import stats<jupyter_output><empty_output><jupyter_text>Wheel-base vs PriceVamos calcular o coeficiente de correlação de Pearson e o P-value entre 'wheel-base' e 'price'.<jupyter_code>pearson_coef, p_value = stats.pearsonr(df['wheel-base'], df['price'])
print('Coeficiente de Pearson', pearson_coef)
print('P-value', p_value)<jupyter_output>Coeficiente de Pearson 0.584641822265508
P-value 8.076488270733218e-20<jupyter_text>A notacão científica do resultado indica que o valor é muito maior ou muito pequeno.No caso de 8.076488270733218e-20 significa:8.076488270733218 vezes 10 elevado a menos 20 (o que faz andar a casa decimal 20 vezes para esquerda):0,0000000000000000008076488270733218  Conclusão:  Como o P-value é $  Horsepower vs Price<jupyter_code>pearson_coef, p_value = stats.pearsonr(df['horsepower'], df['price'])
print('Coeficiente de Pearson', pearson_coef)
print('P-value', p_value)<jupyter_output>Coeficiente de Pearson 0.8096068016571054
P-value 6.273536270650504e-48<jupyter_text>Conclusão:  Como o P-value é $  Length vs Price<jupyter_code>pearson_coef, p_value = stats.pearsonr(df['length'], df['price'])
print('Coeficiente de Pearson', pearson_coef)
print('P-value', p_value)<jupyter_output>Coeficiente de Pearson 0.6906283804483638
P-value 8.016477466159556e-30<jupyter_text>Conclusão:  Como o valor p é $  Width vs Price<jupyter_code>pearson_coef, p_value = stats.pearsonr(df['width'], df['price'])
print('Coeficiente de Pearson', pearson_coef)
print('P-value', p_value)<jupyter_output>Coeficiente de Pearson 0.7512653440522674
P-value 9.200335510481516e-38<jupyter_text>Conclusão:Como o valor p é <0,001, a correlação entre largura e preço é estatisticamente significativa e a relação linear é bastante forte (~ 0,751). ANOVA  A Análise de Variância (ANOVA) é um método estatístico usado para testar se existem diferenças significativas entre as médias de dois ou mais grupos. ANOVA retorna dois parâmetros:   F-test score : ANOVA assume que as médias de todos os grupos são iguais, calcula o quanto as médias reais se desviam da suposição e relata como a pontuação do F-test. Uma pontuação maior significa que há uma diferença maior entre as médias.   P-value : P-value diz o quão estatisticamente significativo é nosso valor de pontuação calculado.  Se nossa variável de preço estiver fortemente correlacionada com a variável que estamos analisando, espere que a ANOVA retorne uma pontuação considerável no F-test e um pequeno P-value.  Drive Wheels Uma vez que ANOVA analisa a diferença entre diferentes grupos da mesma variável, a função groupby será útil. Como o algoritmo ANOVA calcula a média dos dados automaticamente, não precisamos tirar a média antes.  Vamos ver se diferentes tipos de 'drive wheels' afetam o 'price', agrupamos os dados.<jupyter_code>grouped_test2=df_gptest[['drive-wheels', 'price']].groupby(['drive-wheels'])
grouped_test2.head(2)
# Podemos obter os valores do grupo de métodos usando o método "get_group".
grouped_test2.get_group('4wd')['price']
# podemos usar a função 'f_oneway' no módulo 'stats' para obter  pontuação do test-F e o P-value
f_val, p_val = stats.f_oneway(grouped_test2.get_group('fwd')['price'], grouped_test2.get_group('rwd')['price'], grouped_test2.get_group('4wd')['price'])  
 
print( "ANOVA: F=", f_val, ", P =", p_val)<jupyter_output>ANOVA: F= 67.95406500780399 , P = 3.3945443577151245e-23<jupyter_text>Este é um ótimo resultado, com uma grande pontuação no test-F mostrando uma forte correlação e um P-value de quase 0 implicando em significância estatística quase certa. Mas isso significa que todos os três grupos testados são altamente correlacionados?<jupyter_code>#### fwd e rwd
f_val, p_val = stats.f_oneway(grouped_test2.get_group('fwd')['price'], grouped_test2.get_group('rwd')['price'])  
print( "ANOVA: F=", f_val, ", P =", p_val )

#### 4wd and rwd
f_val, p_val = stats.f_oneway(grouped_test2.get_group('4wd')['price'], grouped_test2.get_group('rwd')['price'])  
print( "ANOVA: F=", f_val, ", P =", p_val) 
#### 4wd and fwd
f_val, p_val = stats.f_oneway(grouped_test2.get_group('4wd')['price'], grouped_test2.get_group('fwd')['price'])  
print("ANOVA: F=", f_val, ", P =", p_val)<jupyter_output>ANOVA: F= 0.665465750252303 , P = 0.41620116697845666
{'fraction_non_alphanumeric': 0.08482291551015876, 'fraction_numerical': 0.021538803153103143, 'mean_word_length': 5.998834498834499, 'pattern_counts': {'":': 1, '<': 115, '<?xml version=': 0, '>': 115, 'https://': 2, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 1, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '30', 'dir': 'jupyter-structured-clean-dedup', 'id': '7266', 'license': 'MIT', 'n_tokens_mistral': 6619, 'n_tokens_neox': 6198, 'n_words': 1974, 'path': '.ipynb_checkpoints/pandas-basico-analise-carros-Copy1-checkpoint.ipynb', 'repo_name': 'andersoncordeiro/Learn-Pandas', 'size': '18014'}