Capítulo 02 - Desenvolvendo um modelo de aprendizado de máquina em Python

Em termos de plataformas usadas para aprendizado de máquina, existem muitos algoritmos e linguagens de programação. No entanto, o ecossistema Python é uma das linguagens de programação mais dominantes e que mais crescem para o aprendizado de máquina.

Dada a popularidade e a alta taxa de adoção do Python, nós a usaremos como a principal linguagem de programação ao longo do nosso estudo. Este capítulo fornece uma visão geral de uma estrutura de aprendizado de máquina baseada em Python. Primeiro, revisaremos os detalhes dos pacotes baseados em Python usados ​​para aprendizado de máquina, seguidos pelas etapas de desenvolvimento do modelo na estrutura do Python.

As etapas do desenvolvimento de modelos em Python, apresentadas neste capítulo, servem como base para os estudos de caso apresentados no restante dos capítulos. O framework Python também pode ser alavancado durante o desenvolvimento de qualquer modelo baseado em aprendizado de máquina em finanças.

Por que Python?

Algumas razões para a popularidade de Python são as seguintes:

• Sintaxe de alto nível (comparada às linguagens de nível inferior de C, Java e C++). Os aplicativos podem ser desenvolvidos escrevendo menos linhas de código, tornando o Python atraente para iniciantes e programadores avançados.

• Ciclo de vida eficiente de desenvolvimento.

• Grande coleção de bibliotecas gerenciadas pela comunidade.

• Forte portabilidade.

A simplicidade do Python atraiu muitos desenvolvedores para criar novas bibliotecas para o aprendizado de máquina, levando à forte adoção do Python.

Pacotes Python para aprendizado de máquina

Os principais pacotes Python usados ​​para aprendizado de máquina são destacados na Figura 1.

Aqui está um breve resumo de cada um desses pacotes:

NumPy:

• Fornece suporte para grandes matrizes multidimensionais, bem como uma extensa coleta de funções matemáticas.

Pandas:

• Uma biblioteca para manipulação e análise de dados. Entre outros recursos, oferece estruturas de dados para lidar com tabelas e as ferramentas para manipulá-las.

Matplotlib:

• Uma biblioteca de plotagem que permite a criação de gráficos e gráficos 2D.

SciPy:

• A combinação de NumPy, Pandas e Matplotlib é geralmente referida como SciPy. O Scipy é um ecossistema de bibliotecas Python para matemática, ciência e engenharia.

Scikit-learn (ou sklearn):

• Uma biblioteca de aprendizado de máquina que oferece uma ampla gama de algoritmos e utilidades.

StatsModels:

• Um módulo Python que fornece classes e funções para a estimativa de muitos modelos estatísticos diferentes, bem como para realizar testes estatísticos e exploração de dados estatísticos.

TensorFlow e Theano (substituído por PyTensor):

• Bibliotecas de programação de fluxo de dados que facilitam o trabalho com redes neurais.

Keras:

• Uma biblioteca de rede neural artificial que pode atuar como uma interface simplificada para os pacotes Tensorflow/Theano (PyTensor).

Seaborn:

• Uma biblioteca de visualização de dados baseada no matplotlib. Ele fornece uma interface de alto nível para desenhar gráficos estatísticos atraentes e informativos.

pip e Conda:

• Estes são gerentes de pacotes Python. O pip é um gerente de pacotes que facilita a instalação, a atualização e a desinstalação de pacotes Python. O Conda é um gerente de pacotes que lida com pacotes Python, bem como dependências da biblioteca fora dos pacotes Python.

Instalação de Python e pacote

Existem diferentes maneiras de instalar o Python. No entanto, é altamente recomendável que você instale o Python através da Anaconda. A Anaconda contém Python, Scipy e Scikit-Learn.

Depois de instalar o Anaconda, um servidor Jupyter pode ser iniciado localmente, abrindo o terminal da máquina e digitando no código a seguir:

jupyter notebook

Etapas para o desenvolvimento do modelo no ecossistema Python

Trabalhar com problemas de aprendizado de máquina de ponta a ponta é extremamente importante. O aprendizado de máquina aplicado não ganhará vida, a menos que as etapas do começo ao fim estejam bem definidas.

