LSTMalphabet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "green-software",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.layers import LSTM\n",
    "from keras.utils import np_utils"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18b83253",
   "metadata": {},
   "source": [
    "## LSTM Alphabet Example\n",
    "\n",
    "Module: [***Sequential***](https://keras.io/api/models/sequential/), [***Layers***](https://keras.io/api/layers/) in Keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "developed-internship",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the raw dataset\n",
    "alphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "\n",
    "# create mapping of characters to integers (0-25) and the reverse\n",
    "char_to_int = dict((c, i) for i, c in enumerate(alphabet))\n",
    "int_to_char = dict((i, c) for i, c in enumerate(alphabet))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "intended-things",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training data: \n",
      "\n",
      "AB -> C\n",
      "BC -> D\n",
      "CD -> E\n",
      "DE -> F\n",
      "EF -> G\n",
      "FG -> H\n",
      "GH -> I\n",
      "HI -> J\n",
      "IJ -> K\n",
      "JK -> L\n",
      "KL -> M\n",
      "LM -> N\n",
      "MN -> O\n",
      "NO -> P\n",
      "OP -> Q\n",
      "PQ -> R\n",
      "QR -> S\n",
      "RS -> T\n",
      "ST -> U\n",
      "TU -> V\n",
      "UV -> W\n",
      "VW -> X\n",
      "WX -> Y\n",
      "XY -> Z\n"
     ]
    }
   ],
   "source": [
    "# prepare the dataset of input to output pairs encoded as integers\n",
    "seq_length = 2  # try setting the value to integer (e.g. 1, 2, 3), and check the differences\n",
    "\n",
    "# define the input and output sequence data\n",
    "dataX = []\n",
    "dataY = []\n",
    "\n",
    "print(\"Training data: \\n\" )\n",
    "\n",
    "for i in range(0, len(alphabet) - seq_length, 1):\n",
    "\tseq_in = alphabet[i:i + seq_length]\n",
    "\tseq_out = alphabet[i + seq_length]\n",
    "\tdataX.append([char_to_int[char] for char in seq_in])\n",
    "\tdataY.append(char_to_int[seq_out])\n",
    "\tprint(seq_in, '->', seq_out)  # print out the sequence data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "equal-ghost",
   "metadata": {},
   "outputs": [],
   "source": [
    "# reshape X to be [samples, time steps, features]\n",
    "X = np.reshape(dataX, (len(dataX), seq_length, 1))\n",
    "\n",
    "# normalize\n",
    "X = X / float(len(alphabet))\n",
    "\n",
    "# one-hot encode the output data\n",
    "y = np_utils.to_categorical(dataY)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "theoretical-music",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "lstm (LSTM)                  (None, 32)                4352      \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 26)                858       \n",
      "=================================================================\n",
      "Total params: 5,210\n",
      "Trainable params: 5,210\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# instantiate the LSTM model\n",
    "model = Sequential()\n",
    "\n",
    "# define the model architecture\n",
    "model.add(LSTM(32, input_shape=(X.shape[1], X.shape[2])))\n",
    "model.add(Dense(y.shape[1], activation='softmax'))\n",
    "\n",
    "# define loss, optimizer, metrics\n",
    "model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
    "print (model.summary())\n",
    "\n",
    "# train the model\n",
    "history = model.fit(X, y, epochs=1000, batch_size=len(dataX), verbose=0, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "continuing-sixth",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x28c66cacd88>"
      ]
     },
     "execution_count": 6,
     "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": [
    "# plot the loss and accuracy curves\n",
    "plt.plot(history.history['accuracy'], label='Accuracy', color='red')\n",
    "plt.plot(history.history[\"loss\"], label=\"Loss\",  color='green')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "younger-seven",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model Accuracy: 100.00% \n",
      "\n",
      "['A', 'B'] -> C\n",
      "['B', 'C'] -> D\n",
      "['C', 'D'] -> E\n",
      "['D', 'E'] -> F\n",
      "['E', 'F'] -> G\n",
      "['F', 'G'] -> H\n",
      "['G', 'H'] -> I\n",
      "['H', 'I'] -> J\n",
      "['I', 'J'] -> K\n",
      "['J', 'K'] -> L\n",
      "['K', 'L'] -> M\n",
      "['L', 'M'] -> N\n",
      "['M', 'N'] -> O\n",
      "['N', 'O'] -> P\n",
      "['O', 'P'] -> Q\n",
      "['P', 'Q'] -> R\n",
      "['Q', 'R'] -> S\n",
      "['R', 'S'] -> T\n",
      "['S', 'T'] -> U\n",
      "['T', 'U'] -> V\n",
      "['U', 'V'] -> W\n",
      "['V', 'W'] -> X\n",
      "['W', 'X'] -> Y\n",
      "['X', 'Y'] -> Z\n"
     ]
    }
   ],
   "source": [
    "# summarize performance of the model\n",
    "scores = model.evaluate(X, y, verbose=0)\n",
    "print(\"Model Accuracy: %.2f%% \\n\" % (scores[1]*100) )\n",
    "\n",
    "# demonstrate some model predictions\n",
    "for pattern in dataX:\n",
    "    x = np.reshape(pattern, (1, len(pattern), 1))\n",
    "    x = x / float(len(alphabet))\n",
    "    prediction = model.predict(x, verbose=0)\n",
    "    index = np.argmax(prediction)\n",
    "    seq_out = int_to_char[index]\n",
    "    seq_in = [int_to_char[value] for value in pattern]\n",
    "    print(seq_in, \"->\", seq_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "distinguished-federal",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test a Random Pattern:\n",
      "['E', 'F'] -> G\n",
      "['U', 'V'] -> W\n",
      "['N', 'O'] -> P\n"
     ]
    }
   ],
   "source": [
    "# demonstrate predicting random patterns\n",
    "\n",
    "test_number = 3   #number of random patterns to demonstrate\n",
    "\n",
    "print(\"Test a Random Pattern:\")\n",
    "for i in range(0, test_number):\n",
    "    pattern_index = np.random.randint(len(dataX))\n",
    "    pattern = dataX[pattern_index]\n",
    "    x = np.reshape(pattern, (1, len(pattern), 1))\n",
    "    x = x / float(len(alphabet))\n",
    "    prediction = model.predict(x, verbose=0)\n",
    "    index = np.argmax(prediction)\n",
    "    result = int_to_char[index]\n",
    "    seq_in = [int_to_char[value] for value in pattern]\n",
    "    print(seq_in, \"->\", result)"
   ]
  }
 ],
 "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}