Aprendizado de Máquina - Treinar/Testar
Avalie seu modelo
Em Machine Learning criamos modelos para prever o resultado de determinados eventos, como no capítulo anterior onde previmos a emissão de CO2 de um carro quando sabíamos o peso e o tamanho do motor.
Para medir se o modelo é bom o suficiente, podemos usar um método chamado Train/Test.
O que é Treinar/Teste
Train/Test é um método para medir a precisão do seu modelo.
Ele é chamado de Treinar/Teste porque você divide o conjunto de dados em dois conjuntos: um conjunto de treinamento e um conjunto de teste.
80% para treinamento e 20% para teste.
Você treina o modelo usando o conjunto de treinamento.
Você testa o modelo usando o conjunto de testes.
Treinar o modelo significa criar o modelo.
Testar o modelo significa testar a precisão do modelo.
Comece com um conjunto de dados
Comece com um conjunto de dados que você deseja testar.
Nosso conjunto de dados ilustra 100 clientes em uma loja e seus hábitos de compra.
Exemplo
import numpy
import matplotlib.pyplot as plt
numpy.random.seed(2)
x = numpy.random.normal(3, 1, 100)
y = numpy.random.normal(150, 40,
100) / x
plt.scatter(x, y)
plt.show()
Resultado:
O eixo x representa o número de minutos antes de fazer uma compra.
O eixo y representa a quantidade de dinheiro gasto na compra.
Dividir em Trem/Teste
O conjunto de treinamento deve ser uma seleção aleatória de 80% dos dados originais.
O conjunto de teste deve ser os 20% restantes.
train_x = x[:80]
train_y = y[:80]
test_x = x[80:]
test_y = y[80:]
Exibir o conjunto de treinamento
Exiba o mesmo gráfico de dispersão com o conjunto de treinamento:
Exemplo
plt.scatter(train_x,
train_y)
plt.show()
Resultado:
Parece o conjunto de dados original, então parece ser uma seleção justa:
Exibir o conjunto de testes
Para garantir que o conjunto de testes não seja completamente diferente, também daremos uma olhada no conjunto de testes.
Exemplo
plt.scatter(test_x,
test_y)
plt.show()
Resultado:
O conjunto de teste também se parece com o conjunto de dados original:
Ajustar o conjunto de dados
Como é o conjunto de dados? Na minha opinião, acho que o melhor ajuste seria uma regressão polinomial , então vamos desenhar uma linha de regressão polinomial.
Para desenhar uma linha através dos pontos de dados, usamos o
plot()método do módulo matplotlib:
Exemplo
Desenhe uma linha de regressão polinomial através dos pontos de dados:
import numpy
import
matplotlib.pyplot as plt
numpy.random.seed(2)
x =
numpy.random.normal(3, 1, 100)
y = numpy.random.normal(150, 40, 100) / x
train_x = x[:80]
train_y = y[:80]
test_x = x[80:]
test_y =
y[80:]
mymodel = numpy.poly1d(numpy.polyfit(train_x, train_y, 4))
myline = numpy.linspace(0, 6, 100)
plt.scatter(train_x, train_y)
plt.plot(myline, mymodel(myline))
plt.show()
Resultado:
O resultado pode apoiar minha sugestão de que o conjunto de dados se encaixa em uma regressão polinomial, mesmo que isso nos dê alguns resultados estranhos se tentarmos prever valores fora do conjunto de dados. Exemplo: a linha indica que um cliente que passasse 6 minutos na loja faria uma compra no valor de 200. Isso provavelmente é um sinal de overfitting.
Mas e a pontuação R-quadrado? A pontuação R-quadrado é um bom indicador de quão bem meu conjunto de dados está se ajustando ao modelo.
R2
Lembre-se de R2, também conhecido como R-quadrado?
Ele mede a relação entre o eixo x e o eixo y, e o valor varia de 0 a 1, onde 0 significa nenhum relacionamento e 1 significa totalmente relacionado.
O módulo sklearn possui um método chamado r2_score()
que nos ajudará a encontrar essa relação.
Neste caso, gostaríamos de medir a relação entre os minutos que um cliente permanece na loja e quanto dinheiro ele gasta.
Exemplo
Quão bem meus dados de treinamento se encaixam em uma regressão polinomial?
import numpy
from sklearn.metrics import r2_score
numpy.random.seed(2)
x = numpy.random.normal(3, 1, 100)
y = numpy.random.normal(150, 40,
100) / x
train_x = x[:80]
train_y = y[:80]
test_x = x[80:]
test_y = y[80:]
mymodel = numpy.poly1d(numpy.polyfit(train_x, train_y,
4))
r2 = r2_score(train_y, mymodel(train_x))
print(r2)
Nota: O resultado 0,799 mostra que existe uma relação OK.
Traga o conjunto de testes
Agora criamos um modelo que está OK, pelo menos quando se trata de dados de treinamento.
Agora queremos testar o modelo com os dados de teste também, para ver se nos dá o mesmo resultado.
Exemplo
Vamos encontrar a pontuação R2 ao usar dados de teste:
import numpy
from sklearn.metrics import r2_score
numpy.random.seed(2)
x = numpy.random.normal(3, 1, 100)
y = numpy.random.normal(150, 40,
100) / x
train_x = x[:80]
train_y = y[:80]
test_x = x[80:]
test_y = y[80:]
mymodel = numpy.poly1d(numpy.polyfit(train_x, train_y,
4))
r2 = r2_score(test_y, mymodel(test_x))
print(r2)
Nota: O resultado 0,809 mostra que o modelo também se ajusta ao conjunto de testes e estamos confiantes de que podemos usar o modelo para prever valores futuros.
Prever valores
Agora que estabelecemos que nosso modelo está OK, podemos começar a prever novos valores.
Exemplo
Quanto dinheiro um cliente comprador gastará se ficar na loja por 5 minutos?
print(mymodel(5))
O exemplo previu que o cliente gastaria 22,88 dólares, como parece corresponder ao diagrama:
