O principal objetivo desta leitura é compreender a metodologia estatística suficiente para poder tirar proveito dos algoritmos de aprendizado de máquina, que estão na biblioteca scikit-learn de Python e, em seguida, aplicar esse conhecimento para resolver um problema clássico de aprendizado de máquina.

A primeira parada de nossa jornada nos levará por uma breve história do aprendizado de máquina. Em seguida, iremos mergulhar em diferentes algoritmos. Em nossa parada final, usaremos o que aprendemos para resolver o Problema de previsão da taxa de sobrevivência do Titanic .

Algumas isenções de responsabilidade:

• eu sou um engenheiro de software pilha completa , não é um especialista em algoritmos de aprendizado de máquina.
• Eu acho que você sabe algo básico Pitão .
• Isso é exploratório, então nem todos os detalhes são explicados como seria em um tutorial .

Com isso dito, vamos começar!

Uma introdução rápida aos algoritmos de aprendizado de máquina

Assim que você se aventura neste campo, você percebe que aprendizado de máquina é menos romântico do que você pensa. Inicialmente, estava cheio de esperanças de que depois de aprender mais, seria capaz de construir meu próprio AI Jarvis, que passaria o dia todo codificando software e ganhando dinheiro para mim, para que pudesse passar dias inteiros ao ar livre lendo livros, montando um motocicleta, e desfrutar de um estilo de vida imprudente enquanto meu Jarvis pessoal faz meus bolsos afundarem. No entanto, logo percebi que a base dos algoritmos de aprendizado de máquina são as estatísticas, que pessoalmente considero chatas e desinteressantes. Felizmente, descobriu-se que estatísticas “enfadonhas” têm algumas aplicações fascinantes.

Você logo descobrirá que, para chegar a essas aplicações fascinantes, é necessário entender muito bem as estatísticas. Um dos objetivos dos algoritmos de aprendizado de máquina é encontrar dependências estatísticas nos dados fornecidos.

Os dados fornecidos podem variar desde verificar a pressão arterial versus idade até encontrar texto manuscrito com base na cor de vários pixels.

Dito isso, eu estava curioso para ver se você poderia usar algoritmos de aprendizado de máquina para encontrar dependências em funções de hash criptográficas (SHA, MD5, etc.) - no entanto, você não pode fazer isso porque as cripto primitivas apropriadas são construídas em tal maneira que eles eliminam dependências e produzem resultados que são significativamente difíceis de prever. Acho que, dado o tempo infinito, os algoritmos de aprendizado de máquina podem quebrar qualquer modelo de criptografia.

Infelizmente, não temos muito tempo, então temos que encontrar outra maneira de minerar com eficiência a criptomoeda. Quão longe chegamos até agora?

Uma breve história dos algoritmos de aprendizado de máquina

As raízes dos algoritmos de aprendizado de máquina vêm de Thomas Bayes, que foi um estatístico inglês e viveu no século 18. O artigo dele Um ensaio para resolver um problema na doutrina das oportunidades subjacentes Teorema de Bayes , que é amplamente aplicado no campo das estatísticas.

No século 19, Pierre-Simon Laplace publicou Teoria analítica da probabilidade , expandindo o trabalho de Bayes e definindo o que conhecemos hoje como Teorema de Bayes. Pouco antes, Adrien-Marie Legendre descreveu o método dos “mínimos quadrados”, que também é amplamente usado hoje em dia no aprendizado supervisionado.

O século 20 é o período em que a maioria das descobertas publicamente conhecidas foram feitas neste campo. Andrey Markov inventou as cadeias de Markov, que usou para analisar poemas. Alan Turing propôs uma máquina de aprendizado que poderia se tornar artificialmente inteligente, basicamente prenunciando algoritmos genéticos. Frank Rosenblatt inventou o Perceptron , que gerou grande entusiasmo e grande cobertura da mídia.

Mas aí, na década de 1970, havia muito pessimismo em torno da ideia da IA ​​e, portanto, da redução do financiamento, por isso esse período é chamado de “inverno”. A redescoberta da retropropagação na década de 1980 provocou um ressurgimento na pesquisa de aprendizado de máquina. E hoje, é um assunto quente novamente.

O falecido Leo Breiman distinguiu dois modelos de paradigma estatístico. 'Modelagem Algorítmica', que significa mais ou menos, algoritmos de aprendizado de máquina, semelhantes a floresta aleatória .

Aprendizado de máquina e estatísticas são campos relacionados. De acordo com Michael I. Jordan As ideias de aprendizado de máquina, de princípios metodológicos a ferramentas teóricas, têm uma longa pré-história em estatística. Também sugeriu o ciência do namoro como um termo estável para o problema geral no qual os especialistas em aprendizado de máquina e estadistas têm trabalhado.

Categorias de algoritmos de aprendizado de máquina

O campo do aprendizado de máquina é estabelecido em dois pilares principais chamados aprendizagem supervisionada Y aprendizagem não supervisionada . Algumas pessoas também consideram um novo campo de estudo, como— aprendizado profundo —Isso está separado da questão comum da aprendizagem supervisionada ou não supervisionada.

Aprendizagem supervisionada ocorre quando um computador é apresentado com exemplos de entradas e suas saídas desejadas. O objetivo é aprender sobre fórmulas gerais que mapeiam entradas em saídas. Isso pode ser dividido da seguinte forma:

