Poglobljeno učenje je tehnologija, ki je postala bistveni del delovnih procesov strojnega učenja. Izkoriščanje izboljšav vzporednih računalniških moči in podpornih orodij postaja vse bolj zapleteno in globoko nevronsko omrežje, ki je bilo nekoč nepraktično.
Pojav močnih in dostopnih knjižnic, kot je Tensorflow , Bakla , in Poglobitev4j je odprl tudi razvoj za uporabnike zunaj akademskega sveta in raziskovalnih oddelkov velikih tehnoloških podjetij. Kot dokaz naraščajoče razširjenosti podjetja, kot sta Huawei in Apple, zdaj v svoje najnovejše naprave vključujejo namenske procesorje, optimizirane za globoko učenje, ki poganjajo aplikacije za poglobljeno učenje.
Poglobljeno učenje je dokazalo svojo moč na številnih področjih. Predvsem Googlova AlphaGo je uspel premagati človeške igralce v igri Go, igri, katere osupljiva zapletenost je nekoč veljala za skoraj nepremagljivo oviro za računalnike v konkurenci proti človeškim igralcem. Projekt Flow Machines Sony je razvil nevronsko mrežo, ki lahko sestavlja glasbo v slogu znanih glasbenikov preteklosti. FaceID , varnostna funkcija, ki jo je razvil Apple, uporablja globoko učenje za prepoznavanje obraza uporabnika in za sledenje spremembam uporabnikovega obraza skozi čas.
V tem članku bomo globoko učenje uporabili za dve moji najljubši temi: obdelava naravnega jezika in vino. Zgradili bomo model za razumevanje pregledov vin v naravnem jeziku s strani strokovnjakov in ugotavljali sorto vina, ki ga ocenjujejo.
Globoko učenje je bilo v veliki meri uporabljeno v obdelava naravnega jezika (NLP), ker je zelo primeren za učenje kompleksne temeljne strukture stavka in pomenske bližine različnih besed. Na primer, trenutno stanje tehnike za analizo sentimenta uporablja globoko učenje, da zajame težko oblikovane jezikovne koncepte, kot so negacije in mešana čustva.
Poglobljeno učenje ima več prednosti pred drugimi algoritmi za NLP:
Danes bomo zgradili algoritem za poglobljeno učenje, s katerim bomo na podlagi preglednega besedila določili sorto vina, ki se pregleduje. Podatke o vinski reviji bomo uporabili na naslovu https://www.kaggle.com/zynicide/wine-reviews ki jo zagotavlja uporabnik Kaggle zackthoutt .
Konceptualno je vprašanje, ali lahko vzamemo pregled vina, kot je…
Arome vključujejo tropsko sadje, metlo, žveplo in posušeno zelišče. Okus ni preveč izrazit, poleg živahne kislosti ponuja nezrela jabolka, citruse in posušen žajbelj.
... in prepoznali, da gre za belo mešanico? Nekateri vinski navdušenci morda prepoznajo opozorilne znake belih vin, kot so jabolka, citrusi in izrazita kislost, vendar ali lahko svojo nevronsko mrežo usposobimo za prepoznavanje teh signalov? Ali lahko svojo nevronsko mrežo usposobimo za prepoznavanje prefinjenih razlik med pregledom bele mešanice in pregledom pinota grigio?
Problem, s katerim danes delamo, je v bistvu problem klasifikacije NLP. Obstaja več algoritmov za klasifikacijo NLP, ki so bili uporabljeni za različne probleme v NLP. Na primer, naivni Bayes - so bili uporabljeni v različnih algoritmih za odkrivanje neželene pošte in podpirajo vektorske stroje (SVM) so bili uporabljeni za razvrščanje besedil, kot so poročila o napredku v zdravstvenih ustanovah. Zanimivo bi bilo uvesti preprosto različico teh algoritmov, ki bi služila kot osnova za naš model globokega učenja.
Priljubljena izvedba naivnih Bayesov za NLP vključuje predhodno obdelavo besedila z uporabo TF-IDF in nato izvajanje večnomskih naivnih Bayesov na vnaprej obdelanih izhodih. To omogoča izvajanje algoritma na najvidnejših besedah v dokumentu. Naivne Bayes lahko izvedemo na naslednji način:
import numpy as np from sklearn.naive_bayes import MultinomialNB from sklearn.feature_extraction.text import CountVectorizer import pandas as pd from collections import Counter from sklearn.model_selection import train_test_split from sklearn.feature_extraction.text import TfidfTransformer df = pd.read_csv('data/wine_data.csv') counter = Counter(df['variety'].tolist()) top_10_varieties = {i[0]: idx for idx, i in enumerate(counter.most_common(10))} df = df[df['variety'].map(lambda x: x in top_10_varieties)] description_list = df['description'].tolist() varietal_list = [top_10_varieties[i] for i in df['variety'].tolist()] varietal_list = np.array(varietal_list) count_vect = CountVectorizer() x_train_counts = count_vect.fit_transform(description_list) tfidf_transformer = TfidfTransformer() x_train_tfidf = tfidf_transformer.fit_transform(x_train_counts) train_x, test_x, train_y, test_y = train_test_split(x_train_tfidf, varietal_list, test_size=0.3) clf = MultinomialNB().fit(train_x, train_y) y_score = clf.predict(test_x) n_right = 0 for i in range(len(y_score)): if y_score[i] == test_y[i]: n_right += 1 print('Accuracy: %.2f%%' % ((n_right/float(len(test_y)) * 100))) Zaženite zgornjo kodo in videli bi nekaj takega: 73,56%
Glede na to, da si ogledujemo 10 razredov, je to kar dober rezultat.
Lahko uporabimo tudi podporni vektorski stroj in preverimo, kako bi to naredil. Če želite videti, kako deluje, preprosto zamenjajte definicijo klasifikatorja z
clf = SVC(kernel='linear').fit(train_x, train_y) Zaženite to in videli bi naslednji izhod:
Natančnost: 80,66%
Tudi ne preveč umazano.
Poglejmo, ali lahko zgradimo model globokega učenja, ki lahko preseže ali vsaj ujema te rezultate. Če nam to uspe, bi bil odličen pokazatelj, da je naš model globokega učenja učinkovit vsaj pri ponovitvi rezultatov priljubljenih modelov strojnega učenja na podlagi strokovnega znanja domene.
Danes bomo uporabljali Težko s Tensorflowom za izdelavo našega modela. Keras je knjižnica Python, ki v primerjavi z razmeroma nizkim nivojem vmesnika API-ja Tensorflow omogoča enostavno izdelavo modelov globokega učenja. Poleg gostih plasti bomo uporabili tudi vdelane in konvolucijske sloje, da se naučimo osnovnih semantičnih informacij besed in potencialnih strukturnih vzorcev v podatkih.
Najprej bomo morali podatke prestrukturirati na način, ki ga bo naša nevronska mreža zlahka obdelala in razumela. To lahko storimo tako, da besede nadomestimo z enolično identifikacijskimi številkami. V kombinaciji z vektorjem za vdelavo lahko besede predstavimo na način, ki je prilagodljiv in pomensko občutljiv.
V praksi bomo želeli biti malo pametnejši pri tej predobdelavi. Smiselno bi bilo, da se osredotočimo na pogosto uporabljene besede in filtriramo tudi najpogosteje uporabljene besede (npr. The, this, a).
To funkcijo lahko implementiramo z uporabo Defaultdict in NLTK. Zapišite naslednjo kodo v ločen modul Python. Postavil sem ga v lib/get_top_x_words.py.
from nltk import word_tokenize from collections import defaultdict def count_top_x_words(corpus, top_x, skip_top_n): count = defaultdict(lambda: 0) for c in corpus: for w in word_tokenize(c): count[w] += 1 count_tuples = sorted([(w, c) for w, c in count.items()], key=lambda x: x[1], reverse=True) return [i[0] for i in count_tuples[skip_top_n: skip_top_n + top_x]] def replace_top_x_words_with_vectors(corpus, top_x): topx_dict = {top_x[i]: i for i in range(len(top_x))} return [ [topx_dict[w] for w in word_tokenize(s) if w in topx_dict] for s in corpus ], topx_dict def filter_to_top_x(corpus, n_top, skip_n_top=0): top_x = count_top_x_words(corpus, n_top, skip_n_top) return replace_top_x_words_with_vectors(corpus, top_x) Zdaj smo pripravljeni na izdelavo modela. Želimo vgradni sloj, zvitek in gosto plast, da izkoristimo vse funkcije globokega učenja, ki so lahko koristne za našo aplikacijo. S Kerasom lahko model izdelamo zelo preprosto:
from keras.models import Sequential from keras.layers import Dense, Conv1D, Flatten from keras.layers.embeddings import Embedding from keras.preprocessing import sequence from keras.utils import to_categorical import pandas as pd from collections import Counter from sklearn.model_selection import train_test_split from lib.get_top_xwords import filter_to_top_x df = pd.read_csv('data/wine_data.csv') counter = Counter(df['variety'].tolist()) top_10_varieties = {i[0]: idx for idx, i in enumerate(counter.most_common(10))} df = df[df['variety'].map(lambda x: x in top_10_varieties)] description_list = df['description'].tolist() mapped_list, word_list = filter_to_top_x(description_list, 2500, 10) varietal_list_o = [top_10_varieties[i] for i in df['variety'].tolist()] varietal_list = to_categorical(varietal_list_o) max_review_length = 150 mapped_list = sequence.pad_sequences(mapped_list, maxlen=max_review_length) train_x, test_x, train_y, test_y = train_test_split(mapped_list, varietal_list, test_size=0.3) max_review_length = 150 embedding_vector_length = 64 model = Sequential() model.add(Embedding(2500, embedding_vector_length, input_length=max_review_length)) model.add(Conv1D(50, 5)) model.add(Flatten()) model.add(Dense(100, activation='relu')) model.add(Dense(max(varietal_list_o) + 1, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(train_x, train_y, epochs=3, batch_size=64) y_score = model.predict(test_x) y_score = [[1 if i == max(sc) else 0 for i in sc] for sc in y_score] n_right = 0 for i in range(len(y_score)): if all(y_score[i][j] == test_y[i][j] for j in range(len(y_score[i]))): n_right += 1 print('Accuracy: %.2f%%' % ((n_right/float(len(test_y)) * 100))) Zaženite kodo in videli bi naslednji izhod.
Natančnost: 77,20%
Spomnimo se, da je bila natančnost za naivne Bayes in SVC 73,56% oziroma 80,66%. Torej se naša nevronska mreža zelo drži pred nekaterimi najpogostejšimi metodami klasifikacije besedil.
Danes smo zajeli izdelavo klasifikacijskega modela globokega učenja za analizo ocen vin.
Ugotovili smo, da smo lahko zgradili model, ki je bil sposoben tekmovati z drugimi algoritmi strojnega učenja in jih preseči. Upamo, da ste navdihnjeni za uporabo teh informacij za izdelavo aplikacij, ki analizirajo bolj zapletene nabore podatkov in ustvarjajo bolj zapletene rezultate!
Opomba: Kodo, ki sem jo uporabil za ta članek, najdete na GitHub .
Obdelava naravnega jezika je vrsta računalniških tehnik, ki se uporabljajo za analizo ali ustvarjanje človeškega jezika in govora.
