Diga não ao pip install na linha de comando! Esta é uma maneira alternativa de instalar TensorFlow em sua máquina local em 3 etapas.

Por que estou escrevendo isso?

Brinquei com o pip install com múltiplas configurações por várias horas, tentando descobrir como configurar corretamente meu ambiente do Python para o TensorFlow e o Keras.

Pouco antes de desistir, descobri isso…

"Um dos principais benefícios da instalação do TensorFlow usando conda em vez de pip é o resultado do sistema de gerenciamento de pacotes do conda. Quando o TensorFlow é instalado usando conda, o conda também instala todas as dependências necessárias e compatíveis para os pacotes."

Este artigo orientará você no processo de instalação do TensorFlow e do Keras usando a versão GUI do Anaconda. Presumo que você já tenha baixado e instalado o Anaconda Navigator.

Vamos começar!

1. Inicie o Anaconda Navigator. Vá para a guia Ambientes (Environments) e clique em 'Create'.

2. Insira um novo nome de ambiente - (eu coloquei 'tensorflow_env'). Certifique-se de selecionar Python 3.6 aqui! Em seguida, clique em 'Create' – o processo pode levar alguns minutos.

Nota da tradução: o Python, atualmente, está na versão 3.12. O Anaconda também possui novas versões capazes de instalar algo nas versões mais recentes do Python. Caso você queira, pode testar a instalação com versões mais novas.

3. Em seu novo ambiente 'tensorflow_env', selecione 'Not installed' e digite 'tensorflow'. Em seguida, marque 'tensorflow' e clique em 'Apply'. A janela de pop-up aparecerá. Vá em frente e clique em 'Apply'. Esse processo pode levar vários minutos.

Faça o mesmo para o 'keras'.

Verifique sua instalação importando os pacotes. Se tudo estiver bem, o comando não retornará nada. Se a instalação não for bem-sucedida, você receberá um erro.

Está feito! Você pode seguir este artigo (em inglês) para testar seus pacotes recém-instalados. 🙂

Obrigado pela leitura. Faça os testes!

Considere seguir o autor no GitHub, no Medium e no Twitter para obter mais artigos e tutoriais em seu feed, se gostou do artigo. 🙂

A maioria das tarefas que o aprendizado de máquina realiza atualmente inclui coisas como classificar imagens, traduzir idiomas, lidar com grandes quantidades de dados de sensores e prever valores futuros com base em valores atuais. Você pode escolher diferentes estratégias para se adequar ao problema que está tentando resolver.

A boa notícia? Existe um algoritmo em aprendizado de máquina que lidará com praticamente todos os dados que você puder lançar nele. Chegaremos lá em um minuto.

Aprendizado supervisionado x não supervisionado

Duas das estratégias mais comumente usadas em aprendizado de máquina incluem aprendizado supervisionado e aprendizado não supervisionado.

O que é o aprendizado supervisionado?

O aprendizado supervisionado ocorre quando você treina um modelo de aprendizado de máquina usando dados rotulados. Isso significa que você tem dados que já possuem a classificação correta associada a eles. Um uso comum do aprendizado supervisionado é ajudá-lo a prever valores para novos dados.

Com o aprendizado supervisionado, você precisará reconstruir seus modelos à medida que obtém novos dados, para garantir que as previsões retornadas ainda sejam precisas. Um exemplo de aprendizado supervisionado seria rotular imagens de alimentos. Você poderia ter um conjunto de dados dedicado apenas a imagens de pizza para ensinar ao seu modelo o que é uma pizza.

O que é o aprendizado não supervisionado?

O aprendizado não supervisionado ocorre quando você treina um modelo com dados não rotulados. Isso significa que o modelo terá que encontrar suas próprias características e fazer previsões com base em como os dados são classificados.

Um exemplo de aprendizado não supervisionado seria fornecer ao seu modelo imagens de vários tipos de alimentos sem rótulos. O conjunto de dados teria imagens de pizza, batatas fritas e outros alimentos, e você poderia utilizar algoritmos diferentes para fazer com que o modelo identificasse apenas as imagens de pizza sem nenhum rótulo.

Então, o que é um algoritmo?

Quando você ouvir pessoas falando sobre algoritmos de aprendizado de máquina, lembre-se de que elas estão falando sobre diferentes equações matemáticas.

Um algoritmo é apenas uma função matemática personalizável. É por isso que a maioria dos algoritmos possui coisas como funções de custo, valores de peso e parâmetros de funções que você pode alterar com base nos dados com os quais está trabalhando.  Basicamente, o aprendizado de máquina é apenas um monte de equações matemáticas que precisam ser resolvidas muito rapidamente.

É por isso que existem tantos algoritmos diferentes para lidas com diferentes tipos de dados. Um algoritmo em particular é a máquina de vetores de suporte (SVM, do inglês support vector machine) e é isso que este artigo abordará em detalhes.

O que é SVM?

Máquinas de vetores de suporte são um conjunto de métodos de aprendizado supervisionado utilizados para classificação, regressão, e detecção de outliers. Todas essas são tarefas comuns em aprendizado de máquina.

Você pode utilizá-los para detectar células cancerígenas com base em milhões de imagens ou para prever futuras rotas de direção com um modelo de regressão bem ajustado.

Existem tipos específicos de SVMs que você pode usar para problemas específicos de aprendizado de máquina, como vetor de suporte de regressão (SVR, do inglês support vector regression), que é uma extensão de vetor de suporte de classificação (SVC, do inglês support vector classification).

A principal coisa a se ter em mente aqui é que essas são apenas equações matemáticas ajustadas para fornecer a resposta mais precisa o mais rapidamente possível.

SVMs são diferentes de outros algoritmos de classificação devido à maneira como escolhem a fronteira de decisão (do inglês, decision boundary) que maximiza a distância dos pontos de dados mais próximo de todas as classes. A fronteira de decisão criada pelos SVMs é chamada de classificador de margem máxima ou o hiperplano de margem máxima.

Como funciona um SVM

Um classificador SVM linear simples funciona criando uma linha reta entre duas classes. Isso significa que todos os pontos de dados de um lado da linha representarão uma categoria, e os pontos de dados do outro lado da linha serão colocados em uma categoria diferente. Isso significa que pode haver um número infinito de linhas para escolher.

O que torna o algoritmo SVM linear melhor do que alguns dos outros algoritmos, como o k-vizinhos mais próximos, é que ele escolhe a melhor linha para classificar seus pontos de dados. Ele escolhe a linha que separa os dados e que fica o mais distante possível dos pontos de dados mais próximos.

Um exemplo 2D ajuda a entender todo o jargão do aprendizado de máquina. Basicamente, você tem alguns pontos de dados em uma grade. Você está tentando separar esses pontos de dados pela categoria em que eles deveriam se enquadrar, mas você não quer ter nenhum dado na categoria errada. Isso significa que você está tentando encontrar a linha entre os dois pontos mais próximos que mantém os outros pontos de dados separados.

Portanto, os dois pontos de dados mais próximos fornecem os vetores de suporte que você usará para encontrar essa reta. Essa linha é chamada de limite de decisão.

O limite de decisão não precisa ser uma linha. Também é chamado de hiperplano, porque você pode encontrar o limite de decisão com qualquer número de recursos, não apenas dois.

Tipos de SVMs

Existem dois tipos diferentes de SVMs, cada um usado para coisas diferentes:

• SVM simples: normalmente usado para regressão linear e problemas de classificação.
• SVM kernel: tem mais flexibilidade para dados não lineares porque você pode adicionar mais recursos para ajustar um hiperplano em vez de um espaço bidimensional.

Por que SVMs são usados em aprendizado de máquina?

SVMs são usados em aplicações como reconhecimento de escrita, detecção de intrusão, reconhecimento facial, classificação de e-mail, classificação de genes, e em páginas da web. Essa é uma das razões pelas quais usamos SVMs no aprendizado de máquina. Ele pode lidar tanto com classificação quanto regressão em dados lineares e não lineares.

Outra razão pela qual usamos SVMs é o fato de que eles podem encontrar relações complexas entre seus dados sem que você precise fazer muitas transformações por conta própria. É uma ótima opção quando você trabalha com conjuntos de dados menores, que possuem dezenas a centenas de milhares de recursos. Eles normalmente encontram resultados mais precisos quando comparados a outros algoritmos devido à sua capacidade de lidar com conjuntos de dados pequenos e complexos.

Aqui estão alguns dos prós e contras do uso de SVMs.

Prós

• Eficaz em conjuntos de dados com múltiplas características, como dados financeiros ou médicos.
• Eficaz nos casos em que o número de recursos é maior que o número de pontos de dados.
• Usa um subconjunto de pontos de treinamento na função de decisão chamados vetores de suporte, o que o torna eficiente em termos de memória.
• Diferentes funções de kernel podem ser especificadas para a função de decisão. Você pode usar kernels comuns, mas também é possível especificar kernels personalizados.

Contras

• Se o número de características for muito maior que o número de pontos de dados, é crucial evitar o sobreajuste (em inglês, overfitting) ao escolher as funções do kernel e o termo de regularização.
• SVMs não fornecem estimativas de probabilidade diretamente. Elas são calculados usando uma cara validação cruzada quíntupla.
• Funciona melhor em pequenos conjuntos de amostras devido ao seu alto tempo de treinamento.

Como os SVMs podem usar qualquer número de kernels, é importante que você conheça alguns deles.

Funções do kernel

Linear

Eles são comumente recomendados para classificação de texto, pois a maioria desses tipos de problemas de classificação são linearmente separáveis.

O kernel linear funciona muito bem quando há muitas características, e os problemas de classificação de texto têm muitas características. As funções lineares do kernel são mais rápidas que a maioria das outras e você tem menos parâmetros para otimizar.

Aqui está a função que define o kernel linear:

f(X) = w^T * X + b

Nesta equação, w é o vetor de peso (do inglês, weight) que você deseja minimizar, X são os dados que você está tentando classificar e b é o coeficiente linear estimado a partir dos dados de treinamento. Esta equação define o limite de decisão que o SVM retorna.

Polinomial

O kernel polinomial não é usado na prática com muita frequência porque não é tão eficiente computacionalmente quanto outros kernels e suas previsões não são tão precisas.

Aqui está a função para um kernel polinomial:

f(X1, X2) = (a + X1^T * X2) ^ b

Essa é uma das equações polinomiais de kernel mais simples que você pode usar. f(X1, X2) representa o limite de decisão polinomial que separará seus dados. X1 e X2 representam seus dados.

Função de base radial gaussiana (RBF)

Esse é um dos kernels mais poderosos e comumente usados em SVMs. Ele geralmente é a escolha para dados não lineares.

Aqui está a equação para um kernel RBF:

f(X1, X2) = exp(-gamma * ||X1 - X2||^2)

Nesta equação, gama especifica quanto um único ponto de treinamento tem sobre os outros pontos de dados ao seu redor. ||X1 - X2|| é o produto escalar entre seus recursos.

Sigmoide

Mais útil em redes neurais do que em máquinas de vetores de suporte, mas há casos de uso específicos ocasionais.

Aqui está a função para um kernel sigmoide:

f(X, y) = tanh(alpha * X^T * y + C)

Nesta função, alfa é um vetor de peso e C é um valor de deslocamento para explicar alguns erros de classificação de dados que podem ocorrer.

