Како да се обучи невронска мрежа за анализа на чувствата

Авторот ја избра програмата Пишувај за донации.

Вовед

Анализата на чувствата, силно поврзана со рударството на текст и обработката на природниот јазик, извлекува квалитативна проценка од писмени критики. Многу луѓе читаат филмски критики за да проценат колку добар филм изгледа кај општата популација. Иако доделувањето број или оцена со ѕвезди на филм може да не укажува на неговиот квантитативен успех или неуспех, збирката филмски критики нуди квалитативна перспектива за овие филмови. Текстуалниот филмски преглед може да идентификува што гледачите веруваат дека се добрите и лошите елементи на филмот. Подлабокото испитување на рецензијата често ќе открие дали филмот ги исполнува очекувањата на рецензентот. Анализата на чувствата може да се користи за да се процени перспективата на рецензентот за темите или целокупниот поларитет на прегледот.

За да спроведете анализа на чувствата, би извршиле компјутерска програма за препознавање и категоризирање мислења во текст, како на пример дали писателот (или рецензентот) има позитивен или негативен став кон дадена тема (во овој случај, филм ). Како поддомен на ископување мислење, анализата на чувствата се фокусира на извлекување на емоции и мислења за одредена тема од структурирани, полуструктурирани или неструктурирани текстуални податоци. Како и со другите модели за ископување мислење, може да користите анализа на чувствата за да ги следите мислењата за брендот и производот и да ги разберете потребите на клиентите. Анализата на чувствата се фокусира на поларитетот на текстот (позитивен, негативен или неутрален), како и откривање на специфични чувства и емоции на рецензентот (лут, среќен, тажен и така натаму како што е дефинирано од моделот), итноста, па дури и намери (заинтересирани или незаинтересирани).

Во ова упатство, ќе изградите невронска мрежа која го предвидува чувството на филмски прегледи со keras. Вашиот модел ќе ги категоризира рецензиите во две категории (позитивни или негативни) со користење на базата на прегледи на Меѓународната база на податоци за филмови (IMDb), која содржи 50.000 критики за филмови. До крајот на ова упатство, ќе создадете модел за длабоко учење и ќе обучите невронска мрежа за да врши анализа на чувствата.

Предуслови

  • Еден пример на Ubuntu 22.04 сервер со најмалку 8 GB RAM. На овој сервер ќе му треба корисник без корен со sudo привилегии и конфигуриран заштитен ѕид, кој може да го поставите следејќи го нашиот првичен водич за поставување сервер.
  • Python 3, pip и модулот Python venv инсталиран на серверот, кој можете да го поставите следејќи ги чекорите 1 и 2 од нашето упатство за Како да инсталирате Python 3 и да поставите програмско опкружување.
  • Jupyter лаптоп е инсталиран и работи на оддалечен сервер, кој можете да го поставите со Како да го инсталирате, стартувате и поврзете со Jupyter Notebook на далечински сервер.
  • Модерен веб-прелистувач што ќе го користите за пристап до Jupyter Notebook.
  • Основно разбирање на моделите за машинско учење и длабоко учење. Дознајте повеќе во Вовед во машинско учење.

Чекор 1 - Подготовка на вашата средина за преносни компјутери Jupyter

Jupyter Notebook обезбедува интерактивна пресметковна средина, па затоа често се користи за извршување на модели за длабоко учење наместо Python во терминал на командната линија. Со Jupyter Notebook, командите и излезите се појавуваат во една тетратка, овозможувајќи ви да ги документирате вашите мисли додека го развивате процесот на анализа.

За да го следите ова упатство во вашиот Jupyter Notebook, ќе треба да отворите нов бележник и да ги инсталирате потребните зависности, што ќе го направите во овој чекор.

Забелешка: Ако го следите упатството на оддалечен сервер, можете да користите препраќање порти за да пристапите до вашиот Jupyter Notebook во прелистувачот на вашата локална машина.

Отворете терминал и внесете ја следнава команда:

  1. ssh -L 8888:localhost:8888  your_non_root_user@your_server_ip

По поврзувањето со серверот, одете до врската обезбедена од излезот за да пристапите до вашиот Jupyter Notebook. Чувајте го овој терминал отворен во текот на остатокот од ова упатство.

