As melhores bibliotecas para Python e Processamento de Linguagem Natural

Libraries for data science

Essas são as melhores bibliotecas que transferem o Python de uma linguagem de programação de uso geral para uma ferramenta poderosa e robusta para análise e visualização de dados.

NumPy

O NumPy é a biblioteca básica ou o computador científico em Python, e muitas das bibliotecas downstream usam arrays NumPy como entradas e saídas. O NumPy introduz objetos para matrizes e matrizes multidimensionais e também rotinas que permitem aos desenvolvedores executar funções matemáticas e estatísticas avançadas nos arrays com o menor código possível.

Exemplo:

import numpy as np 
# Create the following rank 2 array with shape (3, 4) # [[ 1 2 3 4] # [ 5 6 7 8] # [ 9 10 11 12]] a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) 
# Use slicing to pull out the subarray consisting of the first 2 rows # and columns 1 and 2; b is the following array of shape (2, 2): # [[2 3] # [6 7]] b = a[:2, 1:3] 
# A slice of an array is a view into the same data, so modifying it # will modify the original array. print(a[0, 1]) # Prints "2" b[0, 0] = 77 # b[0, 0] is the same piece of data as a[0, 1] 
print(a[0, 1]) # Prints "77"

SciPy

O SciPy se baseia no NumPy, adicionando uma coleção de algoritmos e comandos de alto nível para manipular e visualizar dados. Este pacote inclui funções para calcular integrais numericamente, resolvendo equações diferenciais, otimização.

Exemplo – Teste de assimetria e curtose em uma distribuição normal

>> from scipy import stats 
>>> print('normal skewtest teststat = %6.3f pvalue = %6.4f' % stats.skewtest(x)) 
normal skewtest teststat = 2.785 pvalue = 0.0054 
>>> print('normal kurtosistest teststat = %6.3f pvalue = %6.4f' % stats.kurtosistes t(x)) 
normal kurtosistest teststat = 4.757 pvalue = 0.0000
>>> print('normaltest teststat = %6.3f pvalue = %6.4f' % stats.normaltest(x)) 
normaltest teststat = 30.379 pvalue = 0.0000

Pandas

O Pandas adicionam estruturas de dados e ferramentas projetadas para análise prática de dados em finanças, ciências sociais e engenharia. O Panda funciona bem com dados incompletos, confusos e não rotulados e fornece ferramentas para moldar, mesclar, remodelar e fatiar conjuntos de dados.

Example
import pandas as pd 
raw_data = {'first_name': ['Jason', 'Molly', 'Tina', 'Jake', 'Amy'], 
'last_name': ['Miller', 'Jacobson', ".", 'Milner', 'Cooze'], 
'age': [42, 52, 36, 24, 73], 
'preTestScore': [4, 24, 31, ".", "."], 
'postTestScore': ["25,000", "94,000", 57, 62, 70]} 
df = pd.DataFrame(raw_data, columns = ['first_name', 'last_name', 'age', 'preTestScore', 'postTestScore']) 
df

Matplotlib

O Matplotlib é a biblioteca padrão do Python para criar gráficos e plotagens 2D. É de baixo nível, o que significa que requer comandos de adição para gerar gráficos e figuras bonitos do que algumas outras bibliotecas avançadas. É flexível e com comandos suficientes, quase todos os tipos de gráficos podem ser feitos com o matplotlib.

#Example
import numpy as np # importing numpy 
import matplotlib.pyplot as plt # importing matplotlib
# Compute the x and y coordinates for points on sine and cosine curves 
x = np.arange(0, 3 * np.pi, 0.1) 
y_sin = np.sin(x) # finding sin of x 
y_cos = np.cos(x) # finding cosine of x
# Plot the points using matplotlib 
plt.plot(x, y_sin) 
plt.plot(x, y_cos) 
plt.xlabel('x axis label') 
plt.ylabel('y axis label') 
plt.title('Sine and Cosine') 
plt.legend(['Sine', 'Cosine']) 
plt.show()

Libraries for machine learning

O aprendizado de máquina fica no cruzamento da Inteligência Artificial e da Ciência de Dados. Ao treinar computadores com conjuntos de dados do mundo real, somos capazes de criar algoritmos que fazem previsões precisas e sofisticadas. Alguns casos de uso referem-se à obtenção de melhores instruções de direção e à criação de computadores capazes de identificar pontos de referência observando fotos.

Scikit-learn

O Scikit-learn baseia-se no NumPy e no SciPy incorporando algoritmos para tarefas comuns de aprendizado de máquina e mineração de dados, incluindo clustering, regressão e classificação. As ferramentas do Scikit-learn estão bem documentadas e seus colaboradores incluem muitos especialistas em aprendizado de máquina. É uma biblioteca curada, o que significa que os desenvolvedores não precisam escolher entre diferentes versões do mesmo algoritmo. Seu poder e facilidade de uso o tornam popular com startups com muitos dados, como o Evernote e o Spotify.

Example - Logistic regression using Scikit-learn
import numpy as np 
import matplotlib.pyplot as plt 
from sklearn import linear_model, datasets
# import some data to play with 
iris = datasets.load_iris() 
X = iris.data[:, :2] # we only take the first two features. 
Y = iris.targe
h = .02 # step size in the mesh
logreg = linear_model.LogisticRegression(C=1e5)
# we create an instance of Neighbours Classifier and fit the data. 
logreg.fit(X, Y)
# Plot the decision boundary. For that, we will assign a color to each 
# point in the mesh [x_min, x_max]x[y_min, y_max]. 
x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5 
y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5 
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) 
Z = logreg.predict(np.c_[xx.ravel(), yy.ravel()])
# Put the result into a color plot 
Z = Z.reshape(xx.shape) 
plt.figure(1, figsize=(4, 3)) 
plt.pcolormesh(xx, yy, Z, cmap=plt.cm.Paired)
# Plot also the training points 
plt.scatter(X[:, 0], X[:, 1], c=Y, edgecolors='k', cmap=plt.cm.Paired) 
plt.xlabel('Sepal length') 
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max()) 
plt.ylim(yy.min(), yy.max()) 
plt.xticks(()) 
plt.yticks(()) 
plt.show()

TensorFlow

O TensorFlow é desenvolvido pelo Google como um sucessor de código aberto do DistBelief, sua estrutura anterior para o treinamento de redes neurais. O TensoFlow usa um sistema de nós de múltiplas camadas que permitem configurar, treinar e implantar rapidamente redes neurais artificiais com grandes conjuntos de dados. É o que permite ao Google identificar objetos em fotos ou entender palavras faladas em seu aplicativo de reconhecimento de voz e é usado principalmente no Deep Learning.

Natural Language Processing with TensorFlow ( Part I | Part II )

Example - Example in MNIST dataset (hand-written digits from 0-9)
import tensorflow as tf mnist = tf.keras.datasets.mnist 
(x_train, y_train),(x_test, y_test) = mnist.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0 
model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(), tf.keras.layers.Dense(512, activation=tf.nn.relu), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(10, activation=tf.nn.softmax) ]) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) 
model.fit(x_train, y_train, epochs=5) model.evaluate(x_test, y_test
Keras is a high-level neural network API, written in Python and is capable of running on top of TensorFlow, CNTK and  Theano. It was developed with a focus on enabling fast experimentation. To be able to go from idea to result with the least possible delay is key to doing good research.

Você usará o Keras se precisar de uma biblioteca de aprendizado profunda que:

  • Permite a criação fácil e rápida de protótipos através da facilidade de utilização, modularidade e extensibilidade
  • Suporta redes convolucionais e redes recorrentes
  • Funciona perfeitamente com CPU e GPU
#Example
from keras.models import Sequential 
model = Sequential() 
from keras.layers import Dense 
model.add(Dense(units=64, activation='relu', input_dim=100)) 
model.add(Dense(units=10, activation='softmax')) 
model.compile(loss='categorical_crossentropy', optimizer='sgd', 
metrics=['accuracy']) 
model.compile(loss=keras.losses.categorical_crossentropy, 
optimizer=keras.optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True)
model.fit(x_train, y_train, epochs=5, batch_size=32)
model.train_on_batch(x_batch, y_batch)
loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128) 
classes = model.predict(x_test, batch_size=128)

Libraries for natural language processing (NLP)

Scrapy

Scrapy é um Framework open source para extração de informação em websites, ou seja, Framework para Web CrawlerPor ser um Framework, o Scrapy disponibiliza diversas funcionalidades que facilitam o o processo de crawler. Desde o controle de navegação na web, bibliotecas de parse em HTML, representação de dados e pipelines para filtragem e tratamento de dados. (fonte)

Vejam: Web crawler for clustering 2,500 data science websites

NLTK

O NLTK é um conjunto de bibliotecas projetadas para o Processamento de Linguagem Natural (NLP). As funções básicas do NLTK permitem que você marque texto, identifique entidades nomeadas. Ele também exibe árvores de análise que são como diagramas de sentenças que revelam partes da fala e dependências. Através do NLTK, coisas mais complicadas como análise de sentimento e sumarização automática podem ser feitas.

SpaCy

SpaCy é minimalista e opinativo e não o inunda com opções como o NLTK. Sua filosofia é apresentar o melhor algoritmo para cada finalidade. Poucas escolhas opinativas precisam ser feitas e pode-se concentrar em ser produtivo.

Como o SpaCy é construído em Cython, é muito rápido. É considerado “estado da arte”. Sua principal fraqueza é que é apenas um extrator de informações e não faz o conjunto completo de trabalho de processamento de linguagem natural.

Gensim

O Gensim é uma biblioteca bem otimizada para modelagem de tópicos e análise de similaridade de documentos. Os algoritmos de modelagem de tópico, como a implementação da Latitude Dirichlet Allocation (LDA), são os melhores da categoria. É robusto, eficiente e escalável.

Libraries for plotting and visualizations

Uma análise só vale a pena se puder ser comunicada com outras pessoas. Essas bibliotecas são baseadas no matplotlib para permitir uma criação fácil e visualmente atraente de gráficos, gráficos e mapas sofisticados.

Seaborn

O Seaborn é uma biblioteca de visualização popular que é construída sobre a base do matplotlib. Os estilos padrão do Seaborn são mais sofisticados que os do matplotlib. O Seaborn é uma biblioteca de alto nível, o que significa que é fácil gerar vários tipos de enredo, incluindo heatmaps, séries temporais e gráficos de violino.

#Example
>> import seaborn as sns 
>>> sns.set(style="whitegrid") 
>>> tips = sns.load_dataset("tips") 
>>> ax = sns.boxplot(x=tips["total_bill"])

O Bokeh cria gráficos interativos e atualizados em navegadores modernos usando widgets JavaScript. Um recurso do Bokeh é que ele vem com três níveis de interface, de abstrações de alto nível que permitem gerar rapidamente gráficos complexos para uma visualização de baixo nível que oferece flexibilidade máxima aos desenvolvedores de aplicativos.

Matplotlib é para criar gráficos e gráficos 2D. É uma biblioteca de baixo nível, o que significa que requer mais comandos para gerar gráficos e figuras bonitos do que com bibliotecas avançadas. Tem uma boa quantidade de flexibilidade, o que significa que praticamente qualquer tipo de gráfico pode ser feito com o matplotlib.

Scikit-learn vs TensorFlow vs Keras

O TensorFlow é de baixo nível, o que significa que são os blocos de Lego que ajudam a implementar algoritmos de aprendizado de máquina nos quais o scikit-learn oferece algoritmos prontos para uso, como classificação como SVMs, Florestas Aleatórias, Regressão Logística. O TensorFlow brilha para algoritmos de aprendizagem profunda, já que aproveita as GPUs para um treinamento mais eficiente.

A funcionalidade de aprendizagem profunda do Scikit é bastante limitada. Introduziu redes rasas recentemente e seu perceptron multicamadas (MLP) não é bem otimizado em comparação com o Kears ou o TensorFlow.

XGBoost

O XGBoost possui o solver de modelo linear e o algoritmo de aprendizado de árvore. Faz sua seleção de forma inteligente e, posteriormente, dá mais peso ao difícil de classificar as observações. É rápido devido à sua capacidade de fazer cálculos paralelos em uma única máquina. Ele possui recursos adicionais para fazer validação cruzada e encontrar variáveis importantes.

Características

  • Velocidade: Ele pode fazer automaticamente computação paralela no Windows e no Linux, geralmente mais de 10 vezes mais rápido do que o modelo clássico de aumento de gradiente.
  • Tipo de entrada: são necessários vários tipos de dados de entrada
  • Matriz densa: pode levar matriz densa
  • Matriz esparsa: pode levar matriz esparsa
  • xgb.DMatrix: sua própria classe
  • Esparsidade: Aceita entrada esparsa para o reforço de árvore e o intensificador linear e é otimizada para entrada esparsa
  • Personalização: Suporta funções personalizadas de objetivo e funções de avaliação

 

pln

Todos os direitos reservados ao autor.
Tradução automática do google.

4 comentários em “As melhores bibliotecas para Python e Processamento de Linguagem Natural”

  1. Scrapy é uma biblioteca pra criar “Bot de aranha”?? Meu amigo. Esta tradução está muito ruim. Não faz sentido.
    Scrapy é uma biblioteca pra fazer crawler ! E não tem nada a ver com Bot!
    Acho que vale a pena uma boa revisada neste trecho do artigo.

    Abs

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair /  Alterar )

Foto do Google

Você está comentando utilizando sua conta Google. Sair /  Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair /  Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair /  Alterar )

Conectando a %s