TensorFlow 2 quickstart for experts

CV_Classification/TensorFlow 2 quickstart for experts.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "import tensorflow as tf\n",
+    "\n",
+    "from tensorflow.keras.layers import Dense, Flatten, Conv2D\n",
+    "from tensorflow.keras import Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "outputs": [],
+   "source": [
+    "mnist = tf.keras.datasets.mnist\n",
+    "\n",
+    "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
+    "x_train, x_test = x_train / 255.0, x_test / 255.0\n",
+    "\n",
+    "x_train = x_train[..., tf.newaxis].astype(\"float32\")\n",
+    "x_test = x_test[..., tf.newaxis].astype(\"float32\")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "outputs": [],
+   "source": [
+    "train_ds = tf.data.Dataset.from_tensor_slices((x_train, y_train)).shuffle(10000).batch(32)\n",
+    "test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "outputs": [],
+   "source": [
+    "class MyModel(Model):\n",
+    "    def __init__(self):\n",
+    "        super(MyModel, self).__init__()\n",
+    "        self.conv1 = Conv2D(32, 3, activation='relu')\n",
+    "        self.flatten = Flatten()\n",
+    "        self.d1 = Dense(128, activation='relu')\n",
+    "        self.d2 = Dense(10)\n",
+    "\n",
+    "    def call(self, x):\n",
+    "        x = self.conv1(x)\n",
+    "        x = self.flatten(x)\n",
+    "        x = self.d1(x)\n",
+    "\n",
+    "        return self.d2(x)\n",
+    "\n",
+    "model = MyModel()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "outputs": [],
+   "source": [
+    "loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n",
+    "optimizer = tf.keras.optimizers.Adam()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "outputs": [],
+   "source": [
+    "train_loss = tf.keras.metrics.Mean(name='train_loss')\n",
+    "train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')\n",
+    "\n",
+    "test_loss = tf.keras.metrics.Mean(name='test_loss')\n",
+    "test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "outputs": [],
+   "source": [
+    "@tf.function\n",
+    "def train_step(images, labels):\n",
+    "    with tf.GradientTape() as tape:\n",
+    "        predictions = model(images, training=True)\n",
+    "        loss = loss_object(labels, predictions)\n",
+    "\n",
+    "    gradients = tape.gradient(loss, model.trainable_variables)\n",
+    "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n",
+    "\n",
+    "    train_loss(loss)\n",
+    "    train_accuracy(labels, predictions)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "outputs": [],
+   "source": [
+    "@tf.function\n",
+    "def test_step(images, labels):\n",
+    "    predictions = model(images, training=False)\n",
+    "    t_loss = loss_object(labels, predictions)\n",
+    "\n",
+    "    test_loss(t_loss)\n",
+    "    test_accuracy(labels, predictions)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1, Loss: 0.1362500935792923, Accuracy: 95.75833129882812, Test Loss: 0.06010208651423454, Test Accuracy: 98.07999420166016\n",
+      "Epoch 2, Loss: 0.04352438822388649, Accuracy: 98.65333557128906, Test Loss: 0.05184892565011978, Test Accuracy: 98.22999572753906\n",
+      "Epoch 3, Loss: 0.021888718008995056, Accuracy: 99.29500579833984, Test Loss: 0.05651076138019562, Test Accuracy: 98.20999908447266\n",
+      "Epoch 4, Loss: 0.014405352994799614, Accuracy: 99.55833435058594, Test Loss: 0.05141943320631981, Test Accuracy: 98.48999786376953\n",
+      "Epoch 5, Loss: 0.008999002166092396, Accuracy: 99.71833038330078, Test Loss: 0.06053818389773369, Test Accuracy: 98.27999877929688\n"
+     ]
+    }
+   ],
+   "source": [
+    "EPOCHS = 5\n",
+    "\n",
+    "for epoch in range(EPOCHS):\n",
+    "    train_loss.reset_states()\n",
+    "    train_accuracy.reset_states()\n",
+    "    test_loss.reset_states()\n",
+    "    test_accuracy.reset_states()\n",
+    "\n",
+    "    for images, labels in train_ds:\n",
+    "        train_step(images, labels)\n",
+    "\n",
+    "    for test_images, test_labels in test_ds:\n",
+    "        test_step(test_images, test_labels)\n",
+    "\n",
+    "    print(\n",
+    "    f'Epoch {epoch + 1}, '\n",
+    "    f'Loss: {train_loss.result()}, '\n",
+    "    f'Accuracy: {train_accuracy.result() * 100}, '\n",
+    "    f'Test Loss: {test_loss.result()}, '\n",
+    "    f'Test Accuracy: {test_accuracy.result() * 100}'\n",
+    "  )"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file

CV_Classification/TensorFlow 2 quickstart for experts.md

+Import TensorFlow into your program:
+
+```
+import tensorflow as tf
+
+from tensorflow.keras.layers import Dense, Flatten, Conv2D
+from tensorflow.keras import Model
+```
+
+Load and prepare the MNIST dataset.
+
+```
+mnist = tf.keras.datasets.mnist
+
+(x_train, y_train), (x_test, y_test) = mnist.load_data()
+x_train, x_test = x_train / 255.0, x_test / 255.0
+
+# Add a channels dimension
+x_train = x_train[..., tf.newaxis].astype("float32")
+x_test = x_test[..., tf.newaxis].astype("float32")
+```
+
+Use tf.data to batch and shuffle the dataset:
+
+```
+train_ds = tf.data.Dataset.from_tensor_slices(
+    (x_train, y_train)).shuffle(10000).batch(32)
+
+test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)
+```
+
+Build the tf.keras model using the Keras model subclassing API:
+
+```
+class MyModel(Model):
+  def __init__(self):
+    super(MyModel, self).__init__()
+    self.conv1 = Conv2D(32, 3, activation='relu')
+    self.flatten = Flatten()
+    self.d1 = Dense(128, activation='relu')
+    self.d2 = Dense(10)
+
+  def call(self, x):
+    x = self.conv1(x)
+    x = self.flatten(x)
+    x = self.d1(x)
+    return self.d2(x)
+
+# Create an instance of the model
+model = MyModel()
+```
+
+Choose an optimizer and loss function for training:
+
+```
+loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
+
+optimizer = tf.keras.optimizers.Adam()
+```
+
+Select metrics to measure the loss and the accuracy of the model. These metrics accumulate the values over epochs and then print the overall result.
+
+```
+train_loss = tf.keras.metrics.Mean(name='train_loss')
+train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')
+
+test_loss = tf.keras.metrics.Mean(name='test_loss')
+test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')
+```
+
+Use tf.GradientTape to train the model:
+
+```
+@tf.function
+def train_step(images, labels):
+  with tf.GradientTape() as tape:
+    # training=True is only needed if there are layers with different
+    # behavior during training versus inference (e.g. Dropout).
+    predictions = model(images, training=True)
+    loss = loss_object(labels, predictions)
+  gradients = tape.gradient(loss, model.trainable_variables)
+  optimizer.apply_gradients(zip(gradients, model.trainable_variables))
+
+  train_loss(loss)
+  train_accuracy(labels, predictions)
+```
+
+Test the model:
+
+```
+@tf.function
+def test_step(images, labels):
+  # training=False is only needed if there are layers with different
+  # behavior during training versus inference (e.g. Dropout).
+  predictions = model(images, training=False)
+  t_loss = loss_object(labels, predictions)
+
+  test_loss(t_loss)
+  test_accuracy(labels, predictions)
+```
+
+```
+EPOCHS = 5
+
+for epoch in range(EPOCHS):
+  # Reset the metrics at the start of the next epoch
+  train_loss.reset_states()
+  train_accuracy.reset_states()
+  test_loss.reset_states()
+  test_accuracy.reset_states()
+
+  for images, labels in train_ds:
+    train_step(images, labels)
+
+  for test_images, test_labels in test_ds:
+    test_step(test_images, test_labels)
+
+  print(
+    f'Epoch {epoch + 1}, '
+    f'Loss: {train_loss.result()}, '
+    f'Accuracy: {train_accuracy.result() * 100}, '
+    f'Test Loss: {test_loss.result()}, '
+    f'Test Accuracy: {test_accuracy.result() * 100}'
+  )
+```
+
+The image classifier is now trained to ~98% accuracy on this dataset
\ No newline at end of file