ch09 - Embedding ML model into a web app.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import re\n",
    "import nltk\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import PorterStemmer\n",
    "from sklearn.feature_extraction.text import HashingVectorizer\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "import pyprind\n",
    "import pickle\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0% [##############################] 100% | ETA: 00:00:00\n",
      "Total time elapsed: 00:00:54\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.867\n"
     ]
    }
   ],
   "source": [
    "# prepare the model as in ch08\n",
    "\n",
    "def tokenizer(text):\n",
    "    text = re.sub('<[^>]*>', '', text)\n",
    "    emoticons = re.findall('(?::|;|=)(?:-)?(?:\\)|\\(|D|P)', text.lower())\n",
    "    text = re.sub('[\\W]+', ' ', text.lower()) +\\\n",
    "        ' '.join(emoticons).replace('-', '')\n",
    "    tokenized = [w for w in text.split() if w not in stop]\n",
    "    return tokenized\n",
    "\n",
    "def stream_docs(path):\n",
    "    with open(path, 'r', encoding='utf-8') as csv:\n",
    "        next(csv)  # skip header\n",
    "        for line in csv:\n",
    "            text, label = line[:-3], int(line[-2])\n",
    "            yield text, label\n",
    "\n",
    "def get_minibatch(doc_stream, size):\n",
    "    docs, y = [], []\n",
    "    try:\n",
    "        for _ in range(size):\n",
    "            text, label = next(doc_stream)\n",
    "            docs.append(text)\n",
    "            y.append(label)\n",
    "    except StopIteration:\n",
    "        return None, None\n",
    "    return docs, y\n",
    "\n",
    "vect = HashingVectorizer(decode_error='ignore', \n",
    "                         n_features=2**21,\n",
    "                         preprocessor=None, \n",
    "                         tokenizer=tokenizer)\n",
    "\n",
    "clf = SGDClassifier(loss='log', random_state=1, n_iter=1)\n",
    "doc_stream = stream_docs(path='./movie_data.csv')\n",
    "\n",
    "pbar = pyprind.ProgBar(45)\n",
    "stop = stopwords.words('english')\n",
    "classes = np.array([0, 1])\n",
    "for _ in range(45):\n",
    "    X_train, y_train = get_minibatch(doc_stream, size=1000)\n",
    "    if not X_train:\n",
    "        break\n",
    "    X_train = vect.transform(X_train)\n",
    "    clf.partial_fit(X_train, y_train, classes=classes)\n",
    "    pbar.update()\n",
    "    \n",
    "X_test, y_test = get_minibatch(doc_stream, size=5000)\n",
    "X_test = vect.transform(X_test)\n",
    "print('Accuracy: %.3f' % clf.score(X_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# create folders for pickle objects\n",
    "dest = os.path.join('movieclassifier', 'pkl_objects')\n",
    "if not os.path.exists(dest):\n",
    "    os.makedirs(dest)\n",
    "\n",
    "pickle.dump(stop, open(os.path.join(dest, 'stopwords.pkl'), 'wb'), protocol=4)   \n",
    "pickle.dump(clf, open(os.path.join(dest, 'classifier.pkl'), 'wb'), protocol=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Appending to movieclassifier/vectorizer.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile -a movieclassifier/vectorizer.py\n",
    "\n",
    "# saving the code below to a file to use it later\n",
    "from sklearn.feature_extraction.text import HashingVectorizer\n",
    "import re\n",
    "import os\n",
    "import pickle\n",
    "\n",
    "cur_dir = os.path.dirname(__file__)\n",
    "stop = pickle.load(open(\n",
    "                os.path.join(cur_dir, \n",
    "                'pkl_objects', \n",
    "                'stopwords.pkl'), 'rb'))\n",
    "\n",
    "def tokenizer(text):\n",
    "    text = re.sub('<[^>]*>', '', text)\n",
    "    emoticons = re.findall('(?::|;|=)(?:-)?(?:\\)|\\(|D|P)',\n",
    "                           text.lower())\n",
    "    text = re.sub('[\\W]+', ' ', text.lower()) \\\n",
    "                   + ' '.join(emoticons).replace('-', '')\n",
    "    tokenized = [w for w in text.split() if w not in stop]\n",
    "    return tokenized\n",
    "\n",
    "vect = HashingVectorizer(decode_error='ignore',\n",
    "                         n_features=2**21,\n",
    "                         preprocessor=None,\n",
    "                         tokenizer=tokenizer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# check loading pickle object\n",
    "# first, change the current Python directory to movieclassifer:\n",
    "import os\n",
    "os.chdir('movieclassifier')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "import re\n",
    "from vectorizer import vect\n",
    "\n",
    "clf = pickle.load(open(os.path.join('pkl_objects', 'classifier.pkl'), 'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction: positive\n",
      "Probability: 82.73%\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "label = {0:'negative', 1:'positive'}\n",
    "\n",
    "example = ['I love this movie']\n",
    "X = vect.transform(example)\n",
    "print('Prediction: %s\\nProbability: %.2f%%' %\\\n",
    "      (label[clf.predict(X)[0]], clf.predict_proba(X).max()*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# create database and save two review into it\n",
    "import sqlite3\n",
    "\n",
    "if os.path.exists('reviews.sqlite'):\n",
    "    os.remove('reviews.sqlite')\n",
    "\n",
    "conn = sqlite3.connect('reviews.sqlite')\n",
    "c = conn.cursor()\n",
    "c.execute('CREATE TABLE review_db (review TEXT, sentiment INTEGER, date TEXT)')\n",
    "\n",
    "example1 = 'I love this movie'\n",
    "c.execute(\"INSERT INTO review_db (review, sentiment, date) VALUES (?, ?, DATETIME('now'))\", (example1, 1))\n",
    "\n",
    "example2 = 'I disliked this movie'\n",
    "c.execute(\"INSERT INTO review_db (review, sentiment, date) VALUES (?, ?, DATETIME('now'))\", (example2, 0))\n",
    "\n",
    "conn.commit()\n",
    "conn.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# read database enties withing selected dates\n",
    "conn = sqlite3.connect('reviews.sqlite')\n",
    "c = conn.cursor()\n",
    "\n",
    "c.execute(\"SELECT * FROM review_db WHERE date BETWEEN '2015-01-01 10:10:10' AND DATETIME('now')\")\n",
    "results = c.fetchall()\n",
    "\n",
    "conn.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('I love this movie', 1, '2017-08-09 14:14:39'), ('I disliked this movie', 0, '2017-08-09 14:14:39')]\n"
     ]
    }
   ],
   "source": [
    "print(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Developing a web application with Flask\n",
    "\n",
    "\"\"\" \n",
    "Directory structure:\n",
    "1st_flask_app_1/\n",
    "   app.py\n",
    "   templates/\n",
    "       first_app.html\n",
    "       \n",
    "**********************       \n",
    "1st_flask_app_1/app.py\n",
    "\n",
    "from flask import Flask, render_template\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "@app.route('/')\n",
    "def index():\n",
    "    return render_template('first_app.html')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    app.run(debug=True)\n",
    "\n",
    "****************************************\n",
    "1st_flask_app_1/templates/first_app.html\n",
    "\n",
    "<!doctype html>\n",
    "<html>\n",
    "  <head>\n",
    "    <title>First app</title>\n",
    "  </head>\n",
    "  <body>\n",
    "\n",
    "  <div>\n",
    "    Hi, this is my first Flask web app!\n",
    "  </div>\n",
    "\n",
    "  </body>\n",
    "</html>\n",
    "       \n",
    "\"\"\"       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# change directory to the app.py and launch it with \"python\" command \n",
    "# then put the adress to localhost:xxxx to watch the result in browser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\"\"\"    \n",
    "Directory structure:\n",
    "\n",
    "1st_flask_app_2/\n",
    "   app.py\n",
    "   static/\n",
    "       style.css\n",
    "   templates/\n",
    "       _formhelpers.html\n",
    "       first_app.html\n",
    "       hello.html\n",
    "       \n",
    "**********************\n",
    "1st_flask_app_2/app.py\n",
    "\n",
    "from flask import Flask, render_template, request\n",
    "from wtforms import Form, TextAreaField, validators\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "class HelloForm(Form):\n",
    "    sayhello = TextAreaField('',[validators.DataRequired()])\n",
    "\n",
    "@app.route('/')\n",
    "def index():\n",
    "    form = HelloForm(request.form)\n",
    "    return render_template('first_app.html', form=form)\n",
    "\n",
    "@app.route('/hello', methods=['POST'])\n",
    "def hello():\n",
    "    form = HelloForm(request.form)\n",
    "    if request.method == 'POST' and form.validate():\n",
    "        name = request.form['sayhello']\n",
    "        return render_template('hello.html', name=name)\n",
    "    return render_template('first_app.html', form=form)\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    app.run(debug=True)\n",
    "    \n",
    "*********    \n",
    "1st_flask_app_2/static/style.css\n",
    "\n",
    "body {\n",
    "    font-size: 2em;\n",
    "}\n",
    "\n",
    "*******************************************\n",
    "1st_flask_app_2/templates/_formhelpers.html\n",
    "\n",
    "{% macro render_field(field) %}\n",
    "  <dt>{{ field.label }}\n",
    "  <dd>{{ field(**kwargs)|safe }}\n",
    "  {% if field.errors %}\n",
    "    <ul class=errors>\n",
    "    {% for error in field.errors %}\n",
    "      <li>{{ error }}</li>\n",
    "    {% endfor %}\n",
    "    </ul>\n",
    "  {% endif %}\n",
    "  </dd>\n",
    "  </dt>\n",
    "{% endmacro %}\n",
    "\n",
    "****************************************\n",
    "1st_flask_app_2/templates/first_app.html\n",
    "\n",
    "<!doctype html>\n",
    "<html>\n",
    "  <head>\n",
    "    <title>First app</title>\n",
    "    <link rel=\"stylesheet\" href=\"{{ url_for('static', filename='style.css') }}\">\n",
    "  </head>\n",
    "  <body>\n",
    "\n",
    "{% from \"_formhelpers.html\" import render_field %}\n",
    "\n",
    "<div>What's your name?</div>\n",
    "<form method=post action=\"/hello\">\n",
    "\n",
    "  <dl>\n",
    "      {{ render_field(form.sayhello) }}\n",
    "  </dl>\n",
    "\n",
    "  <input type=submit value='Say Hello' name='submit_btn'>\n",
    "\n",
    "</form>\n",
    "\n",
    "  </body>\n",
    "</html>\n",
    "\n",
    "************************************\n",
    "1st_flask_app_2/templates/hello.html\n",
    "\n",
    "<!doctype html>\n",
    "<html>\n",
    "  <head>\n",
    "    <title>First app</title>\n",
    "    <link rel=\"stylesheet\" href=\"{{ url_for('static', filename='style.css') }}\">\n",
    "  </head>\n",
    "  <body>\n",
    "\n",
    "<div>Hello {{ name }}</div>\n",
    "\n",
    "\n",
    "  </body>\n",
    "</html>\n",
    "\n",
    "\"\"\"  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Turning the movie classifier into a web application\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "Directory structure:\n",
    "\n",
    "movieclassifier/\n",
    "   app.py\n",
    "   reviews.sqlite\n",
    "   vectorizer.py\n",
    "   pkl_objects/\n",
    "       classifier.pkl\n",
    "       stopwords.pkl\n",
    "   static/\n",
    "       style.css\n",
    "   templates/\n",
    "       _formhelpers.html\n",
    "       results.html\n",
    "       reviewform.html\n",
    "       thanks.html\n",
    "       \n",
    "**********************\n",
    "movieclassifier/app.py\n",
    "\n",
    "from flask import Flask, render_template, request\n",
    "from wtforms import Form, TextAreaField, validators\n",
    "import pickle\n",
    "import sqlite3\n",
    "import os\n",
    "import numpy as np\n",
    "\n",
    "# import HashingVectorizer from local dir\n",
    "from vectorizer import vect\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "######## Preparing the Classifier\n",
    "cur_dir = os.path.dirname(__file__)\n",
    "clf = pickle.load(open(os.path.join(cur_dir,\n",
    "                 'pkl_objects',\n",
    "                 'classifier.pkl'), 'rb'))\n",
    "db = os.path.join(cur_dir, 'reviews.sqlite')\n",
    "\n",
    "def classify(document):\n",
    "    label = {0: 'negative', 1: 'positive'}\n",
    "    X = vect.transform([document])\n",
    "    y = clf.predict(X)[0]\n",
    "    proba = np.max(clf.predict_proba(X))\n",
    "    return label[y], proba\n",
    "\n",
    "def train(document, y):\n",
    "    X = vect.transform([document])\n",
    "    clf.partial_fit(X, [y])\n",
    "\n",
    "def sqlite_entry(path, document, y):\n",
    "    conn = sqlite3.connect(path)\n",
    "    c = conn.cursor()\n",
    "    c.execute(\"INSERT INTO review_db (review, sentiment, date)\"\\\n",
    "    \" VALUES (?, ?, DATETIME('now'))\", (document, y))\n",
    "    conn.commit()\n",
    "    conn.close()\n",
    "\n",
    "######## Flask\n",
    "class ReviewForm(Form):\n",
    "    moviereview = TextAreaField('',\n",
    "                                [validators.DataRequired(),\n",
    "                                validators.length(min=15)])\n",
    "\n",
    "@app.route('/')\n",
    "def index():\n",
    "    form = ReviewForm(request.form)\n",
    "    return render_template('reviewform.html', form=form)\n",
    "\n",
    "@app.route('/results', methods=['POST'])\n",
    "def results():\n",
    "    form = ReviewForm(request.form)\n",
    "    if request.method == 'POST' and form.validate():\n",
    "        review = request.form['moviereview']\n",
    "        y, proba = classify(review)\n",
    "        return render_template('results.html',\n",
    "                                content=review,\n",
    "                                prediction=y,\n",
    "                                probability=round(proba*100, 2))\n",
    "    return render_template('reviewform.html', form=form)\n",
    "\n",
    "@app.route('/thanks', methods=['POST'])\n",
    "def feedback():\n",
    "    feedback = request.form['feedback_button']\n",
    "    review = request.form['review']\n",
    "    prediction = request.form['prediction']\n",
    "\n",
    "    inv_label = {'negative': 0, 'positive': 1}\n",
    "    y = inv_label[prediction]\n",
    "    if feedback == 'Incorrect':\n",
    "        y = int(not(y))\n",
    "    train(review, y)\n",
    "    sqlite_entry(db, review, y)\n",
    "    return render_template('thanks.html')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    app.run(debug=True)\n",
    "    \n",
    "********************************\n",
    "movieclassifier/static/style.css\n",
    "\n",
    "body{\n",
    "    width:600px;\n",
    "}\n",
    "\n",
    ".button{\n",
    "    padding-top: 20px;\n",
    "}\n",
    "    \n",
    "*****************************************\n",
    "movieclassifier/templates/reviewform.html\n",
    "\n",
    "<!doctype html>\n",
    "<html>\n",
    "  <head>\n",
    "    <title>Movie Classification</title>\n",
    "    <link rel=\"stylesheet\" href=\"{{ url_for('static', filename='style.css') }}\">\n",
    "  </head>\n",
    "  <body>\n",
    "\n",
    "<h2>Please enter your movie review:</h2>\n",
    "\n",
    "{% from \"_formhelpers.html\" import render_field %}\n",
    "\n",
    "<form method=post action=\"/results\">\n",
    "  <dl>\n",
    "    {{ render_field(form.moviereview, cols='30', rows='10') }}\n",
    "  </dl>\n",
    "  <div>\n",
    "      <input type=submit value='Submit review' name='submit_btn'>\n",
    "  </div>\n",
    "</form>\n",
    "\n",
    "  </body>\n",
    "</html>\n",
    "\n",
    "**************************************\n",
    "movieclassifier/templates/results.html\n",
    "\n",
    "<!doctype html>\n",
    "<html>\n",
    "  <head>\n",
    "    <title>Movie Classification</title>\n",
    "    <link rel=\"stylesheet\" href=\"{{ url_for('static', filename='style.css') }}\">\n",
    "  </head>\n",
    "  <body>\n",
    "\n",
    "<h3>Your movie review:</h3>\n",
    "<div>{{ content }}</div>\n",
    "\n",
    "<h3>Prediction:</h3>\n",
    "<div>This movie review is <strong>{{ prediction }}</strong>\n",
    "     (probability: {{ probability }}%).</div>\n",
    "\n",
    "<div id='button'>\n",
    "      <form action=\"/thanks\" method=\"post\">\n",
    "        <input type=submit value='Correct' name='feedback_button'>\n",
    "        <input type=submit value='Incorrect' name='feedback_button'>\n",
    "        <input type=hidden value='{{ prediction }}' name='prediction'>\n",
    "        <input type=hidden value='{{ content }}' name='review'>\n",
    "      </form>\n",
    "</div>\n",
    "\n",
    "<div id='button'>\n",
    "      <form action=\"/\">\n",
    "        <input type=submit value='Submit another review'>\n",
    "      </form>\n",
    "</div>\n",
    "\n",
    "  </body>\n",
    "</html>\n",
    "\n",
    "*************************************\n",
    "movieclassifier/templates/thanks.html\n",
    "\n",
    "<!doctype html>\n",
    "<html>\n",
    "  <head>\n",
    "    <title>Movie Classification</title>\n",
    "    <link rel=\"stylesheet\" href=\"{{ url_for('static', filename='style.css') }}\">\n",
    "  </head>\n",
    "  <body>\n",
    "\n",
    "<h3>Thank you for your feedback!</h3>\n",
    "\n",
    "<div id='button'>\n",
    "      <form action=\"/\">\n",
    "        <input type=submit value='Submit another review'>\n",
    "      </form>\n",
    "</div>\n",
    "\n",
    "  </body>\n",
    "</html>\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Updating the movie review classifier\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "*************************\n",
    "movieclassifier/update.py\n",
    "\n",
    "import pickle\n",
    "import sqlite3\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "# import HashingVectorizer from local dir\n",
    "from vectorizer import vect\n",
    "\n",
    "def update_model(db_path, model, batch_size=10000):\n",
    "\n",
    "    conn = sqlite3.connect(db_path)\n",
    "    c = conn.cursor()\n",
    "    c.execute('SELECT * from review_db')\n",
    "\n",
    "    results = c.fetchmany(batch_size)\n",
    "    while results:\n",
    "        data = np.array(results)\n",
    "        X = data[:, 0]\n",
    "        y = data[:, 1].astype(int)\n",
    "\n",
    "        classes = np.array([0, 1])\n",
    "        X_train = vect.transform(X)\n",
    "        model.partial_fit(X_train, y, classes=classes)\n",
    "        results = c.fetchmany(batch_size)\n",
    "\n",
    "    conn.close()\n",
    "    return model\n",
    "\n",
    "cur_dir = os.path.dirname(__file__)\n",
    "\n",
    "clf = pickle.load(open(os.path.join(cur_dir,\n",
    "                  'pkl_objects',\n",
    "                  'classifier.pkl'), 'rb'))\n",
    "db = os.path.join(cur_dir, 'reviews.sqlite')\n",
    "\n",
    "clf = update_model(db_path=db, model=clf, batch_size=10000)\n",
    "\n",
    "# Uncomment the following lines if you are sure that\n",
    "# you want to update your classifier.pkl file\n",
    "# permanently.\n",
    "\n",
    "# pickle.dump(clf, open(os.path.join(cur_dir,\n",
    "#             'pkl_objects', 'classifier.pkl'), 'wb')\n",
    "#             , protocol=4)\n",
    "\n",
    "\"\"\""
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}