• Aprendizagem semissupervisionada , ocorre quando o computador recebe treinamento incompleto acompanhado de saídas ausentes
• Aprendizado ativo , ocorre quando o computador só pode obter rótulos de aprendizagem para um conjunto limitado de instâncias. Quando usados ​​interativamente, seus conjuntos de treinamento podem ser apresentados ao usuário como marcados
• Aprendizagem por reforço , ocorre quando os dados de treinamento são fornecidos apenas como feedback para as ações do programa no ambiente dinâmico, como dirigir um veículo ou jogar um jogo contra um oponente

Em contraste, o aprendizagem não supervisionada Ocorre quando nenhum rótulo é concedido e cabe ao algoritmo encontrar a estrutura em sua entrada. O aprendizado não supervisionado pode ser um objetivo em si mesmo quando precisamos apenas descobrir padrões ocultos.

Aprendizagem profunda É um novo campo de estudo que se inspira na estrutura e função do cérebro humano, da mesma forma que se baseia em redes neurais artificiais ao invés de apenas conceitos estatísticos. O aprendizado profundo pode ser usado em abordagens supervisionadas e não supervisionadas.

Neste artigo, veremos alguns dos algoritmos de aprendizado de máquina supervisionados mais simples e os usaremos para calcular as chances de sobrevivência de um indivíduo no trágico naufrágio do titânico. Mas, em geral, se você não tiver certeza de qual algoritmo usar, um bom lugar para começar é o folha de revisão de algoritmo de aprendizado de máquina scikit-learn .

Modelos básicos de aprendizado de máquina supervisionado

Talvez o algoritmo mais simples seja a regressão linear. Isso às vezes pode ser representado graficamente como uma linha reta, mas apesar do nome, se houver uma hipótese polinomial, essa linha pode ser uma curva. Em ambos os casos, ele modela as relações entre uma variável dependente escalar $ e $ e um ou mais valores explicativos denotados por $ x $.

Em termos leigos, isso significa que a regressão linear é o algoritmo que aprende a dependência entre cada um dos já conhecidos $ x $ e $ y $, tanto que podemos usá-lo para prever $ y $ para uma amostra desconhecida de $ x $.

como escrever um bot para discórdia

Em nosso primeiro exemplo de aprendizado supervisionado, usaremos um modelo de regressão linear básico para prever a pressão arterial de uma pessoa com base em sua idade. Leste é um conjunto de dados muito simples com duas características importantes: idade e pressão arterial.

Conforme mencionado acima, a maioria dos algoritmos de aprendizado de máquina funciona encontrando uma dependência estatística nos dados que são fornecidos a eles. Esta dependência é chamada de hipótese e geralmente é denotado por $ h ( theta) $.

Para decifrar essa hipótese, vamos começar baixando e explorando os dados.

import matplotlib.pyplot as plt from pandas import read_csv import os # Cargar datos data_path = os.path.join(os.getcwd(), 'data/blood-pressure.txt') dataset = read_csv(data_path, delim_whitespace=True) # Tenemos 30 entradas en nuestro set de data y cuatro características. La primera característica es la identificación de la entrada. # La segunda característica siempre es la nro. 1. La tercera es la edad y la última es la presión arterial. # Ahora dejaremos de lado la Identificación y la característica Uno por ahora, ya que no es importante. dataset = dataset.drop(['ID', 'One'], axis=1) # Y mostraremos esta gráfica %matplotlib inline dataset.plot.scatter(x='Age', y='Pressure') # Ahora, asumiremos que ya sabemos la hipótesis y parece una línea recta h = lambda x: 84 + 1.24 * x # ahora agreguemos esta línea a la gráfica ages = range(18, 85) estimated = [] for i in ages: estimated.append(h(i)) plt.plot(ages, estimated, 'b')

[]

No gráfico acima, cada ponto azul representa nossos dados de amostra e a linha azul é a hipótese que nosso algoritmo deve aprender. Então, qual é essa hipótese?

Para resolver esse problema, precisamos aprender a dependência entre $ x $ e $ y $, que é denotada por $ y = f (x) $. Portanto, $ f (x) $ é a função objetivo ideal. O algoritmo de aprendizado de máquina tentará adivinhar a função de hipótese $ h (x) $, que é a aproximação mais próxima da desconhecida $ f (x) $.

A forma mais simples de hipótese para o problema de regressão linear é a seguinte: $ h_ theta (x) = theta_0 + theta_1 * x $. Temos uma variável escalar de entrada simples $ x $, que gera uma variável escalar simples $ y $, onde $ theta_0 $ e $ theta_1 $ são parâmetros que devemos aprender. O processo de ajuste dessa linha azul nos dados é chamado de regressão linear. É importante entender que temos apenas um parâmetro de entrada $ x_1 $; entretanto, muitas das funções de hipótese também incluirão uma unidade com inclinação ($ x_0 $). Portanto, nossa hipótese resultante tem a forma de $ h_ theta (x) = theta_0 * x_0 + theta_1 * x_1 $. Mas podemos evitar escrever $ x_0 $ porque quase sempre é igual a 1.

Voltando para a linha azul. Nossa hipótese é semelhante a $ h (x) = 84 + 1,24x $, o que significa que $ theta_0 = 84 $ e $ theta_1 = 1,24 $. Como podemos derivar automaticamente esses valores $ theta $?

Precisamos definir um função de custo . Essencialmente, o que uma função de custo faz é calcular a raiz quadrada do erro entre o modelo de previsão e a própria saída.

[J ( theta) = frac {1} {2m} sum_ {i = 1} ^ m (h_ theta (x ^ {(i)}) - y ^ {(i)}) ^ 2 ]

Por exemplo, nossa hipótese prevê que, para alguém de 48 anos, sua pressão arterial deve ser $ h (48) = 84 + 1,24 * 48 = 143mmHg $; entretanto, em nossa amostra de treinamento, temos o valor de $ 130 mmHg $. Portanto, o erro é $ (143 - 130) ^ 2 = $ 169. Agora precisamos calcular esse erro em cada entrada em nosso conjunto de dados de treinamento e, em seguida, adicionar todos juntos ($ sum_ {i = 1} ^ m (h_ theta (x ^ {(i)}) - y ^ {(i )}) ^ 2 $) e obtenha o valor significativo daí. Isso nos dá um único número escalar, que representa o custo da função. Nosso objetivo é encontrar os valores $ theta $, de forma que a função de custo seja menor; em outras palavras, queremos minimizar a função de custo. Esperançosamente, isso é intuitivo: se tivermos um valor de função de custo pequeno, isso significa que o erro de previsão também seria baixo.

import numpy as np # Calculemos el costo para la hipótesis de arriba h = lambda x, theta_0, theta_1: theta_0 + theta_1 * x def cost(X, y, t0, t1): m = len(X) # the number of the training samples c = np.power(np.subtract(h(X, t0, t1), y), 2) return (1 / (2 * m)) * sum(c) X = dataset.values[:, 0] y = dataset.values[:, 1] print('J(Theta) = %2.2f' % cost(X, y, 84, 1.24))

J(Theta) = 1901.95

Agora, precisamos encontrar os valores de $ theta $ tanto que o valor de nosso função de custo é mínimo. Mas como podemos fazer isso?

[minJ ( theta) = frac {1} {2m} sum_ {i = 1} ^ m (h_ theta (x ^ {(i)}) - y ^ {(i)}) ^ 2 ]

Existem muitos algoritmos possíveis, mas o mais popular é gradiente descendente . Para entender a intuição por trás do método gradiente descendente, vamos colocá-lo no gráfico primeiro. Para simplificar, assumiremos uma hipótese mais simples $ h ( theta) = theta_1 * x $. Então, teremos um gráfico 2D simples onde $ x $ é o valor de $ theta $ e $ y $ é a função de custo neste ponto.

princípios e elementos de design visual

import matplotlib.pyplot as plt fig = plt.figure() # Genera los datos theta_1 = np.arange(-10, 14, 0.1) J_cost = [] for t1 in theta_1: J_cost += [ cost(X, y, 0, t1) ] plt.plot(theta_1, J_cost) plt.xlabel(r'$ heta_1$') plt.ylabel(r'$J( heta)$') plt.show()

A função de custo é convexa, o que significa que no intervalo $ [a, b] $ existe apenas um mínimo. O que significa que os melhores parâmetros $ theta $ estão no ponto onde a função de custo é mais baixa.

Basicamente, gradiente descendente é um algoritmo que tenta encontrar um conjunto de parâmetros que minimiza a função. Ele começa com um conjunto inicial de parâmetros e dá passos interativos em direção à direção negativa da função gradiente.

Se calcularmos a derivada de uma função de hipótese em um ponto específico, isso nos dará acesso direto à linha tangente à curva naquele ponto. Isso significa que podemos calcular o atalho em cada ponto do gráfico.

A forma como o algoritmo funciona é esta:

1. Escolhemos um ponto de partida aleatoriamente ($ theta $ aleatoriamente).
2. Encontre a derivada da função de custo neste ponto.
3. Dê um pequeno passo em direção ao atalho $ theta_j: = theta_j - lambda * frac { partial} { partial theta_j} * J ( theta) $.
4. Repita as etapas 2-3 até a convergência.

Agora, a condição de convergência depende da implementação do algoritmo. Talvez paremos depois de 50 passos, depois de algum limiar baixo ou outra coisa.

import math # Ejemplo del algoritmo simple de descenso gradiente tomado de Wikipedia cur_x = 2.5 # The algorithm starts at point x gamma = 0.005 # Step size multiplier precision = 0.00001 previous_step_size = cur_x df = lambda x: 2 * x * math.cos(x) # Recuerda la curva de aprendizaje y establécela while previous_step_size > precision: prev_x = cur_x cur_x += -gamma * df(prev_x) previous_step_size = abs(cur_x - prev_x) print('The local minimum occurs at %f' % cur_x)

El mínimo local pasa en 4.712194

Não implementaremos esses algoritmos neste artigo. Em vez disso, usaremos o já adotado scikit-learn, uma biblioteca de aprendizado de máquina de software livre Python. Ele fornece muitas APIs úteis para diferentes problemas de mineração de dados e aprendizado de máquina.

De sklearn.linear_model importar LinearRegression # La Regresión Lineal usa el método de descenso gradiente # Nuestra data X = dataset[['Age']] y = dataset[['Pressure']] regr = LinearRegression() regr.fit(X, y) # Salidas Argumentadas plt.xlabel('Age') plt.ylabel('Blood pressure') plt.scatter(X, y, color='black') plt.plot(X, regr.predict(X), color='blue') plt.show() plt.gcf().clear()