Outros

Existem muitos outros kernels que você pode usar em seu projeto. Essa pode ser uma decisão a ser tomada quando você precisar atender a certas restrições de erro, quiser tentar acelerar o tempo de treinamento ou quiser superajustar os parâmetros.

Alguns outros kernels incluem: ANOVA de base radial, tangente hiperbólica e Laplace RBF (texto em inglês).

Agora que você sabe um pouco sobre como os kernels funcionam nos bastidores, vamos ver alguns exemplos.

Exemplos com conjuntos de dados

Para mostrar como os SVMs funcionam na prática, passaremos pelo processo de treinamento de um modelo com ele usando a biblioteca Python Scikit-learn. Essa biblioteca é comumente usada em todos os tipos de problemas de aprendizado de máquina e funciona bem com outras bibliotecas Python.

Aqui estão as etapas encontradas regularmente em projetos de aprendizado de máquina:

• Importe o conjunto de dados
• Explore os dados para descobrir como eles são
• Pré-processe os dados
• Divida os dados em atributos e rótulos
• Divida os dados em conjuntos de treinamento e teste
• Treine o algoritmo SVM
• Faça algumas previsões
• Avalie os resultados do algoritmo

Algumas dessas etapas podem ser combinadas dependendo de como você lida com seus dados. Faremos um exemplo com um SVM linear e um SVM não linear. Você pode encontrar o código para esses exemplos aqui.

Exemplo de SVM linear

Começaremos importando algumas bibliotecas que facilitarão o trabalho com a maioria dos projetos de aprendizado de máquina.

import matplotlib.pyplot as plt
import numpy as np
from sklearn import svm

Para um exemplo linear simples, faremos apenas alguns dados fictícios e que atuarão no lugar da importação de um conjunto de dados.

# dados lineares
X = np.array([1, 5, 1.5, 8, 1, 9, 7, 8.7, 2.3, 5.5, 7.7, 6.1])
y = np.array([2, 8, 1.8, 8, 0.6, 11, 10, 9.4, 4, 3, 8.8, 7.5])

A razão pela qual estamos trabalhando com arrays numpy é para tornar as operações de matriz mais rápidas, pois elas usam menos memória do que as listas do Python. Você também pode aproveitar a digitação do conteúdo dos arrays. Agora, vamos dar uma olhada na aparência dos dados em um gráfico:

# exibir dados não classificados
plt.scatter(X, y)
plt.show()

Depois de ver a aparência dos dados, você poderá adivinhar melhor qual algoritmo funcionará melhor para você. Tenha em mente que esse é um conjunto de dados muito simples. Então, na maioria das vezes, você precisará trabalhar em seus dados para colocá-los em um estado utilizável.

Faremos um pré-processamento no código já estruturado. Isso colocará os dados brutos em um formato que podemos usar para treinar o modelo SVM.

# modelando os dados para o treinamento do modelo
training_X = np.vstack((X, y)).T
training_y = [0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1]

Agora, podemos criar o modelo SVM usando um kernel linear.

# defina o modelo
clf = svm.SVC(kernel='linear', C=1.0)

Essa linha de código acabou de criar um modelo completo de aprendizado de máquina. Agora, só precisamos treiná-lo com os dados que pré-processamos.

# treine o model
clf.fit(training_X, training_y)

É assim que você pode construir um modelo para qualquer projeto de aprendizado de máquina. O conjunto de dados que temos pode ser pequeno, mas se você encontrar um conjunto de dados do mundo real que possa ser classificado com um limite linear, esse modelo ainda funcionará.

Com seu modelo treinado, você pode fazer previsões sobre como um novo ponto de dados será classificado e criar um gráfico do limite de decisão. Vamos traçar o limite de decisão.

# obter os valores ponderados para a equação lineara partir do modelo do SVM treinado
w = clf.coef_[0]

# obter o deslocamento de y para a equação linear
a = -w[0] / w[1]

# criar o espaço do eixo x para os pontos de dados
XX = np.linspace(0, 13)

# obter os valores de y para colocar a fronteira de decisão no gráfico
yy = a * XX - clf.intercept_[0] / w[1]

# colocar a fronteira de decisão no gráfico
plt.plot(XX, yy, 'k-')

# exibir o gráfico visualmente
plt.scatter(training_X[:, 0], training_X[:, 1], c=training_y)
plt.legend()
plt.show()

Exemplo de SVM não linear

Neste exemplo, usaremos um conjunto de dados um pouco mais complicado para mostrar uma das áreas em que os SVMs se destacam. Vamos importar alguns pacotes.

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets
from sklearn import svm

Esse conjunto de importações é semelhante ao do exemplo linear, exceto que importa mais uma coisa. Agora, podemos usar um conjunto de dados diretamente da biblioteca Scikit-learn.

# dados não lineares
circle_X, circle_y = datasets.make_circles(n_samples=300, noise=0.05)

A próxima etapa é dar uma olhada na aparência desses dados brutos em um gráfico.

# mostrar os dados não lineares brutos (raw)
plt.scatter(circle_X[:, 0], circle_X[:, 1], c=circle_y, marker='.')
plt.show()

Agora que você pode ver como os dados são separados, podemos escolher um SVM não linear para começar. Esse conjunto de dados não precisa de nenhum pré-processamento antes de usá-lo para treinar o modelo. Portanto, podemos pular essa etapa. Aqui vemos como o modelo SVM ficará para isso:

# criar o algoritmo não linear para o modelo
nonlinear_clf = svm.SVC(kernel='rbf', C=1.0)

Nesse caso, usaremos um kernel RBF (Função de Base Radial Gaussiana) para classificar esses dados. Você também pode tentar o kernel polinomial para ver a diferença entre os resultados obtidos. Agora, é hora de treinar o modelo.

# treinamento do modelo não linear
nonlinear_clf.fit(circle_X, circle_y)

Você pode começar a rotular novos dados na categoria correta com base nesse modelo. Para ver como é o limite de decisão, teremos que criar uma função personalizada para representá-lo.

# Crie o gráfico para a fronteira de decisão para um problema do SVM não linear
def plot_decision_boundary(model, ax=None):
    if ax is None:
        ax = plt.gca()
        
    xlim = ax.get_xlim()
    ylim = ax.get_ylim()
    
    # crie a grade para avaliar o modelo
    x = np.linspace(xlim[0], xlim[1], 30)
    y = np.linspace(ylim[0], ylim[1], 30)
    Y, X = np.meshgrid(y, x)

	# modele os dados
    xy = np.vstack([X.ravel(), Y.ravel()]).T
    
	# obtenha a fronteira de decisão com base no modelo
    P = model.decision_function(xy).reshape(X.shape)
    
    # crie o gráfico para a fronteira de decisão
    ax.contour(X, Y, P,
               levels=[0], alpha=0.5,
               linestyles=['-'])

Você tem tudo o que precisa para traçar o limite de decisão para esses dados não lineares. Podemos fazer isso com algumas linhas de código que usam a biblioteca Matlibplot, assim como os outros gráficos.

# crie o gráfico para os dados e para a fronteira de decisão
plt.scatter(circle_X[:, 0], circle_X[:, 1], c=circle_y, s=50)
plot_decision_boundary(nonlinear_clf)
plt.scatter(nonlinear_clf.support_vectors_[:, 0], nonlinear_clf.support_vectors_[:, 1], s=50, lw=1, facecolors='none')
plt.show()

Quando você tem seus dados e conhece o problema que está tentando resolver, tudo pode ser realmente simples assim.

Você pode alterar completamente seu modelo de treinamento, escolher diferentes algoritmos e recursos para trabalhar e ajustar seus resultados com base em vários parâmetros. Existem bibliotecas e pacotes para tudo isso agora, então não há muita matemática com a qual você precise lidar.

Dicas para problemas do mundo real

Os conjuntos de dados do mundo real têm alguns problemas comuns devido ao tamanho que podem ter, aos diversos tipos de dados que contêm e a quanto poder de computação podem precisar para treinar um modelo.

Existem algumas coisas que você deve observar com SVMs em particular:

• Certifique-se de que seus dados estejam em formato numérico em vez de categórico. Os SVMs esperam números em vez de outros tipos de rótulos.
• Evite copiar dados tanto quanto possível. Algumas bibliotecas do Python duplicarão seus dados se eles não estiverem em um formato específico. A cópia de dados também diminuirá o tempo de treinamento e distorcerá a maneira como o modelo atribui os pesos a um recurso específico.
• Observe o tamanho do cache do kernel, pois ele usa sua RAM. Se você tiver um conjunto de dados muito grande, isso poderá causar problemas ao seu sistema.
• Dimensione seus dados, pois os algoritmos SVM não são invariantes à escala. Isso significa que você pode converter todos os seus dados para ficarem dentro dos intervalos de [0, 1] ou [-1, 1].

Outras considerações

Você pode se perguntar por que não entrei em detalhes profundos da matemática aqui. Isso ocorreu, principalmente, pelo fato de que eu não quero assustar as pessoas e impedi-las de aprender mais sobre aprendizado de máquina.

É divertido aprender sobre essas equações matemáticas longas e complicadas e suas derivações, mas é raro você escrever seus próprios algoritmos e provas em projetos reais.

É como ocorre com a maioria das outras coisas que você usa todos os dias, como o telefone ou o computador. Você pode fazer tudo o que precisa sem saber como os processadores são construídos.

O aprendizado de máquina é como qualquer outra aplicação da engenharia de software. Existem vários pacotes que tornam mais fácil obter os resultados necessários sem um conhecimento profundo em estatística.

Depois de praticar um pouco com os diferentes pacotes e bibliotecas disponíveis, você descobrirá que a parte mais difícil do aprendizado de máquina é obter e rotular seus dados.

A autora trabalha em neurociência, aprendizado de máquina e com questões baseadas na web! Siga a autora no Twitter para saber mais a respeito e sobre outras coisas interessantes em tecnologia.

Em um tutorial anterior do freeCodeCamp, expliquei como criar visualizações de dados com atualizações automáticas em Python (texto em inglês).

Alguns leitores perguntaram se havia algum modo de tornar as visualizações interativas. Felizmente, uma solução fácil já está disponível!

Neste tutorial, vou ensinar como você pode criar visualizações interativas de dados em Python. Essas visualizações são excelentes candidatas para incorporação em seu blog ou site.

A visualização de dados específica com a qual trabalharemos

Em vez de construir uma visualização de dados inteira do zero neste artigo, trabalharemos com a visualização que criamos em meu último tutorial.

A visualização usa pandas, matplotlib e Python para apresentar vários pontos de dados dos 5 maiores bancos de capital aberto dos Estados Unidos.

Aqui está uma imagem estática da visualização que criamos:

O código real para a visualização está incluído abaixo. Abordamos isso no último tutorial, mas observe que você precisará gerar sua própria chave de API IEX Cloud e incluí-la na variável IEX_API_Key para que o script funcione.

############################
#Importação das dependências
############################

import pandas as pd
import matplotlib.pyplot as plt

###############################
#Importação e limpeza dos dados
###############################

IEX_API_Key = ''

tickers = [
            'JPM',
            'BAC',
            'C',
            'WFC',
            'GS',
            ]

#Crie uma string vazia chamada `ticker_string`, a qual adicionaremos tickers e vírgulas
ticker_string = ''

