Este artigo foi publicado como parte do Blogathon de Ciência de Dados
Neste blog, abordaremos tudo o que você precisa saber sobre regressão logística para começar e construir um modelo em Python. Se você é novo no aprendizado de máquina e nunca construiu um modelo antes, não se preocupe; depois de ler isso, tenho certeza de que você será capaz de fazer isso.
Para aqueles que são novos nisso, vamos começar com uma compreensão básica de aprendizado de máquina antes de passar para a regressão logística.
Em termos simples, o modelo de aprendizado de máquina usa algoritmos nos quais a máquina aprende com os dados, assim como os humanos aprendem com suas experiências. O aprendizado de máquina permite que os computadores encontrem insights ocultos sem serem explicitamente programados.
Tipos de algoritmos de aprendizado de máquina
Com base no tipo de saída e na tarefa realizada, os modelos de aprendizado de máquina são classificados nos seguintes tipos
A regressão logística se enquadra no tipo Aprendizagem Supervisionada. Vamos aprender mais sobre isso.
Aprendizagem Supervisionada
É um tipo de aprendizado de máquina que utiliza dados rotulados do passado. Os modelos são treinados usando amostras já rotuladas.
Exemplo: Você tem dados anteriores da primeira divisão de futebol e, com base nesses dados e resultados de partidas anteriores, prevê qual time vencerá o próximo jogo.
Aprendizagem supervisionada é ainda dividido em dois tipos-
- Regressão – a variável de destino/saída é contínua.
- Classificação – a variável de destino/saída é categórica.
A regressão logística é um modelo de classificação. Ajuda a fazer previsões onde a variável de saída é categórica. Com isso, vamos entender a regressão logística em detalhes.
O que é regressão logística?
Conforme afirmado anteriormente, a Regressão Logística é utilizada para resolver problemas de classificação. Os modelos são treinados em conjuntos de dados rotulados históricos e visam prever a qual categoria as novas observações pertencerão.
Abaixo estão alguns exemplos de problemas de classificação binária que podem ser resolvidos usando regressão logística-
- A probabilidade de um candidato político vencer ou perder as próximas eleições.
- Se uma máquina em fabricação irá parar de funcionar em alguns dias ou não.
- Filtrando e-mail como spam ou não spam.
A regressão logística é adequada quando precisamos prever uma resposta binária (apenas 2 valores possíveis, como sim ou não).
O termo regressão logística vem de “Função Logística,”que também é conhecido como“Função Sigmóide”. Vamos aprender mais sobre isso.
Função Logística/Sigmóide
A função sigmóide, comumente conhecida como função logística, prevê a probabilidade de ocorrência de um resultado binário. A função assume qualquer valor e o converte em um número entre 0 e 1. A Função Sigmóide é uma função de ativação de aprendizado de máquina usada para introduzir não linearidade em um modelo de aprendizado de máquina.
A fórmula da Função Logística é:
Quando plotamos a equação acima, obtemos Forma S curva como abaixo.
O ponto principal do gráfico acima é que não importa qual valor de x usamos na função logística ou sigmóide, o saída ao longo do eixo vertical será sempre entre 0 e 1.
Quando o resultado da função sigmóide é maior que 0.5, classificamos o rótulo como classe 1 ou classe positiva; se for menor que 0.5, podemos classificá-lo como uma classe negativa ou
Vamos entender o matemática por trás da função sigmóide.
A regressão logística é derivada da regressão linear ignorando seu valor de saída para a função sigmóide e a equação para a regressão linear é –
Na regressão linear, tentamos encontrar a linha de melhor ajuste alterando os valores m e c da equação acima e y (saída) pode assumir qualquer valor de -infinito a +infinito. Porém, a regressão logística prevê a probabilidade de resultado que pode estar entre 0 e 1. Portanto, para converter esses valores entre 0 e 1 usamos a função sigmóide.
depois de obter nosso valor de saída precisamos ver como funciona nosso modelo, para isso precisamos calcular a função de perda. A função de perda nos diz o quanto nossa produção prevista difere da produção real. Um bom modelo deve ter menos valor de perda. Vamos ver como calcular a função de perda.
Quando y=1, o valor de y previsto deve estar próximo de 1 para reduzir a perda. Agora vamos ver quando nosso valor de saída real é 0.
Quando y=0, o valor de y previsto deve estar próximo de 0 para reduzir a perda.
Vamos prosseguir para a implementação do modelo de regressão logística agora que cobrimos o básico.
Implementação passo a passo do modelo de regressão logística em Python
Com base nos parâmetros do conjunto de dados, construiremos um Modelo de regressão logística em Python para prever se um funcionário será promovido ou não.
Para todos, os ciclos de promoção ou avaliação são os momentos mais emocionantes do ano. As promoções finais só são divulgadas depois que os funcionários são avaliados de acordo com diversos critérios, o que causa atraso na transição para novas responsabilidades. Construiremos um modelo de aprendizado de máquina para prever quem está qualificado para promoção e acelerar o processo.
Você pode obter mais compreensão da declaração do problema e baixe o conjunto de dados de Aprendizagem supervisionada.
Importando Bibliotecas
Começaremos carregando as bibliotecas necessárias para criar um modelo de Regressão Logística.
importar numpy como np importar pandas como pd #Bibliotecas para visualização de dados importar matplotlib.pyplot como plt importar seaborn como sns #Usaremos o sklearn para construir o modelo de regressão logística de sklearn.linear_model importar LogisticRegression
Carregando conjunto de dados
Bem
use o conjunto de dados HR Analytics do link acima. Começaremos carregando o
conjunto de dados do arquivo CSV baixado com o código abaixo.
# Carregando conjunto de dados do arquivo CSV dados = pd.read_csv("train_LZdllcl.csv",sep=",")
Compreendendo os dados para regressão logística
É sempre uma boa ideia aprender mais sobre os dados depois de carregá-los, como o formato dos dados e informações estatísticas sobre as colunas em um conjunto de dados. Podemos conseguir tudo isso com o código abaixo:
#forma do conjunto de dados print("formato do dataframe é: ", data.shape) #Vejamos as primeiras 5 linhas do conjunto de dados dados.head(5) # resumo dos dados dados.info() #Obtenha detalhes estatísticos dos dados dados.describe()
Há um total de 14 variáveis neste conjunto de dados, com um total de 54808 observações. “é_promovido" é nosso Variável alvo, que tem duas categorias codificadas como 1 (promovido) e 0 (não promovido), todos restantes são recursos de entrada. Além disso, podemos observar que nosso conjunto de dados contém recursos numéricos e categóricos.
Limpeza de Dados
A limpeza de dados é uma etapa crucial no processo de pré-processamento de dados. Bem remova colunas com apenas um valor único porque a variância deles será 0 e não nos ajudarão a antecipar nada.
Vamos ver se há alguma coluna que
tem apenas um valor único.
#Verificando as contagens de valores exclusivos nas colunas featureValues={} para d em data.columns.tolist(): count=data[d].nunique() if count==1: featureValues[d]=count # Lista de colunas com o mesmo valor único cols_to_drop= list(featureValues.keys()) print("Colunas com 1 valor único são: n",cols_to_drop)
Isso significa que não existe nenhuma coluna com apenas 1 valor único.
Bem agora elimine a coluna Employee_id porque é apenas um identificador exclusivo e
em seguida, verifique cada campo no conjunto de dados para obter porcentagens de valor nulo.
#Elimine a coluna Employee_id, pois é apenas um ID exclusivo data.drop("employee_id",inplace=True,axis=1) #Verificando porcentagem nula dados.isnull().mean()*100
classificação_ano_anterior e educação ambos os recursos tem valores nulos. Como resultado, imputaremos esses valores nulos em vez de eliminá-los. Após nosso exame dessas colunas, descobrimos que –
- Para linhas com nulo classificação_ano_anterior, podemos ver que o tempo de serviço é 1, o que pode ser o motivo pelo qual não possuem classificação do ano anterior. Como resultado, usaremos 0 para imputar valores nulos.
- Para o educação coluna, vamos imputar valores nulos com modo.
#fill valor faltante dados["ano_anterior_rating"]= dados["ano_anterior_rating"].fillna(0) #alterar tipo para int dados["ano_anterior_rating"]= dados["ano_anterior_rating"].astype("int") #Descubra o valor do modo para educação dados["educação"].mode() #preencher o valor faltante com o modo data["education"]= data["education"].fillna("Bacharelado")
Agora, não temos nenhum valor nulo ou ausente em nossos dados. Então vamos
prossiga para o nosso próximo passo. Não há nulo ou
valores ausentes em nossos dados agora. Então, vamos para a próxima etapa.
Análise Exploratória de Dados antes de criar um Modelo de Regressão Logística
Obter insights dos dados e visualizá-los é uma etapa importante no aprendizado de máquina, pois nos fornece uma visão melhor dos recursos e de seus relacionamentos.
Vejamos a distribuição da variável alvo no conjunto de dados.
# cchart para distribuição da variável alvo fig= plt.figura(figsize=(10,3) ) fig.add_subplot(1,2,1) a= dados["is_promoted"].value_counts(normalize=True).plot.pie() fig.add_subplot(1,2,2) churnchart = sns.countplot (x = dados ["is_promoted"]) plt.tight_layout() plt.show()
Podemos observar nos gráficos acima que os dados dos funcionários promovidos são menores do que os dados dos funcionários não promovidos, indicando que há um desequilíbrio de classe porque a classe 0 tem mais pontos de dados ou observações do que a classe.
Vamos visualizar se existe alguma relação entre a variável alvo e outras variáveis.
# Visualize o relacionamento entre os recursos promovidos e outros fig= plt.figura(figsize=(10,5) ) fig.add_subplot(1,3,1) ar_6=sns.boxplot(x=dados["is_promoted"],y=dados["comprimento_do_serviço"]) fig.add_subplot(1,3,2) ar_6=sns.boxplot(x=dados["is_promoted"],y=dados["avg_training_score"]) fig.add_subplot(1,3,3) ar_6=sns.boxplot(x=dados["is_promoted"],y=dados["ano_anterior_rating"]) plt.tight_layout() plt.show()
Para um funcionário Se o valor avg_training_score for maior, as chances de ser promovido são maiores.
Traçaremos correlações entre diferentes variáveis usando um mapa de calor.
#correlação entre recursos corr_plot = sns.heatmap(data.corr(),annot = True,linewidths=3 ) plt.title("Gráfico de correlação") plt.show()
Nenhuma das características está altamente correlacionada entre si, exceto idade e comprimento de vida.
o serviço.
Engenharia de recursos
Na engenharia de recursos, aplicamos conhecimento de domínio para produzir novos recursos a partir de dados brutos ou convertemos ou codificamos recursos. Codificaremos recursos categóricos ou faça recursos fictícios dentre eles nesta seção.
#Convertendo colunas categóricas em uma codificação ativa dados["gênero"]=dados["gênero"].apply(lambda x: 1 if x=="m" else 0) #lista de colunas cols = data.select_dtypes(["objeto"]).columns #Crie variáveis fictícias ds=pd.get_dummies(dados[cols],drop_first=True) ds #concat colunas recém-criadas com dataframe original dados=pd.concat([dados,ds],eixo=1) #Drop colunas originais data.drop(cols,axis=1,inplace=True)
Divisão de teste de trem
Dividiremos o conjunto de dados em dois subconjuntos: treinamento e teste. Para realizar a divisão train-test, usaremos o aprendizado de máquina Scikit-learn.
- Subconjunto de trens – usaremos este subconjunto para ajustar/treinar o modelo
- Subconjunto de teste – usaremos este subconjunto para avaliar nosso modelo
de sklearn.model_selection importar train_test_split #dividir os dados em variáveis dependentes (X) e variáveis independentes (y) que poderíamos prever y = data.pop("é_promovido") X = dados #Vamos dividir X e y usando a divisão de teste do Train X_train,X_test,y_train,y_test = train_test_split(X,y,random_state=42,train_size=0.8) #get shape dos dados de treinamento e teste print("tamanho do trem X: ",X_train.shape) print("tamanho do trem y: ",y_train.shape) print("tamanho do teste X: ",X_test.shape) print("tamanho do teste y: ",y_test.shape)
Depois de dividir o conjunto de dados, temos 43846 observações no subconjunto de treinamento e 10962 no subconjunto de teste.
Depois de mergulhar no conjunto de dados, vamos passar para a próxima fase de dimensionamento de recursos.
Dimensionamento/normalização de recursos
Por que o dimensionamento de recursos é importante?
Conforme afirmado anteriormente, a Regressão Logística usa Gradient Descent como uma das abordagens para obter o melhor resultado, e o dimensionamento de recursos ajuda a acelerar a descida gradiente processo de convergência. Quando temos características que variam muito em magnitude, o algoritmo assume que características com grande magnitude são mais relevantes do que aquelas com magnitude pequena. Como resultado, quando treinamos o modelo, essas características tornam-se mais importantes.
Por causa disso o dimensionamento de recursos é necessário para colocar todos os recursos no mesmo intervalo, independentemente da sua relevância.
Técnicas de dimensionamento de recursos
Trazemos todos os recursos para o mesmo intervalo usando escalonamento de recursos. Existem muitas maneiras de dimensionar recursos, como normalização, padronização, dimensionamento robusto, dimensionamento mínimo-máximo, etc. Mas aqui discutiremos a técnica de padronização que aplicaremos aos nossos recursos.
Na padronização, os recursos serão dimensionados para ter uma média de 0 e um desvio padrão de 1. It não se ajusta a um intervalo predefinido. Os recursos são dimensionados usando a fórmula abaixo:
z = (x – você) /s
onde u é a média das amostras de treinamento e s é um desvio padrão das amostras de treinamento.
Vamos ver como fazer o dimensionamento de recursos em python usando Scikit-learn.
#Escalonamento de recursos de sklearn.preprocessing importar StandardScaler escala=StandardScaler() X_train = escala.fit_transform(X_train) X_teste = escala.transform(X_teste)
Desequilíbrio de classe
Qual é o desequilíbrio de classe?
quando um conjunto de dados tem mais pontos de dados ou
observações pertencentes a uma categoria e muito poucas para outra, chamamos
trata-se de um problema de desequilíbrio de classes, uma vez que o distribuição de rótulos de classe é
não equilibrado e distorcido. Vamos ver se temos um problema de desequilíbrio de classes.
#check para distribuição de rótulos y_train.value_counts(normalize=True)
Podemos observar que a maioria dos rótulos são da classe 0 e apenas alguns são da classe 1.
If usamos esta distribuição para desenvolver o nosso modelo, este pode tornar-se tendencioso no sentido de prever a classe maioritária, uma vez que não haverá dados suficientes para aprender os padrões das classes minoritárias. O modelo irá comece a prever cada nova observação como 0 or classe majoritária. (No nosso problema o funcionário não é promovido). Obteremos mais precisão do modelo aqui, mas não será um modelo decente porque não vou prever classe 1 ou classe minoritária, que é uma classe crucial.
Como resultado, devemos considerar o desequilíbrio de classes ao desenvolver o nosso modelo de Regressão Logística.
Como lidar com o desequilíbrio de classes?
Há uma variedade de abordagens para lidar com o desequilíbrio de classes, como aumentando amostras de classes minoritárias or diminuindo amostras de classe majoritária para garantir que ambas as classes tenham a mesma distribuição.
Como estamos usando a biblioteca de máquina Scikit-learn para criar o modelo, ela possui um implementação de regressão logística que suporta ponderação de classe. Usaremos o parâmetro embutido “peso_classe”Ao criar uma instância do modelo de regressão logística.
Tanto a classe majoritária quanto a minoritária receberão pesos separados. Durante a fase de treino, as diferenças de peso influenciarão na classificação das aulas.
O objetivo de adicionar pesos de classe é penalizar a classe minoritária por classificação incorreta, definindo um peso de classe mais alto e diminuindo o peso da classe majoritária.
Construir e treinar modelo de regressão logística em Python
Para implementar a regressão logística, usaremos a biblioteca Scikit-learn. Começaremos construindo um modelo básico com parâmetros padrão e, em seguida, veremos como melhorá-lo com o ajuste de hiperparâmetros.
Como dito anteriormente, usaremos o Parâmetro “class_weight” para resolver o problema de desequilíbrio de classe. Vamos começar criando nosso modelo base com o código abaixo.
#importar biblioteca de sklearn.linear_model importar LogisticRegression #make instância do modelo com parâmetros padrão exceto peso da classe #pois adicionaremos pesos de classe devido ao problema de desequilíbrio de classe lr_basemodel =Regressão Logística(class_weight={0:0.1,1:0.9}) # treinar modelo para aprender relações entre variáveis de entrada e saída lr_basemodel.fit(X_train,y_train)
Depois de treinar nosso modelo no conjunto de dados de treinamento, usamos nosso modelo para prever valores para o conjunto de dados de teste e os registramos na variável y_pred_basemodel.
Vejamos quais métricas usar e como avaliar nosso modelo base.
Métricas de avaliação do modelo
Para avaliar o desempenho ou nosso modelo usaremos “pontuação f1”, pois este é um desequilíbrio de classe problema usar a precisão como métrica de desempenho também não é bom, podemos dizer que a pontuação f1 é a métrica ideal quando temos um problema de desequilíbrio de classe. A fórmula para calcular a pontuação F1 é a seguinte:
Pontuação F1 = 2*(Recall * Precisão) / (Recall + Precisão)
Precisão é a razão entre observações positivas previstas com precisão e o total de observações positivas previstas.
Precisão = TP/TP+FP
Recordar é a proporção entre observações positivas previstas com precisão e todas as observações na aula real – sim.
Rechamada = TP/TP+FN
Pontuação F1 é a média ponderada de Precisão e Recall. Portanto, esta pontuação leva em consideração falsos positivos e falsos negativos.
Vamos avaliar nosso modelo básico usando a pontuação f1.
de sklearn.metrics importar f1_score print("A pontuação f1 para o modelo base é: ", f1_score(y_test,y_pred_basemodel))
Obtivemos uma pontuação f0.37 de 1 em nosso modelo básico criado usando parâmetros padrão.
Até este ponto, vimos como criar um modelo de regressão logística usando parâmetros padrão.
Agora vamos aumentar o desempenho do modelo e avaliá-lo novamente após ajustar os hiperparâmetros do modelo.
Otimização de hiperparâmetros para o modelo de regressão logística
Os parâmetros do modelo (como peso, tendência e assim por diante) são aprendidos a partir dos dados, enquanto hiperparâmetros especificam como nosso modelo deve ser organizado. O processo de encontrar o ajuste ideal ou a arquitetura do modelo ideal é conhecido como ajuste de hiperparâmetros. Hiperparâmetros controlar o overfitting ou underfitting do modelo. O ajuste de hiperparâmetros pode ser feito usando algoritmos como Pesquisa de grade or Pesquisa Aleatória.
Usaremos Grid Search, que é o método mais básico de busca de valores ideais para hiperparâmetros. Para ajustar hiperparâmetros, siga as etapas abaixo:
- Crie uma instância de modelo da classe Regressão Logística
- Especifique hiperparâmetros com todos os valores possíveis
- Definir métricas de avaliação de desempenho
- Aplicar validação cruzada
- Treine o modelo usando o conjunto de dados de treinamento
- Determine os melhores valores para os hiperparâmetros fornecidos.
Podemos usar o código abaixo para implementar o ajuste de hiperparâmetros em python usando o método Grid Search.
#Ajuste de hiperparâmetros #define modelo/cria instância lr=Regressão Logística() #tuning peso para a classe minoritária, então o peso para a classe majoritária será 1-peso da classe minoritária #Definindo o intervalo para pesos de classe pesos = np.linspace(0.0,0.99,500) #especificando todos os hiperparâmetros com valores possíveis param= {'C': [0.1, 0.5, 1,10,15,20], 'penalidade': ['l1', 'l2'],,"class_weight":[{0:x ,1:1.0 -x } para x em pesos]} #crie 5 dobras dobras = StratifiedKFold(n_splits = 5, shuffle = True, random_state = 42) #Gridsearch para ajuste de hiperparâmetros modelo= GridSearchCV(estimador= lr,param_grid=param,scoring="f1",cv=folds,return_train_score=True) #train modelo para aprender relações entre x e y model.fit(X_train,y_train)
Após ajustar o modelo, extrairemos os melhores valores de ajuste para todos os hiperparâmetros especificados.
# imprime os melhores hiperparâmetros print("Melhor pontuação na F1: ", model.best_score_) print("Melhores hiperparâmetros: ", model.best_params_)
Agora construiremos nosso modelo de regressão logística usando os valores acima obtidos ajustando os hiperparâmetros.
Construir modelo usando valores ideais de hiperparâmetros
Vamos usar o código abaixo para construir nosso modelo novamente.
#Building Model novamente com melhores parâmetros lr2=Regressão Logística(class_weight={0:0.27,1:0.73},C=20,penalty="l2") lr2.fit(X_train,y_train)
Depois de treinar nosso modelo final, é hora de avaliar nosso modelo de regressão logística usando as métricas escolhidas.
Avaliação de modelo
Avaliaremos nosso modelo no conjunto de dados de teste. Primeiro, preveremos valores no conjunto de dados de teste.
Escolhemos “pontuação f1” como nossa métrica de desempenho acima, mas vamos dar uma olhada nas pontuações de todas as métricas, incluindo métricas de confusão, precisão, recall, pontuação ROC-AUC e, finalmente, pontuação f1, para fins de aprendizagem.
Em seguida, compararemos a pontuação f1 do nosso modelo final com o nosso modelo base para ver se melhorou.
Usaremos o código abaixo para calcular a pontuação
para várias métricas:
# prever probabilidades no teste e obter probabilidade para a classe 1([:1]) y_pred_prob_test = lr2.predict_proba(X_test)[:, 1] #predict rótulos no conjunto de dados de teste y_pred_test = lr2.predict(X_test) # cria matriz de onfusão cm = matriz_confusão(y_test, y_pred_test) print("Matriz de confusão é :nn",cm) imprimir("n") # Pontuação ROC-AUC print("Conjunto de dados de teste de pontuação ROC-AUC: t", roc_auc_score(y_test,y_pred_prob_test)) #Pontuação de precisão print("conjunto de dados de teste de pontuação de precisão: t", Precision_score(y_test,y_pred_test)) #Pontuação de recall print("Conjunto de dados de teste de pontuação de recuperação: t", recall_score(y_test,y_pred_test)) #f1 pontuação print("conjunto de dados de teste de pontuação f1: t", f1_score(y_test,y_pred_test))
Podemos ver que ao ajustar os hiperparâmetros, conseguimos melhorar o desempenho do nosso modelo, uma vez que nossa pontuação F1 para o modelo final (0.43) é maior do que a do modelo base (0.37). Depois que o modelo de ajuste de hiperparâmetros obteve uma pontuação ROC-AUC de 0.88.
Com isso, conseguimos construir nosso modelo de regressão logística e testá-lo no conjunto de dados Test. Mais engenharia de recursos, otimização de hiperparâmetros e técnicas de validação cruzada podem melhorar ainda mais seu desempenho.
Conclusão
Começamos nossa jornada de aprendizado compreendendo os fundamentos do aprendizado de máquina e da regressão logística. Em seguida, passamos para a implementação de um modelo de Regressão Logística em Python. Aprendemos as principais etapas na construção de um modelo de regressão logística, como limpeza de dados, EDA, engenharia de recursos, dimensionamento de recursos, tratamento de problemas de desequilíbrio de classe, treinamento, previsão e avaliação do modelo no conjunto de dados de teste. Além disso, aprendemos como usar o ajuste de hiperparâmetros para melhorar o desempenho do nosso modelo e evitar overfitting e underfitting.
Espero que você ache esta informação útil e experimente.
Conecte-se comigo no LinkedIn.
As mídias mostradas neste artigo não são propriedade da Analytics Vidhya e são usadas a critério do autor.
- "
- 98
- Conta
- algoritmo
- algoritmos
- Todos os Produtos
- análise
- analítica
- arquitetura
- artigo
- fundamentos básicos
- MELHOR
- BLOG
- Caixa
- construir
- Prédio
- chances
- charts
- classificação
- Limpeza
- código
- Coluna
- computadores
- confusão
- Criar
- curva
- dados,
- análise de dados
- Visualização de dados
- lidar
- atraso
- detalhe
- desenvolver
- descoberto
- Cair
- Educação
- Eleição
- colaboradores
- Engenharia
- etc.
- Experiências
- Característica
- Funcionalidades
- Figo
- Primeiro nome
- caber
- seguir
- Futebol
- função
- jogo
- Gênero
- Bom estado, com sinais de uso
- Grade
- guia
- Manipulação
- SUA PARTICIPAÇÃO FAZ A DIFERENÇA
- Como funciona o dobrador de carta de canal
- Como Negociar
- hr
- HTTPS
- Humanos
- idéia
- imagem
- Incluindo
- Crescimento
- influência
- INFORMAÇÕES
- insights
- IT
- Chave
- Rótulos
- grande
- APRENDER
- aprendido
- aprendizagem
- Biblioteca
- Line
- LINK
- Lista
- aprendizado de máquina
- Maioria
- fabrica
- Match
- Mídia
- Métrica
- minoria
- ML
- modelo
- mover
- Novos Recursos
- Outros
- atuação
- Precisão
- predição
- Previsões
- Premier League
- promoção
- Python
- alcance
- Cru
- dados não tratados
- Leitura
- reduzir
- regressão
- Relacionamentos
- DESCANSO
- Resultados
- corrida
- Escala
- dimensionamento
- Ciência
- Pesquisar
- contexto
- simples
- Tamanho
- pequeno
- So
- RESOLVER
- Spam
- velocidade
- divisão
- Etapa
- começo
- começado
- Declaração
- aprendizagem supervisionada
- suportes
- Target
- conta
- teste
- O Básico
- tempo
- Training
- us
- valor
- Ver
- visualização
- QUEM
- ganhar
- trabalho
- X
- ano