print( 'Predicted blood pressure at 25 y.o. = ', regr.predict(25) ) print( 'Predicted blood pressure at 45 y.o. = ', regr.predict(45) ) print( 'Predicted blood pressure at 27 y.o. = ', regr.predict(27) ) print( 'Predicted blood pressure at 34.5 y.o. = ', regr.predict(34.5) ) print( 'Predicted blood pressure at 78 y.o. = ', regr.predict(78) ) Predicted blood pressure at 25 y.o. = [[ 122.98647692]] Predicted blood pressure at 45 y.o. = [[ 142.40388395]] Predicted blood pressure at 27 y.o. = [[ 124.92821763]] Predicted blood pressure at 34.5 y.o. = [[ 132.20974526]] Predicted blood pressure at 78 y.o. = [[ 174.44260555]]

Tipos de dados estatísticos

Ao trabalhar com problemas de aprendizado de máquina, é importante saber como reconhecer os diferentes tipos de dados. Podem ser dados numéricos (contínuos ou discretos), categóricos ou ordinais.

Dados numéricos eles têm significado como medida. Por exemplo: idade, peso, número de bitcoins de uma pessoa ou quantos artigos uma pessoa pode escrever por mês. Os dados numéricos também podem ser do tipo discreto ou contínuo.

• Os dados discretos representam os dados que podem ser contados com números inteiros, por exemplo, o número de quartos em um apartamento ou as vezes que uma moeda é girada.
• Os dados contínuos não são necessariamente representados com números inteiros. Por exemplo, se você está medindo a distância que você pode pular, pode ser 2 metros ou 1,5 metros, ou talvez 1,652245.

Dados categóricos representam valores como o sexo de uma pessoa, estado civil, país, etc. Esses dados podem ser de valor numérico, mas esses números não teriam valor matemático. Você não pode adicioná-los.

Dados ordinais pode ser uma mistura de outros tipos em que as categorias podem ser numeradas de maneira matematicamente significativa. Um exemplo comum são as classificações: muitas vezes somos solicitados a avaliar as coisas em uma escala de um a dez e, em tais casos, apenas números inteiros são permitidos. Embora possamos usar esses dados numericamente (por exemplo, para encontrar a classificação média de algo), geralmente lidamos com esses dados como categóricos ao aplicar métodos de aprendizado de máquina.

Regressão logística

A regressão linear é um algoritmo incrível que nos ajuda a prever valores numéricos como o preço de uma casa com um tamanho específico e determinados quartos. No entanto, às vezes podemos querer prever dados categóricos para obter respostas a perguntas como:

• É um cachorro ou um gato?
• Este tumor é maligno ou benigno?
• Este vinho é bom ou ruim?
• Este e-mail é spam ou não?

O incluso:

• Qual número está nesta foto?
• A qual categoria este e-mail pertence?

Todas essas questões são específicas para o problema de classificação . E o algoritmo de classificação mais simples é chamado Regressão logística , que eventualmente é igual à regressão linear Exceto que você tem uma hipótese diferente.

Em primeiro lugar, podemos reutilizar a mesma hipótese linear $ h_ theta (x) = theta ^ T X $ (isso está na forma vetorial). Embora a regressão linear possa produzir qualquer número nos intervalos $ [a, b] $, a regressão logística só pode obter valores em $ [- 1, 1] $, que se refere à probabilidade de que o objeto seja de uma categoria ou não.

problemas e soluções de segurança da web

Se usarmos um função sigmóide , podemos converter qualquer valor numérico para representar um valor no intervalo $ [- 1, 1] $.

[f (x) = frac {1} {1 + e ^ x} ]

Agora, em vez de $ x $, precisaríamos passar uma hipótese existente e obteríamos:

[f (x) = frac {1} {1 + e ^ { theta_0 + theta_1 * x_1 + ... + theta_n * x_n}} ]

Depois disso, podemos aplicar um limite simples que diz que, se a hipótese for maior que zero, será um valor verdadeiro, caso contrário, será falso.

[h_ theta (x) = begin {cases} 1 & mbox {if} theta ^ T X> 0 \ 0 & mbox {else} end {cases} ]

Isso significa que podemos usar o mesmo função de custo e o mesmo algoritmo de gradiente descendente para aprender uma hipótese de regressão logística.

No próximo exemplo de aprendizado de máquina, aconselharemos os pilotos do ônibus espacial se eles devem ou não controlar a aterrissagem manual ou automaticamente. Contamos com um conjunto de dados muito pequeno —15 amostras - consistindo em seis características e o verdade fundamental .

Em algoritmos de aprendizado de máquina, o termo “ verdade fundamental ”Refere-se à precisão da classificação dos conjuntos de treinamento para técnicas de aprendizagem supervisionada.

Nosso conjunto de dados está completo, o que significa que não há recursos ausentes; apesar disso, alguns recursos têm um '*' no lugar da categoria, o que significa que esse recurso não importa. Todos os asteriscos como este serão substituídos por zeros.

