00_Curse_Folder/1_Fundamentals/Class_12/ei-cifar10_image_classification-nn-classifier.ipynb

{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Download the data - after extracting features through a processing block - so we can train a machine learning model."
            ]
        },
        {
            "cell_type": "code",
            "metadata": {},
            "outputs": [],
            "execution_count": null,
            "source": [
                "import numpy as np\n",
                "import requests\n",
                "\n",
                "API_KEY = 'ei_3c5808f2fc3861a086e7091325c13812d1090b11c8ae02af5b5d3e5a2cdf2da8'\n",
                "\n",
                "def download_data(url):\n",
                "    response = requests.get(url, headers={'x-api-key': API_KEY})\n",
                "    if response.status_code == 200:\n",
                "        return response.content\n",
                "    else:\n",
                "        print(response.content)\n",
                "        raise ConnectionError('Could not download data file')\n",
                "\n",
                "X = download_data('https://studio.edgeimpulse.com/v1/api/51070/training/6/x')\n",
                "Y = download_data('https://studio.edgeimpulse.com/v1/api/51070/training/6/y')\n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Store the data in a temporary file, and load it back through Numpy."
            ]
        },
        {
            "cell_type": "code",
            "metadata": {},
            "outputs": [],
            "execution_count": null,
            "source": [
                "with open('x_train.npy', 'wb') as file:\n",
                "    file.write(X)\n",
                "with open('y_train.npy', 'wb') as file:\n",
                "    file.write(Y)\n",
                "X = np.load('x_train.npy')\n",
                "Y = np.load('y_train.npy')[:,0]"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Define our labels and split the data up in a test and training set:"
            ]
        },
        {
            "cell_type": "code",
            "metadata": {},
            "outputs": [],
            "execution_count": null,
            "source": [
                "import sys, os, random\n",
                "import tensorflow as tf\n",
                "from sklearn.model_selection import train_test_split\n",
                "\n",
                "import logging\n",
                "tf.get_logger().setLevel(logging.ERROR)\n",
                "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n",
                "\n",
                "# Set random seeds for repeatable results\n",
                "RANDOM_SEED = 3\n",
                "random.seed(RANDOM_SEED)\n",
                "np.random.seed(RANDOM_SEED)\n",
                "tf.random.set_seed(RANDOM_SEED)\n",
                "\n",
                "classes_values = [ \"cat\", \"dog\" ]\n",
                "classes = len(classes_values)\n",
                "\n",
                "Y = tf.keras.utils.to_categorical(Y - 1, classes)\n",
                "\n",
                "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=1)\n",
                "\n",
                "input_length = X_train[0].shape[0]\n",
                "\n",
                "train_dataset = tf.data.Dataset.from_tensor_slices((X_train, Y_train))\n",
                "validation_dataset = tf.data.Dataset.from_tensor_slices((X_test, Y_test))\n",
                "\n",
                "def get_reshape_function(reshape_to):\n",
                "    def reshape(image, label):\n",
                "        return tf.reshape(image, reshape_to), label\n",
                "    return reshape\n",
                "\n",
                "callbacks = []\n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Train the model:"
            ]
        },
        {
            "cell_type": "code",
            "metadata": {},
            "outputs": [],
            "execution_count": null,
            "source": [
                "import tensorflow as tf\n",
                "from tensorflow.keras.models import Sequential\n",
                "from tensorflow.keras.layers import Dense, InputLayer, Dropout, Conv1D, Conv2D, Flatten, Reshape, MaxPooling1D, MaxPooling2D, BatchNormalization, TimeDistributed\n",
                "from tensorflow.keras.optimizers import Adam\n",
                "\n",
                "# model architecture\n",
                "model = Sequential()\n",
                "model.add(Conv2D(32, kernel_size=3, activation='relu', kernel_constraint=tf.keras.constraints.MaxNorm(1), padding='same'))\n",
                "model.add(MaxPooling2D(pool_size=2, strides=2, padding='same'))\n",
                "model.add(Conv2D(64, kernel_size=3, activation='relu', kernel_constraint=tf.keras.constraints.MaxNorm(1), padding='same'))\n",
                "model.add(MaxPooling2D(pool_size=2, strides=2, padding='same'))\n",
                "model.add(Flatten())\n",
                "model.add(Dense(64, activation='relu',\n",
                "    activity_regularizer=tf.keras.regularizers.l1(0.00001)))\n",
                "model.add(Dense(classes, activation='softmax', name='y_pred'))\n",
                "\n",
                "# this controls the learning rate\n",
                "opt = Adam(lr=0.0005, beta_1=0.9, beta_2=0.999)\n",
                "# This is only required for some input types, e.g. images\n",
                "SPECIFIC_INPUT_SHAPE = (32, 32, 3)\n",
                "train_dataset = train_dataset.map(get_reshape_function(SPECIFIC_INPUT_SHAPE), tf.data.experimental.AUTOTUNE)\n",
                "validation_dataset = validation_dataset.map(get_reshape_function(SPECIFIC_INPUT_SHAPE), tf.data.experimental.AUTOTUNE)\n",
                "# this controls the batch size, or you can manipulate the tf.data.Dataset objects yourself\n",
                "BATCH_SIZE = 32\n",
                "train_dataset = train_dataset.batch(BATCH_SIZE, drop_remainder=False)\n",
                "validation_dataset = validation_dataset.batch(BATCH_SIZE, drop_remainder=False)\n",
                "\n",
                "# train the neural network\n",
                "model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])\n",
                "model.fit(train_dataset, epochs=10, validation_data=validation_dataset, verbose=2, callbacks=callbacks)\n"
            ]
        },
        {
            "cell_type": "code",
            "metadata": {},
            "outputs": [],
            "execution_count": null,
            "source": [
                "# Save the model to disk\n",
                "model.save('saved_model')"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": []
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "Python 3",
            "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.7.3"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 4
}