Sügav õppimine on tehnoloogia, millest on saanud masinõppe töövoogude oluline osa. Paralleelarvutusvõimsuse ja abivahendite täiustustest kasu saamine, keerulised ja sügavad närvivõrgud, mis olid kunagi ebapraktilised, on nüüd elujõulised.

Selliste võimsate ja ligipääsetavate raamatukogude tekkimine nagu Tensorivoog , Taskulamp ja Deeplearning4j on avanud arenduse ka väljaspool akadeemilisi ringkondi asuvatele kasutajatele ja suurte tehnoloogiaettevõtete teadusosakondadele. Selle kasvava üldlevimise tunnistusena lisavad sellised ettevõtted nagu Huawei ja Apple nüüd oma uusimatesse seadmetesse pühendunud süvaõppele optimeeritud protsessorid, et toita süvaõppimise rakendusi.

Sügav õppimine on tõestanud oma jõudu paljudes valdkondades. Kõige olulisem on Google AlphaGo suutis võita inimmängijaid mängus Go - mängus, mille hämmastavat keerukust peeti kunagi võistluses inimmängijate vastu peaaegu ületamatuks takistuseks arvutitele. Flow Machines projekt by Sony on välja töötanud närvivõrgu, mis suudab muusikat komponeerida mineviku kuulsate muusikute stiilis. FaceID , Apple'i välja töötatud turvafunktsioon, kasutab sügavat õppimist, et tuvastada kasutaja nägu ja jälgida kasutaja näo muutusi aja jooksul.

Selles artiklis rakendame sügavat õppimist kahele minu lemmikteemale: loomulik keele töötlemine ja vein. Koostame mudeli, et mõista asjatundjate looduskeelseid veiniarvustusi ja tuletada nende vaadatava veini mitmekesisust.

Sügav õppimine NLP jaoks

Aastal on ulatuslikult kasutatud sügavat õppimist loomuliku keele töötlemine (NLP), sest see sobib hästi lause keeruka alusstruktuuri ja erinevate sõnade semantilise läheduse õppimiseks. Näiteks kasutab meeleolude analüüs praeguses tehnika tasemes sügavat õppimist, et tabada raskesti modelleeritavaid keelelisi mõisteid, nagu eitused ja segased tunded.

Sügaval õppimisel on teiste NLP algoritmide ees mitmeid eeliseid:

1. Paindlikud mudelid: Sügava õppimise mudelid on palju paindlikumad kui teised ML-mudelid. Saame hõlpsalt katsetada erinevaid struktuure, lisades ja eemaldades kihte vastavalt vajadusele. Sügava õppimise mudelid võimaldavad ka paindlike väljunditega mudeleid ehitada. Paindlikkus on keerukate keelestruktuuride mõistmiseks hästi sobivate mudelite väljatöötamise võti. Samuti on see hädavajalik selliste NLP-rakenduste nagu tõlked, vestlusrobotid ja tekst kõneks rakenduste arendamiseks.
2. Vaja on vähem domeeniteadmisi: Ehkki hea süvaõppemudeli väljatöötamiseks on kindlasti vaja teatud valdkonnateadmisi ja intuitsiooni, tähendab sügava õppe algoritmide võime ise tunnushierarhiaid õppida, et arendaja ei vaja sügava arengu jaoks nii palju põhjalikke teadmisi probleemiruumist NLP algoritmide õppimine. Nii keerulise probleemruumi jaoks nagu loomulik keel on see igati tervitatav eelis.
3. Lihtsam pidev õppimine: Sügava õppimise algoritme on uute andmete saabudes lihtne koolitada. Mõni masinõppe algoritm nõuab värskendamiseks mudeli kaudu kogu andmekogumi saatmist, mis tekitaks probleemi elusate ja suurte andmekogumite jaoks.

Probleem täna

Täna ehitame põhjaliku õppimisalgoritmi, et määrata ülevaadetava teksti põhjal ülevaatatava veini sort. Kasutame veiniajakirja andmekogumit aadressil https://www.kaggle.com/zynicide/wine-reviews mille pakub Kaggle'i kasutaja zackthoutt .

Kontseptuaalselt on küsimus selles, kas saaksime teha veini ülevaate nagu…

Aroomide hulka kuuluvad troopilised puuviljad, harja, väävel ja kuivatatud ürdid. Maitse ei ole ülemäära väljendusrikas, pakkudes viljaka happesuse kõrval küpsemata õuna, tsitruselisi ja kuivatatud salvei.

... ja tunnistage, et tegemist on valge seguga? Mõned veinihuvilised võivad ära tunda valgete veinide nagu õun, tsitruselised ja väljendunud happesuse märguloomad, kuid kas me saame oma närvivõrku treenida neid signaale ära tundma? Lisaks, kas me saame oma närvivõrku treenida, et ära tunda peent erinevusi valge segu ülevaatuse ja pinot grigio ülevaate vahel?

Sarnased algoritmid

Probleem, millega täna koostööd teeme, on sisuliselt NLP klassifikatsiooniprobleem. NLP-s on mitmesugustele probleemidele rakendatud mitmeid NLP klassifikatsiooni algoritme. Näiteks, naiivsed Bayes on kasutatud erinevates rämpsposti tuvastamise algoritmides ja tugivektorimasinad (SVM) on kasutatud selliste tekstide nagu tervishoiuasutuste edusammude klassifitseerimiseks. Oleks huvitav rakendada nende algoritmide lihtne versioon, mis oleks meie süvaõppemudeli aluseks.

Naiivne Bayes

Naiivsete Bayesi populaarne rakendamine NLP jaoks hõlmab teksti eeltöötlust TF-IDF-i abil ja multinoomsete naiivsete Bayesi käitamist eeltöödeldud väljunditel. See võimaldab algoritmi käivitada dokumendi kõige silmapaistvamate sõnade peal. Me saame naiivseid Bayesid rakendada järgmiselt:

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)))

Käivitage ülaltoodud kood ja peaksite nägema järgmist: 73,56%

Arvestades, et vaatame kümmet klassi, on see üsna hea tulemus.

Saame kasutada ka tugivektorimasinat ja vaadata, kuidas see läheks. Selle toimimise nägemiseks asendage lihtsalt klassifikaatori definitsioon tekstiga

clf = SVC(kernel='linear').fit(train_x, train_y)

Käivitage see ja peaksite nägema järgmist väljundit:

föderaalne maksuklassifikaator c korporatsioon

Täpsus: 80,66%

Ka mitte liiga räbal.

Vaatame, kas suudame luua sügava õppemudeli, mis ületaks või vähemalt vastaks nendele tulemustele. Kui see meil õnnestub, oleks see suurepärane viide sellele, et meie süvaõppemudel on vähemalt domeeniekspertiisist teavitatud populaarsete masinõppemudelite tulemuste kordamise tulemus.

Mudeli ehitamine

Täna me kasutame Raske meie mudeli ehitamiseks koos Tensorflow'ga. Keras on Pythoni teek, mis muudab sügavate õppemudelite koostamise Tensorflow API suhteliselt madala taseme liidesega võrreldes väga lihtsaks. Lisaks tihedatele kihtidele kasutame ka sisestamise ja konvolutsioonilisi kihte, et õppida sõnade aluseks olevat semantilist teavet ja võimalikke struktuurimustreid andmetes.

Andmete puhastamine

Esiteks peame andmed ümber korraldama viisil, mida meie närvivõrk saab hõlpsasti töödelda ja mõista. Saame seda teha, asendades sõnad kordumatult identifitseerivate numbritega. Koos kinnistamisvektoriga suudame sõnu kujutada nii paindlikult kui ka semantiliselt tundlikult.

Praktikas tahame olla selle eeltöötluse osas veidi targemad. Mõistlik oleks keskenduda sagedamini kasutatavatele sõnadele ja filtreerida ka kõige sagedamini kasutatavad sõnad (nt the, this, a).

Saame selle funktsiooni rakendada Defaultdict ja NLTK abil. Sisestage järgmine kood eraldi Pythoni moodulisse. Paigutasin selle 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)

Nüüd oleme valmis mudeli ehitama. Soovime, et kinnistuskiht, konvolutsiooniline kiht ja tihe kiht kasutaksid kõiki sügavaid õppefunktsioone, mis võivad meie rakenduses abiks olla. Kerase abil saame mudeli üles ehitada väga lihtsalt:

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)))

Käivitage kood ja peaksite nägema järgmist väljundit.

Täpsus: 77,20%

Tuletame meelde, et naiivsete Bayesi ja SVC täpsus oli vastavalt 73,56% ja 80,66%. Nii et meie närvivõrk hoiab end mõnede levinumate tekstide klassifitseerimise meetodite vastu.

Järeldus

Täna käsitlesime veinide ülevaadete analüüsimiseks klassifikatsiooni süvaõppemudeli loomist.

Leidsime, et suutsime ehitada mudeli, mis oleks võimeline konkureerima mõne teise masinõppe algoritmiga ja ületama neid. Loodame, et olete inspireeritud seda teavet kasutama keerukamaid andmekogumeid analüüsivate ja keerukamate väljundite genereerivate rakenduste loomiseks!

Märkus. Koodi, mida selle artikli jaoks kasutasin, leiate siit GitHub .

Põhitõdede mõistmine

Mis on loomuliku keele töötlemine?

Loomulik keele töötlemine on arvutusmeetodite vahemik, mida kasutatakse inimese keele ja kõne analüüsimiseks või tootmiseks.