#Percorra cada elemento de `tickers` e adicione-os com uma vírgula a ticker_string
for ticker in tickers:
    ticker_string += ticker
    ticker_string += ','
    
#Remova a última vírgula de `ticker_string`
ticker_string = ticker_string[:-1]

#Crie as strings endpoint e years
endpoints = 'chart'
years = '5'

#Faça a interpolação das strings endpoint em HTTP_request string
HTTP_request = f'https://cloud.iexapis.com/stable/stock/market/batch?symbols={ticker_string}&types={endpoints}&range={years}y&cache=true&token={IEX_API_Key}'

#Envie a solicitação HTTP à API IEX Cloud e armazene a resposta em um DataFrame do pandas
bank_data = pd.read_json(HTTP_request)

#Crie uma lista vazia, onde adicionaremos uma série do pandas de dados de preços de ações
series_list = []

#Percorra cada um dos tickers e mostre uma série do pandas com seus preços ao encerramento da bolsa nos últimos 5 anos
for ticker in tickers:
    series_list.append(pd.DataFrame(bank_data[ticker]['chart'])['close'])

#Adicione a coluna dates (datas)
series_list.append(pd.DataFrame(bank_data['JPM']['chart'])['date'])

#Copie a lista 'tickers' que aparece anteriormente no script e adicione um novo elemento chamado 'Date'. 
#Esses elementos serão os nomes das colunas de nosso DataFrame do pandas posteriormente.
column_names = tickers.copy()
column_names.append('Date')

#Concatene as séries do pandas Series em um único DataFrame
bank_data = pd.concat(series_list, axis=1)

#Nomeie as colunas do DataFrame e defina a coluna 'Date' como o índice
bank_data.columns = column_names
bank_data.set_index('Date', inplace = True)

########################
#Crie a imagem do Python
########################

#Defina o tamanho do canvas do matplotlib
fig = plt.figure(figsize = (18,8))

################################################
################################################
#Crie subgráficos no Python
################################################
################################################

########################
#Subgráfico 1
########################
plt.subplot(2,2,1)

#Gere o diagrama de caixas (boxplot)
plt.boxplot(bank_data.transpose())

#Adicione títulos ao gráfico e aos eixos
plt.title('Boxplot of Bank Stock Prices (5Y Lookback)')
plt.xlabel('Bank')
plt.ylabel('Stock Prices')

#Adicione os rótulos a cada diagrama de caixas individual no canvas
ticks = range(1, len(bank_data.columns)+1)
labels = list(bank_data.columns)
plt.xticks(ticks,labels)

########################
#Subgráfico 2
########################
plt.subplot(2,2,2)

#Crie os dados do eixo x
dates = bank_data.index.to_series()
dates = [pd.to_datetime(d) for d in dates]

#Crie os dados do eixo y
WFC_stock_prices =  bank_data['WFC']

#Gere o gráfico de dispersão (scatterplot)
plt.scatter(dates, WFC_stock_prices)

#Adicione títulos ao gráfico e aos eixos
plt.title("Wells Fargo Stock Price (5Y Lookback)")
plt.ylabel("Stock Price")
plt.xlabel("Date")

########################
#Subgráfico 3
########################
plt.subplot(2,2,3)

#Crie os dados do eixo x
dates = bank_data.index.to_series()
dates = [pd.to_datetime(d) for d in dates]

#Crie os dados do eixo y
BAC_stock_prices =  bank_data['BAC']

#Gere o gráfico de dispersão (scatterplot)
plt.scatter(dates, BAC_stock_prices)

#Adicione títulos ao gráfico e aos eixos
plt.title("Bank of America Stock Price (5Y Lookback)")
plt.ylabel("Stock Price")
plt.xlabel("Date")

########################
#Subgráfico 4
########################
plt.subplot(2,2,4)

#Gere o histograma
plt.hist(bank_data.transpose(), bins = 50)

#Adicione uma legenda ao histograma
plt.legend(bank_data.columns,fontsize=10)

#Adicione títulos ao gráfico e aos eixos
plt.title("A Histogram of Daily Closing Stock Prices for the 5 Largest Banks in the US (5Y Lookback)")
plt.ylabel("Observations")
plt.xlabel("Stock Prices")

plt.tight_layout()

################################################
#Salve a imagem em sua máquina local
################################################

plt.savefig('bank_data.png')

Agora que entendemos a visualização específica com a qual trabalharemos, vamos falar sobre o que significa uma visualização ser interativa.

O que significa uma visualização ser interativa?

Existem dois tipos de visualizações de dados que são úteis para embutir em seu site.

O primeiro tipo é uma visualização estática. Esta é basicamente uma imagem - pense em arquivos .png ou .jpg.

O segundo tipo é uma visualização dinâmica. Essas visualizações mudam em resposta ao comportamento do usuário, geralmente via panorâmica ou zoom. As visualizações dinâmicas não são armazenadas em arquivos .png ou .jpg, mas geralmente em tags svg ou iframe.

Este tutorial é sobre criação de visualizações dinâmicas de dados. Especificamente, a visualização que queremos criar terá as seguintes características:

1. Você clicará em um botão no canto inferior esquerdo para ativar o modo dinâmico.
2. Depois que o modo dinâmico estiver ativado, você poderá ampliar e deslocar a visualização com o mouse.
3. Você também pode cortar e dar zoom em uma seção específica da visualização.

Na próxima seção deste tutorial, você aprenderá como instalar e importar a biblioteca mpld3, que é a dependência do Python que usaremos para criar nossos gráficos interativos.

Como importar a biblioteca mpld3

Para usar a biblioteca mpld3 em nossa aplicação do Python, há duas etapas que precisamos concluir primeiro:

1. Instalar a biblioteca mpld3 na máquina em que estamos trabalhando.
2. Importar a biblioteca mpld3 em nosso script do Python.

Primeiro, vamos instalar o mpld3 em nossa máquina local.

A maneira mais fácil de fazer isso é usando o gerenciador de pacotes pip para Python3. Se você já tem o pip instalado em sua máquina, você pode fazer isso executando a seguinte declaração na sua linha de comando:

pip3 install mpld3

Agora que o mpld3 está instalado em sua máquina, podemos importá-lo para nosso script do Python com a seguinte declaração:

import mpld3

Para facilitar a leitura, é considerada uma prática recomendada incluir essa importação junto com o restante das importações na parte superior de seu script. Isso significa que agora sua seção de importação ficará assim:

############################
#Importação das dependências
############################

import pandas as pd
import matplotlib.pyplot as plt
import mpld3

Como transformar uma visualização estática do matplotlib em uma visualização interativa de dados

A principal funcionalidade da biblioteca mpld3 é pegar uma visualização matplotlib existente e transformá-la em algum código HTML que você pode embutir em seu site.

A ferramenta que usamos para isso é o arquivo fig_to_html do mpld3, que aceita um objeto figure do matplotlib como seu único argumento e retorna HTML.

Para usar o método fig_to_html para nosso propósito, basta adicionar o seguinte código ao final do nosso script do Python:

html_str = mpld3.fig_to_html(fig)
Html_file= open("index.html","w")
Html_file.write(html_str)
Html_file.close()

Este código gera o HTML e o salva com o nome de arquivo index.html em seu diretório de trabalho atual. Esta é a aparência disso quando renderizado em uma página da web:

Ao passar o mouse sobre esta visualização, três ícones aparecerão no canto inferior esquerdo. O ícone esquerdo retorna a visualização à sua aparência padrão. O ícone do meio ativa o modo dinâmico. O ícone direito permite cortar e aplicar zoom em um ponto específico da visualização.

Um erro comum ao trabalhar com pandas e mpld3

Ao criar a visualização interativa neste tutorial, você pode encontrar o seguinte erro gerado pelo mpld3:

TypeError: array([ 1.]) is not JSON serializable

Felizmente, existe uma solução bem documentada para esse erro no GitHub.

Você precisa editar o arquivo _display.py encontrado em Lib\site-packages\mpld3 e substituir a classe NumpyEncoder por esta:

class NumpyEncoder(json.JSONEncoder):
    """ Special json encoder for numpy types """

    def default(self, obj):
        if isinstance(obj, (numpy.int_, numpy.intc, numpy.intp, numpy.int8,
            numpy.int16, numpy.int32, numpy.int64, numpy.uint8,
            numpy.uint16,numpy.uint32, numpy.uint64)):
            return int(obj)
        elif isinstance(obj, (numpy.float_, numpy.float16, numpy.float32, 
            numpy.float64)):
            return float(obj)
        try: # Added by ceprio 2018-04-25
            iterable = iter(obj)
        except TypeError:
            pass
        else:
            return list(iterable)
         # Let the base class default method raise the TypeError
        return json.JSONEncoder.default(self, obj)

Depois que essa substituição for feita, seu código deverá funcionar corretamente e seu arquivo index.html deverá ser gerado com êxito.

Reflexões finais

Neste tutorial, você aprendeu como criar visualizações interativas de dados em Python usando as bibliotecas matplotlib e mpld3. Aqui está um resumo específico do que abordamos:

1. A definição de uma visualização dinâmica de dados
2. Como instalar e importar a biblioteca mpld3 em Python
3. Como usar a biblioteca mpld3 para transformar uma visualização do matplotlib em uma visualização dinâmica que você pode embutir em seu site
4. Como corrigir um erro comum que os usuários da biblioteca mpld3 enfrentam

Este tutorial foi escrito por Nick McCullum, que ensina desenvolvimento em Python e JavaScript em seu site.

Escrito por: Maxim Mamaev

Vamos pegar um problema computacional como exemplo, escrever o código e ver como podemos melhorar o tempo de execução. Aqui vamos nós.

Montando a cena: o problema da mochila

Este é o problema computacional que usaremos como exemplo:

O problema da mochila é um problema bem conhecido em otimização combinatória. Nesta seção, revisaremos seu tipo mais comum, o problema da mochila 0–1, e sua solução por meio de programação dinâmica. Se você estiver familiarizado com o assunto, pode pular essa parte.

Você recebe uma mochila de capacidade C e uma coleção de N itens. Cada item tem peso w[i] e valor v[i]. Sua tarefa é arrumar a mochila com os itens mais valiosos. Em outras palavras, você deve maximizar o valor total dos itens que coloca na mochila, com uma restrição: o peso total dos itens levados não pode exceder a capacidade da mochila.

Depois de obter uma solução, o peso total dos itens na mochila é chamado de "peso da solução" e seu valor total é o "valor da solução".

O problema tem muitas aplicações práticas. Por exemplo, você decidiu investir R$ 1.600 em uma famosa ação da FAANG (nome coletivo das ações do Facebook, Amazon, Apple, Netflix e Google, também conhecida como Alphabet). Cada ação tem um preço de mercado atual e a estimativa de preço de um ano. A partir de um dia em 2018, eles são os seguintes:

========= ======= ======= ==========
Empresa   Ticker   Preço  Estimativa
========= ======= ======= ==========
Alphabet  GOOG    1030    1330
Amazon    AMZN    1573    1675
Apple     AAPL    162     193 
Facebook  FB      174     216 
Netflix   NFLX    312     327
========= ======= ======= ==========

Para simplificar o exemplo, vamos supor que você nunca colocaria todos os seus ovos na mesma cesta. Você está disposto(a) a comprar não mais do que uma ação de cada. Quais ações você compra para maximizar seu lucro?

Esse é um problema da mochila. Seu orçamento (R$ 1.600) é a capacidade (C) de armazenamento. As ações são os itens a serem embalados. Os preços atuais são os pesos (w). As estimativas de preços são os valores. O problema parece trivial. No entanto, a solução não é evidente à primeira vista – se você deve comprar uma ação da Amazon, ou uma ação do Google mais uma de alguma combinação de Apple, Facebook, ou Netflix.

Claro que, nesse caso, você pode fazer cálculos rápidos à mão e chegar na solução: você deve comprar Google, Netflix, e Facebook. Desse modo, você gasta R$ 1.516 e espera ganhar R$ 1.873.

Agora, você acredita que descobriu uma mina de outro. Você destrói seu cofrinho e recebe R$ 10.000. Apesar de sua empolgação, você permanece inflexível com a regra "uma ação – uma compra". Portanto, com esse orçamento maior, você tem que ampliar suas opções. Você decide considerar todas as 100 ações da lista da NASDAQ como candidatas para compra.

O futuro nunca foi tão brilhante, mas, de repente, você percebe que, para identificar sua carteira de investimentos ideal, você terá que verificar cerca de 2¹⁰⁰ combinações. Mesmo que você seja superotimista com a iminência e a onipresença da economia digital, qualquer economia requer — no mínimo — um universo onde funcione. Infelizmente, em alguns trilhões de anos, quando sua computação terminar, nosso universo provavelmente não existirá.

Algoritmo de programação dinâmica

Temos que abandonar a abordagem de força bruta e programar alguma solução inteligente. Pequenos problemas de mochila (e o nosso é pequeno, acredite ou não) são resolvidos por programação dinâmica. A ideia básica é partir de um problema trivial cuja solução conhecemos e depois adicionaremos complexidade passo a passo.

Se você achar as explicações a seguir muito abstratas, aqui está uma ilustração comentada da solução para um problema de mochila bem pequeno. Isso ajudará você a visualizar o que está acontecendo.

Suponha que, dados os primeiros itens i da coleção, nós saibamos os valores de solução s(i, k) para todas as capacidades de mochila k no intervalo de 0 a C.

Em outras palavras, costuramos mochilas "auxiliares" C+1 de todos os tamanhos de 0 a C. Em seguida, organizamos nossa coleção, pegamos o primeiro item i e temporariamente separamos todo o resto. E agora assumimos que, por alguma mágica, nós sabemos como embalar de maneira ideal cada um dos pacotes desse conjunto funcional de i itens. Os itens que escolhemos do conjunto funcional podem ser diferentes para pacotes diferentes, mas no momento não estamos interessados em quais itens pegamos ou pulamos. É apenas o valor da solução s(i, k) que registramos para cada um de nosso pacotes recém costurados.

Agora, buscamos o próximo item (i+1)º da coleção e adicionamos ao conjunto funcional. Vamos encontrar valores de solução para todas as mochilas auxiliares com esse novo conjunto funcional. Em outras palavras, nós encontramos s(i+1, k) para todo k=0..C dado s(i, k).

Se k for menor que o peso do novo item w[i+1], não podemos pegar esse item. De fato, mesmo que pegássemos apenas esse item, ele sozinho não caberia na mochila. Portanto, s(i+1, k) = s(i, k) para todo k < w[i+1].

Para os valores k >= w[i+1] temos que fazer uma escolha: ou colocamos o novo item na mochila de capacidade k ou o pulamos. Temos que avaliar essas duas opções para determinar qual delas nos dá mais valor embalado no pacote.

Se pegarmos o (i+1)º item, adquirimos o valor v[i+1] e consumimos a parte da capacidade da mochila para acomodar o peso w[i+1]. Isso nos deixa com a capacidade k–w[i+1] que devemos preencher de modo otimizado usando (alguns dos) primeiros i itens. Esse preenchimento otimizado tem o valor de solução s(i, k–w[i+1]). Esse número já é conhecido por nós porque, por suposição, conhecemos todos os valores de solução para o conjunto funcional de i itens. Portanto, o valor da solução candidata para a mochila k com o item i+1 levado seria
s(i+1, k | i+1 levado) = v[i+1] + s(i, k–w[i+1]).

A outra opção seria pular o item i+1. Nesse caso, nada muda em nossa mochila, e o valor da solução candidata seria o mesmo que s(i, k).

Para decidir sobre a melhor opção, comparamos os dois candidatos para os valores da solução:

s(i+1, k | i+1 levado) = v[i+1] + s(i, k–w[i+1])
s(i+1, k | i+1 ignorado) = s(i, k)

O máximo destes torna-se a solução s(i+1, k).

Resumindo:

if k < w[i+1]:
	s(i+1, k) = s(i, k)
else:
	s(i+1, k) = max( v[i+1] + s(i, k-w[i+1]), s(i, k) )

Agora, podemos resolver o problema da mochila passo a passo. Começamos com o conjunto de trabalho vazio (i=0). Obviamente, s(0, k) = 0 para qualquer k. Em seguida, avançamos adicionando itens ao conjunto de trabalho e encontrando os valores de solução s(i, k) até chegarmos a s(i+1=N, k=C), que é o valor de solução do problema original.

Observe que, ao fazer isso, construímos a grade de valores da solução NxC.

No entanto, apesar de ter aprendido o valor da solução, não sabemos exatamente quais itens foram colocados na mochila. Para descobrir isso, retrocedemos a grade. Partindo de s(i=N, k=C), comparamos s(i, k) com s(i–1, k).

Se s(i, k) = s(i–1, k), o i-ésimo item não foi considerado. Nós reiteramos com i=i–1 mantendo o valor de k inalterado. Caso contrário, o i-ésimo item foi retirado e, para a próxima etapa de exame, encolhemos a mochila em w[i] — definimos i=i–1, k=k–w[i].

Desse modo, examinamos todos os itens do N-ésimo ao primeiros e determinamos quais deles foram colocados na mochila. Isso nos dá a solução para o problema da mochila.

Código e análise

Como temos o algoritmo, vamos comparar várias implementações, começando por uma simples. O código está disponível no GitHub.

Os dados são a lista Nasdaq 100, contendo preços atuais e estimativas de preços para cem ações (até um dia em 2018). Nosso orçamento de investimento é de R$ 10.000.

Lembre-se que preços de ações não são números redondos em reais, mas vêm com centavos. Portanto, para obter a solução exata, temos que contar tudo em centavos — definitivamente queremos evitar números float. Portanto, a capacidade de nossa mochila é ($)10.000 x 100 centavos = ($)1.000.000, e o tamanho total de nosso problema N x C = 1.000.000.

Com um inteiro ocupando 4 bytes de memória, esperamos que o algoritmo vá consumir aproximadamente 400 MB de RAM. Portanto, a memória não será uma limitação. É com o tempo de execução que devemos no preocupar.

Claro, todas as nossas implementações produzirão a mesma solução. Para referência, o investimento (o peso da solução) é 999930 (R$ 9.999,30) e o retorno esperado (o valor da solução) é 1219475 (R$ 12.194,75). A lista de ações a comprar é bem longa (80 de 100 itens). Você pode obtê-la rodando o código.

Lembre-se de que este é um exercício de programação, não um conselho de investimento. Quando você for ler esse artigo, os preços e as estimativas terão mudado em relação ao que é usado aqui como exemplo.

Os bons e velhos loops do tipo "for"

A implementação direta do algoritmo é dada abaixo.

def solve_naive(capacity, items, weights, values):

    grid = [[0] * (capacity+1)]
    for item in range(items):
        grid.append(grid[item].copy())
        for k in range(weights[item], capacity+1):
            grid[item + 1][k] = max(grid[item][k], grid[item][k-weights[item]] + values[item])

    solution_value = grid[items][capacity]
    solution_weight = 0
    taken = []
    k = capacity
    for item in range(items, 0, -1):
        if grid[item][k] != grid[item-1][k]:
            taken.append(item - 1)
            k -= weights[item - 1]
            solution_weight += weights[item-1]

    return solution_value, solution_weight, taken

Existem duas partes.

Na primeira parte (linhas 3-7 acima), dois loops for aninhados são usados para construir a grade da solução.

O loop externo adiciona itens ao conjunto de trabalho até atingirmos N (o valor de N é passado no parâmetro items). A linha de valores de solução para cada novo conjunto de trabalho é inicializada com os valores calculados para o conjunto de trabalho anterior.

O loop interno para cada conjunto de trabalho itera os valores de k do peso do item recém adicionado a C (o valor de C é passado no parâmetro capacity).

Note que não precisamos iniciar o loop de k=0. Quando k é menor do que o peso do item, os valores da solução são sempre os mesmos calculados para o conjunto de trabalho anterior. Esses números já foram copiados para a linha atual pela inicialização.

Quando os loops são concluídos, temos a grade e o valor da solução.

A segunda parte (linhas 9-17) é um único loop for de N iterações. Ele retrocede a grade para descobrir quais itens foram levados pela mochila.

Mais adiante, nos concentraremos exclusivamente na primeira parte do algoritmo, já que este possui complexidade de tempo e espaço O(N*C). A parte de retrocesso requer apenas tempo O(N) e não gasta nenhuma memória adicional – seu consumo de recursos é relativamente insignificante.

A implementação direta leva 180 segundos para resolver o problema da mochila Nasdaq 100 no meu computador.

Isso é muito ruim? Por um lado, com as velocidades da era moderna, não estamos acostumados a passar três minutos esperando que um computador faça as coisas. Por outro lado, o tamanho do problema - cem milhões - parece realmente intimidador, então, talvez, três minutos seja ok?

Para obter algum benchmark, vamos programar o mesmo algoritmo em outra linguagem. Precisamos de uma linguagem compilada estaticamente tipada para garantir a velocidade de computação. Não, não C. Não é chique. Vamos seguir a moda e escrever em Go:

func solver(capacity, items int, weights, values []int) (int, int, []int) {
    
    grid :=  make([][]int, items+1, items+1)
    grid[0] = make([]int, capacity+1, capacity+1) 

    for item := 0; item < items; item++ {

        grid[item+1] = make([]int, capacity+1, capacity+1)
        for k:=0; k<weights[item]; k++ {
            grid[item + 1][k] = grid[item][k]
        }
        for k:=weights[item]; k <= capacity; k++ {
            grid[item + 1][k] = max(grid[item][k], grid[item][k-weights[item]] + values[item])
        }
    } 

    solution_value := grid[items][capacity]
    solution_weight := 0
    var taken []int
    k := capacity
    for item := items; item > 0; item-- {
        if grid[item][k] != grid[item-1][k] {
            taken = append(taken, item-1)
            k -= weights[item - 1]
            solution_weight += weights[item-1]
        }
    }

    return solution_value, solution_weight, taken
}

Como você pode ver, o código Go é bem similar ao do Python. Até copiei e colei uma linha, a mais longa, como está.

Qual é o tempo de execução? 400 milissegundos! Em outras palavras, o Python foi 500 vezes mais lento do que o Go. A lacuna provavelmente será ainda maior se tentarmos em C. Isso é definitivamente um desastre para o Python.

Para descobrir o que torna o código Python mais lento, vamos executá-lo com o line profiler. Você pode encontrar a saída do profiler para esta implementação e as subsequentes do algoritmo no GitHub.

No solucionador direto, 99,7% do tempo de execução é gasto em duas linhas. Essas duas linhas compõem o loop interno, que é executado 98 milhões de vezes:

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    ...
    42       101        170.0      1.7      0.0  for item in range(items):
    43       100    1457275.0  14572.8      0.3      grid.append(grid[item].copy())
    44  98387558  121134401.0      1.2     26.4      for k in range(weights[item], capacity+1):
    45  98387458  336078747.0      3.4     73.3          grid[item + 1][k] = max(grid[item][k], grid[item][k-weights[item]] + values[item])
    ...

Peço desculpas pelas linhas excessivamente longas, mas o line profiler não pode lidar adequadamente com quebras de linha na mesma instrução.

Ouvi dizer que o operador for do Python é lento, mas, curiosamente, a maior parte do tempo não é gasta na linha for mas no corpo do loop.

Podemos dividir o corpo do loop em operações individuais para ver se alguma operação específica é muito lenta:

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    ...
    67       101        196.0      1.9      0.0      for item in range(items):
    68       100    1454886.0  14548.9      0.2          grid.append(grid[item].copy())
    69       100       1463.0     14.6      0.0          wi = weights[item]
    70       100        323.0      3.2      0.0          vi = values[item]
    71  98387558  133663554.0      1.4     16.7          for k in range(wi, capacity+1):
    72  98387458  156110242.0      1.6     19.4              a = grid[item][k]
    73  98387458  194935490.0      2.0     24.3              b = grid[item][k-wi] + vi
    74  98387458  138902753.0      1.4     17.3              if b > a:
    75  60782758  109728042.0      1.8     13.7                  grid[item + 1][k] = b
    76                                                       else:
    77  37604700   67944391.0      1.8      8.5                  grid[item + 1][k] = a
    ...

Parece que nenhuma operação em particular se destaca. Os tempos de execução das operações individuais dentro do loop interno são praticamente os mesmos que os tempos de execução de operações análogas em outras partes do código.

Observe como quebrar o código aumentou o tempo total de execução. O loop interno agora leva 99,9% do tempo de execução. Quanto mais burro seu código Python, mais lento ele fica. Interessante, não é?

Função map integrada

Vamos tornar o código mais otimizado e substituir o loop for interno por uma função map() integrada:

def solve_map(capacity, items, weights, values):
  
    grid = [[0] * (capacity+1)]
    for item in range(items):
        grid.append(grid[item].copy())
        this_weight = weights[item]
        this_value = values[item]
        
        grid[item+1][this_weight:] = 
            list(map(lambda k: max(grid[item][k], 
                                   grid[item][k - this_weight] + this_value), 
                     range(this_weight, capacity+1)))
        
    solution_value = grid[items][capacity]
    solution_weight = 0
    taken = []
    k = capacity
    for item in range(items, 0, -1):
        if grid[item][k] != grid[item-1][k]:
            taken.append(item - 1)
            k -= weights[item - 1]
            solution_weight += weights[item-1]

    return solution_value, solution_weight, taken

O tempo de execução desse código é de 102 segundos, estando 78 segundos abaixo da pontuação da implementação direta. De fato, map() é executado visivelmente, mas não excessivamente, mais rápido.

List comprehension

Você deve ter notado que cada execução do loop interno produz uma lista (que é adicionada à grade de solução como uma nova linha). O jeito do Python de criar listas é, claro, list comprehension. Vamos tentar isso, em vez de map().

def solve_list_comp(capacity, items, weights, values):

    grid = [[0] * (capacity+1)]
    for item in range(items):
        grid.append(grid[item].copy())
        this_weight = weights[item]
        this_value = values[item]
        
        grid[item+1][this_weight:] = 
            [max(grid[item][k], grid[item][k - this_weight] + this_value) 
             for k in range(this_weight, capacity+1)]
        
    solution_value = grid[items][capacity]
    solution_weight = 0
    taken = []
    k = capacity
    for item in range(items, 0, -1):
        if grid[item][k] != grid[item-1][k]:
            taken.append(item - 1)
            k -= weights[item - 1]
            solution_weight += weights[item-1]

    return solution_value, solution_weight, taken

O programa terminou em 81 segundos. Conseguimos outra melhoria e reduzimos o tempo de execução pela metade em comparação à implementação direta (180 s). Fora de contexto, isso seria elogiado como um progresso significativo. Infelizmente, ainda estamos a anos-luz do nosso benchmark de 0,4 s.

Arrays do NumPy

Por fim, esgotamos as ferramentas integradas do Python. Sim, posso ouvir o rugido do público cantando "NumPy! NumPy!" Mas, para apreciar a eficiência do NumPy, devemos colocá-lo em contexto, tentando for, map() e list comprehension de antemão.

Ok, agora é a hora do NumPy. Então, abandonamos as listas e colocamos nossos dados em arrays do NumPy:

def solve_list_comp_numpy(capacity, items, weights, values):

    grid = np.empty((items + 1, capacity + 1), dtype=int)
    grid[0] = 0
    for item in range(items):
        grid[item+1] = grid[item]
        this_weight = weights[item]
        this_value = values[item]
        
        grid[item+1, this_weight:] = 
            [max(grid[item, k], grid[item, k - this_weight] + this_value) 
             for k in range(this_weight, capacity+1)]

    solution_value = grid[items, capacity]
    solution_weight = 0
    taken = []
    k = capacity
    for item in range(items, 0, -1):
        if grid[item, k] != grid[item-1, k]:
            taken.append(item - 1)
            k -= weights[item - 1]
            solution_weight += weights[item-1]

    return solution_value, solution_weight, taken

De repente, o resultado é desencorajador. Este código é executado 1,5 vezes mais devagar do que a solução sem graça por list comprehension (123 s em comparação com os 81 s). Como isso?

Vamos examinar os perfis de linha para ambos solucionadores.

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
Vanilla list comprehension

   245         1       8212.0   8212.0      0.0  grid = [[0] * (capacity+1)]
   246
   247       101       1654.0     16.4      0.0  for item in range(items):
   248       100    1452204.0  14522.0      0.7      grid.append(grid[item].copy())
   249       100       1603.0     16.0      0.0      this_weight = weights[item]
   250       100        272.0      2.7      0.0      this_value = values[item]
   251
   252       100  202696910.0 2026969.1     99.3     grid[item+1][this_weight:] = [max(grid[item][k], grid[item][k - this_weight] + this_value) for k in range(this_weight, capacity+1)]

Using numpy arrays

   273         1         42.0     42.0      0.0  grid = np.empty((items + 1, capacity + 1), dtype=int)
   274         1       2527.0   2527.0      0.0  grid[0] = 0
   275       101       1427.0     14.1      0.0  for item in range(items):
   276       100     322952.0   3229.5      0.1      grid[item+1] = grid[item]
   277       100       1341.0     13.4      0.0      this_weight = weights[item]
   278       100        266.0      2.7      0.0      this_value = values[item]
   279       100  311244493.0 3112444.9     99.9     grid[item+1, this_weight:] = [max(grid[item, k], grid[item, k - this_weight] + this_value) for k in range(this_weight, capacity+1)]

A inicialização do grid[0] como um array do NumPy (linha 274) é três vezes mais rápida do que quando é feita com uma lista do Python (linha 245). Dentro do loop externo, a inicialização do grid[item+1] é 4,5 vezes mais rápida para um array do NumPy (linha 276) do que para uma lista (linha 248). Até agora, tudo bem.

No entanto, a execução da linha 279 é 1,5 vezes mais lenta do que seu análogo sem o NumPy na linha 252. O problema é que list comprehension cria uma lista de valores, mas armazenamos esses valores em um array do NumPy que é encontrado no lado esquerdo da expressão. Portanto, essa linha adiciona implicitamente uma sobrecarga de conversão de uma lista em um array do NumPy. Com a linha 279 respondendo por 99,9% do tempo de execução, todas as vantagens do NumPy observadas anteriormente tornam-se insignificantes.

Ainda precisamos, porém, de uma maneira de iterar por meio de arrays para fazer cálculos. Já aprendemos que list comprehension é a ferramenta de iteração mais rápida. A propósito, se você tentar construir um array do NumPy dentro de um bom e velho loop for, evitando a conversão de lista para array do NumPy, obterá o impressionante tempo de execução de 295 segundos. Então, estamos travados e o NumPy é inútil? Claro que não.

Uso adequado do NumPy

Apenas armazenar dados em arrays do NumPy não adianta. O verdadeiro poder do NumPy vem com as funções que executam cálculos em arrays do NumPy. Elas pegam arrays como parâmetros e retornam arrays como resultados.

Por exemplo, existe a função where(), que recebe três arrays como parâmetros: condition, x, e y, e retorna um array construído pela seleção de elementos de x ou de y. O primeiro parâmetro, condition, é um array de booleanos. Ele diz de onde escolher: se um elemento de condition for avaliado como True, o elemento correspondente de x é enviado para a saída, caso contrário, o elemento de y é selecionado.

Observe que a função do NumPy faz tudo isso em uma única chamada. Percorrer os arrays passa a ser um processo integrado.

É assim que usamos where() como um substituto do loop for interno no primeiro solucionador ou, respectivamente, o list comprehension do último:

def solve_numpy_func(capacity, items, weights, values):

    grid = np.empty((items + 1, capacity + 1), dtype=int)
    grid[0] = 0
    for item in range(items):
        this_weight = weights[item]
        this_value = values[item]
        grid[item+1, :this_weight] = grid[item, :this_weight]
        temp = grid[item, :-this_weight] + this_value
        grid[item + 1, this_weight:] = 
            np.where(temp > grid[item, this_weight:], 
                     temp, 
                     grid[item, this_weight:])

    solution_value = grid[items, capacity]
    solution_weight = 0
    taken = []
    k = capacity
    for item in range(items, 0, -1):
        if grid[item][k] != grid[item - 1][k]:
            taken.append(item - 1)
            k -= weights[item - 1]
            solution_weight += weights[item-1]

    return solution_value, solution_weight, taken

Existem três trechos de códigos interessantes: linha 8, linha 9 e linhas 11-13, conforme numeradas acima. Juntas, elas substituem o loop interno que percorreria todos os tamanhos possíveis de mochilas para encontrar os valores da solução.

Até que a capacidade da mochila atinja o peso do item recém adicionado ao conjunto de trabalho (this_weight), devemos ignorar esse item e definir os valores da solução para os do conjunto de trabalho anterior. Isso é bastante direto (linha 8):

grid[item+1, :this_weight] = grid[item, :this_weight]

Em seguida, construímos um array auxiliar temp (linha 9):

temp = grid[item, :-this_weight] + this_value

Esse código é análogo, mas muito mais rápido do que:

[grid[item, k — this_weight] + this_value
for k in range(this_weight, capacity+1)]

Ele calcula possíveis valores de solução se o novo item for levado para cada uma das mochilas que podem acomodar esse item.

Observe como o array temp é construído adicionando um escalar a um array. Esse é outro recurso poderoso do NumPy chamado "broadcasting". Quando o NumPy vê operandos com dimensões diferentes, ele tenta expandir (ou seja, "transmitir" – em inglês, broadcast) o operando de baixa dimensão para corresponder às dimensões do outro. Em nosso caso, o escalar é expandido para um array do mesmo tamanho que grid[item, :-this_weight] e esses dois arrays são somados. Como resultado, o valor de this_value é adicionado a cada elemento de grid[item, :-this_weight] — nenhum loop é necessário.

Na próxima parte (linhas 10–13), usamos a função where(), que faz exatamente o que é exigido pelo algoritmo: compara dois possíveis valores de solução para cada tamanho de mochila e seleciona aquele que é maior.

grid[item + 1, this_weight:] =             
    np.where(temp > grid[item, this_weight:],
             temp,
             grid[item, this_weight:])

A comparação é feita pelo parâmetro condition, que é calculado como temp > grid[item, this_weight:]. Essa é uma operação elementar que produz um array de valores booleanos, um para cada tamanho de uma mochila auxiliar. Um valor True significa que o item correspondente deve ser colocado na mochila. Portanto, o valor da solução obtido do array é o segundo argumento da função temp. Caso contrário, o item deve ser ignorado, e o valor da solução é copiado da linha anterior da grade - o terceiro argumento da função where().

Por fim, o motor de dobra foi ativado! Esse solucionador é executado em 0,55 s. Isso é 145 vezes mais rápido que o solucionador baseado em list comprehension e 329 vezes mais rápido que o código utilizando o loop for. Embora não tenhamos ultrapassado o solucionador escrito em Go (0,4 s), chegamos bem perto disso.

Alguns loops são pra ficar

Espere, mas e o loop for externo?

Em nosso exemplo, o código do loop externo, que não faz parte do loop interno, é executado apenas 100 vezes, para que possamos escapar sem mexer nele. No entanto, outras vezes, o loop externo pode ser tão longo quanto o interno.

Podemos reescrever o loop externo usando uma função do NumPy de maneira semelhante ao que fizemos para o loop interno? A resposta é não.

Apesar de ambos serem loops for, os loops externo e interno são bem diferentes no que fazem.

O loop interno produz um array 1D baseado em outro array 1D cujos elementos são todos conhecidos quando o loop começa. É essa disponibilidade prévia dos dados de entrada que nos permitiu substituir o loop interno por map(), list comprehension ou uma função do NumPy.

O loop externo produz um array 2D a partir de um array 1D, cujos elementos não são conhecidos quando o loop começa. Além disso, esses componentes de arrays são calculados por um algoritmo recursivo: podemos encontrar os elementos (i+1)º do array somente depois de encontrarmos o iº.

Suponha que o loop externo possa ser apresentado como uma função:
grid = g(row0, row1, … rowN)
Todos os parâmetros da função devem ser avaliados antes que a função seja chamada, mas somente row0 é conhecida de antemão. Como o cálculo da (i+1)ª linha depende da disponibilidade da i-ésima, precisamos de um loop indo de 1 a N para calcular todos os parâmetros da linha. Portanto, para substituir o loop externo com uma função, precisamos de outro loop que avalie os parâmetros dessa função. Esse outro loop é exatamente o loop que estamos tentando substituir.

A outra maneira de evitar o loop for externo é usar recursão. Pode-se facilmente escrever a função recursiva calculate(i) que produz a i-ésima linha da grade. Para fazer o trabalho, a função precisa conhecer a (i-1)ª linha, portanto, chama a si mesma como calculate(i-1) e, em seguida, calcula a i-ésima linha usando as funções do NumPy como fizemos anteriormente. Todo o loop externo pode então ser substituído por calculate(N). Para tornar a imagem completa, um solucionador de mochila recursivo pode ser encontrado no código-fonte que acompanha este artigo no GitHub.

No entanto, a abordagem recursiva claramente não é escalável. O Python não é otimizado para a recursão de cauda. A profundidade da pilha de recursão é, por padrão, limitada pela ordem de mil. Esse limite é certamente conservador, mas, quando exigimos uma profundidade de milhões, o estouro da pilha é altamente provável. Além disso, o experimento mostra que a recursão nem mesmo fornece uma vantagem de desempenho sobre um solucionador baseado em NumPy com o loop for externo.

É aqui que esgotamos as ferramentas fornecidas pelo Python e suas bibliotecas (pelo que sei). Se for absolutamente necessário acelerar o loop que implementa um algoritmo recursivo, será preciso recorrer ao Cython, ou a uma versão do Python compilada em JIT, ou a outra linguagem.

Aprendizados

• Faça cálculos numéricos com as funções do Numpy. Elas são duas ordens de magnitude mais rápidas do que as ferramentas integradas do Python.
• Das ferramentas integradas do Python, list comprehension é mais rápida que map(), que é significativamente mais rápido que for.
• Para algoritmos profundamente recursivos, os loops são mais eficientes do que as chamadas recursivas de funções.
• Você não pode substituir loops recursivos por map(), list comprehension ou uma função do NumPy.
• O código "burro" (dividido em operações elementares) é o mais lento. Use funções e ferramentas integradas.

Escrito por: Praveen Dubey

Bag of Words (BOW – ou, em português, sacola de palavras) é um método para extrair recursos de documentos de texto. Esses recursos podem ser usados para treinar algoritmos de aprendizado de máquina. Ele cria um vocabulário de todas as palavras únicas que ocorrem em todos os documentos do conjunto de treinamento.

Em termos simples, é uma coleção de palavras para representar uma frase, com contagem de palavras e, na maioria das vezes, desconsiderando a ordem em que aparecem.

O BOW é uma abordagem amplamente utilizada com:

1. Processamento de Linguagem Natural
2. Recuperação de informações de documentos
3. Classificação de documentos

De modo geral, envolve as seguintes etapas:

Os vetores gerados podem ser inseridos em seu algoritmo de aprendizado de máquina.

Vamos começar com um exemplo para entender, pegando algumas frases e gerando vetores para elas.

Considere as duas frases abaixo.

1. "John likes to watch movies. Mary likes movies too."

2. "John also likes to watch football games."

Essas duas passagens também podem ser representadas com uma coleção de palavras.

1. ['John', 'likes', 'to', 'watch', 'movies.', 'Mary', 'likes', 'movies', 'too.']

2. ['John', 'also', 'likes', 'to', 'watch', 'football', 'games']

Além disso, para cada passagem, remova ocorrências múltiplas da palavra e use a contagem de palavras para representá-la.

1. {"John":1,"likes":2,"to":1,"watch":1,"movies":2,"Mary":1,"too":1}

2. {"John":1,"also":1,"likes":1,"to":1,"watch":1,"football":1,"games":1}

Supondo que essas passagens façam parte de um documento, abaixo consta a frequência combinada de palavras para nosso documento inteiro. Ambas as frases são consideradas.

 {"John":2,"likes":3,"to":2,"watch":2,"movies":2,"Mary":1,"too":1,  "also":1,"football":1,"games":1}

O vocabulário acima de todas as palavras de um documento, com suas respectivas contagens de palavras, será usado para criar vetores de cada uma das passagens.

O comprimento do vetor será sempre igual ao tamanho do vocabulário. Neste caso, o comprimento do vetor é 11.

