MachineTranslation with SpeechRecognition.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "18QAOGWzGS60",
    "outputId": "cd015db2-829f-46bb-b9b6-d87e56d435d3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "import random\n",
    "data_path = \"Data/English.txt\"\n",
    "data_path2 = \"Data/Hindi.txt\"\n",
    "# Defining lines as a list of each line\n",
    "with open(data_path, 'r', encoding='utf-8') as f:\n",
    "  lines = f.read().strip().split('\\n')\n",
    "with open(data_path2, 'r', encoding='utf-8') as f:\n",
    "  lines2 = f.read().strip().split('\\n')\n",
    "\n",
    "lines = [\" \".join(re.findall(r\"[A-Za-z0-9]+\",line)) for line in lines]\n",
    "lines2 = [re.sub(r\"%s|\\(|\\)|<|>|%|[a-z]|[A-Z]|_\",'',line) for line in lines2]\n",
    "\n",
    "# Grouping lines by response pair\n",
    "pairs = list(zip(lines,lines2))\n",
    "random.shuffle(pairs)\n",
    "print(len(pairs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "AYHmLwP2MnBd",
    "outputId": "916eb325-57ea-4e55-8d61-bd6941b87b05"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('her least favorite animals were mice', 'उसके कम से कम पसंदीदा जानवर चूहे थे।')\n"
     ]
    }
   ],
   "source": [
    "print(pairs[103])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uSYVkFqxapp8"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "input_docs = []\n",
    "target_docs = []\n",
    "input_tokens = set()\n",
    "target_tokens = set()\n",
    "for line in pairs:\n",
    "  input_doc, target_doc = line[0], line[1]\n",
    "  # Appending each input sentence to input_docs\n",
    "  input_docs.append(input_doc)\n",
    "  # Splitting words from punctuation  \n",
    "#   target_doc = \" \".join(re.findall(r\"[\\w']+|[^\\s\\w]\", target_doc))\n",
    "  # Redefine target_doc below and append it to target_docs\n",
    "  target_doc = '<START> ' + target_doc + ' <END>'\n",
    "  target_docs.append(target_doc)\n",
    "  \n",
    "  # Now we split up each sentence into words and add each unique word to our vocabulary set\n",
    "  for token in re.findall(r\"[\\w']+|[^\\s\\w]\", input_doc):\n",
    "    if token not in input_tokens:\n",
    "      input_tokens.add(token)\n",
    "  for token in target_doc.split(\" \"):\n",
    "    if token not in target_tokens:\n",
    "      target_tokens.add(token)\n",
    "input_tokens = sorted(list(input_tokens))\n",
    "target_tokens = sorted(list(target_tokens))\n",
    "num_encoder_tokens = len(input_tokens)\n",
    "num_decoder_tokens = len(target_tokens)\n",
    "\n",
    "input_features_dict = dict(\n",
    "    [(token, i) for i, token in enumerate(input_tokens)])\n",
    "target_features_dict = dict(\n",
    "    [(token, i) for i, token in enumerate(target_tokens)])\n",
    "\n",
    "reverse_input_features_dict = dict(\n",
    "    (i, token) for token, i in input_features_dict.items())\n",
    "reverse_target_features_dict = dict(\n",
    "    (i, token) for token, i in target_features_dict.items())\n",
    "\n",
    "\n",
    "max_encoder_seq_length = max([len(re.findall(r\"[\\w']+|[^\\s\\w]\", input_doc)) for input_doc in input_docs])\n",
    "max_decoder_seq_length = max([len(re.findall(r\"[\\w']+|[^\\s\\w]\", target_doc)) for target_doc in target_docs])\n",
    "\n",
    "encoder_input_data = np.zeros(\n",
    "    (len(input_docs), max_encoder_seq_length, num_encoder_tokens),\n",
    "    dtype='float32')\n",
    "decoder_input_data = np.zeros(\n",
    "    (len(input_docs), max_decoder_seq_length, num_decoder_tokens),\n",
    "    dtype='float32')\n",
    "decoder_target_data = np.zeros(\n",
    "    (len(input_docs), max_decoder_seq_length, num_decoder_tokens),\n",
    "    dtype='float32')\n",
    "\n",
    "for line, (input_doc, target_doc) in enumerate(zip(input_docs, target_docs)):\n",
    "    for timestep, token in enumerate(re.findall(r\"[\\w']+|[^\\s\\w]\", input_doc)):\n",
    "        #Assign 1. for the current line, timestep, & word in encoder_input_data\n",
    "        encoder_input_data[line, timestep, input_features_dict[token]] = 1.\n",
    "    \n",
    "    for timestep, token in enumerate(target_doc.split()):\n",
    "        decoder_input_data[line, timestep, target_features_dict[token]] = 1.\n",
    "        if timestep > 0:\n",
    "            decoder_target_data[line, timestep - 1, target_features_dict[token]] = 1.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "9FpRLZORdZVN",
    "outputId": "eae47498-d48c-4144-c1de-4267e5038079"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<START> उसके कम से कम पसंदीदा जानवर चूहे थे। <END> her least favorite animals were mice 678 200\n"
     ]
    }
   ],
   "source": [
    "print(target_docs[103],input_docs[103],num_decoder_tokens,num_encoder_tokens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "rf49e0wecLqG"
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from keras.layers import Input, LSTM, Dense\n",
    "from keras.models import Model\n",
    "#Dimensionality\n",
    "dimensionality = 256\n",
    "#The batch size and number of epochs\n",
    "batch_size = 256\n",
    "epochs = 40\n",
    "#Encoder\n",
    "encoder_inputs = Input(shape=(None, num_encoder_tokens))\n",
    "encoder_lstm = LSTM(dimensionality, return_state=True)\n",
    "encoder_outputs, state_hidden, state_cell = encoder_lstm(encoder_inputs)\n",
    "encoder_states = [state_hidden, state_cell]\n",
    "#Decoder\n",
    "decoder_inputs = Input(shape=(None, num_decoder_tokens))\n",
    "decoder_lstm = LSTM(dimensionality, return_sequences=True, return_state=True)\n",
    "decoder_outputs, decoder_state_hidden, decoder_state_cell = decoder_lstm(decoder_inputs, initial_state=encoder_states)\n",
    "decoder_dense = Dense(num_decoder_tokens, activation='softmax')\n",
    "decoder_outputs = decoder_dense(decoder_outputs)\n",
    "\n",
    "# #Model\n",
    "training_model = Model([encoder_inputs, decoder_inputs], decoder_outputs)\n",
    "# #Compiling\n",
    "training_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "#Training\n",
    "# history = training_model.fit([encoder_input_data, decoder_input_data], decoder_target_data, batch_size = batch_size, epochs = epochs, validation_split = 0.2)\n",
    "# training_model.save('Data/training_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 581
    },
    "colab_type": "code",
    "id": "fJ9ZVegfVNe_",
    "outputId": "8293fae9-a15e-4a62-836f-a5c12a89d220"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "acc = history.history['accuracy']\n",
    "val_acc = history.history['val_accuracy']\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "\n",
    "epochs = range(len(acc))\n",
    "\n",
    "plt.plot(epochs, acc, 'g', label='Training accuracy')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.legend(loc=0)\n",
    "plt.savefig('wordA.png')\n",
    "plt.figure()\n",
    "plt.show()\n",
    "\n",
    "plt.plot(epochs, loss, 'r', label='Training loss')\n",
    "plt.plot(epochs, val_loss, 'o', label='Validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.legend(loc=0)\n",
    "plt.savefig('wordL.png')\n",
    "plt.figure()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Uxy08NM_hAS6"
   },
   "outputs": [],
   "source": [
    "from tensorflow import keras\n",
    "from keras.models import load_model\n",
    "from keras.layers import Input, LSTM, Dense\n",
    "from keras.models import Model\n",
    "training_model = load_model('Data/training_model.h5')\n",
    "encoder_inputs = training_model.input[0]\n",
    "encoder_outputs, state_h_enc, state_c_enc = training_model.layers[2].output\n",
    "encoder_states = [state_h_enc, state_c_enc]\n",
    "encoder_model = Model(encoder_inputs, encoder_states)\n",
    "\n",
    "latent_dim = 256\n",
    "decoder_state_input_hidden = Input(shape=(latent_dim,))\n",
    "decoder_state_input_cell = Input(shape=(latent_dim,))\n",
    "decoder_states_inputs = [decoder_state_input_hidden, decoder_state_input_cell]\n",
    "decoder_outputs, state_hidden, state_cell = decoder_lstm(decoder_inputs, initial_state=decoder_states_inputs)\n",
    "decoder_states = [state_hidden, state_cell]\n",
    "decoder_outputs = decoder_dense(decoder_outputs)\n",
    "decoder_model = Model([decoder_inputs] + decoder_states_inputs, [decoder_outputs] + decoder_states)\n",
    "\n",
    "def decode_response(test_input):\n",
    "    #Getting the output states to pass into the decoder\n",
    "    states_value = encoder_model.predict(test_input)\n",
    "    #Generating empty target sequence of length 1\n",
    "    target_seq = np.zeros((1, 1, num_decoder_tokens))\n",
    "    #Setting the first token of target sequence with the start token\n",
    "    target_seq[0, 0, target_features_dict['<START>']] = 1.\n",
    "    \n",
    "    #A variable to store our response word by word\n",
    "    decoded_sentence = ''\n",
    "    \n",
    "    stop_condition = False\n",
    "    while not stop_condition:\n",
    "      #Predicting output tokens with probabilities and states\n",
    "      output_tokens, hidden_state, cell_state = decoder_model.predict([target_seq] + states_value)\n",
    "#Choosing the one with highest probability\n",
    "      sampled_token_index = np.argmax(output_tokens[0, -1, :])\n",
    "      sampled_token = reverse_target_features_dict[sampled_token_index]\n",
    "      decoded_sentence += \" \" + sampled_token\n",
    "#Stop if hit max length or found the stop token\n",
    "      if (sampled_token == '<END>' or len(decoded_sentence) > max_decoder_seq_length):\n",
    "        stop_condition = True\n",
    "#Update the target sequence\n",
    "      target_seq = np.zeros((1, 1, num_decoder_tokens))\n",
    "      target_seq[0, 0, sampled_token_index] = 1.\n",
    "      #Update states\n",
    "      states_value = [hidden_state, cell_state]\n",
    "    return decoded_sentence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Speech recognition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import time\n",
    "\n",
    "import speech_recognition as sr\n",
    "\n",
    "\n",
    "def recognize_speech_from_mic(recognizer, microphone):\n",
    "    \"\"\"Transcribe speech recorded from `microphone`.\n",
    "    Returns a dictionary with three keys:\n",
    "    \"success\": a boolean indicating whether or not the API request was\n",
    "               successful\n",
    "    \"error\":   `None` if no error occured, otherwise a string containing\n",
    "               an error message if the API could not be reached or\n",
    "               speech was unrecognizable\n",
    "    \"transcription\": `None` if speech could not be transcribed,\n",
    "               otherwise a string containing the transcribed text\n",
    "    \"\"\"\n",
    "    # check that recognizer and microphone arguments are appropriate type\n",
    "    if not isinstance(recognizer, sr.Recognizer):\n",
    "        raise TypeError(\"`recognizer` must be `Recognizer` instance\")\n",
    "\n",
    "    if not isinstance(microphone, sr.Microphone):\n",
    "        raise TypeError(\"`microphone` must be `Microphone` instance\")\n",
    "\n",
    "    # adjust the recognizer sensitivity to ambient noise and record audio\n",
    "    # from the microphone\n",
    "    with microphone as source:\n",
    "        recognizer.adjust_for_ambient_noise(source)\n",
    "        audio = recognizer.listen(source)\n",
    "\n",
    "    # set up the response object\n",
    "    response = {\n",
    "        \"success\": True,\n",
    "        \"error\": None,\n",
    "        \"transcription\": None\n",
    "    }\n",
    "\n",
    "    # try recognizing the speech in the recording\n",
    "    # if a RequestError or UnknownValueError exception is caught,\n",
    "    #     update the response object accordingly\n",
    "    try:\n",
    "        response[\"transcription\"] = recognizer.recognize_google(audio)\n",
    "    except sr.RequestError:\n",
    "        # API was unreachable or unresponsive\n",
    "        response[\"success\"] = False\n",
    "        response[\"error\"] = \"API unavailable\"\n",
    "    except sr.UnknownValueError:\n",
    "        # speech was unintelligible\n",
    "        response[\"error\"] = \"Unable to recognize speech\"\n",
    "\n",
    "    return response\n",
    "\n",
    "\n",
    "def eng_speak():\n",
    "    # create recognizer and mic instances\n",
    "    recognizer = sr.Recognizer()\n",
    "    microphone = sr.Microphone()\n",
    "\n",
    "    print(\"Speak in English and I will try to translate it into Hindi as per my best knowledge!\\n\")\n",
    "    time.sleep(3)\n",
    "    \n",
    "    # get the guess from the user\n",
    "    # if a transcription is returned, break out of the loop and\n",
    "    #     continue\n",
    "    # if no transcription returned and API request failed, break\n",
    "    #     loop and continue\n",
    "    # if API request succeeded but no transcription was returned,\n",
    "    #     re-prompt the user to say their guess again. Do this up\n",
    "    #     to PROMPT_LIMIT times\n",
    "    PROMPT_LIMIT = 1\n",
    "    for j in range(PROMPT_LIMIT):\n",
    "        print('Speak!')\n",
    "        guess = recognize_speech_from_mic(recognizer, microphone)\n",
    "        if guess[\"transcription\"]:\n",
    "            break\n",
    "        if not guess[\"success\"]:\n",
    "            break\n",
    "        print(\"I didn't catch that. What did you say?\\n\")\n",
    "\n",
    "        # if there was an error, stop the game\n",
    "        if guess[\"error\"]:\n",
    "            print(\"ERROR: {}\".format(guess[\"error\"]))\n",
    "            break\n",
    "\n",
    "    # show the user the transcription\n",
    "    print(\"You said: {}\".format(guess[\"transcription\"]))\n",
    "\n",
    "    # determine if guess is correct and if any attempts remain\n",
    "    eng_statement = guess[\"transcription\"]\n",
    "    return eng_statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyttsx3\n",
    "import argparse\n",
    "import traceback\n",
    "import sys\n",
    "\n",
    "# Default values\n",
    "def talk(text_to_read):\n",
    "    gender = \"male\"\n",
    "    language = \"hindi\"\n",
    "    accent = \"indian\"\n",
    "\n",
    "    # if text args passed in cli\n",
    "    if text_to_read:\n",
    "        text_to_read = text_to_read\n",
    "\n",
    "    # if language args passed in cli\n",
    "    if language:\n",
    "        language = language\n",
    "        if language == \"hindi\":\n",
    "            accent = \"indian\"\n",
    "\n",
    "    # if accent args passed in cli\n",
    "    if accent:\n",
    "        accent = accent\n",
    "\n",
    "    # if gender args passed in cli\n",
    "    if gender:\n",
    "        gender = gender\n",
    "\n",
    "    # filters the languages and accents\n",
    "    def filter_rule(voice, gender, language, accent, default):\n",
    "        if default:\n",
    "            return voice.gender in gender and voice.languages[0] == (language + '_' + accent)\n",
    "        return voice.languages[0] == (language + '_' + accent) or voice.name in [\"default\", \"Alex\"]\n",
    "\n",
    "\n",
    "    # Filtering voices based on given critaria\n",
    "    def filter_voice(voices, gender, language, accent, default=True):\n",
    "        filter_list = [voice for voice in voices if filter_rule(\n",
    "            voice, gender, language, accent, default)]\n",
    "        if len(filter_list):\n",
    "            return filter_list\n",
    "        return filter_voice(voices, gender, language, accent, False)\n",
    "\n",
    "\n",
    "    # update reader's language, accent and gender\n",
    "    def update_language(reader, language, accent, gender):\n",
    "        # Audio Type Selection Criteria\n",
    "        languages = {\"english\": \"en\", \"hindi\": \"hi\"}\n",
    "        genders = {\"male\": [\"VoiceGenderMale\", \"male\"], \"female\": [\"VoiceGenderFemale\", \"female\"], \"none\": [\"None\"]}\n",
    "        accents = {\"indian\": \"IN\", \"us\": \"US\", \"australian\": \"AU\", \"uk\": \"GB\"}\n",
    "\n",
    "        # getting list of filtered voices based on selection criteria\n",
    "        filtered_voice_list = filter_voice(reader.getProperty(\n",
    "            'voices'), genders[gender], languages[language], accents[accent])\n",
    "\n",
    "        if len(filtered_voice_list):\n",
    "            # Displaying the details of filtered voices\n",
    "            print(\"AVAILABLE READERS\")\n",
    "            for index, voice in enumerate(filtered_voice_list):\n",
    "                print(\"\\nVoice Index : %d\" % index)\n",
    "                print(\"ID: %s\" % voice.id)\n",
    "                print(\"Name: %s\" % voice.name)\n",
    "                print(\"Age: %s\" % voice.age)\n",
    "                print(\"Gender: %s\" % voice.gender)\n",
    "                print(\"Languages Known: %s\" % voice.languages)\n",
    "\n",
    "            index = 0\n",
    "            try:\n",
    "                if index and filtered_voice_list[int(index)]:\n",
    "                    index = int(index)\n",
    "            except IndexError:\n",
    "                pass\n",
    "\n",
    "            print(\"\\n%s is reading for you.\" % filtered_voice_list[index].name)\n",
    "            # applying the voice of selected reader\n",
    "        reader.setProperty('voice', filtered_voice_list[1].id)\n",
    "    #     else:\n",
    "    #         print(\"No reader available.\\nAlex is reading for you.\")\n",
    "\n",
    "\n",
    "    try:\n",
    "        # initialize the reading engine\n",
    "        reader = pyttsx3.init()\n",
    "\n",
    "        # updating readers language, accent and gender before reading text.\n",
    "        update_language(reader, language, accent, gender)\n",
    "\n",
    "        # read the given text\n",
    "        reader.say(text_to_read)\n",
    "\n",
    "        # Execution of reading process\n",
    "        reader.runAndWait()\n",
    "\n",
    "        # Finish the reading process\n",
    "        reader.stop()\n",
    "\n",
    "    except OSError as error:\n",
    "        traceback.print_exception(*sys.exc_info())\n",
    "        print(\"There is a chance that some required system lib is missing, install the lib and try again\")\n",
    "\n",
    "    except Exception as error:\n",
    "        traceback.print_exception(*sys.exc_info())\n",
    "        print(\"Someting went wrong; please report the issue at https://github.com/vishalnagda1/text-to-speech/issues\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7UZWQtdnl30H"
   },
   "outputs": [],
   "source": [
    "class Translator:\n",
    "  exit_commands = (\"quit\", \"pause\", \"exit\", \"goodbye\", \"bye\", \"later\", \"stop\")\n",
    "  \n",
    "  #Method to start the translator\n",
    "  def start(self):\n",
    "    user_response = eng_speak()\n",
    "    self.translate(user_response)\n",
    "  \n",
    "  #Method to handle the conversation\n",
    "  def translate(self, reply):\n",
    "    while not self.make_exit(reply):\n",
    "      talk(self.generate_response(reply)+\"\\n\")\n",
    "      reply = eng_speak()\n",
    "    \n",
    "\n",
    "  #Method to convert user input into a matrix\n",
    "  def string_to_matrix(self, user_input):\n",
    "    tokens = re.findall(r\"[\\w']+|[^\\s\\w]\", user_input)\n",
    "    user_input_matrix = np.zeros(\n",
    "      (1, max_encoder_seq_length, num_encoder_tokens),\n",
    "      dtype='float32')\n",
    "    for timestep, token in enumerate(tokens):\n",
    "      if token in input_features_dict:\n",
    "        user_input_matrix[0, timestep, input_features_dict[token]] = 1.\n",
    "    return user_input_matrix\n",
    "  \n",
    "  #Method that will create a response using seq2seq model we built\n",
    "  def generate_response(self, user_input):\n",
    "    input_matrix = self.string_to_matrix(user_input)\n",
    "    chatbot_response = decode_response(input_matrix)\n",
    "    #Remove <START> and <END> tokens from chatbot_response\n",
    "    chatbot_response = chatbot_response.replace(\"<START>\",'')\n",
    "    chatbot_response = chatbot_response.replace(\"<END>\",'')\n",
    "    return chatbot_response\n",
    "  \n",
    "  #Method to check for exit commands\n",
    "  def make_exit(self, reply):\n",
    "    for exit_command in self.exit_commands:\n",
    "      if exit_command in reply:\n",
    "        print(\"Ok, have a great day!\")\n",
    "        return True\n",
    "    return False\n",
    "  \n",
    "translator = Translator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 217
    },
    "colab_type": "code",
    "id": "gii_BGyFW2ji",
    "outputId": "7dab4283-e1fa-460f-de4e-ecff71128209"
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Give in an English sentence. :) \n",
      " he likes banana\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:AutoGraph could not transform <function Model.make_predict_function.<locals>.predict_function at 0x2b1b732dde60> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function Model.make_predict_function.<locals>.predict_function at 0x2b1b732dde60> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING:tensorflow:AutoGraph could not transform <function Model.make_predict_function.<locals>.predict_function at 0x2b1b73177dd0> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function Model.make_predict_function.<locals>.predict_function at 0x2b1b73177dd0> and will run it as-is.\n",
      "Please report this to the TensorFlow team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output.\n",
      "Cause: 'arguments' object has no attribute 'posonlyargs'\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " रात रात रात रात रात अगली अगली अगली अगली अगली अगली अगली अगली हिमयुग हिमयुग हिमयुग हिमयुग\n",
      " she likes peach\n",
      " रात रात रात रात रात अगली अगली अगली अगली अगली अगली अगली अगली हिमयुग हिमयुग हिमयुग हिमयुग\n",
      " hello\n",
      " रात रात बहुत बहुत बहुत अगली अगली अगली अगली अगली अगली अगली अगली हिमयुग हिमयुग हिमयुग हिमयुग\n",
      " bye\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ok, have a great day!\n"
     ]
    }
   ],
   "source": [
    "translator.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "MachineTranslation.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "tf2.0-gpu (Tensorflow)",
   "language": "python",
   "name": "tf2.0-gpu"
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}