Följande artikel hjälper dig: Hur kondenserar man djupinlärningsmodeller för edge-enheter med hjälp av kvantisering?
Kvantisering är processen att distribuera modeller för djupinlärning eller maskininlärning på avancerade enheter som smartphones, smarta tv-apparater, smarta klockor och många fler. Men att distribuera den enorma modellen på kantenheterna är inte möjligt på grund av minnesbegränsningarna och det är här som kvantiseringsprocessen används. Det kondenserar de enorma modellerna för att kunna installeras på kantenheterna felfritt. Den här artikeln ger en kort översikt över hur man kondenserar enorma Tensorflow-modeller till lätta modeller med TensorFlow lite och Tensorflow Model Optimization.
Innehållsförteckning
- Introduktion till kvantisering
- Olika typer av kvantiseringstekniker
- Bygga en modell för djupinlärning från grunden
- Implementering av kvantiseringsteknik efter utbildning
- Medveten implementering av modellkvantiseringsteknik
- Jämför originalmodellen och kvantiserad modellförutsägelse
- Sammanfattning
Introduktion till kvantisering
Kvantisering med avseende på djupinlärning är processen att approximera neurala nätverksvikter som erhålls efter utbredning genom de olika lagren till närmaste heltalsvärde eller i korta lägre bittal. Denna konvertering underlättar för alla tunga djupinlärningsmodeller att enkelt distribueras på edge-enheter sömlöst eftersom den tunga modellen nu kommer att kondenseras till lättare modeller och modellresultaten kan visualiseras på edge-enheterna.
Letar du efter ett komplett förråd av Python-bibliotek som används inom datavetenskap, kolla här.
Diskrepansen förknippad med att köra tyngre djupinlärningsmodeller på lägre processorenheter som smarta enheter övervinns genom kvantisering där modellens totala minnesförbrukning kommer att minskas till nästan en tredjedel eller till en fjärdedel av den ursprungliga Tensorflow-modellens vikt.
Låt oss nu se de olika typerna av kvantiseringstekniker.
Olika typer av kvantiseringstekniker
Det finns huvudsakligen två typer av kvantiseringstekniker möjliga för tyngre modeller för djupinlärning. Dom är:-
- Kvantisering efter träning
- Medveten träningskvantisering
Båda kvantiseringsteknikerna fungerar under överinseende av TensorFlow-lite-modulen som används för att kondensera de tyngre modellerna och pressa dem till kanten av enheter.
Kvantisering efter träning
I kvantiseringstekniken efter träning, kondenseras en tyngre TensorFlow-modell till en mindre med Tensorflow-lite-modulen och i kantenheterna kommer den troligen att användas som små Tensorflow-modeller. Men problemet med denna kvantiseringsteknik är att endast minnesupptaget för modellen på kantenheten komprimeras men modellen på kantenheterna kan inte användas för någon av parametrarna och till och med modellens prestanda om den jämförs på basis av noggrannheten skulle vara mindre jämfört med Tensorflow-modellen i testfasen. Så denna kvantiseringsteknik skulle ge en opålitlig modell i produktionen som visar tecken på dålig prestanda.
Medveten träningskvantisering
Den medvetna träningskvantiseringstekniken används för att övervinna begränsningarna hos efterträningstekniken där denna teknik är ansvarig för att mogna den tunga TensorFlow-modellen under utveckling för att gå vidare genom en kvantiserad modell med väldefinierade parametrar och ge en finjusterad kvantiserad modell som kan skickas vidare till Tensorflow-lite-modulen för att finjustera och erhålla ett komplett lättare paket av Tensorflow-modellen utvecklad redo att användas på kantenheterna.
Bygga en Deep Learning-modell från grunden
I denna fallstudie används Fashion MNIST-datauppsättningen för att bygga en Tensorflow-modell. Denna datauppsättning har 10 klasser av kläder att klassificera. Så låt oss titta på hur man bygger en modell för djupinlärning för att klassificera de 10 klasserna som finns i datamängden.
De första stegen börjar med att importera de nödvändiga TensorFlow-biblioteken och skaffa datamängden. Denna datauppsättning är lätt tillgänglig i Tensorflow-modulen och denna datauppsättning måste förbehandlas genom att dela upp datauppsättningen på lämpligt sätt i tåg och test och även utföra nödvändig omformning och kodning. När en fullständig förbearbetad data är tillgänglig kan modellbyggnaden tas upp med det erforderliga antalet lager och kompileras med lämpliga förlustfunktioner och mätvärden. Med allt detta i handen kan modellen slutligen monteras för det antal iterationer som krävs.
importera tensorflow som tf importera numpy som np importera matplotlib.pyplot som plt från tensorflow.keras.layers import Flatten,Dense,Dropout,Conv2D,MaxPooling2D från tensorflow.keras.models import Sekventiell från tensorflow.keras.utils import to_categorical inline från %matlib tensorflow.keras.datasets import fashion_mnist (X_train,Y_train),(X_test,Y_test)=fashion_mnist.load_data() plt.figure(figsize=(15,5)) för i in range(10): plt.subplot(2, 5,i+1) plt.imshow(X_train[i]) plt.axis(‘off’) plt.show()
Så nu vi har validerat uppdelningen av data framgångsrikt kan vi fortsätta med modellbyggandet.
model1=Sequential() model1.add(Conv2D(32,kernel_size=2,input_shape=(28,28,1),activation=’relu’)) model1.add(MaxPooling2D(pool_size=(2,2))) modell1 .add(Conv2D(16,kernel_size=2,activation=’relu’)) model1.add(MaxPooling2D(pool_size=(2,2))) model1.add(Flatten()) model1.add(Dense(125,activation) =’relu’)) model1.add(Dense(10,activation=’softmax’)) model1.summary()
model1.compile(loss=”sparse_categorical_crossentropy”,optimizer=”adam”,metrics=[‘accuracy’]) model1_fit_res=model1.fit(X_train,Y_train,epochs=10,validation_data=(X_test,Y_test))
print(‘Model träningsförlust: {} och träningsnoggrannheten är: {}’.format(model1.evaluate(X_train,Y_train)[0],model1.evaluate(X_train,Y_train)[1]))
print(‘Förlust av modelltestning: {} och testnoggrannheten är: {}’.format(model1.evaluate(X_test,Y_test)[0],model1.evaluate(X_test,Y_test)[1]))
Låt oss nu spara denna Tensorflow-modell eftersom den kan användas för kvantisering senare.
model1.save(‘TF-Model’)
Låt oss nu se hur man implementerar kvantiseringsteknikerna med den sparade modellen.
Kvantisering efter träning
Innan vi utför kvantiseringen, låt oss observera den totala minnesuppsättningen av hela Tensorflödet i arbetsmiljön.
tf_lite_conv=tf.lite.TFLiteConverter.from_saved_model(‘/content/drive/MyDrive/Colab notebooks/Quantization in neural network]/TF-Model’) tf_lite_mod=tf_lite_conv.convert() print(‘Minne på TF-modellen är ‘,len(tf_lite_mod))
Utföra kvantisering efter träning
Denna kvantiseringsteknik tas upp genom att använda standardoptimeringstekniken för TensorFlow lite-modulen och de erhållna standardoptimeringarna kommer att konverteras till en kvantiserad modell med hjälp av konverteringsfunktionen med denna modell. Vi kan validera minnesupptaget i den kvantiserade modellen med efterträning optimering.
post_tr_conv=tf.lite.TFLiteConverter.from_saved_model(“/content/drive/MyDrive/Colab notebooks/Quantization in neural network]/TF-Model”) post_tr_conv.optimizations = [tf.lite.Optimize.DEFAULT]tflite_quant_model = post_tr_conv.convert() print(‘Minne av den kvantiserade TF-modellen på disken är ‘,len(tflite_quant_model))
Så här kan vi tydligt observera skillnaderna i minnesuppsättning av den ursprungliga Tensorflow-modellen och den kvantiserade modellen där vi tydligt kan se att kvantiseringstekniken har kondenserat den ursprungliga Tensorflow-modellen till en tredjedel av den ursprungliga minnesuppsättningen. Men som tidigare nämnts är denna teknik mer lämpad endast för att komprimera modellen och validera minneskapaciteten. Så för bättre utvärdering av modellens prestanda på edge-enheter används Aware Training Quantization-tekniken.
Medveten implementering av modellkvantiseringsteknik
Denna kvantiseringsteknik är en av de mest effektiva kvantiseringsteknikerna eftersom den inte bara kondenserar de tyngre modellerna utan också ger tillförlitliga modellprestandaparametrar och visar också betydande prestanda när den kondenserade TensorFlow-modellen används i kantenheterna. Låt oss se stegen som är involverade i implementeringen av denna kvantiseringsteknik.
!pip installera tensorflow-model-optimization importera tensorflow_model_optimization som tfmod_opt quant_aw_model=tfmod_opt.quantization.keras.quantize_model quant_aw_model_fit=quant_aw_model(model1)
Så nu när vi har skapat en kvantifierad modell måste vi återigen kompilera modellen med lämpliga förlustfunktioner och mått och senare anpassa samma modell med de delade data.
quant_aw_model_fit.compile(loss=”sparse_categorical_crossentropy”,metrics=[‘accuracy’],optimizer=”adam”) quant_aw_model_fit.summary()
quant_mod_res=quant_aw_model_fit.fit(X_train,Y_train,epochs=10,validation_data=(X_test,Y_test))
Utvärdera de kvantiserade modellens parametrar
print(‘Quantized Model training loss : {} och träningsnoggrannheten är: {}’. format(quant_aw_model_fit.evaluate(X_train,Y_train)[0],quant_aw_model_fit.evaluate(X_train,Y_train)[1]))
print(‘Quantized Model testing loss : {} och testnoggrannheten är: {}’. format(quant_aw_model_fit.evaluate(X_test,Y_test)[0],quant_aw_model_fit.evaluate(X_test,Y_test)[1]))
Låt oss nu validera minneskapaciteten för den kvantiserade modellen och den ursprungliga Tensorflow-modellen med hjälp av några TensorFlow lite-paket.
print(‘Minne av TF-modellen på disken är ‘,len(tf_lite_mod)) print() print(‘Minnesallokering av Quantization Aware Model’,len(tflite_qaware_model))
Så här kan vi tydligt se skillnaden mellan de kvantiserade modellbitarna och de ursprungliga TensorFlow-modellbitarna när det gäller minnesförbrukning. Eftersom vi också utvärderade vissa parametrar för både den ursprungliga Tensorflow-modellen och den kvantiserade modellen och någon nedgång i prestandan inte observerades. För bättre jämförelse låt oss försöka jämföra klassificeringsförmågan hos både Tensorflow och Quantized-modellen för att korrekt klassificera de olika typerna av kläder.
Jämför originalmodellen och kvantiserad modellförutsägelse
y_pred=model1.predict(X_test) figure = plt.figure(figsize=(15,5)) för i, indexera i enumerate(np.random.choice(X_test.shape)[0]storlek=15, ersätt=False)): ax = figur.add_subplot(3, 5, i + 1, xticks=[]yticks=[]) ax.imshow(np.squeeze(X_test[index])) predict_index=np.argmax(y_pred[index]) true_index=Y_test[index]ax.set_title(“{} ({})”.format(etiketter[predict_index]etiketter[true_index]), color=(“grön” om predict_index == true_index annars “röd”))
Eftersom vi har visualiserat förmågan hos den ursprungliga TensorFlow-modellen att klassificera kläderna, låt oss försöka validera om det finns några felklassificeringar av den kvantiserade modellen som skulle distribueras till produktion i kantenheter.
y_pred_quant_aw=quant_aw_model_fit.predict(X_test) figur = plt.figure(figsize=(15,5)) för i, indexera i enumerate(np.random.choice(X_test.shape)[0]storlek=15, ersätt=False)): ax = figur.add_subplot(3, 5, i + 1, xticks=[]yticks=[]) ax.imshow(np.squeeze(X_test[index])) predict_index=np.argmax(y_pred[index]) true_index=Y_test[index]ax.set_title(“{} ({})”.format(etiketter[predict_index]etiketter[true_index]), color=(“grön” om predict_index == true_index annars “röd”))
Sammanfattning
Så som tydligt nämnts i den här artikeln är det här hur olika kvantiseringstekniker används för att kondensera enorma djupinlärningsmodeller till mindre bitar genom att minska den totala minnesuppsättningen av läget som utvecklats till en tredjedel eller en fjärdedel av modellens totala minnesuppsättning och distribuera det på kantenheter som relativt sett skulle ha lägre minne. Så om kvantiseringstekniken tas upp kan alla komplexa djupinlärningsmodeller kondenseras till lättare modeller och distribueras på edge-enheter.