Вие поставивте Jupyter Notebook околина на вашиот сервер во предусловите. Откако ќе се најавите на вашиот сервер, активирајте ја виртуелната средина:

  1. source ~/environments/my_env/bin/activate

Потоа стартувајте ја апликацијата Jupyter Notebook за да ја стартувате апликацијата:

  1. jupyter notebook

По извршувањето и поврзувањето со него, ќе пристапите до корисничкиот интерфејс во вашиот прелистувач. Од паѓачкото мени Ново, изберете ја опцијата Python3(ipykernel), која ќе отвори ново јазиче со тетратка без наслов на Python. Именувајте ја датотеката neural_network.ipynb бидејќи ќе го извршите вашиот код во оваа датотека.

Потоа, во првата ќелија од Jupyter Notebook на вашиот прелистувач, користете pip за да ги инсталирате потребните зависности за обработка на вашите податоци:

!pip install numpy
!pip install tensorflow

Зависноста numpy се користи за манипулирање со низи во линеарна алгебра. Во ова упатство, ќе го користите за манипулирање со базата на податоци на IMDb во неговата форма на низа со повикување на овие функции:

Зависноста tensorflow ви овозможува да го обучите и распоредите вашиот модел за длабоко учење во Пајтон. Со инсталирање на tensorflow се инсталира и keras, кој работи на врвот на TensorFlow и воведува ниво на апстракција помеѓу TensorFlow и корисникот за да овозможи брз развој на модели за длабоко учење. Ова упатство користи tensorflow и keras за целиот процес на обука и распоредување на анализа на чувствата.

Откако ќе ги додадете двете команди во вашиот Jupyter Notebook, притиснете го копчето Run за да ги извршите.

Вашиот Jupyter Notebook ќе обезбеди тековен излез за да покаже дека секоја зависност се презема. Нова влезна ќелија ќе биде достапна под овој излез, каде што ќе ги извршите следните линии на код.

Кога зависностите ќе завршат со преземањето, ќе ги увезете. Додајте ги овие линии во следната ќелија и потоа притиснете Изврши:

import numpy as np
from keras.utils import to_categorical
from keras import models
from keras import layers

Забелешка: може да добиете предупредување за библиотеките TensorFlow и TensorRT кога ги извршувате овие команди. Општо земено, Tensorflow работи со CPU, GPU и TPU. Предупредувачката грешка вели дека инсталираната верзија на TensorFlow може да ги користи операциите AVX и AVX2, што може да го забрза процесот. Ова предупредување не е грешка, туку забелешка дека TensorFlow ќе ги искористи предностите на вашиот процесор за дополнителна брзина.

Инсталирањето на алатката keras ја вклучува вградената база на податоци на IMDB. Податокот има поделба на воз/тест 50/50. За ова упатство, ќе поставите поделба 80/20 за да спречите претренирање на невронската мрежа. Како такви, ќе ги споите податоците во податоци и цели по преземањето за да можете да направите поделба 80/20 подоцна во упатството. Додајте ги овие линии во нова ќелија и притиснете Изврши:

from keras.datasets import imdb
(training_data, training_targets), (testing_data, testing_targets) = imdb.load_data(num_words=10000)
data = np.concatenate((training_data, testing_data), axis=0)
targets = np.concatenate((training_targets, testing_targets), axis=0)

Оваа ќелија ја увезува базата на податоци на IMDb и ги спојува податоците за обуката со податоците од тестот. Стандардно, сетот е поделен на податоци за обука, тренинг_цели, податоци за тестирање и цели за тестирање.

Вашиот Jupyter Notebook ќе има дневник за активности и ќе бидат потребни неколку моменти за да се преземе сетот на податоци:

Output
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb.npz
17464789/17464789 [==============================] - 0s 0us/step

Во овој чекор, ја подготвивте околината на Jupyter Notebook за да можете да ја истражите оваа база на податоци за шеми, претпоставки и аномалии на тестот. Следно, ќе извршите истражувачка анализа на податоци за целата база на податоци.

Чекор 2 - Анализирање на збирката на податоци

