O Python é uma linguagem de uso geral e, como tal, oferece um grande número de extensões que variam da programação científica à visualização de dados, das ferramentas estatísticas ao aprendizado de máquina.
É quase impossível conhecer todas as extensões disponíveis; no entanto, existem algumas delas essenciais se a sua tarefa consistir em analisar dados e criar modelos de aprendizado de máquina nelas.
Portanto, neste artigo, estou abordando 5 pacotes principais que tornarão seu Python extremamente versátil, que são:
Então vamos começar!
Numpy
Numpy é um pacote para computação científica. Permite executar qualquer tipo de operações matemáticas e estatísticas. Em particular (e essa é a razão pela qual é fundamental no aprendizado de máquina), ele permite que você execute cálculos N-dimensionais de maneira muito rápida e fácil. Sempre que você é solicitado a manipular vetores e matrizes, você sabe que precisa usar o Numpy para esse fim.
Vamos agora ver alguns exemplos.
O principal objeto de Numpy é a matriz multidimensional homogênea, que pode parecer um vetor (se as dimensões forem n, 1) ou uma matriz (se as dimensões forem n, m). Vamos criar uma primeira matriz contendo 1,2,3:
import numpy as np
a=np.array([1,2,3])
a
Output: array([1, 2, 3])
Podemos verificar algumas propriedades dessa matriz com os seguintes métodos:
a.shape
Output: (3,)
a.dtype
Output: dtype('int32')
type(a)
Output: numpy.ndarray
Também podemos inicializar matrizes especificando o número de componentes e a forma. Ou seja, se eu quiser criar uma matriz 3 × 4 com número de 0 a 11, escreverei:
b=np.arange(12).reshape(3,4)
b
Output: array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
Você também pode converter em matrizes objetos que não são, como listas. Isso é muito útil sempre que você precisar fazer cálculos com itens de listas. Digamos que você queira subtrair essas duas listas:
list_1=[1,2,3]
list_2=[4,5,6]
list_2-list_1
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-11-4c6e19f7626c> in <module>
1 list_1=[1,2,3]
2 list_2=[4,5,6]
----> 3 list_2-list_1
TypeError: unsupported operand type(s) for -: 'list' and 'list'
Como você pode ver, ocorreu um erro, pois você não pode subtrair duas listas. Mas, se você usar este truque:
np.asarray(list_2)-np.asarray(list_1)
Output: array([3, 3, 3])
O problema é contornado!
Pandas
O Pandas fornece estruturas de dados e ferramentas de análise de dados que são essenciais para que seus dados sejam limpos e empregados em tarefas de aprendizado de máquina.
Os principais objetos dos pandas são DataFrames, que nada mais são que conjuntos de dados estruturados que podem ser facilmente modificados e acessados. Você pode criar ou importar (da web, arquivos csv, arquivos de texto …) seu quadro de dados.
Vamos criar um do zero:
import pandas as pd
data = [['alex', 10], ['tom', 15], ['jim', 14]]
df = pd.DataFrame(data, columns = ['Name', 'Age'])
df
Podemos acessar os elementos desse df como se fosse uma matriz:
df[:1] #showing only the first row
df.iloc[:,1] Output: 0 10 1 15 2 14 Name: Age, dtype: int64
Todas as colunas de um dataframe do pandas são objetos Series:
type(df['Age'])
Output: pandas.core.series.Series
Também podemos anexar novas colunas ao nosso conjunto de dados, bem como definir índices:
g=['M','M','M']
df['Gender']=g
df.set_index('Name',inplace=True)
df
O Pandas é fundamental sempre que você lida com grande quantidade de dados, pois também é capaz de resumir informações relevantes (como presença de valores ausentes, valores extremos, média e frequências e assim por diante).
df.isnull().sum() #for missing values Output: Age 0 Gender 0 dtype: int64df.describe()
Matplotlib
O Matplotlib oferece diferentes ferramentas para visualização de dados. Não é o único pacote de visualização disponível no Python, no entanto, é o mais intuitivo de usar e gera resultados muito agradáveis.
Vamos ver como plotar gráficos diferentes:
import matplotlib.pyplot as plt
import numpy as np
men_means = [20, 34, 30, 35, 27]
x = np.arange(len(labels))
fig, ax = plt.subplots()
ax.bar(x - width/2, men_means, width, label='Men')
ax.set_title('Men Means')
Também podemos mostrar várias barras no mesmo gráfico:
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
men_means = [20, 34, 30, 35, 27]
women_means = [25, 32, 34, 20, 25]
x = np.arange(len(labels))
fig, ax = plt.subplots()
rects1 = ax.bar(x - width/2, men_means, width, label='Men')
rects2 = ax.bar(x + width/2, women_means, width, label='Women')
ax.set_title('Men and Women Means')
Agora vamos modelar uma variável aleatória normal com um histograma e uma aproximação do gráfico de distribuição normal:
import matplotlib.pyplot as plt
mu, sigma = 0, 0.1 # mean and standard deviation
s = np.random.normal(mu, sigma, 1000)
count, bins, ignored = plt.hist(s, 30, normed=True)
plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) *np.exp( - (bins - mu)**2 / (2 * sigma**2) ),linewidth=2, color='r')
plt.show()
Agora imagine que queremos traçar o resultado de uma pesquisa onde as pessoas tinham que dizer sua massa italiana favorita. Os resultados da pesquisa são:
import matplotlib.pyplot as plt
labels = 'Gnocchi', 'Tortellini', 'Spaghetti', 'Penne'
sizes = [15, 30, 45, 10]
explode=(0,0,0,0)
fig1, ax1 = plt.subplots()
ax1.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%',
shadow=True, startangle=90)
ax1.axis('equal')
plt.show()
Você também pode enfatizar a resposta mais popular com a opção explodir:
explode=(0,0,0.1,0)
Como cientista de dados, a visualização de dados é essencial, pois você sempre terá que mostrar seus resultados de maneira intuitiva e poderosa. Além disso, gráficos relevantes costumam ser úteis para identificar padrões nos dados mesmo antes de iniciar a construção de modelos; portanto, podem sugerir que tipo de análise você deve executar.
Scikit-Learn
SkLearn – Este é provavelmente o pacote mais importante para o aprendizado de máquina, pois fornece todos os algoritmos, variando de supervisionado a não supervisionado, de classificação a regressão. Além disso, inclui métricas de avaliação como ROC, MSE R ao quadrado e assim por diante, que serão calculadas automaticamente após cada treinamento do seu algoritmo.
Vamos ver um exemplo muito fácil de tarefa de BC, usando o conjunto de dados Boston House Price e tentando modelar o preço em relação a apenas uma variável, para que possamos visualizá-lo. Como se trata de uma tarefa de regressão (a variável de destino ‘preço’ é contínua), usaremos uma Simple Linear Regression:
import pandas as pd
from sklearn.datasets import load_boston
dataset = load_boston()
df = pd.DataFrame(dataset.data, columns=dataset.feature_names)
df['target'] = dataset.target
df.head()
Como queremos construir uma regressão linear simples (apenas um recurso), precisamos reduzir a dimensionalidade de 13 para 1 e, para isso, sem perder informações relevantes, precisamos executar um Principal Component Analysis:
from sklearn.decomposition import PCA
pca = PCA(1)
projected = pca.fit_transform(dataset.data)
print(dataset.data.shape)
print(projected.shape)
Output:
(506, 13)
(506, 1)
Bom, agora vamos importar e treinar nosso modelo:
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(projected, dataset.target, random_state=0)
from sklearn.linear_model import LinearRegression
lm = LinearRegression()
lm.fit(X_train,y_train)
y_pred = lm.predict(X_test)
#let's visualize the results
plt.scatter(X_test, y_test, color='black')
plt.plot(X_test, y_pred, color='blue', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.xlabel('First Principal component')
plt.ylabel('price')
plt.show()
Também podemos pedir um “feedback” do desempenho do nosso algoritmo:
from sklearn.metrics import mean_squared_error, r2_score
print("MSE: {:.2f}".format(mean_squared_error(y_test, y_pred)))
print("R2: {:.2f}".format(r2_score(y_test, y_pred)))
Output:
MSE: 73.04
R2: 0.11
Como você pode ver, com algumas linhas de código (e menos de 2 minutos), treinamos um modelo de ML sem qualquer cálculo manual.
Seaborn
Como o matplotlib, o seaborn é um pacote Python para visualização de dados. No entanto, deve ser particularmente útil para representações estatísticas e retorna informações mais relevantes sobre seus dados.
Em particular, é muito útil para mostrar possíveis correlações entre dados: com pairplot() and heatmap() você pode ter um primeiro vislumbre significativo dos relacionamentos entre todos os recursos (e destinos):
import seaborn as sns sns.set(style="ticks")
df = sns.load_dataset("iris")
sns.pairplot(df, hue="species")
sns.heatmap(df.corr(),annot=True)
Também podemos visualizar a distribuição conjunta de dados (digamos, dos dois recursos sepal_length e sepal_width):
sns.jointplot(x='sepal_length',y='sepal_width',data=df,size=5)
Por fim, vamos dar uma olhada na distribuição dos valores sepal_length para cada espécie:
ax=sns.boxplot(x='species',y='sepal_length',data=df) ax=sns.stripplot(x='species',y='sepal_length',data=df,jitter=True,edgecolor='gray')
O Seaborn é extremamente rápido e poderoso para exibir informações relevantes e, se você estiver executando uma análise exploratória, poderá economizar muito tempo, sugerindo dicas sobre o melhor algoritmo que você pode escolher. Escusado será dizer que cobrir todas as potencialidades desses pacotes seria quase impossível. No entanto, é importante saber quais são as ferramentas necessárias e como implantá-las durante sua análise. Como boa prática, lembre-se de que, independentemente do tipo de computação que você precisa para sua análise, o python fornece uma maneira mais rápida e inteligente de fazer isso: descobrir fazendo isso é uma estratégia muito boa para explorar essas ferramentas.
Se você estiver interessado em aprender mais sobre esses pacotes, aqui está a documentação oficial:
Originally published at http://datasciencechalktalk.com on September 4, 2019. (Traduzido por Google Translate)
BLOG DO ZOUZA 