AI_Recipe.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "420907d8-502f-41c8-879b-0eda38ee3ac3",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-26 10:12:47.409041: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-12-26 10:12:47.604137: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-12-26 10:12:47.604178: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-12-26 10:12:47.631552: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-12-26 10:12:47.693149: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python version: 3.11.0rc1\n",
      "Tensorflow version: 2.15.0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import platform\n",
    "import time\n",
    "import pathlib\n",
    "import os\n",
    "import json\n",
    "import zipfile\n",
    "import pandas as pd\n",
    "import graphviz\n",
    "import pydot\n",
    "# from google.colab import files\n",
    "\n",
    "print('Python version:', platform.python_version())\n",
    "print('Tensorflow version:', tf.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1fd33c62-68f9-44a2-aabd-24e6138aa3d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-26 10:12:50.458303: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-26 10:12:50.495548: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-26 10:12:50.495574: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n"
     ]
    }
   ],
   "source": [
    " tf.config.list_physical_devices('GPU')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f2179134-c2d6-4a39-b5aa-ab3f22ac9e54",
   "metadata": {},
   "outputs": [],
   "source": [
    "# gpus = tf.config.experimental.list_physical_devices('GPU')\n",
    "# if gpus:\n",
    "#     try:\n",
    "#         for gpu in gpus:\n",
    "#             tf.config.experimental.set_memory_growth(gpu, True)\n",
    "#     except RuntimeError as e:\n",
    "#         print(e)\n",
    "\n",
    "import tensorflow as tf\n",
    "\n",
    "physical_devices = tf.config.list_physical_devices('GPU')\n",
    "tf.config.experimental.set_memory_growth(physical_devices[0], True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d348bd1c-d4fb-4106-9330-cf04b3fa2e73",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_dataset(silent=False):\n",
    "    dataset_file_names = [\n",
    "        'recipes_raw_nosource_ar.json'\n",
    "    ]\n",
    "\n",
    "    dataset = []\n",
    "\n",
    "    for dataset_file_name in dataset_file_names:\n",
    "        dataset_file_path = os.path.join('/tf/recipce_AI/recipe_path_data', dataset_file_name)\n",
    "\n",
    "        with open(dataset_file_path, 'r', encoding='utf-8') as dataset_file:\n",
    "            json_data_dict = json.load(dataset_file)\n",
    "            json_data_list = list(json_data_dict.values())\n",
    "            dict_keys = [key for key in json_data_list[0]]\n",
    "            dict_keys.sort()\n",
    "            dataset += json_data_list\n",
    "\n",
    "            if not silent:\n",
    "                print(dataset_file_path)\n",
    "                print('===========================================')\n",
    "                print('Number of examples: ', len(json_data_list), '\\n')\n",
    "                print('Example object keys:\\n', dict_keys, '\\n')\n",
    "                print('Example object:\\n', json_data_list[0], '\\n')\n",
    "                print('Required keys:\\n')\n",
    "                print('  title: ', json_data_list[0]['title'], '\\n')\n",
    "                print('  ingredients: ', json_data_list[0]['ingredients'], '\\n')\n",
    "                print('  instructions: ', json_data_list[0]['instructions'])\n",
    "                print('\\n\\n')\n",
    "\n",
    "    return dataset\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "29b3ecde-f827-4494-900f-e3f803956e09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/tf/recipce_AI/recipe_path_data/recipes_raw_nosource_ar.json\n",
      "===========================================\n",
      "Number of examples:  39802 \n",
      "\n",
      "Example object keys:\n",
      " ['ingredients', 'instructions', 'picture_link', 'title'] \n",
      "\n",
      "Example object:\n",
      " {'title': 'Slow Cooker Chicken and Dumplings', 'ingredients': ['4 skinless, boneless chicken breast halves ADVERTISEMENT', '2 tablespoons butter ADVERTISEMENT', '2 (10.75 ounce) cans condensed cream of chicken soup ADVERTISEMENT', '1 onion, finely diced ADVERTISEMENT', '2 (10 ounce) packages refrigerated biscuit dough, torn into pieces ADVERTISEMENT', 'ADVERTISEMENT'], 'instructions': 'Place the chicken, butter, soup, and onion in a slow cooker, and fill with enough water to cover.\\nCover, and cook for 5 to 6 hours on High. About 30 minutes before serving, place the torn biscuit dough in the slow cooker. Cook until the dough is no longer raw in the center.\\n', 'picture_link': '55lznCYBbs2mT8BTx6BTkLhynGHzM.S'} \n",
      "\n",
      "Required keys:\n",
      "\n",
      "  title:  Slow Cooker Chicken and Dumplings \n",
      "\n",
      "  ingredients:  ['4 skinless, boneless chicken breast halves ADVERTISEMENT', '2 tablespoons butter ADVERTISEMENT', '2 (10.75 ounce) cans condensed cream of chicken soup ADVERTISEMENT', '1 onion, finely diced ADVERTISEMENT', '2 (10 ounce) packages refrigerated biscuit dough, torn into pieces ADVERTISEMENT', 'ADVERTISEMENT'] \n",
      "\n",
      "  instructions:  Place the chicken, butter, soup, and onion in a slow cooker, and fill with enough water to cover.\n",
      "Cover, and cook for 5 to 6 hours on High. About 30 minutes before serving, place the torn biscuit dough in the slow cooker. Cook until the dough is no longer raw in the center.\n",
      "\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "dataset_raw = load_dataset()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6053f56d-5fff-44d0-b32c-be4dbb0421ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of raw examples:  39802\n"
     ]
    }
   ],
   "source": [
    "print('Total number of raw examples: ', len(dataset_raw))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c18a0965-2ac7-4601-96d1-6a6024a65250",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "def cleaning_dataset(recipe, cleaned_titles):\n",
    "    required_keys = ['title', 'ingredients', 'instructions']\n",
    "    for key in required_keys:\n",
    "        if key not in recipe or not recipe[key]:\n",
    "            return False\n",
    "        if type(recipe[key]) == list and len(recipe[key]) == 0:\n",
    "            return False\n",
    "    title = recipe['title'].lower()\n",
    "    title_tuple = tuple(title)  # Convert title to tuple\n",
    "\n",
    "    if title_tuple in cleaned_titles:\n",
    "        return False\n",
    "\n",
    "    cleaned_titles.add(title_tuple)\n",
    "    return True\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "78d08fe9-89b7-4b54-94c9-f4301cf0dae5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset size BEFORE validation 39802\n",
      "Dataset size AFTER validation 39057\n",
      "Number of invalide recipes 745\n"
     ]
    }
   ],
   "source": [
    "cleaned_titles = set()\n",
    "dataset_validated = [recipe for recipe in dataset_raw if cleaning_dataset(recipe,cleaned_titles)]\n",
    "\n",
    "print('Dataset size BEFORE validation', len(dataset_raw))\n",
    "print('Dataset size AFTER validation', len(dataset_validated))\n",
    "print('Number of invalide recipes', len(dataset_raw) - len(dataset_validated))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a398cd20-2167-4620-9680-1d59b4b61e9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "STOP_WORD_TITLE = '📗 '\n",
    "STOP_WORD_INGREDIENTS = '\\n🥕\\n\\n'\n",
    "STOP_WORD_INSTRUCTIONS = '\\n📝\\n\\n'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5c296e37-ce75-419b-9260-277b0a94dd1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converts recipe object to string (sequence of characters) for later usage in RNN input.\n",
    "def cooking_to_string(recipe):\n",
    "    # This string is presented as a part of recipes so we need to clean it up.\n",
    "    noize_string = 'ADVERTISEMENT'\n",
    "    \n",
    "    title = recipe['title']\n",
    "    ingredients = recipe['ingredients']\n",
    "    instructions = recipe['instructions'].split('\\n')\n",
    "    \n",
    "    ingredients_string = ''\n",
    "    for ingredient in ingredients:\n",
    "        ingredient = ingredient.replace(noize_string, '')\n",
    "        if ingredient:\n",
    "            ingredients_string += f'• {ingredient}\\n'\n",
    "    \n",
    "    instructions_string = ''\n",
    "    for instruction in instructions:\n",
    "        instruction = instruction.replace(noize_string, '')\n",
    "        if instruction:\n",
    "            instructions_string += f'▪︎ {instruction}\\n'\n",
    "    \n",
    "    return f'{STOP_WORD_TITLE}{title}\\n{STOP_WORD_INGREDIENTS}{ingredients_string}{STOP_WORD_INSTRUCTIONS}{instructions_string}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fd38370c-a9c0-41b3-8ddf-8e7f5649fcb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stringified dataset size:  39057\n"
     ]
    }
   ],
   "source": [
    "dataset_stringified = [cooking_to_string(recipe) for recipe in dataset_validated]\n",
    "\n",
    "print('Stringified dataset size: ', len(dataset_stringified))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2f0b6c11-ee7d-4131-8cdf-b0c34eaf2834",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recipe #1\n",
      "---------\n",
      "📗 Slow Cooker Chicken and Dumplings\n",
      "\n",
      "🥕\n",
      "\n",
      "• 4 skinless, boneless chicken breast halves \n",
      "• 2 tablespoons butter \n",
      "• 2 (10.75 ounce) cans condensed cream of chicken soup \n",
      "• 1 onion, finely diced \n",
      "• 2 (10 ounce) packages refrigerated biscuit dough, torn into pieces \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ Place the chicken, butter, soup, and onion in a slow cooker, and fill with enough water to cover.\n",
      "▪︎ Cover, and cook for 5 to 6 hours on High. About 30 minutes before serving, place the torn biscuit dough in the slow cooker. Cook until the dough is no longer raw in the center.\n",
      "\n",
      "\n",
      "\n",
      "Recipe #2\n",
      "---------\n",
      "📗 Awesome Slow Cooker Pot Roast\n",
      "\n",
      "🥕\n",
      "\n",
      "• 2 (10.75 ounce) cans condensed cream of mushroom soup \n",
      "• 1 (1 ounce) package dry onion soup mix \n",
      "• 1 1/4 cups water \n",
      "• 5 1/2 pounds pot roast \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ In a slow cooker, mix cream of mushroom soup, dry onion soup mix and water. Place pot roast in slow cooker and coat with soup mixture.\n",
      "▪︎ Cook on High setting for 3 to 4 hours, or on Low setting for 8 to 9 hours.\n",
      "\n",
      "\n",
      "\n",
      "Recipe #3\n",
      "---------\n",
      "📗 Brown Sugar Meatloaf\n",
      "\n",
      "🥕\n",
      "\n",
      "• 1/2 cup packed brown sugar \n",
      "• 1/2 cup ketchup \n",
      "• 1 1/2 pounds lean ground beef \n",
      "• 3/4 cup milk \n",
      "• 2 eggs \n",
      "• 1 1/2 teaspoons salt \n",
      "• 1/4 teaspoon ground black pepper \n",
      "• 1 small onion, chopped \n",
      "• 1/4 teaspoon ground ginger \n",
      "• 3/4 cup finely crushed saltine cracker crumbs \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ Preheat oven to 350 degrees F (175 degrees C). Lightly grease a 5x9 inch loaf pan.\n",
      "▪︎ Press the brown sugar in the bottom of the prepared loaf pan and spread the ketchup over the sugar.\n",
      "▪︎ In a mixing bowl, mix thoroughly all remaining ingredients and shape into a loaf. Place on top of the ketchup.\n",
      "▪︎ Bake in preheated oven for 1 hour or until juices are clear.\n",
      "\n",
      "\n",
      "\n",
      "Recipe #4\n",
      "---------\n",
      "📗 Best Chocolate Chip Cookies\n",
      "\n",
      "🥕\n",
      "\n",
      "• 1 cup butter, softened \n",
      "• 1 cup white sugar \n",
      "• 1 cup packed brown sugar \n",
      "• 2 eggs \n",
      "• 2 teaspoons vanilla extract \n",
      "• 3 cups all-purpose flour \n",
      "• 1 teaspoon baking soda \n",
      "• 2 teaspoons hot water \n",
      "• 1/2 teaspoon salt \n",
      "• 2 cups semisweet chocolate chips \n",
      "• 1 cup chopped walnuts \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ Preheat oven to 350 degrees F (175 degrees C).\n",
      "▪︎ Cream together the butter, white sugar, and brown sugar until smooth. Beat in the eggs one at a time, then stir in the vanilla. Dissolve baking soda in hot water. Add to batter along with salt. Stir in flour, chocolate chips, and nuts. Drop by large spoonfuls onto ungreased pans.\n",
      "▪︎ Bake for about 10 minutes in the preheated oven, or until edges are nicely browned.\n",
      "\n",
      "\n",
      "\n",
      "Recipe #5\n",
      "---------\n",
      "📗 Homemade Mac and Cheese Casserole\n",
      "\n",
      "🥕\n",
      "\n",
      "• 8 ounces whole wheat rotini pasta \n",
      "• 3 cups fresh broccoli florets \n",
      "• 1 medium onion, chopped \n",
      "• 3 cloves garlic, minced \n",
      "• 4 tablespoons butter, divided \n",
      "• 2 tablespoons all-purpose flour \n",
      "• 1/4 teaspoon salt \n",
      "• 1/8 teaspoon ground black pepper \n",
      "• 2 1/2 cups milk \n",
      "• 8 ounces Cheddar cheese, shredded \n",
      "• 4 ounces reduced-fat cream cheese, cubed and softened \n",
      "• 1/2 cup fine dry Italian-seasoned bread crumbs \n",
      "• Reynolds Wrap® Non Stick Aluminum Foil \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ Preheat oven to 350 degrees F. Line a 2-quart casserole dish with Reynolds Wrap(R) Pan Lining Paper, parchment side up. No need to grease dish.\n",
      "▪︎ Cook the pasta in a large saucepan according to the package directions, adding the broccoli for the last 3 minutes of cooking. Drain. Return to the saucepan and set aside.\n",
      "▪︎ Cook the onion and garlic in 2 tablespoons hot butter in a large skillet 5 to 7 minutes or until tender. Stir in flour, salt, and black pepper. Add the milk all at once. Cook and stir over medium heat until slightly thickened and bubbly. Add cheddar cheese and cream cheese, stirring until melted. Pour cheese sauce over the pasta and broccoli and stir until well combined.\n",
      "▪︎ Melt the remaining 2 tablespoons butter and mix with the bread crumbs in a small bowl. Transfer the pasta mixture to the prepared casserole dish. Top with the buttery bread crumbs.\n",
      "▪︎ Bake, uncovered, about 25 minutes or until bubbly and internal temperature is 165 degrees F. Let stand for 10 minutes before serving.\n",
      "\n",
      "\n",
      "\n",
      "Recipe #6\n",
      "---------\n",
      "📗 Banana Banana Bread\n",
      "\n",
      "🥕\n",
      "\n",
      "• 2 cups all-purpose flour \n",
      "• 1 teaspoon baking soda \n",
      "• 1/4 teaspoon salt \n",
      "• 1/2 cup butter \n",
      "• 3/4 cup brown sugar \n",
      "• 2 eggs, beaten \n",
      "• 2 1/3 cups mashed overripe bananas \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ Preheat oven to 350 degrees F (175 degrees C). Lightly grease a 9x5 inch loaf pan.\n",
      "▪︎ In a large bowl, combine flour, baking soda and salt. In a separate bowl, cream together butter and brown sugar. Stir in eggs and mashed bananas until well blended. Stir banana mixture into flour mixture; stir just to moisten. Pour batter into prepared loaf pan.\n",
      "▪︎ Bake in preheated oven for 60 to 65 minutes, until a toothpick inserted into center of the loaf comes out clean. Let bread cool in pan for 10 minutes, then turn out onto a wire rack.\n",
      "\n",
      "\n",
      "\n",
      "Recipe #7\n",
      "---------\n",
      "📗 Chef John's Fisherman's Pie\n",
      "\n",
      "🥕\n",
      "\n",
      "• For potato crust: \n",
      "• 3 russet potatoes, peeled and cut into chunks \n",
      "• 3 tablespoons butter \n",
      "• 1 pinch freshly grated nutmeg \n",
      "• salt and ground black pepper to taste \n",
      "• 1 pinch cayenne pepper, or to taste \n",
      "• 1/2 cup milk \n",
      "• For the spinach: \n",
      "• 2 teaspoons olive oil \n",
      "• 12 ounces baby spinach leaves \n",
      "• For the sauce: \n",
      "• 3 tablespoons butter \n",
      "• 3 tablespoons all-purpose flour \n",
      "• 2 cloves garlic, minced \n",
      "• 2 cups cold milk, divided \n",
      "• 2 teaspoons lemon zest \n",
      "• For the rest: \n",
      "• 1 tablespoon butter \n",
      "• salt and ground black pepper to taste \n",
      "• 1 pinch cayenne pepper, or to taste \n",
      "• 2 pounds boneless cod fillets \n",
      "• 1/2 lemon, juiced \n",
      "• 1 tablespoon chopped fresh chives for garnish \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ Bring a large saucepan of salted water and to a boil; add russet potatoes to boiling water and cook until very tender, about 20 minutes. Drain well. Mash in 3 tablespoons butter until thoroughly combined. Season with nutmeg, salt, black pepper, and cayenne pepper to taste. Mash 1/2 cup milk into potato mixture until smooth.\n",
      "▪︎ Drizzle olive oil in a large Dutch oven over medium-high heat, add spinach, and season with a big pinch of salt. Cook, stirring occasionally, until spinach has wilted, about 1 minute. Transfer to a bowl lined with paper towels to wick away excess moisture.\n",
      "▪︎ Heat 3 tablespoons butter and flour in a saucepan over medium heat; whisk mixture to a smooth paste. Cook, stirring constantly, until mixture has a nutty smell and is slightly browned, about 2 minutes. Add chopped garlic; whisk until fragrant, 10 to 20 seconds.\n",
      "▪︎ Whisk 1 cup cold milk into flour mixture; cook until thickened. Whisk in remaining 1 cup milk and lemon zest. Bring white sauce to a gentle simmer, whisking constantly; season with salt. Turn heat to very low and keep sauce warm.\n",
      "▪︎ Preheat oven to 375 degrees F (190 degrees C). Grease an 8x12-inch casserole dish with 1 tablespoon butter.\n",
      "▪︎ Season buttered pan with salt, black pepper, and cayenne pepper. Lay boneless cod fillets into the pan in a single layer. Season tops of fillets with more salt, black pepper, and cayenne pepper. Spread spinach evenly over fish and drizzle with lemon juice. Spoon white sauce over spinach; give casserole dish several taps and shakes to eliminate bubbles.\n",
      "▪︎ Drop mashed potatoes by heaping spoonfuls over the casserole and spread smoothly to cover. Place dish onto a rimmed baking sheet to catch spills.\n",
      "▪︎ Bake in the preheated oven until bubbling, about 40 minutes. Turn on oven's broiler and broil until potato crust has a golden brown top, about 2 minutes. Fish should flake easily. Let stand 10 minutes before serving. Garnish with a sprinkle of chives.\n",
      "\n",
      "\n",
      "\n",
      "Recipe #8\n",
      "---------\n",
      "📗 Mom's Zucchini Bread\n",
      "\n",
      "🥕\n",
      "\n",
      "• 3 cups all-purpose flour \n",
      "• 1 teaspoon salt \n",
      "• 1 teaspoon baking soda \n",
      "• 1 teaspoon baking powder \n",
      "• 1 tablespoon ground cinnamon \n",
      "• 3 eggs \n",
      "• 1 cup vegetable oil \n",
      "• 2 1/4 cups white sugar \n",
      "• 3 teaspoons vanilla extract \n",
      "• 2 cups grated zucchini \n",
      "• 1 cup chopped walnuts \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ Grease and flour two 8 x 4 inch pans. Preheat oven to 325 degrees F (165 degrees C).\n",
      "▪︎ Sift flour, salt, baking powder, soda, and cinnamon together in a bowl.\n",
      "▪︎ Beat eggs, oil, vanilla, and sugar together in a large bowl. Add sifted ingredients to the creamed mixture, and beat well. Stir in zucchini and nuts until well combined. Pour batter into prepared pans.\n",
      "▪︎ Bake for 40 to 60 minutes, or until tester inserted in the center comes out clean. Cool in pan on rack for 20 minutes. Remove bread from pan, and completely cool.\n",
      "\n",
      "\n",
      "\n",
      "Recipe #9\n",
      "---------\n",
      "📗 The Best Rolled Sugar Cookies\n",
      "\n",
      "🥕\n",
      "\n",
      "• 1 1/2 cups butter, softened \n",
      "• 2 cups white sugar \n",
      "• 4 eggs \n",
      "• 1 teaspoon vanilla extract \n",
      "• 5 cups all-purpose flour \n",
      "• 2 teaspoons baking powder \n",
      "• 1 teaspoon salt \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ In a large bowl, cream together butter and sugar until smooth. Beat in eggs and vanilla. Stir in the flour, baking powder, and salt. Cover, and chill dough for at least one hour (or overnight).\n",
      "▪︎ Preheat oven to 400 degrees F (200 degrees C). Roll out dough on floured surface 1/4 to 1/2 inch thick. Cut into shapes with any cookie cutter. Place cookies 1 inch apart on ungreased cookie sheets.\n",
      "▪︎ Bake 6 to 8 minutes in preheated oven. Cool completely.\n",
      "\n",
      "\n",
      "\n",
      "Recipe #10\n",
      "---------\n",
      "📗 Singapore Chili Crabs\n",
      "\n",
      "🥕\n",
      "\n",
      "• Sauce: \n",
      "• 1/2 cup ketchup \n",
      "• 1/2 cup chicken broth \n",
      "• 1 large egg \n",
      "• 2 tablespoons soy sauce \n",
      "• 2 tablespoons chile-garlic sauce (such as sambal oelek) \n",
      "• 1 tablespoon oyster sauce \n",
      "• 1 tablespoon tamarind paste \n",
      "• 2 teaspoons fish sauce \n",
      "• 2 teaspoons palm sugar \n",
      "• 1/4 cup minced shallot \n",
      "• 6 cloves garlic, minced \n",
      "• 2 tablespoons vegetable oil, or more as needed \n",
      "• 2 tablespoons minced fresh ginger root \n",
      "• 1 tablespoon minced serrano pepper \n",
      "• 2 cooked Dungeness crabs, cleaned and cracked \n",
      "• 2 tablespoons chopped fresh cilantro \n",
      "• 2 tablespoons sliced green onion (green part only) \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ Whisk ketchup, chicken broth, egg, soy sauce, chile-garlic sauce, oyster sauce, tamarind paste, fish sauce, and palm sugar together in a bowl.\n",
      "▪︎ Stir shallots, garlic, oil, ginger, and serrano pepper together in a pot over medium-high heat. Saute until sizzling, about 2 minutes. Add crab to pot, cover the pot with a lid, and shake until crab is completely coated in shallot mixture. Remove lid and cook and stir until heated through, about 3 minutes.\n",
      "▪︎ Pour ketchup mixture into pot, reduce heat to medium, and cook and stir until sauce thickens and crab is hot about 5 minutes. Remove from heat; stir in cilantro and green onions.\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for recipe_index, recipe_string in enumerate(dataset_stringified[:10]):\n",
    "    print('Recipe #{}\\n---------'.format(recipe_index + 1))\n",
    "    print(recipe_string)\n",
    "    print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "bdbb6138-26a5-4815-ac3e-81963616a99e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "📗 Savory Garlic Marinated Steaks\n",
      "\n",
      "🥕\n",
      "\n",
      "• 1/2 cup balsamic vinegar \n",
      "• 1/4 cup soy sauce \n",
      "• 3 tablespoons minced garlic \n",
      "• 2 tablespoons honey \n",
      "• 2 tablespoons olive oil \n",
      "• 2 teaspoons ground black pepper \n",
      "• 1 teaspoon Worcestershire sauce \n",
      "• 1 teaspoon onion powder \n",
      "• 1/2 teaspoon salt \n",
      "• 1/2 teaspoon liquid smoke flavoring \n",
      "• 1 pinch cayenne pepper \n",
      "• 2 (1/2 pound) rib-eye steaks \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ In a medium bowl, mix the vinegar, soy sauce, garlic, honey, olive oil, ground black pepper, Worcestershire sauce, onion powder, salt, liquid smoke, and cayenne pepper.\n",
      "▪︎ Place steaks in a shallow glass dish with the marinade, and turn to coat. For optimum flavor, rub the liquid into the meat. Cover, and marinate in the refrigerator for 1 to 2 days.\n",
      "▪︎ Preheat grill for medium-high to high heat.\n",
      "▪︎ Lightly oil the grill grate. Grill steaks 7 minutes per side, or to desired doneness. Discard leftover marinade.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(dataset_stringified[500])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a8ef7271-fd3b-41e9-9747-1a239284eca6",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Recipes have different lengths. We need to have one hard-coded sequence length limit before feeding recipes sequences to RNN. \n",
    "#We need to find out what recipe length will cover most of recipe use-cases and at the same time we want to keep it as small \n",
    "#as possible for training performance.\n",
    "\n",
    "recipes_lengths = []\n",
    "for recipe_text in dataset_stringified:\n",
    "    recipes_lengths.append(len(recipe_text))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8b09570a-b0a1-4d71-8a11-789b2675a26d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(recipes_lengths, bins=50)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "67531b70-dcb6-451f-a651-001208bf132a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjAAAAGdCAYAAAAMm0nCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAvoElEQVR4nO3de3RU5b3/8U9CyBDAmXDLhEgCsVggCshFYerlHDSHEWNPrdElNiIK6IITrEmU21FRsRUWLktBBap4CGspRThLqJJCjAFClYAYjXKRiDUaFCexxcwAhQTI8/vDX/ZhBJWES3jG92utvZazn+/e83zd7czHnb33RBljjAAAACwS3dITAAAAaCoCDAAAsA4BBgAAWIcAAwAArEOAAQAA1iHAAAAA6xBgAACAdQgwAADAOjEtPYGzpaGhQXv37tUFF1ygqKiolp4OAAA4BcYY7d+/X0lJSYqO/v7zLBEbYPbu3avk5OSWngYAAGiGPXv2qFu3bt87HrEB5oILLpD07b8At9vdwrMBAACnIhQKKTk52fke/z4RG2Aa/2zkdrsJMAAAWObHLv/gIl4AAGAdAgwAALAOAQYAAFiHAAMAAKxDgAEAANYhwAAAAOsQYAAAgHUIMAAAwDoEGAAAYB0CDAAAsA4BBgAAWKdJAaZHjx6Kioo6YcnOzpYkHT58WNnZ2erUqZPat2+vzMxMVVdXh+2jqqpKGRkZatu2rRISEjRp0iQdPXo0rGbDhg0aOHCgXC6Xevbsqfz8/NPrEgAARJQmBZitW7fqq6++cpaioiJJ0q233ipJys3N1euvv64VK1aopKREe/fu1c033+xsf+zYMWVkZKi+vl6bNm3SkiVLlJ+fr+nTpzs1lZWVysjI0LBhw1ReXq6cnByNGzdOhYWFZ6JfAAAQAaKMMaa5G+fk5Gj16tXavXu3QqGQunTpoqVLl+qWW26RJO3atUt9+vRRaWmphg4dqjVr1ujGG2/U3r175fV6JUkLFy7UlClT9PXXXys2NlZTpkxRQUGBtm/f7rzPyJEjVVtbq7Vr157y3EKhkDwej4LBIL9GDQCAJU71+zumuW9QX1+vl156SXl5eYqKilJZWZmOHDmi9PR0p6Z3795KSUlxAkxpaan69u3rhBdJ8vv9mjBhgnbs2KEBAwaotLQ0bB+NNTk5Oc2dasTrMbXgR2s+m5VxDmYCAMC50ewAs2rVKtXW1uquu+6SJAUCAcXGxio+Pj6szuv1KhAIODXHh5fG8caxH6oJhUI6dOiQ4uLiTjqfuro61dXVOa9DoVBzWwMAAOe5Zt+F9OKLL2rEiBFKSko6k/NptpkzZ8rj8ThLcnJyS08JAACcJc0KMJ9//rnefPNNjRs3zlmXmJio+vp61dbWhtVWV1crMTHRqfnuXUmNr3+sxu12f+/ZF0maNm2agsGgs+zZs6c5rQEAAAs0K8AsXrxYCQkJysj4v+sqBg0apNatW6u4uNhZV1FRoaqqKvl8PkmSz+fTtm3bVFNT49QUFRXJ7XYrLS3NqTl+H401jfv4Pi6XS263O2wBAACRqckBpqGhQYsXL9bo0aMVE/N/l9B4PB6NHTtWeXl5Wr9+vcrKynT33XfL5/Np6NChkqThw4crLS1No0aN0gcffKDCwkI9/PDDys7OlsvlkiSNHz9en376qSZPnqxdu3Zp/vz5Wr58uXJzc89QywAAwHZNvoj3zTffVFVVlcaMGXPC2Jw5cxQdHa3MzEzV1dXJ7/dr/vz5znirVq20evVqTZgwQT6fT+3atdPo0aM1Y8YMpyY1NVUFBQXKzc3V3Llz1a1bNy1atEh+v7+ZLQIAgEhzWs+BOZ/9lJ4Dw23UAIBIcarf3/wWEgAAsA4BBgAAWIcAAwAArEOAAQAA1iHAAAAA6xBgAACAdQgwAADAOgQYAABgHQIMAACwDgEGAABYhwADAACsQ4ABAADWIcAAAADrxLT0BHBunMovVkv8ajUAwA6cgQEAANYhwAAAAOsQYAAAgHUIMAAAwDoEGAAAYB0CDAAAsA4BBgAAWIcAAwAArEOAAQAA1iHAAAAA6xBgAACAdQgwAADAOgQYAABgHQIMAACwDgEGAABYhwADAACsQ4ABAADWIcAAAADrEGAAAIB1CDAAAMA6BBgAAGAdAgwAALAOAQYAAFiHAAMAAKxDgAEAANYhwAAAAOs0OcB8+eWXuuOOO9SpUyfFxcWpb9++evfdd51xY4ymT5+url27Ki4uTunp6dq9e3fYPvbt26esrCy53W7Fx8dr7NixOnDgQFjNhx9+qKuvvlpt2rRRcnKyZs+e3cwWAQBApGlSgPnmm2905ZVXqnXr1lqzZo127typp59+Wh06dHBqZs+erXnz5mnhwoXasmWL2rVrJ7/fr8OHDzs1WVlZ2rFjh4qKirR69Wpt3LhR9957rzMeCoU0fPhwde/eXWVlZXrqqaf02GOP6fnnnz8DLQMAANtFGWPMqRZPnTpVb7/9tv72t7+ddNwYo6SkJD3wwAN68MEHJUnBYFBer1f5+fkaOXKkPvroI6WlpWnr1q0aPHiwJGnt2rW64YYb9MUXXygpKUkLFizQQw89pEAgoNjYWOe9V61apV27dp3SXEOhkDwej4LBoNxu96m2aKUeUwvO2L4+m5VxxvYFAEBTner3d5POwLz22msaPHiwbr31ViUkJGjAgAF64YUXnPHKykoFAgGlp6c76zwej4YMGaLS0lJJUmlpqeLj453wIknp6emKjo7Wli1bnJprrrnGCS+S5Pf7VVFRoW+++eakc6urq1MoFApbAABAZGpSgPn000+1YMECXXzxxSosLNSECRP029/+VkuWLJEkBQIBSZLX6w3bzuv1OmOBQEAJCQlh4zExMerYsWNYzcn2cfx7fNfMmTPl8XicJTk5uSmtAQAAizQpwDQ0NGjgwIF68sknNWDAAN1777265557tHDhwrM1v1M2bdo0BYNBZ9mzZ09LTwkAAJwlTQowXbt2VVpaWti6Pn36qKqqSpKUmJgoSaqurg6rqa6udsYSExNVU1MTNn706FHt27cvrOZk+zj+Pb7L5XLJ7XaHLQAAIDI1KcBceeWVqqioCFv38ccfq3v37pKk1NRUJSYmqri42BkPhULasmWLfD6fJMnn86m2tlZlZWVOzbp169TQ0KAhQ4Y4NRs3btSRI0ecmqKiIvXq1SvsjicAAPDT1KQAk5ubq82bN+vJJ5/UJ598oqVLl+r5559Xdna2JCkqKko5OTn63e9+p9dee03btm3TnXfeqaSkJN10002Svj1jc/311+uee+7RO++8o7ffflsTJ07UyJEjlZSUJEn6zW9+o9jYWI0dO1Y7duzQK6+8orlz5yovL+/Mdg8AAKwU05Tiyy+/XCtXrtS0adM0Y8YMpaam6o9//KOysrKcmsmTJ+vgwYO69957VVtbq6uuukpr165VmzZtnJqXX35ZEydO1HXXXafo6GhlZmZq3rx5zrjH49Ebb7yh7OxsDRo0SJ07d9b06dPDnhUDAAB+upr0HBibRMpzYM7kM15OBc+BAQC0pLPyHBgAAIDzAQEGAABYhwADAACsQ4ABAADWIcAAAADrEGAAAIB1CDAAAMA6BBgAAGAdAgwAALAOAQYAAFiHAAMAAKxDgAEAANYhwAAAAOsQYAAAgHUIMAAAwDoEGAAAYB0CDAAAsA4BBgAAWIcAAwAArEOAAQAA1iHAAAAA6xBgAACAdQgwAADAOgQYAABgHQIMAACwDgEGAABYhwADAACsQ4ABAADWIcAAAADrEGAAAIB1CDAAAMA6BBgAAGAdAgwAALAOAQYAAFiHAAMAAKxDgAEAANYhwAAAAOsQYAAAgHUIMAAAwDpNCjCPPfaYoqKiwpbevXs744cPH1Z2drY6deqk9u3bKzMzU9XV1WH7qKqqUkZGhtq2bauEhARNmjRJR48eDavZsGGDBg4cKJfLpZ49eyo/P7/5HaJJekwt+NEFAICW1uQzMJdccom++uorZ3nrrbecsdzcXL3++utasWKFSkpKtHfvXt18883O+LFjx5SRkaH6+npt2rRJS5YsUX5+vqZPn+7UVFZWKiMjQ8OGDVN5eblycnI0btw4FRYWnmarAAAgUsQ0eYOYGCUmJp6wPhgM6sUXX9TSpUt17bXXSpIWL16sPn36aPPmzRo6dKjeeOMN7dy5U2+++aa8Xq8uu+wyPfHEE5oyZYoee+wxxcbGauHChUpNTdXTTz8tSerTp4/eeustzZkzR36//zTbBQAAkaDJZ2B2796tpKQkXXTRRcrKylJVVZUkqaysTEeOHFF6erpT27t3b6WkpKi0tFSSVFpaqr59+8rr9To1fr9foVBIO3bscGqO30djTeM+vk9dXZ1CoVDYAgAAIlOTAsyQIUOUn5+vtWvXasGCBaqsrNTVV1+t/fv3KxAIKDY2VvHx8WHbeL1eBQIBSVIgEAgLL43jjWM/VBMKhXTo0KHvndvMmTPl8XicJTk5uSmtAQAAizTpT0gjRoxw/rlfv34aMmSIunfvruXLlysuLu6MT64ppk2bpry8POd1KBQixAAAEKFO6zbq+Ph4/fznP9cnn3yixMRE1dfXq7a2NqymurrauWYmMTHxhLuSGl//WI3b7f7BkORyueR2u8MWAAAQmU4rwBw4cEB///vf1bVrVw0aNEitW7dWcXGxM15RUaGqqir5fD5Jks/n07Zt21RTU+PUFBUVye12Ky0tzak5fh+NNY37AAAAaFKAefDBB1VSUqLPPvtMmzZt0q9//Wu1atVKt99+uzwej8aOHau8vDytX79eZWVluvvuu+Xz+TR06FBJ0vDhw5WWlqZRo0bpgw8+UGFhoR5++GFlZ2fL5XJJksaPH69PP/1UkydP1q5duzR//nwtX75cubm5Z757AABgpSZdA/PFF1/o9ttv1z//+U916dJFV111lTZv3qwuXbpIkubMmaPo6GhlZmaqrq5Ofr9f8+fPd7Zv1aqVVq9erQkTJsjn86ldu3YaPXq0ZsyY4dSkpqaqoKBAubm5mjt3rrp166ZFixZxCzUAAHBEGWNMS0/ibAiFQvJ4PAoGg1ZfD3M+Pvn2s1kZLT0FAECEOtXvb34LCQAAWIcAAwAArEOAAQAA1iHAAAAA6xBgAACAdQgwAADAOgQYAABgHQIMAACwDgEGAABYhwADAACsQ4ABAADWIcAAAADrEGAAAIB1CDAAAMA6BBgAAGAdAgwAALAOAQYAAFiHAAMAAKxDgAEAANYhwAAAAOsQYAAAgHUIMAAAwDoEGAAAYB0CDAAAsA4BBgAAWIcAAwAArEOAAQAA1iHAAAAA6xBgAACAdQgwAADAOgQYAABgHQIMAACwDgEGAABYhwADAACsQ4ABAADWIcAAAADrEGAAAIB1CDAAAMA6BBgAAGCd0wows2bNUlRUlHJycpx1hw8fVnZ2tjp16qT27dsrMzNT1dXVYdtVVVUpIyNDbdu2VUJCgiZNmqSjR4+G1WzYsEEDBw6Uy+VSz549lZ+ffzpTBQAAEaTZAWbr1q3605/+pH79+oWtz83N1euvv64VK1aopKREe/fu1c033+yMHzt2TBkZGaqvr9emTZu0ZMkS5efna/r06U5NZWWlMjIyNGzYMJWXlysnJ0fjxo1TYWFhc6cLAAAiSLMCzIEDB5SVlaUXXnhBHTp0cNYHg0G9+OKL+sMf/qBrr71WgwYN0uLFi7Vp0yZt3rxZkvTGG29o586deumll3TZZZdpxIgReuKJJ/Tcc8+pvr5ekrRw4UKlpqbq6aefVp8+fTRx4kTdcsstmjNnzhloGQAA2K5ZASY7O1sZGRlKT08PW19WVqYjR46Ere/du7dSUlJUWloqSSotLVXfvn3l9XqdGr/fr1AopB07djg139233+939nEydXV1CoVCYQsAAIhMMU3dYNmyZXrvvfe0devWE8YCgYBiY2MVHx8ftt7r9SoQCDg1x4eXxvHGsR+qCYVCOnTokOLi4k5475kzZ+rxxx9vajsAAMBCTToDs2fPHt1///16+eWX1aZNm7M1p2aZNm2agsGgs+zZs6elpwQAAM6SJgWYsrIy1dTUaODAgYqJiVFMTIxKSko0b948xcTEyOv1qr6+XrW1tWHbVVdXKzExUZKUmJh4wl1Jja9/rMbtdp/07IskuVwuud3usAUAAESmJgWY6667Ttu2bVN5ebmzDB48WFlZWc4/t27dWsXFxc42FRUVqqqqks/nkyT5fD5t27ZNNTU1Tk1RUZHcbrfS0tKcmuP30VjTuA8AAPDT1qRrYC644AJdeumlYevatWunTp06OevHjh2rvLw8dezYUW63W/fdd598Pp+GDh0qSRo+fLjS0tI0atQozZ49W4FAQA8//LCys7PlcrkkSePHj9ezzz6ryZMna8yYMVq3bp2WL1+ugoKCM9EzAACwXJMv4v0xc+bMUXR0tDIzM1VXVye/36/58+c7461atdLq1as1YcIE+Xw+tWvXTqNHj9aMGTOcmtTUVBUUFCg3N1dz585Vt27dtGjRIvn9/jM9XQAAYKEoY4xp6UmcDaFQSB6PR8Fg0OrrYXpMPf/OOn02K6OlpwAAiFCn+v3NbyEBAADrEGAAAIB1CDAAAMA6BBgAAGAdAgwAALAOAQYAAFiHAAMAAKxDgAEAANY540/ixak7Hx9SBwCADTgDAwAArEOAAQAA1iHAAAAA6xBgAACAdQgwAADAOgQYAABgHQIMAACwDgEGAABYhwADAACsQ4ABAADWIcAAAADr8FtIaLJT+Q2nz2ZlnIOZAAB+qjgDAwAArEOAAQAA1iHAAAAA6xBgAACAdQgwAADAOgQYAABgHQIMAACwDgEGAABYhwADAACsQ4ABAADWIcAAAADrEGAAAIB1CDAAAMA6BBgAAGAdAgwAALAOAQYAAFiHAAMAAKxDgAEAANZpUoBZsGCB+vXrJ7fbLbfbLZ/PpzVr1jjjhw8fVnZ2tjp16qT27dsrMzNT1dXVYfuoqqpSRkaG2rZtq4SEBE2aNElHjx4Nq9mwYYMGDhwol8ulnj17Kj8/v/kdAgCAiNOkANOtWzfNmjVLZWVlevfdd3XttdfqV7/6lXbs2CFJys3N1euvv64VK1aopKREe/fu1c033+xsf+zYMWVkZKi+vl6bNm3SkiVLlJ+fr+nTpzs1lZWVysjI0LBhw1ReXq6cnByNGzdOhYWFZ6hlAABguyhjjDmdHXTs2FFPPfWUbrnlFnXp0kVLly7VLbfcIknatWuX+vTpo9LSUg0dOlRr1qzRjTfeqL1798rr9UqSFi5cqClTpujrr79WbGyspkyZooKCAm3fvt15j5EjR6q2tlZr16495XmFQiF5PB4Fg0G53e7TafGs6TG1oKWncNZ8NiujpacAALDQqX5/N/samGPHjmnZsmU6ePCgfD6fysrKdOTIEaWnpzs1vXv3VkpKikpLSyVJpaWl6tu3rxNeJMnv9ysUCjlncUpLS8P20VjTuI/vU1dXp1AoFLYAAIDI1OQAs23bNrVv314ul0vjx4/XypUrlZaWpkAgoNjYWMXHx4fVe71eBQIBSVIgEAgLL43jjWM/VBMKhXTo0KHvndfMmTPl8XicJTk5uamtAQAASzQ5wPTq1Uvl5eXasmWLJkyYoNGjR2vnzp1nY25NMm3aNAWDQWfZs2dPS08JAACcJTFN3SA2NlY9e/aUJA0aNEhbt27V3Llzddttt6m+vl61tbVhZ2Gqq6uVmJgoSUpMTNQ777wTtr/Gu5SOr/nunUvV1dVyu92Ki4v73nm5XC65XK6mtgMAACx02s+BaWhoUF1dnQYNGqTWrVuruLjYGauoqFBVVZV8Pp8kyefzadu2baqpqXFqioqK5Ha7lZaW5tQcv4/GmsZ9AAAANOkMzLRp0zRixAilpKRo//79Wrp0qTZs2KDCwkJ5PB6NHTtWeXl56tixo9xut+677z75fD4NHTpUkjR8+HClpaVp1KhRmj17tgKBgB5++GFlZ2c7Z0/Gjx+vZ599VpMnT9aYMWO0bt06LV++XAUFkXvHDgAAaJomBZiamhrdeeed+uqrr+TxeNSvXz8VFhbqP/7jPyRJc+bMUXR0tDIzM1VXVye/36/58+c727dq1UqrV6/WhAkT5PP51K5dO40ePVozZsxwalJTU1VQUKDc3FzNnTtX3bp106JFi+T3+89QywAAwHan/RyY8xXPgWlZPAcGANAcZ/05MAAAAC2FAAMAAKxDgAEAANYhwAAAAOsQYAAAgHUIMAAAwDoEGAAAYB0CDAAAsA4BBgAAWIcAAwAArEOAAQAA1iHAAAAA6xBgAACAdQgwAADAOgQYAABgHQIMAACwDgEGAABYhwADAACsQ4ABAADWIcAAAADrEGAAAIB1CDAAAMA6BBgAAGAdAgwAALAOAQYAAFiHAAMAAKxDgAEAANYhwAAAAOsQYAAAgHViWnoCiEw9phb8aM1nszLOwUwAAJGIMzAAAMA6BBgAAGAdAgwAALAOAQYAAFiHAAMAAKxDgAEAANYhwAAAAOsQYAAAgHUIMAAAwDpNCjAzZ87U5ZdfrgsuuEAJCQm66aabVFFREVZz+PBhZWdnq1OnTmrfvr0yMzNVXV0dVlNVVaWMjAy1bdtWCQkJmjRpko4ePRpWs2HDBg0cOFAul0s9e/ZUfn5+8zoEAAARp0kBpqSkRNnZ2dq8ebOKiop05MgRDR8+XAcPHnRqcnNz9frrr2vFihUqKSnR3r17dfPNNzvjx44dU0ZGhurr67Vp0yYtWbJE+fn5mj59ulNTWVmpjIwMDRs2TOXl5crJydG4ceNUWFh4BloGAAC2izLGmOZu/PXXXyshIUElJSW65pprFAwG1aVLFy1dulS33HKLJGnXrl3q06ePSktLNXToUK1Zs0Y33nij9u7dK6/XK0lauHChpkyZoq+//lqxsbGaMmWKCgoKtH37due9Ro4cqdraWq1du/aU5hYKheTxeBQMBuV2u5vb4ll1Kr8XFMn4LSQAwHed6vf3aV0DEwwGJUkdO3aUJJWVlenIkSNKT093anr37q2UlBSVlpZKkkpLS9W3b18nvEiS3+9XKBTSjh07nJrj99FY07iPk6mrq1MoFApbAABAZGp2gGloaFBOTo6uvPJKXXrppZKkQCCg2NhYxcfHh9V6vV4FAgGn5vjw0jjeOPZDNaFQSIcOHTrpfGbOnCmPx+MsycnJzW0NAACc55odYLKzs7V9+3YtW7bsTM6n2aZNm6ZgMOgse/bsaekpAQCAsySmORtNnDhRq1ev1saNG9WtWzdnfWJiourr61VbWxt2Fqa6ulqJiYlOzTvvvBO2v8a7lI6v+e6dS9XV1XK73YqLizvpnFwul1wuV3PaAQAAlmnSGRhjjCZOnKiVK1dq3bp1Sk1NDRsfNGiQWrdureLiYmddRUWFqqqq5PP5JEk+n0/btm1TTU2NU1NUVCS32620tDSn5vh9NNY07gMAAPy0NekMTHZ2tpYuXaq//OUvuuCCC5xrVjwej+Li4uTxeDR27Fjl5eWpY8eOcrvduu++++Tz+TR06FBJ0vDhw5WWlqZRo0Zp9uzZCgQCevjhh5Wdne2cQRk/fryeffZZTZ48WWPGjNG6deu0fPlyFRT8tO/aAQAA32rSGZgFCxYoGAzq3//939W1a1dneeWVV5yaOXPm6MYbb1RmZqauueYaJSYm6tVXX3XGW7VqpdWrV6tVq1by+Xy64447dOedd2rGjBlOTWpqqgoKClRUVKT+/fvr6aef1qJFi+T3+89AywAAwHan9RyY8xnPgTn/8RwYAMB3nZPnwAAAALQEAgwAALAOAQYAAFiHAAMAAKxDgAEAANYhwAAAAOsQYAAAgHUIMAAAwDoEGAAAYB0CDAAAsA4BBgAAWIcAAwAArEOAAQAA1iHAAAAA6xBgAACAdQgwAADAOgQYAABgHQIMAACwDgEGAABYhwADAACsQ4ABAADWiWnpCeCnq8fUgh+t+WxWxjmYCQDANpyBAQAA1iHAAAAA6xBgAACAdQgwAADAOgQYAABgHQIMAACwDgEGAABYhwADAACsQ4ABAADWIcAAAADrEGAAAIB1CDAAAMA6BBgAAGAdAgwAALBOTEtPIFL1mFrQ0lMAACBicQYGAABYhwADAACs0+QAs3HjRv3yl79UUlKSoqKitGrVqrBxY4ymT5+url27Ki4uTunp6dq9e3dYzb59+5SVlSW32634+HiNHTtWBw4cCKv58MMPdfXVV6tNmzZKTk7W7Nmzm94dAACISE0OMAcPHlT//v313HPPnXR89uzZmjdvnhYuXKgtW7aoXbt28vv9Onz4sFOTlZWlHTt2qKioSKtXr9bGjRt17733OuOhUEjDhw9X9+7dVVZWpqeeekqPPfaYnn/++Wa0CAAAIk2UMcY0e+OoKK1cuVI33XSTpG/PviQlJemBBx7Qgw8+KEkKBoPyer3Kz8/XyJEj9dFHHyktLU1bt27V4MGDJUlr167VDTfcoC+++EJJSUlasGCBHnroIQUCAcXGxkqSpk6dqlWrVmnXrl2nNLdQKCSPx6NgMCi3293cFpuNi3jPjM9mZbT0FAAA59Cpfn+f0WtgKisrFQgElJ6e7qzzeDwaMmSISktLJUmlpaWKj493woskpaenKzo6Wlu2bHFqrrnmGie8SJLf71dFRYW++eabk753XV2dQqFQ2AIAACLTGQ0wgUBAkuT1esPWe71eZywQCCghISFsPCYmRh07dgyrOdk+jn+P75o5c6Y8Ho+zJCcnn35DAADgvBQxdyFNmzZNwWDQWfbs2dPSUwIAAGfJGQ0wiYmJkqTq6uqw9dXV1c5YYmKiampqwsaPHj2qffv2hdWcbB/Hv8d3uVwuud3usAUAAESmMxpgUlNTlZiYqOLiYmddKBTSli1b5PP5JEk+n0+1tbUqKytzatatW6eGhgYNGTLEqdm4caOOHDni1BQVFalXr17q0KHDmZwyAACwUJN/SuDAgQP65JNPnNeVlZUqLy9Xx44dlZKSopycHP3ud7/TxRdfrNTUVD3yyCNKSkpy7lTq06ePrr/+et1zzz1auHChjhw5ookTJ2rkyJFKSkqSJP3mN7/R448/rrFjx2rKlCnavn275s6dqzlz5pyZrmGNU7mbizuVAOCnp8kB5t1339WwYcOc13l5eZKk0aNHKz8/X5MnT9bBgwd17733qra2VldddZXWrl2rNm3aONu8/PLLmjhxoq677jpFR0crMzNT8+bNc8Y9Ho/eeOMNZWdna9CgQercubOmT58e9qwYAADw03Vaz4E5n/EcmJ8OzsAAQORokefAAAAAnAsEGAAAYB0CDAAAsA4BBgAAWIcAAwAArEOAAQAA1iHAAAAA6xBgAACAdQgwAADAOgQYAABgHQIMAACwDgEGAABYhwADAACsQ4ABAADWIcAAAADrxLT0BIDT1WNqwY/WfDYr4xzMBABwrnAGBgAAWIcAAwAArEOAAQAA1iHAAAAA6xBgAACAdQgwAADAOgQYAABgHQIMAACwDgEGAABYhwADAACsw08J4CeBnxsAgMjCGRgAAGAdAgwAALAOAQYAAFiHAAMAAKzDRbzA/8eFvgBgD87AAAAA6xBgAACAdQgwAADAOgQYAABgHQIMAACwDnchAU3AnUoAcH7gDAwAALDOeX0G5rnnntNTTz2lQCCg/v3765lnntEVV1zR0tMCfhBnaQDg7Dtvz8C88sorysvL06OPPqr33ntP/fv3l9/vV01NTUtPDQAAtLAoY4xp6UmczJAhQ3T55Zfr2WeflSQ1NDQoOTlZ9913n6ZOnfqj24dCIXk8HgWDQbnd7rM93ROcyn+FAz+EszQAfopO9fv7vPwTUn19vcrKyjRt2jRnXXR0tNLT01VaWnrSberq6lRXV+e8DgaDkr79F3GmXfpo4RnfJ/BdKbkrzsh+tj/uPyP7AYBzofF7+8fOr5yXAeYf//iHjh07Jq/XG7be6/Vq165dJ91m5syZevzxx09Yn5ycfFbmCNjC88eWngEANN3+/fvl8Xi+d/y8DDDNMW3aNOXl5TmvGxoatG/fPnXq1ElRUVFn7H1CoZCSk5O1Z8+eFvnT1LkQ6T3Sn/0ivcdI70+K/B7pr/mMMdq/f7+SkpJ+sO68DDCdO3dWq1atVF1dHba+urpaiYmJJ93G5XLJ5XKFrYuPjz9bU5Tb7Y7I/1EeL9J7pD/7RXqPkd6fFPk90l/z/NCZl0bn5V1IsbGxGjRokIqLi511DQ0NKi4uls/na8GZAQCA88F5eQZGkvLy8jR69GgNHjxYV1xxhf74xz/q4MGDuvvuu1t6agAAoIWdtwHmtttu09dff63p06crEAjosssu09q1a0+4sPdcc7lcevTRR0/4c1UkifQe6c9+kd5jpPcnRX6P9Hf2nbfPgQEAAPg+5+U1MAAAAD+EAAMAAKxDgAEAANYhwAAAAOsQYJroueeeU48ePdSmTRsNGTJE77zzTktP6aQ2btyoX/7yl0pKSlJUVJRWrVoVNm6M0fTp09W1a1fFxcUpPT1du3fvDqvZt2+fsrKy5Ha7FR8fr7Fjx+rAgQNhNR9++KGuvvpqtWnTRsnJyZo9e/bZbk3Stz8dcfnll+uCCy5QQkKCbrrpJlVUVITVHD58WNnZ2erUqZPat2+vzMzMEx6OWFVVpYyMDLVt21YJCQmaNGmSjh49GlazYcMGDRw4UC6XSz179lR+fv7Zbk8LFixQv379nIdE+Xw+rVmzJiJ6O5lZs2YpKipKOTk5zjrbe3zssccUFRUVtvTu3dsZt70/Sfryyy91xx13qFOnToqLi1Pfvn317rvvOuO2f8706NHjhGMYFRWl7OxsSfYfw2PHjumRRx5Ramqq4uLi9LOf/UxPPPFE2G8QndfH0OCULVu2zMTGxpr/+Z//MTt27DD33HOPiY+PN9XV1S09tRP89a9/NQ899JB59dVXjSSzcuXKsPFZs2YZj8djVq1aZT744APzn//5nyY1NdUcOnTIqbn++utN//79zebNm83f/vY307NnT3P77bc748Fg0Hi9XpOVlWW2b99u/vznP5u4uDjzpz/96az35/f7zeLFi8327dtNeXm5ueGGG0xKSoo5cOCAUzN+/HiTnJxsiouLzbvvvmuGDh1qfvGLXzjjR48eNZdeeqlJT08377//vvnrX/9qOnfubKZNm+bUfPrpp6Zt27YmLy/P7Ny50zzzzDOmVatWZu3atWe1v9dee80UFBSYjz/+2FRUVJj//u//Nq1btzbbt2+3vrfveuedd0yPHj1Mv379zP333++st73HRx991FxyySXmq6++cpavv/46Yvrbt2+f6d69u7nrrrvMli1bzKeffmoKCwvNJ5984tTY/jlTU1MTdvyKioqMJLN+/XpjjP3H8Pe//73p1KmTWb16tamsrDQrVqww7du3N3PnznVqzudjSIBpgiuuuMJkZ2c7r48dO2aSkpLMzJkzW3BWP+67AaahocEkJiaap556yllXW1trXC6X+fOf/2yMMWbnzp1Gktm6datTs2bNGhMVFWW+/PJLY4wx8+fPNx06dDB1dXVOzZQpU0yvXr3OckcnqqmpMZJMSUmJMebbflq3bm1WrFjh1Hz00UdGkiktLTXGfBvyoqOjTSAQcGoWLFhg3G6309PkyZPNJZdcEvZet912m/H7/We7pRN06NDBLFq0KKJ6279/v7n44otNUVGR+bd/+zcnwERCj48++qjp37//Scciob8pU6aYq6666nvHI/Fz5v777zc/+9nPTENDQ0Qcw4yMDDNmzJiwdTfffLPJysoyxpz/x5A/IZ2i+vp6lZWVKT093VkXHR2t9PR0lZaWtuDMmq6yslKBQCCsF4/HoyFDhji9lJaWKj4+XoMHD3Zq0tPTFR0drS1btjg111xzjWJjY50av9+viooKffPNN+eom28Fg0FJUseOHSVJZWVlOnLkSFiPvXv3VkpKSliPffv2DXs4ot/vVygU0o4dO5ya4/fRWHMuj/mxY8e0bNkyHTx4UD6fL6J6y87OVkZGxgnziJQed+/eraSkJF100UXKyspSVVWVpMjo77XXXtPgwYN16623KiEhQQMGDNALL7zgjEfa50x9fb1eeukljRkzRlFRURFxDH/xi1+ouLhYH3/8sSTpgw8+0FtvvaURI0ZIOv+PIQHmFP3jH//QsWPHTngSsNfrVSAQaKFZNU/jfH+ol0AgoISEhLDxmJgYdezYMazmZPs4/j3OhYaGBuXk5OjKK6/UpZde6rx/bGzsCT/o+d0ef2z+31cTCoV06NChs9GOY9u2bWrfvr1cLpfGjx+vlStXKi0tLSJ6k6Rly5bpvffe08yZM08Yi4QehwwZovz8fK1du1YLFixQZWWlrr76au3fvz8i+vv000+1YMECXXzxxSosLNSECRP029/+VkuWLAmbY6R8zqxatUq1tbW66667nPe2/RhOnTpVI0eOVO/evdW6dWsNGDBAOTk5ysrKCpvj+XoMz9ufEgBOVXZ2trZv36633nqrpadyRvXq1Uvl5eUKBoP63//9X40ePVolJSUtPa0zYs+ePbr//vtVVFSkNm3atPR0zorG/4qVpH79+mnIkCHq3r27li9frri4uBac2ZnR0NCgwYMH68knn5QkDRgwQNu3b9fChQs1evToFp7dmffiiy9qxIgRSkpKaumpnDHLly/Xyy+/rKVLl+qSSy5ReXm5cnJylJSUZMUx5AzMKercubNatWp1whXm1dXVSkxMbKFZNU/jfH+ol8TERNXU1ISNHz16VPv27QurOdk+jn+Ps23ixIlavXq11q9fr27dujnrExMTVV9fr9ra2hPm15T5f1+N2+0+619CsbGx6tmzpwYNGqSZM2eqf//+mjt3bkT0VlZWppqaGg0cOFAxMTGKiYlRSUmJ5s2bp5iYGHm9Xut7/K74+Hj9/Oc/1yeffBIRx7Br165KS0sLW9enTx/nz2SR9Dnz+eef680339S4ceOcdZFwDCdNmuSchenbt69GjRql3Nxc56zo+X4MCTCnKDY2VoMGDVJxcbGzrqGhQcXFxfL5fC04s6ZLTU1VYmJiWC+hUEhbtmxxevH5fKqtrVVZWZlTs27dOjU0NGjIkCFOzcaNG3XkyBGnpqioSL169VKHDh3Oag/GGE2cOFErV67UunXrlJqaGjY+aNAgtW7dOqzHiooKVVVVhfW4bdu2sP/zFRUVye12Ox/MPp8vbB+NNS1xzBsaGlRXVxcRvV133XXatm2bysvLnWXw4MHKyspy/tn2Hr/rwIED+vvf/66uXbtGxDG88sorT3h0wccff6zu3btLiozPmUaLFy9WQkKCMjIynHWRcAz/9a9/KTo6PAa0atVKDQ0Nkiw4hqd1CfBPzLJly4zL5TL5+flm586d5t577zXx8fFhV5ifL/bv32/ef/998/777xtJ5g9/+IN5//33zeeff26M+fbWuPj4ePOXv/zFfPjhh+ZXv/rVSW+NGzBggNmyZYt56623zMUXXxx2a1xtba3xer1m1KhRZvv27WbZsmWmbdu25+T2xgkTJhiPx2M2bNgQdpvjv/71L6dm/PjxJiUlxaxbt868++67xufzGZ/P54w33uI4fPhwU15ebtauXWu6dOly0lscJ02aZD766CPz3HPPnZNbHKdOnWpKSkpMZWWl+fDDD83UqVNNVFSUeeONN6zv7fscfxeSMfb3+MADD5gNGzaYyspK8/bbb5v09HTTuXNnU1NTExH9vfPOOyYmJsb8/ve/N7t37zYvv/yyadu2rXnppZecGts/Z4z59m7TlJQUM2XKlBPGbD+Go0ePNhdeeKFzG/Wrr75qOnfubCZPnuzUnM/HkADTRM8884xJSUkxsbGx5oorrjCbN29u6Smd1Pr1642kE5bRo0cbY769Pe6RRx4xXq/XuFwuc91115mKioqwffzzn/80t99+u2nfvr1xu93m7rvvNvv37w+r+eCDD8xVV11lXC6XufDCC82sWbPOSX8n602SWbx4sVNz6NAh81//9V+mQ4cOpm3btubXv/61+eqrr8L289lnn5kRI0aYuLg407lzZ/PAAw+YI0eOhNWsX7/eXHbZZSY2NtZcdNFFYe9xtowZM8Z0797dxMbGmi5dupjrrrvOCS+29/Z9vhtgbO/xtttuM127djWxsbHmwgsvNLfddlvYM1Js788YY15//XVz6aWXGpfLZXr37m2ef/75sHHbP2eMMaawsNBIOmHexth/DEOhkLn//vtNSkqKadOmjbnooovMQw89FHa78/l8DKOMOe6RewAAABbgGhgAAGAdAgwAALAOAQYAAFiHAAMAAKxDgAEAANYhwAAAAOsQYAAAgHUIMAAAwDoEGAAAYB0CDAAAsA4BBgAAWIcAAwAArPP/AJf28b1/C0JDAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(recipes_lengths, range=(0, 8000), bins=50)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "7ded7a42-c53a-4dbb-b6e6-cf37fc176ed8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Looks like a limit of 2000 characters for the recipes will cover 80+% cases.\n",
    "# We may try to train RNN with this maximum recipe length limit.\n",
    "MAX_RECIPE_LENGTH = 2000\n",
    "\n",
    "# if DEBUG:\n",
    "#     MAX_RECIPE_LENGTH = 500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9d5ad708-f8b5-4e8a-a6b4-ed5d125d4c4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_recipes_by_length(recipe_test):\n",
    "    return len(recipe_test) <= MAX_RECIPE_LENGTH "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "af9dc173-0ed5-48df-83ae-db2bc15dcdb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset size BEFORE filtering:  39057\n",
      "Dataset size AFTER filtering:  38318\n",
      "Number of etiminated recipes:  739\n"
     ]
    }
   ],
   "source": [
    "dataset_filtered = [recipe_text for recipe_text in dataset_stringified if filter_recipes_by_length(recipe_text)]\n",
    "\n",
    "print('Dataset size BEFORE filtering: ', len(dataset_stringified))\n",
    "print('Dataset size AFTER filtering: ', len(dataset_filtered))\n",
    "print('Number of etiminated recipes: ', len(dataset_stringified) - len(dataset_filtered))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "75e8af6a-ffc9-4690-817e-99f394ec58ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAX_RECIPE_LENGTH:  2000\n",
      "TOTAL_RECIPES_NUM:  38318\n"
     ]
    }
   ],
   "source": [
    "TOTAL_RECIPES_NUM = len(dataset_filtered)\n",
    "\n",
    "print('MAX_RECIPE_LENGTH: ', MAX_RECIPE_LENGTH)\n",
    "print('TOTAL_RECIPES_NUM: ', TOTAL_RECIPES_NUM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a6812818-fce2-45e9-938b-cbe14c4d6b5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "STOP_SIGN = '␣'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "8050e4c7-1e16-448e-8ffe-0d8a68db36ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenizer = tf.keras.preprocessing.text.Tokenizer(\n",
    "    char_level=True,\n",
    "    filters='',\n",
    "    lower=False,\n",
    "    split=''\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d5a29b4b-58a9-4564-bc31-7acfaf70551b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Stop word is not a part of recipes, but tokenizer must know about it as well.\n",
    "tokenizer.fit_on_texts([STOP_SIGN])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "dd6482e8-4c07-474c-8dcf-03f2e51ee77d",
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenizer.fit_on_texts(dataset_filtered)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "2d802aae-6785-4785-a26f-5a2930098450",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'num_words': None,\n",
       " 'filters': '',\n",
       " 'lower': False,\n",
       " 'split': '',\n",
       " 'char_level': True,\n",
       " 'oov_token': None,\n",
       " 'document_count': 38319,\n",
       " 'word_counts': '{\"\\\\u2423\": 1, \"\\\\ud83d\\\\udcd7\": 38318, \" \": 5848239, \"S\": 81080, \"l\": 1168288, \"o\": 1958572, \"w\": 298098, \"C\": 89004, \"k\": 309244, \"e\": 3018509, \"r\": 1533670, \"h\": 837927, \"i\": 1539989, \"c\": 980243, \"n\": 1725269, \"a\": 1913745, \"d\": 956778, \"D\": 19325, \"u\": 924476, \"m\": 556952, \"p\": 891405, \"g\": 573768, \"s\": 1448701, \"\\\\n\": 736599, \"\\\\ud83e\\\\udd55\": 38318, \"\\\\u2022\": 344077, \"4\": 76978, \",\": 372523, \"b\": 459181, \"t\": 1861956, \"v\": 224351, \"2\": 171672, \"(\": 64696, \"1\": 336040, \"0\": 61088, \".\": 327776, \"7\": 18219, \"5\": 70270, \")\": 64685, \"f\": 301669, \"y\": 181477, \"\\\\ud83d\\\\udcdd\": 38318, \"\\\\u25aa\": 124296, \"\\\\ufe0e\": 124296, \"P\": 69909, \"6\": 17335, \"H\": 14275, \"A\": 29666, \"3\": 76541, \"R\": 31484, \"x\": 84461, \"/\": 125366, \"I\": 28658, \"L\": 14602, \"8\": 20040, \"9\": 10715, \"B\": 49344, \"M\": 28367, \"F\": 35487, \"j\": 30739, \"-\": 52767, \"W\": 14567, \"\\\\u00ae\": 6760, \"N\": 3023, \"q\": 19116, \"T\": 21859, \";\": 34355, \"\\'\": 10953, \"Z\": 721, \"z\": 30899, \"G\": 15764, \":\": 4077, \"E\": 5551, \"K\": 2821, \"X\": 116, \"\\\\\"\": 853, \"O\": 6820, \"Y\": 1417, \"\\\\u2122\": 386, \"Q\": 1310, \"J\": 3122, \"!\": 792, \"U\": 2639, \"V\": 2859, \"&\": 441, \"+\": 9, \"=\": 6, \"%\": 360, \"*\": 308, \"\\\\u00a9\": 1, \"[\": 1, \"]\": 1, \"\\\\u00e9\": 18, \"<\": 16, \">\": 16, \"\\\\u00bd\": 5, \"#\": 9, \"\\\\u00f1\": 3, \"?\": 6, \"\\\\u2019\": 5, \"\\\\u00b0\": 2, \"\\\\u201d\": 2, \"$\": 1, \"@\": 1, \"{\": 1, \"}\": 1, \"\\\\u2013\": 1, \"\\\\u0096\": 2, \"\\\\u00e0\": 1, \"\\\\u00e2\": 1, \"\\\\u00e8\": 5, \"\\\\u00e1\": 1}',\n",
       " 'word_docs': '{\"\\\\u2423\": 1, \"\\\\u25aa\": 38318, \"3\": 30001, \" \": 38318, \"7\": 14459, \"4\": 30713, \"o\": 38318, \"\\\\n\": 38318, \"D\": 14287, \"b\": 38183, \"v\": 37256, \"i\": 38318, \"0\": 26031, \"s\": 38318, \"e\": 38318, \"h\": 38308, \"g\": 38204, \"d\": 38318, \".\": 38316, \"r\": 38318, \"n\": 38318, \"\\\\ud83e\\\\udd55\": 38318, \"\\\\u2022\": 38318, \",\": 37930, \"y\": 36130, \"A\": 18675, \"C\": 33236, \"\\\\ufe0e\": 38318, \"5\": 27708, \"P\": 30845, \"a\": 38318, \"t\": 38315, \"1\": 38195, \"m\": 38232, \"k\": 37152, \"\\\\ud83d\\\\udcdd\": 38318, \"p\": 38279, \")\": 29770, \"2\": 36903, \"\\\\ud83d\\\\udcd7\": 38318, \"6\": 12909, \"c\": 38317, \"(\": 29773, \"H\": 11435, \"S\": 32882, \"f\": 37350, \"w\": 37825, \"l\": 38316, \"u\": 38312, \"R\": 18928, \"x\": 29383, \"/\": 33818, \"I\": 16885, \"8\": 14345, \"L\": 11086, \"9\": 8782, \"F\": 22550, \"B\": 26971, \"M\": 19011, \"j\": 14491, \"-\": 25549, \"T\": 15183, \"\\\\u00ae\": 4492, \"W\": 10408, \"q\": 11184, \"N\": 2440, \";\": 18191, \"z\": 12930, \"G\": 12054, \"\\'\": 7611, \"Z\": 672, \":\": 2564, \"E\": 4203, \"K\": 2342, \"X\": 109, \"\\\\\"\": 320, \"O\": 5151, \"Y\": 1202, \"\\\\u2122\": 326, \"Q\": 1226, \"J\": 2508, \"!\": 681, \"U\": 2333, \"V\": 2528, \"&\": 332, \"=\": 4, \"+\": 8, \"%\": 318, \"*\": 245, \"\\\\u00a9\": 1, \"[\": 1, \"]\": 1, \"\\\\u00e9\": 16, \"<\": 5, \">\": 5, \"\\\\u00bd\": 5, \"#\": 9, \"\\\\u00f1\": 3, \"?\": 6, \"\\\\u2019\": 5, \"\\\\u00b0\": 2, \"\\\\u201d\": 1, \"@\": 1, \"$\": 1, \"}\": 1, \"{\": 1, \"\\\\u2013\": 1, \"\\\\u0096\": 2, \"\\\\u00e0\": 1, \"\\\\u00e2\": 1, \"\\\\u00e8\": 3, \"\\\\u00e1\": 1}',\n",
       " 'index_docs': '{\"1\": 38318, \"101\": 1, \"31\": 38318, \"37\": 30001, \"60\": 14459, \"36\": 30713, \"3\": 38318, \"16\": 38318, \"58\": 14287, \"19\": 38183, \"27\": 37256, \"7\": 38318, \"42\": 26031, \"9\": 38318, \"2\": 38318, \"15\": 38308, \"17\": 38204, \"12\": 38318, \"23\": 38316, \"8\": 38318, \"6\": 38318, \"46\": 38318, \"21\": 38318, \"20\": 37930, \"28\": 36130, \"53\": 18675, \"33\": 33236, \"32\": 38318, \"38\": 27708, \"39\": 30845, \"4\": 38318, \"5\": 38315, \"22\": 38195, \"18\": 38232, \"24\": 37152, \"47\": 38318, \"14\": 38279, \"41\": 29770, \"29\": 36903, \"45\": 38318, \"61\": 12909, \"11\": 38317, \"40\": 29773, \"65\": 11435, \"35\": 32882, \"25\": 37350, \"26\": 37825, \"10\": 38316, \"13\": 38312, \"50\": 18928, \"34\": 29383, \"30\": 33818, \"54\": 16885, \"57\": 14345, \"63\": 11086, \"67\": 8782, \"48\": 22550, \"44\": 26971, \"55\": 19011, \"52\": 14491, \"43\": 25549, \"56\": 15183, \"69\": 4492, \"64\": 10408, \"59\": 11184, \"73\": 2440, \"49\": 18191, \"51\": 12930, \"62\": 12054, \"66\": 7611, \"81\": 672, \"71\": 2564, \"70\": 4203, \"75\": 2342, \"86\": 109, \"79\": 320, \"68\": 5151, \"77\": 1202, \"83\": 326, \"78\": 1226, \"72\": 2508, \"80\": 681, \"76\": 2333, \"74\": 2528, \"82\": 332, \"92\": 4, \"90\": 8, \"84\": 318, \"85\": 245, \"102\": 1, \"103\": 1, \"104\": 1, \"87\": 16, \"88\": 5, \"89\": 5, \"94\": 5, \"91\": 9, \"97\": 3, \"93\": 6, \"95\": 5, \"98\": 2, \"99\": 1, \"106\": 1, \"105\": 1, \"108\": 1, \"107\": 1, \"109\": 1, \"100\": 2, \"110\": 1, \"111\": 1, \"96\": 3, \"112\": 1}',\n",
       " 'index_word': '{\"1\": \" \", \"2\": \"e\", \"3\": \"o\", \"4\": \"a\", \"5\": \"t\", \"6\": \"n\", \"7\": \"i\", \"8\": \"r\", \"9\": \"s\", \"10\": \"l\", \"11\": \"c\", \"12\": \"d\", \"13\": \"u\", \"14\": \"p\", \"15\": \"h\", \"16\": \"\\\\n\", \"17\": \"g\", \"18\": \"m\", \"19\": \"b\", \"20\": \",\", \"21\": \"\\\\u2022\", \"22\": \"1\", \"23\": \".\", \"24\": \"k\", \"25\": \"f\", \"26\": \"w\", \"27\": \"v\", \"28\": \"y\", \"29\": \"2\", \"30\": \"/\", \"31\": \"\\\\u25aa\", \"32\": \"\\\\ufe0e\", \"33\": \"C\", \"34\": \"x\", \"35\": \"S\", \"36\": \"4\", \"37\": \"3\", \"38\": \"5\", \"39\": \"P\", \"40\": \"(\", \"41\": \")\", \"42\": \"0\", \"43\": \"-\", \"44\": \"B\", \"45\": \"\\\\ud83d\\\\udcd7\", \"46\": \"\\\\ud83e\\\\udd55\", \"47\": \"\\\\ud83d\\\\udcdd\", \"48\": \"F\", \"49\": \";\", \"50\": \"R\", \"51\": \"z\", \"52\": \"j\", \"53\": \"A\", \"54\": \"I\", \"55\": \"M\", \"56\": \"T\", \"57\": \"8\", \"58\": \"D\", \"59\": \"q\", \"60\": \"7\", \"61\": \"6\", \"62\": \"G\", \"63\": \"L\", \"64\": \"W\", \"65\": \"H\", \"66\": \"\\'\", \"67\": \"9\", \"68\": \"O\", \"69\": \"\\\\u00ae\", \"70\": \"E\", \"71\": \":\", \"72\": \"J\", \"73\": \"N\", \"74\": \"V\", \"75\": \"K\", \"76\": \"U\", \"77\": \"Y\", \"78\": \"Q\", \"79\": \"\\\\\"\", \"80\": \"!\", \"81\": \"Z\", \"82\": \"&\", \"83\": \"\\\\u2122\", \"84\": \"%\", \"85\": \"*\", \"86\": \"X\", \"87\": \"\\\\u00e9\", \"88\": \"<\", \"89\": \">\", \"90\": \"+\", \"91\": \"#\", \"92\": \"=\", \"93\": \"?\", \"94\": \"\\\\u00bd\", \"95\": \"\\\\u2019\", \"96\": \"\\\\u00e8\", \"97\": \"\\\\u00f1\", \"98\": \"\\\\u00b0\", \"99\": \"\\\\u201d\", \"100\": \"\\\\u0096\", \"101\": \"\\\\u2423\", \"102\": \"\\\\u00a9\", \"103\": \"[\", \"104\": \"]\", \"105\": \"$\", \"106\": \"@\", \"107\": \"{\", \"108\": \"}\", \"109\": \"\\\\u2013\", \"110\": \"\\\\u00e0\", \"111\": \"\\\\u00e2\", \"112\": \"\\\\u00e1\"}',\n",
       " 'word_index': '{\" \": 1, \"e\": 2, \"o\": 3, \"a\": 4, \"t\": 5, \"n\": 6, \"i\": 7, \"r\": 8, \"s\": 9, \"l\": 10, \"c\": 11, \"d\": 12, \"u\": 13, \"p\": 14, \"h\": 15, \"\\\\n\": 16, \"g\": 17, \"m\": 18, \"b\": 19, \",\": 20, \"\\\\u2022\": 21, \"1\": 22, \".\": 23, \"k\": 24, \"f\": 25, \"w\": 26, \"v\": 27, \"y\": 28, \"2\": 29, \"/\": 30, \"\\\\u25aa\": 31, \"\\\\ufe0e\": 32, \"C\": 33, \"x\": 34, \"S\": 35, \"4\": 36, \"3\": 37, \"5\": 38, \"P\": 39, \"(\": 40, \")\": 41, \"0\": 42, \"-\": 43, \"B\": 44, \"\\\\ud83d\\\\udcd7\": 45, \"\\\\ud83e\\\\udd55\": 46, \"\\\\ud83d\\\\udcdd\": 47, \"F\": 48, \";\": 49, \"R\": 50, \"z\": 51, \"j\": 52, \"A\": 53, \"I\": 54, \"M\": 55, \"T\": 56, \"8\": 57, \"D\": 58, \"q\": 59, \"7\": 60, \"6\": 61, \"G\": 62, \"L\": 63, \"W\": 64, \"H\": 65, \"\\'\": 66, \"9\": 67, \"O\": 68, \"\\\\u00ae\": 69, \"E\": 70, \":\": 71, \"J\": 72, \"N\": 73, \"V\": 74, \"K\": 75, \"U\": 76, \"Y\": 77, \"Q\": 78, \"\\\\\"\": 79, \"!\": 80, \"Z\": 81, \"&\": 82, \"\\\\u2122\": 83, \"%\": 84, \"*\": 85, \"X\": 86, \"\\\\u00e9\": 87, \"<\": 88, \">\": 89, \"+\": 90, \"#\": 91, \"=\": 92, \"?\": 93, \"\\\\u00bd\": 94, \"\\\\u2019\": 95, \"\\\\u00e8\": 96, \"\\\\u00f1\": 97, \"\\\\u00b0\": 98, \"\\\\u201d\": 99, \"\\\\u0096\": 100, \"\\\\u2423\": 101, \"\\\\u00a9\": 102, \"[\": 103, \"]\": 104, \"$\": 105, \"@\": 106, \"{\": 107, \"}\": 108, \"\\\\u2013\": 109, \"\\\\u00e0\": 110, \"\\\\u00e2\": 111, \"\\\\u00e1\": 112}'}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenizer.get_config()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e0a9259d-95ab-4f7e-8a62-38457e9a416c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VOCABULARY_SIZE:  113\n"
     ]
    }
   ],
   "source": [
    "VOCABULARY_SIZE = len(tokenizer.word_counts) + 1\n",
    "\n",
    "print('VOCABULARY_SIZE: ', VOCABULARY_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "5985ae35-849a-4455-ba33-1573a4f36803",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n\n",
      "/\n"
     ]
    }
   ],
   "source": [
    "print(tokenizer.index_word[6])\n",
    "print(tokenizer.index_word[30])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "123e764d-669c-485c-99e7-bf6f22c2d6b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenizer.word_index['d']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f0242314-7f6f-49b5-b28f-3f0ddb54bd04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['', ' ', 'e', 'o', 'a', 't', 'n', 'i', 'r', 's', 'l', 'c', 'd', 'u', 'p', 'h', '\\n', 'g', 'm', 'b', ',', '•', '1', '.', 'k', 'f', 'w', 'v', 'y', '2', '/', '▪', '︎', 'C', 'x', 'S', '4', '3', '5', 'P', '(', ')', '0', '-', 'B', '📗', '🥕', '📝', 'F', ';', 'R', 'z', 'j', 'A', 'I', 'M', 'T', '8', 'D', 'q', '7', '6', 'G', 'L', 'W', 'H', \"'\", '9', 'O', '®', 'E', ':', 'J', 'N', 'V', 'K', 'U', 'Y', 'Q', '\"', '!', 'Z', '&', '™', '%', '*', 'X', 'é', '<', '>', '+', '#', '=', '?', '½', '’', 'è', 'ñ', '°', '”', '\\x96', '␣', '©', '[', ']', '$', '@', '{', '}', '–', 'à', 'â', 'á']\n"
     ]
    }
   ],
   "source": [
    "# For demo application we need to have an array of characters as vocabulary.\n",
    "js_vocabulary = tokenizer.sequences_to_texts([[word_index] for word_index in range(VOCABULARY_SIZE)])\n",
    "print([char for char in js_vocabulary])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a9a0c396-9801-47d9-99a6-46703af0a65b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[45, 1, 28, 2, 9]]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenizer.texts_to_sequences(['📗 yes'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "344d0139-aaa6-431e-94d4-7ad5f1ab1f16",
   "metadata": {},
   "outputs": [],
   "source": [
    "def recipe_sequence_to_string(recipe_sequence):\n",
    "    recipe_stringified = tokenizer.sequences_to_texts([recipe_sequence])[0]\n",
    "    recipe_stringified = recipe_stringified.replace('   ', '_').replace(' ', '').replace('_', ' ')\n",
    "    print(recipe_stringified)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "2a13fbb7-6cf2-483d-a5c2-070b11773ae3",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_vectorized = tokenizer.texts_to_sequences(dataset_filtered)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "bc236fa1-e101-4dec-9f37-dae6426adc48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vectorized dataset size 38318\n"
     ]
    }
   ],
   "source": [
    "print('Vectorized dataset size', len(dataset_vectorized))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "9506779e-ad14-4cd5-a7fc-ce6cb537e855",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[45, 1, 35, 10, 3, 26, 1, 33, 3, 3] ...\n"
     ]
    }
   ],
   "source": [
    "print(dataset_vectorized[0][:10], '...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "8a9a542e-5c2b-414e-8bf6-e456b5a098c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max_index_example:  112\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "padded_sequences = pad_sequences(dataset_vectorized)\n",
    "max_index_example = np.max(padded_sequences)\n",
    "\n",
    "print('max_index_example: ', max_index_example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "cd06cf22-5f42-4231-b38f-2f6a0bb61ccd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "📗 Awesome Slow Cooker Pot Roast\n",
      "\n",
      "🥕\n",
      "\n",
      "• 2 (10.75 ounce) cans condensed cream of mushroom soup \n",
      "• 1 (1 ounce) package dry onion soup mix \n",
      "• 1 1/4 cups water \n",
      "• 5 1/2 pounds pot roast \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ In a slow cooker, mix cream of mushroom soup, dry onion soup mix and water. Place pot roast in slow cooker and coat with soup mixture.\n",
      "▪︎ Cook on High setting for 3 to 4 hours, or on Low setting for 8 to 9 hours.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "recipe_sequence_to_string(dataset_vectorized[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "4feadf10-90bc-44db-aa17-c5f9c483a7dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recipe #1 length: 546\n",
      "Recipe #2 length: 401\n",
      "Recipe #3 length: 671\n",
      "Recipe #4 length: 736\n",
      "Recipe #5 length: 1518\n",
      "Recipe #6 length: 740\n",
      "Recipe #7 length: 839\n",
      "Recipe #8 length: 667\n",
      "Recipe #9 length: 1264\n",
      "Recipe #10 length: 854\n"
     ]
    }
   ],
   "source": [
    "for recipe_index, recipe in enumerate(dataset_vectorized[:10]):\n",
    "    print('Recipe #{} length: {}'.format(recipe_index + 1, len(recipe)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "09a09036-6da9-43ff-99bc-9184210d3137",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_vectorized_padded_without_stops = tf.keras.preprocessing.sequence.pad_sequences(\n",
    "    dataset_vectorized,\n",
    "    padding='post',\n",
    "    truncating='post',\n",
    "    # We use -1 here and +1 in the next step to make sure that all recipes will have at least 1 stops\n",
    "    # sign at the end, since each sequence will be shifted and truncated afterwards (to generate X and Y sequences).\n",
    "    maxlen=MAX_RECIPE_LENGTH-1,\n",
    "    value=tokenizer.texts_to_sequences([STOP_SIGN])[0]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "a85dee59-4005-49a9-bf26-27e093d5d5b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_vectorized_padded = tf.keras.preprocessing.sequence.pad_sequences(\n",
    "    dataset_vectorized_padded_without_stops,\n",
    "    padding='post',\n",
    "    truncating='post',\n",
    "    maxlen=MAX_RECIPE_LENGTH+1,\n",
    "    value=tokenizer.texts_to_sequences([STOP_SIGN])[0]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "692fe092-4d1c-4e64-b674-ad16688546e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recipe #0 length: 2001\n",
      "Recipe #1 length: 2001\n",
      "Recipe #2 length: 2001\n",
      "Recipe #3 length: 2001\n",
      "Recipe #4 length: 2001\n",
      "Recipe #5 length: 2001\n",
      "Recipe #6 length: 2001\n",
      "Recipe #7 length: 2001\n",
      "Recipe #8 length: 2001\n",
      "Recipe #9 length: 2001\n"
     ]
    }
   ],
   "source": [
    "for recipe_index, recipe in enumerate(dataset_vectorized_padded[:10]):\n",
    "    print('Recipe #{} length: {}'.format(recipe_index, len(recipe)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "7111f96c-15ca-4efd-b2aa-7a8360338268",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "📗 Slow Cooker Chicken and Dumplings\n",
      "\n",
      "🥕\n",
      "\n",
      "• 4 skinless, boneless chicken breast halves \n",
      "• 2 tablespoons butter \n",
      "• 2 (10.75 ounce) cans condensed cream of chicken soup \n",
      "• 1 onion, finely diced \n",
      "• 2 (10 ounce) packages refrigerated biscuit dough, torn into pieces \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ Place the chicken, butter, soup, and onion in a slow cooker, and fill with enough water to cover.\n",
      "▪︎ Cover, and cook for 5 to 6 hours on High. About 30 minutes before serving, place the torn biscuit dough in the slow cooker. Cook until the dough is no longer raw in the center.\n",
      "␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣\n"
     ]
    }
   ],
   "source": [
    "recipe_sequence_to_string(dataset_vectorized_padded[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "c22f3daf-bc75-4300-bfa1-afcbc9fa091a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<_TensorSliceDataset element_spec=TensorSpec(shape=(2001,), dtype=tf.int32, name=None)>\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-26 10:12:59.413366: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-26 10:12:59.413461: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-26 10:12:59.413495: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-26 10:12:59.661494: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-26 10:12:59.661561: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-26 10:12:59.661579: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2022] Could not identify NUMA node of platform GPU id 0, defaulting to 0.  Your kernel may not have been built with NUMA support.\n",
      "2023-12-26 10:12:59.661641: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2023-12-26 10:12:59.661693: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1929] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 3554 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 4050 Laptop GPU, pci bus id: 0000:01:00.0, compute capability: 8.9\n"
     ]
    }
   ],
   "source": [
    "dataset = tf.data.Dataset.from_tensor_slices(dataset_vectorized_padded)\n",
    "print(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "1d8684f3-4872-491b-aee2-1220376a6f21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Raw recipe:\n",
      " [ 45   1  35 ... 101 101 101] \n",
      "\n",
      "\n",
      "\n",
      "Stringified recipe:\n",
      "\n",
      "📗 Slow Cooker Chicken and Dumplings\n",
      "\n",
      "🥕\n",
      "\n",
      "• 4 skinless, boneless chicken breast halves \n",
      "• 2 tablespoons butter \n",
      "• 2 (10.75 ounce) cans condensed cream of chicken soup \n",
      "• 1 onion, finely diced \n",
      "• 2 (10 ounce) packages refrigerated biscuit dough, torn into pieces \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ Place the chicken, butter, soup, and onion in a slow cooker, and fill with enough water to cover.\n",
      "▪︎ Cover, and cook for 5 to 6 hours on High. About 30 minutes before serving, place the torn biscuit dough in the slow cooker. Cook until the dough is no longer raw in the center.\n",
      "␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣\n"
     ]
    }
   ],
   "source": [
    "for recipe in dataset.take(1):\n",
    "    print('Raw recipe:\\n', recipe.numpy(), '\\n\\n\\n')\n",
    "    print('Stringified recipe:\\n')\n",
    "    recipe_sequence_to_string(recipe.numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "9ea331d0-4d82-483c-9f54-7009897fed57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<_MapDataset element_spec=(TensorSpec(shape=(2000,), dtype=tf.int32, name=None), TensorSpec(shape=(2000,), dtype=tf.int32, name=None))>\n"
     ]
    }
   ],
   "source": [
    "def split_input_target(recipe):   \n",
    "    input_text = recipe[:-1]\n",
    "    target_text = recipe[1:]\n",
    "    \n",
    "    return input_text, target_text\n",
    "\n",
    "# dataset_targeted = dataset.map(split_input_target)\n",
    "\n",
    "# print(dataset_targeted)\n",
    "\n",
    "# def split_input_target(recipe):\n",
    "#     input_text = recipe[:-1]\n",
    "#     target_text = recipe[1:]\n",
    "    \n",
    "#     # Ensure target_text is a tensor with an additional dimension\n",
    "#     target_text = tf.expand_dims(target_text, -1)\n",
    "    \n",
    "#     return input_text, target_text\n",
    "\n",
    "dataset_targeted = dataset.map(split_input_target)\n",
    "print(dataset_targeted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "c43d4f0d-e999-4201-b760-96c136fe98df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input sequence size: 2000\n",
      "Target sequence size: 2000\n",
      "\n",
      "Input:   '📗   S l o w   C o o k e r   C h i c k e n   a n d   D u m p l i n g s \\n \\n 🥕 \\n \\n •   4   s k i n l e'\n",
      "Target:  '  S l o w   C o o k e r   C h i c k e n   a n d   D u m p l i n g s \\n \\n 🥕 \\n \\n •   4   s k i n l e s'\n"
     ]
    }
   ],
   "source": [
    "for input_example, target_example in dataset_targeted.take(1):\n",
    "    print('Input sequence size:', repr(len(input_example.numpy())))\n",
    "    print('Target sequence size:', repr(len(target_example.numpy())))\n",
    "    print()\n",
    "    \n",
    "    input_stringified = tokenizer.sequences_to_texts([input_example.numpy()[:50]])[0]\n",
    "    target_stringified = tokenizer.sequences_to_texts([target_example.numpy()[:50]])[0]\n",
    "    \n",
    "    print('Input:  ', repr(''.join(input_stringified)))\n",
    "    print('Target: ', repr(''.join(target_stringified))) \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "31e3c272-bf3f-42fe-84bc-354050d034dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step  1\n",
      "  input: 45 ('📗')\n",
      "  expected output: 1 (' ')\n",
      "Step  2\n",
      "  input: 1 (' ')\n",
      "  expected output: 35 ('S')\n",
      "Step  3\n",
      "  input: 35 ('S')\n",
      "  expected output: 10 ('l')\n",
      "Step  4\n",
      "  input: 10 ('l')\n",
      "  expected output: 3 ('o')\n",
      "Step  5\n",
      "  input: 3 ('o')\n",
      "  expected output: 26 ('w')\n",
      "Step  6\n",
      "  input: 26 ('w')\n",
      "  expected output: 1 (' ')\n",
      "Step  7\n",
      "  input: 1 (' ')\n",
      "  expected output: 33 ('C')\n",
      "Step  8\n",
      "  input: 33 ('C')\n",
      "  expected output: 3 ('o')\n",
      "Step  9\n",
      "  input: 3 ('o')\n",
      "  expected output: 3 ('o')\n",
      "Step 10\n",
      "  input: 3 ('o')\n",
      "  expected output: 24 ('k')\n"
     ]
    }
   ],
   "source": [
    "for i, (input_idx, target_idx) in enumerate(zip(input_example[:10], target_example[:10])):\n",
    "    print('Step {:2d}'.format(i + 1))\n",
    "    print('  input: {} ({:s})'.format(input_idx, repr(tokenizer.sequences_to_texts([[input_idx.numpy()]])[0])))\n",
    "    print('  expected output: {} ({:s})'.format(target_idx, repr(tokenizer.sequences_to_texts([[target_idx.numpy()]])[0])))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "3238f9e6-e292-45c0-a435-a712112c0ec8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<_MapDataset element_spec=(TensorSpec(shape=(2000,), dtype=tf.int32, name=None), TensorSpec(shape=(2000,), dtype=tf.int32, name=None))>\n"
     ]
    }
   ],
   "source": [
    "print(dataset_targeted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "6acaa2b0-0a5a-4466-b760-dc21ebbbb24f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TOTAL_RECIPES_NUM:  38318\n",
      "MAX_RECIPE_LENGTH:  2000\n",
      "VOCABULARY_SIZE:  113\n"
     ]
    }
   ],
   "source": [
    "print('TOTAL_RECIPES_NUM: ', TOTAL_RECIPES_NUM)\n",
    "print('MAX_RECIPE_LENGTH: ', MAX_RECIPE_LENGTH)\n",
    "print('VOCABULARY_SIZE: ', VOCABULARY_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "6f5962f1-3dbf-4486-a809-66ba92ef579c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<_RepeatDataset element_spec=(TensorSpec(shape=(32, 2000), dtype=tf.int32, name=None), TensorSpec(shape=(32, 2000), dtype=tf.int32, name=None))>\n"
     ]
    }
   ],
   "source": [
    "# Batch size.\n",
    "BATCH_SIZE = 32\n",
    "\n",
    "# Buffer size to shuffle the dataset (TF data is designed to work\n",
    "# with possibly infinite sequences, so it doesn't attempt to shuffle\n",
    "# the entire sequence in memory. Instead, it maintains a buffer in\n",
    "# which it shuffles elements).\n",
    "SHUFFLE_BUFFER_SIZE = 1000\n",
    "\n",
    "dataset_train = dataset_targeted \\\n",
    "    .shuffle(SHUFFLE_BUFFER_SIZE) \\\n",
    "    .batch(BATCH_SIZE, drop_remainder=True) \\\n",
    "    .repeat()\n",
    "\n",
    "print(dataset_train)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "fafcfd67-1f72-4841-95e7-48547a1294ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1st batch: input_text: tf.Tensor(\n",
      "[[ 45   1  44 ... 101 101 101]\n",
      " [ 45   1  39 ... 101 101 101]\n",
      " [ 45   1  33 ... 101 101 101]\n",
      " ...\n",
      " [ 45   1  35 ... 101 101 101]\n",
      " [ 45   1  44 ... 101 101 101]\n",
      " [ 45   1  35 ... 101 101 101]], shape=(32, 2000), dtype=int32)\n",
      "\n",
      "1st batch: target_text: tf.Tensor(\n",
      "[[  1  44   2 ... 101 101 101]\n",
      " [  1  39   7 ... 101 101 101]\n",
      " [  1  33   3 ... 101 101 101]\n",
      " ...\n",
      " [  1  35  10 ... 101 101 101]\n",
      " [  1  44   2 ... 101 101 101]\n",
      " [  1  35   5 ... 101 101 101]], shape=(32, 2000), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "for input_text, target_text in dataset_train.take(1):\n",
    "    print('1st batch: input_text:', input_text)\n",
    "    print()\n",
    "    print('1st batch: target_text:', target_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "d5df5a2c-dcb0-4137-a9ca-cb0df7732399",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 77ms/step\n",
      "tmp_input_array shape: (2, 8)\n",
      "tmp_input_array:\n",
      "[[5 8 7 8 4 1 6 3]\n",
      " [7 2 4 2 5 3 2 6]]\n",
      "\n",
      "tmp_output_array shape: (2, 8, 5)\n",
      "tmp_output_array:\n",
      "[[[ 0.04718179 -0.04465931 -0.01293183 -0.00315758 -0.0411256 ]\n",
      "  [-0.02921771  0.01229727  0.00670003  0.01440426  0.0490559 ]\n",
      "  [-0.03914871 -0.0243445  -0.0134518  -0.04609364  0.01846535]\n",
      "  [-0.02921771  0.01229727  0.00670003  0.01440426  0.0490559 ]\n",
      "  [ 0.01385417 -0.03893701  0.04093664 -0.03083023 -0.03207859]\n",
      "  [ 0.02778218 -0.00232452 -0.0111407   0.00903925 -0.00213547]\n",
      "  [ 0.02891413  0.03816811  0.0161065   0.01730621  0.03812561]\n",
      "  [ 0.0145253  -0.0099897  -0.003488    0.04620108  0.02966226]]\n",
      "\n",
      " [[-0.03914871 -0.0243445  -0.0134518  -0.04609364  0.01846535]\n",
      "  [ 0.04857992 -0.03659602  0.04168096  0.0451888  -0.03676478]\n",
      "  [ 0.01385417 -0.03893701  0.04093664 -0.03083023 -0.03207859]\n",
      "  [ 0.04857992 -0.03659602  0.04168096  0.0451888  -0.03676478]\n",
      "  [ 0.04718179 -0.04465931 -0.01293183 -0.00315758 -0.0411256 ]\n",
      "  [ 0.0145253  -0.0099897  -0.003488    0.04620108  0.02966226]\n",
      "  [ 0.04857992 -0.03659602  0.04168096  0.0451888  -0.03676478]\n",
      "  [ 0.02891413  0.03816811  0.0161065   0.01730621  0.03812561]]]\n"
     ]
    }
   ],
   "source": [
    "tmp_vocab_size = 10\n",
    "tmp_embedding_size = 5\n",
    "tmp_input_length = 8\n",
    "tmp_batch_size = 2\n",
    "\n",
    "tmp_model = tf.keras.models.Sequential()\n",
    "tmp_model.add(tf.keras.layers.Embedding(\n",
    "  input_dim=tmp_vocab_size,\n",
    "  output_dim=tmp_embedding_size,\n",
    "  input_length=tmp_input_length\n",
    "))\n",
    "# The model will take as input an integer matrix of size (batch, input_length).\n",
    "# The largest integer (i.e. word index) in the input should be no larger than 9 (tmp_vocab_size).\n",
    "# Now model.output_shape == (None, 10, 64), where None is the batch dimension.\n",
    "tmp_input_array = np.random.randint(\n",
    "  low=0,\n",
    "  high=tmp_vocab_size,\n",
    "  size=(tmp_batch_size, tmp_input_length)\n",
    ")\n",
    "tmp_model.compile('rmsprop', 'mse')\n",
    "tmp_output_array = tmp_model.predict(tmp_input_array)\n",
    "\n",
    "print('tmp_input_array shape:', tmp_input_array.shape)\n",
    "print('tmp_input_array:')\n",
    "print(tmp_input_array)\n",
    "print()\n",
    "print('tmp_output_array shape:', tmp_output_array.shape)\n",
    "print('tmp_output_array:')\n",
    "print(tmp_output_array)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "ddf7f068-0ea8-4679-9304-cd39153d6f5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " embedding_1 (Embedding)     (32, None, 256)           28928     \n",
      "                                                                 \n",
      " lstm (LSTM)                 (32, None, 1024)          5246976   \n",
      "                                                                 \n",
      " dense (Dense)               (32, None, 113)           115825    \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 5391729 (20.57 MB)\n",
      "Trainable params: 5391729 (20.57 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# def build_model(vocab_size, embedding_dim, rnn_units, batch_size):\n",
    "#     model = tf.keras.models.Sequential()\n",
    "#     lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(\n",
    "#         initial_learning_rate=1e-3,\n",
    "#         decay_steps=1000,\n",
    "#         decay_rate=0.9,\n",
    "#         staircase=True\n",
    "#     )\n",
    "\n",
    "#     optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)\n",
    "\n",
    "\n",
    "#     model.add(tf.keras.layers.Embedding(\n",
    "#         input_dim=vocab_size,\n",
    "#         output_dim=embedding_dim,\n",
    "#         batch_input_shape=[batch_size, None]\n",
    "#     ))\n",
    "\n",
    "#     model.add(tf.keras.layers.LSTM(\n",
    "#         units=rnn_units, \n",
    "#         return_sequences=True,\n",
    "#         stateful=True, \n",
    "#         recurrent_initializer=tf.keras.initializers.GlorotNormal(),\n",
    "        \n",
    "#         implementation=2\n",
    "#     ))\n",
    "    \n",
    "\n",
    "#     model.add(tf.keras.layers.BatchNormalization())\n",
    "\n",
    "#     model.add(tf.keras.layers.Dropout(0.2))\n",
    "\n",
    "#     optimizer = tf.keras.optimizers.Adam(clipvalue=0.5)\n",
    "\n",
    "#     #model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy', 'precision', 'recall', 'f1'])\n",
    "\n",
    "#     model.add(tf.keras.layers.Dense(vocab_size))\n",
    "    \n",
    "#     return model\n",
    "\n",
    "# model = build_model(\n",
    "#   vocab_size=VOCABULARY_SIZE,\n",
    "#   embedding_dim=256,\n",
    "#   rnn_units=1024,\n",
    "#   batch_size=BATCH_SIZE\n",
    "# )\n",
    "\n",
    "# model.summary()\n",
    "\n",
    "# import tensorflow as tf\n",
    "# \n",
    "# from tensorflow.keras.models import Sequential\n",
    "# from tensorflow.keras.layers import Embedding, Bidirectional, LSTM, Dense, LayerNormalization, Dropout\n",
    "# from tensorflow.keras.optimizers import Adam\n",
    "# from tensorflow.keras.optimizers.schedules import ExponentialDecay\n",
    "# from tensorflow.keras.callbacks import EarlyStopping\n",
    "\n",
    "# def build_model(vocab_size, embedding_dim, rnn_units, batch_size):\n",
    "#     model = Sequential()\n",
    "\n",
    "#     # Learning rate schedule\n",
    "#     lr_schedule = ExponentialDecay(\n",
    "#         initial_learning_rate=1e-3,\n",
    "#         decay_steps=1000,\n",
    "#         decay_rate=0.9,\n",
    "#         staircase=True\n",
    "#     )\n",
    "\n",
    "#     optimizer = Adam(learning_rate=lr_schedule, clipvalue=0.5)\n",
    "\n",
    "#     model.add(Embedding(\n",
    "#         input_dim=vocab_size,\n",
    "#         output_dim=embedding_dim,\n",
    "#         input_length=2000  # Assuming a sequence length of 500\n",
    "#     ))\n",
    "\n",
    "#     model.add(Bidirectional(LSTM(\n",
    "#         units=rnn_units, \n",
    "#         return_sequences=True,\n",
    "#         stateful=False,  # Set to False for non-stateful training\n",
    "#         recurrent_initializer=tf.keras.initializers.GlorotNormal(),\n",
    "#         implementation=2\n",
    "#     )))\n",
    "\n",
    "#     model.add(LayerNormalization())\n",
    "#     model.add(Dropout(0.2))\n",
    "\n",
    "#     model.add(Dense(vocab_size, activation='softmax'))\n",
    "\n",
    "#     # Compile the model\n",
    "#     model.compile(optimizer=optimizer, loss='sparse_categorical_crossentropy', metrics=['accuracy', 'precision', 'recall', 'f1'])\n",
    "\n",
    "#     return model\n",
    "\n",
    "# # Assuming you have defined VOCABULARY_SIZE, BATCH_SIZE, X_train, y_train, X_val, y_val\n",
    "# VOCABULARY_SIZE = 94\n",
    "# BATCH_SIZE = 32\n",
    "\n",
    "# model = build_model(\n",
    "#     vocab_size=VOCABULARY_SIZE,\n",
    "#     embedding_dim=256,\n",
    "#     rnn_units=1024,\n",
    "#     batch_size=BATCH_SIZE\n",
    "# )\n",
    "\n",
    "# target_example_batch = tf.random.uniform((BATCH_SIZE, 2000), maxval=94, dtype=tf.int32)\n",
    "# example_batch_predictions = tf.random.normal((BATCH_SIZE, 2000, 94))\n",
    "\n",
    "# # Print model summary\n",
    "# model.summary()\n",
    "\n",
    "# # Assuming you have defined X_train, y_train, X_val, y_val\n",
    "# # Train the model with early stopping\n",
    "# early_stopping = EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True)\n",
    "\n",
    "\n",
    "# model.fit(X_train, y_train, epochs=20, batch_size=BATCH_SIZE, validation_data=(X_val, y_val), callbacks=[early_stopping])\n",
    "# import tensorflow as tf\n",
    "# from tensorflow.keras.models import Sequential\n",
    "# from tensorflow.keras.layers import Embedding, Bidirectional, LSTM, Dense, LayerNormalization, Dropout\n",
    "# from tensorflow.keras.optimizers import Adam\n",
    "# from tensorflow.keras.optimizers.schedules import ExponentialDecay\n",
    "# from tensorflow.keras.callbacks import EarlyStopping\n",
    "\n",
    "# def build_model(vocab_size, embedding_dim, rnn_units, batch_size):\n",
    "#     model = tf.keras.models.Sequential()\n",
    "#     lr_schedule = ExponentialDecay(\n",
    "#         initial_learning_rate=1e-3,\n",
    "#         decay_steps=1000,\n",
    "#         decay_rate=0.9,\n",
    "#         staircase=True\n",
    "#     )\n",
    "#     model.add(tf.keras.layers.Embedding(\n",
    "#         input_dim=vocab_size,\n",
    "#         output_dim=embedding_dim,\n",
    "#         batch_input_shape=[batch_size, None]\n",
    "#     ))\n",
    "\n",
    "#     model.add(Bidirectional(LSTM(\n",
    "#         units=rnn_units, \n",
    "#         return_sequences=True,\n",
    "#         stateful=True,  # Set to False for non-stateful training\n",
    "#         recurrent_initializer=tf.keras.initializers.GlorotNormal(),\n",
    "#         implementation=2\n",
    "#     )))\n",
    "\n",
    "\n",
    "#     model.add(Dense(vocab_size, activation='softmax'))\n",
    "#     model.add(LayerNormalization())\n",
    "#     model.add(Dropout(0.2))\n",
    "#     optimizer = Adam(learning_rate=lr_schedule, clipvalue=0.5)\n",
    "#     # model.compile(optimizer=optimizer, \n",
    "#     #           loss='sparse_categorical_crossentropy',\n",
    "#     #           metrics=['accuracy', 'precision', 'recall', 'f1']\n",
    "#     #          )\n",
    "    \n",
    "#     return model\n",
    "# VOCABULARY_SIZE = 113\n",
    "# BATCH_SIZE = 32\n",
    "# model = build_model(\n",
    "#     vocab_size=VOCABULARY_SIZE,\n",
    "#     embedding_dim=256,\n",
    "#     rnn_units=1024,\n",
    "#     batch_size=BATCH_SIZE\n",
    "# )\n",
    "\n",
    "# model.summary()\n",
    "def build_model(vocab_size, embedding_dim, rnn_units, batch_size):\n",
    "    model = tf.keras.models.Sequential()\n",
    "\n",
    "    model.add(tf.keras.layers.Embedding(\n",
    "        input_dim=vocab_size,\n",
    "        output_dim=embedding_dim,\n",
    "        batch_input_shape=[batch_size, None]\n",
    "    ))\n",
    "\n",
    "    model.add(tf.keras.layers.LSTM(\n",
    "        units=rnn_units,\n",
    "        return_sequences=True,\n",
    "        stateful=True,\n",
    "        recurrent_initializer=tf.keras.initializers.GlorotNormal()\n",
    "    ))\n",
    "\n",
    "    model.add(tf.keras.layers.Dense(vocab_size))\n",
    "    \n",
    "    return model\n",
    "\n",
    "model = build_model(\n",
    "    vocab_size=VOCABULARY_SIZE,\n",
    "    embedding_dim=256,\n",
    "    rnn_units=1024,\n",
    "    batch_size=BATCH_SIZE\n",
    ")\n",
    "\n",
    "model.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "34096774-400a-4970-818a-7de708a546c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You must install pydot (`pip install pydot`) and install graphviz (see instructions at https://graphviz.gitlab.io/download/) for plot_model to work.\n"
     ]
    }
   ],
   "source": [
    "    \n",
    "    tf.keras.utils.plot_model(\n",
    "        model,\n",
    "        show_shapes=True,\n",
    "        show_layer_names=True,\n",
    "        to_file='model.png'\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "88a4931f-f82a-4654-8084-ca7c707ccab6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-26 10:13:01.004275: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:454] Loaded cuDNN version 8906\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(32, 2000, 113) # (batch_size, sequence_length, vocab_size)\n"
     ]
    }
   ],
   "source": [
    "for input_example_batch, target_example_batch in dataset_train.take(1):\n",
    "    example_batch_predictions = model(input_example_batch)\n",
    "    print(example_batch_predictions.shape, \"# (batch_size, sequence_length, vocab_size)\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "913e52cb-05f2-4417-89e8-df9cd70b4c84",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction for the 1st letter of the batch 1st sequense:\n",
      "tf.Tensor(\n",
      "[ 4.0740119e-03  5.4946225e-03 -1.0465346e-03 -2.9471659e-03\n",
      "  2.6832102e-03 -6.5123863e-03 -6.7115789e-03  2.6211794e-03\n",
      "  3.8477166e-03 -1.0411129e-03 -7.2265766e-03  9.4367901e-04\n",
      " -3.3513235e-03  3.1113422e-03 -2.2653416e-03 -3.4869093e-04\n",
      " -2.0187921e-03  2.6271250e-03  4.4936134e-04 -3.6010693e-03\n",
      "  2.1743191e-04  1.7120971e-04  1.9233532e-03  4.4946340e-03\n",
      " -1.0052264e-03  3.7629937e-03  2.2383782e-03  1.5016096e-03\n",
      " -4.9881223e-03  3.8539011e-03 -5.8299134e-04 -2.3029649e-03\n",
      "  6.1773136e-03 -5.2049877e-03 -7.7725283e-04 -1.2968812e-03\n",
      " -3.2332365e-04  4.9897289e-04 -2.8181486e-03 -2.2072769e-03\n",
      "  1.2284329e-03 -1.8991624e-03  1.8855419e-04 -1.7020168e-03\n",
      "  2.2655986e-03 -7.4530952e-04 -1.5921375e-03  2.5348598e-03\n",
      "  2.4484482e-03 -1.0197146e-03 -5.6827766e-06 -9.1437553e-04\n",
      " -5.1540197e-03  3.8917162e-04 -3.2070972e-04  4.9817180e-03\n",
      " -7.2639934e-03  1.7299826e-03  2.1776871e-03 -1.4672335e-03\n",
      "  5.1971213e-03 -2.8968889e-05 -1.4389574e-03  5.6202488e-04\n",
      " -5.5613468e-04 -2.5825652e-03  5.2122190e-04  8.5249328e-04\n",
      "  3.8099675e-03 -3.8602101e-03 -7.9277490e-04 -4.1936003e-03\n",
      " -2.4523784e-04  5.5956068e-03 -2.0632970e-03 -8.3102016e-03\n",
      " -1.3387681e-04 -1.2501626e-03  2.8167469e-03  3.1136726e-03\n",
      " -1.4749591e-03  1.1477370e-03 -3.9582176e-04 -1.5023023e-04\n",
      " -2.0205491e-04  8.2990335e-04 -2.5133004e-03  4.0999060e-03\n",
      "  3.1503423e-03  8.7686982e-03 -2.3486898e-03  1.3609162e-03\n",
      "  1.5246588e-03  6.9752960e-03  4.3095658e-03 -3.6183551e-03\n",
      "  2.3697685e-03  4.1001970e-03  1.0453000e-03  4.3926463e-03\n",
      "  3.0180931e-03 -3.2244271e-03 -2.7521548e-04 -4.4026040e-03\n",
      "  2.0613298e-03  4.8564142e-03 -1.5381023e-03  5.7992428e-03\n",
      " -1.3828800e-03  2.0107075e-03  1.0833950e-03  9.6307450e-04\n",
      " -3.6211112e-03], shape=(113,), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "print('Prediction for the 1st letter of the batch 1st sequense:')\n",
    "print(example_batch_predictions[0, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "421edce7-d783-4b9b-a253-37eff08f03a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([[2 0 2 2 0]], shape=(1, 5), dtype=int64)\n"
     ]
    }
   ],
   "source": [
    "# logits is 2-D Tensor with shape [batch_size, num_classes].\n",
    "# Each slice [i, :] represents the unnormalized log-probabilities for all classes.\n",
    "# In the example below we say that the probability for class \"0\"\n",
    "# (element with index 0) is low but the probability for class \"2\" is much higher.\n",
    "tmp_logits = [\n",
    "  [-0.95, 0, 0.95],\n",
    "]\n",
    "\n",
    "# Let's generate 5 samples. Each sample is a class index. Class probabilities \n",
    "# are being taken into account (we expect to see more samples of class \"2\").\n",
    "tmp_samples = tf.random.categorical(\n",
    "    logits=tmp_logits,\n",
    "    num_samples=5\n",
    ")\n",
    "\n",
    "print(tmp_samples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "5ff98b45-8661-4c50-91f6-f82976c3f271",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2000,)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sampled_indices = tf.random.categorical(\n",
    "    logits=example_batch_predictions[0],\n",
    "    num_samples=1\n",
    ")\n",
    "\n",
    "sampled_indices = tf.squeeze(\n",
    "    input=sampled_indices,\n",
    "    axis=-1\n",
    ").numpy()\n",
    "\n",
    "sampled_indices.shape\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "d90fdc2c-548f-4470-9266-28289f69510f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 96,  97,  92,   3,   2,  40,  92,  71, 105,  80, 108,  49,  24,\n",
       "        90,   2,  41,  67,  48,  22,  16,  85,  21,  48,  79,  80,  23,\n",
       "       103,  72,  29,  89,  89,  28,   7,  29,  84,  18,  32,  68,  56,\n",
       "        77,   2,  62,  90,  26,   0,  15,  70,  37,  60,  90,  36, 110,\n",
       "        82,  91,  30,  40,  41, 107, 100,  97,  82,  47, 110,  23,  90,\n",
       "         4, 110,  16,  54,  89,  33,  31, 109,  11,   0,  54,  46,   6,\n",
       "         3,  70,  88, 104, 100,  36,  49,  41,  60,  91,  14,  44,  22,\n",
       "        29, 100,  42,  40,  30,  45,  83,  57, 107])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sampled_indices[:100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "3310a259-24d9-4e83-86ea-a1bd784d0016",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input:\n",
      " \"📗   B o b ' s   A w e s o m e   L a s a g n a \\n \\n 🥕 \\n \\n •   8   o u n c e s   l a s a g n a   n o o\"\n",
      "\n",
      "Next char prediction:\n",
      " 'è ñ = o e ( = : $ ! } ; k + e ) 9 F 1 \\n * • F \" ! . [ J 2 > > y i 2 % m ︎ O T Y e G + w h E 3 7 +'\n"
     ]
    }
   ],
   "source": [
    "print('Input:\\n', repr(''.join(tokenizer.sequences_to_texts([input_example_batch[0].numpy()[:50]]))))\n",
    "print()\n",
    "print('Next char prediction:\\n', repr(''.join(tokenizer.sequences_to_texts([sampled_indices[:50]])))) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "51bdd20a-a130-4ed8-b7d5-c1532ebfabca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Labels shape:  (32, 2000)\n",
      "Logits shape:  (32, 2000, 113)\n"
     ]
    }
   ],
   "source": [
    "    print(\"Labels shape: \", target_example_batch.shape)\n",
    "    print(\"Logits shape: \", example_batch_predictions.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "b10869ea-db7c-44c3-810d-425be4740130",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction shape:  (32, 2000, 113)  # (batch_size, sequence_length, vocab_size)\n",
      "scalar_loss.shape:       (32, 2000)\n",
      "scalar_loss:       4.7292995\n"
     ]
    }
   ],
   "source": [
    "# An objective function.\n",
    "# The function is any callable with the signature scalar_loss = fn(y_true, y_pred).\n",
    "\n",
    "\n",
    "\n",
    "def loss(labels, logits):\n",
    "    entropy = tf.keras.losses.sparse_categorical_crossentropy(\n",
    "        y_true=labels,\n",
    "        y_pred=logits,\n",
    "        from_logits=True\n",
    "    )\n",
    "    return entropy\n",
    "\n",
    "example_batch_loss = loss(target_example_batch, example_batch_predictions)\n",
    "\n",
    "print(\"Prediction shape: \", example_batch_predictions.shape, \" # (batch_size, sequence_length, vocab_size)\")\n",
    "print(\"scalar_loss.shape:      \", example_batch_loss.shape)\n",
    "print(\"scalar_loss:      \", example_batch_loss.numpy().mean()) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "bdc08c1e-7d45-4a24-a8ac-3821121e082f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tf.experimental.numpy.experimental_enable_numpy_behavior()\n",
    "# l = example_batch_predictions.reshape()\n",
    "# print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "b424307d-f505-4717-a8f6-bd5b513caf52",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "adam_optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)\n",
    "\n",
    "model.compile(\n",
    "    optimizer=adam_optimizer,\n",
    "    loss=loss,\n",
    "    metrics=['accuracy'] \n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7168000f-e2de-4d77-a380-79236cd847e2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "5b88b291-71b2-471d-bf75-81037f24c2f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "early_stopping_callback = tf.keras.callbacks.EarlyStopping(\n",
    "    patience=5,\n",
    "    monitor='loss',\n",
    "    restore_best_weights=True,\n",
    "    verbose=1\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "a501e927-e1a3-47b9-bfb7-50cea08c2153",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a checkpoints directory.\n",
    "checkpoint_dir = 'tmp/checkpoints'\n",
    "os.makedirs(checkpoint_dir, exist_ok=True)\n",
    "\n",
    "checkpoint_prefix = os.path.join(checkpoint_dir, 'ckpt_{epoch}')\n",
    "checkpoint_callback=tf.keras.callbacks.ModelCheckpoint(\n",
    "    filepath=checkpoint_prefix,\n",
    "    save_weights_only=True\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "9a6d5c95-3020-4c0b-8422-19fec1fe404e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EPOCHS:           1500\n",
      "INITIAL_EPOCH:    1\n",
      "STEPS_PER_EPOCH:  50\n"
     ]
    }
   ],
   "source": [
    "EPOCHS = 1500\n",
    "INITIAL_EPOCH = 1\n",
    "STEPS_PER_EPOCH = 50\n",
    "\n",
    "print('EPOCHS:          ', EPOCHS)\n",
    "print('INITIAL_EPOCH:   ', INITIAL_EPOCH)\n",
    "print('STEPS_PER_EPOCH: ', STEPS_PER_EPOCH)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b13b4ce-3131-4baf-b504-301afbb7fd6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "val_predictions = [] \n",
    "val_targets = []\n",
    "\n",
    "for x_val, y_val in dataset_train:\n",
    "    predictions = model(x_val)\n",
    "    predictions = tf.argmax(predictions, axis=-1)\n",
    "    val_predictions.extend(predictions.numpy())\n",
    "    val_targets.extend(y_val.numpy())\n",
    "\n",
    "# Calculate precision\n",
    "precision = precision_score(val_targets, val_predictions, average='weighted')\n",
    "print(f'Precision: {precision:.4f}')\n",
    "\n",
    "# Calculate and display confusion matrix\n",
    "conf_matrix = confusion_matrix(val_targets, val_predictions)\n",
    "print('Confusion Matrix:')\n",
    "print(conf_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "e7ef2590-54e6-43ae-bad3-6d2d42425140",
   "metadata": {},
   "outputs": [],
   "source": [
    "# evaluate_model(model, dataset_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "28d9e36d-a069-4c46-bb57-f05890cb894d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2/1500\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-26 10:13:03.210572: I external/local_xla/xla/service/service.cc:168] XLA service 0x7f14cd64bed0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
      "2023-12-26 10:13:03.210600: I external/local_xla/xla/service/service.cc:176]   StreamExecutor device (0): NVIDIA GeForce RTX 4050 Laptop GPU, Compute Capability 8.9\n",
      "2023-12-26 10:13:03.222089: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:269] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
      "I0000 00:00:1703585583.297447    2945 device_compiler.h:186] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 [==============================] - 21s 372ms/step - loss: 1.7415 - accuracy: 0.6139\n",
      "Epoch 3/1500\n",
      "50/50 [==============================] - 18s 365ms/step - loss: 1.2794 - accuracy: 0.6603\n",
      "Epoch 4/1500\n",
      "50/50 [==============================] - 18s 365ms/step - loss: 1.0009 - accuracy: 0.7163\n",
      "Epoch 5/1500\n",
      "50/50 [==============================] - 18s 365ms/step - loss: 0.8742 - accuracy: 0.7465\n",
      "Epoch 6/1500\n",
      "50/50 [==============================] - 18s 365ms/step - loss: 0.7914 - accuracy: 0.7703\n",
      "Epoch 7/1500\n",
      "50/50 [==============================] - 18s 364ms/step - loss: 0.6984 - accuracy: 0.7975\n",
      "Epoch 8/1500\n",
      "50/50 [==============================] - 18s 364ms/step - loss: 0.6400 - accuracy: 0.8159\n",
      "Epoch 9/1500\n",
      "50/50 [==============================] - 18s 363ms/step - loss: 0.5937 - accuracy: 0.8283\n",
      "Epoch 10/1500\n",
      "50/50 [==============================] - 18s 368ms/step - loss: 0.5426 - accuracy: 0.8429\n",
      "Epoch 11/1500\n",
      "50/50 [==============================] - 18s 369ms/step - loss: 0.5042 - accuracy: 0.8539\n",
      "Epoch 12/1500\n",
      "50/50 [==============================] - 18s 366ms/step - loss: 0.4772 - accuracy: 0.8622\n",
      "Epoch 13/1500\n",
      "50/50 [==============================] - 18s 363ms/step - loss: 0.4820 - accuracy: 0.8603\n",
      "Epoch 14/1500\n",
      "50/50 [==============================] - 18s 364ms/step - loss: 0.4441 - accuracy: 0.8714\n",
      "Epoch 15/1500\n",
      "50/50 [==============================] - 18s 363ms/step - loss: 0.4326 - accuracy: 0.8747\n",
      "Epoch 16/1500\n",
      "50/50 [==============================] - 18s 365ms/step - loss: 0.4073 - accuracy: 0.8815\n",
      "Epoch 17/1500\n",
      "50/50 [==============================] - 18s 363ms/step - loss: 0.4005 - accuracy: 0.8836\n",
      "Epoch 18/1500\n",
      "50/50 [==============================] - 18s 364ms/step - loss: 0.3839 - accuracy: 0.8881\n",
      "Epoch 19/1500\n",
      "50/50 [==============================] - 18s 364ms/step - loss: 0.3682 - accuracy: 0.8922\n",
      "Epoch 20/1500\n",
      "50/50 [==============================] - 18s 364ms/step - loss: 0.3674 - accuracy: 0.8925\n",
      "Epoch 21/1500\n",
      "50/50 [==============================] - 18s 364ms/step - loss: 0.3535 - accuracy: 0.8964\n",
      "Epoch 22/1500\n",
      "50/50 [==============================] - 18s 364ms/step - loss: 0.3578 - accuracy: 0.8946\n",
      "Epoch 23/1500\n",
      "50/50 [==============================] - 18s 364ms/step - loss: 0.3585 - accuracy: 0.8942\n",
      "Epoch 24/1500\n",
      "50/50 [==============================] - 18s 364ms/step - loss: 0.3728 - accuracy: 0.8915\n",
      "Epoch 25/1500\n",
      "50/50 [==============================] - 18s 364ms/step - loss: 0.3655 - accuracy: 0.8921\n",
      "Epoch 26/1500\n",
      "50/50 [==============================] - 18s 364ms/step - loss: 0.2793 - accuracy: 0.9153\n",
      "Epoch 27/1500\n",
      "50/50 [==============================] - 18s 366ms/step - loss: 0.2768 - accuracy: 0.9160\n",
      "Epoch 28/1500\n",
      "50/50 [==============================] - 18s 364ms/step - loss: 0.2760 - accuracy: 0.9163\n",
      "Epoch 29/1500\n",
      "50/50 [==============================] - 18s 365ms/step - loss: 0.2695 - accuracy: 0.9179\n",
      "Epoch 30/1500\n",
      "50/50 [==============================] - 19s 371ms/step - loss: 0.2752 - accuracy: 0.9161\n",
      "Epoch 31/1500\n",
      "50/50 [==============================] - 19s 375ms/step - loss: 0.2718 - accuracy: 0.9171\n",
      "Epoch 32/1500\n",
      "50/50 [==============================] - 18s 364ms/step - loss: 0.2715 - accuracy: 0.9171\n",
      "Epoch 33/1500\n",
      "50/50 [==============================] - 18s 368ms/step - loss: 0.2714 - accuracy: 0.9173\n",
      "Epoch 34/1500\n",
      "50/50 [==============================] - ETA: 0s - loss: 0.2753 - accuracy: 0.9162Restoring model weights from the end of the best epoch: 29.\n",
      "50/50 [==============================] - 18s 365ms/step - loss: 0.2753 - accuracy: 0.9162\n",
      "Epoch 34: early stopping\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.11/dist-packages/keras/src/engine/training.py:3103: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n",
      "  saving_api.save_model(\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(\n",
    "    x=dataset_train,\n",
    "    epochs=EPOCHS,\n",
    "    steps_per_epoch=STEPS_PER_EPOCH,\n",
    "    initial_epoch=INITIAL_EPOCH,\n",
    "    callbacks=[\n",
    "        checkpoint_callback,\n",
    "        early_stopping_callback\n",
    "    ]\n",
    ")\n",
    "\n",
    "model_name = 'recipe_generation_rnn_raw.h5'\n",
    "model.save(model_name, save_format='h5')\n",
    "\n",
    "# Access the training history, including accuracy\n",
    "loss_values = history.history['loss']\n",
    "accuracy_values = history.history['accuracy'] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "fe2b57ac-eab5-452a-a212-257f072d67c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def render_training_history(training_history):\n",
    "    loss = training_history.history['loss']\n",
    "\n",
    "    plt.title('Loss')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.plot(loss, label='Training set')\n",
    "    plt.legend()\n",
    "    plt.grid(linestyle='--', linewidth=1, alpha=0.5)\n",
    "    plt.show()\n",
    "\n",
    "render_training_history(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "5baefbbb-14f8-477e-816e-5a8a4d2c5e8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 [==============================] - 8s 158ms/step - loss: 0.2599 - accuracy: 0.9204\n",
      "Loss: 0.2599284052848816,Accuracy: 92.04%\n"
     ]
    }
   ],
   "source": [
    "# accuracy = history.history['accuracy'][-1]\n",
    "# print(f'Final Training Accuracy: {accuracy * 100:.2f}%')\n",
    "loss, accuracy = model.evaluate(dataset_train, steps=STEPS_PER_EPOCH)\n",
    "\n",
    "# # print(f'Loss: {loss}, Accuracy: {accuracy * 100:.2f}%')\n",
    "\n",
    "\n",
    "print(f'Loss: {loss},Accuracy: {accuracy * 100:.2f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "cc27bbcf-47f9-4b38-b717-804645688add",
   "metadata": {},
   "outputs": [],
   "source": [
    "# val_data = list(dataset_train.as_numpy_iterator())\n",
    "# val_inputs = np.array([x for x, y in val_data])\n",
    "# val_targets = np.argmax(np.array([y for x, y in val_data]), axis=-1)\n",
    "\n",
    "# val_predict = np.argmax(model.predict(val_inputs), axis=-1)\n",
    "\n",
    "# # Compute precision\n",
    "# precision = precision_score(val_targets, val_predict, average='weighted')\n",
    "\n",
    "# # Print or use the precision value as needed\n",
    "# print(f'Precision: {precision:.4f}')\n",
    "\n",
    "# import numpy as np\n",
    "# from sklearn.metrics import precision_score, confusion_matrix\n",
    "# val_predictions = []\n",
    "# val_targets = []\n",
    "# for x_val, y_val in dataset_train:\n",
    "#     val_predictions.extend(np.argmax(model.predict(x_val), axis=-1))\n",
    "#     val_targets.extend(y_val.numpy())\n",
    "\n",
    "# # Calculate precision\n",
    "# precision = precision_score(val_targets, val_predictions, average='weighted')\n",
    "# print(f'Precision: {precision:.4f}')\n",
    "\n",
    "# # Calculate and display confusion matrix\n",
    "# conf_matrix = confusion_matrix(val_targets, val_predictions)\n",
    "# print('Confusion Matrix:')\n",
    "# print(conf_matrix)\n",
    "\n",
    "# val_predictions = [] \n",
    "# val_targets = []\n",
    "\n",
    "# for x_val, y_val in dataset_train:\n",
    "#     predictions = model(x_val)\n",
    "#     predictions = tf.argmax(predictions, axis=-1)\n",
    "#     val_predictions.extend(predictions.numpy())\n",
    "#     val_targets.extend(y_val.numpy())\n",
    "\n",
    "# # Calculate precision\n",
    "# precision = precision_score(val_targets, val_predictions, average='weighted')\n",
    "# print(f'Precision: {precision:.4f}')\n",
    "\n",
    "# # Calculate and display confusion matrix\n",
    "# conf_matrix = confusion_matrix(val_targets, val_predictions)\n",
    "# print('Confusion Matrix:')\n",
    "# print(conf_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "070794b6-219f-45c8-a181-07ccc9a412dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': [1.741512417793274,\n",
       "  1.279423475265503,\n",
       "  1.0008916854858398,\n",
       "  0.8742000460624695,\n",
       "  0.791394054889679,\n",
       "  0.6984485387802124,\n",
       "  0.639983057975769,\n",
       "  0.5936669111251831,\n",
       "  0.5425500273704529,\n",
       "  0.5042470693588257,\n",
       "  0.477173388004303,\n",
       "  0.4819999933242798,\n",
       "  0.44412773847579956,\n",
       "  0.432580828666687,\n",
       "  0.40729331970214844,\n",
       "  0.4004534184932709,\n",
       "  0.38388633728027344,\n",
       "  0.3681653141975403,\n",
       "  0.36740371584892273,\n",
       "  0.35352447628974915,\n",
       "  0.3578071892261505,\n",
       "  0.35853341221809387,\n",
       "  0.3727625608444214,\n",
       "  0.3654598295688629,\n",
       "  0.27925124764442444,\n",
       "  0.27680638432502747,\n",
       "  0.27598363161087036,\n",
       "  0.2694512605667114,\n",
       "  0.27522239089012146,\n",
       "  0.2718459963798523,\n",
       "  0.27154263854026794,\n",
       "  0.2713594436645508,\n",
       "  0.2752751410007477],\n",
       " 'accuracy': [0.613940954208374,\n",
       "  0.6603356003761292,\n",
       "  0.7163100242614746,\n",
       "  0.7465137243270874,\n",
       "  0.7703081369400024,\n",
       "  0.7975393533706665,\n",
       "  0.8159199953079224,\n",
       "  0.8283431529998779,\n",
       "  0.8428884148597717,\n",
       "  0.8539112210273743,\n",
       "  0.862202525138855,\n",
       "  0.8602637648582458,\n",
       "  0.8714022040367126,\n",
       "  0.874671220779419,\n",
       "  0.8815175294876099,\n",
       "  0.8835903406143188,\n",
       "  0.8881331086158752,\n",
       "  0.8922112584114075,\n",
       "  0.8925315737724304,\n",
       "  0.8963847160339355,\n",
       "  0.8946240544319153,\n",
       "  0.8941590785980225,\n",
       "  0.8914615511894226,\n",
       "  0.8921303153038025,\n",
       "  0.9153431057929993,\n",
       "  0.9159978032112122,\n",
       "  0.9162584543228149,\n",
       "  0.91789311170578,\n",
       "  0.9161059260368347,\n",
       "  0.9170781373977661,\n",
       "  0.9171437621116638,\n",
       "  0.9173027873039246,\n",
       "  0.9161843657493591]}"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "history.history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dafc58da-d7df-40d1-8f38-fa0b3fe25cd2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "10782b2d-28ce-49ad-a6f6-8ca83ae74879",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_2\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " embedding_2 (Embedding)     (1, None, 256)            28928     \n",
      "                                                                 \n",
      " lstm_1 (LSTM)               (1, None, 1024)           5246976   \n",
      "                                                                 \n",
      " dense_1 (Dense)             (1, None, 113)            115825    \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 5391729 (20.57 MB)\n",
      "Trainable params: 5391729 (20.57 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# simplified_batch_size = 1\n",
    "# # Length of the vocabulary in chars.\n",
    "# vocab_size = VOCABULARY_SIZE\n",
    "\n",
    "# # The embedding dimension.\n",
    "# embedding_dim = 256\n",
    "\n",
    "# # Number of RNN units.\n",
    "# rnn_units = 1024\n",
    "\n",
    "# model_simplified = build_model(vocab_size, embedding_dim, rnn_units, simplified_batch_size)\n",
    "# model_simplified.load_weights(tf.train.latest_checkpoint(checkpoint_dir))\n",
    "# model_simplified.build(tf.TensorShape([simplified_batch_size, None]))\n",
    "\n",
    "# model_simplified.summary()\n",
    "\n",
    "simplified_batch_size = 1\n",
    "vocab_size = VOCABULARY_SIZE\n",
    "embedding_dim = 256\n",
    "rnn_units = 1024\n",
    "\n",
    "model_simplified = build_model(vocab_size, embedding_dim, rnn_units, simplified_batch_size)\n",
    "\n",
    "# Load the weights from the latest checkpoint\n",
    "model_simplified.load_weights(tf.train.latest_checkpoint(checkpoint_dir))\n",
    "\n",
    "# Print the model summary\n",
    "model_simplified.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "76d345af-fe7f-4864-9c77-359a4ca84bdb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, None)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_simplified.input_shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "aa6e7064-e8b2-459c-9def-c5c938d18477",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_text(model, start_string, num_generate = 1000, temperature=1.0):\n",
    "    # Evaluation step (generating text using the learned model)\n",
    "    \n",
    "    padded_start_string = STOP_WORD_TITLE + start_string\n",
    "\n",
    "    # Converting our start string to numbers (vectorizing).\n",
    "    input_indices = np.array(tokenizer.texts_to_sequences([padded_start_string]))\n",
    "\n",
    "    # Empty string to store our results.\n",
    "    text_generated = []\n",
    "\n",
    "    # Here batch size == 1.\n",
    "    model.reset_states()\n",
    "    for char_index in range(num_generate):\n",
    "        predictions = model(input_indices)\n",
    "        # remove the batch dimension\n",
    "        predictions = tf.squeeze(predictions, 0)\n",
    "\n",
    "        # Using a categorical distribution to predict the character returned by the model.\n",
    "        predictions = predictions / temperature\n",
    "        predicted_id = tf.random.categorical(\n",
    "            predictions,\n",
    "            num_samples=1\n",
    "        )[-1, 0].numpy()\n",
    "\n",
    "        # We pass the predicted character as the next input to the model\n",
    "        # along with the previous hidden state.\n",
    "        input_indices = tf.expand_dims([predicted_id], 0)\n",
    "        \n",
    "        next_character = tokenizer.sequences_to_texts(input_indices.numpy())[0]\n",
    "\n",
    "        text_generated.append(next_character)\n",
    "\n",
    "    return (padded_start_string + ''.join(text_generated))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "daf3b865-31cb-41c8-a458-533e5f8ff432",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_combinations(model):\n",
    "    recipe_length = 1000\n",
    "    try_letters = [ 'mushroom']\n",
    "    try_temperature = [1.0, 0.8, 0.4, 0.2]\n",
    "\n",
    "    for letter in try_letters:\n",
    "        for temperature in try_temperature:\n",
    "            generated_text = generate_text(\n",
    "                model,\n",
    "                start_string=letter,\n",
    "                num_generate = recipe_length,\n",
    "                temperature=temperature\n",
    "            )\n",
    "            print(f'Attempt: \"{letter}\" + {temperature}')\n",
    "            print('-----------------------------------')\n",
    "            print(generated_text)\n",
    "            print('\\n\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "1d2f27ca-7304-4e06-8115-ba028e1cf346",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attempt: \"mushroom\" + 1.0\n",
      "-----------------------------------\n",
      "📗 mushroomDVkm}supers and marinated over the mozzarella chips \n",
      "• salt to taste (optional) \n",
      "• 1 teaspoon salt \n",
      "• 1 teaspoon ground black pepper \n",
      "• 1 teaspoon Chyes \n",
      "\n",
      "📝\n",
      "\n",
      "▪︎ Cook the shredded chicken breasts in boiling water if desired and ground the mizza mixture. Season with the yralkon ground lime rice. Spoon into 15 pieck before serving.\n",
      "␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣\n",
      "\n",
      "\n",
      "\n",
      "Attempt: \"mushroom\" + 0.8\n",
      "-----------------------------------\n",
      "📗 mushroomx°{E3 955055%44;1á%18© xx93;55;384454;4554253,5455ñ;2 0}045;4 x18  R5S848858858%8985; %™.␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣\n",
      "\n",
      "\n",
      "\n",
      "Attempt: \"mushroom\" + 0.4\n",
      "-----------------------------------\n",
      "📗 mushroomd½©Kñ03 2355%%54%z%4534 553855%55383;4%2; 5 23 3855%%5542534%4%545534;5%%28355545455334555%%4344; 2530584%55%4R48858%2454;. 75 250%5%5%4;4485%%) 4 2005%5°%555%4.␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣\n",
      "\n",
      "\n",
      "\n",
      "Attempt: \"mushroom\" + 0.2\n",
      "-----------------------------------\n",
      "📗 mushroomd333455554%555554455545555544554545444%5555%55555554;4%4855 045554%4%%25 255 455%555554;454;438554%45555554554444445454;4;4;4% 5 550%5%5555355554;4%48455555%%43445454444%44;4 0455 058558554554;455555553455554545555445555544554455544444454;44488  0455%58885585%%4;4; 2 855%5558554554;4555544455444455544444454444454;48554555854;485554555585;%5588585855455555555544555554555455544344544%555%4%4 545555%%%44445555%%%2% 0 850%%55555355545555555344534454445445455455445544%5%4; 58 x585%558453545555555444544555554344444;44;84855%%5%%␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "generate_combinations(model_simplified)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc5a5da6-7130-4698-978c-ee6138f9923d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "7c3943cc-bc38-4933-ac04-776c71602f10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss values: [1.741512417793274, 1.279423475265503, 1.0008916854858398, 0.8742000460624695, 0.791394054889679, 0.6984485387802124, 0.639983057975769, 0.5936669111251831, 0.5425500273704529, 0.5042470693588257, 0.477173388004303, 0.4819999933242798, 0.44412773847579956, 0.432580828666687, 0.40729331970214844, 0.4004534184932709, 0.38388633728027344, 0.3681653141975403, 0.36740371584892273, 0.35352447628974915, 0.3578071892261505, 0.35853341221809387, 0.3727625608444214, 0.3654598295688629, 0.27925124764442444, 0.27680638432502747, 0.27598363161087036, 0.2694512605667114, 0.27522239089012146, 0.2718459963798523, 0.27154263854026794, 0.2713594436645508, 0.2752751410007477]\n",
      "Accuracy values: [0.613940954208374, 0.6603356003761292, 0.7163100242614746, 0.7465137243270874, 0.7703081369400024, 0.7975393533706665, 0.8159199953079224, 0.8283431529998779, 0.8428884148597717, 0.8539112210273743, 0.862202525138855, 0.8602637648582458, 0.8714022040367126, 0.874671220779419, 0.8815175294876099, 0.8835903406143188, 0.8881331086158752, 0.8922112584114075, 0.8925315737724304, 0.8963847160339355, 0.8946240544319153, 0.8941590785980225, 0.8914615511894226, 0.8921303153038025, 0.9153431057929993, 0.9159978032112122, 0.9162584543228149, 0.91789311170578, 0.9161059260368347, 0.9170781373977661, 0.9171437621116638, 0.9173027873039246, 0.9161843657493591]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Print or use the history values as needed\n",
    "print(f'Loss values: {loss_values}')\n",
    "print(f'Accuracy values: {accuracy_values}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "204124f6-d440-4edf-b199-1b3bb4512a62",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function tensorflow.python.debug.lib.check_numerics_callback.enable_check_numerics(stack_height_limit=30, path_length_limit=50)>"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.keras.backend.clear_session()\n",
    "\n",
    "tf.debugging.enable_check_numerics\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "558a2076-1f2d-41c2-bc07-189f443e38c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-26 10:28:40.281170: I external/local_xla/xla/stream_executor/stream.cc:1986] INTERNAL: Unknown error\n",
      "2023-12-26 10:28:40.281218: I external/local_xla/xla/stream_executor/stream.cc:1990] [stream=0x852d730,impl=0x2484d2f0] INTERNAL: stream did not block host until done; was already in an error state\n"
     ]
    },
    {
     "ename": "InternalError",
     "evalue": "stream did not block host until done; was already in an error state",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mInternalError\u001b[0m                             Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[86], line 14\u001b[0m\n\u001b[1;32m     11\u001b[0m y_val \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray(y_val)\n\u001b[1;32m     13\u001b[0m \u001b[38;5;66;03m# Get model predictions on the validation set\u001b[39;00m\n\u001b[0;32m---> 14\u001b[0m y_val_probabilities \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpredict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx_val\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     16\u001b[0m \u001b[38;5;66;03m# Assuming the number of classes is known\u001b[39;00m\n\u001b[1;32m     17\u001b[0m num_classes \u001b[38;5;241m=\u001b[39m STEPS_PER_EPOCH  \u001b[38;5;66;03m# Replace with the actual number of classes\u001b[39;00m\n",
      "File \u001b[0;32m/usr/local/lib/python3.11/dist-packages/keras/src/utils/traceback_utils.py:70\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     67\u001b[0m     filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n\u001b[1;32m     68\u001b[0m     \u001b[38;5;66;03m# To get the full stack trace, call:\u001b[39;00m\n\u001b[1;32m     69\u001b[0m     \u001b[38;5;66;03m# `tf.debugging.disable_traceback_filtering()`\u001b[39;00m\n\u001b[0;32m---> 70\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m e\u001b[38;5;241m.\u001b[39mwith_traceback(filtered_tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m     71\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m     72\u001b[0m     \u001b[38;5;28;01mdel\u001b[39;00m filtered_tb\n",
      "File \u001b[0;32m/usr/local/lib/python3.11/dist-packages/tensorflow/python/framework/ops.py:362\u001b[0m, in \u001b[0;36m_EagerTensorBase._numpy\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    360\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_numpy_internal()\n\u001b[1;32m    361\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:  \u001b[38;5;66;03m# pylint: disable=protected-access\u001b[39;00m\n\u001b[0;32m--> 362\u001b[0m   \u001b[38;5;28;01mraise\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_status_to_exception(e) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n",
      "\u001b[0;31mInternalError\u001b[0m: stream did not block host until done; was already in an error state"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d464a5a3-6f43-413a-b3c5-9c6904753167",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "76f64f80-5067-4e15-9e1d-c69c28854bec",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "When providing an infinite dataset, you must specify the number of steps to run (if you did not intend to create an infinite dataset, make sure to not call `repeat()` on the dataset).",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[85], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m val_predict \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39margmax(\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpredict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdataset_train\u001b[49m\u001b[43m)\u001b[49m, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m      2\u001b[0m val_targ \u001b[38;5;241m=\u001b[39m dataset_train\u001b[38;5;241m.\u001b[39mmap(\u001b[38;5;28;01mlambda\u001b[39;00m x, y: y)\n\u001b[1;32m      3\u001b[0m precision \u001b[38;5;241m=\u001b[39m precision_score(val_targ, val_predict, average\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mweighted\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
      "File \u001b[0;32m/usr/local/lib/python3.11/dist-packages/keras/src/utils/traceback_utils.py:70\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     67\u001b[0m     filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n\u001b[1;32m     68\u001b[0m     \u001b[38;5;66;03m# To get the full stack trace, call:\u001b[39;00m\n\u001b[1;32m     69\u001b[0m     \u001b[38;5;66;03m# `tf.debugging.disable_traceback_filtering()`\u001b[39;00m\n\u001b[0;32m---> 70\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m e\u001b[38;5;241m.\u001b[39mwith_traceback(filtered_tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m     71\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m     72\u001b[0m     \u001b[38;5;28;01mdel\u001b[39;00m filtered_tb\n",
      "File \u001b[0;32m/usr/local/lib/python3.11/dist-packages/keras/src/engine/data_adapter.py:834\u001b[0m, in \u001b[0;36mDatasetAdapter._validate_args\u001b[0;34m(self, y, sample_weights, steps, pss_evaluation_shards)\u001b[0m\n\u001b[1;32m    828\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m    829\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWhen performing exact evaluation, the dataset \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    830\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmust be finite. Make sure not to call `repeat()` \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    831\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mon your dataset.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    832\u001b[0m     )\n\u001b[1;32m    833\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 834\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m    835\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWhen providing an infinite dataset, you must \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    836\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mspecify the number of steps to run (if you did \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    837\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnot intend to create an infinite dataset, make \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    838\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msure to not call `repeat()` on the dataset).\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    839\u001b[0m     )\n",
      "\u001b[0;31mValueError\u001b[0m: When providing an infinite dataset, you must specify the number of steps to run (if you did not intend to create an infinite dataset, make sure to not call `repeat()` on the dataset)."
     ]
    }
   ],
   "source": [
    "\n",
    "val_predict = np.argmax(model.predict(dataset_train), axis=-1)\n",
    "val_targ = dataset_train.map(lambda x, y: y)\n",
    "precision = precision_score(val_targ, val_predict, average='weighted')\n",
    "recall = recall_score(val_targ, val_predict, average='weighted')\n",
    "f1 = f1_score(val_targ, val_predict, average='weighted')\n",
    "\n",
    "print(f'Precision: {precision:.4f}, Recall: {recall:.4f}, F1: {f1:.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8370eb60-201b-4028-9745-eafe2d7fb953",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.0rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}