keras - transfer learning / fine tuning

tflite 에서 weight만 빼서 거기서 부터 학습 시키면 그게 fine tune / transfer learning(전이학습)이 되는건가?

The conversion from a TensorFlow SaveModel or tf.keras H5 model to .tflite is an irreversible process. Specifically, the original model topology is optimized during the compilation by the TFLite converter, which leads to some loss of information. Also, the original tf.keras model's loss and optimizer configurations are discarded, because those aren't required for inference. However, the .tflite file still contains some information that can help you restore the original trained model. Most importantly, the weight values are available, although they might be quantized, which could lead to some loss in precision. The code example below shows you how to read weight values from a .tflite file after it's created from a simple trained tf.keras.Model. import numpy as np import tensorflow as tf # First, create and train a dummy model for demonstration purposes. model = tf.keras.Sequential([     tf.keras.layers.Dense(10, input_shape=[5], activation="relu"),     tf.keras.layers.Dense(1, activation="sigmoid")]) model.compile(loss="binary_crossentropy", optimizer="sgd") xs = np.ones([8, 5]) ys = np.zeros([8, 1]) model.fit(xs, ys, epochs=1) # Convert it to a TFLite model file. converter = tf.lite.TFLiteConverter.from_keras_model(model) tflite_model = converter.convert() open("converted.tflite", "wb").write(tflite_model) # Use `tf.lite.Interpreter` to load the written .tflite back from the file system. interpreter = tf.lite.Interpreter(model_path="converted.tflite") all_tensor_details = interpreter.get_tensor_details() interpreter.allocate_tensors() for tensor_item in all_tensor_details:   print("Weight %s:" % tensor_item["name"])   print(interpreter.tensor(tensor_item["index"])())

[링크 : https://stackoverflow.com/questions/59559289/is-there-any-way-to-convert-a-tensorflow-lite-tflite-file-back-to-a-keras-fil]

 

읽어오든.. tf.keras.application.MobileNetV2 해서 만들던 weight의 유무를 제외하면 동일하게 불러오는건가 보다.

# Create the base model from the pre-trained model MobileNet V2 IMG_SHAPE = IMG_SIZE + (3,) base_model = tf.keras.applications.MobileNetV2(input_shape=IMG_SHAPE,                                                include_top=False,                                                weights='imagenet') #or load your own #base_model= tf.saved_model.load("./pretrained_models/ssd_mobilenet_v2_320x320_coco17_tpu-8/saved_model")

[링크 : https://www.aranacorp.com/en/training-a-tensorflow2-model-with-keras/]

 

다시 찾아보니 keras쪽 표현으로

transfer-learning은 기존의 값을 변화시키지 않고 추가 레이어에 학습시키는 것 같고

The typical transfer-learning workflow This leads us to how a typical transfer learning workflow can be implemented in Keras: Instantiate a base model and load pre-trained weights into it. Freeze all layers in the base model by setting trainable = False. Create a new model on top of the output of one (or several) layers from the base model. Train your new model on your new dataset. Note that an alternative, more lightweight workflow could also be: Instantiate a base model and load pre-trained weights into it. Run your new dataset through it and record the output of one (or several) layers from the base model. This is called feature extraction. Use that output as input data for a new, smaller model. First, instantiate a base model with pre-trained weights. base_model = keras.applications.Xception(     weights='imagenet',  # Load weights pre-trained on ImageNet.     input_shape=(150, 150, 3),     include_top=False)  # Do not include the ImageNet classifier at the top. Then, freeze the base model. base_model.trainable = False Create a new model on top. inputs = keras.Input(shape=(150, 150, 3)) # We make sure that the base_model is running in inference mode here, # by passing `training=False`. This is important for fine-tuning, as you will # learn in a few paragraphs. x = base_model(inputs, training=False) # Convert features of shape `base_model.output_shape[1:]` to vectors x = keras.layers.GlobalAveragePooling2D()(x) # A Dense classifier with a single unit (binary classification) outputs = keras.layers.Dense(1)(x) model = keras.Model(inputs, outputs) Train the model on new data. model.compile(optimizer=keras.optimizers.Adam(),               loss=keras.losses.BinaryCrossentropy(from_logits=True),               metrics=[keras.metrics.BinaryAccuracy()]) model.fit(new_dataset, epochs=20, callbacks=..., validation_data=...)

 

fine tuning은 모델 자체의 가중치를 변경시킬수 있도록 해서, 천천히 학습 시키는 것 같다.

Fine-tuning Once your model has converged on the new data, you can try to unfreeze all or part of the base model and retrain the whole model end-to-end with a very low learning rate. This is an optional last step that can potentially give you incremental improvements. It could also potentially lead to quick overfitting – keep that in mind. It is critical to only do this step after the model with frozen layers has been trained to convergence. If you mix randomly-initialized trainable layers with trainable layers that hold pre-trained features, the randomly-initialized layers will cause very large gradient updates during training, which will destroy your pre-trained features. It's also critical to use a very low learning rate at this stage, because you are training a much larger model than in the first round of training, on a dataset that is typically very small. As a result, you are at risk of overfitting very quickly if you apply large weight updates. Here, you only want to readapt the pretrained weights in an incremental way. This is how to implement fine-tuning of the whole base model: # Unfreeze the base model base_model.trainable = True # It's important to recompile your model after you make any changes # to the `trainable` attribute of any inner layer, so that your changes # are take into account model.compile(optimizer=keras.optimizers.Adam(1e-5),  # Very low learning rate               loss=keras.losses.BinaryCrossentropy(from_logits=True),               metrics=[keras.metrics.BinaryAccuracy()]) # Train end-to-end. Be careful to stop before you overfit! model.fit(new_dataset, epochs=10, callbacks=..., validation_data=...)

[링크 : https://keras.io/guides/transfer_learning/]

 

 

+

[링크 : https://89douner.tistory.com/270] vgg16 기준 추가학습

 

SavedModel 형식과 비교하여 H5 파일에 포함되지 않은 두 가지가 있습니다. model.add_loss() 및 model.add_metric()을 통해 추가된 외부 손실 및 메트릭은 저장되지 않습니다(SavedModel과 다름). 모델에 이러한 솔실 및 메트릭이 있고 훈련을 다시 시작하려면 모델을 로드한 후 이러한 손실을 다시 추가해야 합니다. 이는 self.add_loss() 및 self.add_metric()을 통해 레이어 내부에서 생성한 손실/메트릭에는 적용되지 않습니다. 이러한 손실 및 메트릭은 레이어가 로드되는 한 레이어의 call 메서드의 일부이기 때문에 계속 유지됩니다. 사용자 정의 레이어와 같은 사용자 정의 객체의 계산 그래프는 저장 파일에 포함되지 않습니다. 로드 시 Keras는 모델을 다시 구성하기 위해 이러한 객체의 Python 클래스/함수에 액세스해야 합니다. 사용자 정의 객체를 참고하세요.

[링크 : https://www.tensorflow.org/guide/keras/save_and_serialize?hl=ko]