de sklearn.linear_model importar LogisticRegression # Data data_path = os.path.join(os.getcwd(), 'data/shuttle-landing-control.csv') dataset = read_csv(data_path, header=None, names=['Auto', 'Stability', 'Error', 'Sign', 'Wind', 'Magnitude', 'Visibility'], na_values='*').fillna(0) # Preparar características X = dataset[['Stability', 'Error', 'Sign', 'Wind', 'Magnitude', 'Visibility']] y = dataset[['Auto']].values.reshape(1, -1)[0] model = LogisticRegression() model.fit(X, y) # Por ahora nos falta un concepto importante. No sabemos qué tan bien funciona nuestro # modelo y debido a ello, en realidad no podemos mejorar el rendimiento de nuestra hipótesis. # Hay muchas métricas útiles pero por ahora, validaremos que tan bien # Actúa nuestro algoritmo en el set de datos, en el cual aprendió. 'La puntuación de nuestro modelo es %2.2f%%' % (model.score(X, y) * 100)

Puntuación de nuestro modelo es 73.33%

Validação?

No exemplo anterior, validamos o desempenho do nosso modelo usando os dados de aprendizagem. No entanto, é uma boa escolha, visto que nosso algoritmo pode ou não desconsiderar os dados? Vamos ver um exemplo mais simples onde temos uma característica que representa o tamanho de uma casa e outra que representa o preço.

de sklearn.pipeline importar make_pipeline de sklearn.preprocessing importer PolynomialFeatures de sklearn.linear_model importar LinearRegression de sklearn.model_selection importar cross_val_score # Función Verdad del terreno ground_truth = lambda X: np.cos(15 + np.pi * X) # Generar observaciones aleatorias alrededor de la función verdad del terreno n_samples = 15 degrees = [1, 4, 30] X = np.linspace(-1, 1, n_samples) y = ground_truth(X) + np.random.randn(n_samples) * 0.1 plt.figure(figsize=(14, 5)) models = {} # Trazar todos modelos del algoritmo de aprendizaje de máquina para idx, degree in enumerate(degrees): ax = plt.subplot(1, len(degrees), idx + 1) plt.setp(ax, xticks=(), yticks=()) # Definir el modelo polynomial_features = PolynomialFeatures(degree=degree) model = make_pipeline(polynomial_features, LinearRegression()) models[degree] = model # Entrenar el modelo model.fit(X[:, np.newaxis], y) # Evaluar el modelo usando validación cruzada scores = cross_val_score(model, X[:, np.newaxis], y) X_test = X plt.plot(X_test, model.predict(X_test[:, np.newaxis]), label='Model') plt.scatter(X, y, edgecolor='b', s=20, label='Observations') plt.xlabel('x') plt.ylabel('y') plt.ylim((-2, 2)) plt.title('Degree {} MSE = {:.2e}'.format( degree, -scores.mean())) plt.show()

O modelo de algoritmo de aprendizado de máquina é sobregeneralizado se você não pode generalizar nem os dados de treinamento, nem novas observações. No exemplo acima, usamos uma hipótese linear simples, que não representa os dados reais de treinamento e terá um desempenho muito fraco. Normalmente, a generalização excessiva não é discutida porque pode ser facilmente detectada com boas medições.

Se nosso algoritmo se lembrar de todas as observações que lhe foram mostradas, ele terá um desempenho inferior com as novas observações que estão fora do conjunto de dados de treinamento. Isso é chamado sobreajuste . Por exemplo, um modelo polinomial de trigésimo grau passa a maioria dos pontos e pontua bem no conjunto de treinamento, mas qualquer coisa diferente disso terá um desempenho insatisfatório.

Nosso conjunto de dados consiste em um recurso simples que pode ser plotado em 2D; mas na vida real, poderíamos ter conjuntos de dados com centenas de recursos, o que os torna impossíveis de plotar visualmente no espaço euclidiano. Que outras opções temos para ver se o modelo é supergeneralizado ou superdimensionado?

É hora de apresentá-lo ao conceito curva de aprendizagem . Este é um gráfico simples que representa o erro quadrático sobre o número de amostras de treinamento.

distribuição normal de simulação monte carlo

Nos materiais de aprendizagem, você encontrará gráficos semelhantes a estes:

Mas na vida real você pode não encontrar uma imagem tão perfeita. Vamos traçar a curva de aprendizado para cada um de nossos modelos.

from sklearn.model_selection import learning_curve, ShuffleSplit # Trazar curvas de aprendizaje plt.figure(figsize=(20, 5)) for idx, degree in enumerate(models): ax = plt.subplot(1, len(degrees), idx + 1) plt.title('Degree {}'.format(degree)) plt.grid() plt.xlabel('Training examples') plt.ylabel('Score') train_sizes = np.linspace(.6, 1.0, 6) # Validación cruzada con 100 iteraciones para obtener una prueba sencilla de *mean* y entrenamiento # curvas de puntuación cada vez con 20% de los datos seleccionados aleatoriamente como set de validación. cv = ShuffleSplit(n_splits=100, test_size=0.2, random_state=0) model = models[degree] train_sizes, train_scores, test_scores = learning_curve( model, X[:, np.newaxis], y, cv=cv, train_sizes=train_sizes, n_jobs=4) train_scores_mean = np.mean(train_scores, axis=1) test_scores_mean = np.mean(test_scores, axis=1) plt.plot(train_sizes, train_scores_mean, 'o-', color='r', label='Training score') plt.plot(train_sizes, test_scores_mean, 'o-', color='g', label='Test score') plt.legend(loc = 'best') plt.show()

