Kihagyás

12. gyakorlat

Warning

Figyelem! A héten kiadásra kerül egy újabb beadandó!

Warning

Figyelem! Jövő héten ZH!

A gyakorlat anyaga

A gyakorlaton gépi tanulási módszerekkel fogunk foglalkozni, a teljesség igénye nélkül néhány alappéldát nézünk meg. További magyarázattal a Mesterséges intelligencia és Gépi tanulási módszerek kurzusok fognak szolgálni.

Az órán megnézünk egy egyszerű döntési fát, amivel megismerkedünk az alapabb dolgokkal, majd pedig nézünk egy TensorFlow-beli neuronhálót ruhák felismerésére.

Néhány link, ami segíthet a témakör elmélyítésében: Mesterséges intelligencia tananyag: https://www.inf.u-szeged.hu/~jelasity/mi1/2020/index.html Döntési fa: https://hu.wikipedia.org/wiki/D%C3%B6nt%C3%A9si_fa, http://www.inf.u-szeged.hu/~rfarkas/ML20/dontesi_fa.html http://www.inf.u-szeged.hu/~rfarkas/ML20/index.html http://www.inf.u-szeged.hu/~rfarkas/ML17/gepitanulas.html https://www.analyticsvidhya.com/blog/2020/01/fundamentals-deep-learning-activation-functions-when-to-use-them/

Az órán a scikit-learn csomagot, valamint a TensorFlow csomagot fogjuk használni.

A telepítéshez a pip install scikit-learn, valamint a pip install tensorflow parancsokat lehet használni, illetve, ha valaki a Python infrastruktúrának Anacondat használ, akkor neki nyert ügye van.

A model perzisztálásához a joblib modult használjuk (ezt meg lehetne oldani pickles-zel is például). A joblib könnyedén telepíthető a pip install joblib paranccsal.

Alapok

Nagyon egyszerű adathalmazzal dolgozunk, zenei ízlés meghatározására szolgál.

age gender genre
20 1 HipHop
23 1 HipHop
25 1 HipHop
26 1 Jazz
29 1 Jazz
30 1 Jazz
31 1 Classical
33 1 Classical
37 1 Classical
20 0 Dance
21 0 Dance
25 0 Dance
26 0 Acoustic
27 0 Acoustic
30 0 Acoustic
31 0 Classical
34 0 Classical
35 0 Classical
  • Először is, be kell olvasni (múlt óra, pandas)
  • A beolvasott táblázatot szét kellene szedni, hogy milyen jellemzők állnak rendelkezésre, és mi az, amit szeretnénk majd prediktálni.
  • Létre kell hoznunk egy modellt, ami jelen esetben egy egyszerű döntési fa lesz.
  • Be kell tanítani az osztályozót.
  • Prediktálhatunk is.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import os

import pandas as pd
from sklearn.tree import DecisionTreeClassifier

music_df = pd.read_csv(os.path.join("data", "music.csv"))

# print(music_df)

# Adatok szétszedése input és output halmazokra (mit akarunk prediktálni)
X = music_df.drop(columns="genre")
y = music_df["genre"]

# print(X)
# print(y)

model = DecisionTreeClassifier()
model.fit(X, y)

predictions = model.predict([[21, 1], [20, 2], [60, 1], [60, 2]])
print(predictions)

kor = input("Hány éves emberre vagy kíváncsi?\n")
nem = input("Az ember neme (0 - nő, 1 - férfi)?\n")

predictions = model.predict([[kor, nem]])

Nyilván nem a legjobb ötlet minden adatot oda dobni tanításra, mert akkor nem lesz mivel kiértékelni a modelt. Így fel kéne osztani az adatokat, erre is van könnyed megoldás az sklearnből. Illetve, ha már ki tudjuk értékelni valahogy a modelt, akkor jó volna hozzá valamiféle mérőszám is, erre is biztosít függvényt az sklearn.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
import os

import pandas as pd
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split  # !!
from sklearn.tree import DecisionTreeClassifier

music_df = pd.read_csv(os.path.join("data", "music.csv"))

X = music_df.drop(columns="genre")
y = music_df["genre"]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

model = DecisionTreeClassifier()
model.fit(X_train, y_train)

predictions = model.predict(X_test)
# print(predictions)

resulting_score = accuracy_score(y_test, predictions)
print("A model pontossága", resulting_score)

Ez így már egész tűrhető, azonban nem akarjuk minden egyes alkalommal betanítani a modelt, hanem csak alkalmadtál elő szeretnénk kapni a "fiókból", és prediktálni vele.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import os

import joblib
import pandas as pd
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split  # !!
from sklearn.tree import DecisionTreeClassifier

music_df = pd.read_csv(os.path.join("data", "music.csv"))

X = music_df.drop(columns="genre")
y = music_df["genre"]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

model = DecisionTreeClassifier()
model.fit(X_train, y_train)