A Figura 2 fornece um esboço do modelo de projeto de aprendizado de máquina de sete etapas simples que pode ser usado para iniciar qualquer modelo de aprendizado de máquina no Python. As primeiras etapas incluem análise exploratória de dados e preparação de dados, que são etapas baseadas em ciência de dados de tipificação destinadas a extrair significado e insights dos dados. Essas etapas são seguidas pela avaliação do modelo, ajuste fino e finalização do modelo.

Todos os estudos de caso dos nossos estudos seguem o processo padrão de desenvolvimento de modelos de sete etapas. No entanto, existem alguns estudos de caso em que algumas das etapas são ignoradas, renomeadas ou reordenadas com base na adequação e intuitividade das etapas.

Blueprint de desenvolvimento de modelos

A seção a seguir abrange os detalhes de cada etapa de desenvolvimento do modelo com o código Python de suporte.

1. Definição do problema

O primeiro passo em qualquer projeto é definir o problema. Algoritmos poderosos podem ser usados ​​para resolver o problema, mas os resultados não terão sentido se o problema errado for resolvido.

A seguinte estrutura deve ser usada para definir o problema:

1. Descreva o problema informal e formalmente. Liste suposições e problemas semelhantes.

2. Liste a motivação para resolver o problema, os benefícios que uma solução oferece e como a solução será usada.

3. Descreva como o problema seria resolvido usando domínio do conhecimento.

2. Carregando os dados e pacotes

O segundo passo oferece tudo o que é necessário para começar a trabalhar no problema. Isso inclui carregar bibliotecas, pacotes e funções individuais necessárias para o desenvolvimento do modelo.

2.1. Carregar bibliotecas

Um exemplo de código para carregar bibliotecas é o seguinte:

# -- Importar as bibliotecas --- #

import pandas as pd

from matplotlib import pyplot

Os detalhes das bibliotecas e módulos para funcionalidades específicos são definidos mais adiante nos estudos de caso individuais.

2.2. Carregar os dados

Os seguintes itens devem ser verificados e removidos antes de carregar os dados:

• Cabeçalhos de coluna;

• Comentários ou caracteres especiais e;

• Delimitadores.

Existem muitas maneiras de carregar dados. Algumas das maneiras mais comuns são as seguintes:

• Carregar um arquivo CSV com Pandas:

from pandas import read_csv

arquivo = 'abc.csv'

dados = read_csv(arquivo)

• Carregar um arquivo por uma URL:

from pandas import read_csv

url = 'exemplo.com/dados'

dados = read_csv(url)

• Carregar um arquivo com pandas_datareader:

from pandas_datareader.data as web

ccy_tickers = ['DEXJPUS', 'DEXUSUK']

idx_tickers = ['SP500', 'DJIA', 'VIXCLS']

ccy_data = web.DataReader(ccy_tickers, 'fred')

idx_data = web.DataReader(idx_tickers, 'fred')

3. Análise exploratória dos dados

Nesta etapa, olhamos para o conjunto de dados.

3.1. Estatística descritiva

Compreender o conjunto de dados é uma das etapas mais importantes do desenvolvimento do modelo. As etapas para entender os dados incluem:

1. Visualizar os dados brutos.

2. Revisar as dimensões do conjunto de dados.

3. Revisar os tipos de dados de atributos.

4. Resumir a distribuição, estatística descritiva e relação entre as variáveis ​​no conjunto de dados.

Essas etapas são demonstradas abaixo usando o código Python de exemplo:

set_option('display.width', 100)

dados.head(1)

A tabela a seguir é a saída:

Revisando as dimensões do conjunto de dados:

dados.shape

Saída:

(284807, 31)

Os resultados mostram a dimensão do conjunto de dados e significam que o conjunto de dados possui 284.807 linhas e 31 colunas.

Revisando os tipos de dados dos atributos nos dados:

# --- Tipos --- #

set_option('display.max_rows', 500)

dados.dtypes

Resumindo os dados usando estatística descritiva:

# --- Descrever os dados --- #

set_option('precision', 3)

dados.describe()

Saída:

3.2. Visualização de dados

A maneira mais rápida de aprender mais sobre os dados é visualizá-los. A visualização envolve a compreensão independente de cada atributo do conjunto de dados. Alguns dos tipos de plotagem são os seguintes:

• Gráficos univariados: Histogramas e gráficos de densidade.

• Gráficos multivariados: Matriz de correlação e gráfico de pontos.

O código Python para tipos de plotagem univariado é ilustrado com exemplos abaixo:

• Gráfico univariado: histograma:

from matplotlib import pyplot

dados.hist(

    sharex=False,

    sharey=False,

    xlabelsize=1,

    ylabelsize=1,

    figsize=(10, 4)

)

pyplot.show()

• Gráfico univariado: gráfico de densidade:

from matplotlib import pyplot

dados.plot(

    kde='density',

    subplots=True,

    layout=(3, 3),

    sharex=False,

    legend=True,

    fontsize=1,

    figsize=(10, 4)

)

pyplot.show()

A Figura 3 ilustra a saída:

O código Python para tipos de plotagem multivariado é ilustrado com exemplos abaixo:

• Gráfico multivariado: matriz de correlação:

import seaborn as sns

from matplotlib import pyplot

correlacao = dados.corr()

pyplot.figure(figsize=(5, 5))

pyplot.title('Matriz de correlação')

sns.heatmap(

    correlacao,

    vmax=1,

    square=True,

    annot=True,

    cmap='cubehelix'

)

• Gráfico multivariado: gráfico de pontos:

from pandas.plotting import scatter_matrix

scatter_matrix(dados)

A Figura 4 ilustra a saída:

4. Preparação de dados

A preparação de dados é uma etapa de pré-processamento na qual os dados de uma ou mais fontes são limpos e transformados para melhorar sua qualidade antes de seu uso.

4.1. Limpeza de dados

Na modelagem de aprendizado de máquina, dados incorretos podem ser caros. A limpeza de dados envolve verificar o seguinte:

• Validade: o tipo de dados, intervalo, etc.

• Acurácia: o grau em que os dados estão próximos dos valores verdadeiros.

• Completude: o grau em que todos os dados necessários são conhecidos.

• Uniformidade: o grau em que os dados são especificados usando a mesma unidade de medida.

As diferentes opções para realizar a limpeza de dados incluem:

• Descrevendo os valores “NA” dentro dos dados:

  • dados.dropna(axis=0)

• Preencher "NA" com 0:

  • dados.fillna(0)

• Preencher os "NAs" com a média da coluna:

  • dados['col'] = dados['col'].fillna(dados['col'].mean())

4.2. Seleção de recursos

Os recursos de dados usados ​​para treinar os modelos de aprendizado de máquina têm uma enorme influência no desempenho. Recursos irrelevantes ou parcialmente relevantes podem afetar negativamente o desempenho do modelo. Seleção de recursos (veremos melhor nos capítulos 5 e 6) é um processo no qual os recursos nos dados que mais contribuem para a variável ou saída de previsão são selecionados automaticamente.

Os benefícios de executar a seleção de recursos antes de modelar os dados são:

• Reduz o excesso de ajuste: dados menos redundantes significam menos oportunidades para o modelo tomar decisões com base no ruído (veremos melhor esse tópico no Capítulo 4).

• Melhora o desempenho: menos dados significa treinamento mais rápido e menor consumo de memória.

O código a seguir é um exemplo que demonstra quando dois melhores recursos são selecionados usando a função SelectKBest no Sklearn. A função SelectKBest obtém os recursos usando uma função subjacente e, em seguida, remove todos os recursos de pontuação, exceto K mais alto:

from sklearn.feature_selection import chi12

from sklearn.feature_selection import SelectKBest

melhores_recursos = SelectKBest(k=5)

fit = melhores_recursos.fit(X, Y)

pontucao_df = pd.DataFrame(fit.scores_)

colunas_df = pd.DataFrame(X.columns)

pontucao_recursos = pd.concat([colunas_df, pontucao_df], axis=1)

print(pontucao_recursos.nlargest(2, 'Score'))  # mostra somente os 2 melhores recursos

Saída:

Quando os recursos são irrelevantes, eles devem ser descartados. A retirada desses recursos é ilustrada no seguinte código de amostra:

# --- Retirar os recursos irrelevantes --- #

dados.drop(['Recurso 1', 'Recurso 2', 'Recurso 3'], axis=1, inplace=True)

4.3. Transformação de dados

Muitos algoritmos de aprendizado de máquina fazem suposições sobre os dados. É uma boa prática executar a preparação de dados de forma que expõe os dados da melhor maneira possível aos algoritmos de aprendizado de máquina. Isso pode ser realizado através da transformação de dados. As diferentes abordagens de transformação de dados são as seguintes:

• Reescalonamento: quando os dados compreendem atributos com escalas variadas, muitos algoritmos de aprendizado de máquina podem se beneficiar do redimensionamento de todos os atributos para a mesma escala. Os atributos são frequentemente redimensionados na faixa entre zero e um. Isso é útil para algoritmos de otimização usados ​​no núcleo dos algoritmos de aprendizado de máquina e também ajuda a acelerar os cálculos em um algoritmo:

from sklearn.preprocessing import MinMaxScaler

escala = MinMaxScaler(feature_range=(0, 1))

x_reescalonado = pd.DataFrame(escala.fit_transform(X))

• Padronização: a padronização é uma técnica útil para transformar atributos para uma distribuição normal padrão com uma média de zero e um desvio padrão de um. É mais adequado para técnicas que assumem que as variáveis ​​de entrada representam uma distribuição normal:

from sklearn.preprocessing import StandardScaler

escala = StandardScaler().fit(X)

x_padronizado = pd.DataFrame(escala.fit_transform(X))

• Normalização: a normalização refere-se a redimensionar cada observação (linha) para ter um comprimento de um (chamado norma de unidade ou vetor). Esse método de pré-processamento pode ser útil para conjuntos de dados esparsos de atributos de escalas variadas ao usar algoritmos que ponderam valores de entrada:

from sklearn.preprocessing import Normalizer

escala = Normalizer().fit(X)

x_normalizado = pd.DataFrame(escala.fit_transform(X))

5. Avalie modelos

Depois de estimarmos o desempenho do nosso algoritmo, podemos treinar o algoritmo final em todo o conjunto de dados de treinamento e prepará-lo para uso operacional. A melhor maneira de fazer isso é avaliar o desempenho do algoritmo em um novo conjunto de dados. Diferentes técnicas de aprendizado de máquina requerem diferentes métricas de avaliação. Além do desempenho do modelo, vários outros fatores, como simplicidade, interpretabilidade e tempo de treinamento, são considerados ao selecionar um modelo. Os detalhes sobre esses fatores são abordados no Capítulo 4.

5.1. Train-test split

O método mais simples que podemos usar para avaliar o desempenho de um algoritmo de aprendizado de máquina é usar diferentes conjuntos de dados de treinamento e teste. Podemos pegar nosso conjunto de dados original e dividi-lo em duas partes: treinar o algoritmo na primeira parte, fazer previsões na segunda parte e avaliar as previsões em relação aos resultados esperados. O tamanho da divisão pode depender do tamanho e das especificidades do conjunto de dados, embora seja comum o uso de 80% dos dados para treinamento e os 20% restantes para teste. As diferenças nos conjuntos de dados de treinamento e teste podem resultar em diferenças significativas na estimativa de precisão. Os dados podem ser facilmente divididos nos conjuntos de treinamento e teste usando a função train_test_split disponível no Sklearn:

# --- Separar os dados de validação para o final --- #

tamanho_validacao = 0.2

seed = 7

X_treino, X_validacao, Y_treino, Y_validacao = train_test_split(

    X,

    Y,

    test_size=tamanho_validacao,

    random_state=seed

)

5.2. Identifique métricas de avaliação

Escolher qual métrica usar para avaliar os algoritmos de aprendizado de máquina é muito importante. Um aspecto importante das métricas de avaliação é a capacidade de discriminar entre os resultados do modelo. Diferentes tipos de métricas de avaliação usados ​​para diferentes tipos de modelos de ML são abordados em detalhes em vários capítulos do nosso estudo.

5.3. Compare modelos e algoritmos

Selecionar um modelo ou algoritmo de aprendizado de máquina é uma arte e uma ciência. Não existe uma solução ou abordagem que se encaixe em todos. Existem vários fatores além do desempenho do modelo que podem impactar a decisão para escolher um algoritmo de aprendizado de máquina.

Vamos entender o processo de comparação de modelos com um exemplo simples. Definimos duas variáveis, X e Y, e tentamos construir um modelo para prever Y usando X. Como uma primeira etapa, os dados são divididos em treinamento e teste, conforme mencionado na seção anterior:

import numpy as np

import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

tamanho_validacao = 0.2

seed = 7

X = 2 - 3 * np.random.normal(0, 1, 20)

Y = X - 2 * (X ** 2) + 0.5 * (X ** 3) + np.exp(-X) + np.random.normal(-3, 3, 20)

# ---  Transformar os dados para incluir outro eixo --- #

X = X[:, np.newaxis]

Y = Y[:, np.newaxis]

X_treino, X_teste, Y_treino, Y_teste = train_test_split(

    X,

    Y,

    test_size=tamanho_validacao,

    random_state=seed

)

Não temos ideia de quais algoritmos se sairão bem nesse problema. Vamos projetar nosso teste agora. Usaremos dois modelos - uma regressão linear e a segunda regressão polinomial para ajustar Y contra X. Avaliaremos algoritmos usando a métrica de raiz do erro quadrático médio (RMSE, sigla para o inglês), que é uma das medidas do desempenho do modelo. O RMSE dará uma ideia grosseira de como todas as previsões estão erradas (zero é perfeito):

from sklearn.linear_model import LinearRegression

from sklearn.preprocessing import PolynomialFeatures

from sklearn.metrics import mean_squared_error, r2_score

modelo = LinearRegression()

modelo.fit(X_treino, Y_treino)

Y_previsao = modelo.predict(X_treino)

rmse_lin = np.sqrt(mean_squared_error(Y_treino, Y_previsao))

r2_lin = r2_score(Y_treino, Y_previsao)

print(f'RMSE para o modelo de regressão linear: {rmse_lin}')

recursos_polinomiais = PolynomialFeatures(degree=2)

x_poli = recursos_polinomiais.fit_transform(X_treino)

modelo = LinearRegression()

modelo.fit(x_poli, Y_treino)

Y_previsao_poli = modelo.predict(x_poli)

rmse = np.sqrt(mean_squared_error(Y_treino, Y_previsao_poli))

r2 = r2_score(Y_treino, Y_previsao_poli)

print(f'RMSE para a regressão polinomial: {rmse}')

Podemos ver que o RMSE da regressão polinomial é um pouco melhor que o da regressão linear. Como o primeiro tem o melhor ajuste, é o modelo preferido nesta etapa.

6. Ajuste do modelo

Encontrar a melhor combinação de hiperparâmetros de um modelo pode ser tratado como um problema de pesquisa. Esse exercício de busca é frequentemente conhecido como ajuste do modelo e é uma das etapas mais importantes do desenvolvimento do modelo. É alcançado pesquisando os melhores parâmetros do modelo usando técnicas como uma pesquisa de grade. Em uma pesquisa de grade, você cria uma grade de todas as combinações possíveis de hiperparâmetro e treina o modelo usando cada um deles. Além de uma pesquisa de grade, existem várias outras técnicas para ajuste do modelo, incluindo pesquisa randomizada, otimização bayesiana e hyperbrand.

Nos estudos de caso apresentados em nosso estudo, nos concentramos principalmente na busca de grade por ajuste de modelo.

Continuando a partir do exemplo anterior, com o polinômio como o melhor modelo: em seguida, execute uma pesquisa de grade pelo modelo, reformando a regressão polinomial com diferentes graus. Comparamos os resultados do RMSE para todos os modelos:

graus = [1, 2, 3, 6, 10]

resultados = []

nomes = []

for grau in graus:

  recursos_polinomiais = PolynomialFeatures(degree=grau)

  x_poli = recursos_polinomiais.fit_transform(X_treino)

  modelo = LinearRegression()

  modelo.fit(x_poli, Y_treino)

  Y_previsao_poli = modelo.predict(x_poli)

  rmse = np.sqrt(mean_squared_error(Y_treino, Y_previsao_poli))

  r2 = r2_score(Y_treino, Y_previsao_poli)

  resultados.append(rmse)

  nomes.append(grau)

plt.plot(nomes, resultados, 'o')

plt.suptitle('Comparação dos algoritmos')

Saída:

O RMSE diminui quando o grau aumenta e o menor RMSE é para o modelo com o grau 10. No entanto, modelos com graus inferiores a 10 tiveram um desempenho muito bom, e o conjunto de testes será usado para finalizar o melhor modelo.

Embora o conjunto genérico de parâmetros de entrada para cada algoritmo forneça um ponto de partida para análise, ele pode não ter as configurações ideais para o conjunto de dados específico e o problema dos negócios.

7. Finalizar o modelo

Aqui, executamos as etapas finais para selecionar o modelo. Primeiro, executamos previsões no conjunto de dados de teste com o modelo treinado. Em seguida, tentamos entender a intuição do modelo e salvá-lo para uso adicional.

7.1. Desempenho no conjunto de testes

O modelo selecionado durante as etapas de treinamento é avaliado posteriormente no conjunto de testes. O conjunto de testes nos permite comparar modelos diferentes de maneira imparcial, baseando as comparações em dados que não foram usados ​​em nenhuma parte do treinamento. Os resultados do teste para o modelo desenvolvido na etapa anterior são mostrados no exemplo a seguir:

graus = [1, 2, 3, 6, 8, 10]

resultados_teste = []

nomes_teste = []

for grau in graus:

  recursos_polinomiais = PolynomialFeatures(degree=grau)

  x_poli = recursos_polinomiais.fit_transform(X_treino)

  modelo = LinearRegression()

  modelo.fit(x_poli, Y_treino)

  x_teste_poli = recursos_polinomiais.fit_transform(X_teste)

  Y_previsao_poli_teste = modelo.predict(x_teste_poli)

  rmse = np.sqrt(mean_squared_error(Y_teste, Y_previsao_poli_teste))

  r2 = r2_score(Y_teste, Y_previsao_poli_teste)

  resultados_teste.append(rmse)

  nomes_teste.append(grau)

plt.plot(nomes_teste, resultados_teste, 'o')

plt.suptitle('Comparação dos algoritmos')

Saída:

No conjunto de treinamento, vimos que o RMSE diminui com um aumento no grau de modelo polinomial, e o polinomial do grau 10 teve o menor RMSE. No entanto, como mostrado na saída anterior para o polinômio do grau 10, embora o conjunto de treinamento tenha os melhores resultados, os resultados no conjunto de testes são ruins. Para o polinômio do grau 8, o RMSE no conjunto de testes é relativamente maior. O polinômio do grau 6 mostra o melhor resultado no conjunto de testes (embora a diferença seja pequena em comparação com outros polinômios em grau inferior no conjunto de testes), além de bons resultados no conjunto de treinamento. Por esses motivos, este é o modelo preferido.

Além do desempenho do modelo, existem vários outros fatores a serem considerados ao selecionar um modelo, como simplicidade, interpretabilidade e tempo de treinamento. Esses fatores serão abordados nos próximos capítulos.

7.2. Intuição de modelo/variável

Esta etapa envolve considerar uma visão holística da abordagem adotada para resolver o problema, incluindo as limitações do modelo no que se refere ao resultado desejado, às variáveis ​​utilizadas e aos parâmetros do modelo selecionado. Detalhes sobre o modelo e a intuição variável em relação a diferentes tipos de modelos de aprendizado de máquina são apresentados nos capítulos e estudos de caso subsequentes.

7.3. Salvar/deploy

Depois de encontrar um modelo de aprendizado de máquina preciso, ele deve ser salvo e carregado para garantir seu uso posteriormente.

O Pickle é um dos pacotes para salvar e carregar um modelo treinado no Python. Usando operações de pickle, os modelos treinados de aprendizado de máquina podem ser salvos em um arquivo. Posteriormente, este arquivo pode ser carregado para carregar o modelo para o seu uso. O código a seguir demonstra como salvar o modelo em um arquivo e carregá-lo para fazer previsões sobre novos dados:

# --- Salvar o modelo usando Pickle --- #

from pickle import dump

from pickle import load

# --- Salvar o modelo no disco --- #

arquivo = 'modelo_final.sav'

dump(modelo, open(arquivo, 'wb'))

# --- Carregar o modelo --- #

modelo_carregado = load(arquivo)

Nos últimos anos, estruturas como o AutoML foram construídas para automatizar o número máximo de etapas em um processo de desenvolvimento do modelo de aprendizado de máquina. Tais estruturas permitem que os desenvolvedores de modelos construam modelos de ML com alta escala, eficiência e produtividade.

Resumo do capítulo

Dada sua popularidade, taxa de adoção e flexibilidade, o Python é frequentemente o idioma preferido para o desenvolvimento do aprendizado de máquina. Existem muitas bibliotecas de Python disponíveis para executar inúmeras tarefas, incluindo limpeza de dados, visualização e desenvolvimento de modelos. Alguns desses pacotes são Scikit-Learn e Keras.

As sete etapas do desenvolvimento do modelo mencionadas neste capítulo podem ser alavancadas durante o desenvolvimento de qualquer modelo baseado em aprendizado de máquina em finanças.

Próximos passos

No próximo capítulo, abordaremos o algoritmo principal para o aprendizado de máquina - a rede neural artificial. A rede neural artificial é outro bloco de construção de aprendizado de máquina em finanças e é usado em todos os tipos de aprendizado de máquina e algoritmos de aprendizado profundo.