{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "7PWGmGmWYqvO" }, "source": [ "Modelo de clasificación de imágenes multiple con transferencia de aprendizaje\n", "==============================================================================" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
PRECAUCIÓN 😱: El tema presentado en esta sección está clasificado como avanzado. El entendimiento de este contenido es totalmente opcional.
" ] }, { "cell_type": "markdown", "metadata": { "id": "Urew8izjYqvS" }, "source": [ "### Preparación del ambiente" ] }, { "cell_type": "markdown", "metadata": { "id": "tRGuXNxQYqvT" }, "source": [ "Intalamos las librerias necesarias" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "wwugKa2QYqvU" }, "outputs": [], "source": [ "!wget https://raw.githubusercontent.com/santiagxf/M72109/master/docs/vision/tasks/classification/code/cnn_mclass_transfer_learning.txt \\\n", " --quiet --no-clobber\n", "!pip install -r cnn_mclass_transfer_learning.txt --quiet" ] }, { "cell_type": "markdown", "metadata": { "id": "IWEnxUMBYqvV" }, "source": [ "Descargamos el conjunto de datos\n", "\n", "> **Nota:** Note que estamos descargando el conjunto de datos completo de imágenes en este ejemplo. Si quiere utilizar un conjunto de datos más chico, puede cambiar donde dice `imdb-movie-gull.zip` por `imdb-movie.zip`." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "YFbIUx1DYqvV" }, "outputs": [], "source": [ "!wget https://santiagxf.blob.core.windows.net/public/imdb-movie-genre-full.zip \\\n", " --quiet --no-clobber --directory-prefix ./Datasets/\n", "!unzip -o -qq ./Datasets/imdb-movie-genre-full.zip -d Datasets" ] }, { "cell_type": "markdown", "metadata": { "id": "vMPQvw-5Y5YA" }, "source": [ "Verifiquemos el tamaño del conjunto de datos" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "m7UR4XJwY0jP", "outputId": "b2e05e91-b5b7-4d4f-e747-e12614f1f1c6" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "36337\n" ] } ], "source": [ "!ls Datasets/SampleMoviePosters | wc -l" ] }, { "cell_type": "markdown", "metadata": { "id": "ogUVrKpvYqvW" }, "source": [ "En caso de que quiera descargar todo el conjunto de datos de imágenes puede utilizar el siguiente codigo para descargar las imagenes dadas sus URLs (aproximadamente 40K imagenes). Su uso es:\n", "\n", "```\n", "donwload_all(data)\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "YwCUrt5vYqvX" }, "outputs": [], "source": [ "import urllib\n", "\n", "def download_file(download_url, filename):\n", " try:\n", " response = urllib.request.urlopen(download_url) \n", " except urllib.error.HTTPError:\n", " return False\n", " \n", " file = open(filename, 'wb')\n", " file.write(response.read())\n", " file.close()\n", " \n", " return True\n", "\n", "def donwload_all(data):\n", " data['Downloaded'] = False\n", " \n", " from tqdm import tqdm\n", "\n", " for index, row in tqdm(data.iterrows()):\n", " data['Downloaded'][index] = download_file(row['Poster'], row['Image'])" ] }, { "cell_type": "markdown", "metadata": { "id": "CudUhXcAYqvX" }, "source": [ "### Sobre el conjunto de datos de este ejemplo" ] }, { "cell_type": "markdown", "metadata": { "id": "NADMfpG2YqvY" }, "source": [ "Este conjunto de datos proviene de [Kaggle](https://www.kaggle.com/neha1703/movie-genre-from-its-poster) y contiene carteles (posters) de películas del [sitio web de IMDB](https://www.imdb.com /). Este conjunto de datos contiene la siguiente información para cada película: \n", "\n", " - ID de IMDB\n", " - enlace de IMDB\n", " - título\n", " - puntuación de IMDB\n", " - género\n", " - un enlace para descargar el póster de la película\n", " \n", "En este conjunto de datos, cada póster de película puede pertenecer al menos a un género y puede tener como máximo 3 etiquetas asignadas. El número total de carteles ronda los 40K." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "lZCUTQrAYqvZ" }, "outputs": [], "source": [ "import pandas as pd\n", "\n", "data = pd.read_csv(\"Datasets/MovieGenre.csv\", encoding = \"ISO-8859-1\").dropna()\n", "data['Image'] = \"Datasets/SampleMoviePosters/\" + data[\"imdbId\"].astype(str) + \".jpg\"\n", "data['Genre'] = data['Genre'].apply(lambda x: x.split(\"|\"))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 357 }, "id": "dAqmpqcwYqva", "outputId": "db5960de-9a26-4507-f399-838506ae5f95" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Unnamed: 0imdbIdImdb LinkTitleIMDB ScoreGenrePosterDownloadedImage
00114709http://www.imdb.com/title/tt114709Toy Story (1995)8.3[Animation, Adventure, Comedy]https://images-na.ssl-images-amazon.com/images...TrueDatasets/SampleMoviePosters/114709.jpg
11113497http://www.imdb.com/title/tt113497Jumanji (1995)6.9[Action, Adventure, Family]https://images-na.ssl-images-amazon.com/images...TrueDatasets/SampleMoviePosters/113497.jpg
22113228http://www.imdb.com/title/tt113228Grumpier Old Men (1995)6.6[Comedy, Romance]https://images-na.ssl-images-amazon.com/images...TrueDatasets/SampleMoviePosters/113228.jpg
33114885http://www.imdb.com/title/tt114885Waiting to Exhale (1995)5.7[Comedy, Drama, Romance]https://images-na.ssl-images-amazon.com/images...TrueDatasets/SampleMoviePosters/114885.jpg
44113041http://www.imdb.com/title/tt113041Father of the Bride Part II (1995)5.9[Comedy, Family, Romance]https://images-na.ssl-images-amazon.com/images...TrueDatasets/SampleMoviePosters/113041.jpg
\n", "
" ], "text/plain": [ " Unnamed: 0 imdbId ... Downloaded Image\n", "0 0 114709 ... True Datasets/SampleMoviePosters/114709.jpg\n", "1 1 113497 ... True Datasets/SampleMoviePosters/113497.jpg\n", "2 2 113228 ... True Datasets/SampleMoviePosters/113228.jpg\n", "3 3 114885 ... True Datasets/SampleMoviePosters/114885.jpg\n", "4 4 113041 ... True Datasets/SampleMoviePosters/113041.jpg\n", "\n", "[5 rows x 9 columns]" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data.head(5)" ] }, { "cell_type": "markdown", "metadata": { "id": "_5dIadjUYqvb" }, "source": [ "Filtraremos el conjunto de datos solo por aquellas imágenes que están disponible. La columna \"Downloaded\" indica esta información." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "ZkrdmOSkYqvb" }, "outputs": [], "source": [ "images = data[data['Downloaded'] == True][\"Image\"].to_numpy()\n", "labels = data[data['Downloaded'] == True][\"Genre\"].to_numpy()" ] }, { "cell_type": "markdown", "metadata": { "id": "EQGHgr-iYqvc" }, "source": [ "## Preparación de los datos" ] }, { "cell_type": "markdown", "metadata": { "id": "HwcKKnQTYqvc" }, "source": [ "Primero debemos generar las etiquetas que se utilizarán para el modelo de clasificación. Dado que este es un problema de clasificación multiple, utilizaremos `MultiLabelBinarizer`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "GfeVufTeYqvc" }, "outputs": [], "source": [ "from sklearn.preprocessing import MultiLabelBinarizer\n", "\n", "label_encoder = MultiLabelBinarizer()\n", "labels = label_encoder.fit_transform(labels)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "M2KuPhVZYqvd" }, "outputs": [], "source": [ "N_LABELS = len(label_encoder.classes_)" ] }, { "cell_type": "markdown", "metadata": { "id": "vpeV32gkYqvd" }, "source": [ "Dividimos el conjunto de datos en entrenamiento y testing:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "UbadDpc1Yqvd" }, "outputs": [], "source": [ "from sklearn.model_selection import train_test_split\n", "\n", "X_train, X_test, y_train, y_test = train_test_split(images, labels, test_size=0.3)" ] }, { "cell_type": "markdown", "metadata": { "id": "UceCMYgfYqvd" }, "source": [ "Configuramos algunos parámetros de las imágenes" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "SItHsNDoYqve" }, "outputs": [], "source": [ "IMG_SIZE = 224 # Tamaño en pixeles de las imágenes\n", "CHANNELS = 3 # Numero de canales. RGB = 3\n", "BATCH_SIZE = 128 # Tamaño del lote para entrenamiento\n", "SHUFFLE_BUFFER_SIZE = 1024 # Mezclaremos el conjunto de datos en lotes de 1024 imágenes" ] }, { "cell_type": "markdown", "metadata": { "id": "P6DQbDksYqve" }, "source": [ "Definimos una función para leer las imágenes de los directorios:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "JzENRI2pYqve" }, "outputs": [], "source": [ "import tensorflow as tf\n", "from tensorflow.data.experimental import AUTOTUNE\n", "\n", "def parse_image(filename, labels, CHANNELS:int=3, IMG_SIZE:int=224):\n", " image_string = tf.io.read_file(filename)\n", " image_decoded = tf.image.decode_jpeg(image_string, channels=CHANNELS)\n", " image_resized = tf.image.resize(image_decoded, [IMG_SIZE, IMG_SIZE])\n", " image_normalized = image_resized / 255.0\n", "\n", " return image_normalized, labels" ] }, { "cell_type": "markdown", "metadata": { "id": "zMS27EPXYqve" }, "source": [ "Definimos una función para generar el conjunto de datos:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "UFi724uXYqvf" }, "outputs": [], "source": [ "def create_dataset(filenames, labels, is_training=True, cache=False):\n", " dataset = tf.data.Dataset.from_tensor_slices((filenames, labels))\n", " dataset = dataset.map(parse_image, num_parallel_calls=AUTOTUNE)\n", " \n", " if is_training == True:\n", " if cache:\n", " # Utilice caching solo si el dataset es pequeño y cabe en memoria\n", " dataset = dataset.cache()\n", " dataset = dataset.shuffle(buffer_size=SHUFFLE_BUFFER_SIZE)\n", " \n", " dataset = dataset.batch(BATCH_SIZE)\n", " dataset = dataset.prefetch(buffer_size=AUTOTUNE)\n", " \n", " return dataset" ] }, { "cell_type": "markdown", "metadata": { "id": "BhgsLht5Yqvf" }, "source": [ "Instanciamos nuestros conjuntos de datos de entrenamiento y testing:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "MLJ958GVYqvf" }, "outputs": [], "source": [ "train_ds = create_dataset(X_train, y_train, is_training=True)\n", "test_ds = create_dataset(X_test, y_test, is_training=False)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "yrH478QkbCZh", "outputId": "736bb581-8fff-4e50-8e33-37339aa71749" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(128, 224, 224, 3)\n" ] } ], "source": [ "dataset = train_ds.take(1)\n", "for x, y in dataset.as_numpy_iterator():\n", " print(x.shape)" ] }, { "cell_type": "markdown", "metadata": { "id": "R6wjVDUSYqvf" }, "source": [ "## Utilizando transferencia de aprendizaje en nuestro modelo" ] }, { "cell_type": "markdown", "metadata": { "id": "LuuxrrTbYqvf" }, "source": [ "### ¿Qué es TensorFlow Hub?" ] }, { "cell_type": "markdown", "metadata": { "id": "FaKP8RqaYqvf" }, "source": [ "Un concepto que es esencial en el desarrollo de software es la idea de reutilizar el código que está disponible a través de librerías. Las librerías hacen que el desarrollo sea más rápido y generan más eficiencia. Para los cientificos de datos que trabajan en visión artificial, entrenar arquitecturas de redes neuronales complejas desde cero resulta altamente complejo. TensorFlow Hub es una biblioteca que permite publicar y reutilizar componentes de aprendizaje automático prediseñados. Con TF.Hub, resulta sencillo volver a entrenar la capa superior de un modelo previamente entrenado para reconocer las clases en un nuevo conjunto de datos. TensorFlow Hub también distribuye modelos sin la capa de clasificación. Estos se pueden utilizar para realizar fácilmente el aprendizaje por transferencia. Puede descargar cualquier [modelo para imágenes compatible con Tensorflow 2 de tfhub.dev](https://tfhub.dev/s?module-type=image-feature-vector&q=tf2). La única condición es asegurarse de que la forma de las características de la imagen en nuestro conjunto de datos preparado coincida con la forma de entrada esperada del modelo que desea reutilizar." ] }, { "cell_type": "markdown", "metadata": { "id": "5R_iaknKYqvg" }, "source": [ "### Utilizando un modelo para transferencia de aprendizaje" ] }, { "cell_type": "markdown", "metadata": { "id": "Mt2Mu37rYqvg" }, "source": [ "Usaremos una instancia previamente entrenada de MobileNetV2 y un tamaño de entrada de 224x224. MobileNetV2 es en realidad una gran familia de arquitecturas de redes neuronales que se diseñaron principalmente para acelerar la inferencia en el dispositivo celular. Vienen en diferentes tamaños según el multiplicador de profundidad (número de características en capas convolucionales ocultas) y el tamaño de las imágenes de entrada." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "p-DksEnsYqvg" }, "outputs": [], "source": [ "import tensorflow_hub as hub\n", "\n", "feature_extractor_url = \"https://tfhub.dev/google/imagenet/mobilenet_v2_100_224/feature_vector/4\"\n", "feature_extractor_layer = hub.KerasLayer(feature_extractor_url,\n", " input_shape=(IMG_SIZE,IMG_SIZE,CHANNELS))" ] }, { "cell_type": "markdown", "metadata": { "id": "WJzE61qJYqvg" }, "source": [ "El extractor que estamos usando aquí acepta imágenes de forma (224, 224, 3) y devuelve un vector de 1280 de longitud para cada imagen. Para evitar que TensorFlow intente ajustar los pesos de esta parte del modelo, debemos congelar los pesos en la capa del extractor, de modo que el entrenamiento solo modifique las capas de clasificación. Por lo general, esto es una buena práctica cuando se trabaja con conjuntos de datos que son muy pequeños en comparación con el conjunto de datos original en el que se entrenó el extractor de predictor. Solo se recomienda entrenarla si el conjunto de datos de entrenamiento es grande y muy similar al conjunto de datos de ImageNet original." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "KXDIR71BYqvg" }, "outputs": [], "source": [ "feature_extractor_layer.trainable = False" ] }, { "cell_type": "markdown", "metadata": { "id": "SVvlQIJHYqvg" }, "source": [ "Generamos el modelo agregando un clasificador:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "k7SXaLeyYqvg" }, "outputs": [], "source": [ "import tensorflow.keras as keras\n", "import tensorflow_addons as tfa\n", "\n", "model = keras.Sequential([\n", " feature_extractor_layer,\n", " keras.layers.Dense(1024, activation='relu', name='hidden_layer'),\n", " keras.layers.Dense(N_LABELS, activation='sigmoid', name='output')\n", "])" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "-TifV8fLYqvh" }, "outputs": [], "source": [ "model.compile(\n", " optimizer=tf.keras.optimizers.Adam(learning_rate=1e-5),\n", " loss='binary_crossentropy',\n", " metrics=[tf.keras.metrics.categorical_accuracy])" ] }, { "cell_type": "markdown", "metadata": { "id": "bAZspXg8Yqvh" }, "source": [ "Entrenamos el modelo:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "8Tvv1aYKYqvh" }, "outputs": [], "source": [ "EPOCHS = 10" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "AwujXWKXYqvh", "outputId": "8bba34d8-551a-4a96-9c6b-1c9742096e52" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1/10\n", "202/202 [==============================] - 85s 406ms/step - loss: 0.3871 - categorical_accuracy: 0.1850 - val_loss: 0.2406 - val_categorical_accuracy: 0.2630\n", "Epoch 2/10\n", "202/202 [==============================] - 83s 402ms/step - loss: 0.2259 - categorical_accuracy: 0.2778 - val_loss: 0.2206 - val_categorical_accuracy: 0.2837\n", "Epoch 3/10\n", "202/202 [==============================] - 83s 403ms/step - loss: 0.2142 - categorical_accuracy: 0.3003 - val_loss: 0.2133 - val_categorical_accuracy: 0.3045\n", "Epoch 4/10\n", "202/202 [==============================] - 83s 400ms/step - loss: 0.2080 - categorical_accuracy: 0.3169 - val_loss: 0.2085 - val_categorical_accuracy: 0.3197\n", "Epoch 5/10\n", "202/202 [==============================] - 82s 399ms/step - loss: 0.2035 - categorical_accuracy: 0.3300 - val_loss: 0.2050 - val_categorical_accuracy: 0.3290\n", "Epoch 6/10\n", "202/202 [==============================] - 82s 397ms/step - loss: 0.2002 - categorical_accuracy: 0.3394 - val_loss: 0.2025 - val_categorical_accuracy: 0.3365\n", "Epoch 7/10\n", "202/202 [==============================] - 82s 399ms/step - loss: 0.1977 - categorical_accuracy: 0.3457 - val_loss: 0.2006 - val_categorical_accuracy: 0.3439\n", "Epoch 8/10\n", "202/202 [==============================] - 82s 397ms/step - loss: 0.1956 - categorical_accuracy: 0.3505 - val_loss: 0.1991 - val_categorical_accuracy: 0.3429\n", "Epoch 9/10\n", "202/202 [==============================] - 83s 399ms/step - loss: 0.1940 - categorical_accuracy: 0.3553 - val_loss: 0.1979 - val_categorical_accuracy: 0.3459\n", "Epoch 10/10\n", "202/202 [==============================] - 83s 401ms/step - loss: 0.1925 - categorical_accuracy: 0.3581 - val_loss: 0.1970 - val_categorical_accuracy: 0.3526\n" ] } ], "source": [ "history = model.fit(train_ds, epochs=EPOCHS, validation_data=test_ds)" ] }, { "cell_type": "markdown", "metadata": { "id": "aKe54hPmw902" }, "source": [ "Generamos las predicciones para evaluar el modelo" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "S3ULNJqVt9w0" }, "outputs": [], "source": [ "import numpy as np\n", "\n", "y_prob = model.predict(test_ds)\n", "y_pred = np.round(y_prob)" ] }, { "cell_type": "markdown", "metadata": { "id": "Ler0ers4xBOL" }, "source": [ "Generamos una matriz de confusión para todas las etiquetas" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "JncVaD-5vDO_" }, "outputs": [], "source": [ "from sklearn.metrics import multilabel_confusion_matrix\n", "\n", "cm = multilabel_confusion_matrix(y_test, y_pred)" ] }, { "cell_type": "markdown", "metadata": { "id": "0T2pj6s5xHGl" }, "source": [ "### Verificando los resultados" ] }, { "cell_type": "markdown", "metadata": { "id": "pJs_oJ97xMxf" }, "source": [ "Dado que se trata de un problema de clasificación multiple, utilizaremos una matriz de confusión multiple para verificar la performance de nuestro modelo. La siguiente función intentará graficar esta información para poder verificarla más facilmente:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 513 }, "id": "fDpqvwjbvxKt", "outputId": "b5025cc8-b8e1-4b6f-92d3-9627ffcd34e5" }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "\n", "\n", "def print_confusion_matrix(confusion_matrix, axes, class_label, class_names, fontsize=14):\n", " df_cm = pd.DataFrame(\n", " confusion_matrix, index=class_names, columns=class_names,\n", " )\n", "\n", " try:\n", " heatmap = sns.heatmap(df_cm, annot=True, fmt=\"d\", cbar=False, ax=axes)\n", " except ValueError:\n", " raise ValueError(\"Confusion matrix values must be integers.\")\n", " \n", " heatmap.yaxis.set_ticklabels(heatmap.yaxis.get_ticklabels(), rotation=0, ha='right', fontsize=fontsize)\n", " heatmap.xaxis.set_ticklabels(heatmap.xaxis.get_ticklabels(), rotation=45, ha='right', fontsize=fontsize)\n", " axes.set_ylabel('True label')\n", " axes.set_xlabel('Predicted label')\n", " axes.set_title(class_label)\n", "\n", "fig, ax = plt.subplots(4, 4, figsize=(12, 7)) \n", "for axes, cfs_matrix, label in zip(ax.flatten(), cm, label_encoder.classes_):\n", " print_confusion_matrix(cfs_matrix, axes, label, [\"N\", \"Y\"])\n", "\n", "fig.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "id": "6PGNKDotxaPE" }, "source": [ "### Persisitendo el modelo" ] }, { "cell_type": "markdown", "metadata": { "id": "1ScAlMOuYqvh" }, "source": [ "Guardamos el modelo en caso de que lo necesitemos más tarde:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "P33_DxqVYqvh", "outputId": "0e1a0fbe-c045-4a93-c46b-41860eb501b1" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Modelo almacenado en: './Models/imbd-mclass_20211011_051505.h5'\n" ] } ], "source": [ "from datetime import datetime\n", "t = datetime.now().strftime(\"%Y%m%d_%H%M%S\")\n", "export_path = \"./Models/imbd-mclass_{}.h5\".format(t)\n", "model.save(export_path)\n", "print(\"Modelo almacenado en: '{}'\".format(export_path))" ] }, { "cell_type": "markdown", "metadata": { "id": "u9xvzp69x7Fu" }, "source": [ "Luego podemos cargarlo nuevamente como sigue:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "Sg13SslNYqvh" }, "outputs": [], "source": [ "reloaded = tf.keras.models.load_model(export_path, custom_objects={'KerasLayer':hub.KerasLayer})" ] } ], "metadata": { "accelerator": "GPU", "colab": { "name": "CNN - Transfer Learning.ipynb", "provenance": [], "toc_visible": true }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.2" } }, "nbformat": 4, "nbformat_minor": 0 }