ටෙන්සර්ෆ්ලෝ 2 ටෙන්සර්ෆ්ලෝ 1 ට වඩා මන්දගාමී වන්නේ ඇයි?

එය බොහෝ පරිශීලකයින් විසින් පයිටෝර්ච් වෙත මාරුවීමට හේතුව ලෙස දක්වා ඇත, නමුත් ඉතා වැදගත් ප්‍රායෝගික ගුණාත්මකභාවය, වේගය, උනන්දුවෙන් ක්‍රියාත්මක කිරීම සඳහා කැප කිරීම සඳහා සාධාරණීකරණයක් / පැහැදිලි කිරීමක් මම තවම සොයාගෙන නැත.

පහත දැක්වෙන්නේ කේත මිණුම් සලකුණු කාර්ය සාධනය, TF1 එදිරිව TF2 - TF1 ඕනෑම තැනක සිට ක්‍රියාත්මක වීමයි 47% සිට 276% දක්වා වේගයෙන් ධාවනය වේ.

මගේ ප්‍රශ්නය: ප්‍රස්ථාරයේ හෝ දෘඩාංග මට්ටමින් මෙතරම් සැලකිය යුතු මන්දගාමිත්වයක් ලබා දෙන්නේ කුමක් ද?

සවිස්තරාත්මක පිළිතුරක් සොයමින් - පුළුල් සංකල්ප සමඟ දැනටමත් හුරුපුරුදුය. අදාළ Git

පිරිවිතර : CUDA 10.0.130, cuDNN 7.4.2, Python 3.7.4, වින්ඩෝස් 10, GTX 1070

මිණුම් සලකුණු ප්‍රති results ල :

UPDATE : පහත දැක්වෙන කෝඩ් අනුව ආසක්ත ක්රියාකරවීම අක්රීය කරන්නේ නැහැ උදව් කරන්න. කෙසේ වෙතත්, හැසිරීම නොගැලපේ: සමහර විට ප්‍රස්ථාර මාදිලියේ ධාවනය සැලකිය යුතු ලෙස උපකාරී වේ, වෙනත් වේලාවක එය ක්‍රියාත්මක වේ ඊජර්ට සාපේක්ෂව මන්දගාමී වේ.

ටීඑෆ් ඩෙව්ස් කොතැනකවත් නොපෙන්වන හෙයින්, මම මේ කාරණය මා විසින්ම විමර්ශනය කරමි - සම්බන්ධිත ගිතුබ් ගැටලුවේ ප්‍රගතිය අනුගමනය කළ හැකිය.

යාවත්කාලීන කිරීම 2 : පැහැදිලි කිරීම් සමඟ බෙදා ගැනීමට පර්යේෂණාත්මක ප්‍රති results ල ටොන්; අද කළ යුතුයි.

මිණුම් සලකුණු කේතය :

# use tensorflow.keras... to benchmark tf.keras; used GPU for all above benchmarks
from keras.layers import Input, Dense, LSTM, Bidirectional, Conv1D
from keras.layers import Flatten, Dropout
from keras.models import Model
from keras.optimizers import Adam
import keras.backend as K
import numpy as np
from time import time

batch_shape = (32, 400, 16)
X, y = make_data(batch_shape)

model_small = make_small_model(batch_shape)
model_small.train_on_batch(X, y)  # skip first iteration which builds graph
timeit(model_small.train_on_batch, 200, X, y)

K.clear_session()  # in my testing, kernel was restarted instead

model_medium = make_medium_model(batch_shape)
model_medium.train_on_batch(X, y)  # skip first iteration which builds graph
timeit(model_medium.train_on_batch, 10, X, y)

භාවිතා කරන කාර්යයන් :

def timeit(func, iterations, *args):
    t0 = time()
    for _ in range(iterations):
        func(*args)
    print("Time/iter: %.4f sec" % ((time() - t0) / iterations))

def make_small_model(batch_shape):
    ipt   = Input(batch_shape=batch_shape)
    x     = Conv1D(128, 400, strides=4, padding='same')(ipt)
    x     = Flatten()(x)
    x     = Dropout(0.5)(x)
    x     = Dense(64, activation='relu')(x)
    out   = Dense(1,  activation='sigmoid')(x)
    model = Model(ipt, out)
    model.compile(Adam(lr=1e-4), 'binary_crossentropy')
    return model

def make_medium_model(batch_shape):
    ipt   = Input(batch_shape=batch_shape)
    x     = Bidirectional(LSTM(512, activation='relu', return_sequences=True))(ipt)
    x     = LSTM(512, activation='relu', return_sequences=True)(x)
    x     = Conv1D(128, 400, strides=4, padding='same')(x)
    x     = Flatten()(x)
    x     = Dense(256, activation='relu')(x)
    x     = Dropout(0.5)(x)
    x     = Dense(128, activation='relu')(x)
    x     = Dense(64,  activation='relu')(x)
    out   = Dense(1,   activation='sigmoid')(x)
    model = Model(ipt, out)
    model.compile(Adam(lr=1e-4), 'binary_crossentropy')
    return model

def make_data(batch_shape):
    return np.random.randn(*batch_shape), np.random.randint(0, 2, (batch_shape[0], 1))

යාවත්කාලීන කිරීම 5/19/2020 : TF 2.2, එකම පරීක්ෂණ භාවිතා කිරීම: ඊජර් වේගයෙහි සුළු දියුණුවක් පමණි. train_on_batchපහත දැක්වෙන විශාල-විශාල සංඛ්‍යා නඩුව සඳහා වන බිම් , x- අක්ෂය අනුක්‍රමික යෝග්‍යතා පුනරාවර්තන වේ; මගේ GPU එහි සම්පූර්ණ ධාරිතාවයට ආසන්න නැත, එබැවින් එය තෙරපෙමින් පවතින බවට සැක කරන්න, නමුත් කාලයත් සමඟ පුනරාවර්තනය මන්දගාමී වේ.