Para representar nossas frases originais em um vetor, cada vetor é inicializado com zeros — [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Isso é seguido por iteração e comparação com cada palavra em nosso vocabulário, incrementando o valor do vetor se a passagem tiver essa palavra.

John likes to watch movies. Mary likes movies too.[1, 2, 1, 1, 2, 1, 1, 0, 0, 0]

John also likes to watch football games.[1, 1, 1, 1, 0, 0, 0, 1, 1, 1]

Por exemplo, na passagem 1, a palavra likes aparece na segunda posição e aparece duas vezes. Assim, o segundo elemento de nosso vetor para a passagem 1 será 2: [1, 2, 1, 1, 2, 1, 1, 0, 0, 0]

O vetor é sempre proporcional ao tamanho do nosso vocabulário.

Um documento grande onde o vocabulário gerado é enorme pode resultar em um vetor com muitos valores 0. Isso é chamado de vetor esparso. Os vetores esparsos exigem mais memória e recursos computacionais durante a modelagem. O grande número de posições ou dimensões pode tornar o processo de modelagem muito desafiador para algoritmos tradicionais.

Programando nosso algoritmo BOW

A entrada para o nosso código será composta de diversas frases. A saída será os vetores.

O vetor de entrada é este:

["Joe waited for the train", "The train was late", "Mary and Samantha took the bus", "I looked for Mary and Samantha at the bus station", "Mary and Samantha arrived at the bus station early but waited until noon for the bus"]

Etapa 1: Tokenizar uma frase

Vamos começar removendo stopwords das frases.

Stopwords são palavras que não contêm significância suficiente para serem usadas sem nosso algoritmo. Não gostaríamos que essas palavras ocupassem espaço em nosso banco de dados ou tomassem um tempo valioso de processamento. Para isso, podemos removê-las facilmente armazenando uma lista de palavras que você considere que sejam stopwords.

Tokenização é o ato de quebrar uma sequência de strings em pedaços como palavras, palavras-chave, frases, símbolos e outros elementos chamados tokens. Tokens podem ser palavras individuais, frases ou até mesmo passagens inteiras. No processo de tokenização, alguns caracteres como sinais de pontuação são descartados.

def word_extraction(sentence):    ignore = ['a', "the", "is"]    words = re.sub("[^\w]", " ",  sentence).split()    cleaned_text = [w.lower() for w in words if w not in ignore]    return cleaned_text

Para uma implementação mais robusta de stopwords, você pode usar a biblioteca python nltk. Ela possui um conjunto de palavras predefinidas por idioma. Aqui está um exemplo:

import nltkfrom nltk.corpus import stopwords set(stopwords.words('english'))

Etapa 2: Aplicar tokenização a todas as frases

def tokenize(sentences):    words = []    for sentence in sentences:        w = word_extraction(sentence)        words.extend(w)            words = sorted(list(set(words)))    return words

O método percorre as frases e adiciona a palavra extraída em um vetor.

A saída do método será:

['and', 'arrived', 'at', 'bus', 'but', 'early', 'for', 'i', 'joe', 'late', 'looked', 'mary', 'noon', 'samantha', 'station', 'the', 'took', 'train', 'until', 'waited', 'was']

Etapa 3: Construir vocabulário e gerar vetores

Use os métodos definidos nas etapas 1 e 2 para criar o vocabulário do documento e extrair as palavras das frases.

def generate_bow(allsentences):        vocab = tokenize(allsentences)    print("Word List for Document \n{0} \n".format(vocab));

for sentence in allsentences:        words = word_extraction(sentence)        bag_vector = numpy.zeros(len(vocab))        for w in words:            for i,word in enumerate(vocab):                if word == w:                     bag_vector[i] += 1                            print("{0}\n{1}\n".format(sentence,numpy.array(bag_vector)))

Aqui está a entrada definida e a execução do nosso código:

allsentences = ["Joe waited for the train train", "The train was late", "Mary and Samantha took the bus", "I looked for Mary and Samantha at the bus station", "Mary and Samantha arrived at the bus station early but waited until noon for the bus"]
generate_bow(allsentences)

Os vetores de saída para cada frase são:

Resultado:

Joe waited for the train [0. 0. 0. 0. 0. 0. 1. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 2. 0. 1. 0.]

The train was late [0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 1. 0. 0. 1.]

Mary and Samantha took the bus [1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0.]

I looked for Mary and Samantha at the bus station [1. 0. 1. 1. 0. 0. 1. 1. 0. 0. 1. 1. 0. 1. 1. 0. 0. 0. 0. 0. 0.]

Mary and Samantha arrived at the bus station early but waited until noon for the bus [1. 1. 1. 2. 1. 1. 1. 0. 0. 0. 0. 1. 1. 1. 1. 0. 0. 0. 1. 1. 0.]

Como você pode ver, cada frase foi comparada com nossa lista de palavras gerada na Etapa 1. Com base na comparação, o valor do elemento do vetor pode ser incrementado. Esses vetores podem ser usados em algoritmos de ML para classificação de documentos e previsões.

Escrevemos nosso código e geramos vetores, mas agora vamos entender um pouco mais sobre o bag of words.

Insights sobre o bag of words

O modelo BOW considera apenas se uma palavra conhecida ocorre em um documento ou não. Não se importa com o significado, contexto e ordem em que aparecem.

Isso dá a ideia de que documentos semelhantes terão contagens de palavras semelhantes entre si. Em outras palavras, quanto mais semelhantes as palavras em dois documentos, mais semelhantes os documentos podem ser.

Limitações do BOW

1. Significado semântico: a abordagem básica do BOW não considera o significado da palavra no documento. Ele ignora completamente o contexto em que ela é usada. A mesma palavra pode ser usada em vários lugares com base no contexto ou em palavras próximas.
2. Tamanho do vetor: Para um documento grande, o tamanho do vetor pode ser enorme, resultando em muitos cálculos e muito tempo. Pode ser necessário ignorar palavras com base na relevância para o seu caso de uso.

Essa foi uma pequena introdução ao método BOW. O código mostrou como ele funciona de um modo simples. Há muito mais para entender sobre o BOW. Por exemplo, em vez de dividir nossa frase em uma única palavra (1-grama), você pode dividi-la em um par de duas palavras (bigrama ou 2-gramas). Às vezes, a representação em bigramas parece ser muito melhor do que usar 1-grama. Eles podem ser frequentemente representados usando a notação N-grama. Listei alguns artigos de pesquisa na seção de recursos para um conhecimento mais aprofundado.

Você não precisa codificar o BOW sempre que precisar. Já faz parte de muitos frameworks disponíveis, como o CountVectorizer no sci-kit learn.

Nosso código anterior pode ser substituído por:

from sklearn.feature_extraction.text import CountVectorizervectorizer = CountVectorizer()X = vectorizer.fit_transform(allsentences)print(X.toarray())

É sempre bom entender como funcionam as bibliotecas dos frameworks, bem como os métodos por trás delas. Quanto melhor você entender os conceitos, melhor poderá usar os frameworks.

Agradecemos pela leitura do artigo. O código mostrado está disponível no GitHub do autor.

Você pode seguir o autor no Medium, Twitter e no LinkedIn. Para qualquer dúvida, você pode entrar em contato com o autor por e-mail.

Recursos para ler mais sobre bag of words (em inglês)

1. Wikipedia-BOW
2. Understanding Bag-of-Words Model: A Statistical Framework
3. Semantics-Preserving Bag-of-Words Models and Applications

Escrito por: Sharad Vijalapuram

O que é regressão?

Regressão é um dos processos de análise de dados mais importantes e comumente usados. Simplificando, é um método estatístico que explica a força da relação entre uma variável dependente e uma ou mais variáveis independentes.

Uma variável dependente pode ser uma variável ou um campo que você esteja tentando prever ou compreender. Uma variável independente pode ser os campos ou pontos de dados que você acha que podem ter um impacto na variável dependente.

Ao fazer isso, ela responde algumas questões importantes:

• Quais variáveis importam?
• Até que ponto essas variáveis importam?
• Qual o nível de nossa confiança sobre essas variáveis?

Vamos ver um exemplo…

Para explicar melhor os números na tabela de regressão, pensei que seria útil usar um conjuntos de dados como amostra e percorrer os números e sua importância.

Estou usando um pequeno conjunto dados que contém as pontuações no GRE (um teste que os alunos fazem para serem considerados para admissão em universidades nos EUA) de 500 alunos e suas chances de admissão em uma universidade.

Como chance de admissão (em inglês, chance of admittance) depende da pontuação no GRE (em inglês, GRE scores), chance de admissão é a variável dependente e pontuação no GRE é a variável independente.

Linha de regressão

Desenhar uma linha reta que melhor descreva a relação entre as pontuações no GRE de alunos e suas chances de admissão nos fornece a linha de regressão linear. Esta é conhecida como linha de tendência em várias ferramentas de Business Intelligence (BI). A ideia básica por trás do desenho dessa linha é minimizar a distância entre os pontos de dados em uma determinada coordenada x e a coordenada y pela qual a linha de regressão passa.

A linha de regressão facilita a representação da relação. Ela se baseia em uma equação matemática que associa o coeficiente x e o ponto de interceptação do eixo y.

y é o ponto no qual a linha intercepta o eixo y quando x = 0. Também é o valor que o modelo assumiria ou preveria quando x fosse 0.

Coeficientes fornecem o impacto ou o peso de uma variável em relação a todo o modelo. Em outras palavras, fornecem a quantidade de mudança necessária na variável dependente para que ocorra uma mudança de unidade na variável independente.

Calculando a equação da linha de regressão

Para descobrir o ponto de interceptação de y do modelo, estendemos a linha de regressão o suficiente para que ela intersecte o eixo y em x = 0. Esse é o nosso ponto de interceptação de y, que está em torno de -2,5. O número pode não fazer sentido para o conjunto de dados em questão, mas a intenção é mostrar apenas o cálculo desse ponto.

O coeficiente para este modelo será apenas a inclinação da linha de regressão, e pode ser calculado obtendo a mudança na chance de admissão de acordo com a mudança nas pontuações no GRE.

No exemplo acima, o coeficiente seria apenas

m = (y2-y1) / (x2-x1)

Neste caso, seria próximo de 0,01.

A fórmula y = m*x + b nos ajuda a calcular a equação matemática de nossa linha de regressão. Substituindo os valores do ponto de interceptação de y e da inclinação que obtivemos ao estender a linha de regressão, podemos formular a equação abaixo:

y = 0,01x — 2,48

-2,48 é um valor de ponto de interceptação de y mais preciso que obtive da tabela de regressão, conforme mostrado posteriormente neste artigo.

Essa equação nos permite predizer a chance de admissão de um(a) aluno(a) quando sua pontuação no GRE é conhecida.

Agora que temos o básico, vamos partir para a leitura e a interpretação de uma tabela de regressão.

Lendo uma tabela de regressão

A tabela de regressão pode ser dividida em basicamente três componentes:

• análise de variância (ANOVA): fornece a análise da variância no modelo, como o próprio nome sugere.
• estatísticas de regressão: fornecem informações numéricas sobre a variação e sobre a exatidão da explicação do modelo para a variação dos dados/observações fornecidos.
• saída residual: fornece o valor previsto pelo modelo e a diferença entre o valor real observado da variável dependente e seu respectivo valor previsto pelo modelo de regressão para cada ponto dos dados.

Análise de variância (ANOVA)

Graus de liberdade (gl)

Os gl da regressão (em inglês, regression degrees of freedom ou regression df) são o número de variáveis independentes no nosso modelo de regressão. Como consideramos apenas as pontuações no GRE nesse exemplo, seu valor é 1.

O gl residual (em inglês, residual degrees of freedom ou residual df) é o número total de observações (linhas) do conjunto de dados subtraído pelo número de variáveis que estão sendo estimadas. Neste exemplo, tanto o coeficiente de pontuação GRE quanto a constante são estimados.

gl residual = 500 — 2 = 498

gl total — é a soma da regressão e dos graus de liberdade residuais, que equivale ao tamanho do conjunto de dados menos 1.

Soma dos quadrados (SQ)

SQ da regressão (em inglês, regression sum of squares ou regression SS) é a variação total da variável dependente que é explicada pelo modelo de regressão. É a soma do quadrado da diferença entre o valor previsto e a média do valor de todos os pontos de dados.

∑ (ŷ — ӯ)²

Na tabela ANOVA, a SQ da regressão é 6,5 e a SQ total é 9,9, o que significa que o modelo de regressão explica cerca de 6,5/9,9 (aproximadamente 65%) de toda a variabilidade no conjunto de dados.

SQ residual (em inglês, residual sum of squares ou residual SS) é a variação total na variável dependente que não é explicada pelo modelo de regressão. Ela também é chamada de soma dos quadrados do erro, sendo a soma do quadrado da diferença entre valores reais e previstos de todos os pontos de dados.

∑ (y — ŷ)²

Na tabela ANOVA, a SQ residual é de cerca de 3,4. Em geral, quanto menor o erro, melhor o modelo de regressão explica a variação no conjunto de dados e, portanto, geralmente queremos minimizar esse erro.

A SQ Total é a soma de ambas, SQ da regressão e residual, ou por quanto a chance de admissão variaria se as pontuações no GRE NÃO fossem levadas em consideração.

Erros quadráticos médios (EQM) — são a média da soma dos quadrados ou a soma dos quadrados dividida pelos graus de liberdade de ambos os casos, regressão e resíduos.

EQM da regressão = ∑ (ŷ — ӯ)²/Reg. gl

EQM residual = ∑ (y — ŷ)²/Res. gl

F — é usado para testar a hipótese de que a inclinação da variável independente é zero. Matematicamente também pode ser calculado como

F = EQM da regressão/EQM residual

Caso contrário, é calculada comparando a estatística F com uma distribuição F com gl de regressão em graus no numerador e gl residual em graus no denominador.

Significância F — nada mais é do que o valor-p para a hipótese nula de que o coeficiente da variável independente é zero e, como acontece com qualquer valor-p, um baixo valor-p indica que existe uma relação significativa entre as variáveis dependentes e independentes.

Erro padrão — fornece o desvio padrão estimado da distribuição dos coeficientes. É a quantidade pela qual o coeficiente varia em diferentes casos. Um coeficiente muito maior que seu erro padrão implica uma probabilidade de que o coeficiente não seja 0.

t-Stat é a estatística t ou o valor t do teste, e seu valor é igual ao coeficiente dividido pelo erro padrão.

t-Stat = coeficientes/erro padrão

Novamente, quanto maior o coeficiente em relação ao erro padrão, maior é o t-Stat e maior a probabilidade de que o coeficiente esteja longe de 0.

valor-p — A estatística t é comparada com a distribuição t para determinar o valor-p. Geralmente, consideramos apenas o valor-p da variável independente, que fornece a probabilidade de obter uma amostra tão próxima daquela usada para derivar a equação de regressão, para verificar se a inclinação da linha de regressão é realmente zero ou se o coeficiente é próximo do coeficiente obtido.

Um valor-p abaixo de 0,05 indica 95% de confiança de que a inclinação da linha de regressão não é zero e, portanto, existe uma relação linear significativa entre as variáveis dependentes e independentes.

Um valor-p maior do que 0,05 indica que a inclinação da linha de regressão pode ser zero e que não há evidência suficiente, ao nível de confiança de 95%, da existência de uma relação linear significativa entre as variáveis dependentes e independentes.

Uma vez que o valor-p da variável independente pontuação no GRE está muito próximo de 0, podemos estar extremamente confiantes da existência de uma relação linear significativa entre as pontuações no GRE e a chance de admissão.

95% inferiores e superiores — Como usamos principalmente uma amostra de dados para estimar a linha de regressão e seus coeficientes, eles são geralmente uma aproximação dos verdadeiros coeficientes e, por conseguinte, da verdadeira linha de regressão. Os limites inferior e superior de 95% fornecem o 95º intervalo de confiança dos limites inferior e superior para cada coeficiente.

Como o intervalo de confiança de 95% para as pontuações no GRE é 0,009 e 0,01, os limites não contêm zero e, portanto, podemos ter 95% de confiança de que existe uma relação linear significativa entre as pontuações GRE e a chance de admissão.

Observe que um nível de confiança de 95% é amplamente utilizado, mas um nível diferente de 95% é possível e pode ser configurado durante a análise de regressão.

Estatísticas de regressão

R² (R quadrado) — representa o poder de um modelo. Ele mostra a quantidade de variação na variável dependente que é explicada pela variável independente, e sempre fica entre os valores 0 e 1. À medida que o R² aumenta, mais a variação nos dados é explicada pelo modelo e melhor o modelo obtém a previsão. Um R² baixo indicaria que o modelo não se ajusta bem aos dados, e que uma variável independente não explica bem a variação na variável dependente.

R² = soma dos quadrados da regressão/soma total dos quadrados

No entanto, o R quadrado não pode determinar se as estimativas e previsões do coeficiente são tendenciosas. É por isso que você deve analisar os gráficos de resíduos, que são discutidos posteriormente neste artigo.

O R quadrado também não indica se um modelo de regressão é adequado. Você pode ter um valor R quadrado baixo para um bom modelo, ou um valor R quadrado alto para um modelo que não se ajusta aos dados.

O R², neste caso, é 65%, o que implica que as pontuações no GRE podem explicar 65% da variação na chance de admissão.

R² ajustado — é o R² multiplicado por um fator de ajuste. Isso é usando ao comparar diferentes modelos de regressão com diferentes variáveis independentes. Esse número é útil ao decidir sobre as variáveis independentes corretas em modelos de regressão múltipla.

R múltiplo — é a raiz quadrada positiva de R²

Erro padrão — é diferente do erro padrão dos coeficientes. Este é o desvio padrão estimado do erro da equação de regressão, e é uma boa medida da acurácia da linha de regressão. É a raiz quadrada dos erros quadráticos médios residuais.

Erro padrão = √(Res.MS)

Saída residual

Resíduos são a diferença entre o valor real e o valor previsto do modelo de regressão. A saída residual é o valor da variável dependente previsto pelo modelo de regressão e o resíduo para cada ponto de dados.

Como o nome sugere, um gráfico residual é um gráfico de dispersão entre o resíduo e a variável independente, que, neste caso, é a pontuação GRE de cada aluno.

Um gráfico residual é importante para detectar coisas como heterocedasticidade, não linearidade e valores atípicos (em inglês, outliers). O processo para detectá-los não está sendo discutido neste artigo, mas o fato de que o gráfico de resíduos para o nosso exemplo possui dados aleatoriamente dispersos nos ajuda a estabelecer o fato de que a relação entre as variáveis neste modelo é linear.

Intenção

A intenção deste artigo não é construir um modelo de regressão funcional, mas fornecer um passo a passo de todas as variáveis de regressão e sua importância quando necessário, com a amostra de um conjunto de dados em uma tabela de regressão.

Embora este artigo forneça uma explicação com uma regressão linear com apenas uma variável como exemplo, esteja ciente de que algumas dessas variáveis podem ter mais importância nos casos de multivariáveis ou outras situações.

Referências (em inglês)

• Graduate Admissions Dataset
• 10 things about reading a regression table
• A refresher on regression analysis

Imagine ter um bot de mensagens que enviará uma imagem aleatória com um cachorro fofo sempre que você quiser. Parece legal, certo? Vamos fazer um bot desses!

Para este tutorial, vamos usar o Python 3, a biblioteca python-telegram-bot e a API pública RandomDog.

Ao final deste tutorial, você terá um bot para aliviar o estresse e que enviará imagens fofas de cachorros sempre que você precisar. 😀

Começando

Antes de começarmos a escrever o programa, precisamos gerar um token para nosso bot. O token é necessário para acessar a API do Telegram e instalar as dependências necessárias.

1. Crie um bot no BotFather

Se você quiser criar um bot no Telegram, primeiro precisa "registrar" seu bot antes de usá-lo. Ao "registrarmos" nosso bot, obteremos o token para acessar a API do Telegram.

Acesse o BotFather (se for abrir na área de trabalho, certifique-se de que possui o aplicativo do Telegram). Então, crie um bot enviando o comando /newbot. Siga as etapas até obter o nome de usuário e o token para seu bot. Você pode acessar seu bot por meio deste URL: https://telegram.me/NOME_DE_USUARIO_DO_SEU_BOT e seu token deve ter esta aparência:

704418931:AAEtcZ*************

2. Instale a biblioteca

Como vamos usar uma biblioteca para este tutorial, instale-a usando este comando:

pip3 install python-telegram-bot

Se a biblioteca for instalada com sucesso, estamos prontos.

Escreva o programa

Vamos fazer nosso primeiro bot. Ele deve retornar uma imagem de cachorro quando enviarmos o comando /bop. Para conseguirmos fazer isso, podemos usar a API pública do RandomDog para nos ajudar a gerar imagens aleatórias de cães.

O fluxo de trabalho do nosso bot é simples assim:

acesse a API -> obtenha o URL da imagem -> envie a imagem

1. Importe as bibliotecas

Primeiro, importamos todas as bibliotecas que precisaremos.

from telegram.ext import Updater, CommandHandler
import requests
import re

2. Acesse a API e obtenha o URL da imagem

Vamos criar uma função para obter o URL. Usando a biblioteca requests, podemos acessar a API e obter os dados em json.

contents = requests.get('https://random.dog/woof.json').json()

Você pode conferir os dados json acessando, pelo seu navegador, este URL: https://random.dog/woof.json. Você verá algo assim em sua tela:

{“url":"https://random.dog/*****.JPG"}

Obtenha o URL da imagem, pois precisamos desse parâmetro para conseguir enviar a imagem.

image_url = contents['url']

Envolva o código em uma função chamada get_url() .

def get_url():
    contents = requests.get('https://random.dog/woof.json').json()    
    url = contents['url']
    return url

3. Envie a imagem

Para enviar uma mensagem/imagem, precisamos de dois parâmetros, o URL da imagem e o ID do destinatário – pode ser o ID de um grupo ou o ID de um usuário.

Podemos obter o URL da imagem chamando nossa função get_url().

url = get_url()

Obtenha o ID do destinatário usando este código:

chat_id = update.message.chat_id

Após conseguirmos o URL da imagem e o ID do destinatário, é hora de enviar a mensagem, que é uma imagem.

bot.send_photo(chat_id=chat_id, photo=url)

Envolva o código em uma função chamada bop e certifique-se de que seu código se pareça com isso:

def bop(bot, update):
    url = get_url()
    chat_id = update.message.chat_id
    bot.send_photo(chat_id=chat_id, photo=url)

4. Programa principal (main)

Por fim, crie outra função chamada main para executar nosso programa. Não se esqueça de alterar SEU_TOKEN pelo token que geramos anteriormente neste tutorial.

def main():
    updater = Updater('SEU_TOKEN')
    dp = updater.dispatcher
    dp.add_handler(CommandHandler('bop',bop))
    updater.start_polling()
    updater.idle()
    
if __name__ == '__main__':
    main()

Ao final, seu código deve ficar assim:

from telegram.ext import Updater, InlineQueryHandler, CommandHandler
import requests
import re

def get_url():
    contents = requests.get('https://random.dog/woof.json').json()    
    url = contents['url']
    return url

def bop(bot, update):
    url = get_url()
    chat_id = update.message.chat_id
    bot.send_photo(chat_id=chat_id, photo=url)

def main():
    updater = Updater('SEU_TOKEN')
    dp = updater.dispatcher
    dp.add_handler(CommandHandler('bop',bop))
    updater.start_polling()
    updater.idle()

if __name__ == '__main__':
    main()

5. Execute o programa

Incrível! Você terminou seu primeiro programa. Agora, vamos conferir se funciona. Salve o arquivo, chame-o de main.py e execute-o usando este comando:

python3 main.py

Vá até seu bot do telegram acessando este URL: https://telegram.me/NOME_DE_USUARIO_DO_SEU_BOT.

Envie o comando /bop. Se tudo funcionar perfeitamente, o bot responderá com uma imagem de cachorro aleatória. Fofo, não é?

Tratamento de erros

Ótimo! Agora, você tem um bot que enviará uma imagem fofa de cachorro sempre que quiser.

Tem mais! A API RandomDog não gera apenas imagens, mas também vídeos e GIFs. Se acessarmos a API e obtivermos um vídeo ou GIF, haverá um erro e o bot não enviará a mensagem para você.

Vamos corrigir isso para que o bot envie apenas uma mensagem com um anexo de imagem. Se obtivermos um vídeo ou GIF, chamaremos a API novamente até obtermos uma imagem.

1. Encontre a correspondência da extensão do arquivo usando expressões regulares

Vamos usar uma expressão regular, ou regex, para resolver esse problema.

Para distinguir uma imagem de um vídeo ou GIF, podemos dar uma olhada na extensão do arquivo. Precisamos somente da última parte do nosso URL.

https://random.dog/*****.JPG

Precisamos definir, primeiro, quais extensões de arquivo são permitidas em nosso programa.

allowed_extension = ['jpg','jpeg','png']

Em seguida, usamos a regex para extrair a extensão do arquivo do URL.

file_extension = re.search("([^.]*)$",url).group(1).lower()

Usando este código, crie uma função chamada get_image_url() para iterar o URL até obter a extensão de arquivo que queremos (jpg, jpeg ou png):

def get_image_url():
    allowed_extension = ['jpg','jpeg','png']
    file_extension = ''
    while file_extension not in allowed_extension:
        url = get_url()
        file_extension = re.search("([^.]*)$",url).group(1).lower()
    return url

2. Modifique seu código

Ótimo! Agora, para a última parte, substitua a linha url = get_url() na função bop() por url = get_image_url() e seu código deve ficar assim:

from telegram.ext import Updater, InlineQueryHandler, CommandHandler
import requests
import re

def get_url():
    contents = requests.get('https://random.dog/woof.json').json()    
    url = contents['url']
    return url

def get_image_url():
    allowed_extension = ['jpg','jpeg','png']
    file_extension = ''
    while file_extension not in allowed_extension:
        url = get_url()
        file_extension = re.search("([^.]*)$",url).group(1).lower()
    return url

def bop(bot, update):
    url = get_image_url()
    chat_id = update.message.chat_id
    bot.send_photo(chat_id=chat_id, photo=url)

def main():
    updater = Updater('SEU_TOKEN')
    dp = updater.dispatcher
    dp.add_handler(CommandHandler('bop',bop))
    updater.start_polling()
    updater.idle()

if __name__ == '__main__':
    main()

Legal! Tudo deve funcionar perfeitamente. Confira também a conta do GitHub do autor para obter o código.

Parabéns por terminar este tutorial. Você agora tem um bot legal para o Telegram.

Obrigado e boa sorte praticando! 😀