keras.fit() և keras.fit_generator()

<h2>Ներածություն <p>Keras-ում fit() և fit generator() մեթոդները աներևակայելիորեն հեշտացնում են Python-ում խորը նյարդային ցանցերի վարժեցումը: Fit() մեթոդը հնարավորություն է տալիս արդյունավետորեն մշակել և վարժեցնել տվյալների խմբաքանակի վրա՝ այն հատկապես օգտակար դարձնելով ավելի փոքր տվյալների հավաքածուների համար, որոնք կարող են բեռնվել հիշողության մեջ: Մյուս կողմից, fit generator() մեթոդը, որը հնարավորություն է տալիս խմբաքանակների դինամիկ բեռնում և մշակում, ավելի հարմար է ավելի մեծ տվյալների հավաքածուների համար, որոնք չեն կարող միանգամից բեռնվել հիշողության մեջ:

Կերասի հիմունքները

Այսօր տեխնոլոգիան ամեն կերպ բարելավվել է։ Այսպիսով, տեխնոլոգիայի և ապագայի այս առաջադեմ միջավայրում Keras-ը հայտնի դարձավ որպես պիթոնի հայտնի գրադարաններից մեկը: Այն հիմնականում աշխատում է խորը նեյրոնային ցանցերի ստեղծման, գնահատման և ուսուցման համար: Մարդու ուղեղի կառուցվածքն ու աշխատանքը նմանակվում են այս խորը նեյրոնային ցանցերով, մեքենայական ուսուցման ալգորիթմի ձևով: Պատկերի ճանաչումը, բնական լեզվի մշակումը, խոսքի ճանաչումը և այլն: գործունեությանը։

The fit() մեթոդը

Սա Keras-ի հիմնական մեթոդն է մոդելային ուսուցման համար, և այն լավ է աշխատում փոքր և միջին չափի տվյալների հավաքածուների հետ: Եթե ձեր տվյալների բազան չափազանց մեծ է հիշողության մեջ տեղավորելու համար, ապա fit() ֆունկցիան պետք է, որ դուք այն ամբողջությամբ տեղադրեք հիշողության մեջ նախքան մարզվելը: Անկախ նրանից, fit() տեխնիկան օգտագործելը պարզ է: Պարզապես մուտքագրեք ձեր վերապատրաստման տվյալները, պիտակները, դարաշրջանների քանակը և խմբաքանակի չափը: Այնուհետև Keras-ը վարժեցնում է ձեր մոդելը՝ կրկնելով ձեր տվյալների բազան որոշակի թվով դարաշրջանների և խմբաքանակի չափերի համար: Fit() մեթոդը գերազանց է հիմնական մարզումների համար, բայց այն ունի սահմանափակումներ:

Հարմարվելու սահմանափակումներ()

Keras' fit() ֆունկցիան սովորաբար օգտագործվում է խորը նյարդային ցանցեր (DNN) մարզելու համար։ Այնուամենայնիվ, այն ունի զգալի սահմանափակումներ, որոնք կարող են սահմանափակել դրա օգտակարությունը: Fit()-ի հետ կապված ամենալուրջ խնդիրներից մեկը հսկայական տվյալների հավաքածուների հետ գործ ունենալն է: Չնայած ուժեղ և բազմակողմանի գործիք լինելուն՝ DNN-ների վերապատրաստման համար, մեծ տվյալների բազան կարող է պատճառ դառնալ, որ fit() ֆունկցիան երկար ժամանակ մշակի, ինչի հետևանքով ձեր նախագիծը հետաձգվի: Հիշողության օգտագործումը fit(-ի մեկ այլ սահմանափակում է): Երբ դուք ունեք սահմանափակ հիշողություն, սա կարող է լուրջ դժվարություն լինել: Այն նաև առանձնապես հարմարվող չէ հարմարեցման առումով:

fit_generator() մեթոդը

Fit_generator() մեթոդը, ինչպես fit() մեթոդը, վերապատրաստում է նեյրոնային ցանցը տվյալների բազայի վրա: Միակ փոփոխությունն այն է, թե ինչպես են մշակվում տվյալները: Մինչ fit()-ը բեռնում է ամբողջ տվյալների բազան միանգամից հիշողության մեջ, fit_generator() տվյալները մշակում է խմբաքանակով: Այս աննշան տարբերությունը կարող է նշանակալից թվալ, բայց այն տալիս է բազմաթիվ եզակի առավելություններ: Սկսնակների համար այն հնարավորություն է տալիս աշխատել զգալիորեն ավելի մեծ տվյալների հավաքածուների հետ: Դասընթացի կեսին հիշողությունն այլևս չի սպառվում: Ավելին, այն թույլ է տալիս հարմարեցնել ձեր տվյալների մշակումը ավելի բարդ ձևերով:

Շարահյուսություն

fit() −

model.fit(x=x_train, y=y_train, batch_size=batch_size, epochs=epochs, validation_data=(x_val, y_val))

fit_generator −

model.fit_generator(generator=train_generator, steps_per_epoch=steps_per_epoch,  epochs=epochs, validation_data=val_generator, validation_steps=val_steps)

Բացատրություն

Մեզ անհրաժեշտ է հենց մոդելային օրինակը, որը ծառայում է որպես վերապատրաստման գործընթացի հիմք: Այնուհետև ձեզ անհրաժեշտ կլինեն մուտքային տվյալները (x_train) և պիտակները (y_train), որոնք կօգտագործվեն մոդելը վարժեցնելու համար:

Batch_size տարբերակը սահմանում է նմուշների քանակը, որոնք կմշակվեն մինչև մոդելի ներքին պարամետրերը թարմացվեն: Այս արժեքը կարող է ազդել վերապատրաստման գործընթացի արագության և արդյունավետության վրա: Ավելին, դարաշրջանների թիվը սահմանում է, թե ուսուցման ընթացքում ուսուցման ամբողջական տվյալների բազան քանի անգամ է մշակվելու մոդելի միջոցով:

Եթե առկա է, կարող եք ավելացնել կամընտիր validation_data՝ մոդելի արդյունավետությունը ստուգելու և վերապատրաստման ընթացքում որոշակի տվյալների բազայի կորուստը հետևելու համար: Սա թույլ է տալիս ուսումնասիրել մոդելի ընդհանրացման ունակությունը և կատարել ցանկացած անհրաժեշտ բարելավում:

Որպես այլընտրանք, դուք կարող եք օգտագործել train_generator, որը ստեղծում է ուսուցման տվյալների փաթեթներ թռիչքի ժամանակ: Steps_per_epoch տարբերակը ցույց է տալիս, թե քանի խմբաքանակ պետք է գեներատորը ստեղծի յուրաքանչյուր դարաշրջանի համար: Նմանապես, val_generator-ը կարող է օգտագործվել val_steps արգումենտով, որը սահմանում է խմբաքանակների քանակը, որոնք վավերացման գեներատորը պետք է ստեղծի յուրաքանչյուր դարաշրջանի համար:

Ալգորիթմ

• Քայլ 1 - Ներմուծեք բոլոր անհրաժեշտ գրադարաններն ու մոդուլները:

• Քայլ 2 − Հաջորդը հիշեք՝ բեռնել կամ արտադրել բոլոր անհրաժեշտ վերապատրաստման և վավերացման տվյալները:

• Քայլ 3 − Keras API-ն պետք է օգտագործվի՝ մոդելի ճարտարապետությունը տրամադրելու համար:

• Քայլ 4 - Կազմել մոդելը կորստի ֆունկցիայից հետո, օպտիմիզատորը և գնահատման մատրիցը սահմանվելուց հետո

• Քայլ 5 − Մոդելը վարժեցնելու համար օգտագործեք վերը նշված մոդելներից որևէ մեկը (որը fit() կամ fit_generator է)

Մոտեցում 1. Վերահսկվող ուսուցում՝ օգտագործելով fit():

Այս կոդը հրահանգում է համակարգչային ծրագրին օգտագործել նեյրոնային ցանց՝ տվյալների օրինաչափություններ սովորելու համար: Ծրագիրն ունի երկու շերտ՝ մեկը, որը փնտրում է օրինաչափություններ տվյալների մեջ, և մյուսը, որը կանխատեսում է տվյալների կատեգորիան:

Օրինակ

# Importing required libraries
import tensorflow as tf
from tensorflow import keras
import numpy as np
# Defining the Sequential model with 2 layers
model = keras.Sequential([
	keras.layers.Dense(units=64, activation='relu', input_dim=100),
	keras.layers.Dense(units=10, activation='softmax')
])
# Compiling the model with required configuration
model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])
# Creating a dummy dataset
x_train = np.random.random((1000, 100))
y_train = np.random.random((1000, 10))
# Training the model
model.fit(x_train, y_train, epochs=20, batch_size=128)

Արդյունք

Epoch 1/20
8/8 [==============================] - 1s 3ms/step - loss: 12.2208 - accuracy: 0.1070
Epoch 2/20
8/8 [==============================] - 0s 3ms/step - loss: 12.6586 - accuracy: 0.1090
...
Epoch 20/20
8/8 [==============================] - 0s 2ms/step - loss: 35170420.0000 - accuracy: 0.1060
<keras.callbacks.History at 0x7f14d04b2c80>

Մոտեցում 2. Օրինակ՝ օգտագործելով Keras.fit_generator()

Այս կոդում մենք կիրականացնենք տվյալների ավելացում և վերահաշվարկ՝ օգտագործելով ImageDataGenerator դասը Keras-ից: Տվյալների գեներատորները անմիջապես տալիս են տվյալների խմբաքանակներ՝ հնարավորություն տալով վերապատրաստվել մեծածավալ տվյալների հավաքածուներով:

Օրինակ

import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from keras.preprocessing.image import ImageDataGenerator
x_train = np.random.random((1000, 20))
y_train = np.random.randint(2, size=(1000, 1))
x_val = np.random.random((100, 20))
y_val = np.random.randint(2, size=(100, 1))
train_datagen = ImageDataGenerator(rescale=1./255)
val_datagen = ImageDataGenerator(rescale=1./255)
train_generator = train_datagen.flow(x_train, y_train, batch_size=32)
val_generator = val_datagen.flow(x_val, y_val, batch_size=32)
model = Sequential()
model.add(Dense(64, activation='relu', input_dim=20))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy'])
model.fit_generator(generator=train_generator, steps_per_epoch=30, epochs=10, validation_data=val_generator, validation_steps=3)

Արդյունք

Epoch 1/10
30/30 [==============================] - 0s 5ms/step - loss: 0.7105 - accuracy: 0.4969 - val_loss: 0.6967 - val_accuracy: 0.4792
...
Epoch 10/10
30/30 [==============================] - 0s 2ms/step - loss: 0.6932 - accuracy: 0.5031 - val_loss: 0.6931 - val_accuracy: 0.4792

Եզրակացություն

Հիշեք, որ fit() մեթոդը հիանալի է փոքր տվյալների հավաքածուների և պարզ մոդելների համար, բայց այն ունի իր սահմանափակումները: Fit_generator() մեթոդն առաջարկում է ավելի ճկունություն և անհատականացման տարբերակներ ավելի մեծ տվյալների հավաքածուների և ավելի բարդ մոդելների համար: Ընտրեք խելամտորեն՝ ելնելով ձեր կոնկրետ կարիքներից: