papers/AlexNet/AlexNet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AlexNet\n",
    "\n",
    "使用 TensorFlow 2 实现 AlexNet，并以 <https://www.tensorflow.org/tutorials/images/classification> 为例进行验证。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 导入依赖"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import PIL\n",
    "import pathlib\n",
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras.models import Sequential"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_classes = 5\n",
    "batch_size = 128\n",
    "img_height = 227\n",
    "img_width = 227\n",
    "epochs=100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 下载数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_url = \"https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz\"\n",
    "data_dir = tf.keras.utils.get_file('flower_photos', origin=dataset_url, untar=True)\n",
    "data_dir = pathlib.Path(data_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_ds = tf.keras.preprocessing.image_dataset_from_directory(\n",
    "  data_dir,\n",
    "  validation_split=0.2,\n",
    "  subset=\"training\",\n",
    "  seed=123,\n",
    "  image_size=(img_height, img_width),\n",
    "  batch_size=batch_size)\n",
    "\n",
    "val_ds = tf.keras.preprocessing.image_dataset_from_directory(\n",
    "  data_dir,\n",
    "  validation_split=0.2,\n",
    "  subset=\"validation\",\n",
    "  seed=123,\n",
    "  image_size=(img_height, img_width),\n",
    "  batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AlexNet(keras.Model):\n",
    "    def __init__(self, num_classes, input_shape=(227, 227, 3)):\n",
    "        super(AlexNet, self).__init__()\n",
    "        self.input_layer = layers.Conv2D(\n",
    "            filters=96,\n",
    "            kernel_size=(11, 11),\n",
    "            strides=(4, 4),\n",
    "            activation=keras.activations.relu,\n",
    "            padding='valid',\n",
    "            input_shape=input_shape)\n",
    "        self.middle_layers = [\n",
    "            layers.BatchNormalization(),\n",
    "            layers.MaxPool2D(pool_size=(3, 3), strides=(2, 2)),\n",
    "\n",
    "            layers.Conv2D(\n",
    "                filters=256,\n",
    "                kernel_size=(5, 5),\n",
    "                strides=(1, 1),\n",
    "                activation=keras.activations.relu,\n",
    "                padding='same'\n",
    "            ),\n",
    "            layers.BatchNormalization(),\n",
    "            layers.MaxPool2D(pool_size=(3, 3), strides=(2, 2)),\n",
    "\n",
    "            layers.Conv2D(\n",
    "                filters=384,\n",
    "                kernel_size=(3, 3),\n",
    "                strides=(1, 1),\n",
    "                activation=keras.activations.relu,\n",
    "                padding='same'\n",
    "            ),\n",
    "            layers.BatchNormalization(),\n",
    "\n",
    "            layers.Conv2D(\n",
    "                filters=384,\n",
    "                kernel_size=(3, 3),\n",
    "                strides=(1, 1),\n",
    "                activation=keras.activations.relu,\n",
    "                padding='same'\n",
    "            ),\n",
    "            layers.BatchNormalization(),\n",
    "\n",
    "            layers.Conv2D(\n",
    "                filters=256,\n",
    "                kernel_size=(3, 3),\n",
    "                strides=(1, 1),\n",
    "                activation=keras.activations.relu,\n",
    "                padding='same'\n",
    "            ),\n",
    "            layers.BatchNormalization(),\n",
    "            layers.MaxPool2D(pool_size=(3, 3), strides=(2, 2)),\n",
    "\n",
    "            layers.Flatten(),\n",
    "            \n",
    "            layers.Dense(units=4096, activation=keras.activations.relu),\n",
    "            layers.Dropout(rate=0.5),\n",
    "            \n",
    "            layers.Dense(units=4096, activation=keras.activations.relu),\n",
    "            layers.Dropout(rate=0.5),\n",
    "        ]\n",
    "        self.out_layer = layers.Dense(\n",
    "            units=num_classes, activation=keras.activations.softmax)\n",
    "\n",
    "    def call(self, inputs):\n",
    "        x = self.input_layer(inputs)\n",
    "        for layer in self.middle_layers:\n",
    "            x = layer(x)\n",
    "        probs = self.out_layer(x)\n",
    "        return probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_augmentation = keras.Sequential(\n",
    "  [\n",
    "    layers.experimental.preprocessing.RandomFlip(\"horizontal\", \n",
    "                                                 input_shape=(img_height, \n",
    "                                                              img_width,\n",
    "                                                              3)),\n",
    "    layers.experimental.preprocessing.RandomRotation(0.1),\n",
    "    layers.experimental.preprocessing.RandomZoom(0.1),\n",
    "  ]\n",
    ")\n",
    "\n",
    "augmented_train_ds = train_ds.map(\n",
    "  lambda x, y: (data_augmentation(x, training=True), y))\n",
    "\n",
    "model = AlexNet(num_classes)\n",
    "model.compile(optimizer='adam',\n",
    "              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n",
    "              metrics=['accuracy'])\n",
    "model.build((None, img_height, img_width, 3))\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 训练模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "history = model.fit(\n",
    "  augmented_train_ds,\n",
    "  validation_data=val_ds,\n",
    "  epochs=epochs\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 可视化训练结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "acc = history.history['accuracy']\n",
    "val_acc = history.history['val_accuracy']\n",
    "\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "\n",
    "epochs_range = range(epochs)\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(epochs_range, acc, label='Training Accuracy')\n",
    "plt.plot(epochs_range, val_acc, label='Validation Accuracy')\n",
    "plt.legend(loc='lower right')\n",
    "plt.title('Training and Validation Accuracy')\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(epochs_range, loss, label='Training Loss')\n",
    "plt.plot(epochs_range, val_loss, label='Validation Loss')\n",
    "plt.legend(loc='upper right')\n",
    "plt.title('Training and Validation Loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 预测新数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sunflower_url = \"https://storage.googleapis.com/download.tensorflow.org/example_images/592px-Red_sunflower.jpg\"\n",
    "sunflower_path = tf.keras.utils.get_file('Red_sunflower', origin=sunflower_url)\n",
    "\n",
    "img = keras.preprocessing.image.load_img(\n",
    "    sunflower_path, target_size=(img_height, img_width)\n",
    ")\n",
    "img_array = keras.preprocessing.image.img_to_array(img)\n",
    "img_array = tf.expand_dims(img_array, 0) # Create a batch\n",
    "\n",
    "predictions = model.predict(img_array)\n",
    "score = tf.nn.softmax(predictions[0])\n",
    "\n",
    "print(\n",
    "    \"This image most likely belongs to {} with a {:.2f} percent confidence.\"\n",
    "    .format(train_ds.class_names[np.argmax(score)], 100 * np.max(score))\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "9f12336d765fce89a8eb21273d1fecb2b25cdd44091943dfd88fc4225cbf0971"
  },
  "kernelspec": {
   "display_name": "Python 3.8.5 64-bit ('tensorflow': conda)",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}