Сега ќе ја процените базата на податоци за да идентификувате како да го обучите вашиот модел со овие податоци. Спроведувањето на истражувачка анализа на податоци за вашата база на податоци ќе ја разјасни основната структура на базата на податоци. Овој процес може да открие трендови, обрасци и односи кои не се лесно видливи. Оваа информација може да ви помогне да откриете грешки, да ги разоткриете претпоставките и да ги разберете односите помеѓу клучните променливи. Ваквите сознанија на крајот може да доведат до избор на соодветен модел за предвидување.

Вашата прва задача со оваа база на податоци е да ги вратите излезните типови и бројот на единствени зборови. За да ги добиете овие информации, извршете ги следните линии во нова ќелија:

print("The output categories are", np.unique(targets))
print("The number of unique words is", len(np.unique(np.hstack(data))))

Оваа ќелија го печати бројот на уникатни чувства во базата на податоци (позитивни [1] или негативни [0]) и бројот на единствени зборови што се користат во прегледот.

Ќе се отпечати следниот излез:

Output
The output categories are [0 1]
The number of unique words is 9998

Првата линија од овој излез вели дека филмовите се означени или позитивни (1) или негативни (0). Втората линија вели дека има 9998 уникатни зборови во сетот.

Следно, ќе ја утврдите просечната должина на зборовите за прегледите на филмот и стандардното отстапување на зборовите. За да го направите тоа, извршете ги овие линии на код во нова ќелија:

length = [len(i) for i in data]
print("The Average Review length is", np.mean(length))
print("The Standard Deviation is", round(np.std(length)))

Оваа ќелија ќе ја отпечати просечната должина на прегледот и стандардното отстапување за базата на податоци:

Output
The Average Review length is 234.75892
The Standard Deviation is 173

Оваа проценка покажува дека просечната должина на прегледот е 234 зборови со стандардна девијација од 173.

Следно, ќе отпечатите елемент од сетот (првиот индекс) со извршување на овие редови во нова ќелија:

print("Label:", targets[0])
print(data[0])

Ќе се отпечати пар преглед на филм-етикета за првиот елемент во базата на податоци:

Output
Label: 1
[1, 14, 22, 16, 43, 530, 973, 1622, 1385, 65, 458, 4468, 66, 3941, 4, 173, 36, 256, 5, 25, 100, 43, 838, 112, 50, 670, 2, 9, 35, 480, 284, 5, 150, 4, 172, 112, 167, 2, 336, 385, 39, 4, 172, 4536, 1111, 17, 546, 38, 13, 447, 4, 192, 50, 16, 6, 147, 2025, 19, 14, 22, 4, 1920, 4613, 469, 4, 22, 71, 87, 12, 16, 43, 530, 38, 76, 15, 13, 1247, 4, 22, 17, 515, 17, 12, 16, 626, 18, 2, 5, 62, 386, 12, 8, 316, 8, 106, 5, 4, 2223, 5244, 16, 480, 66, 3785, 33, 4, 130, 12, 16, 38, 619, 5, 25, 124, 51, 36, 135, 48, 25, 1415, 33, 6, 22, 12, 215, 28, 77, 52, 5, 14, 407, 16, 82, 2, 8, 4, 107, 117, 5952, 15, 256, 4, 2, 7, 3766, 5, 723, 36, 71, 43, 530, 476, 26, 400, 317, 46, 7, 4, 2, 1029, 13, 104, 88, 4, 381, 15, 297, 98, 32, 2071, 56, 26, 141, 6, 194, 7486, 18, 4, 226, 22, 21, 134, 476, 26, 480, 5, 144, 30, 5535, 18, 51, 36, 28, 224, 92, 25, 104, 4, 226, 65, 16, 38, 1334, 88, 12, 16, 283, 5, 16, 4472, 113, 103, 32, 15, 16, 5345, 19, 178, 32]

Овој излез го обезбедува првиот преглед на датата на податоци, означен како позитивен (1), а целосниот текст како индекс на цел број. Стандардно, прегледите на текст се дадени во нивната нумеричка кодирана форма како листа на индекси на зборови базирани на цели броеви. Зборовите во прегледите се индексирани врз основа на тоа колку често се појавуваат низ целата база на податоци. На пример, вториот најчест термин во податоците е кодиран со цел број 2.

Потоа ќе го вратите речникот, мапирајќи ги индексите на зборови назад во оригиналните зборови за да можете да го прочитате прегледот на текстот. Извршете ги овие линии во нова ќелија:

index = imdb.get_word_index()
reverse_index = dict([(value, key) for (key, value) in index.items()])
decoded = " ".join( [reverse_index.get(i - 3, "#") for i in data[0]] )
print(decoded)

Овој код блок ќе ја дешифрира нумеричката форма во читлив текст. Со функцијата get_word_index(), добивате дикт мапирајќи ги зборовите на нивниот индекс во базата на податоци на IMDb. Променливата reverse_index потоа има дикт што ги пресликува индексите на зборовите откако ќе го врати индексот на зборовите. Функцијата dict() создава речник кој ги складира вредностите на податоците во парови клуч-вредност. Последните две линии код ќе ја декодираат и отпечатат првата низа во базата на податоци.

Користејќи ја функцијата get_word_index(), ќе го добиете следниот излез:

Output
# this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert # is an amazing actor and now the same being director # father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for # and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also # to the two little boy's that played the # of norman and paul they were just brilliant children are often left out of the # list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all

Функцијата get_word_index() ги декодира нумеричките податоци за овој преглед во читливи зборови и го заменува секој непрепознатлив збор со #.

Во овој чекор, ја проценивте базата на податоци, прегледајќи како е подготвен секој преглед. Со оваа информација, сега ќе ги подготвите податоците за обука.

Чекор 3 - Подготовка на податоци за обука

Во овој чекор, ќе ја подготвите базата на податоци за обука. Моделите за длабоко учење генерално се развиваат од податоците за кои се обучени.

Кога ги подготвувате овие податоци, ќе ги форматирате на прецизен начин за да добиете вредни сознанија кои водат до попрецизни резултати од моделот. Некои техники за подготовка на податоци вклучуваат избор на карактеристики (избор на карактеристики релевантни за моделот), инженерство на карактеристики (конвертирање на променливите во вашата база на податоци во корисни функции користејќи методи за кодирање) и разделување вашата база на податоци во воз и тест множества.

Во ова упатство, ќе ги поделите податоците на тест и обучувачки множества и ќе извршите инженерство на карактеристики со векторизирање на податоците.

Во следната ќелија, извршете ги следните линии на код за да го векторизирате секој преглед во базата на податоци:

def vectorize(sequences, dimension = 10000):
    results = np.zeros((len(sequences), dimension))
    for i, sequence in enumerate(sequences):
        results[i, sequence] = 1
    return results

data = vectorize(data)
targets = np.array(targets).astype("float32")

Прво, го векторизирате и пополнувате секој преглед, така што секој преглед ќе содржи точно 10.000 броеви. Преку овој процес, секој преглед кој е пократок од 10.000 зборови го пополнувате со нули бидејќи најголемиот преглед во базата на податоци е околу таа должина и невронската мрежа бара секој влез да биде со иста големина.

Функцијата vectorize() зема два параметри: низа и претходно поставена димензија од 10000. Оваа функција го повикува методот zeros() од numpy, кој враќа нова низа исполнета со нули и потоа ги шифрира останатите податоци. Со последните две линии на код, ќе ја повикате дефинираната функција во базата на податоци и потоа ќе ја конвертирате целната колона од вашата база на податоци во 32-битен пловечки број. 32-битен пловечки број е број со подвижна запирка со околу седум цифри на прецизност. Конвертирањето на целната колона во 32-битен пловечки број ќе ја зголеми прецизноста на колоната и моделот за длабоко учење по проширување.

Како последен чекор во подготовката на вашите податоци, ќе ги поделите вашите податоци на комплети за обука и тестирање. Ќе ставите 40.000 прегледи во комплетот за обука и 10.000 во комплетот за тестирање, обезбедувајќи поделба 80/20 што беше опишано претходно.

Поделете ја вашата база на податоци со извршување на овие команди во нова ќелија:

test_x = data[:10000]
test_y = targets[:10000]
train_x = data[40000:]
train_y = targets[40000:]

Базата на податоци е поделена на тест и возови во сооднос 1:4, при што целите во возот и тестот се зачувани како train_y и test_y и прегледите во воз и тест сет зачувани како train_x и test_y, соодветно. Покрај тестирањето и оценувањето на вашиот модел со нови податоци, поделбата на базата на податоци значи дека вашиот модел ќе избегне преоптоварување, што е кога алгоритам премногу добро ги моделира податоците за обуката.

Во овој чекор, ги подготвивте податоците и го одвоивте датата на податоци во сетови за воз и тест. Ги трансформиравте необработените податоци во карактеристики што може да се користат за модел за длабоко учење. Со вашите податоци подготвени за обука, сега ќе ја изградите и обучувате невронската мрежа што ќе ја користи вашиот модел за длабоко учење.

Чекор 4 - Градење и обука на невронската мрежа

Сега можете да ја изградите вашата невронска мрежа.

Ќе започнете со дефинирање на типот на модел што сакате да го изградите. Постојат два типа на модели достапни во keras: Model Sequential API и Functional API. Во ова упатство, ќе го користите Sequential API бидејќи ви овозможува да креирате модели слој-по-слој.

Забелешка: За посложени модели за длабоко учење, треба да го користите функционалното API бидејќи секвенцијалниот API не ви дозволува да креирате модели што споделуваат слоеви или имаат повеќе влезови или излези. Сепак, за ова упатство, секвенцијалниот API ќе биде доволен.

Поставете го вашиот модел како секвенцијален модел со извршување на оваа команда во нова ќелија:

model = models.Sequential()

Забелешка: Може да добиете друга грешка на TensorFlow во овој момент, во која се наведува дека треба да се обнови TensorFlow со соодветните ознаки на компајлерот. Оваа грешка е поврзана со претходната грешка и резултати бидејќи пакетите TensorFlow 2.x поддржуваат и процесор и графички процесор, па затоа TensorFlow ги бара двигателите за графичкиот процесор. Можете безбедно да го игнорирате ова предупредување, бидејќи тоа нема да влијае на резултатот од упатството.

Бидејќи слоевите ја формираат основата на моделите за длабоко учење, потоа ќе ги додадете влезните, скриените и излезните слоеви. Помеѓу нив, ќе користите густо на секој слој и отпаѓање за да спречите преоптоварување.

Извршете ги овие линии во нова ќелија за да ги додадете слоевите:

# Input - Layer
model.add(layers.Dense(50, activation = "relu", input_shape=(10000, )))
# Hidden - Layers
model.add(layers.Dropout(0.3, noise_shape=None, seed=None))
model.add(layers.Dense(50, activation = "relu"))
model.add(layers.Dropout(0.2, noise_shape=None, seed=None))
model.add(layers.Dense(50, activation = "relu"))
# Output- Layer
model.add(layers.Dense(1, activation = "sigmoid"))
model.summary()

Ќе ја користите функцијата relu во скриените слоеви бидејќи дава прифатлив резултат. relu значи Поправена линеарна единица и функцијата враќа 0 ако добие негативен влез или вредноста назад за која било позитивна вредност. Додавањето на оваа функција во првиот слој ги отстранува негативните вредности со враќање на 0. Во ова упатство, функцијата relu осигурува дека сите вредности што влегуваат во влезниот слој се позитивни вредности, кои се неопходни за нервните влезови.

На излезниот слој, ќе ја користите функцијата sigmoid, која ги пресликува вредностите 0 и 1. Бидејќи излезот е позитивен (1) или негативен (0), функцијата sigmoid ќе обезбеди излезниот слој да произведува излез кој е или 0 или 1.

На крајот, ќе дозволите keras да отпечати резиме на моделот што штотуку го изградивте.

Ќе добиете резиме на карактеристиките на моделот што штотуку сте го обучиле:

Output
Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense (Dense)               (None, 50)                500050    
                                                                 
 dropout (Dropout)           (None, 50)                0         
                                                                 
 dense_1 (Dense)             (None, 50)                2550      
                                                                 
 dropout_1 (Dropout)         (None, 50)                0         
                                                                 
 dense_2 (Dense)             (None, 50)                2550      
                                                                 
 dense_3 (Dense)             (None, 1)                 51        
                                                                 
=================================================================
Total params: 505,201
Trainable params: 505,201
Non-trainable params: 0
_________________________________________________________________

Следно, ќе го составите и конфигурирате моделот за обука. Ќе ја користите точноста како метрика за оценување. Функцијата загуба ќе ја пресмета количината што моделот треба да се обиде да ја минимизира за време на обуката. Избирате binary-crossentropy во овој пример бидејќи загубата на вкрстена ентропија помеѓу вистинските и предвидените ознаки е одлична мерка за бинарни (0 или 1 ) апликации за класификација.

За да го компајлирате моделот, извршете ги следните редови во следната ќелија:

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

Функцијата compile() ја дефинира архитектурата на моделот. Вие го имплементирате алгоритмот adam како оптимизатор на вашиот модел во оваа дефиниција. Овој алгоритам е метод на спуштање со градиент кој се базира на приближување на моменти од прв и втор ред. Метриката и параметрите за загуба се многу тесно поврзани. Додека метричкиот параметар дефинира како да се процени перформансите на вашиот модел, параметарот за загуба ја дефинира количината што моделот сака да ја минимизира за време на обуката. Метриката овде е точност (делот од предвидувањата што моделот ги добива правилно), додека загубата е binary_crossentropy (метрика помеѓу ознаките и предвидувањата што се користат кога има само две ознаки класи [позитивниот 1 и негативниот 0]).

Сега, ќе можете да го обучите вашиот модел. За да го направите ова, ќе користите batch_size од 32 и само две епохи. големината на серијата е бројот на примероци што ќе се пропагираат преку невронската мрежа, а епоха е повторување на целиот податок за обука. Поголема големина на серија генерално подразбира побрз тренинг, но понекогаш се спојува побавно. Спротивно на тоа, помалата големина на серијата е побавна во обуката, но може да се спои побрзо.

Сега ќе започнете да го обучувате вашиот модел за да ги доведе сите параметри до точната вредност за да ги мапирате вашите влезови на вашиот влез. Извршете ги овие линии во следната ќелија:

results = model.fit(
train_x, train_y,
epochs= 2,
batch_size = 32,
validation_data = (test_x, test_y)
)

Ќе го обучите вашиот модел користејќи ја функцијата .fit(). Оваа функција го обучува моделот за длабоко учење за фиксен број повторувања на базата на податоци. Функцијата вклучува два потребни параметри:

  • train_x се однесува на влезните податоци.
  • train_y се однесува на целните податоци за комплетот за обука на кој ќе се обучуваат податоците и може да преземат други параметри.

Останатите параметри го вклучуваат следново:

  • епохи (бројот на епохи за обука на моделот каде што епохата е повторување во текот на сите дадени податоци).
  • batch_size (бројот на примероци по ажурирање на градиент).
  • validation_data (податоци на кои моделот ќе ја процени загубата на крајот од секоја епоха).

Овој код го обучува моделот користејќи две епохи и големина на серија од 32, што значи дека целата база на податоци ќе биде пренесена низ невронската мрежа двапати со 32 примери за обука што се користат во секоја итерација. Податоците за валидација се дадени како test_x и test_y.

Забелешка: Обуката за модел за анализа на сентимент е интензивна RAM меморија. Ако го извршите ова упатство на сервер со RAM од 8 GB, може да го добиете следново предупредување: Алокацијата на x надминува 10% од слободната системска меморија. Можете да го игнорирате ова предупредување кога ќе се појави и да продолжите со упатството, бидејќи само наведува дека обуката зазема значителна количина од слободната системска меморија и нема никакво влијание врз остатокот од упатството.

Во овој чекор, го изградивте вашиот модел за длабоко учење и го обучивте врз базата на податоци што сте ја подготвиле. Следно, ќе ги процените перформансите на моделот во однос на различна база на податоци користејќи ги податоците за валидација генерирани во овој чекор.

Чекор 5 - Евалуација на моделот

Ќе го оцените моделот во овој чекор. Евалуацијата на моделот е составен дел на процесот на подобрување и развој на машинското учење. Оваа евалуација помага да се најде најдобриот модел што ги претставува вашите податоци и колку добро функционира избраниот модел.

Постојат четири основни метрики за евалуација на моделот за модел на класификација на машинско учење: точност, прецизност, отповикување и резултат F1.

Прецизноста е вообичаено користена метрика за изведба бидејќи го проценува делот од предвидувањата што вашиот модел ги направил правилно. Точноста се одредува со делење на бројот на точни предвидувања со вкупниот број на предвидувања. Ќе користите точност за да го оцените вашиот модел во ова упатство.

Прецизноста, во контекст на овој модел, би се однесувала на позитивни филмски критики кои биле правилно предвидени наспроти вкупниот број предвидени позитивни филмски критики. Да се потсетиме е поделбата на позитивни критики за филмови кои беа правилно предвидени според вкупниот број прегледи на филмови проценети во сетот на податоци. Прецизноста одговара на прашањето, Од сите филмски рецензии што вашиот модел ги означи како позитивни, колку всушност беа позитивни?. Спротивно на тоа, потсетувањето одговара на прашањето, Од сите филмски критики кои се навистина позитивни, колку вашиот модел означи како позитивни?. Резултатот Ф1 е пондериран просек на резултатите од прецизноста и отповикувањето. Како таква, ги зема предвид сите рецензии што се погрешно категоризирани.

Во ова упатство, ќе ги оцените перформансите на вашиот модел користејќи ја неговата точност. Извршете ги овие линии на код во следната ќелија:

scores = model.evaluate(test_x, test_y, verbose=0)
print("Accuracy: %.2f%%" % (scores[1]*100))

Овој код го складира резултатот за точност на моделот во променлива наречена scores и го печати на екранот. Функцијата .evaluate зема три параметри

  • x_test: колоната за карактеристики за тест-базата.
  • y_test: целната колона за тест сет.
  • ребросмислено: режимот на говорност.

Следниот излез ќе се печати со стапка на точност:

Output
Accuracy: 86.59%

Точноста на овој обучен модел е 86,59%.

Овој резултат за точност покажува дека овој модел точно предвидува дали прегледот е позитивен или негативен околу девет од десет пати. Може да продолжите да работите на вашиот код за да се обидете да го натерате вашиот класификатор да работи со подобра точност. За да го подобрите вашиот модел и да ја подобрите точноста, можете да го зголемите бројот на епохи или големината на серијата за вашиот модел.

Моделите за длабоко учење (и моделите за машинско учење) се исто толку моќни како и податоците што ги давате. Како такво, зголемувањето на точноста на вашиот модел често се постигнува со додавање повеќе податоци. Сепак, податоците што се користат за овој модел се вградени и не можат да се менуваат. Во овој случај, можете да ја подобрите точноста на моделот со додавање на повеќе слоеви на вашиот модел или зголемување на бројот на епохи (бројот на пати кога го пренесувате целиот сет низ невронската мрежа) во чекор 4.

За да го зголемите бројот на епохи, заменете го бројот на епохи во ќелијата model.fit() од 2 во 3 (или друг број), потоа повторно активирајте ја таа ќелија и ќелиите што следат:

results = model.fit(
train_x, train_y,
epochs= 3,
batch_size = 32,
validation_data = (test_x, test_y)
)

Зголемен е бројот на епохи, што значи дека податоците за обуката ќе минуваат низ невронската мрежа вкупно три пати, а моделот ќе има дополнителна можност да учи од податоците. Кога повторно ќе ја извршите функцијата model.evaluate(), ќе добиете нов излез со ажурирана стапка на точност.

Во овој чекор, го оценивте моделот што го изградивте со пресметување на неговата точност. По првичното пресметување, го зголемивте бројот на епохи за да го подобрите моделот и да го преиспитате резултатот за точност.

Заклучок

Во ова упатство, трениравте невронска мрежа да го категоризира чувството на филмски критики како позитивни или негативни користејќи keras. Ја користевте базата на податоци за класификација на чувствата на IMDb, собрани од истражувачи од Универзитетот Стенфорд. Податокот содржи една од однапред преземените сетови на податоци keras за класификација на бинарни чувства. Можете да пристапите до базата на податоци, збир од 25.000 високополаризирани прегледи на филмови за обука и уште 25.000 за тестирање. Ја прегледавте оваа база на податоци за да развиете модел на голема невронска мрежа за анализа на чувствата.

Сега кога изградивте и обучивте невронска мрежа, можете да ја испробате оваа имплементација со ваши сопствени податоци или да ја тестирате на други популарни збирки на податоци. Може да експериментирате со другите сетови на податоци keras или да пробате различни алгоритми.

За да го изградите вашето искуство keras и TensorFlow, можете да го следите нашето упатство за Како да изградите модел за длабоко учење за да го предвидите задржувањето на вработените користејќи Keras и TensorFlow.