Em nosso cenário simulado, a linha azul que representa a pontuação do treinamento parece uma linha reta. Na verdade, diminui um pouco - você pode ver no gráfico do polinômio de primeiro grau, mas nos outros é muito sutil de ver nesta resolução. Pelo menos podemos ver que há uma grande diferença entre as curvas de aprendizado do treinamento e as observações do teste com um cenário de 'alta inclinação'.

No gráfico de classificação de aprendizagem “normal” no meio, você pode ver como as linhas de pontuação de treinamento e teste se juntam.

E no gráfico de “alta variância” você pode ver que com um baixo número de amostras, as pontuações de teste e treinamento são muito semelhantes, porém, quando você aumenta o número de testes, a pontuação de treinamento permanece quase perfeita enquanto o teste está aumentando.

---

Podemos consertar modelos generalizados (também chamados de modelos com grande inclinação ) se usarmos uma hipótese não linear, por exemplo, a hipótese com mais características polinomiais.

Nosso modelo superequipado ( grande variação ) para cada exemplo mostrado a você; mas mesmo assim, quando os dados de teste são introduzidos, a diferença entre as curvas de aprendizado aumenta. Podemos usar regularização, validação cruzada e mais amostras de dados para corrigir modelos superaquecidos.

Validação cruzada

Uma das práticas comuns usadas para evitar overfitting é salvar alguns dos dados disponíveis e usá-los como um conjunto de teste. No entanto, quando diferentes configurações do modelo são avaliadas, como o número de características polinomiais, ainda há o risco de overfitting do conjunto de teste porque os parâmetros podem ser ligeiramente alterados para atingir um desempenho ideal do estimador e é por isso que nosso conhecimento no conjunto de teste pode vazar para o modelo. Para resolver esse problema, precisamos nos apropriar de outra parte do conjunto de dados, que é chamada de 'conjunto de validação'. O treinamento é feito no conjunto de treinamento e quando acreditamos que alcançamos o desempenho ideal do modelo, podemos fazer a avaliação usando o conjunto de validação.

No entanto, se particionarmos os três conjuntos de dados, o número de amostras que podem ser usadas para treinar os modelos será drasticamente reduzido e os resultados podem depender de uma escolha aleatória particular para o par de conjuntos de treinamento de validação.

