ذخیره و بارگذاری مدل در پایتون

ذخیره و بارگذاری مدل‌ها در یادگیری عمیق یک اصل مهم است با توجه به این که فرآیند آموزش مدل یک پروسه زمان‌بر می‌باشد.ذخیره و بارگذاری مدل در پایتون را در ادامه شرح و آموزش می‌دهیم.

در این مطلب به دنبال روشی برای ذخیره و بارگذاری مدل هستیم.این آموزش را با کمک کتابخانه کراس ادامه می‌دهیم.این کتابخانه امکان ذخیره نمودن وزن‌های مدل را نیز دارا می‌باشد.

وزن مدل در فرمت HDF5 ذخیره می شود. HDF5 یک قالب شبکه ای است که برای ذخیره آرایه های چند بعدی اعداد ایده آل است.

ساختار مدل را می توان با استفاده از دو فرمت مختلف JSON و YAML توصیف و ذخیره کرد.

در این مطلب دو نمونه از ذخیره و بارگذاری مدل در فایل را بررسی می کنیم:

• ذخیره مدل در JSON.
• ذخیره مدل در YAML.

هر دو روش ذخیره و بارگذاری وزن مدل را در فایل های فرمت HDF5 نشان می دهند.

در ادامه از این دیتاست استفاده می‌کنیم.

توجه: برای ذخیره مدل ها باید کتابخانه h5py را نصب کرده باشید. به صورت زیر می توانید آن را به راحتی نصب کنید:

sudo pip install h5py

 ذخیره مدل شبکه عصبی با JSON :

کراس توانایی توصیف هر مدلی را با استفاده از فرمت JSON با تابع() to_json فراهم می کند. با استفاده از این متد ذخیره و بعداً از طریق تابع ()model_from_json بارگذاری می‌شود که یک مدل جدید از مشخصات JSON ایجاد می کند.

وزن‌ها مستقیماً از مدل با استفاده از تابع () save_weights ذخیره می‌شوند و بعداً با استفاده از تابع ()load_weights بارگذاری می‌شوند.

مثال زیر یک مدل ساده را در مجموعه داده Pima Indians آموزش و ارزیابی می‎کند. سپس مدل به فرمت JSON تبدیل شده و در پوشه محلی  model.json نوشته می‌شود. وزن های شبکه model.h5 در فهرست محلی نوشته می‌شود.

# MLP for Pima Indians Dataset Serialize to JSON and HDF5
from keras.models import Sequential
from keras.layers import Dense
from keras.models import model_from_json
import numpy
import os
# fix random seed for reproducibility
numpy.random.seed(7)
# load pima indians dataset
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]
# create model
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# Compile model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# Fit the model
model.fit(X, Y, epochs=150, batch_size=10, verbose=0)
# evaluate the model
scores = model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))

# serialize model to JSON
model_json = model.to_json()
with open("model.json", "w") as json_file:
    json_file.write(model_json)
# serialize weights to HDF5
model.save_weights("model.h5")
print("Saved model to disk")

# later...

# load json and create model
json_file = open('model.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights("model.h5")
print("Loaded model from disk")

# evaluate loaded model on test data
loaded_model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
score = loaded_model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (loaded_model.metrics_names[1], score[1]*100))

توجه: نتایج شما ممکن است با توجه به ماهیت تصادفی الگوریتم یا روش ارزیابی یا در دقت عددی متفاوت باشد. مثال را چند بار اجرا کنید و میانگین نتیجه را مقایسه کنید.

اجرای این مثال خروجی زیر را ارائه می دهد.

acc: 78.78%
Saved model to disk
Loaded model from disk
acc: 78.78%

فرمت JSON مدل به شکل زیر است:

{  
   "class_name":"Sequential",
   "config":{  
      "name":"sequential_1",
      "layers":[  
         {  
            "class_name":"Dense",
            "config":{  
               "name":"dense_1",
               "trainable":true,
               "batch_input_shape":[  
                  null,
                  8
               ],
               "dtype":"float32",
               "units":12,
               "activation":"relu",
               "use_bias":true,
               "kernel_initializer":{  
                  "class_name":"VarianceScaling",
                  "config":{  
                     "scale":1.0,
                     "mode":"fan_avg",
                     "distribution":"uniform",
                     "seed":null
                  }
               },
               "bias_initializer":{  
                  "class_name":"Zeros",
                  "config":{  

                  }
               },
               "kernel_regularizer":null,
               "bias_regularizer":null,
               "activity_regularizer":null,
               "kernel_constraint":null,
               "bias_constraint":null
            }
         },
         {  
            "class_name":"Dense",
            "config":{  
               "name":"dense_2",
               "trainable":true,
               "dtype":"float32",
               "units":8,
               "activation":"relu",
               "use_bias":true,
               "kernel_initializer":{  
                  "class_name":"VarianceScaling",
                  "config":{  
                     "scale":1.0,
                     "mode":"fan_avg",
                     "distribution":"uniform",
                     "seed":null
                  }
               },
               "bias_initializer":{  
                  "class_name":"Zeros",
                  "config":{  

                  }
               },
               "kernel_regularizer":null,
               "bias_regularizer":null,
               "activity_regularizer":null,
               "kernel_constraint":null,
               "bias_constraint":null
            }
         },
         {  
            "class_name":"Dense",
            "config":{  
               "name":"dense_3",
               "trainable":true,
               "dtype":"float32",
               "units":1,
               "activation":"sigmoid",
               "use_bias":true,
               "kernel_initializer":{  
                  "class_name":"VarianceScaling",
                  "config":{  
                     "scale":1.0,
                     "mode":"fan_avg",
                     "distribution":"uniform",
                     "seed":null
                  }
               },
               "bias_initializer":{  
                  "class_name":"Zeros",
                  "config":{  

                  }
               },
               "kernel_regularizer":null,
               "bias_regularizer":null,
               "activity_regularizer":null,
               "kernel_constraint":null,
               "bias_constraint":null
            }
         }
      ]
   },
   "keras_version":"2.2.5",
   "backend":"tensorflow"
}

 ذخیره مدل شبکه عصبی با YAML:

حال مثال قبل را با استفاده از روش دوم انجام می‌دهیم.مانند قبل ایتدا به نصب کتابخانه از طریق ذستور زیر داریم:

sudo pip install PyYAML

در این مثال، مدل با استفاده از YAML توصیف می‌شود. در فایل model.yaml ذخیره می‌شود و بعداً از طریق تابع model_from_yaml در یک مدل جدید بارگذاری می‌شود.

وزن ها به مانند قبل در فرمت HDF5 و model.h5 ذخیزه میشود.

# MLP for Pima Indians Dataset serialize to YAML and HDF5
from keras.models import Sequential
from keras.layers import Dense
from keras.models import model_from_yaml
import numpy
import os
# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)
# load pima indians dataset
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]
# create model
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# Compile model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# Fit the model
model.fit(X, Y, epochs=150, batch_size=10, verbose=0)
# evaluate the model
scores = model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))

# serialize model to YAML
model_yaml = model.to_yaml()
with open("model.yaml", "w") as yaml_file:
    yaml_file.write(model_yaml)
# serialize weights to HDF5
model.save_weights("model.h5")
print("Saved model to disk")

# later...

# load YAML and create model
yaml_file = open('model.yaml', 'r')
loaded_model_yaml = yaml_file.read()
yaml_file.close()
loaded_model = model_from_yaml(loaded_model_yaml)
# load weights into new model
loaded_model.load_weights("model.h5")
print("Loaded model from disk")

# evaluate loaded model on test data
loaded_model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
score = loaded_model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (loaded_model.metrics_names[1], score[1]*100))

با اجرای مثال، خروجی زیر نمایش داده می‌شود.

acc: 78.78%
Saved model to disk
Loaded model from disk
acc: 78.78%

مدل توصیف شده در فرمت YAML به شکل زیر است:

backend: tensorflow
class_name: Sequential
config:
  layers:
  - class_name: Dense
    config:
      activation: relu
      activity_regularizer: null
      batch_input_shape: !!python/tuple
      - null
      - 8
      bias_constraint: null
      bias_initializer:
        class_name: Zeros
        config: {}
      bias_regularizer: null
      dtype: float32
      kernel_constraint: null
      kernel_initializer:
        class_name: VarianceScaling
        config:
          distribution: uniform
          mode: fan_avg
          scale: 1.0
          seed: null
      kernel_regularizer: null
      name: dense_1
      trainable: true
      units: 12
      use_bias: true
  - class_name: Dense
    config:
      activation: relu
      activity_regularizer: null
      bias_constraint: null
      bias_initializer:
        class_name: Zeros
        config: {}
      bias_regularizer: null
      dtype: float32
      kernel_constraint: null
      kernel_initializer:
        class_name: VarianceScaling
        config:
          distribution: uniform
          mode: fan_avg
          scale: 1.0
          seed: null
      kernel_regularizer: null
      name: dense_2
      trainable: true
      units: 8
      use_bias: true
  - class_name: Dense
    config:
      activation: sigmoid
      activity_regularizer: null
      bias_constraint: null
      bias_initializer:
        class_name: Zeros
        config: {}
      bias_regularizer: null
      dtype: float32
      kernel_constraint: null
      kernel_initializer:
        class_name: VarianceScaling
        config:
          distribution: uniform
          mode: fan_avg
          scale: 1.0
          seed: null
      kernel_regularizer: null
      name: dense_3
      trainable: true
      units: 1
      use_bias: true
  name: sequential_1
keras_version: 2.2.5

ذخیره وزن‌ها و معماری مدل به صورت همزمان:

کراس همچنین از یک رابط ساده‌تر برای ذخیره وزن مدل و معماری مدل با هم در یک فایل H5 پشتیبانی می‌کند.

این بدان معناست که ما می‌توانیم مدل را مستقیماً بارگذاری و استفاده کنیم، بدون اینکه مجبور باشیم آن را مانند مثال‌های بالا کامپایل کنیم.

شما می توانید مدل خود را با فراخوانی تابع ()save روی مدل و تعیین نام فایل ذخیره کنید.

مثال زیر این  حالت را با نصب یک مدل، ارزیابی آن و ذخیره آن در فایل model.h5 نشان می دهد.

ذخیره و بارگذاری مدل در پایتون با کمک کراس:

نحوه ذخیره مدل در کراس:

# MLP for Pima Indians Dataset saved to single file
from numpy import loadtxt
from keras.models import Sequential
from keras.layers import Dense
# load pima indians dataset
dataset = loadtxt("pima-indians-diabetes.csv", delimiter=",")
# split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]
# define model
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# compile model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# Fit the model
model.fit(X, Y, epochs=150, batch_size=10, verbose=0)
# evaluate the model
scores = model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
# save model and architecture to single file
model.save("model.h5")
print("Saved model to disk")

توجه: نتایج شما ممکن است با توجه به ماهیت تصادفی الگوریتم یا روش ارزیابی متفاوت باشد. مثال را چند بار اجرا کنید و میانگین نتیجه را مقایسه کنید.

acc: 77.73%
Saved model to disk

بعداً می توانیم این مدل را از فایل بارگذاری کنیم و از آن استفاده کنیم.

نحوه بارگذاری یک مدل کراس:

سپس مدل ذخیره شده را می توانید با فراخوانی تابع load_model و ارسال نام فایل بارگیری کنید.  این تابع مدل را با همان معماری و وزن برمی گرداند.

در این مورد، مدل را بارگذاری می‌کنیم، معماری را خلاصه می‌کنیم و آن را روی همان مجموعه داده ارزیابی می‌کنیم تا تأیید کنیم وزن‌ها و معماری یکسان هستند.

# load and evaluate a saved model
from numpy import loadtxt
from keras.models import load_model

# load model
model = load_model('model.h5')
# summarize model.
model.summary()
# load dataset
dataset = loadtxt("pima-indians-diabetes.csv", delimiter=",")
# split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]
# evaluate the model
score = model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], score[1]*100))

مدل به همان  مقدار دقت می رسد که در این مورد 77٪ است.

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_1 (Dense)              (None, 12)                108       
_________________________________________________________________
dense_2 (Dense)              (None, 8)                 104       
_________________________________________________________________
dense_3 (Dense)              (None, 1)                 9         
=================================================================
Total params: 221
Trainable params: 221
Non-trainable params: 0
_________________________________________________________________

acc: 77.73%