# Mentés
joblib.dump(model, "model.joblib")

del model
model2 = joblib.load("model.joblib")
predictions = model2.predict(X_test)
# print(predictions)

resulting_score = accuracy_score(y_test, predictions)
print("A model pontossága", resulting_score)

Modell kiértékelése keresztvalidációval:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
import os

import pandas as pd
from sklearn.model_selection import train_test_split  # !!
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score

music_df = pd.read_csv(os.path.join("data", "music.csv"))

X = music_df.drop(columns="genre")
y = music_df["genre"]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

model = DecisionTreeClassifier()
# model.fit(X_train, y_train)
# score = model.score(X_test, y_test)
# print(score)

scores = cross_val_score(model, X_train, y_train, cv=4)
print(scores)
print(f"Accuracy: {scores.mean()}")

Vizualizálás döntési fák esetében

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import os

import pandas as pd
from sklearn import tree
from sklearn.model_selection import train_test_split  # !!
from sklearn.tree import DecisionTreeClassifier

music_df = pd.read_csv(os.path.join("data", "music.csv"))

X = music_df.drop(columns="genre")
y = music_df["genre"]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

model = DecisionTreeClassifier()
model.fit(X_train, y_train)

tree.export_graphviz(model, out_file="alma.dot",
                     feature_names=["Kor", "Nem"],
                     class_names=sorted(y.unique()),
                     label="all",
                     rounded=True,
                     filled=True)

TensorFlow

  • 64 bites Python (újabb változat, újabb pippel)
  • GPU-hoz CUDA Toolkit
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import matplotlib.pyplot as plt
import numpy as np
import tensorflow.keras as keras

# https://www.tensorflow.org/tutorials/keras/classification

data = keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = data.load_data()
# X_train, y_train, X_test, y_test

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
print(train_images[10])

plt.imshow(train_images[10], cmap=plt.cm.binary)

plt.show()

# 0-1 közé kerüljön (numpy tömb)
train_images = train_images / 255.0
test_images = test_images / 255.0
# print(train_images[10])

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(units=128, activation="relu"),  # teljesen összekötött
    keras.layers.Dense(units=10, activation="softmax")  # összegük 1
])

model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])

# epoch == hányszor lásson egy képet
model.fit(train_images, train_labels, epochs=2)

test_loss, test_accuracy = model.evaluate(test_images, test_labels)
print("test accuracy", test_accuracy)

prediction = model.predict(test_images)
print("prediction", prediction[0])
print("argmax", np.argmax(prediction[0]))
print(class_names[np.argmax(prediction[0])])

for i in range(5):
    plt.grid(False)
    plt.imshow(test_images[i], cmap=plt.cm.binary)
    plt.xlabel(f"Actual: {class_names[test_labels[i]]}")
    plt.title(f"Prediction: {class_names[np.argmax(prediction[i])]}")
    # plt.show()

for i in range(len(prediction)):
    if test_labels[i] != np.argmax(prediction[i]):
        plt.grid(False)
        plt.imshow(test_images[i], cmap=plt.cm.binary)
        plt.xlabel(f"Actual: {class_names[test_labels[i]]}")
        plt.title(f"Prediction: {class_names[np.argmax(prediction[i])]}")
        plt.show()

Itt is lehetőségünk van a modelt elmenteni:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import matplotlib.pyplot as plt
import numpy as np
import tensorflow.keras as keras

# https://www.tensorflow.org/tutorials/keras/classification

data = keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = data.load_data()

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

# 0-1 közé kerüljön (numpy tömb)
train_images = train_images / 255.0
test_images = test_images / 255.0
# print(train_images[10])

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(units=128, activation="relu"),  # teljesen összekötött
    keras.layers.Dense(units=10, activation="softmax")  # összegük 1
])

model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])

model.fit(train_images, train_labels, epochs=2)

model.save("fashion_mnist_model")

del model

model2 = keras.models.load_model("fashion_mnist_model")

prediction = model2.predict(test_images)

for i in range(5):
    print(f"Actual: {class_names[test_labels[i]]}, Prediction: {class_names[np.argmax(prediction[i])]}")

Markov-láncok

Ehhez a markovify modult fogjuk használni, ami a pip install markovify paranccsal telepíthető.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import markovify


def main():
    with open("data/ts1.txt", "r") as fp:
        lyrics = fp.read()
    text_model = markovify.Text(lyrics)
    text_model = text_model.compile(True)
    for i in range(5):
        # print(text_model.make_sentence())
        print(text_model.make_short_sentence(100, 20))


if __name__ == '__main__':
    main()

Feladatok

  1. Szkript készítése, ami az azlyrics.com oldalról leszedi a kedvenc előadód összes dalszövegét.
  2. Egy másik TensorFlow tutorial elkészítése, esetleg saját, gyűjtött adatokon valamilyen modell összeállítása.

Utolsó frissítés: 2021-05-31 12:08:34