ඉහත දැක්වෙන පරිදි, ප්‍රස්ථාරය සහ ඊජර් පිළිවෙලින් ඔවුන්ගේ TF1 සගයන්ට වඩා 1.56x සහ 1.97x මන්දගාමී වේ. අභිරුචි / පහත් මට්ටමේ ක්‍රියාකාරිත්වය සඳහා ටෙන්සර් ෆ්ලෝ හි දුර්වල සහයෝගය අනුව පයිටෝර්ච් වෙත මාරුවීම ගැන සලකා බලන බැවින් මම මෙය තවදුරටත් නිදොස්කරණය කරමි. කෙසේ වෙතත්, මම devs ගේ ප්‍රතිපෝෂණය ලබා ගැනීම සඳහා නිකුතුවක් විවෘත කළෙමි .

යාවත්කාලීන කිරීම 2/18/2020 : මම රාත්‍රී 2.1 සහ 2.1 බංකුවක සිටිමි; ප්‍රති results ල මිශ්‍ර වේ. එක් වින්‍යාසයක් හැර අනෙක් සියල්ලම (ආකෘති සහ දත්ත ප්‍රමාණය) TF2 සහ TF1 හි හොඳම ඒවාට වඩා වේගවත් හෝ වේගවත් ය. මන්දගාමී හා නාටකාකාර ලෙස මන්දගාමී වන්නේ විශාල-විශාලයි - එස්පී. ප්‍රස්ථාර ක්‍රියාත්මක කිරීමේදී ( 1.6x සිට 2.5x මන්දගාමී වේ ).

තවද, අන්තයන් ඇත මා විසින් පරීක්ෂා කරන ලද විශාල ආකෘතියක් සඳහා ප්‍රස්ථාරය සහ ඊජර් අතර ප්‍රජනන හැකියාව ඇත - අහඹු ලෙස / ගණනය-සමාන්තරකරණයෙන් පැහැදිලි කළ නොහැකි එකක්. කාල සීමාවන්ට අනුව මෙම හිමිකම් සඳහා ප්‍රජනනය කළ හැකි කේතයක් මට දැනට ඉදිරිපත් කළ නොහැක, ඒ වෙනුවට ඔබේම ආකෘති සඳහා මෙය පරීක්ෂා කිරීමට මම තරයේ නිර්දේශ කරමි.

මේවා පිළිබඳව තවමත් Git ප්‍රශ්නයක් විවෘත කර නැත, නමුත් මම මුල් පිටපත පිළිබඳව අදහස් දැක්වුවෙමි - තවමත් ප්‍රතිචාරයක් නොමැත. ප්‍රගතියක් ලැබීමෙන් පසු මම පිළිතුරු (ය) යාවත්කාලීන කරමි.

සහතිකය : එසේ නොවේ , ඔබ කරන්නේ කුමක්දැයි ඔබ දන්නේ නම්. නමුත් ඔබ එසේ නොකරන්නේ නම් , එය ඔබට විශාල මුදලක් වැය විය හැකිය - සාමාන්‍යයෙන් GPU වැඩි දියුණු කිරීම් කිහිපයකින් සහ බහු GPU වලින් නරකම අවස්ථාව.

මෙම පිළිතුර : ගැටළුව පිළිබඳ ඉහළ මට්ටමේ විස්තරයක් මෙන්ම ඔබේ අවශ්‍යතාවන්ට විශේෂිත වූ පුහුණු වින්‍යාසය තීරණය කරන්නේ කෙසේද යන්න පිළිබඳ මාර්ගෝපදේශ සැපයීම ද අරමුණු කරයි. භාවිතා කරන ලද සියලු මිණුම් සලකුණු ප්‍රති results ල + කේතය ඇතුළත් සවිස්තරාත්මක, පහත් මට්ටමේ විස්තරයක් සඳහා, මගේ අනෙක් පිළිතුර බලන්න.

මම කිසියම් දෙයක් ඉගෙන ගන්නේ නම් මම මගේ පිළිතුර (ය) යාවත්කාලීන කරමි - මෙම ප්‍රශ්නය යොමු කිරීම සඳහා පිටු සලකුණු / "තරු" කළ හැකිය.

ISSUE SUMMARY : තහවුරු කළ පරිදි ටෙන්සර් ෆ්ලෝ සංවර්ධකයෙකු වන Q. ස්කොට් ෂු විසින් කරන ලද පරිදි, TF2 ඊජර් ක්‍රියාත්මක කිරීම සහ දැඩි ඒකාබද්ධතාවය w / Keras කෙරෙහි අවධානය යොමු කළේය. ප්‍රතිලාභ: විශාල වශයෙන් පුළුල් කරන ලද සැකසුම්, බෙදා හැරීම්, නිදොස්කරණය සහ යෙදවීමේ හැකියාවන්. කෙසේ වෙතත් මේවායින් සමහරක් පිරිවැය වේ.

කෙසේ වෙතත් කාරණය තරමක් සංකීර්ණ ය. එය TF1 එදිරිව TF2 පමණක් නොවේ - දුම්රිය වේගයෙහි සැලකිය යුතු වෙනස්කම් ඇති කරන සාධක අතර:

1. TF2 එදිරිව TF1
2. ඊජර් එදිරිව ප්‍රස්ථාර ප්‍රකාරය
3. keras එදිරිව. tf.keras
4. numpyඑදිරිව tf.data.Datasetඑදිරිව ...
5. train_on_batch() එදිරිව. fit()
6. GPU එදිරිව CPU
7. model(x)එදිරිව model.predict(x)එදිරිව ...

අවාසනාවකට මෙන්, ඉහත කිසිවක් පාහේ අනෙකට වඩා ස්වාධීන නොවන අතර, සෑම එකක්ම තවත් එකක් සාපේක්ෂව අවම වශයෙන් දෙගුණයක් ක්‍රියාත්මක කළ හැකිය. වාසනාවකට මෙන්, ඔබට ක්‍රමානුකූලව වැඩ කළ හැකි දේ තීරණය කළ හැකිය, සහ කෙටිමං කිහිපයක් සමඟ - මම පෙන්වන පරිදි.

මම කළ යුත්තේ කුමක් ද? දැනට, එකම ක්‍රමය - ඔබේ විශේෂිත ආකෘතිය, දත්ත සහ දෘඩාංග සඳහා අත්හදා බැලීම. තනි වින්‍යාසයක් සෑම විටම වඩා හොඳින් ක්‍රියා නොකරනු ඇත - නමුත් කළ යුතු දේ සහ ඔබගේ සෙවීම සරල කිරීමට අවශ්‍ය නැත:

>> කරන්න:

• train_on_batch()+ numpy+ tf.keras+ TF1 + උනන්දුවෙන් / ප්‍රස්ථාරයෙන්
• train_on_batch()+ numpy+ tf.keras+ TF2 + ප්‍රස්ථාරය
• fit()+ numpy+ tf.keras+ TF1 / TF2 + ප්‍රස්තාරය + විශාල ආකෘතිය සහ දත්ත

>> කරන්න එපා:

• fit()+ numpy+ kerasකුඩා හා මධ්‍යම ආකෘති සහ දත්ත සඳහා
• fit()+ numpy+ tf.keras+ TF1 / TF2 + උනන්දුවෙන්

• train_on_batch()+ numpy+ keras+ TF1 + උනන්දුවෙන්

• [මේජර්] tf.python.keras ; එය 10-100x මන්දගාමීව ධාවනය කළ හැකි අතර දෝෂ විශාල ප්‍රමාණයක් ඇත; වැඩි විස්තර

  • මෙම ඇතුළත් layers, models, optimizers, සහ ඒ හා සම්බන්ධ "යල්-කොටුව" භාවිතය ආනයන; ops, utils, සහ ආශ්‍රිත 'පුද්ගලික' ආනයන හොඳයි - නමුත් නිසැකවම, alts සඳහා පරීක්ෂා කරන්න, සහ ඒවා භාවිතා කරන්නේද යන්නtf.keras

උදාහරණ මිණුම් සලකුණු සැකසුම සඳහා මගේ අනෙක් පිළිතුරේ පතුලේ ඇති කේතය වෙත යොමු වන්න. ඉහත ලැයිස්තුව ප්‍රධාන වශයෙන් අනෙක් පිළිතුරේ ඇති “බෙන්ච්මාර්ක්ස්” වගු මත පදනම් වේ.

සීමාවන් ඉහත සඳහන් ආකාරයට කරන්න, ගේ සහ එපා ගේ:

• මෙම ප්‍රශ්නයේ මාතෘකාව "TF2 TF1 ට වඩා මන්දගාමී වන්නේ ඇයි?" සහ එහි ශරීරය පැහැදිලිවම පුහුණුව ගැන සැලකිලිමත් වන අතර කාරණය එයට පමණක් සීමා නොවේ; අනුමානය විශ්වාසනීයත්වයක් , ද, ප්රධාන වේගය වෙනස්කම් වලට යටත් වේ පවා ආදිය එම කාර්ය සාධක බලකාය අනුවාදය, ආනයන, දත්ත හැඩතල, ඇතුළත - බලන්න මේ පිළිතුර .
• RNNs TF2 හි වැඩි දියුණු කර ඇති බැවින් අනෙක් පිළිතුරෙහි දත්ත ජාලකය සැලකිය යුතු ලෙස වෙනස් කිරීමට ඉඩ ඇත
• මූලික වශයෙන් භාවිතා කරන ආකෘති Conv1Dසහ Dense- ආර්එන්එන්, විරල දත්ත / ඉලක්ක, 4/5 ඩී ආදාන සහ වෙනත් වින්‍යාසයන් නොමැත
• ආදාන දත්ත සීමිතයි numpy සහ tf.data.Datasetවෙනත් බොහෝ ආකෘති පවතී අතර,; වෙනත් පිළිතුර බලන්න
• GPU භාවිතා කරන ලදී; ප්‍රති results ල ලැබෙනු ඇත වූ CPU මත වෙනස් වේ. ඇත්ත වශයෙන්ම, මම ප්‍රශ්නය ඇසූ විට, මගේ CUDA නිසියාකාරව වින්‍යාස කර නොමැති අතර සමහර ප්‍රති results ල CPU මත පදනම් වූ ඒවා විය.

උනන්දුවෙන් ක්‍රියාත්මක කිරීම සඳහා TF2 වඩාත් ප්‍රායෝගික ගුණාත්මකභාවය, වේගය කැප කළේ ඇයි?එය පැහැදිලිව දක්වා නැත - ප්‍රස්ථාරය තවමත් පවතී. නමුත් ප්‍රශ්නය නම් “ඇයි උනන්දු වන්නේ”:

• සුපිරි නිදොස්කරණය : "මම අතරමැදි ස්ථර ප්‍රතිදානයන් ලබා ගන්නේ කෙසේද" හෝ "මම බර පරීක්ෂා කරන්නේ කෙසේද" යනුවෙන් අසන ප්‍රශ්න රාශියක් ඔබ දැක ඇති; උනන්දුවෙන්, එය (පාහේ) තරම් සරල ය .__dict__. ප්‍රස්ථාරයට වෙනස්ව, විශේෂ පසුබිම් කාර්යයන් පිළිබඳ හුරුපුරුදු වීමක් අවශ්‍ය වේ - නිදොස් කිරීම සහ ස්වයං විමර්ශනය කිරීමේ සමස්ත ක්‍රියාවලියම බෙහෙවින් සංකීර්ණ කරයි.
• වේගවත් මූලාකෘතිකරණය : ඉහත අදහස් වලට සමාන අදහස් අනුව; වේගවත් අවබෝධය = සත්‍ය ඩීඑල් සඳහා වැඩි කාලයක් ඉතිරිව ඇත.

EAGER සක්‍රීය කළ හැක්කේ කෙසේද?

tf.enable_eager_execution()  # TF1; must be done before any model/tensor creation
tf.compat.v1.disable_eager_execution() # TF2; above holds

අතිරේක තොරතුරු :

• _on_batch()TF2 හි ක්රම සමඟ ප්රවේශම් වන්න ; TF dev ට අනුව, ඔවුන් තවමත් මන්දගාමී ක්‍රියාත්මක කිරීමක් භාවිතා කරයි, නමුත් හිතාමතාම නොවේ - එනම් එය නිවැරදි කළ යුතුය. විස්තර සඳහා වෙනත් පිළිතුරක් බලන්න.

ටෙන්සර්ෆ්ලෝ ඩිව්ස් සඳහා ඉල්ලීම් :

1. කරුණාකර නිවැරදි කරන්න train_on_batch(), සහ ඇමතීමේ කාර්ය සාධන අංගයfit() ඇමතීමේ ; අභිරුචි දුම්රිය ලූප බොහෝ දෙනෙකුට විශේෂයෙන් මට වැදගත් ය.
2. පරිශීලකයින්ගේ දැනුම සඳහා මෙම කාර්ය සාධන වෙනස්කම් පිළිබඳ ලියකියවිලි / ලේඛනය සඳහන් කරන්න.
3. පයිටෝර්ච් වෙත එබී බැලීමෙන් වළක්වා ගැනීම සඳහා සාමාන්‍ය ක්‍රියාත්මක කිරීමේ වේගය වැඩි දියුණු කරන්න.

වගකීම් : ස්තූතියි

• ප්‍රශ්නය - ටෙන්සර් ෆ්ලෝ සංවර්ධක ස්කොට් ෂු, මේ පිළිබඳව සවිස්තරාත්මක පැහැදිලි කිරීමක් සඳහා.
• පී. ඇන්ඩ්‍රි ප්‍රයෝජනවත් පරීක්ෂණ සහ සාකච්ඡාව බෙදා ගැනීම සඳහා .

යාවත්කාලීන කිරීම් :

• 11/14/19 - සියළුම වින්‍යාසයන් w / Numpy ආදාන දත්ත සඳහා TF2 මත මන්දගාමීව ධාවනය වන ආකෘතියක් (මගේ සැබෑ යෙදුමේ) හමු විය . වෙනස්කම් 13-19%, සාමාන්‍යය 17%. අතර ඇති වෙනස්කම් kerasසහ tf.keras: කෙසේ වෙතත්, වඩාත් නාටකීය විය 18-40% , සාමාන්යය. 32% (TF1 සහ 2 යන දෙකම). (* - TF2 OOM'd සඳහා ඊගර් හැර)

• 11/17/19 - යාවත්කාලීන devs on_batch()දී ක්රම මෑත සිදු දැන් ලෙස කාර්ය සාධක බලකාය 2.1 නිකුත් කිරීමට, හෝ ලබා ගත හැකි - වැඩි දියුණු වේගය ඇති පවසමින් tf-nightly. මට පසුකාලීනව ධාවනය කිරීමට නොහැකි බැවින්, 2.1 දක්වා බංකුව ප්‍රමාද වනු ඇත.

• 2/20/20 - පුරෝකථන කාර්ය සාධනය ද බංකුවට දැමීම වටී; නිදසුනක් ලෙස, TF2 හි, CPU පුරෝකථන වේලාවන්ට වරින් වර කරල් ඇතුළත් විය හැකිය

මෙම පිළිතුර : TF2 එදිරිව TF1 දුම්රිය ලූප, ආදාන දත්ත සකසන සහ ඊජර් එදිරිව ප්‍රස්ථාර ප්‍රකාර ක්‍රියාත්මක කිරීම ඇතුළුව ගැටළුව පිළිබඳ සවිස්තරාත්මක, ප්‍රස්තාර / දෘඩාංග මට්ටමේ විස්තරයක් සැපයීමට අපේක්ෂා කරයි. ගැටළු සාරාංශයක් සහ විසඳුම් මාර්ගෝපදේශ සඳහා, මගේ අනෙක් පිළිතුර බලන්න.

කාර්යසාධන සත්‍යාපනය : සමහර විට එකක් වේගවත් වේ, සමහර විට වින්‍යාසය අනුව වෙනස් වේ. TF2 එදිරිව TF1 යන තාක් දුරට, ඒවා සාමාන්‍යයෙන් සමාන වේ, නමුත් සැලකිය යුතු වින්‍යාසය මත පදනම් වූ වෙනස්කම් පවතින අතර TF1 TF2 තුරන් කරන්නේ අනෙක් අතට වඩා බොහෝ විට ය. පහත "BENCHMARKING" බලන්න.

ඊගර් වී. ග්‍රැෆ් : සමහරුන්ට මෙම සම්පූර්ණ පිළිතුරේ මස්: මගේ පරීක්ෂණයට අනුව, ටීඑෆ් 2 හි උනන්දුව ටීඑෆ් 1 ට වඩා මන්දගාමී ය. විස්තර තවදුරටත් පහළට.

ඒ දෙක අතර මූලික වෙනස වන්නේ: ප්රස්තාරය ඉතා පරිගණකමය ජාලය සකසනු ලබයි සක්රීය ලෙස , හා ඉටු කරන 'වෙත පවසා' විට - ෙහයින්ද, හැම දෙයක්ම නිර්මාණය මත ආසක්ත ඉටු. නමුත් කතාව ආරම්භ වන්නේ මෙතැනින් පමණි:

• ඊජර් ප්‍රස්ථාරයෙන් බැහැර නොවන අතර ඇත්ත වශයෙන්ම අපේක්ෂාවට පටහැනිව බොහෝ විට ප්‍රස්ථාරය විය හැකිය . එය බොහෝ දුරට ක්‍රියාත්මක වන ප්‍රස්ථාරය - මෙයට ප්‍රස්ථාරයේ විශාල කොටසක් ඇතුළත් වන ආකෘති සහ ප්‍රශස්තිකරණ බර ඇතුළත් වේ.

• උනන්දුවෙන් ක්‍රියාත්මක කිරීමේදී තමන්ගේම ප්‍රස්ථාරයක කොටසක් නැවත ගොඩනඟයි ; ප්‍රස්ථාරය සම්පූර්ණයෙන් ගොඩනගා නොතිබීමේ සෘජු ප්‍රතිවිපාකය - පැතිකඩ ප්‍රති .ල බලන්න. මෙය පරිගණකමය පොදු කාර්යයක් ඇත.

• උනන්දුව මන්දගාමී w / Numpy යෙදවුම් ; එක් මෙම Git අදහස් සහ කේතය, ආසක්ත දී Numpy යෙදවුම් දක්වන GPU CPU ගෙන් tensors පිටපත් කිරීමේ පොදු කාර්ය පිරිවැය වේ. ප්‍රභව කේතය හරහා පියවර, දත්ත හැසිරවීමේ වෙනස්කම් පැහැදිලිය; ඊජර් කෙලින්ම නැම්පි පසුකර යන අතර ප්‍රස්ථාරය ආතතීන් පසුකර නැම්පි වෙත තක්සේරු කරයි; නිශ්චිත ක්‍රියාවලිය පිළිබඳ අවිනිශ්චිත, නමුත් දෙවැන්න GPU මට්ටමේ ප්‍රශස්තිකරණයට සම්බන්ධ විය යුතුය

• TF2 Eager TF1 Eager වලට වඩා මන්දගාමී වේ - මෙය ... අනපේක්ෂිතයි. මිණුම් සලකුණු ප්‍රති results ල පහත බලන්න. වෙනස්කම් නොසැලකිලිමත් සිට සැලකිය යුතු දක්වා විහිදේ, නමුත් අනුකූල වේ. එය එසේ වන්නේ මන්දැයි සැක සහිතයි - TF dev පැහැදිලි කරන්නේ නම්, පිළිතුර යාවත්කාලීන වේ.

TF2 එදිරිව TF1 : TF dev ගේ, Q. ස්කොට් ෂුගේ, ප්‍රතිචාර - මගේ අවධාරණයෙන් හා නැවත ලිවීමේ අදාළ කොටස් උපුටා දක්වමින් :

උනන්දුවෙන්, ධාවන කාලයට ඔප්ස් ක්‍රියාත්මක කර පයිතන් කේතයේ සෑම පේළියක් සඳහාම සංඛ්‍යාත්මක අගය ලබා දිය යුතුය. තනි පියවර ක්‍රියාත්මක කිරීමේ ස්වභාවය එය මන්දගාමී වීමට හේතු වේ .

TF2 හි, කෙරස් පුහුණුව, එවාල් සහ පුරෝකථනය සඳහා සිය ප්‍රස්ථාරය තැනීම සඳහා tf.function භාවිතා කරයි. අපි ඒවා ආකෘතිය සඳහා "ක්‍රියාත්මක කිරීමේ කාර්යය" ලෙස හඳුන්වමු. TF1 හි, “ක්‍රියාත්මක කිරීමේ කාර්යය” යනු FuncGraph එකක් වන අතර එය TF ශ්‍රිතය ලෙස පොදු අංගයක් බෙදා ගත් නමුත් වෙනස් ක්‍රියාත්මක කිරීමක් ඇත.

ක්‍රියාවලිය අතරතුර, අපි කෙසේ හෝ දුම්රිය_ඔන්_බැච් (), ටෙස්ට්_ඕන්_බැච් () සහ අනාවැකි_ඔබ_බැච් () සඳහා වැරදි ක්‍රියාත්මක කිරීමක් අතහැර දැමුවෙමු . ඒවා තවමත් සංඛ්‍යාත්මකව නිවැරදි ය , නමුත් x_on_batch සඳහා ක්‍රියාත්මක කිරීමේ කාර්යය tf.function ඔතා ඇති පයිතන් ශ්‍රිතයට වඩා පිරිසිදු පයිතන් ශ්‍රිතයකි. මෙය මන්දගාමී වීමට හේතු වේ

TF2 හි, අපි සියලු ආදාන දත්ත tf.data.Dataset බවට පරිවර්තනය කරමු, එමඟින් අපට එක් ආකාරයක යෙදවුම් හැසිරවීමට අපගේ ක්‍රියාත්මක කිරීමේ කාර්යය ඒකාබද්ධ කළ හැකිය. දත්ත සමුදා පරිවර්තනයේ යම්කිසි පොදු කාර්යයක් තිබිය හැකි අතර , මම සිතන්නේ මෙය එක් කණ්ඩායමකට යන වියදමට වඩා එක් වරක් පමණක් පොදු කාර්යයක් බවයි

ඉහත ඡේදයේ අවසාන වාක්‍යය සහ පහත ඡේදයේ අවසාන වගන්තිය සමඟ:

උනන්දුවක් දක්වන මාදිලියේ මන්දගාමී බව මඟහරවා ගැනීම සඳහා, අපට @ tf.function ඇත, එය පයිතන් ශ්‍රිතයක් ප්‍රස්ථාරයක් බවට පත් කරයි. Np අරාව වැනි සංඛ්යාත්මක අගය පෝෂණය කරන විට, tf.function හි සිරුර ස්ථිතික ප්රස්ථාරයක් බවට පරිවර්තනය කර, ප්රශස්තිකරණය කර, අවසාන අගය ආපසු ලබා දෙන අතර එය වේගවත් වන අතර TF1 ප්රස්ථාර මාදිලිය හා සමාන කාර්ය සාධනයක් තිබිය යුතුය.

මම එකඟ නොවෙමි - මගේ පැතිකඩ ප්‍රති results ල අනුව, ඊජර්ගේ ආදාන දත්ත සැකසීම ප්‍රස්ථාරයට වඩා සැලකිය යුතු ලෙස මන්දගාමී බව පෙන්නුම් කරයි. එසේම, tf.data.Datasetවිශේෂයෙන් සැක සහිත නමුත් ඊජර් එකම දත්ත පරිවර්තන ක්‍රම කිහිපයකින් නැවත නැවත අමතයි - පැතිකඩ බලන්න.

අවසාන වශයෙන්, දේව්ගේ සම්බන්ධිත කැපවීම: කෙරස් v2 ලූප සඳහා සහය දැක්වීම සඳහා සැලකිය යුතු වෙනස්කම් ප්‍රමාණයක් .

දුම්රිය වළළු : (1) ඊජර් එදිරිව ප්‍රස්ථාරය මත පදනම්ව; (2) ආදාන දත්ත ආකෘතිය, පුහුණුව විශේෂිත දුම්රිය පුඩුවක් සමඟ ඉදිරියට යනු ඇත - TF2 _select_training_loop(), training.py , වලින් එකක්:

training_v2.Loop()
training_distributed.DistributionMultiWorkerTrainingLoop(
              training_v2.Loop()) # multi-worker mode
# Case 1: distribution strategy
training_distributed.DistributionMultiWorkerTrainingLoop(
            training_distributed.DistributionSingleWorkerTrainingLoop())
# Case 2: generator-like. Input is Python generator, or Sequence object,
# or a non-distributed Dataset or iterator in eager execution.
training_generator.GeneratorOrSequenceTrainingLoop()
training_generator.EagerDatasetOrIteratorTrainingLoop()
# Case 3: Symbolic tensors or Numpy array-like. This includes Datasets and iterators 
# in graph mode (since they generate symbolic tensors).
training_generator.GeneratorLikeTrainingLoop() # Eager
training_arrays.ArrayLikeTrainingLoop() # Graph

සෑම එකක්ම සම්පත් වෙන් කිරීම වෙනස් ලෙස හසුරුවන අතර කාර්ය සාධනය සහ හැකියාව මත ප්‍රතිවිපාක දරයි.

දුම්රියfittrain_on_batchkerastf.keras වළළු : එදිරිව , එදිරිව : සෑම සිව්දෙනෙකුටම විවිධ දුම්රිය වළළු භාවිතා කරයි. keras' fit, උදාහරණයක් ලෙස, යම් ආකාරයක භාවිතා fit_loopඋදා, training_arrays.fit_loop()සහ එහි train_on_batchභාවිත කළ හැක K.function(). tf.kerasපෙර කොටසේ විස්තර කර ඇති වඩාත් නවීන ධූරාවලියක් ඇත.

දුම්රිය වළළු : ප්‍රලේඛනය - විවිධ ක්‍රියාත්මක කිරීමේ ක්‍රම පිළිබඳ අදාළ මූලාශ්‍ර ලේඛනය :

අනෙකුත් ටෙන්සර් ෆ්ලෝ මෙහෙයුම් මෙන් නොව, අපි පයිතන් සංඛ්‍යාත්මක යෙදවුම් ආතන්‍ය බවට පරිවර්තනය නොකරමු. තවද, එක් එක් විශේෂිත පයිතන් සංඛ්‍යාත්මක අගය සඳහා නව ප්‍රස්ථාරයක් ජනනය වේ

function සෑම අද්විතීය ආදාන හැඩතල සහ දත්ත කට්ටල සඳහා වෙනම ප්‍රස්ථාරයක් ස්ථාපනය කරයි .

තනි tf.function වස්තුවකට හුඩ් යටතේ බහු ගණනය කිරීමේ ප්‍රස්තාර සිතියම් ගත කිරීමට අවශ්‍ය විය හැකිය. මෙය දෘශ්‍යමාන විය යුත්තේ කාර්ය සාධනය ලෙස පමණි (ප්‍රස්ථාර සොයා ගැනීම සඳහා ගණනය කළ නොහැකි හා මතක පිරිවැයක් ඇත )

ආදාන දත්ත සකසනයන් : ඉහත සඳහන් කළ ආකාරයටම, ක්‍රියාකරවන්නන් තෝරාගනු ලබන්නේ ධාවන කාල වින්‍යාසයන්ට අනුව සකසන ලද අභ්‍යන්තර ධජ මත පදනම්ව (ක්‍රියාත්මක කිරීමේ ආකාරය, දත්ත ආකෘතිය, බෙදා හැරීමේ උපාය). සරලම නඩුව ඊජර් සමඟ වන අතර එය කෙලින්ම w / Numpy අරා ක්‍රියා කරයි. සමහර නිශ්චිත උදාහරණ සඳහා, මෙම පිළිතුර බලන්න .

මොඩල් ප්‍රමාණය, දත්ත ප්‍රමාණය:

• තීරණාත්මක ය; සියලුම මාදිලි සහ දත්ත ප්‍රමාණයන් මත තනි වින්‍යාසයක් ඔටුනු නොලැබේ.
• ආකෘති ප්‍රමාණයට සාපේක්ෂව දත්ත ප්‍රමාණය වැදගත් ය; කුඩා දත්ත සහ ආකෘති සඳහා, දත්ත හුවමාරුව (උදා: CPU සිට GPU දක්වා) ඉහළින් ආධිපත්‍යය දරයි. ඒ හා සමානව, කුඩා පරිවර්තන සකසනයකට දත්ත පරිවර්තනය කිරීමේ වේලාව ආධිපත්‍යය අනුව විශාල දත්ත මත මන්දගාමීව ධාවනය කළ හැකිය ( convert_to_tensor"ප්‍රොෆයිලර්" හි බලන්න )
• දුම්රිය ලූප සහ වේගය ආදාන දත්ත සකසනයෙහි වේගය වෙනස් වේ.

බෙන්ච්මාර්ක්ස් : අඹරන ලද මස්. - වචන ලේඛනය - එක්සෙල් පැතුරුම්පත

පාරිභාෂිතය :

• % රහිත සංඛ්‍යා සියල්ල තත්පර වේ
• % ලෙස ගණනය කර ඇත (1 - longer_time / shorter_time)*100; තාර්කිකත්වය: එක් සාධකයක් අනෙකට වඩා වේගවත් වන්නේ කුමන සාධකය නිසාද යන්න අපි උනන්දු වෙමු ; shorter / longerඇත්ත වශයෙන්ම රේඛීය නොවන සම්බන්ධතාවයක් වන අතර එය සෘජු සංසන්දනය සඳහා ප්‍රයෝජනවත් නොවේ
• % සං sign ා නිර්ණය:
  • TF2 එදිරිව TF1: +TF2 වේගවත් නම්
  • GvE (ප්‍රස්ථාර එදිරිව ඊජර්): +ප්‍රස්ථාරය වේගවත් නම්
• TF2 = TensorFlow 2.0.0 + Keras 2.3.1; TF1 = TensorFlow 1.14.0 + Keras 2.2.5

පැතිකඩ :

පැතිකඩ - පැහැදිලි කිරීම : ස්පයිඩර් 3.3.6 IDE පැතිකඩ.

• සමහර කාර්යයන් අනෙක් අයගේ කූඩු වල පුනරාවර්තනය වේ; එබැවින්, "දත්ත සැකසුම්" සහ "පුහුණු" කාර්යයන් අතර නිශ්චිත වෙන්වීම සොයා ගැනීම දුෂ්කර ය, එබැවින් අතිච්ඡාදනය වනු ඇත - අවසාන ප්‍රති .ලයෙන් උච්චාරණය කළ පරිදි.

• % සංඛ්‍යා ගණනය කරන ලද wrt ධාවන කාලය us ණ ගොඩනැගීමේ කාලය

• 1 හෝ 2 වතාවක් හැඳින්වූ සියලුම (අද්විතීය) ධාවන වේලාවන් සාරාංශ කිරීමෙන් ගණනය කළ කාලය ගොඩනඟන්න
• පුනරාවර්තන # හා සමාන # වාර ගණනක් සහ ඒවායේ සමහර කැදලි ධාවන වේලාවන් ලෙස හැඳින්වෙන සියලුම (අද්විතීය) ධාවන වේලාවන් සාරාංශ කිරීමෙන් දුම්රිය කාලය ගණනය කෙරේ.
• කාර්යයන් ඒවායේ මුල් නම් අනුව _func = funcපැතිකඩ කර ඇත , අවාසනාවකට (එනම් පැතිකඩ ලෙස func), එය ගොඩනැගීමේ කාලය සමඟ මිශ්‍ර වේ - එබැවින් එය බැහැර කිරීමේ අවශ්‍යතාවය

පරිසරය පරීක්ෂා කිරීම :

• අවම w / අවම පසුබිම් කාර්යයන් ක්‍රියාත්මක වන කේතය ක්‍රියාත්මක කිරීම
• දක්වන GPU w / ඒ අනුකරණ කිහිපයක් කාලය අනුකරණ පෙර, යෝජනා ලෙස "උණුසුම්" විය මෙම පශ්චාත්
• CUDA 10.0.130, cuDNN 7.6.0, TensorFlow 1.14.0, සහ TensorFlow 2.0.0 ප්‍රභවයෙන් සාදන ලද අතර ඇනකොන්ඩා
• පයිතන් 3.7.4, ස්පයිඩර් 3.3.6 IDE
• GTX 1070, Windows 10, 24GB DDR4 2.4-MHz RAM, i7-7700HQ 2.8-GHz CPU

ක්‍රමවේදය :

• 'කුඩා', 'මධ්‍යම', සහ 'විශාල' ආකෘතිය සහ දත්ත ප්‍රමාණ
• ආදාන දත්ත ප්‍රමාණයෙන් ස්වාධීනව එක් එක් ආකෘති ප්‍රමාණය සඳහා පරාමිති # නිවැරදි කරන්න
• "විශාල" ආකෘතියට වැඩි පරාමිතීන් සහ ස්ථර ඇත
• "විශාල" දත්ත වලට දිගු අනුක්‍රමයක් ඇත, නමුත් සමාන batch_sizeසහnum_channels
• ආකෘති භාවිතා කරන්නේ Conv1D, Dense'ඉගෙන ගත හැකි' ස්ථර පමණි; ටී.එෆ්-අනුවාදයේ එක් එක් ආර්.එම්.එන්. වෙනස්කම්
• මාදිලිය සහ ප්‍රශස්තිකරණ ප්‍රස්ථාර ගොඩනැගීම මඟ හැරීම සඳහා සෑම විටම මිණුම් සලකුණු ලූපයෙන් පිටත එක් දුම්රිය සුදුසුකමක් ධාවනය කරන්න
• විරල දත්ත (උදා layers.Embedding()) හෝ විරල ඉලක්ක භාවිතා නොකිරීම (උදාSparseCategoricalCrossEntropy()

සීමාවන් : “සම්පූර්ණ” පිළිතුරක් මගින් හැකි සෑම දුම්රිය පුඩුවක්ම සහ නැවත ක්‍රියාකරවන්නෙකුම පැහැදිලි කරනු ඇත, නමුත් එය නිසැකවම මගේ කාල හැකියාවෙන්, නොපැමිණෙන වැටුපෙන් හෝ සාමාන්‍ය අවශ්‍යතාවයෙන් ඔබ්බට ය. ප්‍රති results ල ක්‍රමවේදය තරම්ම හොඳය - විවෘත මනසකින් අර්ථ නිරූපණය කරන්න.

කේතය :

import numpy as np
import tensorflow as tf
import random
from termcolor import cprint
from time import time

from tensorflow.keras.layers import Input, Dense, Conv1D
from tensorflow.keras.layers import Dropout, GlobalAveragePooling1D
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
import tensorflow.keras.backend as K
#from keras.layers import Input, Dense, Conv1D
#from keras.layers import Dropout, GlobalAveragePooling1D
#from keras.models import Model 
#from keras.optimizers import Adam
#import keras.backend as K

#tf.compat.v1.disable_eager_execution()
#tf.enable_eager_execution()

def reset_seeds(reset_graph_with_backend=None, verbose=1):
    if reset_graph_with_backend is not None:
        K = reset_graph_with_backend
        K.clear_session()
        tf.compat.v1.reset_default_graph()
        if verbose:
            print("KERAS AND TENSORFLOW GRAPHS RESET")

    np.random.seed(1)
    random.seed(2)
    if tf.__version__[0] == '2':
        tf.random.set_seed(3)
    else:
        tf.set_random_seed(3)
    if verbose:
        print("RANDOM SEEDS RESET")

print("TF version: {}".format(tf.__version__))
reset_seeds()

def timeit(func, iterations, *args, _verbose=0, **kwargs):
    t0 = time()
    for _ in range(iterations):
        func(*args, **kwargs)
        print(end='.'*int(_verbose))
    print("Time/iter: %.4f sec" % ((time() - t0) / iterations))

def make_model_small(batch_shape):
    ipt   = Input(batch_shape=batch_shape)
    x     = Conv1D(128, 40, strides=4, padding='same')(ipt)
    x     = GlobalAveragePooling1D()(x)
    x     = Dropout(0.5)(x)
    x     = Dense(64, activation='relu')(x)
    out   = Dense(1,  activation='sigmoid')(x)
    model = Model(ipt, out)
    model.compile(Adam(lr=1e-4), 'binary_crossentropy')
    return model

def make_model_medium(batch_shape):
    ipt = Input(batch_shape=batch_shape)
    x = ipt
    for filters in [64, 128, 256, 256, 128, 64]:
        x  = Conv1D(filters, 20, strides=1, padding='valid')(x)
    x     = GlobalAveragePooling1D()(x)
    x     = Dense(256, activation='relu')(x)
    x     = Dropout(0.5)(x)
    x     = Dense(128, activation='relu')(x)
    x     = Dense(64,  activation='relu')(x)
    out   = Dense(1,   activation='sigmoid')(x)
    model = Model(ipt, out)
    model.compile(Adam(lr=1e-4), 'binary_crossentropy')
    return model

def make_model_large(batch_shape):
    ipt   = Input(batch_shape=batch_shape)
    x     = Conv1D(64,  400, strides=4, padding='valid')(ipt)
    x     = Conv1D(128, 200, strides=1, padding='valid')(x)
    for _ in range(40):
        x = Conv1D(256,  12, strides=1, padding='same')(x)
    x     = Conv1D(512,  20, strides=2, padding='valid')(x)
    x     = Conv1D(1028, 10, strides=2, padding='valid')(x)
    x     = Conv1D(256,   1, strides=1, padding='valid')(x)
    x     = GlobalAveragePooling1D()(x)
    x     = Dense(256, activation='relu')(x)
    x     = Dropout(0.5)(x)
    x     = Dense(128, activation='relu')(x)
    x     = Dense(64,  activation='relu')(x)    
    out   = Dense(1,   activation='sigmoid')(x)
    model = Model(ipt, out)
    model.compile(Adam(lr=1e-4), 'binary_crossentropy')
    return model

def make_data(batch_shape):
    return np.random.randn(*batch_shape), \
           np.random.randint(0, 2, (batch_shape[0], 1))

def make_data_tf(batch_shape, n_batches, iters):
    data = np.random.randn(n_batches, *batch_shape),
    trgt = np.random.randint(0, 2, (n_batches, batch_shape[0], 1))
    return tf.data.Dataset.from_tensor_slices((data, trgt))#.repeat(iters)

batch_shape_small  = (32, 140,   30)
batch_shape_medium = (32, 1400,  30)
batch_shape_large  = (32, 14000, 30)

batch_shapes = batch_shape_small, batch_shape_medium, batch_shape_large
make_model_fns = make_model_small, make_model_medium, make_model_large
iterations = [200, 100, 50]
shape_names = ["Small data",  "Medium data",  "Large data"]
model_names = ["Small model", "Medium model", "Large model"]

def test_all(fit=False, tf_dataset=False):
    for model_fn, model_name, iters in zip(make_model_fns, model_names, iterations):
        for batch_shape, shape_name in zip(batch_shapes, shape_names):
            if (model_fn is make_model_large) and (batch_shape == batch_shape_small):
                continue
            reset_seeds(reset_graph_with_backend=K)
            if tf_dataset:
                data = make_data_tf(batch_shape, iters, iters)
            else:
                data = make_data(batch_shape)
            model = model_fn(batch_shape)

            if fit:
                if tf_dataset:
                    model.train_on_batch(data.take(1))
                    t0 = time()
                    model.fit(data, steps_per_epoch=iters)
                    print("Time/iter: %.4f sec" % ((time() - t0) / iters))
                else:
                    model.train_on_batch(*data)
                    timeit(model.fit, iters, *data, _verbose=1, verbose=0)
            else:
                model.train_on_batch(*data)
                timeit(model.train_on_batch, iters, *data, _verbose=1)
            cprint(">> {}, {} done <<\n".format(model_name, shape_name), 'blue')
            del model

test_all(fit=True, tf_dataset=False)