bot.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import spacy\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from rasa_nlu.model import Interpreter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nlp = spacy.load('en')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Utkarsh Sah\\Anaconda3\\lib\\site-packages\\rasa_nlu\\extractors\\entity_synonyms.py:85: UserWarning: Failed to load synonyms file from './models/faq_chatbot_nlu/default/faq_chatbot_nlu\\entity_synonyms.json'\n",
      "  \"\".format(entity_synonyms_file))\n"
     ]
    }
   ],
   "source": [
    "interpreter = Interpreter.load('./models/faq_chatbot_nlu/default/faq_chatbot_nlu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def run_nlu(query):\n",
    "    global interpreter\n",
    "    return interpreter.parse(query)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def bot():\n",
    "    print('********** Chatbot Loaded! Start typing your queries here **********')\n",
    "    print('\\n')\n",
    "    query = ''\n",
    "    while(True):\n",
    "        query = input()\n",
    "        query = query.lower()\n",
    "        if (query=='exit'):\n",
    "            break\n",
    "        parsed_query = run_nlu(query)\n",
    "        response = route(parsed_query)\n",
    "        print('A: ',response)\n",
    "        print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def route(parsed_query):\n",
    "    response = 'Kindly rephrase your words'\n",
    "    demand_optional_entity_message = 'Please enter required information'\n",
    "    intent = parsed_query['intent']['name']\n",
    "    print('( Intent:',intent,')')\n",
    "    if (intent == 'greet' or intent == 'gratitude' or intent == 'goodbye'):\n",
    "        response = general_conversation(intent)\n",
    "    if (intent == 'requirement'):\n",
    "        response = requirement(parsed_query)\n",
    "    if (intent == 'extent'):\n",
    "        response = single_entity_routing(parsed_query, intent ,'body')\n",
    "    if (intent == 'definition'):\n",
    "        response = single_entity_routing(parsed_query, intent ,'subject')\n",
    "    if (intent == 'duration'):\n",
    "        response = single_entity_routing(parsed_query, intent ,'subject')\n",
    "    if (intent == 'benefits'):\n",
    "        response = single_entity_routing(parsed_query, intent ,'subject')\n",
    "    if (intent == 'legislation'):\n",
    "        response = single_entity_routing(parsed_query, intent ,'field')\n",
    "    if (intent == 'purpose'):\n",
    "        response = single_entity_routing(parsed_query, intent ,'subject')\n",
    "    if (intent == 'conditions'):\n",
    "        response = single_entity_routing(parsed_query, intent ,'subject')\n",
    "    if (intent == 'validity'):\n",
    "        response = single_entity_routing(parsed_query, intent ,'country')\n",
    "    if (intent == 'procedure'):\n",
    "        response = single_entity_routing(parsed_query, intent ,'subject')\n",
    "    if (intent == 'services'):\n",
    "        response = single_entity_routing(parsed_query, intent ,'body')\n",
    "    if (intent == 'address'):\n",
    "        demand_optional_entity_message = 'For which city do you need the address for?'\n",
    "        response = one_optional_double_entity_routing(parsed_query, intent ,'body','area', demand_optional_entity_message)\n",
    "    if (intent == 'contact'):\n",
    "        demand_optional_entity_message = 'For which city do you need the contact for?'\n",
    "        response = one_optional_double_entity_routing(parsed_query, intent ,'body','area', demand_optional_entity_message)\n",
    "    if (intent == 'email'):\n",
    "        demand_optional_entity_message = 'For which city do you need the email for?'\n",
    "        response = one_optional_double_entity_routing(parsed_query, intent ,'body','area', demand_optional_entity_message)\n",
    "    if (intent == 'types'):\n",
    "        demand_optional_entity_message = 'Please mention any status or card that you hold'\n",
    "        response = one_optional_double_entity_routing(parsed_query, intent ,'subject','status', demand_optional_entity_message)\n",
    "    return response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def most_similar_rows(routings, req_entity, req_entity_value):\n",
    "    global nlp\n",
    "    similarity_score = []\n",
    "    for item in routings[req_entity]:\n",
    "        w1 = nlp(req_entity_value)\n",
    "        w2 = nlp(item)\n",
    "        similarity = w1.similarity(w2)\n",
    "        similarity_score.append(similarity)\n",
    "    max_similarity_score = max(similarity_score)\n",
    "    routings['score'] = similarity_score\n",
    "    req_entity_rows = routings[routings['score'] == max_similarity_score]\n",
    "    return req_entity_rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def one_optional_double_entity_routing(parsed_query, intent, req_entity, optional_entity, demand_optional_entity_message):\n",
    "    global nlp\n",
    "    response = 'Kindly rephrase your words'\n",
    "    path = 'routings/'+intent+'.xlsx'\n",
    "    routings = pd.read_excel(path)\n",
    "    entities = parsed_query['entities']\n",
    "    if (len(entities) == 0):\n",
    "        return response\n",
    "    \n",
    "    req_entity_value = []\n",
    "    for entity in entities:\n",
    "        if (entity['entity'] == req_entity):\n",
    "            req_entity_value.append(entity['value'])\n",
    "    if (len(req_entity_value) == 0):\n",
    "        return 'No such information found.'\n",
    "    req_entity_value = req_entity_value[0]\n",
    "    \n",
    "    demand_optional_entity = False\n",
    "    req_entity_rows = most_similar_rows(routings, req_entity, req_entity_value)\n",
    "    independent_row = req_entity_rows[req_entity_rows[optional_entity].isnull()]\n",
    "    if (not(len(entities) == 1 and len(independent_row) == 1)):\n",
    "        demand_optional_entity = True\n",
    "\n",
    "    if (not demand_optional_entity):\n",
    "        for item in req_entity_rows['response']:\n",
    "            response = item\n",
    "        return response\n",
    "\n",
    "    optional_entity_value = []\n",
    "    for entity in entities:\n",
    "        if (entity['entity'] == optional_entity):\n",
    "            optional_entity_value.append(entity['value'])\n",
    "\n",
    "    if (len(optional_entity_value) == 0):\n",
    "        print(demand_optional_entity_message)\n",
    "        \n",
    "        flag = 0\n",
    "        optional_entity_detected = []\n",
    "        while (flag == 0):\n",
    "            optional_entity_query = input().lower()\n",
    "            optional_query_entities = run_nlu(optional_entity_query)['entities']\n",
    "\n",
    "            if (len(optional_query_entities) == 0):\n",
    "                print('Kindly enter a valid',optional_entity)\n",
    "            else:\n",
    "                for entity in optional_query_entities:\n",
    "                    if (entity['entity'] == optional_entity): \n",
    "                        optional_entity_detected.append(entity['value'])\n",
    "                        flag = 1\n",
    "\n",
    "                if (len(optional_entity_detected) == 0):\n",
    "                    print('Kindly enter a valid',optional_entity)\n",
    "                else:\n",
    "                    optional_entity_detected = optional_entity_detected[0]\n",
    "                    optional_entity_value.append(optional_entity_detected)\n",
    "\n",
    "    optional_entity_value = optional_entity_value[0]\n",
    "    req_entity_rows.drop(['score'], axis=1, inplace=True)\n",
    "    req_entity_rows.dropna(axis=0, inplace=True)\n",
    "    optional_entity_rows = most_similar_rows(req_entity_rows, optional_entity, optional_entity_value)\n",
    "    for item in optional_entity_rows['response']:\n",
    "        response = item\n",
    "    \n",
    "    return response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Indian income is taxable. Foreign income is not taxable.'"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test = run_nlu('types of taxable income')\n",
    "message = 'enter status'\n",
    "one_optional_double_entity_routing(test, 'types', 'subject', 'status', message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def single_entity_routing(parsed_query, intent, req_entity):\n",
    "    global nlp\n",
    "    response = 'Kindly rephrase your words'\n",
    "    path = 'routings/'+intent+'.xlsx'\n",
    "    routings = pd.read_excel(path)\n",
    "    entities = parsed_query['entities']\n",
    "    if (len(entities) == 0):\n",
    "        return response\n",
    "    req_entity_value = []\n",
    "    for entity in entities:\n",
    "        if (entity['entity'] == req_entity):\n",
    "            req_entity_value.append(entity['value'])\n",
    "    if (len(req_entity_value) == 0):\n",
    "        return response\n",
    "    req_entity_value = req_entity_value[0]\n",
    "    \n",
    "    max_similarity = None\n",
    "    max_similar_row = None\n",
    "    for item in routings[req_entity]:\n",
    "        w1 = nlp(req_entity_value)\n",
    "        w2 = nlp(item)\n",
    "        similarity = w1.similarity(w2)\n",
    "        if (max_similarity == None):\n",
    "            max_similarity = similarity\n",
    "            max_similar_row = routings[routings[req_entity] == item]\n",
    "        if (max_similarity < similarity):\n",
    "            max_similarity = similarity\n",
    "            max_similar_row = routings[routings[req_entity] == item]            \n",
    "    if (len(max_similar_row) == 0):\n",
    "        return response\n",
    "    for item in max_similar_row['response']:\n",
    "        response = item\n",
    "    return response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def requirement(parsed_query):\n",
    "    global nlp\n",
    "    response = 'Kindly rephrase your words'\n",
    "    requirement_routings = pd.read_excel('routings/requirement.xlsx')\n",
    "    entities = parsed_query['entities']\n",
    "    \n",
    "    if (len(entities) == 0):\n",
    "        return response\n",
    "    \n",
    "    status = []\n",
    "    for entity in entities:\n",
    "        if (entity['entity'] == 'status'):\n",
    "            status.append(entity['value'])\n",
    "    if (len(status) == 0):\n",
    "        print('Please enter a status card that you hold')\n",
    "        flag = 0\n",
    "        while(flag == 0):\n",
    "            status_query = input().lower()\n",
    "            status_query_entities = run_nlu(status_query)['entities']\n",
    "            if (len(status_query_entities) == 0):\n",
    "                print('Kindly rephrase your words and enter a valid status')\n",
    "            else:\n",
    "                status_detected = status_query_entities[0]['value']\n",
    "                flag = 1   \n",
    "        status.append(status_detected)\n",
    "\n",
    "    status = status[0]\n",
    "    data = requirement_routings[requirement_routings['status'].isnull() == False]   \n",
    "    required_row = data[data['status'] == status]\n",
    "    if (len(required_row) == 0):\n",
    "        return 'Sorry! No such information found.'\n",
    "    response = required_row['response'][0]\n",
    "    return response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def general_conversation(intent):\n",
    "    if (intent == 'greet'):\n",
    "        return \"Hi! I'm the Invest India Visa Chatbot\"\n",
    "    if (intent == 'gratitude'):\n",
    "        return \"It was a pleasure helping you\"\n",
    "    if (intent == 'goodbye'):\n",
    "        return \"Goodbye! Would love to hear from you again\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "********** Chatbot Loaded! Start typing your queries here **********\n",
      "\n",
      "\n",
      "email for frro of amritsar\n",
      "( Intent: email )\n",
      "No error 2\n",
      "No error 3\n",
      "No error 4\n",
      "1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Utkarsh Sah\\Anaconda3\\lib\\site-packages\\ipykernel\\__main__.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A:  frroasr@nic.in\n",
      "\n",
      "\n",
      "exit\n"
     ]
    }
   ],
   "source": [
    "bot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}