Uma solução para esse problema é um procedimento chamado validação cruzada. Em uma validação cruzada de $ k $ -fold padrão, os dados são divididos em subconjuntos de $ k $ chamados dobras. O algoritmo é então treinado iterativamente com $ k-1 $ dobras, enquanto usa as dobras restantes como conjuntos de teste (chamados de ' pregas resistentes ”)

A validação cruzada permite que os parâmetros sejam graduados apenas com o conjunto de treinamento original. Isso permite que você mantenha seu conjunto de teste como um conjunto de dados invisível para escolher seu modelo final.

Existem muitas outras técnicas de validação cruzada, como deixe P de fora , estratificado $ k $ -fold , embaralhar e dividir etc. mas estão fora do escopo deste artigo.

Regularização

Esta é outra técnica que pode ajudá-lo a resolver o problema de overfitting do modelo. A maioria dos conjuntos de dados tem um padrão e algum ruído. O objetivo da regularização é reduzir a influência do ruído no modelo.

Existem três técnicas principais de regularização: Laço, Tikhonov e malha elástica.

Regularização L1 (ou Regularização Lasso ) é aquele que selecionará algumas características para minimizar a zero, de forma que estas nada tenham a ver com o modelo final. L1 pode ser visto como um método de seleção de características importantes.

** Regularização L2 ** (ou ** regularização Tikhonov **) é a que se encarregará de forçar todos características sejam relativamente pequenas, para que tenham menos influência no modelo.

Malha elástica é o combinação de L1 e L2.

Normalização (característica de escala)

O recurso de dimensionamento também é uma etapa importante enquanto os dados são pré-processados. Nosso conjunto de dados pode ter algumas características com valores $ [- infty, infty] $ e outras características com escalas diferentes. Este é um método que permite padronizar os intervalos de valores independentes.

llc s corp c corp

O recurso de dimensionamento é um processo importante para melhorar o desempenho dos modelos de aprendizagem. Em primeiro lugar, a descida do gradiente convergirá muito mais rápido se todos os recursos forem dimensionados para o mesmo padrão. Da mesma forma, muitos dos algoritmos - por exemplo: máquinas de vetores de suporte (SVM) - funcionam calculando a distância entre dois pontos e, se um dos recursos tiver valores grandes, a distância será muito influenciada por esse recurso.

Máquinas de vetor de suporte

SVM (por seu nome em inglês Máquinas de vetor de suporte ) é outro algoritmo de aprendizado de máquina popular que pode ser usado para problemas de classificação e regressão. No SVM cada observação é plotada como um ponto em um espaço $ n $ dimensional - onde $ n $ é o número de recursos que temos. O valor de cada recurso é o valor de coordenadas específicas. Em seguida, tentamos encontrar um hiperplano que separe muito bem duas classes.

Depois de identificar o melhor hiperplano, queremos adicionar margens que ajudariam a separar ainda mais as duas classes.

O SVM é muito eficaz quando o número de recursos é muito alto ou se o número de recursos é maior que o número de amostras de dados. Embora, como o SVM normalmente trabalha com vetores, é crucial normalizar os dados antes de usá-los.

Redes neurais

Os algoritmos de rede neural são provavelmente o ramo mais interessante dos estudos de aprendizado de máquina. As redes neurais tentam imitar a conexão dos neurônios no cérebro.

É assim que funciona uma rede neural. Combinamos muitos nós onde cada nó obtém um conjunto de resultados, faz alguns cálculos e, em seguida, fornece um valor.

Existe uma grande variedade de algoritmos de rede neural para aprendizagem supervisionada e não supervisionada. As redes neurais podem ser usadas para dirigir carros autônomos, jogar videogames, aviões terrestres, classificar imagens e muito mais.

The Infamous Titanic

O RMS Titanic foi um navio britânico que naufragou no Oceano Atlântico Norte em 15 de abril de 1912 após colidir com um iceberg. Cerca de 2.224 passageiros e tripulantes tinham a bordo, mais de 1.500 dos quais morreram, tornando-se um dos desastres marítimos comerciais mais mortíferos dos últimos tempos.

Agora que entendemos a intuição de um dos algoritmos de aprendizado de máquina mais básicos usados ​​para classificação de problemas, podemos aplicar nosso conhecimento para prever a taxa de sobrevivência das pessoas a bordo do Titanic.

Nosso conjunto de dados virá do Plataforma de dados científicos de competitividade da Kaggle .

import os from pandas import read_csv, concat # Cargar datos data_path = os.path.join(os.getcwd(), 'data/titanic.csv') dataset = read_csv(data_path, skipinitialspace=True) dataset.head(5)

	PassengerId	Sobreviveu	Pclass	Nome	Sexo	Era	SibSp	respeito	Bilhete	Façam	Cabine	Embarcou
0	1	0	3	Braund, Sr. Owen Harris	masculino	22,0	1	0	A / 5 21171	7,2500	NaN	S
1	2	1	1	Cumings, Sra. John Bradley (Florence Briggs Th ...	Feminino	38,0	1	0	PC 17599	71,2833	C85	C
2	3	1	3	Heikkinen, senhorita. Um emprestimo	Feminino	26,0	0	0	STON / O2. 3101282	7,9250	NaN	S
3	4	1	1	Futrelle, Sra. Jacques Heath (Lily May Peel)	Feminino	35,0	1	0	113803	53,1000	C123	S
4	5	0	3	Allen, Sr. William Henry	masculino	35,0	0	0	373450	8.0500	NaN	S

Nossa primeira etapa será carregar e explorar os dados. Temos 891 registros de teste; cada registro tem a seguinte estrutura:

• passageirosId - ID do passageiro a bordo
• sobrevivência - se a pessoa sobreviveu ou não ao acidente
• pclase - Tipo de tíquete, por exemplo, 1º, 2º, 3º
• gênero - gênero do passageiro: masculino ou feminino
• nome - título incluído
• idade - idade em anos
• sibsp - Número de parentes / cônjuges a bordo do Titanic
• parch - Número de pais / filhos a bordo do Titanic
• bilhete - número do bilhete
• tarifa - custo da passagem
• cabine - número da cabine
• embarcado - Porto do navio

Este conjunto de dados contém informações numéricas e categóricas. Normalmente, é uma boa ideia se aprofundar nos dados que você possui e, com base neles, criar suposições. No entanto, neste caso, vamos pular esta etapa e ir direto para as previsões.

import pandas as pd # Necesitamos eliminar algunas características insignificantes y mapear el resto. # Número y costo del boleto no deberían contribuir en el rendimiento de nuestro modelo. # Característica de nombres viene con títulos (como: Sr. Srta. Doctor) incluidos. # El género es muy importante. # El Puerto de embarcación podría ser atribuir algún valor. # Usar el Puerto de embarcación podría ser contra-intuitivo pero podría # existir una tasa de supervivencia más alta para pasajeros que abordaron en el mismo Puerto. dataset['Title'] = dataset.Name.str.extract(' ([A-Za-z]+).', expand=False) dataset = dataset.drop(['PassengerId', 'Ticket', 'Cabin', 'Name'], axis=1) pd.crosstab(dataset['Title'], dataset['Sex'])

Título Sexo	Feminino	masculino
Capitão	0	1
Com o	0	2
Condessa	1	0
Don	0	1
Dr	1	6
Jonkheer	0	1
Senhora	1	0
Principal	0	2
mestre	0	40
Senhorita	182	0
Em	2	0
Sra	1	0
Senhor	0	517
Sra	125	0
Em	1	0
Rev	0	6
Senhor	0	1

# Reemplazaremos muchos títulos con un nombre más común, equivalente Inglés, # o re-clasificación dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col', 'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Other') dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss') dataset['Title'] = dataset['Title'].replace('Ms', 'Miss') dataset['Title'] = dataset['Title'].replace('Mme', 'Mrs') dataset[['Title', 'Survived']].groupby(['Title'], as_index=False).mean()

	Título	Sobreviveu
0	mestre	0,575000
1	Senhorita	0,702703
2	Senhor	0,156673
3	Sra	0,793651
4	De outros	0,347826

# Ahora mapearemos categorias alfanumericas a números title_mapping = { 'Mr': 1, 'Miss': 2, 'Mrs': 3, 'Master': 4, 'Other': 5 } gender_mapping = { 'female': 1, 'male': 0 } port_mapping = { 'S': 0, 'C': 1, 'Q': 2 } # Mapa de título dataset['Title'] = dataset['Title'].map(title_mapping).astype(int) # Mapa de género dataset['Sex'] = dataset['Sex'].map(gender_mapping).astype(int) # Mapa de puerto freq_port = dataset.Embarked.dropna().mode()[0] dataset['Embarked'] = dataset['Embarked'].fillna(freq_port) dataset['Embarked'] = dataset['Embarked'].map(port_mapping).astype(int) # Arreglar errores de edades que falten dataset['Age'] = dataset['Age'].fillna(dataset['Age'].dropna().median()) dataset.head()

	Sobreviveu	Pclass	Sexo	Era	SibSp	respeito	Façam	Embarcou	Título
0	0	3	0	22,0	1	0	7,2500	0	1
1	1	1	1	38,0	1	0	71,2833	1	3
2	1	3	1	26,0	0	0	7,9250	0	2
3	1	1	1	35,0	1	0	53,1000	0	3
4	0	3	0	35,0	0	0	8.0500	0	1

Neste ponto, classificaremos diferentes tipos de algoritmos de aprendizado de máquina em Python usando scikit-learn para criar um conjunto diferente de modelos. Será fácil ver qual tem melhor desempenho.

• Regressão Logística com Polinômios de Número Variante
• Máquina de vetor de suporte com um kernel linear
• Máquina de vetor de suporte com um kernel polinomial
• Neuronal vermelho

Para cada um dos modelos, usaremos a validação $ k $ -fold.

de sklearn.model_selection importar KFold, train_test_split de sklearn.pipeline importar make_pipeline de sklearn.preprocessing importar PolynomialFeatures, StandardScaler de sklearn.neural_network importar MLPClassifier de sklearn.svm importar SVC # Preparar data X = dataset.drop(['Survived'], axis = 1).values y = dataset[['Survived']].values X = StandardScaler().fit_transform(X) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state = None) # Prepare cross-validation (cv) cv = KFold(n_splits = 5, random_state = None) # Rendimiento p_score = lambda model, score: print('Performance of the %s model is %0.2f%%' % (model, score * 100)) # Clasificadores names = [ 'Logistic Regression', 'Logistic Regression with Polynomial Hypotheses', 'Linear SVM', 'RBF SVM', 'Neural Net', ] classifiers = [ LogisticRegression(), make_pipeline(PolynomialFeatures(3), LogisticRegression()), SVC(kernel='linear', C=0.025), SVC(gamma=2, C=1), MLPClassifier(alpha=1), ] # iterate over classifiers models = [] trained_classifiers = [] for name, clf in zip(names, classifiers): scores = [] for train_indices, test_indices in cv.split(X): clf.fit(X[train_indices], y[train_indices].ravel()) scores.append( clf.score(X_test, y_test.ravel()) ) min_score = min(scores) max_score = max(scores) avg_score = sum(scores) / len(scores) trained_classifiers.append(clf) models.append((name, min_score, max_score, avg_score)) fin_models = pd.DataFrame(models, columns = ['Name', 'Min Score', 'Max Score', 'Mean Score']) fin_models.sort_values(['Mean Score']).head()

	Nome	Minha pontuação	Pontuação máxima	Pontuação média
2	Linear SVM	0,793296	0,821229	0,803352
0	Regressão Logística	0,826816	0,860335	0,846927
4	Rede Neural	0,826816	0,860335	0,849162
1	Regressão Logística com Hipóteses Polinomiais	0,854749	0,882682	0,869274
3	RBF SVM	0,843575	0,888268	0,869274

Bem, nossa pesquisa experimental nos diz que o classificador SVM tem o melhor desempenho com um kernel de função básica radial (RBF). Agora podemos serializar nosso modelo e reutilizá-lo em aplicativos de produção.

import pickle svm_model = trained_classifiers[3] data_path = os.path.join(os.getcwd(), 'best-titanic-model.pkl') pickle.dump(svm_model, open(data_path, 'wb'))

O aprendizado de máquina não é complicado, mas é um campo de estudo muito amplo, e requer conhecimentos no campo da matemática e estatística para compreender todos os seus conceitos.

No momento, o aprendizado de máquina e o aprendizado profundo estão entre os tópicos de discussão mais procurados do Vale do Silício, principalmente porque podem automatizar muitas tarefas repetidas, como reconhecimento de voz, dirigir carros, transações financeiras, assistência ao paciente , cozinhar , marketing , entre muitos outros.

Agora, com esse conhecimento, você pode resolver desafios no Kaggle.

Esta foi uma breve introdução ao algoritmo de aprendizado de máquina supervisionado. Felizmente, existem muitos cursos online e informações sobre algoritmos de aprendizado de máquina. Eu pessoalmente recomendo começar com o curso de Andrew Ng no Coursera.

Fontes

• Curso de Andrew Ng no Coursera
• Conjuntos de dados Kaggle
• Lista de leitura sobre aprendizagem profunda
• Lista de livros gratuitos sobre algoritmos de aprendizado de máquina, mineração de dados, aprendizado profundo e tópicos relacionados
• Uma introdução à teoria do aprendizado de máquina e suas aplicações: um tutorial visual com exemplos