Machine learning - trainen/testen
Evalueer uw model
In Machine Learning maken we modellen om de uitkomst van bepaalde gebeurtenissen te voorspellen, zoals in het vorige hoofdstuk waar we de CO2-uitstoot van een auto voorspelden toen we het gewicht en de motorinhoud kenden.
Om te meten of het model goed genoeg is, kunnen we de methode Train/Test gebruiken.
Wat is trein/test?
Train/Test is een methode om de nauwkeurigheid van uw model te meten.
Het wordt Train/Test genoemd omdat je de dataset in twee sets splitst: een trainingsset en een testset.
80% voor training en 20% voor testen.
Je traint het model met behulp van de trainingsset.
Je test het model met behulp van de testset.
Train het model betekent het model maken .
Test het model betekent test de nauwkeurigheid van het model.
Begin met een dataset
Begin met een dataset die u wilt testen.
Onze dataset illustreert 100 klanten in een winkel en hun winkelgewoonten.
Voorbeeld
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()
Resultaat:
De x-as vertegenwoordigt het aantal minuten voordat een aankoop wordt gedaan.
De y-as geeft het bedrag weer dat aan de aankoop is uitgegeven.
Opsplitsen in trein/test
De trainingsset moet een willekeurige selectie zijn van 80% van de oorspronkelijke gegevens.
De testset moet de resterende 20% zijn.
train_x = x[:80]
train_y = y[:80]
test_x = x[80:]
test_y = y[80:]
Geef de trainingsset weer
Geef hetzelfde spreidingsplot weer met de trainingsset:
Voorbeeld
plt.scatter(train_x,
train_y)
plt.show()
Resultaat:
Het lijkt op de originele dataset, dus het lijkt een eerlijke selectie:
Toon de testset
Om er zeker van te zijn dat de testset niet helemaal anders is, nemen we ook de testset onder de loep.
Voorbeeld
plt.scatter(test_x,
test_y)
plt.show()
Resultaat:
De testset ziet er ook uit als de originele dataset:
Pas de gegevensset aan
Hoe ziet de dataset eruit? Naar mijn mening denk ik dat de beste pasvorm een polynomiale regressie zou zijn , dus laten we een lijn van polynomiale regressie trekken.
Om een lijn door de datapunten te trekken, gebruiken we de
plot()methode van de matplotlib-module:
Voorbeeld
Teken een polynomiale regressielijn door de gegevenspunten:
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()
Resultaat:
Het resultaat kan mijn suggestie ondersteunen dat de dataset past bij een polynomiale regressie, ook al zou het ons rare resultaten geven als we proberen waarden buiten de dataset te voorspellen. Voorbeeld: de lijn geeft aan dat een klant die 6 minuten in de winkel doorbrengt, een aankoop zou doen ter waarde van 200. Dat is waarschijnlijk een teken van overfitting.
Maar hoe zit het met de R-kwadraatscore? De R-kwadraatscore is een goede indicator van hoe goed mijn dataset bij het model past.
R2
Herinner je je R2, ook wel R-kwadraat genoemd?
Het meet de relatie tussen de x-as en de y-as, en de waarde varieert van 0 tot 1, waarbij 0 geen relatie betekent en 1 volledig gerelateerd is.
De sklearn-module heeft een methode genaamd r2_score()
die ons zal helpen deze relatie te vinden.
In dit geval willen we de relatie meten tussen het aantal minuten dat een klant in de winkel blijft en hoeveel geld hij uitgeeft.
Voorbeeld
Hoe goed passen mijn trainingsgegevens in een polynomiale regressie?
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)
Opmerking: het resultaat 0.799 laat zien dat er een OK-relatie is.
Breng de testset binnen
Nu hebben we een model gemaakt dat OK is, tenminste als het gaat om trainingsgegevens.
Nu willen we het model ook testen met de testgegevens, om te zien of dit hetzelfde resultaat geeft.
Voorbeeld
Laten we de R2-score vinden bij het gebruik van testgegevens:
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)
Opmerking: het resultaat 0,809 laat zien dat het model ook in de testset past en we zijn ervan overtuigd dat we het model kunnen gebruiken om toekomstige waarden te voorspellen.
Waarden voorspellen
Nu we hebben vastgesteld dat ons model in orde is, kunnen we nieuwe waarden gaan voorspellen.
Voorbeeld
Hoeveel geld is een kopende klant kwijt als hij of zij 5 minuten in de winkel blijft?
print(mymodel(5))
Het voorbeeld voorspelde dat de klant 22,88 dollar zou uitgeven, zoals lijkt te corresponderen met het diagram:
