Reuters_multilable_multiclass_classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:516: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:517: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:518: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:519: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:520: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "/home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf \n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers \n",
    "from tensorflow.keras import models \n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.datasets import reuters\n",
    "#(train_data,train_labels), (test_data, test_labels) = reuters.load_data(num_words = 10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Reuters dataset classifies short news articles into 46 catagories, the random assigment of labels would yield an accuracy of 19%, with the current network it is about 80% accurate, much better\n",
    "The Key takeaway here is you require all of your hidden layers to have higher dimentions than your output, to avoid information loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorflow/python/keras/datasets/reuters.py:112: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  x_train, y_train = np.array(xs[:idx]), np.array(labels[:idx])\n",
      "/home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorflow/python/keras/datasets/reuters.py:113: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  x_test, y_test = np.array(xs[idx:]), np.array(labels[idx:])\n"
     ]
    }
   ],
   "source": [
    "(train_data,train_labels),(test_data,test_labels) = reuters.load_data(num_words=10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Encoding is the same as the IMDB database. The same vectorisiation is followed This is also following the same book"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vectorise_sequence(sequences, dimention = 10000):\n",
    "    results = np.zeros((len(sequences), dimention))\n",
    "    for i, sequence in enumerate(sequences):\n",
    "        results[i,sequence] = 1\n",
    "    return results\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = vectorise_sequence(train_data)\n",
    "x_test = vectorise_sequence(test_data)\n",
    "one_hot_train_labels = vectorise_sequence(train_labels,dimention= 46)\n",
    "one_hot_test_labels = vectorise_sequence(test_labels,dimention= 46)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/sean/anaconda3/envs/tf-gpu-cuda8/lib/python3.7/site-packages/tensorflow/python/ops/init_ops.py:1251: calling VarianceScaling.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n"
     ]
    }
   ],
   "source": [
    "model = models.Sequential()\n",
    "model.add(layers.Dense(64,activation='relu', input_shape = (10000,)))\n",
    "model.add(layers.Dense(64,activation='relu'))\n",
    "model.add(layers.Dense(46,activation='softmax'))\n",
    "\n",
    "model.compile(optimizer = 'rmsprop', loss = \"categorical_crossentropy\",metrics = ['accuracy'])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_val = x_train[:1000]\n",
    "partial_x_train= x_train[1000:]\n",
    "\n",
    "\n",
    "y_val = one_hot_train_labels[:1000]\n",
    "partial_y_train= one_hot_train_labels[1000:]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 7982 samples, validate on 1000 samples\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-10-11 15:36:55.614698: I tensorflow/core/platform/cpu_feature_guard.cc:142] Your CPU supports instructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 AVX AVX2 FMA\n",
      "2021-10-11 15:36:55.642566: I tensorflow/core/platform/profile_utils/cpu_utils.cc:94] CPU Frequency: 3700210000 Hz\n",
      "2021-10-11 15:36:55.643753: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x556ac5a580a0 executing computations on platform Host. Devices:\n",
      "2021-10-11 15:36:55.644030: I tensorflow/compiler/xla/service/service.cc:175]   StreamExecutor device (0): <undefined>, <undefined>\n",
      "2021-10-11 15:36:55.646133: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcuda.so.1\n",
      "2021-10-11 15:36:55.677389: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:1005] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2021-10-11 15:36:55.677736: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1640] Found device 0 with properties: \n",
      "name: NVIDIA GeForce GTX 970 major: 5 minor: 2 memoryClockRate(GHz): 1.253\n",
      "pciBusID: 0000:2b:00.0\n",
      "2021-10-11 15:36:55.679722: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcudart.so.9.0\n",
      "2021-10-11 15:36:55.696858: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcublas.so.9.0\n",
      "2021-10-11 15:36:55.708123: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcufft.so.9.0\n",
      "2021-10-11 15:36:55.712159: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcurand.so.9.0\n",
      "2021-10-11 15:36:55.737519: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcusolver.so.9.0\n",
      "2021-10-11 15:36:55.758982: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcusparse.so.9.0\n",
      "2021-10-11 15:36:55.808846: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcudnn.so.7\n",
      "2021-10-11 15:36:55.808954: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:1005] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2021-10-11 15:36:55.809382: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:1005] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2021-10-11 15:36:55.809692: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1763] Adding visible gpu devices: 0\n",
      "2021-10-11 15:36:55.810148: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcudart.so.9.0\n",
      "2021-10-11 15:36:55.840948: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1181] Device interconnect StreamExecutor with strength 1 edge matrix:\n",
      "2021-10-11 15:36:55.840963: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1187]      0 \n",
      "2021-10-11 15:36:55.840967: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1200] 0:   N \n",
      "2021-10-11 15:36:55.841058: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:1005] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2021-10-11 15:36:55.841313: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:1005] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2021-10-11 15:36:55.841529: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:1005] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2021-10-11 15:36:55.841731: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1326] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 3170 MB memory) -> physical GPU (device: 0, name: NVIDIA GeForce GTX 970, pci bus id: 0000:2b:00.0, compute capability: 5.2)\n",
      "2021-10-11 15:36:55.843032: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x556ac8ee9880 executing computations on platform CUDA. Devices:\n",
      "2021-10-11 15:36:55.843041: I tensorflow/compiler/xla/service/service.cc:175]   StreamExecutor device (0): NVIDIA GeForce GTX 970, Compute Capability 5.2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-10-11 15:36:56.951563: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcublas.so.9.0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7982/7982 [==============================] - 1s 72us/sample - loss: 2.5834 - acc: 0.5209 - val_loss: 1.7322 - val_acc: 0.6440\n",
      "Epoch 2/9\n",
      "7982/7982 [==============================] - 0s 30us/sample - loss: 1.4022 - acc: 0.7169 - val_loss: 1.2806 - val_acc: 0.7380\n",
      "Epoch 3/9\n",
      "7982/7982 [==============================] - 0s 32us/sample - loss: 1.0229 - acc: 0.7881 - val_loss: 1.1152 - val_acc: 0.7610\n",
      "Epoch 4/9\n",
      "7982/7982 [==============================] - 0s 26us/sample - loss: 0.8002 - acc: 0.8368 - val_loss: 1.0288 - val_acc: 0.7870\n",
      "Epoch 5/9\n",
      "7982/7982 [==============================] - 0s 25us/sample - loss: 0.6345 - acc: 0.8693 - val_loss: 0.9487 - val_acc: 0.8110\n",
      "Epoch 6/9\n",
      "7982/7982 [==============================] - 0s 24us/sample - loss: 0.5051 - acc: 0.8975 - val_loss: 0.9200 - val_acc: 0.8090\n",
      "Epoch 7/9\n",
      "7982/7982 [==============================] - 0s 21us/sample - loss: 0.4085 - acc: 0.9136 - val_loss: 0.9042 - val_acc: 0.8170\n",
      "Epoch 8/9\n",
      "7982/7982 [==============================] - 0s 23us/sample - loss: 0.3326 - acc: 0.9291 - val_loss: 0.9055 - val_acc: 0.8180\n",
      "Epoch 9/9\n",
      "7982/7982 [==============================] - 0s 24us/sample - loss: 0.2763 - acc: 0.9385 - val_loss: 0.9025 - val_acc: 0.8230\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(partial_x_train,partial_y_train,epochs=9,batch_size=500,validation_data=(x_val,y_val))\n",
    "#resutls = model.evaluate(x_test,one_hot_test_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "epochs  = range(1,len(loss)+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f84471b8a50>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(epochs,loss,label = 'Training Loss')\n",
    "plt.plot(epochs,val_loss,label = 'Validation Loss')\n",
    "\n",
    "plt.ylabel('Loss Function')\n",
    "plt.xlabel('Epochs')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f8447030390>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = history.history['acc']\n",
    "val_acc = history.history['val_acc']\n",
    "\n",
    "\n",
    "plt.plot(epochs,acc,label = 'Training Accuracy')\n",
    "plt.plot(epochs,val_acc,label = 'Validation Accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "747e10b70f6080f0bd7f506f4a278cc40a2da2e2842866c9e118e4fa0fbc3bf4"
  },
  "kernelspec": {
   "display_name": "Python 3.7.11 64-bit ('tf-gpu-cuda8': 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.7.11"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}