ResumeDash.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import dash\n",
    "#from jupyter_dash import JupyterDash\n",
    "import dash_core_components as dcc\n",
    "import dash_html_components as html\n",
    "import plotly.express as px\n",
    "from jupyter_dash import JupyterDash\n",
    "from dash.dependencies import Input, Output,State\n",
    "import base64\n",
    "import datetime\n",
    "import io\n",
    "import dash_table\n",
    "import pandas as pd\n",
    "import dash_table\n",
    "from PyPDF2 import PdfFileReader\n",
    "\n",
    "\n",
    "import pickle  # To load the tokenizer\n",
    "\n",
    "# Used to pad the text to the right length of sequence\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences  \n",
    "\n",
    "import tensorflow as tf  # To load the saved model(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "def preprocess_resume(text_to_clean: str) -> str:\n",
    "    \"\"\"\n",
    "    Does initial processing to the resume text before passing it to the model\n",
    "    \n",
    "    :param str text_to_clean: The text contained in the resume\n",
    "    :return: processed text\n",
    "    :rtype: str\n",
    "    \"\"\"\n",
    "    # Replace all newlines and blanklines with special strings\n",
    "    regx = re.compile(r\"\\n\\n\")\n",
    "    text_to_clean = regx.sub(repl=\" blankline \", string=text_to_clean)\n",
    "\n",
    "    regx = re.compile(r\"\\n\")\n",
    "    text_to_clean = regx.sub(repl=\" newline \", string=text_to_clean)\n",
    "\n",
    "\n",
    "    # Make all white space a single space\n",
    "    regx = re.compile(r\"\\s+\")\n",
    "    text_to_clean = regx.sub(repl=\" \", string=text_to_clean)\n",
    "\n",
    "    # Remove any trailing or leading white space\n",
    "    text_to_clean = text_to_clean.strip(\" \")\n",
    "    return text_to_clean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the model and required files for the model\n",
    "with open('tokenizer.pickle', 'rb') as handle:\n",
    "    tokenizer = pickle.load(handle)\n",
    "\n",
    "model = tf.keras.models.load_model('./fund_accounting') \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_length = 570   # ~ The median value of the length of a resume\n",
    "trunc_type='post'\n",
    "padding_type='post'\n",
    "\n",
    "def get_prediction(resume_text: str) -> float:\n",
    "    \"\"\"\n",
    "    Passes the resume text to the model and produces a percentage prediction\n",
    "    \n",
    "    :param str resume_text: The text contained in the resume\n",
    "    :return: The percentage prediction\n",
    "    :rtype: float\n",
    "    \"\"\"\n",
    "    sequence = tokenizer.texts_to_sequences([resume_text])\n",
    "    padded = pad_sequences(\n",
    "        sequence, \n",
    "        maxlen=max_length, \n",
    "        padding=padding_type, \n",
    "        truncating=trunc_type\n",
    "    )\n",
    "    prediction = model.predict(padded)[0][0]  # Get only the first value\n",
    "    return prediction * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dash app running on http://127.0.0.1:8050/\n"
     ]
    }
   ],
   "source": [
    "external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n",
    "\n",
    "colors = {\n",
    "    'background': '#FAFDFF'\n",
    "}\n",
    "\n",
    "\n",
    "app = JupyterDash(__name__, external_stylesheets=external_stylesheets)\n",
    "\n",
    "app.layout = html.Div(style={'backgroundColor': colors['background']}, children=[\n",
    "    html.H1(\"My Resume Score\",style={'textAlign': 'left', 'color': '#1285F9'}),\n",
    "    html.H3(\"Upload your resume\",style={'textAlign': 'center', 'color': '#1C2833'}),\n",
    "    dcc.Dropdown(\n",
    "    options=[\n",
    "        {'label': 'Engineering', 'value': 'Engineering'},\n",
    "        {'label': 'Technology', 'value': 'Tech'},\n",
    "        {'label': 'Accounting&Finance', 'value': 'Accounting & Finance'},\n",
    "        {'label': 'Education', 'value': 'Education'}\n",
    "    ],\n",
    "    placeholder=\"Select your feild of study\",\n",
    ")  ,\n",
    "    \n",
    "    \n",
    "    dcc.Dropdown(\n",
    "        id='demo-dropdown',\n",
    "    options=[\n",
    "        {'label': 'Employed', 'value': 'Employed'},\n",
    "        {'label': 'Looking for a job', 'value': 'looking'},\n",
    "       \n",
    "    ],\n",
    "    placeholder=\"Select your employment status\",\n",
    ") ,\n",
    "dcc.Upload(\n",
    "        id='upload-data',\n",
    "        children=html.Div([\n",
    "            'Drag and Drop or ',\n",
    "            html.A('Select Files')\n",
    "        ]),\n",
    "        style={\n",
    "            'width': '100%',\n",
    "            'height': '60px',\n",
    "            'lineHeight': '60px',\n",
    "            'borderWidth': '1px',\n",
    "            'borderStyle': 'dashed',\n",
    "            'borderRadius': '5px',\n",
    "            'textAlign': 'center',\n",
    "            'margin': '10px'\n",
    "        },\n",
    "        # Allow multiple files to be uploaded\n",
    "        multiple=True\n",
    "    ),\n",
    "    html.Div(id='output-data-upload'),\n",
    "])\n",
    "\n",
    "\n",
    "def parse_contents(contents, filename, date):\n",
    "    content_type, content_string = contents.split(',')\n",
    "\n",
    "    decoded = base64.b64decode(content_string)\n",
    "    try:\n",
    "        if 'csv' in filename:\n",
    "            # Assume that the user uploaded a CSV file\n",
    "            df = pd.read_csv(\n",
    "                io.StringIO(decoded.decode('utf-8')))\n",
    "        elif 'xls' in filename:\n",
    "            # Assume that the user uploaded an excel file\n",
    "            df = pd.read_excel(io.BytesIO(decoded))\n",
    "        elif 'pdf' in filename:\n",
    "            # Assume that the user uploaded a pdf file\n",
    "            pdf = PdfFileReader(io.BytesIO(decoded))\n",
    "            data=\"\"\n",
    "            for page in pdf.pages:\n",
    "                data += page.extractText()\n",
    "            data = preprocess_resume(data)\n",
    "            prediction = get_prediction(data)\n",
    "            return html.Div([\n",
    "                f'Your resume matches that of a fund accountant by: {prediction}%'\n",
    "            ])\n",
    "    except Exception as e:\n",
    "        print(e)\n",
    "        return html.Div([\n",
    "            'There was an error processing this file.'\n",
    "        ])\n",
    "\n",
    "    return html.Div([\n",
    "        html.H5(filename),\n",
    "        html.H6(datetime.datetime.fromtimestamp(date)),\n",
    "\n",
    "        dash_table.DataTable(\n",
    "            data=df.to_dict('records'),\n",
    "            columns=[{'name': i, 'id': i} for i in df.columns]\n",
    "        ),\n",
    "\n",
    "        html.Hr(),  # horizontal line\n",
    "\n",
    "        # For debugging, display the raw contents provided by the web browser\n",
    "        html.Div('Raw Content'),\n",
    "        html.Pre(contents[0:200] + '...', style={\n",
    "            'whiteSpace': 'pre-wrap',\n",
    "            'wordBreak': 'break-all'\n",
    "        })\n",
    "    ])\n",
    "\n",
    "\n",
    "@app.callback(Output('output-data-upload', 'children'),\n",
    "              [Input('upload-data', 'contents')],\n",
    "              [State('upload-data', 'filename'),\n",
    "               State('upload-data', 'last_modified')])\n",
    "def update_output(list_of_contents, list_of_names, list_of_dates):\n",
    "    if list_of_contents is not None:\n",
    "        children = [\n",
    "            parse_contents(c, n, d) for c, n, d in\n",
    "            zip(list_of_contents, list_of_names, list_of_dates)]\n",
    "        return children\n",
    "\n",
    "def update_output(value):\n",
    "    return 'You have selected \"{}\"'.format(value)\n",
    "\n",
    "\n",
    "\n",
    "#if __name__ == '__main__':\n",
    "    app.run_server(debug=True)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "#     model = joblib.load(\"tokenizer.pickle\")\n",
    "# Update model\n",
    "    app.run_server(debug=True)"
   ]
  },
  {
   "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"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}