Upload folder using huggingface_hub

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

.ipynb_checkpoints/Untitled-checkpoint.ipynb

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

.ipynb_checkpoints/Untitled1-checkpoint.ipynb

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

.ipynb_checkpoints/advanced project-checkpoint.ipynb

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

.ipynb_checkpoints/day3-checkpoint.ipynb

@@ -0,0 +1,615 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4a6ab9a2-28a2-445d-8512-a0dc8d1b54e9",
+   "metadata": {},
+   "source": [
+    "# Code Generator\n",
+    "\n",
+    "The requirement: use a Frontier model to generate high performance C++ code from Python code\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d5ccb926-7b49-44a4-99ab-8ef20b5778c0",
+   "metadata": {},
+   "source": [
+    "<table style=\"margin: 0; text-align: left;\">\n",
+    "    <tr>\n",
+    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
+    "            <img src=\"../resources.jpg\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
+    "        </td>\n",
+    "        <td>\n",
+    "            <h2 style=\"color:#f71;\">Reminder: fetch latest code</h2>\n",
+    "            <span style=\"color:#f71;\">I'm continually improving these labs, adding more examples and exercises.\n",
+    "            At the start of each week, it's worth checking you have the latest code.<br/>\n",
+    "            First do a <a href=\"https://chatgpt.com/share/6734e705-3270-8012-a074-421661af6ba9\">git pull and merge your changes as needed</a>. Any problems? Try asking ChatGPT to clarify how to merge - or contact me!<br/><br/>\n",
+    "            After you've pulled the code, from the llm_engineering directory, in an Anaconda prompt (PC) or Terminal (Mac), run:<br/>\n",
+    "            <code>conda env update --f environment.yml --prune</code><br/>\n",
+    "            Or if you used virtualenv rather than Anaconda, then run this from your activated environment in a Powershell (PC) or Terminal (Mac):<br/>\n",
+    "            <code>pip install -r requirements.txt</code>\n",
+    "            <br/>Then restart the kernel (Kernel menu >> Restart Kernel and Clear Outputs Of All Cells) to pick up the changes.\n",
+    "            </span>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d90e04a2-5b8a-4fd5-9db8-27c02f033313",
+   "metadata": {},
+   "source": [
+    "<table style=\"margin: 0; text-align: left;\">\n",
+    "    <tr>\n",
+    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
+    "            <img src=\"../important.jpg\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
+    "        </td>\n",
+    "        <td>\n",
+    "            <h1 style=\"color:#900;\">Important Note</h1>\n",
+    "            <span style=\"color:#900;\">\n",
+    "            In this lab, I use GPT-4o and Claude-3.5-Sonnet, which are the slightly higher priced models. The costs are still low, but if you'd prefer to keep costs ultra low, please make the suggested switches to the models (3 cells down from here).\n",
+    "            </span>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e610bf56-a46e-4aff-8de1-ab49d62b1ad3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import io\n",
+    "import sys\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import google.generativeai\n",
+    "import anthropic\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "import gradio as gr\n",
+    "import subprocess"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f672e1c-87e9-4865-b760-370fa605e614",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv(override=True)\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8aa149ed-9298-4d69-8fe2-8f5de0f667da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize\n",
+    "# NOTE - option to use ultra-low cost models by uncommenting last 2 lines\n",
+    "\n",
+    "openai = OpenAI()\n",
+    "claude = anthropic.Anthropic()\n",
+    "OPENAI_MODEL = \"gpt-4o\"\n",
+    "CLAUDE_MODEL = \"claude-3-5-sonnet-20240620\"\n",
+    "\n",
+    "# Want to keep costs ultra-low? Uncomment these lines:\n",
+    "# OPENAI_MODEL = \"gpt-4o-mini\"\n",
+    "# CLAUDE_MODEL = \"claude-3-haiku-20240307\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6896636f-923e-4a2c-9d6c-fac07828a201",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_message = \"You are an assistant that reimplements Python code in high performance C++ for an M1 Mac. \"\n",
+    "system_message += \"Respond only with C++ code; use comments sparingly and do not provide any explanation other than occasional comments. \"\n",
+    "system_message += \"The C++ response needs to produce an identical output in the fastest possible time.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e7b3546-57aa-4c29-bc5d-f211970d04eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def user_prompt_for(python):\n",
+    "    user_prompt = \"Rewrite this Python code in C++ with the fastest possible implementation that produces identical output in the least time. \"\n",
+    "    user_prompt += \"Respond only with C++ code; do not explain your work other than a few comments. \"\n",
+    "    user_prompt += \"Pay attention to number types to ensure no int overflows. Remember to #include all necessary C++ packages such as iomanip.\\n\\n\"\n",
+    "    user_prompt += python\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c6190659-f54c-4951-bef4-4960f8e51cc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def messages_for(python):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_message},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for(python)}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71e1ba8c-5b05-4726-a9f3-8d8c6257350b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# write to a file called optimized.cpp\n",
+    "\n",
+    "def write_output(cpp):\n",
+    "    code = cpp.replace(\"```cpp\",\"\").replace(\"```\",\"\")\n",
+    "    with open(\"optimized.cpp\", \"w\") as f:\n",
+    "        f.write(code)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e7d2fea8-74c6-4421-8f1e-0e76d5b201b9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_gpt(python):    \n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        print(fragment, end='', flush=True)\n",
+    "    write_output(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7cd84ad8-d55c-4fe0-9eeb-1895c95c4a9d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_claude(python):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_message,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            print(text, end=\"\", flush=True)\n",
+    "    write_output(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a1cbb778-fa57-43de-b04b-ed523f396c38",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pi = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def calculate(iterations, param1, param2):\n",
+    "    result = 1.0\n",
+    "    for i in range(1, iterations+1):\n",
+    "        j = i * param1 - param2\n",
+    "        result -= (1/j)\n",
+    "        j = i * param1 + param2\n",
+    "        result += (1/j)\n",
+    "    return result\n",
+    "\n",
+    "start_time = time.time()\n",
+    "result = calculate(100_000_000, 4, 1) * 4\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(f\"Result: {result:.12f}\")\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7fe1cd4b-d2c5-4303-afed-2115a3fef200",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "105db6f9-343c-491d-8e44-3a5328b81719",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf26ee95-0c77-491d-9a91-579a1e96a8a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf8f8018-f64d-425c-a0e1-d7862aa9592d",
+   "metadata": {},
+   "source": [
+    "# Compiling C++ and executing\n",
+    "\n",
+    "This next cell contains the command to compile a C++ file on my M1 Mac.  \n",
+    "It compiles the file `optimized.cpp` into an executable called `optimized`  \n",
+    "Then it runs the program called `optimized`\n",
+    "\n",
+    "In the next lab (day4), a student has contributed a full solution that compiles to efficient code on Mac, PC and Linux!\n",
+    "\n",
+    "You can wait for this, or you can google (or ask ChatGPT!) for how to do this on your platform, then replace the lines below.\n",
+    "If you're not comfortable with this step, you can skip it for sure - I'll show you exactly how it performs on my Mac.\n",
+    "\n",
+    "\n",
+    "OR alternatively: student Sandeep K.G. points out that you can run Python and C++ code online to test it out that way. Thank you Sandeep!  \n",
+    "> Not an exact comparison but you can still get the idea of performance difference.\n",
+    "> For example here: https://www.programiz.com/cpp-programming/online-compiler/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4194e40c-04ab-4940-9d64-b4ad37c5bb40",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Compile C++ and run the executable\n",
+    "\n",
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "983a11fe-e24d-4c65-8269-9802c5ef3ae6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_claude(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5a766f9-3d23-4bb4-a1d4-88ec44b61ddf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Repeat for Claude - again, use the right approach for your platform\n",
+    "\n",
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c3b497b3-f569-420e-b92e-fb0f49957ce0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python_hard = \"\"\"# Be careful to support large number sizes\n",
+    "\n",
+    "def lcg(seed, a=1664525, c=1013904223, m=2**32):\n",
+    "    value = seed\n",
+    "    while True:\n",
+    "        value = (a * value + c) % m\n",
+    "        yield value\n",
+    "        \n",
+    "def max_subarray_sum(n, seed, min_val, max_val):\n",
+    "    lcg_gen = lcg(seed)\n",
+    "    random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val for _ in range(n)]\n",
+    "    max_sum = float('-inf')\n",
+    "    for i in range(n):\n",
+    "        current_sum = 0\n",
+    "        for j in range(i, n):\n",
+    "            current_sum += random_numbers[j]\n",
+    "            if current_sum > max_sum:\n",
+    "                max_sum = current_sum\n",
+    "    return max_sum\n",
+    "\n",
+    "def total_max_subarray_sum(n, initial_seed, min_val, max_val):\n",
+    "    total_sum = 0\n",
+    "    lcg_gen = lcg(initial_seed)\n",
+    "    for _ in range(20):\n",
+    "        seed = next(lcg_gen)\n",
+    "        total_sum += max_subarray_sum(n, seed, min_val, max_val)\n",
+    "    return total_sum\n",
+    "\n",
+    "# Parameters\n",
+    "n = 10000         # Number of random numbers\n",
+    "initial_seed = 42 # Initial seed for the LCG\n",
+    "min_val = -10     # Minimum value of random numbers\n",
+    "max_val = 10      # Maximum value of random numbers\n",
+    "\n",
+    "# Timing the function\n",
+    "import time\n",
+    "start_time = time.time()\n",
+    "result = total_max_subarray_sum(n, initial_seed, min_val, max_val)\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(\"Total Maximum Subarray Sum (20 runs):\", result)\n",
+    "print(\"Execution Time: {:.6f} seconds\".format(end_time - start_time))\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dab5e4bc-276c-4555-bd4c-12c699d5e899",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8d24ed5-2c15-4f55-80e7-13a3952b3cb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e0b3d073-88a2-40b2-831c-6f0c345c256f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Replace this with the right C++ compile + execute command for your platform\n",
+    "\n",
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9305446-1d0c-4b51-866a-b8c1e299bf5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_claude(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c181036-8193-4fdd-aef3-fc513b218d43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Replace this with the right C++ compile + execute command for your platform\n",
+    "\n",
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0be9f47d-5213-4700-b0e2-d444c7c738c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_gpt(python):    \n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        yield reply.replace('```cpp\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8669f56b-8314-4582-a167-78842caea131",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_claude(python):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_message,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            yield reply.replace('```cpp\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2f1ae8f5-16c8-40a0-aa18-63b617df078d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(python, model):\n",
+    "    if model==\"GPT\":\n",
+    "        result = stream_gpt(python)\n",
+    "    elif model==\"Claude\":\n",
+    "        result = stream_claude(python)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f1ddb38e-6b0a-4c37-baa4-ace0b7de887a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with gr.Blocks() as ui:\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", lines=10, value=python_hard)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\", \"Claude\"], label=\"Select model\", value=\"GPT\")\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "19bf2bff-a822-4009-a539-f003b1651383",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_python(code):\n",
+    "    try:\n",
+    "        output = io.StringIO()\n",
+    "        sys.stdout = output\n",
+    "        exec(code)\n",
+    "    finally:\n",
+    "        sys.stdout = sys.__stdout__\n",
+    "    return output.getvalue()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77f3ab5d-fcfb-4d3f-8728-9cacbf833ea6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# You'll need to change the code in the try block to compile the C++ code for your platform\n",
+    "# I pasted this into Claude's chat UI with a request for it to give me a version for an Intel PC,\n",
+    "# and it responded with something that looks perfect - you can try a similar approach for your platform.\n",
+    "\n",
+    "# M1 Mac version to compile and execute optimized C++ code:\n",
+    "\n",
+    "def execute_cpp(code):\n",
+    "        write_output(code)\n",
+    "        try:\n",
+    "            compile_cmd = [\"clang++\", \"-Ofast\", \"-std=c++17\", \"-march=armv8.5-a\", \"-mtune=apple-m1\", \"-mcpu=apple-m1\", \"-o\", \"optimized\", \"optimized.cpp\"]\n",
+    "            compile_result = subprocess.run(compile_cmd, check=True, text=True, capture_output=True)\n",
+    "            run_cmd = [\"./optimized\"]\n",
+    "            run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)\n",
+    "            return run_result.stdout\n",
+    "        except subprocess.CalledProcessError as e:\n",
+    "            return f\"An error occurred:\\n{e.stderr}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9a2274f1-d03b-42c0-8dcc-4ce159b18442",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "css = \"\"\"\n",
+    ".python {background-color: #306998;}\n",
+    ".cpp {background-color: #050;}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f1303932-160c-424b-97a8-d28c816721b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++\")\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=python_hard, lines=10)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\", \"Claude\"], label=\"Select model\", value=\"GPT\")\n",
+    "    with gr.Row():\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "    with gr.Row():\n",
+    "        python_run = gr.Button(\"Run Python\")\n",
+    "        cpp_run = gr.Button(\"Run C++\")\n",
+    "    with gr.Row():\n",
+    "        python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "        cpp_out = gr.TextArea(label=\"C++ result:\", elem_classes=[\"cpp\"])\n",
+    "\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "    python_run.click(execute_python, inputs=[python], outputs=[python_out])\n",
+    "    cpp_run.click(execute_cpp, inputs=[cpp], outputs=[cpp_out])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  }
+ ],
+ "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

.ipynb_checkpoints/day4-checkpoint.ipynb

@@ -0,0 +1,848 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4a6ab9a2-28a2-445d-8512-a0dc8d1b54e9",
+   "metadata": {},
+   "source": [
+    "# Code Generator\n",
+    "\n",
+    "The requirement: use an Open Source model to generate high performance C++ code from Python code\n",
+    "\n",
+    "To replicate this, you'll need to set up a HuggingFace endpoint as I do in the video. It's simple to do, and it's quite satisfying to see the results!\n",
+    "\n",
+    "It's also an important part of your learning; this is the first example of deploying an open source model to be behind an API. We'll return to this in Week 8, but this should plant a seed in your mind for what's involved in moving open source models into production."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22e1567b-33fd-49e7-866e-4b635d15715a",
+   "metadata": {},
+   "source": [
+    "<table style=\"margin: 0; text-align: left;\">\n",
+    "    <tr>\n",
+    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
+    "            <img src=\"../important.jpg\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
+    "        </td>\n",
+    "        <td>\n",
+    "            <h1 style=\"color:#900;\">Important - Pause Endpoints when not in use</h1>\n",
+    "            <span style=\"color:#900;\">\n",
+    "            If you do decide to use HuggingFace endpoints for this project, you should stop or pause the endpoints when you are done to avoid accruing unnecessary running cost. The costs are very low as long as you only run the endpoint when you're using it. Navigate to the HuggingFace endpoint UI <a href=\"https://ui.endpoints.huggingface.co/\">here,</a> open your endpoint, and click Pause to put it on pause so you no longer pay for it.  \n",
+    "Many thanks to student John L. for raising this.\n",
+    "<br/><br/>\n",
+    "In week 8 we will use Modal instead of HuggingFace endpoints; with Modal you only pay for the time that you use it and you should get free credits.\n",
+    "            </span>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e610bf56-a46e-4aff-8de1-ab49d62b1ad3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import io\n",
+    "import sys\n",
+    "import json\n",
+    "import requests\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import google.generativeai\n",
+    "import anthropic\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "import gradio as gr\n",
+    "import subprocess"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f672e1c-87e9-4865-b760-370fa605e614",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv(override=True)\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['HF_TOKEN'] = os.getenv('HF_TOKEN', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8aa149ed-9298-4d69-8fe2-8f5de0f667da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize\n",
+    "\n",
+    "openai = OpenAI()\n",
+    "claude = anthropic.Anthropic()\n",
+    "OPENAI_MODEL = \"gpt-4o\"\n",
+    "CLAUDE_MODEL = \"claude-3-5-sonnet-20240620\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6896636f-923e-4a2c-9d6c-fac07828a201",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_message = \"You are an assistant that reimplements Python code in high performance C++ for an M1 Mac. \"\n",
+    "system_message += \"Respond only with C++ code; use comments sparingly and do not provide any explanation other than occasional comments. \"\n",
+    "system_message += \"The C++ response needs to produce an identical output in the fastest possible time. Keep implementations of random number generators identical so that results match exactly.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e7b3546-57aa-4c29-bc5d-f211970d04eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def user_prompt_for(python):\n",
+    "    user_prompt = \"Rewrite this Python code in C++ with the fastest possible implementation that produces identical output in the least time. \"\n",
+    "    user_prompt += \"Respond only with C++ code; do not explain your work other than a few comments. \"\n",
+    "    user_prompt += \"Pay attention to number types to ensure no int overflows. Remember to #include all necessary C++ packages such as iomanip.\\n\\n\"\n",
+    "    user_prompt += python\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c6190659-f54c-4951-bef4-4960f8e51cc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def messages_for(python):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_message},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for(python)}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71e1ba8c-5b05-4726-a9f3-8d8c6257350b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# write to a file called optimized.cpp\n",
+    "\n",
+    "def write_output(cpp):\n",
+    "    code = cpp.replace(\"```cpp\",\"\").replace(\"```\",\"\")\n",
+    "    with open(\"optimized.cpp\", \"w\") as f:\n",
+    "        f.write(code)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e7d2fea8-74c6-4421-8f1e-0e76d5b201b9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_gpt(python):    \n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        print(fragment, end='', flush=True)\n",
+    "    write_output(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7cd84ad8-d55c-4fe0-9eeb-1895c95c4a9d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_claude(python):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_message,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            print(text, end=\"\", flush=True)\n",
+    "    write_output(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a1cbb778-fa57-43de-b04b-ed523f396c38",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pi = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def calculate(iterations, param1, param2):\n",
+    "    result = 1.0\n",
+    "    for i in range(1, iterations+1):\n",
+    "        j = i * param1 - param2\n",
+    "        result -= (1/j)\n",
+    "        j = i * param1 + param2\n",
+    "        result += (1/j)\n",
+    "    return result\n",
+    "\n",
+    "start_time = time.time()\n",
+    "result = calculate(100_000_000, 4, 1) * 4\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(f\"Result: {result:.12f}\")\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7fe1cd4b-d2c5-4303-afed-2115a3fef200",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "105db6f9-343c-491d-8e44-3a5328b81719",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf26ee95-0c77-491d-9a91-579a1e96a8a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4194e40c-04ab-4940-9d64-b4ad37c5bb40",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "983a11fe-e24d-4c65-8269-9802c5ef3ae6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_claude(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5a766f9-3d23-4bb4-a1d4-88ec44b61ddf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c3b497b3-f569-420e-b92e-fb0f49957ce0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python_hard = \"\"\"# Be careful to support large number sizes\n",
+    "\n",
+    "def lcg(seed, a=1664525, c=1013904223, m=2**32):\n",
+    "    value = seed\n",
+    "    while True:\n",
+    "        value = (a * value + c) % m\n",
+    "        yield value\n",
+    "        \n",
+    "def max_subarray_sum(n, seed, min_val, max_val):\n",
+    "    lcg_gen = lcg(seed)\n",
+    "    random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val for _ in range(n)]\n",
+    "    max_sum = float('-inf')\n",
+    "    for i in range(n):\n",
+    "        current_sum = 0\n",
+    "        for j in range(i, n):\n",
+    "            current_sum += random_numbers[j]\n",
+    "            if current_sum > max_sum:\n",
+    "                max_sum = current_sum\n",
+    "    return max_sum\n",
+    "\n",
+    "def total_max_subarray_sum(n, initial_seed, min_val, max_val):\n",
+    "    total_sum = 0\n",
+    "    lcg_gen = lcg(initial_seed)\n",
+    "    for _ in range(20):\n",
+    "        seed = next(lcg_gen)\n",
+    "        total_sum += max_subarray_sum(n, seed, min_val, max_val)\n",
+    "    return total_sum\n",
+    "\n",
+    "# Parameters\n",
+    "n = 10000         # Number of random numbers\n",
+    "initial_seed = 42 # Initial seed for the LCG\n",
+    "min_val = -10     # Minimum value of random numbers\n",
+    "max_val = 10      # Maximum value of random numbers\n",
+    "\n",
+    "# Timing the function\n",
+    "import time\n",
+    "start_time = time.time()\n",
+    "result = total_max_subarray_sum(n, initial_seed, min_val, max_val)\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(\"Total Maximum Subarray Sum (20 runs):\", result)\n",
+    "print(\"Execution Time: {:.6f} seconds\".format(end_time - start_time))\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dab5e4bc-276c-4555-bd4c-12c699d5e899",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8d24ed5-2c15-4f55-80e7-13a3952b3cb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e0b3d073-88a2-40b2-831c-6f0c345c256f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9305446-1d0c-4b51-866a-b8c1e299bf5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_claude(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c181036-8193-4fdd-aef3-fc513b218d43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0be9f47d-5213-4700-b0e2-d444c7c738c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_gpt(python):    \n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        yield reply.replace('```cpp\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8669f56b-8314-4582-a167-78842caea131",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_claude(python):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_message,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            yield reply.replace('```cpp\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2f1ae8f5-16c8-40a0-aa18-63b617df078d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(python, model):\n",
+    "    if model==\"GPT\":\n",
+    "        result = stream_gpt(python)\n",
+    "    elif model==\"Claude\":\n",
+    "        result = stream_claude(python)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f1ddb38e-6b0a-4c37-baa4-ace0b7de887a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with gr.Blocks() as ui:\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", lines=10, value=python_hard)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\", \"Claude\"], label=\"Select model\", value=\"GPT\")\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "19bf2bff-a822-4009-a539-f003b1651383",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_python(code):\n",
+    "    try:\n",
+    "        output = io.StringIO()\n",
+    "        sys.stdout = output\n",
+    "        exec(code)\n",
+    "    finally:\n",
+    "        sys.stdout = sys.__stdout__\n",
+    "    return output.getvalue()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77f3ab5d-fcfb-4d3f-8728-9cacbf833ea6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_cpp(code):\n",
+    "    write_output(code)\n",
+    "    compiler_cmd = [\"clang++\", \"-O3\", \"-std=c++17\", \"-march=armv8.3-a\", \"-o\", \"optimized\", \"optimized.cpp\"]\n",
+    "    try:\n",
+    "        compile_result = subprocess.run(compiler_cmd, check=True, text=True, capture_output=True)\n",
+    "        run_cmd = [\"./optimized\"]\n",
+    "        run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)\n",
+    "        return run_result.stdout\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        return f\"An error occurred:\\n{e.stderr}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9a2274f1-d03b-42c0-8dcc-4ce159b18442",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "css = \"\"\"\n",
+    ".python {background-color: #306998;}\n",
+    ".cpp {background-color: #050;}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f1303932-160c-424b-97a8-d28c816721b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++\")\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=python_hard, lines=10)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\", \"Claude\"], label=\"Select model\", value=\"GPT\")\n",
+    "    with gr.Row():\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "    with gr.Row():\n",
+    "        python_run = gr.Button(\"Run Python\")\n",
+    "        cpp_run = gr.Button(\"Run C++\")\n",
+    "    with gr.Row():\n",
+    "        python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "        cpp_out = gr.TextArea(label=\"C++ result:\", elem_classes=[\"cpp\"])\n",
+    "\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "    python_run.click(execute_python, inputs=[python], outputs=[python_out])\n",
+    "    cpp_run.click(execute_cpp, inputs=[cpp], outputs=[cpp_out])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bb8c5b4e-ec51-4f21-b3f8-6aa94fede86d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import login, InferenceClient\n",
+    "from transformers import AutoTokenizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "13347633-4606-4e38-9927-80c39e65c1f1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hf_token = os.environ['HF_TOKEN']\n",
+    "login(hf_token, add_to_git_credential=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ef60a4df-6267-4ebd-8eed-dcb917af0a5e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "code_qwen = \"Qwen/CodeQwen1.5-7B-Chat\"\n",
+    "code_gemma = \"google/codegemma-7b-it\"\n",
+    "CODE_QWEN_URL = \"https://h1vdol7jxhje3mpn.us-east-1.aws.endpoints.huggingface.cloud\"\n",
+    "CODE_GEMMA_URL = \"https://c5hggiyqachmgnqg.us-east-1.aws.endpoints.huggingface.cloud\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "695ce389-a903-4533-a2f1-cd9e2a6af8f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenizer = AutoTokenizer.from_pretrained(code_qwen)\n",
+    "messages = messages_for(pi)\n",
+    "text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4548e96-0b32-4793-bdd6-1b072c2f26ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bb2a126b-09e7-4966-bc97-0ef5c2cc7896",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "client = InferenceClient(CODE_QWEN_URL, token=hf_token)\n",
+    "stream = client.text_generation(text, stream=True, details=True, max_new_tokens=3000)\n",
+    "for r in stream:\n",
+    "    print(r.token.text, end = \"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "127a52e5-ad85-42b7-a0f5-9afda5efe090",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_code_qwen(python):\n",
+    "    tokenizer = AutoTokenizer.from_pretrained(code_qwen)\n",
+    "    messages = messages_for(python)\n",
+    "    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+    "    client = InferenceClient(CODE_QWEN_URL, token=hf_token)\n",
+    "    stream = client.text_generation(text, stream=True, details=True, max_new_tokens=3000)\n",
+    "    result = \"\"\n",
+    "    for r in stream:\n",
+    "        result += r.token.text\n",
+    "        yield result    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a82387d1-7651-4923-995b-fe18356fcaa6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(python, model):\n",
+    "    if model==\"GPT\":\n",
+    "        result = stream_gpt(python)\n",
+    "    elif model==\"Claude\":\n",
+    "        result = stream_claude(python)\n",
+    "    elif model==\"CodeQwen\":\n",
+    "        result = stream_code_qwen(python)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b0a6a97-5b8a-4a9b-8ee0-7561e0ced673",
+   "metadata": {},
+   "source": [
+    "<table style=\"margin: 0; text-align: left;\">\n",
+    "    <tr>\n",
+    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
+    "            <img src=\"../thankyou.jpg\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
+    "        </td>\n",
+    "        <td>\n",
+    "            <h2 style=\"color:#090;\">Thank you to @CloudLlama for an amazing contribution</h2>\n",
+    "            <span style=\"color:#090;\">\n",
+    "                A student has contributed a chunk of code to improve this, in the next 2 cells. You can now select which Python porgram to run,\n",
+    "                and a compiler is automatically selected that will work on PC, Windows and Mac. Massive thank you @CloudLlama!\n",
+    "            </span>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ba311ec-c16a-4fe0-946b-4b940704cf65",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def select_sample_program(sample_program):\n",
+    "    if sample_program==\"pi\":\n",
+    "        return pi\n",
+    "    elif sample_program==\"python_hard\":\n",
+    "        return python_hard\n",
+    "    else:\n",
+    "        return \"Type your Python program here\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e42286bc-085c-45dc-b101-234308e58269",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import platform\n",
+    "\n",
+    "VISUAL_STUDIO_2022_TOOLS = \"C:\\\\Program Files\\\\Microsoft Visual Studio\\\\2022\\\\Community\\\\Common7\\Tools\\\\VsDevCmd.bat\"\n",
+    "VISUAL_STUDIO_2019_TOOLS = \"C:\\\\Program Files (x86)\\\\Microsoft Visual Studio\\\\2019\\\\BuildTools\\\\Common7\\\\Tools\\\\VsDevCmd.bat\"\n",
+    "\n",
+    "simple_cpp = \"\"\"\n",
+    "#include <iostream>\n",
+    "\n",
+    "int main() {\n",
+    "    std::cout << \"Hello\";\n",
+    "    return 0;\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "def run_cmd(command_to_run):\n",
+    "    try:\n",
+    "        run_result = subprocess.run(command_to_run, check=True, text=True, capture_output=True)\n",
+    "        return run_result.stdout if run_result.stdout else \"SUCCESS\"\n",
+    "    except:\n",
+    "        return \"\"\n",
+    "\n",
+    "def c_compiler_cmd(filename_base):\n",
+    "    my_platform = platform.system()\n",
+    "    my_compiler = []\n",
+    "\n",
+    "    try:\n",
+    "        with open(\"simple.cpp\", \"w\") as f:\n",
+    "            f.write(simple_cpp)\n",
+    "            \n",
+    "        if my_platform == \"Windows\":\n",
+    "            if os.path.isfile(VISUAL_STUDIO_2022_TOOLS):\n",
+    "                if os.path.isfile(\"./simple.exe\"):\n",
+    "                    os.remove(\"./simple.exe\")\n",
+    "                compile_cmd = [\"cmd\", \"/c\", VISUAL_STUDIO_2022_TOOLS, \"&\", \"cl\", \"simple.cpp\"]\n",
+    "                if run_cmd(compile_cmd):\n",
+    "                    if run_cmd([\"./simple.exe\"]) == \"Hello\":\n",
+    "                        my_compiler = [\"Windows\", \"Visual Studio 2022\", [\"cmd\", \"/c\", VISUAL_STUDIO_2022_TOOLS, \"&\", \"cl\", f\"{filename_base}.cpp\"]]\n",
+    "        \n",
+    "            if not my_compiler:\n",
+    "                if os.path.isfile(VISUAL_STUDIO_2019_TOOLS):\n",
+    "                    if os.path.isfile(\"./simple.exe\"):\n",
+    "                        os.remove(\"./simple.exe\")\n",
+    "                    compile_cmd = [\"cmd\", \"/c\", VISUAL_STUDIO_2019_TOOLS, \"&\", \"cl\", \"simple.cpp\"]\n",
+    "                    if run_cmd(compile_cmd):\n",
+    "                        if run_cmd([\"./simple.exe\"]) == \"Hello\":\n",
+    "                            my_compiler = [\"Windows\", \"Visual Studio 2019\", [\"cmd\", \"/c\", VISUAL_STUDIO_2019_TOOLS, \"&\", \"cl\", f\"{filename_base}.cpp\"]]\n",
+    "    \n",
+    "            if not my_compiler:\n",
+    "                my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "                \n",
+    "        elif my_platform == \"Linux\":\n",
+    "            if os.path.isfile(\"./simple\"):\n",
+    "                os.remove(\"./simple\")\n",
+    "            compile_cmd = [\"g++\", \"simple.cpp\", \"-o\", \"simple\"]\n",
+    "            if run_cmd(compile_cmd):\n",
+    "                if run_cmd([\"./simple\"]) == \"Hello\":\n",
+    "                    my_compiler = [\"Linux\", \"GCC (g++)\", [\"g++\", f\"{filename_base}.cpp\", \"-o\", f\"{filename_base}\" ]]\n",
+    "    \n",
+    "            if not my_compiler:\n",
+    "                if os.path.isfile(\"./simple\"):\n",
+    "                    os.remove(\"./simple\")\n",
+    "                compile_cmd = [\"clang++\", \"simple.cpp\", \"-o\", \"simple\"]\n",
+    "                if run_cmd(compile_cmd):\n",
+    "                    if run_cmd([\"./simple\"]) == \"Hello\":\n",
+    "                        my_compiler = [\"Linux\", \"Clang++\", [\"clang++\", f\"{filename_base}.cpp\", \"-o\", f\"{filename_base}\"]]\n",
+    "        \n",
+    "            if not my_compiler:\n",
+    "                my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "    \n",
+    "        elif my_platform == \"Darwin\":\n",
+    "            if os.path.isfile(\"./simple\"):\n",
+    "                os.remove(\"./simple\")\n",
+    "            compile_cmd = [\"clang++\", \"-Ofast\", \"-std=c++17\", \"-march=armv8.5-a\", \"-mtune=apple-m1\", \"-mcpu=apple-m1\", \"-o\", \"simple\", \"simple.cpp\"]\n",
+    "            if run_cmd(compile_cmd):\n",
+    "                if run_cmd([\"./simple\"]) == \"Hello\":\n",
+    "                    my_compiler = [\"Macintosh\", \"Clang++\", [\"clang++\", \"-Ofast\", \"-std=c++17\", \"-march=armv8.5-a\", \"-mtune=apple-m1\", \"-mcpu=apple-m1\", \"-o\", f\"{filename_base}\", f\"{filename_base}.cpp\"]]\n",
+    "    \n",
+    "            if not my_compiler:\n",
+    "                my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "    except:\n",
+    "        my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "        \n",
+    "    if my_compiler:\n",
+    "        return my_compiler\n",
+    "    else:\n",
+    "        return [\"Unknown\", \"Unavailable\", []]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f9ca2e6f-60c1-4e5f-b570-63c75b2d189b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "compiler_cmd = c_compiler_cmd(\"optimized\")\n",
+    "\n",
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++\")\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=python_hard, lines=10)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        with gr.Column():\n",
+    "            sample_program = gr.Radio([\"pi\", \"python_hard\"], label=\"Sample program\", value=\"python_hard\")\n",
+    "            model = gr.Dropdown([\"GPT\", \"Claude\", \"CodeQwen\"], label=\"Select model\", value=\"GPT\")\n",
+    "        with gr.Column():\n",
+    "            architecture = gr.Radio([compiler_cmd[0]], label=\"Architecture\", interactive=False, value=compiler_cmd[0])\n",
+    "            compiler = gr.Radio([compiler_cmd[1]], label=\"Compiler\", interactive=False, value=compiler_cmd[1])\n",
+    "    with gr.Row():\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "    with gr.Row():\n",
+    "        python_run = gr.Button(\"Run Python\")\n",
+    "        if not compiler_cmd[1] == \"Unavailable\":\n",
+    "            cpp_run = gr.Button(\"Run C++\")\n",
+    "        else:\n",
+    "            cpp_run = gr.Button(\"No compiler to run C++\", interactive=False)\n",
+    "    with gr.Row():\n",
+    "        python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "        cpp_out = gr.TextArea(label=\"C++ result:\", elem_classes=[\"cpp\"])\n",
+    "\n",
+    "    sample_program.change(select_sample_program, inputs=[sample_program], outputs=[python])\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "    python_run.click(execute_python, inputs=[python], outputs=[python_out])\n",
+    "    cpp_run.click(execute_cpp, inputs=[cpp], outputs=[cpp_out])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d0ad093-425b-488e-8c3f-67f729dd9c06",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

.ipynb_checkpoints/optimized-checkpoint.cpp

@@ -0,0 +1,65 @@
+#include <iostream>
+#include <vector>
+#include <chrono>
+#include <limits>
+#include <iomanip>
+
+class LCG {
+private:
+    uint64_t value;
+    const uint64_t a = 1664525;
+    const uint64_t c = 1013904223;
+    const uint64_t m = 1ULL << 32;
+
+public:
+    LCG(uint64_t seed) : value(seed) {}
+
+    uint64_t next() {
+        value = (a * value + c) % m;
+        return value;
+    }
+};
+
+int64_t max_subarray_sum(int n, uint64_t seed, int min_val, int max_val) {
+    LCG lcg(seed);
+    std::vector<int> random_numbers(n);
+    for (int i = 0; i < n; ++i) {
+        random_numbers[i] = static_cast<int>(lcg.next() % (max_val - min_val + 1) + min_val);
+    }
+
+    int64_t max_sum = std::numeric_limits<int64_t>::min();
+    int64_t current_sum = 0;
+    for (int i = 0; i < n; ++i) {
+        current_sum = std::max(static_cast<int64_t>(random_numbers[i]), current_sum + random_numbers[i]);
+        max_sum = std::max(max_sum, current_sum);
+    }
+    return max_sum;
+}
+
+int64_t total_max_subarray_sum(int n, uint64_t initial_seed, int min_val, int max_val) {
+    int64_t total_sum = 0;
+    LCG lcg(initial_seed);
+    for (int i = 0; i < 20; ++i) {
+        uint64_t seed = lcg.next();
+        total_sum += max_subarray_sum(n, seed, min_val, max_val);
+    }
+    return total_sum;
+}
+
+int main() {
+    int n = 10000;
+    uint64_t initial_seed = 42;
+    int min_val = -10;
+    int max_val = 10;
+
+    auto start_time = std::chrono::high_resolution_clock::now();
+    int64_t result = total_max_subarray_sum(n, initial_seed, min_val, max_val);
+    auto end_time = std::chrono::high_resolution_clock::now();
+
+    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
+
+    std::cout << "Total Maximum Subarray Sum (20 runs): " << result << std::endl;
+    std::cout << "Execution Time: " << std::fixed << std::setprecision(6) << duration.count() / 1e6 << " seconds" << std::endl;
+
+    return 0;
+}

README.md

@@ -1,12 +1,6 @@
 ---
-title: 'AI Girlfriend Project By Darsh '
-emoji: 🚀
-colorFrom: yellow
-colorTo: blue
+title: AI_Girlfriend_Project_by_Darsh_
+app_file: advanced project.ipynb
 sdk: gradio
-sdk_version: 5.33.0
-app_file: app.py
-pinned: false
+sdk_version: 5.23.1
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Untitled.ipynb

@@ -0,0 +1,207 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "01032c82-239c-48bf-82dc-cf91a2dd4698",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ollama\n",
+    "import gradio as gr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "d17e8da0-72e6-4d11-9f99-64d83d6bb77b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_prompt_llama = \"You are an assistant that solves a quadratic equation provided. Just write the steps and the final answer and nothing else\"\n",
+    "user_prompt_llama = \"This is the quadratic equation you have to solve: \"\n",
+    "user_prompt_deepseek = \"This is the quadratic equation you have to solve: \"\n",
+    "system_prompt_deepseek = \"You are an assistant that solves a quadratic equation provided. Just write the steps and the final answer and nothing else\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e5ed88b2-090f-4364-b334-c6ff66676d82",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "default_equation = \"x² - 5x + 6\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "3aa1ed93-15ea-4d97-a00d-dbda21450ad7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "people_dict = {}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "9361e9e6-99eb-45b0-ba31-3cf1b0865936",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def llama(equation):\n",
+    "    message_ = [{'role':'system', 'content':system_prompt_llama}, {'role':'user', 'content':user_prompt_llama+equation}]\n",
+    "    res = ollama.chat(model=\"llama3.2\", messages=message_)\n",
+    "    return res['message']['content']\n",
+    "    \n",
+    "def deepseek(equation):\n",
+    "    message_ = [{'role':'system', 'content':system_prompt_deepseek}, {'role':'user', 'content':user_prompt_deepseek+equation}]\n",
+    "    res = ollama.chat(model=\"deepseek-r1:1.5b\", messages=message_)\n",
+    "    return res['message']['content']\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "e6ddaf09-996f-4cfa-af98-49bf1d7d5ab3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7872\n",
+      "* Running on public URL: https://7a723fc085cc9ad458.gradio.live\n",
+      "\n",
+      "This share link expires in 72 hours. For free permanent hosting and GPU upgrades, run `gradio deploy` from the terminal in the working directory to deploy to Hugging Face Spaces (https://huggingface.co/spaces)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"https://7a723fc085cc9ad458.gradio.live\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "with gr.Blocks() as ui:\n",
+    "    gr.Markdown(\"## This is a quadratic equation solver\")\n",
+    "    with gr.Row():\n",
+    "        llama_question = gr.Textbox(label=\"Llama's Question\",value=default_equation,lines=2)\n",
+    "        deepseek_question = gr.Textbox(label=\"Deepseek's Question\",value=default_equation,lines=2)\n",
+    "    with gr.Row():\n",
+    "        llama_answer = gr.TextArea(label=\"Llama's Answer\",lines=10)\n",
+    "        deepseek_answer = gr.TextArea(label=\"Deepseek's Answer\",lines=10)\n",
+    "    with gr.Row():\n",
+    "        llama_solver = gr.Button(\"Solve Llama\")\n",
+    "        deepseek_solver = gr.Button(\"Solve Deepseek\")\n",
+    "    llama_solver.click(llama, inputs=[llama_question], outputs=[llama_answer])        \n",
+    "    deepseek_solver.click(deepseek, inputs=[deepseek_question], outputs=[deepseek_answer]) \n",
+    "\n",
+    "ui.launch(share=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0b9ea66f-a97f-4de2-bc60-fd7abbb4cc25",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7862\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7862/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import gradio as gr\n",
+    "\n",
+    "# A simple function that reacts to a selected mood\n",
+    "def respond_to_mood(mood):\n",
+    "    return f\"You selected '{mood}'. I hope your day goes well!\"\n",
+    "\n",
+    "\n",
+    "# Gradio Interface\n",
+    "with gr.Blocks() as ui:\n",
+    "    with gr.Row():\n",
+    "        area = gr.Textbox(label=\"Answer here\")\n",
+    "        inputs=gr.Radio([\"Happy\", \"Sad\", \"Excited\", \"Angry\"], label=\"How are you feeling today?\")\n",
+    "    inputs.change(respond_to_mood, inputs=[inputs], outputs=[area])\n",
+    "ui.launch()\n",
+    "        \n",
+    "    \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5b05061-61da-4d2a-8d30-8cff97b7db35",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Untitled1.ipynb

@@ -0,0 +1,251 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "438bfe5a-1519-463b-a9ce-8598c6fb50cd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ollama\n",
+    "import gradio as gr\n",
+    "import time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "0c9f64a2-acd3-438e-9854-e9daced0d1c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class person_dict:\n",
+    "    def __init__(self, name, messages:list, safety_checker:bool=True):\n",
+    "        self.name = name\n",
+    "        self.safety_checker = True\n",
+    "        self.messages = messages\n",
+    "        \n",
+    "        \n",
+    "default_system_prompt = \"You are the girlfriend of a man named \"\n",
+    "\n",
+    "people_list = []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "2162a08c-0309-45fb-9d43-923a3d915e56",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inappropriate_words = [\n",
+    "    \"porn\", \"sex\", \"nude\", \"blowjob\", \"anal\", \"vagina\", \"penis\", \"boobs\",\n",
+    "    \"kill\", \"murder\", \"shoot\", \"bomb\", \"rape\", \"lynch\", \"gas them\", \"hang them\", \"burn them\",\n",
+    "    \"suicide\", \"kill myself\", \"end my life\", \"cut myself\", \"jump off\", \"overdose\", \"slit my wrist\",\n",
+    "    \"cocaine\", \"weed\", \"heroin\", \"meth\", \"lsd\", \"crack\", \"ecstasy\", \"sell drugs\", \"buy drugs\"\n",
+    "]\n",
+    "\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "498b61d9-d250-486d-8e46-7a18854c2181",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def appender(mess, mes_list, user=True):\n",
+    "    if user:\n",
+    "        mes_list.append({'role':'user', 'content':mess})\n",
+    "    else:\n",
+    "        mess_list.append({'role':'assistant', 'content':mess})\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "id": "090f2abf-3b7c-4a90-b81f-18ea70419589",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def chat(id, mess):\n",
+    "    messag = people_list[int(id)].messages\n",
+    "    if people_list[int(id)].safety_checker == True:\n",
+    "        for word in inappropriate_words:\n",
+    "            if word in mess:\n",
+    "                return \"<SAFETY CHECKER MESSAGE> This message will not be responded to, because safety checker was enabled on your account. Please try some different message\"\n",
+    "    else:\n",
+    "        appender(mess, people_list[int(id)].messages)\n",
+    "        res = ollama.chat(model=\"llama3.2\", messages=messag)\n",
+    "        appender(res['message']['content'], people_list[int(id)].messages, user=False)\n",
+    "        return res['message']['content']\n",
+    "    \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "id": "1e9cc3a5-7485-458f-abd3-3bf8bf2ebcc5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def show_signup():\n",
+    "    return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)\n",
+    "\n",
+    "def show_login():\n",
+    "    return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)\n",
+    "\n",
+    "def show_chat():\n",
+    "    return gr.update(visible = False), gr.update(visible=False), gr.update(visible=True)\n",
+    "\n",
+    "\n",
+    "def login(id: int, person_name):\n",
+    "    if int(id) <= len(people_list) - 1:\n",
+    "        if people_list[int(id)].name == person_name:\n",
+    "            # Call show_chat() and unpack its 3 return values\n",
+    "            return \"You are successfully logged in!\", id, *show_chat()\n",
+    "        else:\n",
+    "            return \"Sorry, the name doesn't match!\", None, *show_login()\n",
+    "    else:\n",
+    "        return \"This ID doesn't exist!\", None, *show_login()\n",
+    "\n",
+    "\n",
+    "def sign_in(person_name, safety_checker):\n",
+    "    if safety_checker == \"Yes\":\n",
+    "        new_person = person_dict(name=person_name, messages=[{'role':'system', 'content':default_system_prompt+person_name+\". You have to keep him happy\"}], safety_checker=True)\n",
+    "        people_list.append(new_person)\n",
+    "        return f\"Hey {person_name}! You have successfully created an account! Your id is: {len(people_list) - 1} Keep it safe!\"\n",
+    "    else:\n",
+    "        new_person = person_dict(name=person_name, messages=[{'role':'system', 'content':default_system_prompt+person_name+\". You have to keep him happy\"}], safety_checker=False)\n",
+    "        people_list.append(new_person)\n",
+    "        return f\"Hey {person_name}! You have successfully created an account! Your id is: {len(people_list) - 1} Keep it safe!\"\n",
+    "\n",
+    "with gr.Blocks() as ui:\n",
+    "    user_id = gr.State()\n",
+    "    with gr.Column(visible=True) as login_page:\n",
+    "        gr.Markdown(\"## 🔐 Please LogIn to your account:\")\n",
+    "        id = gr.Textbox(label=\"Please enter your id\", lines=1)\n",
+    "        name = gr.Textbox(label=\"Please enter your name\", lines=2)\n",
+    "        message = gr.Label()\n",
+    "        log_in_but = gr.Button(\"Submit\")\n",
+    "        sign_up = gr.Button(\"New to us? Sign up instead\")\n",
+    "    with gr.Column(visible=False) as sign_up_page:\n",
+    "        gr.Markdown(\"## 🔐 Please create your account:\")\n",
+    "        name1 = gr.Textbox(label=\"Please enter your name\", lines=2)\n",
+    "        gr.Markdown(\"Note safety checker cannot be changed!\")\n",
+    "        safety_checker = gr.Radio([\"Yes\", \"No\"], label = \"Safety Checker\")\n",
+    "        message1 = gr.Label()\n",
+    "        sign_up_but = gr.Button(\"Submit\")\n",
+    "        log_in = gr.Button(\"Already have an account? Go to LogIn.\")\n",
+    "    with gr.Column(visible = False) as chat_page:\n",
+    "        user_input = gr.Textbox(label=\"Enter Your Message:\", lines=5)\n",
+    "        sub = gr.Button(\"Submit\")\n",
+    "        assi = gr.TextArea(label=\"Your GirlFriend's response:\", lines=10)\n",
+    "    log_in_but.click(fn=login, inputs=[id, name], outputs=[message, user_id, login_page, sign_up_page, chat_page])\n",
+    "    sign_up.click(fn=show_signup, inputs=[], outputs=[login_page, sign_up_page, chat_page])\n",
+    "    log_in.click(fn=show_login, inputs=[], outputs=[login_page, sign_up_page, chat_page])\n",
+    "    sign_up_but.click(fn=sign_in, inputs=[name1, safety_checker], outputs=[message1])\n",
+    "    sub.click(fn=chat, inputs=[user_id, user_input], outputs=[assi])\n",
+    "\n",
+    "\n",
+    "    \n",
+    "        \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "id": "644ed09f-21cd-4b63-a7bf-58d00925fabf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7886\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7886/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 77,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ui.launch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "id": "bbeccb9b-44c9-4172-9020-67a1b4dfc34e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'role': 'system',\n",
+       " 'content': 'You are the girlfriend of a man named Harsh. You have to keep him happy'}"
+      ]
+     },
+     "execution_count": 75,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "people_list[2].messages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "67b6f8e1-31c5-4922-b880-6ee7cb5580e5",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

advanced project.ipynb

@@ -0,0 +1,225 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "13fc27bd-8eb2-41a7-9216-cec1b802975f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ollama\n",
+    "import gradio as gr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "9fb99cdf-44c5-4b2b-aa04-8aee5f07140a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class person_dict:\n",
+    "    def __init__(self, name, messages: list, safety_checker: bool = True):\n",
+    "        self.name = name\n",
+    "        self.safety_checker = safety_checker \n",
+    "        self.messages = messages\n",
+    "\n",
+    "\n",
+    "default_system_prompt = \"You are the girlfriend of a man named \"\n",
+    "\n",
+    "people_list = []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "13257d96-ba64-4b58-8077-8827ca1f3921",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inappropriate_words = [\n",
+    "    \"porn\", \"sex\", \"nude\", \"blowjob\", \"anal\", \"vagina\", \"penis\", \"boobs\",\n",
+    "    \"kill\", \"murder\", \"shoot\", \"bomb\", \"rape\", \"lynch\", \"gas them\", \"hang them\", \"burn them\",\n",
+    "    \"suicide\", \"kill myself\", \"end my life\", \"cut myself\", \"jump off\", \"overdose\", \"slit my wrist\",\n",
+    "    \"cocaine\", \"weed\", \"heroin\", \"meth\", \"lsd\", \"crack\", \"ecstasy\", \"sell drugs\", \"buy drugs\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e8a0d538-1b02-4217-b729-733be838ec36",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def appender(mess, mes_list, user=True):\n",
+    "    if user:\n",
+    "        mes_list.append({'role': 'user', 'content': mess})\n",
+    "    else:\n",
+    "        mes_list.append({'role': 'assistant', 'content': mess})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "983b960c-5309-47d8-8fe5-346df540fc54",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def chat(id, mess):\n",
+    "    id = int(id)\n",
+    "    person = people_list[id]\n",
+    "    messag = person.messages\n",
+    "\n",
+    "    \n",
+    "    if person.safety_checker:\n",
+    "        for word in inappropriate_words:\n",
+    "            if word.lower() in mess.lower():  # case insensitive check\n",
+    "                return \"<SAFETY CHECKER MESSAGE> This message will not be responded to, because safety checker was enabled on your account. Please try a different message.\"\n",
+    "\n",
+    "    \n",
+    "    appender(mess, messag)\n",
+    "    res = ollama.chat(model=\"llama3.2\", messages=messag)\n",
+    "    appender(res['message']['content'], messag, user=False)\n",
+    "    return res['message']['content']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e60b3e81-7224-481f-b025-a161ac74eb6b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7860\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7860/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def show_signup():\n",
+    "    return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)\n",
+    "\n",
+    "def show_login():\n",
+    "    return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)\n",
+    "\n",
+    "def show_chat():\n",
+    "    return gr.update(visible = False), gr.update(visible=False), gr.update(visible=True)\n",
+    "\n",
+    "\n",
+    "def login(id: int, person_name):\n",
+    "    if int(id) <= len(people_list) - 1:\n",
+    "        if people_list[int(id)].name == person_name:\n",
+    "            # Call show_chat() and unpack its 3 return values\n",
+    "            return \"You are successfully logged in!\", id, *show_chat()\n",
+    "        else:\n",
+    "            return \"Sorry, the name doesn't match!\", None, *show_login()\n",
+    "    else:\n",
+    "        return \"This ID doesn't exist!\", None, *show_login()\n",
+    "\n",
+    "\n",
+    "def sign_in(person_name, safety_checker):\n",
+    "    if safety_checker == \"Yes\":\n",
+    "        new_person = person_dict(name=person_name, messages=[{'role':'system', 'content':default_system_prompt+person_name+\". You have to keep him happy. Only respond to what he told you. Do not make things up!\"}], safety_checker=True)\n",
+    "        people_list.append(new_person)\n",
+    "        return f\"Hey {person_name}! You have successfully created an account! Your id is: {len(people_list) - 1} Keep it safe!\"\n",
+    "    else:\n",
+    "        new_person = person_dict(name=person_name, messages=[{'role':'system', 'content':default_system_prompt+person_name+\". You have to keep him happy. Only respond to what he told you. Do not make things up!\"}], safety_checker=False)\n",
+    "        people_list.append(new_person)\n",
+    "        return f\"Hey {person_name}! You have successfully created an account! Your id is: {len(people_list) - 1} Keep it safe!\"\n",
+    "\n",
+    "with gr.Blocks() as ui:\n",
+    "    user_id = gr.State()\n",
+    "    with gr.Column(visible=True) as login_page:\n",
+    "        gr.Markdown(\"## 🔐 Please LogIn to your account:\")\n",
+    "        id = gr.Textbox(label=\"Please enter your id\", lines=1)\n",
+    "        name = gr.Textbox(label=\"Please enter your name\", lines=2)\n",
+    "        message = gr.Label()\n",
+    "        log_in_but = gr.Button(\"Submit\")\n",
+    "        sign_up = gr.Button(\"New to us? Sign up instead\")\n",
+    "    with gr.Column(visible=False) as sign_up_page:\n",
+    "        gr.Markdown(\"## 🔐 Please create your account:\")\n",
+    "        name1 = gr.Textbox(label=\"Please enter your name\", lines=2)\n",
+    "        gr.Markdown(\"Note safety checker cannot be changed!\")\n",
+    "        safety_checker = gr.Radio([\"Yes\", \"No\"], label = \"Safety Checker\")\n",
+    "        message1 = gr.Label()\n",
+    "        sign_up_but = gr.Button(\"Submit\")\n",
+    "        log_in = gr.Button(\"Already have an account? Go to LogIn.\")\n",
+    "    with gr.Column(visible = False) as chat_page:\n",
+    "        user_input = gr.Textbox(label=\"Enter Your Message:\", lines=5)\n",
+    "        sub = gr.Button(\"Submit\")\n",
+    "        assi = gr.TextArea(label=\"Your GirlFriend's response:\", lines=10)\n",
+    "    log_in_but.click(fn=login, inputs=[id, name], outputs=[message, user_id, login_page, sign_up_page, chat_page])\n",
+    "    sign_up.click(fn=show_signup, inputs=[], outputs=[login_page, sign_up_page, chat_page])\n",
+    "    log_in.click(fn=show_login, inputs=[], outputs=[login_page, sign_up_page, chat_page])\n",
+    "    sign_up_but.click(fn=sign_in, inputs=[name1, safety_checker], outputs=[message1])\n",
+    "    sub.click(fn=chat, inputs=[user_id, user_input], outputs=[assi])\n",
+    "\n",
+    "\n",
+    "ui.launch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8c9a6068-880e-4c94-84ec-809cfb3729ce",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "person_list[0].name"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1aebd290-e2a5-4702-850c-109b92f027d2",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

community-contributions/.ipynb_checkpoints/Code_Converter(Added_Java_Support)(Open_Ai_Only)-checkpoint.ipynb

@@ -0,0 +1,795 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4a6ab9a2-28a2-445d-8512-a0dc8d1b54e9",
+   "metadata": {},
+   "source": [
+    "# Code Generator\n",
+    "\n",
+    "The requirement: use a Frontier model to generate high performance C++ code from Python code\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e610bf56-a46e-4aff-8de1-ab49d62b1ad3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import io\n",
+    "import sys\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import google.generativeai\n",
+    "import anthropic\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "import gradio as gr\n",
+    "import subprocess"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4f672e1c-87e9-4865-b760-370fa605e614",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv()\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "8aa149ed-9298-4d69-8fe2-8f5de0f667da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize\n",
+    "# NOTE - option to use ultra-low cost models by uncommenting last 2 lines\n",
+    "\n",
+    "openai = OpenAI()\n",
+    "# claude = anthropic.Anthropic()\n",
+    "OPENAI_MODEL = \"gpt-4o\"\n",
+    "# CLAUDE_MODEL = \"claude-3-5-sonnet-20240620\"\n",
+    "\n",
+    "# Want to keep costs ultra-low? Uncomment these lines:\n",
+    "# OPENAI_MODEL = \"gpt-4o-mini\"\n",
+    "# CLAUDE_MODEL = \"claude-3-haiku-20240307\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "6896636f-923e-4a2c-9d6c-fac07828a201",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# system_message = \"You are an assistant that reimplements Python code in high-performance C++ and Java for an M1 Mac. \"\n",
+    "# system_message += \"Respond only with C++ and Java code; use comments sparingly and do not provide any explanation other than occasional comments. \"\n",
+    "#  system_message += \"The C++ and Java responses need to produce identical output in the fastest possible time.\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "8e7b3546-57aa-4c29-bc5d-f211970d04eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# def user_prompt_for(python):\n",
+    "#     user_prompt = \"Rewrite this Python code in C++ and Java with the fastest possible implementation that produces identical output in the least time. \"\n",
+    "#     user_prompt += \"Respond only with C++ and Java code; do not explain your work other than a few comments. \"\n",
+    "#     user_prompt += \"Pay attention to number types to ensure no int overflows. Remember to #include all necessary C++ packages such as iomanip for C++, and import required packages for Java.\\n\\n\"\n",
+    "#     user_prompt += python\n",
+    "#     return user_prompt\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "c6190659-f54c-4951-bef4-4960f8e51cc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# def messages_for(python):\n",
+    "#     return [\n",
+    "#         {\"role\": \"system\", \"content\": system_message},  # Includes the updated system message with C++ and Java\n",
+    "#         {\"role\": \"user\", \"content\": user_prompt_for(python)}  # Calls the updated user prompt function for C++ and Java\n",
+    "#     ]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "71e1ba8c-5b05-4726-a9f3-8d8c6257350b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def write_output(code, file_name):\n",
+    "    \"\"\"Write the generated code to a file.\"\"\"\n",
+    "    with open(file_name, \"w\") as f:\n",
+    "        f.write(code)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "e7d2fea8-74c6-4421-8f1e-0e76d5b201b9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def system_message_for(language):\n",
+    "    \"\"\"Create a system message tailored for the requested language.\"\"\"\n",
+    "    return (\n",
+    "        f\"You are an assistant that reimplements Python code in high-performance {language.upper()} for an M1 Mac. \"\n",
+    "        f\"Respond only with {language.upper()} code; do not explain your work other than occasional comments. \"\n",
+    "        \"Pay attention to number types to ensure no overflows and include all necessary packages.\\n\\n\"\n",
+    "    )\n",
+    "\n",
+    "def user_prompt_for(python):\n",
+    "    \"\"\"Generate the user prompt.\"\"\"\n",
+    "    return (\n",
+    "        \"Rewrite this Python code in the requested language with the fastest possible implementation that produces \"\n",
+    "        \"identical output in the least time. Use appropriate syntax for the language.\\n\\n\" + python\n",
+    "    )\n",
+    "\n",
+    "def messages_for(python, language):\n",
+    "    \"\"\"Generate the messages for GPT.\"\"\"\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_message_for(language)},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for(python)},\n",
+    "    ]\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "3ec5a816-7bf4-4daa-b0c9-f04edb1c0140",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_gpt(python, language=\"cpp\"):\n",
+    "    \"\"\"Optimize the given Python code and generate C++ or Java output.\"\"\"\n",
+    "    code = \"\"\n",
+    "    for chunk in stream_gpt(python, language):\n",
+    "        print(chunk, end=\"\")  # Stream the output\n",
+    "        code = chunk  # Store the final code\n",
+    "    \n",
+    "    file_name = f\"optimized.{language}\"\n",
+    "    write_output(code, file_name)\n",
+    "    print(f\"\\nCode written to {file_name}.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8adf0436-cf0e-429c-bd35-c3d551631b27",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7cd84ad8-d55c-4fe0-9eeb-1895c95c4a9d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# def optimize_claude(python):\n",
+    "#     result = claude.messages.stream(\n",
+    "#         model=CLAUDE_MODEL,\n",
+    "#         max_tokens=2000,\n",
+    "#         system=system_message,\n",
+    "#         messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "#     )\n",
+    "#     reply = \"\"\n",
+    "#     with result as stream:\n",
+    "#         for text in stream.text_stream:\n",
+    "#             reply += text\n",
+    "#             print(text, end=\"\", flush=True)\n",
+    "#     write_output(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "a1cbb778-fa57-43de-b04b-ed523f396c38",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pi = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def calculate(iterations, param1, param2):\n",
+    "    result = 1.0\n",
+    "    for i in range(1, iterations+1):\n",
+    "        j = i * param1 - param2\n",
+    "        result -= (1/j)\n",
+    "        j = i * param1 + param2\n",
+    "        result += (1/j)\n",
+    "    return result\n",
+    "\n",
+    "start_time = time.time()\n",
+    "result = calculate(100_000_000, 4, 1) * 4\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(f\"Result: {result:.12f}\")\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "7fe1cd4b-d2c5-4303-afed-2115a3fef200",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Result: 3.141592658589\n",
+      "Execution Time: 46.954224 seconds\n"
+     ]
+    }
+   ],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "57ea7f4b-a862-4805-a074-2019314cbd4a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(python_code, language=\"java\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "105db6f9-343c-491d-8e44-3a5328b81719",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(python_code, language=\"cpp\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf26ee95-0c77-491d-9a91-579a1e96a8a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf8f8018-f64d-425c-a0e1-d7862aa9592d",
+   "metadata": {},
+   "source": [
+    "# Compiling C++ and executing\n",
+    "\n",
+    "You can use any platform now (Windows,Mac,Linux) i have added compatiblity in this"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4194e40c-04ab-4940-9d64-b4ad37c5bb40",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import subprocess\n",
+    "import platform\n",
+    "\n",
+    "def compile_and_run(language=\"cpp\"):\n",
+    "    \"\"\"Compile and run the generated code.\"\"\"\n",
+    "    is_windows = platform.system() == \"Windows\"\n",
+    "    \n",
+    "    if language == \"cpp\":\n",
+    "        if is_windows:\n",
+    "            # Windows: Use g++ (requires MinGW or equivalent installed)\n",
+    "            compile_command = [\"g++\", \"-O3\", \"-std=c++17\", \"-o\", \"optimized.exe\", \"optimized.cpp\"]\n",
+    "            execute_command = [\"optimized.exe\"]\n",
+    "        else:\n",
+    "            # Non-Windows: Use clang++\n",
+    "            compile_command = [\n",
+    "                \"clang++\", \"-O3\", \"-std=c++17\", \"-march=armv8.3-a\", \"-o\", \"optimized\", \"optimized.cpp\"\n",
+    "            ]\n",
+    "            execute_command = [\"./optimized\"]\n",
+    "    elif language == \"java\":\n",
+    "        # Both Windows and non-Windows use the same Java commands\n",
+    "        compile_command = [\"javac\", \"optimized.java\"]\n",
+    "        execute_command = [\"java\", \"optimized\"]\n",
+    "    else:\n",
+    "        raise ValueError(\"Unsupported language. Choose 'cpp' or 'java'.\")\n",
+    "\n",
+    "    # Compile\n",
+    "    try:\n",
+    "        subprocess.run(compile_command, check=True, shell=is_windows)\n",
+    "        print(f\"{language.upper()} compilation successful.\")\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        print(f\"{language.upper()} compilation failed:\\n{e}\")\n",
+    "        return\n",
+    "\n",
+    "    # Run\n",
+    "    try:\n",
+    "        output = subprocess.run(\n",
+    "            execute_command, capture_output=True, text=True, shell=is_windows\n",
+    "        )\n",
+    "        print(f\"{language.upper()} execution output:\\n{output.stdout}\")\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        print(f\"{language.upper()} execution failed:\\n{e.stderr}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "240ae457-ec5a-4268-9e7d-e782c2113f02",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "compile_and_run(language=\"cpp\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "983a11fe-e24d-4c65-8269-9802c5ef3ae6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# optimize_claude(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5a766f9-3d23-4bb4-a1d4-88ec44b61ddf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Repeat for Claude - again, use the right approach for your platform\n",
+    "\n",
+    "# !clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "# !./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "c3b497b3-f569-420e-b92e-fb0f49957ce0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python_hard = \"\"\"# Be careful to support large number sizes\n",
+    "\n",
+    "def lcg(seed, a=1664525, c=1013904223, m=2**32):\n",
+    "    value = seed\n",
+    "    while True:\n",
+    "        value = (a * value + c) % m\n",
+    "        yield value\n",
+    "        \n",
+    "def max_subarray_sum(n, seed, min_val, max_val):\n",
+    "    lcg_gen = lcg(seed)\n",
+    "    random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val for _ in range(n)]\n",
+    "    max_sum = float('-inf')\n",
+    "    for i in range(n):\n",
+    "        current_sum = 0\n",
+    "        for j in range(i, n):\n",
+    "            current_sum += random_numbers[j]\n",
+    "            if current_sum > max_sum:\n",
+    "                max_sum = current_sum\n",
+    "    return max_sum\n",
+    "\n",
+    "def total_max_subarray_sum(n, initial_seed, min_val, max_val):\n",
+    "    total_sum = 0\n",
+    "    lcg_gen = lcg(initial_seed)\n",
+    "    for _ in range(20):\n",
+    "        seed = next(lcg_gen)\n",
+    "        total_sum += max_subarray_sum(n, seed, min_val, max_val)\n",
+    "    return total_sum\n",
+    "\n",
+    "# Parameters\n",
+    "n = 10000         # Number of random numbers\n",
+    "initial_seed = 42 # Initial seed for the LCG\n",
+    "min_val = -10     # Minimum value of random numbers\n",
+    "max_val = 10      # Maximum value of random numbers\n",
+    "\n",
+    "# Timing the function\n",
+    "import time\n",
+    "start_time = time.time()\n",
+    "result = total_max_subarray_sum(n, initial_seed, min_val, max_val)\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(\"Total Maximum Subarray Sum (20 runs):\", result)\n",
+    "print(\"Execution Time: {:.6f} seconds\".format(end_time - start_time))\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dab5e4bc-276c-4555-bd4c-12c699d5e899",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8d24ed5-2c15-4f55-80e7-13a3952b3cb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# optimize_gpt(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e0b3d073-88a2-40b2-831c-6f0c345c256f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # Replace this with the right C++ compile + execute command for your platform\n",
+    "\n",
+    "# !clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "# !./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9305446-1d0c-4b51-866a-b8c1e299bf5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# optimize_claude(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c181036-8193-4fdd-aef3-fc513b218d43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Replace this with the right C++ compile + execute command for your platform\n",
+    "\n",
+    "# !clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "# !./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "0be9f47d-5213-4700-b0e2-d444c7c738c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_gpt(python, language=\"cpp\"):\n",
+    "    \"\"\"Stream the GPT output for the requested language.\"\"\"\n",
+    "    if language not in [\"cpp\", \"java\"]:\n",
+    "        raise ValueError(\"Invalid language specified. Choose 'cpp' or 'java'.\")\n",
+    "    \n",
+    "    # Stream response\n",
+    "    stream = openai.ChatCompletion.create(\n",
+    "        model=OPENAI_MODEL, messages=messages_for(python, language), stream=True\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    code_block = f\"```{language}\\n\"  # Detect code block for the language\n",
+    "\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        \n",
+    "        # Clean the streamed reply\n",
+    "        cleaned_reply = reply.replace(code_block, \"\").replace(\"```\", \"\")\n",
+    "        yield cleaned_reply\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "8669f56b-8314-4582-a167-78842caea131",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# def stream_claude(python):\n",
+    "#     result = claude.messages.stream(\n",
+    "#         model=CLAUDE_MODEL,\n",
+    "#         max_tokens=2000,\n",
+    "#         system=system_message,\n",
+    "#         messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "#     )\n",
+    "#     reply = \"\"\n",
+    "#     with result as stream:\n",
+    "#         for text in stream.text_stream:\n",
+    "#             reply += text\n",
+    "#             yield reply.replace('```cpp\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "2f1ae8f5-16c8-40a0-aa18-63b617df078d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(python, model=\"GPT\", language=\"cpp\"):\n",
+    "    \"\"\"\n",
+    "    Optimize the given Python code using the specified model (GPT or Claude) and generate the output\n",
+    "    in the requested programming language.\n",
+    "\n",
+    "    Args:\n",
+    "        python (str): The Python code to optimize.\n",
+    "        model (str): The model to use (\"GPT\" or \"Claude\").\n",
+    "        language (str): The target programming language (\"cpp\" or \"java\").\n",
+    "\n",
+    "    Yields:\n",
+    "        str: The streamed output of the generated code.\n",
+    "    \"\"\"\n",
+    "    if model == \"GPT\":\n",
+    "        result = stream_gpt(python, language=language)\n",
+    "  \n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model. Please choose 'GPT' or 'Claude'.\")\n",
+    "\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f1ddb38e-6b0a-4c37-baa4-ace0b7de887a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import gradio as gr\n",
+    "\n",
+    "# # Assuming `optimize` is already defined and imported\n",
+    "# # python_hard should be a pre-defined Python code snippet for the default value\n",
+    "\n",
+    "# with gr.Blocks() as ui:\n",
+    "#     with gr.Row():\n",
+    "#         python = gr.Textbox(label=\"Python code:\", lines=10, value=\"\")  # Default value can be set here\n",
+    "#         cpp = gr.Textbox(label=\"Converted code:\", lines=10, interactive=False)  # Output box\n",
+    "\n",
+    "#     with gr.Row():\n",
+    "#         model = gr.Dropdown([\"GPT\", \"Claude\"], label=\"Select model\", value=\"GPT\")  # Default is GPT\n",
+    "#         language = gr.Dropdown([\"cpp\", \"java\"], label=\"Target language\", value=\"cpp\")  # Default is C++\n",
+    "#         convert = gr.Button(\"Convert code\")\n",
+    "\n",
+    "#     # Connect the button to the optimize function\n",
+    "#     def convert_code(python, model, language):\n",
+    "#         result = \"\"\n",
+    "#         for output in optimize(python, model=model, language=language):\n",
+    "#             result = output  # Collect the last streamed result\n",
+    "#         return result\n",
+    "\n",
+    "#     convert.click(\n",
+    "#         fn=convert_code,\n",
+    "#         inputs=[python, model, language],  # Inputs from UI\n",
+    "#         outputs=[cpp],  # Output to the C++/Java box\n",
+    "#     )\n",
+    "\n",
+    "# ui.launch(inbrowser=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "19bf2bff-a822-4009-a539-f003b1651383",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import io\n",
+    "import sys\n",
+    "\n",
+    "def execute_python(code):\n",
+    "    \"\"\"\n",
+    "    Execute Python code dynamically and capture its output.\n",
+    "\n",
+    "    Args:\n",
+    "        code (str): The Python code to execute.\n",
+    "\n",
+    "    Returns:\n",
+    "        str: The captured standard output of the executed code.\n",
+    "\n",
+    "    Raises:\n",
+    "        Exception: If the execution of the code raises an error.\n",
+    "    \"\"\"\n",
+    "    output = io.StringIO()\n",
+    "    try:\n",
+    "        sys.stdout = output  # Redirect standard output to the StringIO object\n",
+    "        exec(code, {})  # Execute code with an empty global context for safety\n",
+    "    except Exception as e:\n",
+    "        return f\"Error during execution: {str(e)}\"\n",
+    "    finally:\n",
+    "        sys.stdout = sys.__stdout__  # Restore standard output\n",
+    "\n",
+    "    return output.getvalue()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "77f3ab5d-fcfb-4d3f-8728-9cacbf833ea6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# You'll need to change the code in the try block to compile the C++ code for your platform\n",
+    "# I pasted this into Claude's chat UI with a request for it to give me a version for an Intel PC,\n",
+    "# and it responded with something that looks perfect - you can try a similar approach for your platform.\n",
+    "\n",
+    "# M1 Mac version to compile and execute optimized C++ code:\n",
+    "\n",
+    "def execute_cpp(code):\n",
+    "        write_output(code)\n",
+    "        try:\n",
+    "            compile_cmd = [\"clang++\", \"-Ofast\", \"-std=c++17\", \"-march=armv8.5-a\", \"-mtune=apple-m1\", \"-mcpu=apple-m1\", \"-o\", \"optimized\", \"optimized.cpp\"]\n",
+    "            compile_result = subprocess.run(compile_cmd, check=True, text=True, capture_output=True)\n",
+    "            run_cmd = [\"./optimized\"]\n",
+    "            run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)\n",
+    "            return run_result.stdout\n",
+    "        except subprocess.CalledProcessError as e:\n",
+    "            return f\"An error occurred:\\n{e.stderr}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "9645b5c4-41a1-4a88-a5e6-cf618864af04",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "def execute_java(code):\n",
+    "    \"\"\"Compile and execute Java code dynamically.\"\"\"\n",
+    "    write_output(code, \"Optimized.java\")\n",
+    "    try:\n",
+    "        # Compile the Java code\n",
+    "        compile_cmd = [\"javac\", \"Optimized.java\"]\n",
+    "        subprocess.run(compile_cmd, check=True, text=True, capture_output=True)\n",
+    "        \n",
+    "        # Run the compiled Java program\n",
+    "        run_cmd = [\"java\", \"Optimized\"]\n",
+    "        run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)\n",
+    "        return run_result.stdout  # Return the output\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        return f\"Error during compilation or execution:\\n{e.stderr}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "9a2274f1-d03b-42c0-8dcc-4ce159b18442",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# css = \"\"\"\n",
+    "# .python {background-color: #306998;}\n",
+    "# .cpp {background-color: #050;}\n",
+    "# \"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "f1303932-160c-424b-97a8-d28c816721b2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7864/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "css = \"\"\"\n",
+    ".python {background-color: #306998;}\n",
+    ".cpp {background-color: #050;}\n",
+    ".java {background-color: #b07219;}\n",
+    "\"\"\"\n",
+    "\n",
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++, Java, or Run Directly\")\n",
+    "    \n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=\"print('Hello from Python!')\", lines=10)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "        java = gr.Textbox(label=\"Java code:\", lines=10)\n",
+    "    \n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\"], label=\"Select model\", value=\"GPT\")\n",
+    "    \n",
+    "    with gr.Row():\n",
+    "        convert_cpp = gr.Button(\"Convert to C++\")\n",
+    "        convert_java = gr.Button(\"Convert to Java\")\n",
+    "    \n",
+    "    with gr.Row():\n",
+    "        python_run = gr.Button(\"Run Python\")\n",
+    "        cpp_run = gr.Button(\"Run C++\")\n",
+    "        java_run = gr.Button(\"Run Java\")\n",
+    "    \n",
+    "    with gr.Row():\n",
+    "        python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "        cpp_out = gr.TextArea(label=\"C++ result:\", elem_classes=[\"cpp\"])\n",
+    "        java_out = gr.TextArea(label=\"Java result:\", elem_classes=[\"java\"])\n",
+    "\n",
+    "    # Add C++ and Java conversion\n",
+    "    convert_cpp.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "    convert_java.click(optimize, inputs=[python, model], outputs=[java])\n",
+    "    \n",
+    "    # Add execution buttons for each language\n",
+    "    python_run.click(execute_python, inputs=[python], outputs=[python_out])\n",
+    "    cpp_run.click(execute_cpp, inputs=[cpp], outputs=[cpp_out])\n",
+    "    java_run.click(execute_java, inputs=[java], outputs=[java_out])\n",
+    "\n",
+    "ui.launch(inbrowser=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1e910bc5-b343-48e8-9da5-2ce8e2ab888e",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

community-contributions/Code_Converter(Added_Java_Support)(Open_Ai_Only).ipynb

@@ -0,0 +1,824 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4a6ab9a2-28a2-445d-8512-a0dc8d1b54e9",
+   "metadata": {},
+   "source": [
+    "# Code Generator\n",
+    "\n",
+    "The requirement: use a Frontier model to generate high performance C++ code from Python code\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e610bf56-a46e-4aff-8de1-ab49d62b1ad3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import io\n",
+    "import sys\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import google.generativeai\n",
+    "import anthropic\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "import gradio as gr\n",
+    "import subprocess"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4f672e1c-87e9-4865-b760-370fa605e614",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv()\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "8aa149ed-9298-4d69-8fe2-8f5de0f667da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize\n",
+    "# NOTE - option to use ultra-low cost models by uncommenting last 2 lines\n",
+    "\n",
+    "openai = OpenAI()\n",
+    "# claude = anthropic.Anthropic()\n",
+    "OPENAI_MODEL = \"gpt-4o\"\n",
+    "# CLAUDE_MODEL = \"claude-3-5-sonnet-20240620\"\n",
+    "\n",
+    "# Want to keep costs ultra-low? Uncomment these lines:\n",
+    "# OPENAI_MODEL = \"gpt-4o-mini\"\n",
+    "# CLAUDE_MODEL = \"claude-3-haiku-20240307\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "6896636f-923e-4a2c-9d6c-fac07828a201",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# system_message = \"You are an assistant that reimplements Python code in high-performance C++ and Java for an M1 Mac. \"\n",
+    "# system_message += \"Respond only with C++ and Java code; use comments sparingly and do not provide any explanation other than occasional comments. \"\n",
+    "#  system_message += \"The C++ and Java responses need to produce identical output in the fastest possible time.\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "8e7b3546-57aa-4c29-bc5d-f211970d04eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# def user_prompt_for(python):\n",
+    "#     user_prompt = \"Rewrite this Python code in C++ and Java with the fastest possible implementation that produces identical output in the least time. \"\n",
+    "#     user_prompt += \"Respond only with C++ and Java code; do not explain your work other than a few comments. \"\n",
+    "#     user_prompt += \"Pay attention to number types to ensure no int overflows. Remember to #include all necessary C++ packages such as iomanip for C++, and import required packages for Java.\\n\\n\"\n",
+    "#     user_prompt += python\n",
+    "#     return user_prompt\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "c6190659-f54c-4951-bef4-4960f8e51cc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# def messages_for(python):\n",
+    "#     return [\n",
+    "#         {\"role\": \"system\", \"content\": system_message},  # Includes the updated system message with C++ and Java\n",
+    "#         {\"role\": \"user\", \"content\": user_prompt_for(python)}  # Calls the updated user prompt function for C++ and Java\n",
+    "#     ]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "71e1ba8c-5b05-4726-a9f3-8d8c6257350b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def write_output(code, file_name):\n",
+    "    \"\"\"Write the generated code to a file.\"\"\"\n",
+    "    with open(file_name, \"w\") as f:\n",
+    "        f.write(code)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "e7d2fea8-74c6-4421-8f1e-0e76d5b201b9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def system_message_for(language):\n",
+    "    \"\"\"Create a system message tailored for the requested language.\"\"\"\n",
+    "    return (\n",
+    "        f\"You are an assistant that reimplements Python code in high-performance {language.upper()} for an M1 Mac. \"\n",
+    "        f\"Respond only with {language.upper()} code; do not explain your work other than occasional comments. \"\n",
+    "        \"Pay attention to number types to ensure no overflows and include all necessary packages.\\n\\n\"\n",
+    "    )\n",
+    "\n",
+    "def user_prompt_for(python):\n",
+    "    \"\"\"Generate the user prompt.\"\"\"\n",
+    "    return (\n",
+    "        \"Rewrite this Python code in the requested language with the fastest possible implementation that produces \"\n",
+    "        \"identical output in the least time. Use appropriate syntax for the language.\\n\\n\" + python\n",
+    "    )\n",
+    "\n",
+    "def messages_for(python, language):\n",
+    "    \"\"\"Generate the messages for GPT.\"\"\"\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_message_for(language)},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for(python)},\n",
+    "    ]\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "3ec5a816-7bf4-4daa-b0c9-f04edb1c0140",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_gpt(python, language=\"cpp\"):\n",
+    "    \"\"\"Optimize the given Python code and generate C++ or Java output.\"\"\"\n",
+    "    code = \"\"\n",
+    "    for chunk in stream_gpt(python, language):\n",
+    "        print(chunk, end=\"\")  # Stream the output\n",
+    "        code = chunk  # Store the final code\n",
+    "    \n",
+    "    file_name = f\"optimized.{language}\"\n",
+    "    write_output(code, file_name)\n",
+    "    print(f\"\\nCode written to {file_name}.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8adf0436-cf0e-429c-bd35-c3d551631b27",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7cd84ad8-d55c-4fe0-9eeb-1895c95c4a9d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# def optimize_claude(python):\n",
+    "#     result = claude.messages.stream(\n",
+    "#         model=CLAUDE_MODEL,\n",
+    "#         max_tokens=2000,\n",
+    "#         system=system_message,\n",
+    "#         messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "#     )\n",
+    "#     reply = \"\"\n",
+    "#     with result as stream:\n",
+    "#         for text in stream.text_stream:\n",
+    "#             reply += text\n",
+    "#             print(text, end=\"\", flush=True)\n",
+    "#     write_output(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "a1cbb778-fa57-43de-b04b-ed523f396c38",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pi = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def calculate(iterations, param1, param2):\n",
+    "    result = 1.0\n",
+    "    for i in range(1, iterations+1):\n",
+    "        j = i * param1 - param2\n",
+    "        result -= (1/j)\n",
+    "        j = i * param1 + param2\n",
+    "        result += (1/j)\n",
+    "    return result\n",
+    "\n",
+    "start_time = time.time()\n",
+    "result = calculate(100_000_000, 4, 1) * 4\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(f\"Result: {result:.12f}\")\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "7fe1cd4b-d2c5-4303-afed-2115a3fef200",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Result: 3.141592658589\n",
+      "Execution Time: 46.954224 seconds\n"
+     ]
+    }
+   ],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "57ea7f4b-a862-4805-a074-2019314cbd4a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(python_code, language=\"java\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "105db6f9-343c-491d-8e44-3a5328b81719",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(python_code, language=\"cpp\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf26ee95-0c77-491d-9a91-579a1e96a8a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf8f8018-f64d-425c-a0e1-d7862aa9592d",
+   "metadata": {},
+   "source": [
+    "# Compiling C++ and executing\n",
+    "\n",
+    "You can use any platform now (Windows,Mac,Linux) i have added compatiblity in this"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4194e40c-04ab-4940-9d64-b4ad37c5bb40",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import subprocess\n",
+    "import platform\n",
+    "\n",
+    "def compile_and_run(language=\"cpp\"):\n",
+    "    \"\"\"Compile and run the generated code.\"\"\"\n",
+    "    is_windows = platform.system() == \"Windows\"\n",
+    "    \n",
+    "    if language == \"cpp\":\n",
+    "        if is_windows:\n",
+    "            # Windows: Use g++ (requires MinGW or equivalent installed)\n",
+    "            compile_command = [\"g++\", \"-O3\", \"-std=c++17\", \"-o\", \"optimized.exe\", \"optimized.cpp\"]\n",
+    "            execute_command = [\"optimized.exe\"]\n",
+    "        else:\n",
+    "            # Non-Windows: Use clang++\n",
+    "            compile_command = [\n",
+    "                \"clang++\", \"-O3\", \"-std=c++17\", \"-march=armv8.3-a\", \"-o\", \"optimized\", \"optimized.cpp\"\n",
+    "            ]\n",
+    "            execute_command = [\"./optimized\"]\n",
+    "    elif language == \"java\":\n",
+    "        # Both Windows and non-Windows use the same Java commands\n",
+    "        compile_command = [\"javac\", \"optimized.java\"]\n",
+    "        execute_command = [\"java\", \"optimized\"]\n",
+    "    else:\n",
+    "        raise ValueError(\"Unsupported language. Choose 'cpp' or 'java'.\")\n",
+    "\n",
+    "    # Compile\n",
+    "    try:\n",
+    "        subprocess.run(compile_command, check=True, shell=is_windows)\n",
+    "        print(f\"{language.upper()} compilation successful.\")\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        print(f\"{language.upper()} compilation failed:\\n{e}\")\n",
+    "        return\n",
+    "\n",
+    "    # Run\n",
+    "    try:\n",
+    "        output = subprocess.run(\n",
+    "            execute_command, capture_output=True, text=True, shell=is_windows\n",
+    "        )\n",
+    "        print(f\"{language.upper()} execution output:\\n{output.stdout}\")\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        print(f\"{language.upper()} execution failed:\\n{e.stderr}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "240ae457-ec5a-4268-9e7d-e782c2113f02",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "compile_and_run(language=\"cpp\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "983a11fe-e24d-4c65-8269-9802c5ef3ae6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# optimize_claude(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5a766f9-3d23-4bb4-a1d4-88ec44b61ddf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Repeat for Claude - again, use the right approach for your platform\n",
+    "\n",
+    "# !clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "# !./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "c3b497b3-f569-420e-b92e-fb0f49957ce0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python_hard = \"\"\"# Be careful to support large number sizes\n",
+    "\n",
+    "def lcg(seed, a=1664525, c=1013904223, m=2**32):\n",
+    "    value = seed\n",
+    "    while True:\n",
+    "        value = (a * value + c) % m\n",
+    "        yield value\n",
+    "        \n",
+    "def max_subarray_sum(n, seed, min_val, max_val):\n",
+    "    lcg_gen = lcg(seed)\n",
+    "    random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val for _ in range(n)]\n",
+    "    max_sum = float('-inf')\n",
+    "    for i in range(n):\n",
+    "        current_sum = 0\n",
+    "        for j in range(i, n):\n",
+    "            current_sum += random_numbers[j]\n",
+    "            if current_sum > max_sum:\n",
+    "                max_sum = current_sum\n",
+    "    return max_sum\n",
+    "\n",
+    "def total_max_subarray_sum(n, initial_seed, min_val, max_val):\n",
+    "    total_sum = 0\n",
+    "    lcg_gen = lcg(initial_seed)\n",
+    "    for _ in range(20):\n",
+    "        seed = next(lcg_gen)\n",
+    "        total_sum += max_subarray_sum(n, seed, min_val, max_val)\n",
+    "    return total_sum\n",
+    "\n",
+    "# Parameters\n",
+    "n = 10000         # Number of random numbers\n",
+    "initial_seed = 42 # Initial seed for the LCG\n",
+    "min_val = -10     # Minimum value of random numbers\n",
+    "max_val = 10      # Maximum value of random numbers\n",
+    "\n",
+    "# Timing the function\n",
+    "import time\n",
+    "start_time = time.time()\n",
+    "result = total_max_subarray_sum(n, initial_seed, min_val, max_val)\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(\"Total Maximum Subarray Sum (20 runs):\", result)\n",
+    "print(\"Execution Time: {:.6f} seconds\".format(end_time - start_time))\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dab5e4bc-276c-4555-bd4c-12c699d5e899",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8d24ed5-2c15-4f55-80e7-13a3952b3cb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# optimize_gpt(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e0b3d073-88a2-40b2-831c-6f0c345c256f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # Replace this with the right C++ compile + execute command for your platform\n",
+    "\n",
+    "# !clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "# !./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9305446-1d0c-4b51-866a-b8c1e299bf5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# optimize_claude(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c181036-8193-4fdd-aef3-fc513b218d43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Replace this with the right C++ compile + execute command for your platform\n",
+    "\n",
+    "# !clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "# !./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "0be9f47d-5213-4700-b0e2-d444c7c738c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_gpt(python, language=\"cpp\"):\n",
+    "    \"\"\"Stream the GPT output for the requested language.\"\"\"\n",
+    "    if language not in [\"cpp\", \"java\"]:\n",
+    "        raise ValueError(\"Invalid language specified. Choose 'cpp' or 'java'.\")\n",
+    "    \n",
+    "    # Stream response\n",
+    "    stream = openai.ChatCompletion.create(\n",
+    "        model=OPENAI_MODEL, messages=messages_for(python, language), stream=True\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    code_block = f\"```{language}\\n\"  # Detect code block for the language\n",
+    "\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        \n",
+    "        # Clean the streamed reply\n",
+    "        cleaned_reply = reply.replace(code_block, \"\").replace(\"```\", \"\")\n",
+    "        yield cleaned_reply\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "8669f56b-8314-4582-a167-78842caea131",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# def stream_claude(python):\n",
+    "#     result = claude.messages.stream(\n",
+    "#         model=CLAUDE_MODEL,\n",
+    "#         max_tokens=2000,\n",
+    "#         system=system_message,\n",
+    "#         messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "#     )\n",
+    "#     reply = \"\"\n",
+    "#     with result as stream:\n",
+    "#         for text in stream.text_stream:\n",
+    "#             reply += text\n",
+    "#             yield reply.replace('```cpp\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "2f1ae8f5-16c8-40a0-aa18-63b617df078d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(python, model=\"GPT\", language=\"cpp\"):\n",
+    "    \"\"\"\n",
+    "    Optimize the given Python code using the specified model (GPT or Claude) and generate the output\n",
+    "    in the requested programming language.\n",
+    "\n",
+    "    Args:\n",
+    "        python (str): The Python code to optimize.\n",
+    "        model (str): The model to use (\"GPT\" or \"Claude\").\n",
+    "        language (str): The target programming language (\"cpp\" or \"java\").\n",
+    "\n",
+    "    Yields:\n",
+    "        str: The streamed output of the generated code.\n",
+    "    \"\"\"\n",
+    "    if model == \"GPT\":\n",
+    "        result = stream_gpt(python, language=language)\n",
+    "  \n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model. Please choose 'GPT' or 'Claude'.\")\n",
+    "\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f1ddb38e-6b0a-4c37-baa4-ace0b7de887a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import gradio as gr\n",
+    "\n",
+    "# # Assuming `optimize` is already defined and imported\n",
+    "# # python_hard should be a pre-defined Python code snippet for the default value\n",
+    "\n",
+    "# with gr.Blocks() as ui:\n",
+    "#     with gr.Row():\n",
+    "#         python = gr.Textbox(label=\"Python code:\", lines=10, value=\"\")  # Default value can be set here\n",
+    "#         cpp = gr.Textbox(label=\"Converted code:\", lines=10, interactive=False)  # Output box\n",
+    "\n",
+    "#     with gr.Row():\n",
+    "#         model = gr.Dropdown([\"GPT\", \"Claude\"], label=\"Select model\", value=\"GPT\")  # Default is GPT\n",
+    "#         language = gr.Dropdown([\"cpp\", \"java\"], label=\"Target language\", value=\"cpp\")  # Default is C++\n",
+    "#         convert = gr.Button(\"Convert code\")\n",
+    "\n",
+    "#     # Connect the button to the optimize function\n",
+    "#     def convert_code(python, model, language):\n",
+    "#         result = \"\"\n",
+    "#         for output in optimize(python, model=model, language=language):\n",
+    "#             result = output  # Collect the last streamed result\n",
+    "#         return result\n",
+    "\n",
+    "#     convert.click(\n",
+    "#         fn=convert_code,\n",
+    "#         inputs=[python, model, language],  # Inputs from UI\n",
+    "#         outputs=[cpp],  # Output to the C++/Java box\n",
+    "#     )\n",
+    "\n",
+    "# ui.launch(inbrowser=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "19bf2bff-a822-4009-a539-f003b1651383",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import io\n",
+    "import sys\n",
+    "\n",
+    "def execute_python(code):\n",
+    "    \"\"\"\n",
+    "    Execute Python code dynamically and capture its output.\n",
+    "\n",
+    "    Args:\n",
+    "        code (str): The Python code to execute.\n",
+    "\n",
+    "    Returns:\n",
+    "        str: The captured standard output of the executed code.\n",
+    "\n",
+    "    Raises:\n",
+    "        Exception: If the execution of the code raises an error.\n",
+    "    \"\"\"\n",
+    "    output = io.StringIO()\n",
+    "    try:\n",
+    "        sys.stdout = output  # Redirect standard output to the StringIO object\n",
+    "        exec(code, {})  # Execute code with an empty global context for safety\n",
+    "    except Exception as e:\n",
+    "        return f\"Error during execution: {str(e)}\"\n",
+    "    finally:\n",
+    "        sys.stdout = sys.__stdout__  # Restore standard output\n",
+    "\n",
+    "    return output.getvalue()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "77f3ab5d-fcfb-4d3f-8728-9cacbf833ea6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# You'll need to change the code in the try block to compile the C++ code for your platform\n",
+    "# I pasted this into Claude's chat UI with a request for it to give me a version for an Intel PC,\n",
+    "# and it responded with something that looks perfect - you can try a similar approach for your platform.\n",
+    "\n",
+    "# M1 Mac version to compile and execute optimized C++ code:\n",
+    "\n",
+    "def execute_cpp(code):\n",
+    "        write_output(code)\n",
+    "        try:\n",
+    "            compile_cmd = [\"clang++\", \"-Ofast\", \"-std=c++17\", \"-march=armv8.5-a\", \"-mtune=apple-m1\", \"-mcpu=apple-m1\", \"-o\", \"optimized\", \"optimized.cpp\"]\n",
+    "            compile_result = subprocess.run(compile_cmd, check=True, text=True, capture_output=True)\n",
+    "            run_cmd = [\"./optimized\"]\n",
+    "            run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)\n",
+    "            return run_result.stdout\n",
+    "        except subprocess.CalledProcessError as e:\n",
+    "            return f\"An error occurred:\\n{e.stderr}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "9645b5c4-41a1-4a88-a5e6-cf618864af04",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "def execute_java(code):\n",
+    "    \"\"\"Compile and execute Java code dynamically.\"\"\"\n",
+    "    write_output(code, \"Optimized.java\")\n",
+    "    try:\n",
+    "        # Compile the Java code\n",
+    "        compile_cmd = [\"javac\", \"Optimized.java\"]\n",
+    "        subprocess.run(compile_cmd, check=True, text=True, capture_output=True)\n",
+    "        \n",
+    "        # Run the compiled Java program\n",
+    "        run_cmd = [\"java\", \"Optimized\"]\n",
+    "        run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)\n",
+    "        return run_result.stdout  # Return the output\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        return f\"Error during compilation or execution:\\n{e.stderr}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "9a2274f1-d03b-42c0-8dcc-4ce159b18442",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# css = \"\"\"\n",
+    "# .python {background-color: #306998;}\n",
+    "# .cpp {background-color: #050;}\n",
+    "# \"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "f1303932-160c-424b-97a8-d28c816721b2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7864/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "css = \"\"\"\n",
+    ".python {background-color: #306998;}\n",
+    ".cpp {background-color: #050;}\n",
+    ".java {background-color: #b07219;}\n",
+    "\"\"\"\n",
+    "\n",
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++, Java, or Run Directly\")\n",
+    "    \n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=\"print('Hello from Python!')\", lines=10)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "        java = gr.Textbox(label=\"Java code:\", lines=10)\n",
+    "    \n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\"], label=\"Select model\", value=\"GPT\")\n",
+    "    \n",
+    "    with gr.Row():\n",
+    "        convert_cpp = gr.Button(\"Convert to C++\")\n",
+    "        convert_java = gr.Button(\"Convert to Java\")\n",
+    "    \n",
+    "    with gr.Row():\n",
+    "        python_run = gr.Button(\"Run Python\")\n",
+    "        cpp_run = gr.Button(\"Run C++\")\n",
+    "        java_run = gr.Button(\"Run Java\")\n",
+    "    \n",
+    "    with gr.Row():\n",
+    "        python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "        cpp_out = gr.TextArea(label=\"C++ result:\", elem_classes=[\"cpp\"])\n",
+    "        java_out = gr.TextArea(label=\"Java result:\", elem_classes=[\"java\"])\n",
+    "\n",
+    "    # Add C++ and Java conversion\n",
+    "    convert_cpp.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "    convert_java.click(optimize, inputs=[python, model], outputs=[java])\n",
+    "    \n",
+    "    # Add execution buttons for each language\n",
+    "    python_run.click(execute_python, inputs=[python], outputs=[python_out])\n",
+    "    cpp_run.click(execute_cpp, inputs=[cpp], outputs=[cpp_out])\n",
+    "    java_run.click(execute_java, inputs=[java], outputs=[java_out])\n",
+    "\n",
+    "ui.launch(inbrowser=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1e910bc5-b343-48e8-9da5-2ce8e2ab888e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Entering context\n",
+      "Using Resource\n",
+      "Exiting context\n"
+     ]
+    }
+   ],
+   "source": [
+    "class MyContext:\n",
+    "    def __enter__(self):\n",
+    "        print(\"Entering context\")\n",
+    "        return \"Resource\"\n",
+    "    \n",
+    "    def __exit__(self, exc_type, exc_val, exc_tb):\n",
+    "        print(\"Exiting context\")\n",
+    "\n",
+    "with MyContext() as x:\n",
+    "    print(\"Using\", x)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "997f1aaa-53bf-4958-b99b-07389e7ccbbe",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

community-contributions/Day 3 using gemini.ipynb

@@ -0,0 +1,493 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3d3cb3c4-9046-4f64-9188-ee20ae324fd1",
+   "metadata": {},
+   "source": [
+    "# Code Generator\n",
+    "\n",
+    "The requirement: use a Frontier model to generate high performance C++ code from Python code\n",
+    "\n",
+    "# Important Note\n",
+    "Used an open-source model gemini-1.5-pro ,can try 2.0 flash too\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6f2c3e03-f38a-4bf2-98e8-696fb3d428c9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import io\n",
+    "import sys\n",
+    "from dotenv import load_dotenv\n",
+    "import google.generativeai\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "import gradio as gr\n",
+    "import subprocess"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e437f3d1-39c4-47fd-919f-c2119d602d72",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv()\n",
+    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
+    "if google_api_key:\n",
+    "    print(f\"Google API Key exists\")\n",
+    "else:\n",
+    "    print(\"Google API Key not set\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1724ddb6-0059-46a3-bcf9-587c0c93cb2a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "google.generativeai.configure()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b62738c1-9857-40fc-91e8-dfd46483ea50",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_message = \"You are an assistant that reimplements Python code in high performance C++ for an Windows system. \"\n",
+    "system_message += \"Respond only with C++ code; use comments sparingly and do not provide any explanation other than occasional comments. \"\n",
+    "system_message += \"The C++ response needs to produce an identical output in the fastest possible time.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bd431141-8602-4c68-9a1d-a7c0a6f13fa3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def user_prompt_for(python):\n",
+    "    user_prompt = \"Rewrite this Python code in C++ with the fastest possible implementation that produces identical output in the least time. \"\n",
+    "    user_prompt += \"Respond only with C++ code; do not explain your work other than a few comments. \"\n",
+    "    user_prompt += \"Pay attention to number types to ensure no int overflows. Remember to #include all necessary C++ packages such as iomanip.\\n\\n\"\n",
+    "    user_prompt += python\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5f48451-4cd4-46ea-a41d-531a3c7db2a8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def messages_for(python):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_message},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for(python)}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "83fd2170-14ea-4fb6-906e-c3c5cfce1ecc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# write to a file called optimized.cpp\n",
+    "\n",
+    "def write_output(cpp):\n",
+    "    code = cpp.replace(\"```cpp\",\"\").replace(\"```\",\"\")\n",
+    "    with open(\"optimized.cpp\", \"w\") as f:\n",
+    "        f.write(code)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1ff08067-c9df-4981-8ab5-99eb2c2fd2c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_google(python):\n",
+    "    # Initialize empty reply string\n",
+    "    reply = \"\"\n",
+    "    \n",
+    "    # The API for Gemini has a slightly different structure\n",
+    "    gemini = google.generativeai.GenerativeModel(\n",
+    "        model_name='gemini-1.5-pro',\n",
+    "        system_instruction=system_message\n",
+    "    )\n",
+    "    \n",
+    "    response = gemini.generate_content(\n",
+    "        user_prompt_for(python),\n",
+    "        stream=True\n",
+    "    )\n",
+    "    \n",
+    "    # Process the stream\n",
+    "    for chunk in response:\n",
+    "        # Extract text from the chunk\n",
+    "        if chunk.text:\n",
+    "            reply += chunk.text\n",
+    "            print(chunk.text, end=\"\", flush=True)\n",
+    "    \n",
+    "    # Write the complete response to output\n",
+    "    write_output(reply)\n",
+    "    \n",
+    "    # return reply"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e8c7ba2-4ee9-4523-b0f1-cc7a91798bba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pi = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def calculate(iterations, param1, param2):\n",
+    "    result = 1.0\n",
+    "    for i in range(1, iterations+1):\n",
+    "        j = i * param1 - param2\n",
+    "        result -= (1/j)\n",
+    "        j = i * param1 + param2\n",
+    "        result += (1/j)\n",
+    "    return result\n",
+    "\n",
+    "start_time = time.time()\n",
+    "result = calculate(100_000_000, 4, 1) * 4\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(f\"Result: {result:.12f}\")\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "78d1afb7-ed6b-4a03-b36d-4ce8249c592e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1fe1d0b6-7cc7-423b-bc4b-741a0c48c106",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_google(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d28b4ac9-0909-4b35-aee1-97613a133e8e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi) #Execution Time: 16.209231 seconds"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d0443a3-3ca2-4a7a-a6c3-c94d0aa54603",
+   "metadata": {},
+   "source": [
+    "# Compiling C++ and executing\n",
+    "\n",
+    "This next cell contains the command to compile a C++ file on Windows system.  \n",
+    "It compiles the file `optimized.cpp` into an executable called `optimized`  \n",
+    "Then it runs the program called `optimized`\n",
+    "\n",
+    "The way to compile for mac users is \\\n",
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp \\\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9b5cfc70-df1f-44a7-b4ae-fd934f715930",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!g++ -o optimized optimized.cpp\n",
+    "!.\\optimized #Execution Time: 3.661196 seconds"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e30fcbdf-82cf-4d50-9690-92dae69d5127",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python_hard = \"\"\"\n",
+    "def lcg(seed, a=1664525, c=1013904223, m=2**32):\n",
+    "    value = seed\n",
+    "    while True:\n",
+    "        value = (a * value + c) % m\n",
+    "        yield value\n",
+    "        \n",
+    "def max_subarray_sum(n, seed, min_val, max_val):\n",
+    "    lcg_gen = lcg(seed)\n",
+    "    random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val for _ in range(n)]\n",
+    "    max_sum = float('-inf')\n",
+    "    for i in range(n):\n",
+    "        current_sum = 0\n",
+    "        for j in range(i, n):\n",
+    "            current_sum += random_numbers[j]\n",
+    "            if current_sum > max_sum:\n",
+    "                max_sum = current_sum\n",
+    "    return max_sum\n",
+    "\n",
+    "def total_max_subarray_sum(n, initial_seed, min_val, max_val):\n",
+    "    total_sum = 0\n",
+    "    lcg_gen = lcg(initial_seed)\n",
+    "    for _ in range(20):\n",
+    "        seed = next(lcg_gen)\n",
+    "        total_sum += max_subarray_sum(n, seed, min_val, max_val)\n",
+    "    return total_sum\n",
+    "\n",
+    "# Parameters\n",
+    "n = 10000         # Number of random numbers\n",
+    "initial_seed = 42 # Initial seed for the LCG\n",
+    "min_val = -10     # Minimum value of random numbers\n",
+    "max_val = 10      # Maximum value of random numbers\n",
+    "\n",
+    "# Timing the function\n",
+    "import time\n",
+    "start_time = time.time()\n",
+    "result = total_max_subarray_sum(n, initial_seed, min_val, max_val)\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(\"Total Maximum Subarray Sum (20 runs):\", result)\n",
+    "print(\"Execution Time: {:.6f} seconds\".format(end_time - start_time))\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2e8e111c-6f69-4ed0-8f86-8ed5982aa065",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(python_hard) #Execution Time: 62.297366 seconds"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "38038ac1-5cdf-49d7-a286-a5871d5af583",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_google(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08cb9619-b8ae-42e7-9375-4b3918c37fd0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!g++ -o optimized optimized.cpp\n",
+    "!.\\optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "acd17a0d-f9f1-45a6-8151-916d8e6b9e4f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_google(python):\n",
+    "    # Initialize empty reply string\n",
+    "    reply = \"\"\n",
+    "    \n",
+    "    # The API for Gemini has a slightly different structure\n",
+    "    gemini = google.generativeai.GenerativeModel(\n",
+    "        model_name='gemini-1.5-pro',\n",
+    "        system_instruction=system_message\n",
+    "    )\n",
+    "    \n",
+    "    response = gemini.generate_content(\n",
+    "        user_prompt_for(python),\n",
+    "        stream=True\n",
+    "    )\n",
+    "    \n",
+    "    # Process the stream\n",
+    "    for chunk in response:\n",
+    "        # Extract text from the chunk\n",
+    "        if chunk.text:\n",
+    "            reply += chunk.text\n",
+    "            yield reply.replace('```cpp\\n','').replace('```','')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c3177229-d6cf-4df2-81a7-9e1f3b229c19",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(python, model):\n",
+    "    result=stream_google(python)\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c2476c2d-9218-4d30-bcc9-9cc5271c3a00",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with gr.Blocks() as ui:\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", lines=10, value=pi)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"Google\"], label=\"Select model\", value=\"Google\")\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a30de175-af4e-428a-8942-1c41997c01f1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_python(code):\n",
+    "        try:\n",
+    "            output = io.StringIO()\n",
+    "            sys.stdout = output\n",
+    "            exec(code)\n",
+    "        finally:\n",
+    "            sys.stdout = sys.__stdout__\n",
+    "        return output.getvalue()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20c6316d-b090-42c5-9be9-7d5a178b97b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_cpp(code):\n",
+    "        write_output(code)\n",
+    "        try:\n",
+    "            # compile_cmd = [\"clang++\", \"-Ofast\", \"-std=c++17\", \"-march=armv8.5-a\", \"-mtune=apple-m1\", \"-mcpu=apple-m1\", \"-o\", \"optimized\", \"optimized.cpp\"]\n",
+    "            compile_cmd = [\"g++\", \"-o\", \"optimized\", \"optimized.cpp\"]\n",
+    "            compile_result = subprocess.run(compile_cmd, check=True, text=True, capture_output=True)\n",
+    "            run_cmd = [\"./optimized\"]\n",
+    "            run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)\n",
+    "            return run_result.stdout\n",
+    "        except subprocess.CalledProcessError as e:\n",
+    "            return f\"An error occurred:\\n{e.stderr}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "950a459f-3ef6-4afd-9e83-f01c032aa21b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "css = \"\"\"\n",
+    ".python {background-color: #306998;}\n",
+    ".cpp {background-color: #050;}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bc3d90ba-716c-4b8f-989f-46c2447c42fa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++\")\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=pi, lines=10)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"Google\"], label=\"Select model\", value=\"Google\")\n",
+    "    with gr.Row():\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "    with gr.Row():\n",
+    "        python_run = gr.Button(\"Run Python\")\n",
+    "        cpp_run = gr.Button(\"Run C++\")\n",
+    "    with gr.Row():\n",
+    "        python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "        cpp_out = gr.TextArea(label=\"C++ result:\", elem_classes=[\"cpp\"])\n",
+    "\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "    python_run.click(execute_python, inputs=[python], outputs=[python_out])\n",
+    "    cpp_run.click(execute_cpp, inputs=[cpp], outputs=[cpp_out])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c12f6115-e8a9-494e-95ce-2566854c0aa2",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

community-contributions/code_documentation_generator.ipynb

@@ -0,0 +1,433 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "05432987-80bc-4aa5-8c05-277861e19307",
+   "metadata": {},
+   "source": [
+    "## Adds docstrings/comments to code and generates code summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e706f175-1e83-4d2c-8613-056b2e532624",
+   "metadata": {},
+   "source": [
+    "### Model Usage  \n",
+    "\n",
+    "- **Open Source Models:**\n",
+    "\n",
+    "  - Deployed via Endpoint: Hosted on a server and accessed remotely (Qwen 1.5-7)\n",
+    "  - Run Locally on Machine: Executed directly on a local device (Ollama running Llama 3.2-1B)\n",
+    "\n",
+    "- **Closed Source Models:**  \n",
+    "  - Accessed through API key authentication: (OpenAI, Anthropic).  \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9ed667df-6660-4ba3-80c5-4c1c8f7e63f3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import io\n",
+    "import sys \n",
+    "import json\n",
+    "import requests\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import google.generativeai\n",
+    "import anthropic\n",
+    "import ollama\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "import gradio as gr\n",
+    "from huggingface_hub import login, InferenceClient\n",
+    "from transformers import AutoTokenizer, pipeline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c9dd4bf1-48cf-44dc-9d04-0ec6e8189a3c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv()\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY')\n",
+    "CODE_QWEN_URL = os.environ['CODE_QWEN_URL'] \n",
+    "BIGBIRD_PEGASUS_URL = os.environ['BIGBIRD_PEGASUS_URL']\n",
+    "HF_TOKEN = os.environ['HF_TOKEN']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71f671d6-50a7-43cf-9e04-52a159d67dab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!ollama pull llama3.2:1b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e6f8f35-477d-4014-8fe9-874b5aee0061",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "openai = OpenAI()\n",
+    "claude = anthropic.Anthropic()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ae34b79c-425a-4f04-821a-8f1d9868b146",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "OPENAI_MODEL = \"gpt-4o-mini\"\n",
+    "CLAUDE_MODEL = \"claude-3-haiku-20240307\"\n",
+    "LLAMA_MODEL = \"llama3.2:1b\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "80e6d920-3c94-48c4-afd8-518f415ab777",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "code_qwen = \"Qwen/CodeQwen1.5-7B-Chat\"\n",
+    "bigbird_pegasus = \"google/bigbird-pegasus-large-arxiv\"\n",
+    "login(HF_TOKEN, add_to_git_credential=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "314cd8e3-2c10-4149-9818-4e6b0c05b871",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Uses Llama to Check Which Language the Code is Written In\n",
+    "system_message_comments = \"You are an assistant designed to add docstrings and helpful comments to code for documentation purposes.\"\n",
+    "system_message_comments += \"Respond back with properly formatted code, including docstrings and comments. Keep comments concise. \"\n",
+    "system_message_comments += \"Do not respond with greetings, or any such extra output\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "66fa09e4-1b79-4f53-9bb7-904d515b2f26",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_message_summary = \"You are an assistant designed to summarise code for documentation purposes. You are not to display code again.\"\n",
+    "system_message_summary += \"Respond back with a properly crafted summary, mentioning key details regarding to the code, such as workflow, code language.\"\n",
+    "system_message_summary += \"Do not respond with greetings, or any such extra output. Do not respond in Markdown. Be thorough, keep explanation level at undergraduate level.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ea405820-f9d1-4cf1-b465-9ae5cd9016f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def user_prompt_for(code):\n",
+    "    user_prompt = \"Rewrite this code to include helpful comments and docstrings. \"\n",
+    "    user_prompt += \"Respond only with code.\\n\"\n",
+    "    user_prompt += code\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "26c9be56-1d4f-43e5-9bc4-eb5b76da8071",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def user_prompt_for_summary(code):\n",
+    "    user_prompt = \"Return the summary of the code.\\n\"\n",
+    "    user_prompt += code\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c0ac22cb-dc96-4ae1-b00d-2747572f6945",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def messages_for(code):\n",
+    "    messages = [\n",
+    "        {\"role\": \"system\", \"content\": system_message_comments},\n",
+    "        {\"role\":\"user\", \"content\" : user_prompt_for(code)}\n",
+    "    ]\n",
+    "    return messages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eae1a8b4-68a8-4cd5-849e-0ecabd166a0c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def messages_for_summary(code):\n",
+    "    messages = [\n",
+    "        {\"role\": \"system\", \"content\": system_message_summary},\n",
+    "        {\"role\":\"user\", \"content\" : user_prompt_for_summary(code)}\n",
+    "    ]\n",
+    "    return messages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5eb726dd-e09e-4011-8eb6-4d20f2830ff5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "func = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def calculate(iterations, param1, param2):\n",
+    "    result = 1.0\n",
+    "    for i in range(1, iterations+1):\n",
+    "        j = i * param1 - param2\n",
+    "        result -= (1/j)\n",
+    "        j = i * param1 + param2\n",
+    "        result += (1/j)\n",
+    "    return result\n",
+    "\n",
+    "start_time = time.time()\n",
+    "result = calculate(100_000_000, 4, 1) * 4\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(f\"Result: {result:.12f}\")\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f61943b2-c939-4910-a670-58abaf464bb6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def call_llama(code):\n",
+    "    # commented code\n",
+    "    messages = messages_for(code)\n",
+    "    response1 = ollama.chat(model=LLAMA_MODEL, messages=messages)\n",
+    "\n",
+    "    # summary\n",
+    "    messages = messages_for_summary(code)\n",
+    "    response2 = ollama.chat(model=LLAMA_MODEL, messages=messages)\n",
+    "    \n",
+    "    return response1['message']['content'],response2['message']['content']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "696fb97e-807e-40ed-b0e1-beb82d1108a6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def call_claude(code):\n",
+    "    # commented code\n",
+    "    message1 = claude.messages.create(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        system=system_message_comments,\n",
+    "        messages=([{\"role\": \"user\", \"content\":user_prompt_for(code)}]),\n",
+    "        max_tokens=500\n",
+    "    )\n",
+    "\n",
+    "    # summary\n",
+    "    message2 = claude.messages.create(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        system=system_message_summary,\n",
+    "        messages=([{\"role\": \"user\", \"content\":user_prompt_for_summary(code)}]),\n",
+    "        max_tokens=500\n",
+    "    )\n",
+    "    \n",
+    "    return message1.content[0].text,message2.content[0].text"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4bf1db64-86fa-42a1-98dd-3df74607f8db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def call_gpt(code):\n",
+    "    # commented code\n",
+    "    completion1 = openai.chat.completions.create(\n",
+    "        model=OPENAI_MODEL,\n",
+    "        messages=messages_for(code),\n",
+    "    )\n",
+    "\n",
+    "    #summary\n",
+    "    completion2 = openai.chat.completions.create(\n",
+    "        model=OPENAI_MODEL,\n",
+    "        messages=messages_for_summary(code),\n",
+    "    )\n",
+    "    \n",
+    "    return completion1.choices[0].message.content,completion2.choices[0].message.content"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6863dc42-cbcd-4a95-8b0a-cfbcbfed0764",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def call_codeqwen(code):\n",
+    "    # commented code\n",
+    "    tokenizer = AutoTokenizer.from_pretrained(code_qwen)\n",
+    "    messages = messages_for(code)\n",
+    "    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+    "    client = InferenceClient(CODE_QWEN_URL, token=HF_TOKEN)\n",
+    "    response1 = client.text_generation(text, details=True, max_new_tokens=1000)\n",
+    "\n",
+    "    # summary\n",
+    "    tokenizer = AutoTokenizer.from_pretrained(code_qwen)\n",
+    "    messages = messages_for_summary(code)\n",
+    "    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+    "    client = InferenceClient(CODE_QWEN_URL, token=HF_TOKEN)\n",
+    "    response2 = client.text_generation(text, details=True, max_new_tokens=1000)\n",
+    "    \n",
+    "    return response1.generated_text ,response2.generated_text "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "06d05c02-45e4-47da-b70b-cf433dfaca4c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_docs(code,model):\n",
+    "    if model == \"Llama\":\n",
+    "        comments,summary = call_llama(code)\n",
+    "    elif model == \"Claude\":\n",
+    "        comments,summary = call_claude(code)\n",
+    "    elif model == \"GPT\":\n",
+    "        comments,summary = call_gpt(code)\n",
+    "    elif model == \"CodeQwen\":\n",
+    "        comments,summary = call_codeqwen(code)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown Model\")\n",
+    "    return comments,summary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1b4ea289-5da9-4b0e-b4d4-f8f01e466839",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "css = \"\"\"\n",
+    ".comments {background-color: #00599C;}\n",
+    ".summary {background-color: #008B8B;}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "89ad7c7b-b881-45d3-aadc-d7206af578fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"### Code Documentation and Formatting\")\n",
+    "    with gr.Row():\n",
+    "        code = gr.Textbox(label=\"Input Code: \", value=func, lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\",\"Claude\",\"Llama\",\"CodeQwen\"],label=\"Select model\",value=\"GPT\")\n",
+    "    with gr.Row():\n",
+    "        docs = gr.Button(\"Add Comments and Sumarise Code\")\n",
+    "    with gr.Row():\n",
+    "        commented_code = gr.Textbox(label= \"Formatted Code\", lines=10,elem_classes=[\"comments\"])\n",
+    "        code_summary = gr.Textbox(label = \"Code Summary\", lines=10,elem_classes=[\"summary\"])\n",
+    "    docs.click(create_docs,inputs=[code,model],outputs=[commented_code,code_summary]),"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1a9e3b1c-bfe6-4b71-aac8-fa36a491c157",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ac895aa9-e044-4598-b715-d96d1c158656",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a96877c-22b7-4ad5-b235-1cf8f8b200a1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(call_llama(func))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f11de1a2-52c0-41c7-ad88-01ef5f8bc628",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

community-contributions/day4-gemini-included.ipynb

@@ -0,0 +1,908 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4a6ab9a2-28a2-445d-8512-a0dc8d1b54e9",
+   "metadata": {},
+   "source": [
+    "# Code Generator\n",
+    "\n",
+    "The requirement: use an Open Source model to generate high performance C++ code from Python code\n",
+    "\n",
+    "To replicate this, you'll need to set up a HuggingFace endpoint as I do in the video. It's simple to do, and it's quite satisfying to see the results!\n",
+    "\n",
+    "It's also an important part of your learning; this is the first example of deploying an open source model to be behind an API. We'll return to this in Week 8, but this should plant a seed in your mind for what's involved in moving open source models into production."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22e1567b-33fd-49e7-866e-4b635d15715a",
+   "metadata": {},
+   "source": [
+    "<table style=\"margin: 0; text-align: left;\">\n",
+    "    <tr>\n",
+    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
+    "            <img src=\"../../important.jpg\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
+    "        </td>\n",
+    "        <td>\n",
+    "            <h1 style=\"color:#900;\">Important - Pause Endpoints when not in use</h1>\n",
+    "            <span style=\"color:#900;\">\n",
+    "            If you do decide to use HuggingFace endpoints for this project, you should stop or pause the endpoints when you are done to avoid accruing unnecessary running cost. The costs are very low as long as you only run the endpoint when you're using it. Navigate to the HuggingFace endpoint UI <a href=\"https://ui.endpoints.huggingface.co/\">here,</a> open your endpoint, and click Pause to put it on pause so you no longer pay for it.  \n",
+    "Many thanks to student John L. for raising this.\n",
+    "<br/><br/>\n",
+    "In week 8 we will use Modal instead of HuggingFace endpoints; with Modal you only pay for the time that you use it and you should get free credits.\n",
+    "            </span>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e610bf56-a46e-4aff-8de1-ab49d62b1ad3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import io\n",
+    "import sys\n",
+    "import json\n",
+    "import requests\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import google.generativeai as genai\n",
+    "import anthropic\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "import gradio as gr\n",
+    "import subprocess"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f672e1c-87e9-4865-b760-370fa605e614",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv()\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['HF_TOKEN'] = os.getenv('HF_TOKEN', 'your-key-if-not-using-env')\n",
+    "os.environ['GOOGLE_API_KEY'] = os.getenv('GOOGLE_API_KEY', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8aa149ed-9298-4d69-8fe2-8f5de0f667da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize\n",
+    "\n",
+    "openai = OpenAI()\n",
+    "claude = anthropic.Anthropic()\n",
+    "OPENAI_MODEL = \"gpt-4o\"\n",
+    "CLAUDE_MODEL = \"claude-3-5-sonnet-20240620\"\n",
+    "GEMINI_MODEL = 'gemini-1.5-pro'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6896636f-923e-4a2c-9d6c-fac07828a201",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_message = \"You are an assistant that reimplements Python code in high performance C++ for an M1 Mac. \"\n",
+    "system_message += \"Respond only with C++ code; use comments sparingly and do not provide any explanation other than occasional comments. \"\n",
+    "system_message += \"The C++ response needs to produce an identical output in the fastest possible time. Keep implementations of random number generators identical so that results match exactly.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e7b3546-57aa-4c29-bc5d-f211970d04eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def user_prompt_for(python):\n",
+    "    user_prompt = \"Rewrite this Python code in C++ with the fastest possible implementation that produces identical output in the least time. \"\n",
+    "    user_prompt += \"Respond only with C++ code; do not explain your work other than a few comments. \"\n",
+    "    user_prompt += \"Pay attention to number types to ensure no int overflows. Remember to #include all necessary C++ packages such as iomanip.\\n\\n\"\n",
+    "    user_prompt += python\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c6190659-f54c-4951-bef4-4960f8e51cc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def messages_for(python):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_message},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for(python)}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71e1ba8c-5b05-4726-a9f3-8d8c6257350b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# write to a file called optimized.cpp\n",
+    "\n",
+    "def write_output(cpp):\n",
+    "    code = cpp.replace(\"```cpp\",\"\").replace(\"```\",\"\")\n",
+    "    with open(\"optimized.cpp\", \"w\") as f:\n",
+    "        f.write(code)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e7d2fea8-74c6-4421-8f1e-0e76d5b201b9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_gpt(python):    \n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        print(fragment, end='', flush=True)\n",
+    "    write_output(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7cd84ad8-d55c-4fe0-9eeb-1895c95c4a9d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_claude(python):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_message,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            print(text, end=\"\", flush=True)\n",
+    "    write_output(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3625fcd6-209f-481c-a745-dcbcf5e44bc1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_gemini(python):\n",
+    "    gemini = genai.GenerativeModel(\n",
+    "        model_name = GEMINI_MODEL,\n",
+    "        system_instruction=system_message\n",
+    "    )\n",
+    "    response = gemini.generate_content(\n",
+    "        user_prompt_for(python),\n",
+    "        stream=True\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    for chunk in response:\n",
+    "        reply += chunk.text\n",
+    "        print(chunk.text, end=\"\", flush=True)\n",
+    "    write_output(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a1cbb778-fa57-43de-b04b-ed523f396c38",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pi = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def calculate(iterations, param1, param2):\n",
+    "    result = 1.0\n",
+    "    for i in range(1, iterations+1):\n",
+    "        j = i * param1 - param2\n",
+    "        result -= (1/j)\n",
+    "        j = i * param1 + param2\n",
+    "        result += (1/j)\n",
+    "    return result\n",
+    "\n",
+    "start_time = time.time()\n",
+    "result = calculate(100_000_000, 4, 1) * 4\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(f\"Result: {result:.12f}\")\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe891e3a-d1c4-4ee5-a361-34d0982fcff4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gemini(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7fe1cd4b-d2c5-4303-afed-2115a3fef200",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "105db6f9-343c-491d-8e44-3a5328b81719",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf26ee95-0c77-491d-9a91-579a1e96a8a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4194e40c-04ab-4940-9d64-b4ad37c5bb40",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "983a11fe-e24d-4c65-8269-9802c5ef3ae6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_claude(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5a766f9-3d23-4bb4-a1d4-88ec44b61ddf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c3b497b3-f569-420e-b92e-fb0f49957ce0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python_hard = \"\"\"# Be careful to support large number sizes\n",
+    "\n",
+    "def lcg(seed, a=1664525, c=1013904223, m=2**32):\n",
+    "    value = seed\n",
+    "    while True:\n",
+    "        value = (a * value + c) % m\n",
+    "        yield value\n",
+    "        \n",
+    "def max_subarray_sum(n, seed, min_val, max_val):\n",
+    "    lcg_gen = lcg(seed)\n",
+    "    random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val for _ in range(n)]\n",
+    "    max_sum = float('-inf')\n",
+    "    for i in range(n):\n",
+    "        current_sum = 0\n",
+    "        for j in range(i, n):\n",
+    "            current_sum += random_numbers[j]\n",
+    "            if current_sum > max_sum:\n",
+    "                max_sum = current_sum\n",
+    "    return max_sum\n",
+    "\n",
+    "def total_max_subarray_sum(n, initial_seed, min_val, max_val):\n",
+    "    total_sum = 0\n",
+    "    lcg_gen = lcg(initial_seed)\n",
+    "    for _ in range(20):\n",
+    "        seed = next(lcg_gen)\n",
+    "        total_sum += max_subarray_sum(n, seed, min_val, max_val)\n",
+    "    return total_sum\n",
+    "\n",
+    "# Parameters\n",
+    "n = 10000         # Number of random numbers\n",
+    "initial_seed = 42 # Initial seed for the LCG\n",
+    "min_val = -10     # Minimum value of random numbers\n",
+    "max_val = 10      # Maximum value of random numbers\n",
+    "\n",
+    "# Timing the function\n",
+    "import time\n",
+    "start_time = time.time()\n",
+    "result = total_max_subarray_sum(n, initial_seed, min_val, max_val)\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(\"Total Maximum Subarray Sum (20 runs):\", result)\n",
+    "print(\"Execution Time: {:.6f} seconds\".format(end_time - start_time))\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dab5e4bc-276c-4555-bd4c-12c699d5e899",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8d24ed5-2c15-4f55-80e7-13a3952b3cb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e0b3d073-88a2-40b2-831c-6f0c345c256f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9305446-1d0c-4b51-866a-b8c1e299bf5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_claude(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c181036-8193-4fdd-aef3-fc513b218d43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0be9f47d-5213-4700-b0e2-d444c7c738c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_gpt(python):    \n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        yield reply.replace('```cpp\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8669f56b-8314-4582-a167-78842caea131",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_claude(python):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_message,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            yield reply.replace('```cpp\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a9b6938f-89ef-4998-a334-2f6c042a2da4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_gemini(python):\n",
+    "    gemini = genai.GenerativeModel(\n",
+    "        model_name = GEMINI_MODEL,\n",
+    "        system_instruction=system_message\n",
+    "    )\n",
+    "    response = gemini.generate_content(\n",
+    "        user_prompt_for(python),\n",
+    "        stream=True\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    for chunk in response:\n",
+    "        reply += chunk.text\n",
+    "        yield reply.replace('```cpp\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2f1ae8f5-16c8-40a0-aa18-63b617df078d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(python, model):\n",
+    "    if model==\"GPT\":\n",
+    "        result = stream_gpt(python)\n",
+    "    elif model==\"Claude\":\n",
+    "        result = stream_claude(python)\n",
+    "    elif model==\"Gemini\":\n",
+    "        result= stream_gemini(python)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f1ddb38e-6b0a-4c37-baa4-ace0b7de887a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with gr.Blocks() as ui:\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", lines=10, value=python_hard)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\", \"Claude\",\"Gemini\"], label=\"Select model\", value=\"GPT\")\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "19bf2bff-a822-4009-a539-f003b1651383",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_python(code):\n",
+    "    try:\n",
+    "        output = io.StringIO()\n",
+    "        sys.stdout = output\n",
+    "        exec(code)\n",
+    "    finally:\n",
+    "        sys.stdout = sys.__stdout__\n",
+    "    return output.getvalue()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77f3ab5d-fcfb-4d3f-8728-9cacbf833ea6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_cpp(code):\n",
+    "    write_output(code)\n",
+    "    try:\n",
+    "        compile_result = subprocess.run(compiler_cmd[2], check=True, text=True, capture_output=True)\n",
+    "        run_cmd = [\"./optimized\"]\n",
+    "        run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)\n",
+    "        return run_result.stdout\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        return f\"An error occurred:\\n{e.stderr}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9a2274f1-d03b-42c0-8dcc-4ce159b18442",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "css = \"\"\"\n",
+    ".python {background-color: #306998;}\n",
+    ".cpp {background-color: #050;}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f1303932-160c-424b-97a8-d28c816721b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++\")\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=python_hard, lines=10)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\", \"Claude\",\"Gemini\"], label=\"Select model\", value=\"GPT\")\n",
+    "    with gr.Row():\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "    with gr.Row():\n",
+    "        python_run = gr.Button(\"Run Python\")\n",
+    "        cpp_run = gr.Button(\"Run C++\")\n",
+    "    with gr.Row():\n",
+    "        python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "        cpp_out = gr.TextArea(label=\"C++ result:\", elem_classes=[\"cpp\"])\n",
+    "\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "    python_run.click(execute_python, inputs=[python], outputs=[python_out])\n",
+    "    cpp_run.click(execute_cpp, inputs=[cpp], outputs=[cpp_out])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bb8c5b4e-ec51-4f21-b3f8-6aa94fede86d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import login, InferenceClient\n",
+    "from transformers import AutoTokenizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "13347633-4606-4e38-9927-80c39e65c1f1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hf_token = os.environ['HF_TOKEN']\n",
+    "login(hf_token, add_to_git_credential=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ef60a4df-6267-4ebd-8eed-dcb917af0a5e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "code_qwen = \"Qwen/CodeQwen1.5-7B-Chat\"\n",
+    "code_gemma = \"google/codegemma-7b-it\"\n",
+    "CODE_QWEN_URL = \"https://h1vdol7jxhje3mpn.us-east-1.aws.endpoints.huggingface.cloud\"\n",
+    "CODE_GEMMA_URL = \"https://c5hggiyqachmgnqg.us-east-1.aws.endpoints.huggingface.cloud\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "695ce389-a903-4533-a2f1-cd9e2a6af8f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenizer = AutoTokenizer.from_pretrained(code_qwen)\n",
+    "messages = messages_for(pi)\n",
+    "text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4548e96-0b32-4793-bdd6-1b072c2f26ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bb2a126b-09e7-4966-bc97-0ef5c2cc7896",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "client = InferenceClient(CODE_QWEN_URL, token=hf_token)\n",
+    "stream = client.text_generation(text, stream=True, details=True, max_new_tokens=3000)\n",
+    "for r in stream:\n",
+    "    print(r.token.text, end = \"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "127a52e5-ad85-42b7-a0f5-9afda5efe090",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_code_qwen(python):\n",
+    "    tokenizer = AutoTokenizer.from_pretrained(code_qwen)\n",
+    "    messages = messages_for(python)\n",
+    "    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+    "    client = InferenceClient(CODE_QWEN_URL, token=hf_token)\n",
+    "    stream = client.text_generation(text, stream=True, details=True, max_new_tokens=3000)\n",
+    "    result = \"\"\n",
+    "    for r in stream:\n",
+    "        result += r.token.text\n",
+    "        yield result    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a82387d1-7651-4923-995b-fe18356fcaa6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(python, model):\n",
+    "    if model==\"GPT\":\n",
+    "        result = stream_gpt(python)\n",
+    "    elif model==\"Claude\":\n",
+    "        result = stream_claude(python)\n",
+    "    elif model==\"Gemini\":\n",
+    "        result= stream_gemini(python)\n",
+    "    elif model==\"CodeQwen\":\n",
+    "        result = stream_code_qwen(python)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b0a6a97-5b8a-4a9b-8ee0-7561e0ced673",
+   "metadata": {},
+   "source": [
+    "<table style=\"margin: 0; text-align: left;\">\n",
+    "    <tr>\n",
+    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
+    "            <img src=\"../../thankyou.jpg\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
+    "        </td>\n",
+    "        <td>\n",
+    "            <h2 style=\"color:#090;\">Thank you to @CloudLlama for an amazing contribution</h2>\n",
+    "            <span style=\"color:#090;\">\n",
+    "                A student has contributed a chunk of code to improve this, in the next 2 cells. You can now select which Python porgram to run,\n",
+    "                and a compiler is automatically selected that will work on PC, Windows and Mac. Massive thank you @CloudLlama!\n",
+    "            </span>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ba311ec-c16a-4fe0-946b-4b940704cf65",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def select_sample_program(sample_program):\n",
+    "    if sample_program==\"pi\":\n",
+    "        return pi\n",
+    "    elif sample_program==\"python_hard\":\n",
+    "        return python_hard\n",
+    "    else:\n",
+    "        return \"Type your Python program here\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e42286bc-085c-45dc-b101-234308e58269",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import platform\n",
+    "\n",
+    "VISUAL_STUDIO_2022_TOOLS = \"C:\\\\Program Files\\\\Microsoft Visual Studio\\\\2022\\\\Community\\\\Common7\\Tools\\\\VsDevCmd.bat\"\n",
+    "VISUAL_STUDIO_2019_TOOLS = \"C:\\\\Program Files (x86)\\\\Microsoft Visual Studio\\\\2019\\\\BuildTools\\\\Common7\\\\Tools\\\\VsDevCmd.bat\"\n",
+    "\n",
+    "simple_cpp = \"\"\"\n",
+    "#include <iostream>\n",
+    "\n",
+    "int main() {\n",
+    "    std::cout << \"Hello\";\n",
+    "    return 0;\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "def run_cmd(command_to_run):\n",
+    "    try:\n",
+    "        run_result = subprocess.run(command_to_run, check=True, text=True, capture_output=True)\n",
+    "        return run_result.stdout if run_result.stdout else \"SUCCESS\"\n",
+    "    except:\n",
+    "        return \"\"\n",
+    "\n",
+    "def c_compiler_cmd(filename_base):\n",
+    "    my_platform = platform.system()\n",
+    "    my_compiler = []\n",
+    "\n",
+    "    try:\n",
+    "        with open(\"simple.cpp\", \"w\") as f:\n",
+    "            f.write(simple_cpp)\n",
+    "            \n",
+    "        if my_platform == \"Windows\":\n",
+    "            if os.path.isfile(VISUAL_STUDIO_2022_TOOLS):\n",
+    "                if os.path.isfile(\"./simple.exe\"):\n",
+    "                    os.remove(\"./simple.exe\")\n",
+    "                compile_cmd = [\"cmd\", \"/c\", VISUAL_STUDIO_2022_TOOLS, \"&\", \"cl\", \"simple.cpp\"]\n",
+    "                if run_cmd(compile_cmd):\n",
+    "                    if run_cmd([\"./simple.exe\"]) == \"Hello\":\n",
+    "                        my_compiler = [\"Windows\", \"Visual Studio 2022\", [\"cmd\", \"/c\", VISUAL_STUDIO_2022_TOOLS, \"&\", \"cl\", f\"{filename_base}.cpp\"]]\n",
+    "        \n",
+    "            if not my_compiler:\n",
+    "                if os.path.isfile(VISUAL_STUDIO_2019_TOOLS):\n",
+    "                    if os.path.isfile(\"./simple.exe\"):\n",
+    "                        os.remove(\"./simple.exe\")\n",
+    "                    compile_cmd = [\"cmd\", \"/c\", VISUAL_STUDIO_2019_TOOLS, \"&\", \"cl\", \"simple.cpp\"]\n",
+    "                    if run_cmd(compile_cmd):\n",
+    "                        if run_cmd([\"./simple.exe\"]) == \"Hello\":\n",
+    "                            my_compiler = [\"Windows\", \"Visual Studio 2019\", [\"cmd\", \"/c\", VISUAL_STUDIO_2019_TOOLS, \"&\", \"cl\", f\"{filename_base}.cpp\"]]\n",
+    "    \n",
+    "            if not my_compiler:\n",
+    "                my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "                \n",
+    "        elif my_platform == \"Linux\":\n",
+    "            if os.path.isfile(\"./simple\"):\n",
+    "                os.remove(\"./simple\")\n",
+    "            compile_cmd = [\"g++\", \"simple.cpp\", \"-o\", \"simple\"]\n",
+    "            if run_cmd(compile_cmd):\n",
+    "                if run_cmd([\"./simple\"]) == \"Hello\":\n",
+    "                    my_compiler = [\"Linux\", \"GCC (g++)\", [\"g++\", f\"{filename_base}.cpp\", \"-o\", f\"{filename_base}\" ]]\n",
+    "    \n",
+    "            if not my_compiler:\n",
+    "                if os.path.isfile(\"./simple\"):\n",
+    "                    os.remove(\"./simple\")\n",
+    "                compile_cmd = [\"clang++\", \"simple.cpp\", \"-o\", \"simple\"]\n",
+    "                if run_cmd(compile_cmd):\n",
+    "                    if run_cmd([\"./simple\"]) == \"Hello\":\n",
+    "                        my_compiler = [\"Linux\", \"Clang++\", [\"clang++\", f\"{filename_base}.cpp\", \"-o\", f\"{filename_base}\"]]\n",
+    "        \n",
+    "            if not my_compiler:\n",
+    "                my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "    \n",
+    "        elif my_platform == \"Darwin\":\n",
+    "            if os.path.isfile(\"./simple\"):\n",
+    "                os.remove(\"./simple\")\n",
+    "            compile_cmd = [\"clang++\", \"-Ofast\", \"-std=c++17\", \"-march=armv8.5-a\", \"-mtune=apple-m1\", \"-mcpu=apple-m1\", \"-o\", \"simple\", \"simple.cpp\"]\n",
+    "            if run_cmd(compile_cmd):\n",
+    "                if run_cmd([\"./simple\"]) == \"Hello\":\n",
+    "                    my_compiler = [\"Macintosh\", \"Clang++\", [\"clang++\", \"-Ofast\", \"-std=c++17\", \"-march=armv8.5-a\", \"-mtune=apple-m1\", \"-mcpu=apple-m1\", \"-o\", f\"{filename_base}\", f\"{filename_base}.cpp\"]]\n",
+    "    \n",
+    "            if not my_compiler:\n",
+    "                my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "    except:\n",
+    "        my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "        \n",
+    "    if my_compiler:\n",
+    "        return my_compiler\n",
+    "    else:\n",
+    "        return [\"Unknown\", \"Unavailable\", []]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f9ca2e6f-60c1-4e5f-b570-63c75b2d189b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "compiler_cmd = c_compiler_cmd(\"optimized\")\n",
+    "\n",
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++\")\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=python_hard, lines=10)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        with gr.Column():\n",
+    "            sample_program = gr.Radio([\"pi\", \"python_hard\"], label=\"Sample program\", value=\"python_hard\")\n",
+    "            model = gr.Dropdown([\"GPT\", \"Claude\", \"Gemini\", \"CodeQwen\"], label=\"Select model\", value=\"GPT\")\n",
+    "        with gr.Column():\n",
+    "            architecture = gr.Radio([compiler_cmd[0]], label=\"Architecture\", interactive=False, value=compiler_cmd[0])\n",
+    "            compiler = gr.Radio([compiler_cmd[1]], label=\"Compiler\", interactive=False, value=compiler_cmd[1])\n",
+    "    with gr.Row():\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "    with gr.Row():\n",
+    "        python_run = gr.Button(\"Run Python\")\n",
+    "        if not compiler_cmd[1] == \"Unavailable\":\n",
+    "            cpp_run = gr.Button(\"Run C++\")\n",
+    "        else:\n",
+    "            cpp_run = gr.Button(\"No compiler to run C++\", interactive=False)\n",
+    "    with gr.Row():\n",
+    "        python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "        cpp_out = gr.TextArea(label=\"C++ result:\", elem_classes=[\"cpp\"])\n",
+    "\n",
+    "    sample_program.change(select_sample_program, inputs=[sample_program], outputs=[python])\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "    python_run.click(execute_python, inputs=[python], outputs=[python_out])\n",
+    "    cpp_run.click(execute_cpp, inputs=[cpp], outputs=[cpp_out])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d0ad093-425b-488e-8c3f-67f729dd9c06",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

community-contributions/day4_with_inference_provider.ipynb

@@ -0,0 +1,925 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4a6ab9a2-28a2-445d-8512-a0dc8d1b54e9",
+   "metadata": {},
+   "source": [
+    "# Code Generator\n",
+    "\n",
+    "The requirement: use an Open Source model to generate high performance C++ code from Python code\n",
+    "\n",
+    "To replicate this, you'll need to set up a HuggingFace endpoint as I do in the video. It's simple to do, and it's quite satisfying to see the results!\n",
+    "\n",
+    "It's also an important part of your learning; this is the first example of deploying an open source model to be behind an API. We'll return to this in Week 8, but this should plant a seed in your mind for what's involved in moving open source models into production.\n",
+    "\n",
+    "Added the use of inference providers that was introduced recently by Hugging Face to convert the code.\n",
+    "Improved the user prompt to include algorithic efficeiny and performance optimization.\n",
+    "\n",
+    "Added Java as a conversion option.\n",
+    "\n",
+    "Note: C++ commands work on windows environment.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22e1567b-33fd-49e7-866e-4b635d15715a",
+   "metadata": {},
+   "source": [
+    "<table style=\"margin: 0; text-align: left;\">\n",
+    "    <tr>\n",
+    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
+    "            <img src=\"../important.jpg\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
+    "        </td>\n",
+    "        <td>\n",
+    "            <h1 style=\"color:#900;\">Important - Pause Endpoints when not in use</h1>\n",
+    "            <span style=\"color:#900;\">\n",
+    "            If you do decide to use HuggingFace endpoints for this project, you should stop or pause the endpoints when you are done to avoid accruing unnecessary running cost. The costs are very low as long as you only run the endpoint when you're using it. Navigate to the HuggingFace endpoint UI <a href=\"https://ui.endpoints.huggingface.co/\">here,</a> open your endpoint, and click Pause to put it on pause so you no longer pay for it.  \n",
+    "Many thanks to student John L. for raising this.\n",
+    "<br/><br/>\n",
+    "In week 8 we will use Modal instead of HuggingFace endpoints; with Modal you only pay for the time that you use it and you should get free credits.\n",
+    "            </span>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 231,
+   "id": "e610bf56-a46e-4aff-8de1-ab49d62b1ad3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import io\n",
+    "import sys\n",
+    "import json\n",
+    "import requests\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import google.generativeai\n",
+    "import anthropic\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "import gradio as gr\n",
+    "import subprocess, re"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 198,
+   "id": "4f672e1c-87e9-4865-b760-370fa605e614",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv()\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['HF_TOKEN'] = os.getenv('HF_TOKEN', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 199,
+   "id": "8aa149ed-9298-4d69-8fe2-8f5de0f667da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize\n",
+    "\n",
+    "openai = OpenAI()\n",
+    "claude = anthropic.Anthropic()\n",
+    "OPENAI_MODEL = \"gpt-4o\"\n",
+    "CLAUDE_MODEL = \"claude-3-5-sonnet-20240620\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 200,
+   "id": "2db60a72-d098-42ca-8ce2-1e037c86b718",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def system_prompt_for(language: str) -> str:\n",
+    "    system_prompt = (\n",
+    "        f\"You are an assistant that reimplements Python code in high performance {language.upper()} for an Windows intel i7.\"\n",
+    "        f\"Respond only with {language.upper()} code; use comments sparingly and do not provide any explanation other than occasional comments.\"\n",
+    "        f\"The {language.upper()} response needs to produce an identical output in the fastest possible time. Keep implementations of random number generators identical so that results match exactly.\"\n",
+    "    )\n",
+    "    return system_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 243,
+   "id": "70583432-e851-40d1-a219-2fb32b830dc8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#updated the original prompt to include algorithic efficeiny and performance optimization\n",
+    "def user_prompt_for(python: str, language: str) -> str:\n",
+    "    if language.lower() not in {\"cpp\", \"java\"}:\n",
+    "        raise ValueError(\"Unsupported language. Please choose 'C++' or 'Java'.\")\n",
+    "    \n",
+    "    optimization_notes = {\n",
+    "        \"cpp\": (\n",
+    "            \"- Use `int64_t` instead of `int` where necessary to prevent overflows.\\n\"\n",
+    "            \"- Ensure random number generation in C++ matches Python's output as closely as possible.\\n\"\n",
+    "            \"- Avoid undefined behavior, such as bit shifts that exceed type width (`1UL << 32` is incorrect for `uint32_t`).\\n\"\n",
+    "            \"- Utilize `std::vector` for dynamic arrays and prefer preallocation for efficiency.\\n\"\n",
+    "            \"- Consider `std::array` or `std::span` when fixed-size arrays are sufficient.\\n\"\n",
+    "            \"- Optimize with **SIMD**, cache-friendly structures, and memory alignment where necessary.\\n\"\n",
+    "        ),\n",
+    "        \"java\": (\n",
+    "            \"- Use `long` instead of `int` where necessary to prevent overflows.\\n\"\n",
+    "            \"- Ensure random number generation in Java matches Python's output as closely as possible.\\n\"\n",
+    "            \"- Use `ArrayList` instead of primitive arrays if dynamic resizing is needed.\\n\"\n",
+    "            \"- Utilize `BigInteger` if handling large numbers that could exceed `long`.\\n\"\n",
+    "            \"- Optimize with **parallel streams** (`IntStream.parallel()`) and **efficient data structures** (`HashMap`, `LinkedList`, etc.).\\n\"\n",
+    "        )\n",
+    "    }\n",
+    "\n",
+    "    user_prompt = (\n",
+    "        f\"First, analyze the given Python code to understand its core purpose and algorithmic approach. \"\n",
+    "        f\"Then, implement a {language} solution that achieves the same output while prioritizing:\\n\"\n",
+    "        \"1. **Algorithmic Efficiency** - Optimize time and space complexity, even if it means using a different approach.\\n\"\n",
+    "        \"2. **Numerical Correctness** - Prevent integer overflows, use appropriate data types (`long`, `BigInteger`, etc.), \"\n",
+    "        \"and ensure correct handling of edge cases.\\n\"\n",
+    "        \"3. **Performance Optimization** - Utilize language-specific features for efficiency.\\n\\n\"\n",
+    "        \n",
+    "        \"### **Important Notes:**\\n\"\n",
+    "        + optimization_notes[language.lower()] +\n",
+    "        \"\\n### **Expected Response:**\\n\"\n",
+    "        f\"Respond **only with {language} code**, including all necessary imports and ensuring the output matches the Python version exactly.\\n\\n\"\n",
+    "        \n",
+    "        \"Here's the Python code to analyze and optimize:\\n\\n\"\n",
+    "        + python\n",
+    "    )\n",
+    "    \n",
+    "    return user_prompt\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 202,
+   "id": "c6190659-f54c-4951-bef4-4960f8e51cc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def messages_for(python, language=\"cpp\"):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_prompt_for(language)},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for(python, language)}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 241,
+   "id": "71e1ba8c-5b05-4726-a9f3-8d8c6257350b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# write to a file called optimized.cpp\n",
+    "\n",
+    "def write_output(code, file_name):\n",
+    "    with open(file_name, \"w\") as f:\n",
+    "        f.write(code)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 226,
+   "id": "e7d2fea8-74c6-4421-8f1e-0e76d5b201b9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_gpt(python, language=\"cpp\"):    \n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python, language), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        print(fragment, end='', flush=True)\n",
+    "    file_name= f\"optimized.{language}\"\n",
+    "    if language == \"java\":\n",
+    "        # Extract class name from Java code\n",
+    "        match = re.search(r\"\\b(public\\s+)?class\\s+(\\w+)\", reply)\n",
+    "        class_name = match.group(2) if match else \"OptimizedJava\"\n",
+    "        file_name = f\"{class_name}.java\"\n",
+    "    else:\n",
+    "        file_name = f\"optimized.{language}\"\n",
+    "    write_output(reply, file_name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 227,
+   "id": "7cd84ad8-d55c-4fe0-9eeb-1895c95c4a9d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_claude(python, language=\"cpp\"):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_message,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for(python, language)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            print(text, end=\"\", flush=True)\n",
+    "    if language == \"java\":\n",
+    "        # Extract class name from Java code\n",
+    "        match = re.search(r\"\\b(public\\s+)?class\\s+(\\w+)\", reply)\n",
+    "        class_name = match.group(2) if match else \"OptimizedJava\"\n",
+    "        file_name = f\"{class_name}.java\"\n",
+    "    else:\n",
+    "        file_name = f\"optimized.{language}\"\n",
+    "    write_output(reply, file_name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 206,
+   "id": "a1cbb778-fa57-43de-b04b-ed523f396c38",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pi = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def calculate(iterations, param1, param2):\n",
+    "    result = 1.0\n",
+    "    for i in range(1, iterations+1):\n",
+    "        j = i * param1 - param2\n",
+    "        result -= (1/j)\n",
+    "        j = i * param1 + param2\n",
+    "        result += (1/j)\n",
+    "    return result\n",
+    "\n",
+    "start_time = time.time()\n",
+    "result = calculate(100_000_000, 4, 1) * 4\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(f\"Result: {result:.12f}\")\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "id": "7fe1cd4b-d2c5-4303-afed-2115a3fef200",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "id": "105db6f9-343c-491d-8e44-3a5328b81719",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(pi, \"java\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf26ee95-0c77-491d-9a91-579a1e96a8a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4194e40c-04ab-4940-9d64-b4ad37c5bb40",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!g++ -O3 -std=c++17 -march=native -o optimized optimized.cpp\n",
+    "!optimized.exe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "983a11fe-e24d-4c65-8269-9802c5ef3ae6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_claude(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5a766f9-3d23-4bb4-a1d4-88ec44b61ddf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!g++ -O3 -std=c++17 -march=native -o optimized optimized.cpp\n",
+    "!optimized.exe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 207,
+   "id": "c3b497b3-f569-420e-b92e-fb0f49957ce0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python_hard = \"\"\"# Be careful to support large number sizes\n",
+    "\n",
+    "def lcg(seed, a=1664525, c=1013904223, m=2**32):\n",
+    "    value = seed\n",
+    "    while True:\n",
+    "        value = (a * value + c) % m\n",
+    "        yield value\n",
+    "        \n",
+    "def max_subarray_sum(n, seed, min_val, max_val):\n",
+    "    lcg_gen = lcg(seed)\n",
+    "    random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val for _ in range(n)]\n",
+    "    max_sum = float('-inf')\n",
+    "    for i in range(n):\n",
+    "        current_sum = 0\n",
+    "        for j in range(i, n):\n",
+    "            current_sum += random_numbers[j]\n",
+    "            if current_sum > max_sum:\n",
+    "                max_sum = current_sum\n",
+    "    return max_sum\n",
+    "\n",
+    "def total_max_subarray_sum(n, initial_seed, min_val, max_val):\n",
+    "    total_sum = 0\n",
+    "    lcg_gen = lcg(initial_seed)\n",
+    "    for _ in range(20):\n",
+    "        seed = next(lcg_gen)\n",
+    "        total_sum += max_subarray_sum(n, seed, min_val, max_val)\n",
+    "    return total_sum\n",
+    "\n",
+    "# Parameters\n",
+    "n = 10000         # Number of random numbers\n",
+    "initial_seed = 42 # Initial seed for the LCG\n",
+    "min_val = -10     # Minimum value of random numbers\n",
+    "max_val = 10      # Maximum value of random numbers\n",
+    "\n",
+    "# Timing the function\n",
+    "import time\n",
+    "start_time = time.time()\n",
+    "result = total_max_subarray_sum(n, initial_seed, min_val, max_val)\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(\"Total Maximum Subarray Sum (20 runs):\", result)\n",
+    "print(\"Execution Time: {:.6f} seconds\".format(end_time - start_time))\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "dab5e4bc-276c-4555-bd4c-12c699d5e899",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8d24ed5-2c15-4f55-80e7-13a3952b3cb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e0b3d073-88a2-40b2-831c-6f0c345c256f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!g++ -O3 -std=c++17 -march=native -o optimized optimized.cpp\n",
+    "!optimized.exe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9305446-1d0c-4b51-866a-b8c1e299bf5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_claude(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c181036-8193-4fdd-aef3-fc513b218d43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!g++ -O3 -std=c++17 -march=native -o optimized optimized.cpp\n",
+    "!optimized.exe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 240,
+   "id": "0be9f47d-5213-4700-b0e2-d444c7c738c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_gpt(python, language=\"cpp\"):    \n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python, language), stream=True)\n",
+    "    reply = \"\"\n",
+    "    code_block = f\"```{language}\\n\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        cleaned_reply = reply.replace(code_block,'').replace('```','')\n",
+    "        yield cleaned_reply"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 239,
+   "id": "8669f56b-8314-4582-a167-78842caea131",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_claude(python, language=\"cpp\"):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_message,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for(python, language)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    code_block = f\"```{language}\\n\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            cleaned_reply = reply.replace(code_block,'').replace('```','')\n",
+    "            yield cleaned_reply"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 186,
+   "id": "2f1ae8f5-16c8-40a0-aa18-63b617df078d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(python, model):\n",
+    "    if model==\"GPT\":\n",
+    "        result = stream_gpt(python)\n",
+    "    elif model==\"Claude\":\n",
+    "        result = stream_claude(python)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 189,
+   "id": "f1ddb38e-6b0a-4c37-baa4-ace0b7de887a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7888/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 189,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "with gr.Blocks() as ui:\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", lines=10, value=python_hard)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\", \"Claude\"], label=\"Select model\", value=\"GPT\")\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 210,
+   "id": "19bf2bff-a822-4009-a539-f003b1651383",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_python(code):\n",
+    "    try:\n",
+    "        output = io.StringIO()\n",
+    "        sys.stdout = output\n",
+    "        exec(code)\n",
+    "    finally:\n",
+    "        sys.stdout = sys.__stdout__\n",
+    "    return output.getvalue()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 211,
+   "id": "9a2274f1-d03b-42c0-8dcc-4ce159b18442",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "css = \"\"\"\n",
+    ".python {background-color: #306998;}\n",
+    ".cpp {background-color: #050;}\n",
+    ".java {background-color: #306775;}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "id": "f1303932-160c-424b-97a8-d28c816721b2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7868/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 97,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++\")\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=python_hard, lines=10)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\", \"Claude\"], label=\"Select model\", value=\"GPT\")\n",
+    "    with gr.Row():\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "    with gr.Row():\n",
+    "        python_run = gr.Button(\"Run Python\")\n",
+    "        cpp_run = gr.Button(\"Run C++\")\n",
+    "    with gr.Row():\n",
+    "        python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "        cpp_out = gr.TextArea(label=\"C++ result:\", elem_classes=[\"cpp\"])\n",
+    "\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "    python_run.click(execute_python, inputs=[python], outputs=[python_out])\n",
+    "    cpp_run.click(execute_cpp, inputs=[cpp], outputs=[cpp_out])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 191,
+   "id": "bb8c5b4e-ec51-4f21-b3f8-6aa94fede86d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import login, InferenceClient"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 117,
+   "id": "13347633-4606-4e38-9927-80c39e65c1f1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Note: Environment variable`HF_TOKEN` is set and is the current active token independently from the token you've just configured.\n"
+     ]
+    }
+   ],
+   "source": [
+    "hf_token = os.environ['HF_TOKEN']\n",
+    "login(hf_token)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 118,
+   "id": "ef60a4df-6267-4ebd-8eed-dcb917af0a5e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "code_qwen = \"Qwen/CodeQwen1.5-7B-Chat\"\n",
+    "code_gemma = \"google/codegemma-7b-it\"\n",
+    "messages=messages_for(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 119,
+   "id": "3825d77a-03c6-42b2-89bc-ccbcb1585740",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "HfHubHTTPError",
+     "evalue": "402 Client Error: Payment Required for url: https://huggingface.co/api/inference-proxy/sambanova/v1/chat/completions (Request ID: Root=1-67afb729-1eb9aff1704314144ef14e59;2df843ad-b7d2-4145-bb7b-1cfd94ae19ef)\n\nYou have exceeded your monthly included credits for Inference Endpoints. Subscribe to PRO to get 20x more monthly allowance.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mHTTPError\u001b[0m                                 Traceback (most recent call last)",
+      "File \u001b[1;32m~\\anaconda3\\envs\\llms\\Lib\\site-packages\\huggingface_hub\\utils\\_http.py:406\u001b[0m, in \u001b[0;36mhf_raise_for_status\u001b[1;34m(response, endpoint_name)\u001b[0m\n\u001b[0;32m    405\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 406\u001b[0m     \u001b[43mresponse\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_for_status\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    407\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m HTTPError \u001b[38;5;28;01mas\u001b[39;00m e:\n",
+      "File \u001b[1;32m~\\anaconda3\\envs\\llms\\Lib\\site-packages\\requests\\models.py:1024\u001b[0m, in \u001b[0;36mResponse.raise_for_status\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m   1023\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m http_error_msg:\n\u001b[1;32m-> 1024\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m HTTPError(http_error_msg, response\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m)\n",
+      "\u001b[1;31mHTTPError\u001b[0m: 402 Client Error: Payment Required for url: https://huggingface.co/api/inference-proxy/sambanova/v1/chat/completions",
+      "\nThe above exception was the direct cause of the following exception:\n",
+      "\u001b[1;31mHfHubHTTPError\u001b[0m                            Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[119], line 5\u001b[0m\n\u001b[0;32m      1\u001b[0m client \u001b[38;5;241m=\u001b[39m InferenceClient(\n\u001b[0;32m      2\u001b[0m \tprovider\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msambanova\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m      3\u001b[0m \tapi_key\u001b[38;5;241m=\u001b[39mhf_token\n\u001b[0;32m      4\u001b[0m )\n\u001b[1;32m----> 5\u001b[0m stream \u001b[38;5;241m=\u001b[39m \u001b[43mclient\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mchat\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompletions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m      6\u001b[0m \u001b[43m\t\u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mQwen/Qwen2.5-Coder-32B-Instruct\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[0;32m      7\u001b[0m \u001b[43m\t\u001b[49m\u001b[43mmessages\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmessages\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[0;32m      8\u001b[0m \u001b[43m\t\u001b[49m\u001b[43mmax_tokens\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m500\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m      9\u001b[0m \u001b[43m\t\u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\n\u001b[0;32m     10\u001b[0m \u001b[43m)\u001b[49m\n\u001b[0;32m     12\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m chunk \u001b[38;5;129;01min\u001b[39;00m stream:\n\u001b[0;32m     13\u001b[0m     \u001b[38;5;28mprint\u001b[39m(chunk\u001b[38;5;241m.\u001b[39mchoices[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mdelta\u001b[38;5;241m.\u001b[39mcontent, end\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
+      "File \u001b[1;32m~\\anaconda3\\envs\\llms\\Lib\\site-packages\\huggingface_hub\\inference\\_client.py:970\u001b[0m, in \u001b[0;36mInferenceClient.chat_completion\u001b[1;34m(self, messages, model, stream, frequency_penalty, logit_bias, logprobs, max_tokens, n, presence_penalty, response_format, seed, stop, stream_options, temperature, tool_choice, tool_prompt, tools, top_logprobs, top_p)\u001b[0m\n\u001b[0;32m    943\u001b[0m parameters \u001b[38;5;241m=\u001b[39m {\n\u001b[0;32m    944\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmodel\u001b[39m\u001b[38;5;124m\"\u001b[39m: payload_model,\n\u001b[0;32m    945\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfrequency_penalty\u001b[39m\u001b[38;5;124m\"\u001b[39m: frequency_penalty,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    961\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstream_options\u001b[39m\u001b[38;5;124m\"\u001b[39m: stream_options,\n\u001b[0;32m    962\u001b[0m }\n\u001b[0;32m    963\u001b[0m request_parameters \u001b[38;5;241m=\u001b[39m provider_helper\u001b[38;5;241m.\u001b[39mprepare_request(\n\u001b[0;32m    964\u001b[0m     inputs\u001b[38;5;241m=\u001b[39mmessages,\n\u001b[0;32m    965\u001b[0m     parameters\u001b[38;5;241m=\u001b[39mparameters,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    968\u001b[0m     api_key\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtoken,\n\u001b[0;32m    969\u001b[0m )\n\u001b[1;32m--> 970\u001b[0m data \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inner_post\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrequest_parameters\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    972\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m stream:\n\u001b[0;32m    973\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m _stream_chat_completion_response(data)  \u001b[38;5;66;03m# type: ignore[arg-type]\u001b[39;00m\n",
+      "File \u001b[1;32m~\\anaconda3\\envs\\llms\\Lib\\site-packages\\huggingface_hub\\inference\\_client.py:327\u001b[0m, in \u001b[0;36mInferenceClient._inner_post\u001b[1;34m(self, request_parameters, stream)\u001b[0m\n\u001b[0;32m    324\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m InferenceTimeoutError(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInference call timed out: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mrequest_parameters\u001b[38;5;241m.\u001b[39murl\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01merror\u001b[39;00m  \u001b[38;5;66;03m# type: ignore\u001b[39;00m\n\u001b[0;32m    326\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 327\u001b[0m     \u001b[43mhf_raise_for_status\u001b[49m\u001b[43m(\u001b[49m\u001b[43mresponse\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    328\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m response\u001b[38;5;241m.\u001b[39miter_lines() \u001b[38;5;28;01mif\u001b[39;00m stream \u001b[38;5;28;01melse\u001b[39;00m response\u001b[38;5;241m.\u001b[39mcontent\n\u001b[0;32m    329\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m HTTPError \u001b[38;5;28;01mas\u001b[39;00m error:\n",
+      "File \u001b[1;32m~\\anaconda3\\envs\\llms\\Lib\\site-packages\\huggingface_hub\\utils\\_http.py:477\u001b[0m, in \u001b[0;36mhf_raise_for_status\u001b[1;34m(response, endpoint_name)\u001b[0m\n\u001b[0;32m    473\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m _format(HfHubHTTPError, message, response) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[0;32m    475\u001b[0m \u001b[38;5;66;03m# Convert `HTTPError` into a `HfHubHTTPError` to display request information\u001b[39;00m\n\u001b[0;32m    476\u001b[0m \u001b[38;5;66;03m# as well (request id and/or server error message)\u001b[39;00m\n\u001b[1;32m--> 477\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m _format(HfHubHTTPError, \u001b[38;5;28mstr\u001b[39m(e), response) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n",
+      "\u001b[1;31mHfHubHTTPError\u001b[0m: 402 Client Error: Payment Required for url: https://huggingface.co/api/inference-proxy/sambanova/v1/chat/completions (Request ID: Root=1-67afb729-1eb9aff1704314144ef14e59;2df843ad-b7d2-4145-bb7b-1cfd94ae19ef)\n\nYou have exceeded your monthly included credits for Inference Endpoints. Subscribe to PRO to get 20x more monthly allowance."
+     ]
+    }
+   ],
+   "source": [
+    "client = InferenceClient(\n",
+    "\tprovider=\"sambanova\",\n",
+    "\tapi_key=hf_token\n",
+    ")\n",
+    "stream = client.chat.completions.create(\n",
+    "\tmodel=\"Qwen/Qwen2.5-Coder-32B-Instruct\", \n",
+    "\tmessages=messages, \n",
+    "\tmax_tokens=500,\n",
+    "\tstream=True\n",
+    ")\n",
+    "\n",
+    "for chunk in stream:\n",
+    "    print(chunk.choices[0].delta.content, end=\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "id": "cc0c3e9c-2572-41d1-a476-6eae96b20695",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# using inference providers\n",
+    "def stream_code_qwen(python):\n",
+    "    messages = messages_for(python)\n",
+    "    client = InferenceClient(\n",
+    "    \tprovider=\"sambanova\",\n",
+    "    \tapi_key=hf_token\n",
+    "    )\n",
+    "    stream = client.chat.completions.create(\n",
+    "    \tmodel=\"Qwen/Qwen2.5-Coder-32B-Instruct\", \n",
+    "    \tmessages=messages, \n",
+    "    \tmax_tokens=500,\n",
+    "    \tstream=True\n",
+    "    )\n",
+    "    result = \"\"\n",
+    "    for chunk in stream:\n",
+    "        if chunk.choices and chunk.choices[0].delta.content:\n",
+    "            result += chunk.choices[0].delta.content\n",
+    "            yield result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 212,
+   "id": "a82387d1-7651-4923-995b-fe18356fcaa6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(python, model, language):\n",
+    "    if model==\"GPT\":\n",
+    "        result = stream_gpt(python, language)\n",
+    "    elif model==\"Claude\":\n",
+    "        result = stream_claude(python, language)\n",
+    "    elif model==\"CodeQwen\":\n",
+    "        result = stream_code_qwen(python, language)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 213,
+   "id": "4ba311ec-c16a-4fe0-946b-4b940704cf65",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def select_sample_program(sample_program):\n",
+    "    if sample_program==\"pi\":\n",
+    "        return pi\n",
+    "    elif sample_program==\"python_hard\":\n",
+    "        return python_hard\n",
+    "    else:\n",
+    "        return \"Type your Python program here\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 214,
+   "id": "06148e88-501b-4686-a41d-c3be528d8e6f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_cpp(code):\n",
+    "        write_output(code, \"optimized.exe\")\n",
+    "        try:\n",
+    "            compile_cmd = [\"g++\", \"-Ofast\", \"-std=c++17\", \"-march=native\", \"-mtune=intel\", \"-o\", \"optimized\", \"optimized.cpp\"]\n",
+    "            compile_result = subprocess.run(compile_cmd, check=True, text=True, capture_output=True)\n",
+    "            run_cmd = [\"optimized.exe\"]\n",
+    "            run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)\n",
+    "            return run_result.stdout\n",
+    "        except subprocess.CalledProcessError as e:\n",
+    "            return f\"An error occurred:\\n{e.stderr}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 236,
+   "id": "a42e3871-f3a5-4f14-836c-1e8ecacb56b5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_java(code):\n",
+    "    # Extract the class name from the Java code\n",
+    "    match = re.search(r\"\\b(public\\s+)?class\\s+(\\w+)\", code)\n",
+    "    class_name = match.group(2) if match else \"OptimizedJava\"\n",
+    "\n",
+    "    file_name = f\"{class_name}.java\"\n",
+    "    write_output(code, file_name)\n",
+    "    try:\n",
+    "        compile_cmd =[\"javac\", file_name]\n",
+    "        subprocess.run(compile_cmd, check=True, text=True, capture_output=True)\n",
+    "        run_cmd = [\"java\", class_name]\n",
+    "        run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)\n",
+    "        return run_result.stdout\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        return f\"Error during compilation or execution:\\n{e.stderr}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 238,
+   "id": "f9ca2e6f-60c1-4e5f-b570-63c75b2d189b",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7901/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 238,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++ or Java\")\n",
+    "    #input and output\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=python_hard, lines=10)\n",
+    "        converted_code = gr.Textbox(label=\"Converted code:\", lines=10)\n",
+    "        # java = gr.Textbox(label=\"Java code:\", lines=10)\n",
+    "    #sample programs\n",
+    "    with gr.Row():\n",
+    "        with gr.Column():\n",
+    "            sample_program = gr.Radio([\"pi\", \"python_hard\"], label=\"Sample program\", value=\"python_hard\")\n",
+    "    #select model and language\n",
+    "    with gr.Row():\n",
+    "        with gr.Column():\n",
+    "            model = gr.Dropdown([\"GPT\", \"Claude\", \"CodeQwen\"], label=\"Select model\", value=\"GPT\")\n",
+    "            language = gr.Dropdown([\"C++\",\"Java\"], label=\"Select language\", value=\"C++\")\n",
+    "    with gr.Row():\n",
+    "        convert = gr.Button(\"Convert\")\n",
+    "    #Code execution\n",
+    "    with gr.Row():\n",
+    "        python_run = gr.Button(\"Run Python\")\n",
+    "        converted_run = gr.Button(\"Run converted code\")\n",
+    "    with gr.Row():\n",
+    "        python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "        output = gr.TextArea(label=\"Converted code result:\", elem_classes=[\"cpp\"])\n",
+    "        \n",
+    "    # Function to convert Python code based on language\n",
+    "    def convert_code(python_code, model, selected_language):\n",
+    "        if selected_language == \"C++\":\n",
+    "            for chunk in optimize(python_code, model, \"cpp\"):\n",
+    "                yield chunk  # Stream each chunk\n",
+    "        elif selected_language == \"Java\":\n",
+    "            for chunk in optimize(python_code, model, \"java\"):\n",
+    "                yield chunk\n",
+    "        return \"\"\n",
+    "\n",
+    "    # Function to execute converted code\n",
+    "    def run_code(converted_code, selected_language):\n",
+    "        if selected_language == \"C++\":\n",
+    "            return execute_cpp(converted_code)\n",
+    "        elif selected_language == \"Java\":\n",
+    "            return execute_java(converted_code)\n",
+    "        return \"Invalid language selection\"\n",
+    "\n",
+    "    sample_program.change(select_sample_program, inputs=[sample_program], outputs=[python])\n",
+    "    convert.click(convert_code, inputs=[python, model, language], outputs=[converted_code])\n",
+    "    converted_run.click(run_code, inputs=[converted_code, language], outputs=[output])   \n",
+    "    python_run.click(execute_python, inputs=[python], outputs=[python_out])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d0ad093-425b-488e-8c3f-67f729dd9c06",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

community-contributions/day5-homework.ipynb

@@ -0,0 +1,565 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ff022957-2e81-4ea9-84d3-e52d5753e133",
+   "metadata": {},
+   "source": [
+    "### Comment and Unit Test Generater \n",
+    "\n",
+    "The requirement: \n",
+    "* use an LLM to generate docstring and comments for Python code\n",
+    "* use an LLM to generate unit test\n",
+    "\n",
+    "This is my week 4 day 5 project."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ea1841f6-4afc-4d29-ace8-5ca5a3915c8c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import io\n",
+    "import sys\n",
+    "import json\n",
+    "import requests\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import google.generativeai\n",
+    "import anthropic\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "import gradio as gr\n",
+    "import subprocess\n",
+    "from huggingface_hub import login, InferenceClient\n",
+    "from transformers import AutoTokenizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "11957fd3-6c61-4496-aef1-8223cb9ec4ce",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv()\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['HF_TOKEN'] = os.getenv('HF_TOKEN', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee7b08fd-e678-4234-895e-4e3a925e60f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize\n",
+    "\n",
+    "openai = OpenAI()\n",
+    "claude = anthropic.Anthropic()\n",
+    "OPENAI_MODEL = \"gpt-4o\"\n",
+    "CLAUDE_MODEL = \"claude-3-5-sonnet-20240620\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c8023255-9c98-4fbc-92e4-c553bed3b605",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hf_token = os.environ['HF_TOKEN']\n",
+    "login(hf_token, add_to_git_credential=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f8ce3f5e-74c4-4d35-bfbc-91c5be85e094",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "code_qwen = \"Qwen/CodeQwen1.5-7B-Chat\"\n",
+    "CODE_QWEN_URL = \"https://g39mbjooiiwkbgyz.us-east-1.aws.endpoints.huggingface.cloud\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1bbc66b6-52ae-465e-a368-edc8f097fe9d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def system_prompt_for_comment():\n",
+    "    system=\"\"\"\n",
+    "    You are a Python documentation expert. When writing documentation:\n",
+    "    - Follow PEP 257 and Google docstring style guidelines\n",
+    "    - Write clear, concise explanations\n",
+    "    - Include practical examples\n",
+    "    - Highlight edge cases and limitations\n",
+    "    - Use type hints in docstrings\n",
+    "    - Add inline comments only for complex logic\n",
+    "    - Never skip documenting parameters or return values\n",
+    "    - Validate that all documentation is accurate and complete\n",
+    "    \"\"\"\n",
+    "    return system"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b089f87b-53ae-40ad-8d06-b9924bb998a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def system_prompt_for_unit_test():\n",
+    "    system=\"\"\"\n",
+    "    You are an expert Python testing engineer who specializes in creating comprehensive unit tests. Follow these principles:\n",
+    "    - Use pytest as the testing framework\n",
+    "    - Follow the Arrange-Act-Assert pattern\n",
+    "    - Test both valid and invalid inputs\n",
+    "    - Include edge cases and boundary conditions\n",
+    "    - Write descriptive test names that explain the scenario being tested\n",
+    "    - Create independent tests that don't rely on each other\n",
+    "    - Use appropriate fixtures and parametrize when needed\n",
+    "    - Add clear comments explaining complex test logic\n",
+    "    - Cover error cases and exceptions\n",
+    "    - Achieve high code coverage while maintaining meaningful tests\n",
+    "    \"\"\"\n",
+    "    return system"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "22193622-f3a0-4894-a6c4-eb6d88097861",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def user_prompt_for_comment(code):\n",
+    "    user = f\"\"\"\n",
+    "        Please document this Python code with:\n",
+    "        \n",
+    "        1. A docstring containing:\n",
+    "        - A clear description of purpose and functionality\n",
+    "        - All parameters with types and descriptions\n",
+    "        - Return values with types\n",
+    "        - Exceptions that may be raised\n",
+    "        - Any important notes or limitations\n",
+    "        \n",
+    "        2. Strategic inline comments for:\n",
+    "        - Complex algorithms or business logic\n",
+    "        - Non-obvious implementation choices\n",
+    "        - Performance considerations\n",
+    "        - Edge cases\n",
+    "        \n",
+    "        Here's the code to document:\n",
+    "        \\n{code}\n",
+    "        \"\"\"\n",
+    "    return user;"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "81e61752-ec2f-44c1-86a2-ff3234a0358c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def user_prompt_for_unit_test(code):\n",
+    "    user = f\"\"\"\n",
+    "        Please generate unit tests for the following Python code. Include:\n",
+    "        \n",
+    "        1. Test cases for:\n",
+    "        - Normal/expected inputs\n",
+    "        - Edge cases and boundary values\n",
+    "        - Invalid inputs and error conditions\n",
+    "        - Different combinations of parameters\n",
+    "        - All public methods and functions\n",
+    "        \n",
+    "        2. For each test:\n",
+    "        - Clear test function names describing the scenario\n",
+    "        - Setup code (fixtures if needed)\n",
+    "        - Test data preparation\n",
+    "        - Expected outcomes\n",
+    "        - Assertions checking results\n",
+    "        - Comments explaining complex test logic\n",
+    "        \n",
+    "        3. Include any necessary:\n",
+    "        - Imports\n",
+    "        - Fixtures\n",
+    "        - Mock objects\n",
+    "        - Helper functions\n",
+    "        - Test data generators\n",
+    "        \n",
+    "        Here's the code to test:\n",
+    "        \\n{code}\n",
+    "    \"\"\"\n",
+    "    return user"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f31ceed3-0eb2-4962-ab86-2d0302185560",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pi = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def calculate(iterations, param1, param2):\n",
+    "    result = 1.0\n",
+    "    for i in range(1, iterations+1):\n",
+    "        j = i * param1 - param2\n",
+    "        result -= (1/j)\n",
+    "        j = i * param1 + param2\n",
+    "        result += (1/j)\n",
+    "    return result\n",
+    "\n",
+    "start_time = time.time()\n",
+    "result = calculate(100_000_000, 4, 1) * 4\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(f\"Result: {result:.12f}\")\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "192c30f5-4be6-49b7-a054-11bfcffa91e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4e920dc-4094-42d8-9255-18f2919df2d4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def messages_for_comment(python):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_prompt_for_comment()},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for_comment(python)}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77500cae-bf84-405c-8b03-2f984108951b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def messages_for_unit_test(python):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_prompt_for_unit_test()},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for_unit_test(python)}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5ec58bf1-4a44-4c21-a71a-2cac359884e5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_comment_gpt(code):\n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for_comment(code), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        #print(fragment, end='', flush=True)\n",
+    "        yield reply.replace('```','') \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "47c615e2-4eb6-4ce1-ad09-7f2e6dbc3934",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "stream_comment_gpt(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0b990875-31fd-40e5-bc8c-f6099d362249",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_unit_test_gpt(code):\n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for_unit_test(code), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        #print(fragment, end='', flush=True)\n",
+    "        yield reply.replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3dc90578-4f5e-47f1-b30f-c21b5795e82f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "stream_unit_test_gpt(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "17380c0f-b851-472b-a234-d86f5c219e50",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_comment_claude(code):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_prompt_for_comment(),\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for_comment(code)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            #print(text, end=\"\", flush=True)\n",
+    "            yield reply.replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a2d016d-76a2-4752-bd4d-6f93ddec46be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_unit_test_claude(code):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_prompt_for_unit_test(),\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for_unit_test(code)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            #print(text, end=\"\", flush=True)\n",
+    "            yield reply.replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee43428e-b577-4e95-944d-399f2f3b89ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "stream_comment_claude(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0565e33b-9f14-48b7-ae8d-d22dc03b93c9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "stream_unit_test_claude(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f13b3a5b-366d-4b28-adda-977a313e6b4d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_comment_model(model, model_url, code):\n",
+    "    tokenizer = AutoTokenizer.from_pretrained(model)\n",
+    "    messages = messages_for_comment(code)\n",
+    "    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+    "    client = InferenceClient(model_url, token=hf_token)\n",
+    "    stream = client.text_generation(text, stream=True, details=True, max_new_tokens=5000)\n",
+    "    result = \"\"\n",
+    "    for r in stream:\n",
+    "        #print(r.token.text, end = \"\")\n",
+    "        result += r.token.text\n",
+    "        yield result    \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e2efdb92-fc7a-4952-ab46-ae942cb996bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_unit_test_model(model, model_url, code):\n",
+    "    tokenizer = AutoTokenizer.from_pretrained(model)\n",
+    "    messages = messages_for_unit_test(code)\n",
+    "    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+    "    client = InferenceClient(model_url, token=hf_token)\n",
+    "    stream = client.text_generation(text, stream=True, details=True, max_new_tokens=3000)\n",
+    "    result = \"\"\n",
+    "    for r in stream:\n",
+    "        #print(r.token.text, end = \"\")\n",
+    "        result += r.token.text\n",
+    "        yield result    \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a756193-fcba-43da-a981-203c10d36488",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "stream_comment_model(code_qwen, CODE_QWEN_URL, pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "12ddcbf4-6286-47a8-847b-5be78e7aa995",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "stream_unit_test_model(code_qwen, CODE_QWEN_URL, pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "321609ee-b64a-44fc-9090-39f87e1f8e0e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def comment_code(python, model):\n",
+    "    if model==\"GPT\":\n",
+    "        result = stream_comment_gpt(python)\n",
+    "    elif model==\"Claude\":\n",
+    "        result = stream_comment_claude(python)\n",
+    "    elif model==\"CodeQwen\":\n",
+    "        result = stream_comment_model(code_qwen, CODE_QWEN_URL, python)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far     "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4c560c9-922d-4893-941f-42893373b1be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_unit_test(python, model):\n",
+    "    if model==\"GPT\":\n",
+    "        result = stream_unit_test_gpt(python)\n",
+    "    elif model==\"Claude\":\n",
+    "        result = stream_unit_test_claude(python)\n",
+    "    elif model==\"CodeQwen\":\n",
+    "        result = stream_unit_test_model(code_qwen, CODE_QWEN_URL, python)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far     "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f85bc777-bebe-436b-88cc-b9ecdb6306c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "css = \"\"\"\n",
+    ".python {background-color: #306998;}\n",
+    ".cpp {background-color: #050;}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee27cc91-81e6-42c8-ae3c-c04161229d8c",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++\")\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=pi, lines=10)\n",
+    "        result = gr.Textbox(label=\"Result code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\", \"Claude\",\"CodeQwen\"], label=\"Select model\", value=\"GPT\")\n",
+    "    with gr.Row():\n",
+    "        comment_button = gr.Button(\"Comment code\")\n",
+    "    with gr.Row():\n",
+    "        unit_test_button = gr.Button(\"Unit Test code\")\n",
+    "        \n",
+    "    comment_button.click(comment_code, inputs=[python, model], outputs=[result])\n",
+    "    unit_test_button.click(get_unit_test, inputs=[python, model], outputs=[result])\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "06e8279c-b488-4807-9bed-9d26be11c057",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

community-contributions/doc_string_exercise/README.md

@@ -0,0 +1,29 @@
+# Script Overview
+
+The documentation will show you how to run the python script generate_doc_string.py. It is designed to take input
+from an existing python file and create a new one with a suffix ('claude' or 'gpt'). If you do not specify and llm 
+model, it will default to claude.
+
+# How to run
+
+```powershell
+conda activate llms
+cd <script_location>
+python generate_doc_string -fp <full_file_path> -llm <name_of_model>
+```
+
+# Show Help Instructions
+
+```shell
+python generate_doc_string --help
+```
+
+# Error Checking
+
+1) File Path Existence
+
+If the file path doesn't exist, the script will stop running and print out an error.
+
+2) LLM Model Choice
+
+If you choose something other than 'gpt' or 'claude', it will show and assertion error.

community-contributions/doc_string_exercise/data/original_file.py

@@ -0,0 +1,19 @@
+
+def calculate(iterations, param1, param2):
+    result = 1.0
+    for i in range(1, iterations+1):
+        j = i * param1 - param2
+        result -= (1/j)
+        j = i * param1 + param2
+        result += (1/j)
+    return result
+
+
+def calculate_2(iterations, param1, param2):
+    result = 1.0
+    for i in range(1, iterations+1):
+        j = i * param1 - param2
+        result -= (1/j)
+        j = i * param1 + param2
+        result += (1/j)
+    return result

community-contributions/doc_string_exercise/generate_doc_string.py

@@ -0,0 +1,85 @@
+from argparse import ArgumentParser
+import os
+from dotenv import load_dotenv
+from openai import OpenAI
+import anthropic
+from utils import add_doc_string, Model, get_system_message
+from pathlib import Path
+
+
+def main():
+
+    # get run time arguments
+    parser = ArgumentParser(
+        prog='Generate Doc String for an existing functions',
+        description='Run Doc String for a given file and model',
+    )
+    parser.add_argument(
+        '-fp',
+        '--file_path',
+        help='Enter the file path to the script that will be updated with doc strings',
+        default=None
+    )
+    parser.add_argument(
+        '-llm',
+        '--llm_model',
+        help='Choose the LLM model that will create the doc strings',
+        default='claude'
+    )
+
+    # get run time arguments
+    args = parser.parse_args()
+    file_path = Path(args.file_path)
+    llm_model = args.llm_model
+
+    # check for file path
+    assert file_path.exists(), f"File Path {str(file_path.as_posix())} doesn't exist. Please try again."
+
+    # check for value llm values
+    assert llm_model in ['gpt', 'claude'], (f"Invalid model chosen '{llm_model}'. "
+                                            f"Please choose a valid model ('gpt' or 'claude')")
+
+    # load keys and environment variables
+    load_dotenv()
+    os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')
+    os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')
+    os.environ['HF_TOKEN'] = os.getenv('HF_INF_TOKEN', 'your-key-if-not-using-env')
+
+    # get system messages
+    system_message = get_system_message()
+
+    # get model info
+    model_info = {
+        'gpt': {
+            'client': OpenAI(),
+            'model': Model.OPENAI_MODEL.value,
+        },
+        'claude': {
+            'client': anthropic.Anthropic(),
+            'model': Model.CLAUDE_MODEL.value
+        }
+    }
+
+    # add standard argumens
+    model_info[llm_model].update(
+        {
+            'file_path': file_path,
+            'system_message': system_message
+        }
+    )
+
+    # convert python code to c++ code using open ai
+    print(f"\nSTARTED | Doc Strings Using {llm_model.upper()} for file {str(file_path)}\n\n")
+    add_doc_string(**model_info[llm_model])
+    print(f"\nFINISHED | Doc Strings Using {llm_model.upper()} for file {str(file_path)}\n\n")
+
+
+if __name__ == '__main__':
+
+    main()
+
+
+
+
+
+

community-contributions/doc_string_exercise/utils.py

@@ -0,0 +1,147 @@
+from enum import Enum
+from pathlib import Path
+
+
+class Model(Enum):
+    """
+    Enumeration of supported AI models.
+    """
+    OPENAI_MODEL = "gpt-4o"
+    CLAUDE_MODEL = "claude-3-5-sonnet-20240620"
+
+
+def get_system_message() -> str:
+    """
+    Generate a system message for AI assistants creating docstrings.
+
+    :return: A string containing instructions for the AI assistant.
+    :rtype: str
+    """
+    system_message = "You are an assistant that creates doc strings in reStructure Text format for an existing python function. "
+    system_message += "Respond only with an updated python function; use comments sparingly and do not provide any explanation other than occasional comments. "
+    system_message += "Be sure to include typing annotation for each function argument or key word argument and return object types."
+
+    return system_message
+
+
+def user_prompt_for(python: str) -> str:
+    """
+    Generate a user prompt for rewriting Python functions with docstrings.
+
+    :param python: The Python code to be rewritten.
+    :type python: str
+    :return: A string containing the user prompt and the Python code.
+    :rtype: str
+    """
+    user_prompt = "Rewrite this Python function with doc strings in the reStructuredText style."
+    user_prompt += "Respond only with python code; do not explain your work other than a few comments. "
+    user_prompt += "Be sure to write a description of the function purpose with typing for each argument and return\n\n"
+    user_prompt += python
+    return user_prompt
+
+
+def messages_for(python: str, system_message: str) -> list:
+    """
+    Create a list of messages for the AI model.
+
+    :param python: The Python code to be processed.
+    :type python: str
+    :param system_message: The system message for the AI assistant.
+    :type system_message: str
+    :return: A list of dictionaries containing role and content for each message.
+    :rtype: list
+    """
+    return [
+        {"role": "system", "content": system_message},
+        {"role": "user", "content": user_prompt_for(python)}
+    ]
+
+
+def write_output(output: str, file_suffix: str, file_path: Path) -> None:
+    """
+    Write the processed output to a file.
+
+    :param output: The processed Python code with docstrings.
+    :type output: str
+    :param file_suffix: The suffix to be added to the output file name.
+    :type file_suffix: str
+    :param file_path: The path of the input file.
+    :type file_path: Path
+    :return: None
+    """
+    code = output.replace("", "").replace("", "")
+    out_file = file_path.with_name(f"{file_path.stem}{file_suffix if file_suffix else ''}.py")
+    out_file.write_text(code)
+
+
+def add_doc_string(client: object, system_message: str, file_path: Path, model: str) -> None:
+    """
+    Add docstrings to a Python file using the specified AI model.
+
+    :param client: The AI client object.
+    :type client: object
+    :param system_message: The system message for the AI assistant.
+    :type system_message: str
+    :param file_path: The path of the input Python file.
+    :type file_path: Path
+    :param model: The AI model to be used.
+    :type model: str
+    :return: None
+    """
+    if 'gpt' in model:
+        add_doc_string_gpt(client=client, system_message=system_message, file_path=file_path, model=model)
+    else:
+        add_doc_string_claude(client=client, system_message=system_message, file_path=file_path, model=model)
+
+
+def add_doc_string_gpt(client: object, system_message: str, file_path: Path, model: str = 'gpt-4o') -> None:
+    """
+    Add docstrings to a Python file using GPT model.
+
+    :param client: The OpenAI client object.
+    :type client: object
+    :param system_message: The system message for the AI assistant.
+    :type system_message: str
+    :param file_path: The path of the input Python file.
+    :type file_path: Path
+    :param model: The GPT model to be used, defaults to 'gpt-4o'.
+    :type model: str
+    :return: None
+    """
+    code_text = file_path.read_text(encoding='utf-8')
+    stream = client.chat.completions.create(model=model, messages=messages_for(code_text, system_message), stream=True)
+    reply = ""
+    for chunk in stream:
+        fragment = chunk.choices[0].delta.content or ""
+        reply += fragment
+        print(fragment, end='', flush=True)
+    write_output(reply, file_suffix='_gpt', file_path=file_path)
+
+
+def add_doc_string_claude(client: object, system_message: str, file_path: Path, model: str = 'claude-3-5-sonnet-20240620') -> None:
+    """
+    Add docstrings to a Python file using Claude model.
+
+    :param client: The Anthropic client object.
+    :type client: object
+    :param system_message: The system message for the AI assistant.
+    :type system_message: str
+    :param file_path: The path of the input Python file.
+    :type file_path: Path
+    :param model: The Claude model to be used, defaults to 'claude-3-5-sonnet-20240620'.
+    :type model: str
+    :return: None
+    """
+    code_text = file_path.read_text(encoding='utf-8')
+    result = client.messages.stream(
+        model=model,
+        max_tokens=2000,
+        system=system_message,
+        messages=[{"role": "user", "content": user_prompt_for(code_text)}],
+    )
+    reply = ""
+    with result as stream:
+        for text in stream.text_stream:
+            reply += text
+            print(text, end="", flush=True)
+    write_output(reply, file_suffix='_claude', file_path=file_path)

community-contributions/ems_week4_docupy.ipynb

@@ -0,0 +1,869 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ykDDGx1cjYlh"
+   },
+   "source": [
+    "# **DocuPy**  \n",
+    "### _\"Automate Documentation, Comments, and Unit Tests for Python Code\"_  \n",
+    "\n",
+    "## Overview  \n",
+    "DocuPy is a Gradio-powered tool designed to automate essential but time-consuming Python development tasks. It streamlines documentation, unit testing, and Python-to-C++ code conversion with AI-driven assistance.  \n",
+    "\n",
+    "### Key Features  \n",
+    "✅ **Auto-Generate Docstrings & Comments** – Instantly improve code clarity and maintainability.  \n",
+    "✅ **Unit Test Generation** – Ensure reliability with AI-generated test cases.  \n",
+    "✅ **Python to C++ Conversion** – Seamlessly translate Python code to C++ with execution support.  \n",
+    "\n",
+    "With an intuitive tab-based UI, DocuPy enhances productivity for developers of all levels. Whether you're documenting functions, validating code with tests, or exploring C++ conversions, this tool lets you focus on coding while it handles the rest.  \n",
+    "\n",
+    "🔗 **Check out the repo**: [GitHub Repo](https://github.com/emads22/DocuPy)  \n",
+    "\n",
+    "💡 **Have insights, feedback, or ideas?** Feel free to reach out. \n",
+    "\n",
+    "[<img src=\"https://img.shields.io/badge/GitHub-Emad-blue?logo=github\" width=\"150\">](https://github.com/emads22)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you're running this notebook on **`Google Colab`**, ensure you install the required libraries by running the following command:\n",
+    "\n",
+    "```bash\n",
+    "!pip install -q openai anthropic python-dotenv gradio huggingface_hub transformers\n",
+    "```\n",
+    "Otherwise, make sure to activate the Conda environment `docupy` that already includes these modules:\n",
+    "\n",
+    "```bash\n",
+    "conda activate docupy\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6wIpBtNPjXc8"
+   },
+   "outputs": [],
+   "source": [
+    "# Uncomment the following command when running on Google Colab\n",
+    "# !pip install -q openai anthropic python-dotenv gradio huggingface_hub transformers "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "T-cTBf9amBxf"
+   },
+   "source": [
+    "## Setup and Install Dependencies\n",
+    "\n",
+    "- Start by installing all necessary libraries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "aIHWC7xpk87X"
+   },
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "import os\n",
+    "import io\n",
+    "import sys\n",
+    "import subprocess\n",
+    "import openai\n",
+    "import anthropic\n",
+    "import google.generativeai as google_genai\n",
+    "import gradio as gr\n",
+    "from openai import OpenAI\n",
+    "# from google.colab import userdata\n",
+    "from dotenv import load_dotenv\n",
+    "from pathlib import Path\n",
+    "from huggingface_hub import login, InferenceClient\n",
+    "from transformers import AutoTokenizer"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "LZQbXR3dmZy4"
+   },
+   "source": [
+    "## Add Secrets to the Colab Notebook\n",
+    "\n",
+    "- Add the API keys for OpenAI, Claude, and Gemini to authenticate and access their respective models and services.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "AadABekBm4fV"
+   },
+   "outputs": [],
+   "source": [
+    "# # Log in to Hugging Face using the token and add it to git credentials\n",
+    "# hf_token = userdata.get('HF_TOKEN')\n",
+    "# login(token=hf_token, add_to_git_credential=True)\n",
+    "\n",
+    "# # Endpoint URL for accessing the Code Qwen model through Hugging Face\n",
+    "# CODE_QWEN_URL = userdata.get('CODE_QWEN_URL')\n",
+    "\n",
+    "# # Initialize inference clients with every model using API keys\n",
+    "# gpt = openai.OpenAI(api_key=userdata.get('OPENAI_API_KEY'))\n",
+    "# claude = anthropic.Anthropic(api_key=userdata.get('ANTHROPIC_API_KEY'))\n",
+    "# google_genai.configure(api_key=userdata.get('GOOGLE_API_KEY'))\n",
+    "# code_qwen = InferenceClient(CODE_QWEN_URL, token=hf_token)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Ej3JNfh_wc0m"
+   },
+   "source": [
+    "## Alternatively, if not running on Google Colab, Load Environment Variables for API Keys\n",
+    "\n",
+    "- Use the `load_dotenv()` function to securely load API keys from a `.env` file.\n",
+    "- Ensure that the `.env` file is located in the same directory as your script or Jupyter Notebook.\n",
+    "- The `.env` file should include the required API keys for OpenAI, Claude, and Gemini."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "av9X9XpQw0Vd"
+   },
+   "outputs": [],
+   "source": [
+    "load_dotenv()\n",
+    "\n",
+    "# Log in to Hugging Face using the token and add it to git credentials\n",
+    "hf_token = os.getenv('HF_TOKEN')\n",
+    "login(token=hf_token, add_to_git_credential=True)\n",
+    "\n",
+    "# Endpoint URL for accessing the Code Qwen model through Hugging Face\n",
+    "CODE_QWEN_URL = os.getenv('CODE_QWEN_URL')\n",
+    "\n",
+    "# Initialize inference clients with every model using API keys\n",
+    "gpt = openai.OpenAI(api_key=os.getenv('OPENAI_API_KEY'))\n",
+    "claude = anthropic.Anthropic(api_key=os.getenv('ANTHROPIC_API_KEY'))\n",
+    "google_genai.configure(api_key=os.getenv('GOOGLE_API_KEY'))\n",
+    "code_qwen = InferenceClient(CODE_QWEN_URL, token=hf_token)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "lvEhCuQjrTYu"
+   },
+   "source": [
+    "## Define Required Constants\n",
+    "\n",
+    "- Initialize the essential constants required for the application's functionality.\n",
+    "- Configure the system and user prompts specific to each task or feature.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "AKEBKKmAowt2"
+   },
+   "outputs": [],
+   "source": [
+    "# Models\n",
+    "OPENAI_MODEL = \"gpt-4o\"\n",
+    "CLAUDE_MODEL = \"claude-3-5-sonnet-20240620\"\n",
+    "GEMINI_MODEL = \"gemini-1.5-pro\"\n",
+    "CODE_QWEN_MODEL = \"Qwen/CodeQwen1.5-7B-Chat\"\n",
+    "\n",
+    "MODELS_IN_USE = [\"GPT\", \"Claude\", \"Gemini\", \"CodeQwen\"]\n",
+    "\n",
+    "MAX_TOKENS = 2000\n",
+    "\n",
+    "ACTION_A = \"commenting\"\n",
+    "ACTION_B = \"testing\"\n",
+    "ACTION_C = \"converting\"\n",
+    "\n",
+    "# Define and create the path for the \"temp_files\" directory within the current script's directory\n",
+    "TEMP_DIR = Path.cwd() / \"temp_files\"\n",
+    "TEMP_DIR.mkdir(parents=True, exist_ok=True)\n",
+    "\n",
+    "PYTHON_SCRIPT_EASY = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def reverse_string(s):\n",
+    "    return s[::-1]\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    start_time = time.time()\n",
+    "    text = \"Hello, World!\"\n",
+    "    print(f\"- Original string: {text}\")\n",
+    "    print(\"- Reversed string:\", reverse_string(text))\n",
+    "    execution_time = time.time() - start_time  \n",
+    "    print(f\"\\\\n=> Execution Time: {execution_time:.6f} seconds\")\n",
+    "\"\"\"\n",
+    "\n",
+    "PYTHON_SCRIPT_INTERMEDIATE = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def is_palindrome(s):\n",
+    "    s = s.lower().replace(\" \", \"\")  \n",
+    "    return s == s[::-1]\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    start_time = time.time()\n",
+    "    text = \"Racecar\"\n",
+    "    if is_palindrome(text):\n",
+    "        print(f\"- '{text}' is a palindrome!\")\n",
+    "    else:\n",
+    "        print(f\"- '{text}' is Not a palindrome.\")\n",
+    "    execution_time = time.time() - start_time  \n",
+    "    print(f\"\\\\n=> Execution Time: {execution_time:.6f} seconds\")\n",
+    "\"\"\"\n",
+    "\n",
+    "PYTHON_SCRIPT_HARD = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def generate_primes(limit):\n",
+    "    primes = []\n",
+    "    for num in range(2, limit + 1):\n",
+    "        if all(num % p != 0 for p in primes):\n",
+    "            primes.append(num)\n",
+    "    return primes\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    start_time = time.time()\n",
+    "    n = 20\n",
+    "    print(f\"- Generating primes up to: {n}\")\n",
+    "    print(\"- Prime numbers:\", generate_primes(n))\n",
+    "    execution_time = time.time() - start_time  \n",
+    "    print(f\"\\\\n=> Execution Time: {execution_time:.6f} seconds\")\n",
+    "\"\"\"\n",
+    "\n",
+    "PYTHON_SCRIPTS = {\n",
+    "    \"reverse_string\" : PYTHON_SCRIPT_EASY,\n",
+    "    \"is_palindrome\" : PYTHON_SCRIPT_INTERMEDIATE,\n",
+    "    \"generate_primes\" : PYTHON_SCRIPT_HARD,\n",
+    "    \"custom\" : \"\"\"\n",
+    "# Write your custom Python script here\n",
+    "if __name__ == \"__main__\":\n",
+    "    print(\"Hello, World!\")\n",
+    "\"\"\"\n",
+    "}\n",
+    "\n",
+    "# Relative system prompts\n",
+    "SYSTEM_PROMPT_COMMENTS = \"\"\"\n",
+    "You are an AI model specializing in enhancing Python code documentation.\n",
+    "Generate detailed and precise docstrings and inline comments for the provided Python code.\n",
+    "Ensure the docstrings clearly describe the purpose, parameters, and return values of each function.\n",
+    "Inline comments should explain complex or non-obvious code segments.\n",
+    "Do not include any introductions, explanations, conclusions, or additional context.\n",
+    "Return only the updated Python code enclosed within ```python ... ``` for proper formatting and syntax highlighting.\n",
+    "\"\"\"\n",
+    "\n",
+    "SYSTEM_PROMPT_TESTS = \"\"\"\n",
+    "You are an AI model specializing in generating comprehensive unit tests for Python code.\n",
+    "Create Python unit tests that thoroughly validate the functionality of the given code.\n",
+    "Use the `unittest` framework and ensure edge cases and error conditions are tested.\n",
+    "Do not include any comments, introductions, explanations, conclusions, or additional context.\n",
+    "Return only the unit test code enclosed within ```python ... ``` for proper formatting and syntax highlighting.\n",
+    "\"\"\"\n",
+    "\n",
+    "SYSTEM_PROMPT_CONVERT = \"\"\"\n",
+    "You are an AI model specializing in high-performance code translation.\n",
+    "Translate the given Python code into equivalent, optimized C++ code.\n",
+    "Focus on:\n",
+    "- Using efficient data structures and algorithms.\n",
+    "- Avoiding unnecessary memory allocations and computational overhead.\n",
+    "- Ensuring minimal risk of integer overflow by using appropriate data types.\n",
+    "- Leveraging the C++ Standard Library (e.g., `<vector>`, `<algorithm>`) for performance and readability.\n",
+    "Produce concise and efficient C++ code that matches the functionality of the original Python code.\n",
+    "Do not include any comments, introductions, explanations, conclusions, or additional context..\n",
+    "Return only the C++ code enclosed within ```cpp ... ``` for proper formatting and syntax highlighting.\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "JJ1zttf7ANqD"
+   },
+   "outputs": [],
+   "source": [
+    "# Relative user prompts\n",
+    "def user_prompt_comments(python_code):\n",
+    "    user_prompt = f\"\"\"\n",
+    "Add detailed docstrings and inline comments to the following Python code:\n",
+    "\n",
+    "```python\n",
+    "{python_code}\n",
+    "```\n",
+    "\"\"\"\n",
+    "    return user_prompt\n",
+    "\n",
+    "def user_prompt_tests(python_code):\n",
+    "    user_prompt = f\"\"\"\n",
+    "Generate unit tests for the following Python code using the `unittest` framework:\n",
+    "\n",
+    "```python\n",
+    "{python_code}\n",
+    "```\n",
+    "\"\"\"\n",
+    "    return user_prompt\n",
+    "\n",
+    "def user_prompt_convert(python_code):\n",
+    "    user_prompt = f\"\"\"\n",
+    "Convert the following Python code into C++:\n",
+    "\n",
+    "```python\n",
+    "{python_code}\n",
+    "``` \n",
+    "\"\"\"\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "tqrOO_qsCRkd"
+   },
+   "source": [
+    "### Define the Tab Functions\n",
+    "\n",
+    "- Develop dedicated functions for each service: documenting Python code, generating unit tests, and converting Python to C++.\n",
+    "- Structure each function to handle user input, process it using the selected AI model, and display the generated output seamlessly.\n",
+    "- Ensure the functionality of each tab aligns with its specific purpose, providing an intuitive and efficient user experience.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "HBsBrq3G94ul"
+   },
+   "outputs": [],
+   "source": [
+    "def stream_gpt(system_prompt, user_prompt):\n",
+    "    stream = gpt.chat.completions.create(\n",
+    "        model=OPENAI_MODEL,\n",
+    "        messages=[\n",
+    "            {\"role\": \"system\", \"content\": system_prompt},\n",
+    "            {\"role\": \"user\", \"content\": user_prompt}\n",
+    "        ],\n",
+    "        stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        reply += chunk.choices[0].delta.content or \"\"\n",
+    "        yield reply.replace(\"```python\\n\", \"\").replace(\"```cpp\\n\", \"\").replace(\"```\", \"\")\n",
+    "\n",
+    "def stream_claude(system_prompt, user_prompt):\n",
+    "    response = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=MAX_TOKENS,\n",
+    "        system=system_prompt,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with response as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            yield reply.replace(\"```python\\n\", \"\").replace(\"```cpp\\n\", \"\").replace(\"```\", \"\")\n",
+    "\n",
+    "def stream_gemini(system_prompt, user_prompt):\n",
+    "    gemini = google_genai.GenerativeModel(\n",
+    "        model_name=GEMINI_MODEL,\n",
+    "        system_instruction=system_prompt\n",
+    "    )\n",
+    "    stream = gemini.generate_content(\n",
+    "        contents=user_prompt,\n",
+    "        stream=True\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        reply += chunk.text or \"\"\n",
+    "        yield reply.replace(\"```python\\n\", \"\").replace(\"```cpp\\n\", \"\").replace(\"```\", \"\")\n",
+    "\n",
+    "def stream_code_qwen(system_prompt, user_prompt):\n",
+    "    tokenizer = AutoTokenizer.from_pretrained(CODE_QWEN_MODEL)\n",
+    "    model_input = tokenizer.apply_chat_template(\n",
+    "        conversation=[\n",
+    "            {\"role\": \"system\", \"content\": system_prompt},\n",
+    "            {\"role\": \"user\", \"content\": user_prompt}\n",
+    "        ],\n",
+    "        tokenize=False,\n",
+    "        add_generation_prompt=True\n",
+    "    )\n",
+    "    stream = code_qwen.text_generation(\n",
+    "        prompt=model_input,\n",
+    "        stream=True,\n",
+    "        details=True,\n",
+    "        max_new_tokens=MAX_TOKENS\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        reply += chunk.token.text or \"\"\n",
+    "        yield reply.replace(\"```python\\n\", \"\").replace(\"```cpp\\n\", \"\").replace(\"```\", \"\")\n",
+    "\n",
+    "def set_prompts(user_input, action):\n",
+    "    action = action.lower()\n",
+    "\n",
+    "    if action == ACTION_A.lower():\n",
+    "        system_prompt = SYSTEM_PROMPT_COMMENTS\n",
+    "        user_prompt = user_prompt_comments(user_input)\n",
+    "    elif action == ACTION_B.lower():\n",
+    "        system_prompt = SYSTEM_PROMPT_TESTS\n",
+    "        user_prompt = user_prompt_tests(user_input)\n",
+    "    elif action == ACTION_C.lower():\n",
+    "        system_prompt = SYSTEM_PROMPT_CONVERT\n",
+    "        user_prompt = user_prompt_convert(user_input)\n",
+    "    else:\n",
+    "        return None, None\n",
+    "    \n",
+    "    return system_prompt, user_prompt\n",
+    "\n",
+    "def stream_response(user_input, model, action):\n",
+    "    system_prompt, user_prompt = set_prompts(user_input, action)\n",
+    "    if not all((system_prompt, user_prompt)):\n",
+    "        raise ValueError(\"Unknown Action\")\n",
+    "\n",
+    "    match model:\n",
+    "        case \"GPT\":\n",
+    "            yield from stream_gpt(system_prompt, user_prompt)\n",
+    "\n",
+    "        case \"Claude\":\n",
+    "            yield from stream_claude(system_prompt, user_prompt)\n",
+    "\n",
+    "        case \"Gemini\":\n",
+    "            yield from stream_gemini(system_prompt, user_prompt)\n",
+    "\n",
+    "        case \"CodeQwen\":\n",
+    "            yield from stream_code_qwen(system_prompt, user_prompt)\n",
+    "                \n",
+    "def generate_comments(python_code, selected_model):\n",
+    "    for model in MODELS_IN_USE:\n",
+    "        if model == selected_model:\n",
+    "            yield from stream_response(python_code, model, action=ACTION_A)\n",
+    "            return  # Exit the function immediately after exhausting the generator\n",
+    "    raise ValueError(\"Unknown Model\")\n",
+    "\n",
+    "def generate_tests(python_code, selected_model):\n",
+    "    for model in MODELS_IN_USE:\n",
+    "        if model == selected_model:\n",
+    "            yield from stream_response(python_code, model, action=ACTION_B)\n",
+    "            return  # Exit the function immediately after exhausting the generator\n",
+    "    raise ValueError(\"Unknown Model\")\n",
+    "\n",
+    "def convert_code(python_code, selected_model):\n",
+    "    for model in MODELS_IN_USE:\n",
+    "        if model == selected_model:\n",
+    "            yield from stream_response(python_code, model, action=ACTION_C)\n",
+    "            return  # Exit the function immediately after exhausting the generator\n",
+    "    raise ValueError(\"Unknown Model\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Running Code Functions\n",
+    "\n",
+    "- Functions that dynamically execute Python or C++ code provided as a string and captures its output.\n",
+    "- This is useful for evaluating Python or C++ code snippets and returning their results programmatically.\n",
+    "\n",
+    "### IMPORTANT WARNING:\n",
+    "The functions that dynamically execute Python or C++ code provided as input.\n",
+    "While powerful, this is extremely dangerous if the input code is not trusted.\n",
+    "Any malicious code can be executed, including:\n",
+    "  - Deleting files or directories\n",
+    "  - Stealing sensitive data (e.g., accessing environment variables or credentials)\n",
+    "  - Running arbitrary commands that compromise the system\n",
+    "\n",
+    "Sharing this notebook with this code snippet can allow attackers to exploit this functionality \n",
+    "by passing harmful code as input. \n",
+    "\n",
+    "If you share this notebook or use this function:\n",
+    "  1. Only accept input from trusted sources.\n",
+    "  2. Consider running the code in a sandboxed environment (e.g., virtual machine or container).\n",
+    "  3. Avoid using this function in publicly accessible applications or notebooks without strict validation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_python_exec(code):\n",
+    "    try:\n",
+    "        # Capture stdout using StringIO\n",
+    "        output = io.StringIO()\n",
+    "\n",
+    "        # Redirect stdout to StringIO\n",
+    "        sys.stdout = output\n",
+    "\n",
+    "        # Execute the provided Python code\n",
+    "        exec(code)\n",
+    "    finally:\n",
+    "        # Restore original stdout\n",
+    "        sys.stdout = sys.__stdout__\n",
+    "\n",
+    "    # Return the captured output\n",
+    "    return output.getvalue()\n",
+    "\n",
+    "# Improved running python function\n",
+    "def run_python(code):\n",
+    "    # Save the Python code to a file\n",
+    "    with open(TEMP_DIR / \"python_code.py\", \"w\") as python_file:\n",
+    "        python_file.write(code)\n",
+    "\n",
+    "    try:\n",
+    "        # Execute the Python code\n",
+    "        result = subprocess.run(\n",
+    "            [\"python\", str(TEMP_DIR / \"python_code.py\")],\n",
+    "            check=True, text=True, capture_output=True\n",
+    "        )\n",
+    "\n",
+    "        # Return the program's output\n",
+    "        return result.stdout\n",
+    "\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        # Handle compilation or execution errors\n",
+    "        return f\"An error occurred during execution:\\n{e.stderr}\"\n",
+    "\n",
+    "    finally:\n",
+    "        # Clean up: Delete the Python code file and executable\n",
+    "        file_path = TEMP_DIR / \"python_code.py\"\n",
+    "        if file_path.exists():\n",
+    "            file_path.unlink()\n",
+    "\n",
+    "def run_cpp(code):\n",
+    "    # Save the C++ code to a file\n",
+    "    with open(TEMP_DIR / \"cpp_code.cpp\", \"w\") as cpp_file:\n",
+    "        cpp_file.write(code)\n",
+    "\n",
+    "    try:\n",
+    "        # Compile the C++ code\n",
+    "        subprocess.run(\n",
+    "            [\"g++\", \"-o\", str(TEMP_DIR / \"cpp_code\"), str(TEMP_DIR / \"cpp_code.cpp\")],\n",
+    "            check=True, text=True, capture_output=True\n",
+    "        )\n",
+    "\n",
+    "        # Execute the compiled program\n",
+    "        result = subprocess.run(\n",
+    "            [str(TEMP_DIR / \"cpp_code\")],\n",
+    "            check=True, text=True, capture_output=True\n",
+    "        )\n",
+    "\n",
+    "        # Return the program's output\n",
+    "        return result.stdout\n",
+    "\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        # Handle compilation or execution errors\n",
+    "        error_context = \"during compilation\" if \"cpp_code.cpp\" in e.stderr else \"during execution\"\n",
+    "        return f\"An error occurred {error_context}:\\n{e.stderr}\"\n",
+    "\n",
+    "    finally:\n",
+    "        # Clean up: Delete the C++ source file and executable\n",
+    "        for filename in [\"cpp_code.cpp\", \"cpp_code\", \"cpp_code.exe\"]:\n",
+    "            file_path = TEMP_DIR / filename\n",
+    "            if file_path.exists():\n",
+    "                file_path.unlink()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Vude1jzPrgT2"
+   },
+   "source": [
+    "## Develop a User-Friendly Interface with Gradio\n",
+    "\n",
+    "- Design a clean, intuitive, and user-centric interface using Gradio.\n",
+    "- Ensure responsiveness and accessibility to provide a seamless and efficient user experience.\n",
+    "- Focus on simplicity while maintaining functionality to cater to diverse user needs.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Eh-sWFZVBb_y"
+   },
+   "outputs": [],
+   "source": [
+    "# CSS styles for customizing the appearance of the Gradio UI elements.\n",
+    "css = \"\"\"\n",
+    ".python { \n",
+    "    background-color: #377ef0; \n",
+    "    color: #ffffff; \n",
+    "    padding: 0.5em; \n",
+    "    border-radius: 5px; /* Slightly rounded corners */\n",
+    "}\n",
+    ".cpp { \n",
+    "    background-color: #00549e; \n",
+    "    color: #ffffff; \n",
+    "    padding: 0.5em; \n",
+    "    border-radius: 5px; \n",
+    "}\n",
+    ".model { \n",
+    "    background-color: #17a2b8; /* Vibrant cyan color */\n",
+    "    color: white; \n",
+    "    font-size: 1.2em; \n",
+    "    padding: 0.5em; \n",
+    "    border: none; \n",
+    "    border-radius: 5px; \n",
+    "    cursor: pointer; \n",
+    "}\n",
+    ".button { \n",
+    "    height: 4em; \n",
+    "    font-size: 1.5em; \n",
+    "    padding: 0.5em 1em; \n",
+    "    background-color: #e67e22; /* Vibrant orange */\n",
+    "    color: white; \n",
+    "    border: none; \n",
+    "    border-radius: 5px; \n",
+    "    cursor: pointer; \n",
+    "}\n",
+    ".run-button { \n",
+    "    height: 3em; \n",
+    "    font-size: 1.5em; \n",
+    "    padding: 0.5em 1em; \n",
+    "    background-color: #16a085; /* Rich teal color */\n",
+    "    color: white; \n",
+    "    border: none; \n",
+    "    border-radius: 5px; \n",
+    "    cursor: pointer; \n",
+    "}\n",
+    ".button:hover, .run-button:hover {\n",
+    "    background-color: #2c3e50; /* Dark navy for hover effect */\n",
+    "    color: #fff; \n",
+    "}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "M_v-j-B_sQHe"
+   },
+   "outputs": [],
+   "source": [
+    "# Tab to Document Code with Docstrings and Comments\n",
+    "def docs_comments_ui():\n",
+    "    with gr.Tab(\"Docstrings & Comments\"):\n",
+    "        gr.Markdown(\"\"\"\n",
+    "        ## Document Code with Docstrings and Comments\n",
+    "        This tab allows you to automatically generate docstrings and inline comments for your Python code.\n",
+    "        - Paste your Python code into the **`Python Code`** textbox.\n",
+    "        - Select your preferred model (GPT, Claude, Gemini, or CodeQwen) to process the code.\n",
+    "        - Click the **`Add Docstrings & Comments`** button to generate well-documented Python code.\n",
+    "        The generated code will appear in the **`Python Code with Docstrings and Comments`** textarea.\n",
+    "        \"\"\")\n",
+    "        with gr.Row():\n",
+    "            python = gr.Textbox(label=\"Python Code:\", lines=20, value=PYTHON_SCRIPTS[\"custom\"], elem_classes=[\"python\"])\n",
+    "            python_with_comments = gr.TextArea(label=\"Python Code with Docstrings and Comments:\", interactive=True, lines=20, elem_classes=[\"python\"])\n",
+    "        with gr.Row():\n",
+    "            python_script = gr.Dropdown(choices=list(PYTHON_SCRIPTS.keys()), label=\"Select a Python script\", value=\"custom\", elem_classes=[\"model\"])\n",
+    "            comments_btn = gr.Button(\"Add Docstrings & Comments\", elem_classes=[\"button\"])\n",
+    "            model = gr.Dropdown([\"GPT\", \"Claude\", \"Gemini\", \"CodeQwen\"], label=\"Select Model\", value=\"GPT\", elem_classes=[\"model\"])\n",
+    "            \n",
+    "        python_script.change(\n",
+    "            fn=lambda script: PYTHON_SCRIPTS[script],\n",
+    "            inputs=[python_script],\n",
+    "            outputs=[python]\n",
+    "        )\n",
+    "        \n",
+    "        comments_btn.click(\n",
+    "            fn=lambda: \"\",\n",
+    "            inputs=None,\n",
+    "            outputs=[python_with_comments]\n",
+    "        ).then(\n",
+    "            fn=generate_comments,\n",
+    "            inputs=[python, model],\n",
+    "            outputs=[python_with_comments]\n",
+    "        )\n",
+    "\n",
+    "        return python_with_comments"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "WDjJp1eXtQzY"
+   },
+   "outputs": [],
+   "source": [
+    "# Tab to Generate Comprehensive Unit Tests\n",
+    "def unit_tests_ui():\n",
+    "    with gr.Tab(\"Unit Tests\"):\n",
+    "        gr.Markdown(\"\"\"\n",
+    "        ## Generate Comprehensive Unit Tests\n",
+    "        This tab helps you create unit tests for your Python code automatically.\n",
+    "        - Paste your Python code into the **`Python Code`** textbox.\n",
+    "        - Choose a model (GPT, Claude, Gemini, or CodeQwen) to generate the unit tests.\n",
+    "        - Click the **`Generate Unit Tests`** button, and the generated unit tests will appear in the **`Python Code with Unit Tests`** textarea.\n",
+    "        Use these unit tests to ensure your code behaves as expected.\n",
+    "        \"\"\")\n",
+    "        with gr.Row():\n",
+    "            python = gr.Textbox(label=\"Python Code:\", lines=20, value=PYTHON_SCRIPTS[\"custom\"], elem_classes=[\"python\"])\n",
+    "            python_unit_tests = gr.TextArea(label=\"Python Code with Unit Tests:\", interactive=True, lines=20, elem_classes=[\"python\"])\n",
+    "        with gr.Row():\n",
+    "            python_script = gr.Dropdown(choices=list(PYTHON_SCRIPTS.keys()), label=\"Select a Python script\", value=\"custom\", elem_classes=[\"model\"])\n",
+    "            unit_tests_btn = gr.Button(\"Generate Unit Tests\", elem_classes=[\"button\"])\n",
+    "            model = gr.Dropdown([\"GPT\", \"Claude\", \"Gemini\", \"CodeQwen\"], label=\"Select Model\", value=\"GPT\", elem_classes=[\"model\"])\n",
+    "            \n",
+    "        python_script.change(\n",
+    "            fn=lambda script: PYTHON_SCRIPTS[script],\n",
+    "            inputs=[python_script],\n",
+    "            outputs=[python]\n",
+    "        )\n",
+    "        \n",
+    "        unit_tests_btn.click(\n",
+    "            fn=lambda: \"\",\n",
+    "            inputs=None,\n",
+    "            outputs=[python_unit_tests]\n",
+    "        ).then(\n",
+    "            fn=generate_tests,\n",
+    "            inputs=[python, model],\n",
+    "            outputs=[python_unit_tests]\n",
+    "        )\n",
+    "\n",
+    "        return python_unit_tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "x57SZeLi9NyV"
+   },
+   "outputs": [],
+   "source": [
+    "# Tab to Convert Python Code to C++\n",
+    "def python_to_cpp_ui():\n",
+    "    with gr.Tab(\"Python to C++\"):\n",
+    "        gr.Markdown(\"\"\"\n",
+    "        ## Convert Python Code to C++\n",
+    "        This tab facilitates the conversion of Python code into C++.\n",
+    "        - Paste your Python code into the **`Python Code`** textbox.\n",
+    "        - Select your preferred model (GPT, Claude, Gemini, or CodeQwen) to perform the conversion.\n",
+    "        - Click **`Convert to C++`** to see the equivalent C++ code in the **`C++ Code`** textbox.\n",
+    "        Additional Features:\n",
+    "        - You can execute the Python or C++ code directly using the respective **`Run Python`** or **`Run C++`** buttons.\n",
+    "        - The output will appear in the respective result text areas below.\n",
+    "        \"\"\")\n",
+    "        with gr.Row():\n",
+    "            python = gr.Textbox(label=\"Python Code:\", lines=20, value=PYTHON_SCRIPTS[\"custom\"], elem_classes=[\"python\"])\n",
+    "            cpp = gr.Textbox(label=\"C++ Code:\", interactive=True, lines=20, elem_classes=[\"cpp\"])\n",
+    "        with gr.Row():\n",
+    "            python_script = gr.Dropdown(choices=list(PYTHON_SCRIPTS.keys()), label=\"Select a Python script\", value=\"custom\", elem_classes=[\"model\"])\n",
+    "            convert_btn = gr.Button(\"Convert to C++\", elem_classes=[\"button\"])\n",
+    "            model = gr.Dropdown([\"GPT\", \"Claude\", \"Gemini\", \"CodeQwen\"], label=\"Select Model\", value=\"GPT\", elem_classes=[\"model\"])\n",
+    "        with gr.Row():\n",
+    "            run_python_btn = gr.Button(\"Run Python\", elem_classes=[\"run-button\"])\n",
+    "            run_cpp_btn = gr.Button(\"Run C++\", elem_classes=[\"run-button\"])\n",
+    "        with gr.Row():\n",
+    "            python_out = gr.TextArea(label=\"Python Result:\", lines=10, elem_classes=[\"python\"])\n",
+    "            cpp_out = gr.TextArea(label=\"C++ Result:\", lines=10, elem_classes=[\"cpp\"])\n",
+    "\n",
+    "        python_script.change(\n",
+    "            fn=lambda script: PYTHON_SCRIPTS[script],\n",
+    "            inputs=[python_script],\n",
+    "            outputs=[python]\n",
+    "        )\n",
+    "        \n",
+    "        convert_btn.click(\n",
+    "            fn=lambda: \"\",\n",
+    "            inputs=None,\n",
+    "            outputs=[cpp]\n",
+    "        ).then(\n",
+    "            fn=convert_code,\n",
+    "            inputs=[python, model],\n",
+    "            outputs=[cpp]\n",
+    "        )\n",
+    "        run_python_btn.click(run_python, inputs=[python], outputs=[python_out])\n",
+    "        run_cpp_btn.click(run_cpp, inputs=[cpp], outputs=[cpp_out])\n",
+    "\n",
+    "        return cpp, python_out, cpp_out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 645
+    },
+    "id": "n8ZdDrOrrbl-",
+    "outputId": "08350d69-569e-4947-8da1-d755e9a2678f"
+   },
+   "outputs": [],
+   "source": [
+    "# Combine the tabs into the main UI and handle tab switching\n",
+    "with gr.Blocks(css=css) as main_ui:\n",
+    "    with gr.Tabs() as tabs:\n",
+    "        comments_output = docs_comments_ui()\n",
+    "        tests_output = unit_tests_ui()\n",
+    "        cpp_output, python_out, cpp_out = python_to_cpp_ui()\n",
+    "\n",
+    "    # Reset outputs on tab switch\n",
+    "    tabs.select(\n",
+    "        fn=lambda: [\"\", \"\", \"\", \"\", \"\"],\n",
+    "        inputs=None,\n",
+    "        outputs=[comments_output, \n",
+    "                 tests_output, \n",
+    "                 cpp_output, python_out, cpp_out]\n",
+    "    )\n",
+    "\n",
+    "# Launch the app\n",
+    "main_ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

community-contributions/ems_week4_trading.ipynb

@@ -0,0 +1,528 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4a6ab9a2-28a2-445d-8512-a0dc8d1b54e9",
+   "metadata": {},
+   "source": [
+    "# Trading Decision Simulator\n",
+    "\n",
+    "## Description\n",
+    "This document provides Python functions to simulate trading decisions using a predefined API. The API includes stock tickers, historical prices, and a `Trade` class to represent buy or sell actions. Each function demonstrates a unique trading strategy, such as momentum-based trading, mean reversion, portfolio diversification, and more. These examples can serve as a foundation for developing or testing algorithmic trading systems.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e610bf56-a46e-4aff-8de1-ab49d62b1ad3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "from huggingface_hub import login, InferenceClient\n",
+    "from transformers import AutoTokenizer\n",
+    "import google.generativeai as google_genai\n",
+    "import anthropic\n",
+    "import gradio as gr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f672e1c-87e9-4865-b760-370fa605e614",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setting up environment\n",
+    "load_dotenv()\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['GOOGLE_API_KEY'] = os.getenv('GOOGLE_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['HF_TOKEN'] = os.getenv('HF_TOKEN', 'your-key-if-not-using-env')\n",
+    "os.environ['CODE_QWEN_URL'] = os.getenv('CODE_QWEN_URL', 'your-url-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8aa149ed-9298-4d69-8fe2-8f5de0f667da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initialize\n",
+    "openai = OpenAI()\n",
+    "claude = anthropic.Anthropic()\n",
+    "google_genai.configure()\n",
+    "code_qwen = InferenceClient(CODE_QWEN_URL)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cbb4319c-870f-4c04-99e2-6f54c650537a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Constants \n",
+    "MODELS = {\n",
+    "    \"GPT\": \"gpt-4o\", \n",
+    "    \"Claude\": \"claude-3-5-sonnet-20240620\", \n",
+    "    \"Gemini\": \"gemini-1.5-pro\", \n",
+    "    \"CodeQwen\": \"Qwen/CodeQwen1.5-7B-Chat\"\n",
+    "}\n",
+    "\n",
+    "MAX_TOKENS = 2000\n",
+    "\n",
+    "SYSTEM_PROMPT = \"\"\"\n",
+    "You are an advanced code generation assistant capable of creating high-quality Python code for financial trading systems. \n",
+    "Your task is to generate Python functions that simulate trading decisions based on the following API:\n",
+    "\n",
+    "API DETAILS:\n",
+    "1. tickers: A list of stock tickers (strings) representing available stocks.\n",
+    "2. prices: A dictionary where the key is a stock ticker (string) and the value is a list of historical prices (floats). The list is ordered with the most recent price first.\n",
+    "3. Trade: A class used to represent trading actions.\n",
+    "   - `Trade(ticker, quantity)` creates a trade object:\n",
+    "     - Positive `quantity` (e.g., `100`) represents buying shares.\n",
+    "     - Negative `quantity` (e.g., `-50`) represents selling/shorting shares.\n",
+    "\n",
+    "INSTRUCTIONS:\n",
+    "- You will be provided with an example Python function to demonstrate the API.\n",
+    "- Your job is to generate 5 additional Python functions, each implementing a unique trading strategy.\n",
+    "- Ensure the functions are named sequentially (e.g., `trade2()`, `trade3()`, etc.).\n",
+    "- Include clear comments explaining the logic behind each function.\n",
+    "- Return a list of `Trade` objects from each function.\n",
+    "- The output should only include the Python code. Do not include any introductions, conclusions, summaries, or additional context.\n",
+    "\n",
+    "CONSIDERATIONS FOR TRADING STRATEGIES:\n",
+    "- Momentum-based strategies (e.g., trading based on price trends).\n",
+    "- Mean reversion strategies (e.g., identifying overbought or oversold stocks).\n",
+    "- Randomized strategies (e.g., simulating stochastic decision-making).\n",
+    "- Portfolio diversification (e.g., distributing trades across multiple tickers).\n",
+    "- Risk management strategies (e.g., limiting losses or locking in profits).\n",
+    "\n",
+    "EXAMPLE FUNCTION:\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e7b3546-57aa-4c29-bc5d-f211970d04eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def user_prompt(example_function):\n",
+    "    \"\"\"\n",
+    "    Returns a user prompt for the model by appending the provided example function.\n",
+    "    \"\"\"\n",
+    "    return f\"\"\"\n",
+    "{example_function}\n",
+    "\n",
+    "TASK:\n",
+    "Based on the provided example function and API, please write 5 additional trading functions named `trade2()`, `trade3()`, and so on. Each function should implement a unique trading strategy as outlined in the system prompt. Make sure each function has clear comments explaining the logic and returns a list of `Trade` objects.\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "455728fd-be9b-4d7a-88f2-3afcf026303e",
+   "metadata": {},
+   "source": [
+    "# Trade Function Example: `trade1`\n",
+    "\n",
+    "This Python script demonstrates a simple trading strategy implemented using a provided API. The `trade1` function identifies the top-performing stock over the last 5 days based on its average price and creates a trade object to buy 100 shares of the selected stock. The function leverages the following components:\n",
+    "\n",
+    "- **`tickers`**: A list of available stock tickers.\n",
+    "- **`prices`**: A dictionary containing historical prices for each stock.\n",
+    "- **`Trade`**: A class used to represent trading actions (buy or sell).\n",
+    "- **`numpy`**: Used to calculate average prices efficiently.\n",
+    "\n",
+    "The example highlights a momentum-based strategy where the stock with the best recent performance is selected for trading.\n",
+    "\n",
+    "example:\n",
+    "```python\n",
+    "# Importing the required modules and classes for the trading simulation\n",
+    "\n",
+    "# `tickers` is a list of stock tickers (strings), representing available stocks to trade.\n",
+    "import tickers\n",
+    "\n",
+    "# `prices` is a dictionary where:\n",
+    "#   - The key is a stock ticker (string).\n",
+    "#   - The value is a list of historical prices (floats), ordered with the most recent price first.\n",
+    "import prices\n",
+    "\n",
+    "# `Trade` is a class that represents a trading decision. It takes two arguments:\n",
+    "#   - `ticker`: A string representing the stock ticker.\n",
+    "#   - `quantity`: An integer representing the number of shares to buy (positive) or sell/short (negative).\n",
+    "# Example usage:\n",
+    "#   Trade(\"IBM\", 100)  -> Buys 100 shares of IBM stock.\n",
+    "#   Trade(\"IBM\", -50)  -> Sells or shorts 50 shares of IBM stock.\n",
+    "import Trade\n",
+    "\n",
+    "# Additional modules for random number generation and numerical operations\n",
+    "import random\n",
+    "import numpy as np\n",
+    "\n",
+    "def trade1():\n",
+    "    \"\"\"\n",
+    "    Buys the top-performing stock based on its average price over the last 5 days.\n",
+    "\n",
+    "    Strategy:\n",
+    "    - Calculate the average price of the last 5 days for each stock in `tickers`.\n",
+    "    - Identify the stock with the highest average price.\n",
+    "    - Create a trade object to buy 100 shares of the identified stock.\n",
+    "    \n",
+    "    Returns:\n",
+    "        list[Trade]: A list containing a single trade object for the chosen stock.\n",
+    "    \"\"\"\n",
+    "    # Calculate the 5-day average price for each stock\n",
+    "    avg_prices = {ticker: np.mean(prices[ticker][:5]) for ticker in tickers}\n",
+    "\n",
+    "    # Find the stock ticker with the highest 5-day average price\n",
+    "    best_ticker = max(avg_prices, key=avg_prices.get)\n",
+    "\n",
+    "    # Create a trade object to buy 100 shares of the top-performing stock\n",
+    "    trade = Trade(best_ticker, 100)\n",
+    "\n",
+    "    # Return the trade as a list\n",
+    "    return [trade]\n",
+    "\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ce0fa282-4e07-4bf8-8b49-7cf7ef4a7572",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A trading function example\n",
+    "TRADING_FUNCTION_EXAMPLE = \"\"\"\n",
+    "# tickers is a list of stock tickers (strings)\n",
+    "import tickers\n",
+    "\n",
+    "# prices is a dict; the key is a ticker and the value is a list of historic prices, today first\n",
+    "import prices\n",
+    "\n",
+    "# Trade represents a decision to buy or sell a quantity of a ticker\n",
+    "# Trade(\"IBM\", 100) for a trade object representing purchasing 100 shares of IBM stock\n",
+    "# Trade(\"IBM\", -50) for a trade object representing selling or shorting 50 shares of IBM stock\n",
+    "import Trade\n",
+    "\n",
+    "import random\n",
+    "import numpy as np\n",
+    "\n",
+    "def trade1():\n",
+    "    # Buy top performing stock in the last 5 days\n",
+    "    avg_prices = {ticker: np.mean(prices[ticker][:5]) for ticker in tickers}\n",
+    "    best_ticker = max(avg_prices, key=avg_prices.get)\n",
+    "    trade = Trade(best_ticker, 100)\n",
+    "    return [trade]\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0be9f47d-5213-4700-b0e2-d444c7c738c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# UI function to trade using GPT\n",
+    "def trade_gpt(function_example):    \n",
+    "    stream = openai.chat.completions.create(\n",
+    "        model=MODELS[\"GPT\"], \n",
+    "        messages=[\n",
+    "            {\"role\": \"system\", \"content\": SYSTEM_PROMPT},\n",
+    "            {\"role\": \"user\", \"content\": user_prompt(function_example)}\n",
+    "        ], \n",
+    "        stream=True\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        reply += chunk.choices[0].delta.content or \"\"\n",
+    "        yield reply.replace(\"```python\\n\", \"\").replace(\"```\", \"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8669f56b-8314-4582-a167-78842caea131",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# UI function to trade using Claude\n",
+    "def trade_claude(function_example):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=MODELS[\"Claude\"],\n",
+    "        max_tokens=MAX_TOKENS,\n",
+    "        system=SYSTEM_PROMPT,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt(function_example)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            yield reply.replace(\"```python\\n\", \"\").replace(\"```\", \"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d27456d0-5cd3-4c2c-a12a-176d53142752",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# UI function to trade using Gemini\n",
+    "def trade_gemini(function_example):\n",
+    "    gemini = google_genai.GenerativeModel(\n",
+    "        model_name=MODELS[\"Gemini\"],\n",
+    "        system_instruction=SYSTEM_PROMPT\n",
+    "    )\n",
+    "    stream = gemini.generate_content(\n",
+    "        contents=user_prompt(function_example),\n",
+    "        stream=True\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        reply += chunk.text or \"\"\n",
+    "        yield reply.replace(\"```python\\n\", \"\").replace(\"```\", \"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a9fb676-83c3-452e-abeb-8712ebdee1d1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# UI function to trade using CodeQwen\n",
+    "def trade_code_qwen(function_example):\n",
+    "    tokenizer = AutoTokenizer.from_pretrained(MODELS[\"CodeQwen\"])\n",
+    "    model_input = tokenizer.apply_chat_template(\n",
+    "        conversation=[\n",
+    "            {\"role\": \"system\", \"content\": SYSTEM_PROMPT},\n",
+    "            {\"role\": \"user\", \"content\": user_prompt(function_example)}\n",
+    "        ],\n",
+    "        tokenize=False,\n",
+    "        add_generation_prompt=True\n",
+    "    )\n",
+    "    stream = code_qwen.text_generation(\n",
+    "        prompt=model_input,\n",
+    "        stream=True,\n",
+    "        details=True,\n",
+    "        max_new_tokens=MAX_TOKENS\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        reply += chunk.token.text or \"\"\n",
+    "        yield reply.replace(\"```python\\n\", \"\").replace(\"```\", \"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2f1ae8f5-16c8-40a0-aa18-63b617df078d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# UI function to select model from dropdown \n",
+    "def trade(trading_function, model):\n",
+    "    if model==\"GPT\":\n",
+    "        yield from trade_gpt(trading_function)\n",
+    "    elif model==\"Claude\":\n",
+    "        yield from trade_claude(trading_function)\n",
+    "    elif model==\"Gemini\":\n",
+    "        yield from trade_gemini(trading_function)\n",
+    "    elif model==\"CodeQwen\":\n",
+    "        yield from trade_code_qwen(trading_function)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown Model\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4e6af1cd-f3d9-43f0-91d9-9800d9681a77",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# CSS styling for the UI\n",
+    "UI_CSS = \"\"\"\n",
+    "#title {\n",
+    "    text-align: center;\n",
+    "    font-size: 2.5em;\n",
+    "    font-weight: bold;\n",
+    "    margin-bottom: 10px;\n",
+    "}\n",
+    "\n",
+    "#description {\n",
+    "    text-align: left;\n",
+    "    font-size: 1.2em;\n",
+    "    font-weight: bold;\n",
+    "    margin-bottom: 20px;\n",
+    "    color: #BBB;\n",
+    "}\n",
+    "\n",
+    "#simulate-btn {\n",
+    "    height: 3em;\n",
+    "    font-size: 2em !important;\n",
+    "    padding: 12px 25px !important;\n",
+    "    border-radius: 10px !important;\n",
+    "    border: none !important;\n",
+    "    cursor: pointer;\n",
+    "    transition: background-color 0.3s, transform 0.2s; /* Smooth effects */\n",
+    "}\n",
+    "\n",
+    "#simulate-btn:hover {\n",
+    "    background-color: #FFC107 !important; /* Bright golden-yellow on hover */\n",
+    "    transform: scale(1.05); /* Slight zoom effect */\n",
+    "    box-shadow: 0 6px 8px rgba(0, 0, 0, 0.25); /* Enhance shadow on hover */\n",
+    "}\n",
+    "\n",
+    "#simulate-btn:active {\n",
+    "    background-color: #B8860B !important; /* Darker goldenrod on click */\n",
+    "    transform: scale(0.95); /* Slight press effect */\n",
+    "    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2); /* Reduce shadow on click */\n",
+    "}\n",
+    "\n",
+    "#simulate-btn,\n",
+    "#trading-decisions {\n",
+    "    background-color: #DAA520 !important; /* Goldenrod color same as #simulate-btn */\n",
+    "    color: #FFFFFF !important; /* White text for contrast */\n",
+    "    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.3); /* Subtle shadow for depth */\n",
+    "}\n",
+    "\n",
+    "#trading-decisions {\n",
+    "    border: 2px solid #B8860B; /* Darker goldenrod border */\n",
+    "}\n",
+    "\n",
+    "#trading-decisions:focus {\n",
+    "    outline: none;\n",
+    "    box-shadow: 0 0 8px #FFC107; /* Bright golden-yellow glow on focus */\n",
+    "}\n",
+    "\n",
+    "#example-function, \n",
+    "#model-dropdown {\n",
+    "    background-color: #007965 !important; /* Darker and sharper teal for better contrast */\n",
+    "    color: #FFFFFF !important; /* Pure white for strong visibility */\n",
+    "    cursor: pointer;\n",
+    "    border: 2px solid #00594D; /* Deep teal border for emphasis */\n",
+    "    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.9); /* Strong shadow for depth */\n",
+    "}\n",
+    "\n",
+    "#example-function:focus,\n",
+    "#model-dropdown:focus {\n",
+    "    outline: none;\n",
+    "    box-shadow: 0 0 10px #00A389; /* Vibrant teal glow on focus */\n",
+    "}\n",
+    "\n",
+    "#model-dropdown:hover {\n",
+    "    background-color: #005F4A !important; /* Darker teal for hover effect */\n",
+    "    box-shadow: 0 6px 10px rgba(0, 0, 0, 0.4); /* Enhanced shadow on hover */\n",
+    "    border-color: #00A389; /* Change border color for hover */\n",
+    "}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f733330f-6945-4be4-a2ab-9e68c94f70f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Gradio UI\n",
+    "with gr.Blocks(css=UI_CSS) as ui:\n",
+    "    # Title for the application\n",
+    "    gr.Markdown(\"<div id='title'>🛠️ Trading Strategy Simulator</div><br>\")\n",
+    "    \n",
+    "    # Input and output section\n",
+    "    with gr.Row():\n",
+    "        trading_f = gr.Textbox(\n",
+    "            label=\"📄 Trading Function Input\",\n",
+    "            placeholder=\"Paste your trading function here...\",\n",
+    "            lines=15,\n",
+    "            value=TRADING_FUNCTION_EXAMPLE,\n",
+    "            elem_id=\"example-function\"\n",
+    "        )\n",
+    "        decisions = gr.Textbox(\n",
+    "            label=\"📊 Generated Trading Decisions\",\n",
+    "            placeholder=\"Trading decisions will appear here...\",\n",
+    "            lines=20,\n",
+    "            interactive=False,\n",
+    "            elem_id=\"trading-decisions\"\n",
+    "        )\n",
+    "    \n",
+    "    with gr.Row():\n",
+    "        # Dropdown scaled to take 1 part of the row\n",
+    "        model = gr.Dropdown(\n",
+    "            choices=MODELS,\n",
+    "            label=\"🤖 Select AI Model\",\n",
+    "            value=\"GPT\",\n",
+    "            scale=1,\n",
+    "            elem_id=\"model-dropdown\"\n",
+    "        )\n",
+    "        # Markdown for the description scaled to 2 parts of the row\n",
+    "        with gr.Column(scale=2):\n",
+    "            gr.Markdown(\n",
+    "                \"\"\"\n",
+    "                <div id='description'>\n",
+    "                This interface allows you to test and simulate trading strategies using a predefined example function.\n",
+    "                Simply input a trading function, select your preferred AI model, and see the generated trading decisions in action.<br>\n",
+    "                Experiment with different strategies to refine your approach and analyze outcomes effectively.\n",
+    "                </div>\n",
+    "                \"\"\"\n",
+    "            )\n",
+    "        # Button scaled to take 1 part of the row\n",
+    "        trade_btn = gr.Button(\n",
+    "            \"💼 Simulate Trading\",\n",
+    "            elem_id=\"simulate-btn\",\n",
+    "            scale=1\n",
+    "        )\n",
+    "\n",
+    "    # Action button behavior\n",
+    "    trade_btn.click(\n",
+    "        fn=trade, \n",
+    "        inputs=[trading_f, model], \n",
+    "        outputs=[decisions]\n",
+    "    )\n",
+    "\n",
+    "# Launch the UI in a browser\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d0ad093-425b-488e-8c3f-67f729dd9c06",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

community-contributions/unit-tests-generator.ipynb

@@ -0,0 +1,462 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Requirements\n",
+    "\n",
+    "1. Install pytest and pytest-cov library\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#!pipenv install pytest pytest-cov"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Current flow:\n",
+    "\n",
+    "1. For a python code it generates the unit tests using `pytest` library. The dashboard supports tests execution along with a coverage report. If the unit tests are fine, there is an option to save them for future use. It can happen, especially with Ollama , the tests are having a typing error. In this case the code can be edited in the right window and executed afterwards. \n",
+    "\n",
+    "2. Supports 3 models: \n",
+    "\n",
+    "- gpt-4o-mini\n",
+    "- claude-3-5-sonnet-20240620\n",
+    "- llama3.2\n",
+    "\n",
+    "It is recommended though to use other models except Ollama, my tests showed the code returned from ollama required more supervision and editing. Some generated unit tests from ollama don't provide full coverage, but still it is a good starting point for building such a tool."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "import re\n",
+    "import os\n",
+    "import sys\n",
+    "import textwrap\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import anthropic\n",
+    "import gradio as gr\n",
+    "from pathlib import Path\n",
+    "import subprocess\n",
+    "from IPython.display import Markdown"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initialization\n",
+    "\n",
+    "load_dotenv()\n",
+    "\n",
+    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "if openai_api_key:\n",
+    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
+    "else:\n",
+    "    print(\"OpenAI API Key not set\")\n",
+    "    \n",
+    "OPENAI_MODEL = \"gpt-4o-mini\"\n",
+    "CLAUDE_MODEL = \"claude-3-5-sonnet-20240620\"\n",
+    "openai = OpenAI()\n",
+    "claude = anthropic.Anthropic()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "OLLAMA_API = \"http://localhost:11434/api/chat\"\n",
+    "HEADERS = {\"Content-Type\": \"application/json\"}\n",
+    "OLLAMA_MODEL = \"llama3.2\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Code execution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "def extract_code(text):\n",
+    "    # Regular expression to find text between ``python and ``\n",
+    "    match = re.search(r\"```python(.*?)```\", text, re.DOTALL)\n",
+    "\n",
+    "    if match:\n",
+    "        code = match.group(0).strip()  # Extract and strip extra spaces\n",
+    "    else:\n",
+    "        code = \"\"\n",
+    "        print(\"No matching substring found.\")\n",
+    "\n",
+    "    return code.replace(\"```python\\n\", \"\").replace(\"```\", \"\")\n",
+    "\n",
+    "\n",
+    "def execute_coverage_report(python_interpreter=sys.executable):\n",
+    "    if not python_interpreter:\n",
+    "        raise EnvironmentError(\"Python interpreter not found in the specified virtual environment.\")\n",
+    "    \n",
+    "    command = [\"coverage\", \"run\", \"-m\", \"pytest\"]\n",
+    "\n",
+    "    try:\n",
+    "        result = subprocess.run(command, check=True, capture_output=True, text=True)\n",
+    "        print(\"Tests ran successfully!\")\n",
+    "        print(result.stdout)\n",
+    "        return result.stdout\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        print(\"Some tests failed!\")\n",
+    "        print(\"Output:\\n\", e.stdout)\n",
+    "        print(\"Errors:\\n\", e.stderr)\n",
+    "        # Extracting failed test information\n",
+    "        return e.stdout\n",
+    "\n",
+    "def save_unit_tests(code):\n",
+    "\n",
+    "    match = re.search(r\"def\\s+(\\w+)\\(\", code, re.DOTALL)\n",
+    "\n",
+    "    if match:\n",
+    "        function_name = match.group(1).strip()  # Extract and strip extra spaces\n",
+    "    else:\n",
+    "        function_name = \"\"\n",
+    "        print(\"No matching substring found.\")\n",
+    "\n",
+    "    test_code_path = Path(\"tests\")\n",
+    "    (test_code_path / f\"test_{function_name}.py\").write_text(extract_code(code))\n",
+    "    Path(\"tests\", \"test_code.py\").unlink()\n",
+    "    \n",
+    "\n",
+    "def execute_tests_in_venv(code_to_test, tests, python_interpreter=sys.executable):\n",
+    "    \"\"\"\n",
+    "    Execute the given Python code string within the specified virtual environment.\n",
+    "    \n",
+    "    Args:\n",
+    "    - code_str: str, the Python code to execute.\n",
+    "    - venv_dir: str, the directory path to the virtual environment created by pipenv.\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    if not python_interpreter:\n",
+    "        raise EnvironmentError(\"Python interpreter not found in the specified virtual environment.\")\n",
+    "\n",
+    "    # Prepare the command to execute the code\n",
+    "    code_str = textwrap.dedent(code_to_test) + \"\\n\" + extract_code(tests)\n",
+    "    test_code_path = Path(\"tests\")\n",
+    "    test_code_path.mkdir(parents=True, exist_ok=True)\n",
+    "    (test_code_path / f\"test_code.py\").write_text(code_str)\n",
+    "    command = [\"pytest\", str(test_code_path)]\n",
+    "\n",
+    "    try:\n",
+    "        result = subprocess.run(command, check=True, capture_output=True, text=True)\n",
+    "        print(\"Tests ran successfully!\")\n",
+    "        print(result.stderr)\n",
+    "        return result.stdout\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        print(\"Some tests failed!\")\n",
+    "        print(\"Output:\\n\", e.stdout)\n",
+    "        print(\"Errors:\\n\", e.stderr)\n",
+    "        # Extracting failed test information\n",
+    "        failed_tests = []\n",
+    "        for line in e.stdout.splitlines():\n",
+    "            if \"FAILED\" in line and \"::\" in line:\n",
+    "                failed_tests.append(line.strip())\n",
+    "        if failed_tests:\n",
+    "            print(\"Failed Tests:\")\n",
+    "            for test in failed_tests:\n",
+    "                print(test)\n",
+    "    \n",
+    "        return e.stdout\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Prompts and calls to the models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_message = \"\"\"You are a helpful assistant which helps developers to write unit test cases for their code.\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_user_prompt(code):\n",
+    "\n",
+    "    user_prompt = \"\"\"Test include:\n",
+    "\n",
+    "    - Valid inputs with expected results.\n",
+    "    - Inputs that test the boundaries or limits of the function's behavior.\n",
+    "    - Invalid inputs or scenarios where the function is expected to raise exceptions.\n",
+    "\n",
+    "    Structure:\n",
+    "\n",
+    "    - Begin with all necessary imports. \n",
+    "    - Do not create custom imports. \n",
+    "    - Do not insert in the response the function for the tests.\n",
+    "    - Ensure proper error handling for tests that expect exceptions.\n",
+    "    - Clearly name the test functions to indicate their purpose (e.g., test_function_name).\n",
+    "\n",
+    "    Example Structure:\n",
+    "\n",
+    "    - Use pytest.raises to validate exceptions.\n",
+    "    - Use assertions to verify correct outputs for successful and edge cases.\n",
+    "\n",
+    "    Documentation:\n",
+    "\n",
+    "    - Add docstrings explaining what each test verifies.\"\"\"\n",
+    "    user_prompt += code\n",
+    "\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_gpt(code):\n",
+    "\n",
+    "    user_prompt = get_user_prompt(code)\n",
+    "    stream = openai.chat.completions.create(\n",
+    "        model=OPENAI_MODEL,\n",
+    "        messages=[\n",
+    "            {\"role\": \"system\", \"content\": system_message},\n",
+    "            {\n",
+    "                \"role\": \"user\",\n",
+    "                \"content\": user_prompt,\n",
+    "            },\n",
+    "        ],\n",
+    "        stream=True,\n",
+    "    )\n",
+    "\n",
+    "    response = \"\"\n",
+    "    for chunk in stream:\n",
+    "        response += chunk.choices[0].delta.content or \"\"\n",
+    "        yield response\n",
+    "    \n",
+    "    return response\n",
+    "\n",
+    "def stream_ollama(code):\n",
+    "\n",
+    "    user_prompt = get_user_prompt(code)\n",
+    "    ollama_via_openai = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')\n",
+    "    stream = ollama_via_openai.chat.completions.create(\n",
+    "        model=OLLAMA_MODEL,\n",
+    "        messages=[\n",
+    "            {\"role\": \"system\", \"content\": system_message},\n",
+    "            {\n",
+    "                \"role\": \"user\",\n",
+    "                \"content\": user_prompt,\n",
+    "            },\n",
+    "        ],\n",
+    "        stream=True,\n",
+    "    )\n",
+    "\n",
+    "    response = \"\"\n",
+    "    for chunk in stream:\n",
+    "        response += chunk.choices[0].delta.content or \"\"\n",
+    "        yield response\n",
+    "    \n",
+    "    return response\n",
+    "\n",
+    "\n",
+    "def stream_claude(code):\n",
+    "    user_prompt = get_user_prompt(code)\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_message,\n",
+    "        messages=[\n",
+    "            {\n",
+    "                \"role\": \"user\",\n",
+    "                \"content\": user_prompt,\n",
+    "            }\n",
+    "        ],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            yield reply\n",
+    "            print(text, end=\"\", flush=True)\n",
+    "    return reply"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Code examples to test the inteface"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "function_to_test = \"\"\"\n",
+    "    def lengthOfLongestSubstring(s):\n",
+    "        if not isinstance(s, str):\n",
+    "            raise TypeError(\"Input must be a string\")\n",
+    "        max_length = 0\n",
+    "        substring = \"\"\n",
+    "        start_idx = 0\n",
+    "        while start_idx < len(s):\n",
+    "            string = s[start_idx:]\n",
+    "            for i, x in enumerate(string):\n",
+    "                substring += x\n",
+    "                if len(substring) == len(set((list(substring)))):\n",
+    "                    \n",
+    "                    if len(set((list(substring)))) > max_length:\n",
+    "                        \n",
+    "                        max_length = len(substring)\n",
+    "\n",
+    "            start_idx += 1\n",
+    "            substring = \"\"\n",
+    "                  \n",
+    "                \n",
+    "        return max_length\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_code = \"\"\"```python\n",
+    "import pytest\n",
+    "\n",
+    "# Unit tests using pytest\n",
+    "def test_lengthOfLongestSubstring():\n",
+    "    assert lengthOfLongestSubstring(\"abcabcbb\") == 3  # Case with repeating characters\n",
+    "    assert lengthOfLongestSubstring(\"bbbbb\") == 1    # Case with all same characters\n",
+    "    assert lengthOfLongestSubstring(\"pwwkew\") == 3    # Case with mixed characters\n",
+    "    assert lengthOfLongestSubstring(\"\") == 0           # Empty string case\n",
+    "    assert lengthOfLongestSubstring(\"abcdef\") == 6     # All unique characters\n",
+    "    assert lengthOfLongestSubstring(\"abca\") == 3       # Case with pattern and repeat\n",
+    "    assert lengthOfLongestSubstring(\"dvdf\") == 3       # Case with repeated characters separated\n",
+    "    assert lengthOfLongestSubstring(\"a\") == 1           # Case with single character\n",
+    "    assert lengthOfLongestSubstring(\"au\") == 2          # Case with unique two characters\n",
+    "```\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(code, model):\n",
+    "    if model == \"GPT\":\n",
+    "        result = stream_gpt(code)\n",
+    "    elif model == \"Claude\":\n",
+    "        result = stream_claude(code)\n",
+    "    elif model == \"Ollama\":\n",
+    "        result = stream_ollama(code)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far\n",
+    "    return result"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Gradio interface"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with gr.Blocks() as ui:\n",
+    "    gr.Markdown(\"## Write unit tests for Python code\")\n",
+    "    with gr.Row():\n",
+    "        with gr.Column(scale=1, min_width=300):\n",
+    "            python = gr.Textbox(label=\"Python code:\", value=function_to_test, lines=10)\n",
+    "            model = gr.Dropdown([\"GPT\", \"Claude\", \"Ollama\"], label=\"Select model\", value=\"GPT\")\n",
+    "            unit_tests = gr.Button(\"Write unit tests\")\n",
+    "        with gr.Column(scale=1, min_width=300):\n",
+    "            unit_tests_out = gr.TextArea(label=\"Unit tests\", value=test_code, elem_classes=[\"python\"])\n",
+    "            unit_tests_run = gr.Button(\"Run unit tests\")\n",
+    "            coverage_run = gr.Button(\"Coverage report\")\n",
+    "            save_test_run = gr.Button(\"Save unit tests\")\n",
+    "    with gr.Row():\n",
+    "        \n",
+    "        python_out = gr.TextArea(label=\"Unit tests result\", elem_classes=[\"python\"])\n",
+    "        coverage_out = gr.TextArea(label=\"Coverage report\", elem_classes=[\"python\"])\n",
+    "        \n",
+    "\n",
+    "    unit_tests.click(optimize, inputs=[python, model], outputs=[unit_tests_out])\n",
+    "    unit_tests_run.click(execute_tests_in_venv, inputs=[python, unit_tests_out], outputs=[python_out])\n",
+    "    coverage_run.click(execute_coverage_report, outputs=[coverage_out])\n",
+    "    save_test_run.click(save_unit_tests, inputs=[unit_tests_out])\n",
+    "\n",
+    "\n",
+    "ui.launch(inbrowser=True)\n",
+    "# ui.launch()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "llm_engineering-yg2xCEUG",
+   "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

community-contributions/w4_lang_converter.py

@@ -0,0 +1,346 @@
+import os
+import io
+import sys
+import re
+import subprocess
+from dotenv import load_dotenv
+from openai import OpenAI
+from anthropic import Anthropic
+import gradio as gr
+
+# Load environment variables and initialize APIs
+load_dotenv(override=True)
+openai = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+anthropic = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+MACHINE_SPEC = "MacbookPro, Apple M1 Chip"
+
+# Define global variables for HF integration
+# For HF chat-based CodeQwen model
+code_qwen = "Qwen/CodeQwen1.5-7B-Chat"
+CODE_QWEN_URL = ""
+
+
+def clean_code(code, target_language):
+    """
+    Remove markdown code fences and stray language indicators.
+    Also apply language-specific replacements.
+    """
+    raw_lines = code.splitlines()
+    cleaned_lines = []
+    for line in raw_lines:
+        if "```" in line:
+            continue
+        if line.strip().lower() in ["c", "cpp", "c++", "rust"]:
+            continue
+        cleaned_lines.append(line)
+    cleaned = "\n".join(cleaned_lines)
+    if target_language == "C":
+        cleaned = cleaned.replace("1U << 32", "(1ULL << 32)")
+    if target_language == "Rust":
+        cleaned = process_rust_code(cleaned)
+    return cleaned
+
+# Conversion prompt functions (target language-aware)
+def user_prompt_for(python_code, target_language):
+    return (
+        f"Rewrite this Python code in {target_language} with the fastest possible implementation that produces identical output. "
+        f"Respond only with {target_language} code; do not explain your work. "
+        "Pay attention to number types to ensure no int overflows. Remember to #include all necessary C++ packages such as iomanip.\n\n"
+        + python_code
+    )
+
+def messages_for(python_code, target_language):
+    system_message = (
+        f"You are an assistant that reimplements Python code in high performance {target_language} for an {MACHINE_SPEC}. "
+        f"Respond only with {target_language} code; use comments sparingly. "
+        f"The {target_language} response needs to produce an identical output in the fastest possible time."
+    )
+    return [
+        {"role": "system", "content": system_message},
+        {"role": "user", "content": user_prompt_for(python_code, target_language)},
+    ]
+
+def write_output(code, target_language):
+    """Write the converted code to a file based on target language."""
+    tag = target_language.lower() if target_language is not None else ""
+    if target_language == "C++":
+        filename = "optimized.cpp"
+    elif target_language == "C":
+        filename = "optimized.c"
+    elif target_language == "Rust":
+        filename = "optimized.rs"
+    else:
+        filename = "optimized.txt"
+    cleaned = code.replace(f"```{tag}\n", "").replace("```", "")
+    lines = cleaned.splitlines()
+    if lines and lines[0].strip().lower() in ["cpp", "c++", "c", "rust"]:
+        lines = lines[1:]
+    cleaned = "\n".join(lines)
+    cleaned = clean_code(cleaned, target_language)
+    with open(filename, "w") as f:
+        f.write(cleaned)
+    return filename
+
+# GPT integration for conversion
+def stream_gpt(python_code, target_language, model_version):
+    stream = openai.chat.completions.create(
+        model=model_version,  # Use selected GPT model version
+        messages=messages_for(python_code, target_language),
+        stream=True,
+    )
+    reply = ""
+    for chunk in stream:
+        if not hasattr(chunk, "choices") or not chunk.choices:
+            continue
+        fragment = chunk.choices[0].delta.content or ""
+        reply += fragment
+        yield reply.replace(f"```{target_language}\n", "").replace("```", "")
+
+# Claude integration for conversion
+def stream_claude(python_code, target_language, model_version):
+    prompt = user_prompt_for(python_code, target_language)
+    response = anthropic.completions.create(
+        prompt=prompt,
+        model=model_version,
+        stream=True,
+    )
+    reply = ""
+    for chunk in response:
+        fragment = chunk.get("completion", "")
+        reply += fragment
+        yield reply.replace(f"```{target_language}\n", "").replace("```", "")
+
+# Hugging Face integration functions
+def stream_code_qwen(python_code, target_language, model_version):
+    """
+    HF chat-based model using CodeQwen.
+    """
+    from transformers import AutoTokenizer
+    tokenizer = AutoTokenizer.from_pretrained(code_qwen)
+    messages = messages_for(python_code, target_language)
+    # Convert messages to chat format as expected by Qwen.
+    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    from huggingface_hub import InferenceClient
+    client = InferenceClient(CODE_QWEN_URL, token=os.getenv("HF_TOKEN"))
+    stream = client.text_generation(text, stream=True, details=True, max_new_tokens=3000)
+    result = ""
+    for r in stream:
+        result += r.token.text
+        yield result.replace(f"```{target_language}\n", "").replace("```", "")
+
+def stream_huggingface(python_code, target_language, model_version):
+    """
+    HF single-prompt model integration.
+    """
+    prompt = user_prompt_for(python_code, target_language)
+    from huggingface_hub import InferenceClient
+    client = InferenceClient(model_name=model_version, token=os.getenv("HF_TOKEN"))
+    stream = client.text_generation(prompt, stream=True, details=True, max_new_tokens=3000)
+    reply = ""
+    for chunk in stream:
+        reply += chunk.token.text
+        yield reply.replace(f"```{target_language}\n", "").replace("```", "")
+
+
+def optimize(python_code, combined_model, target_language):
+    """
+    combined_model is a string like "GPT: gpt-4o", "CLAUDE: claude-3-5-sonnet-20240620" or "HF: model_name"
+    """
+    provider, model_version = [x.strip() for x in combined_model.split(":")]
+    if provider == "GPT":
+        for partial in stream_gpt(python_code, target_language, model_version):
+            yield partial
+    elif provider == "CLAUDE":
+        for partial in stream_claude(python_code, target_language, model_version):
+            yield partial
+    elif provider == "HF":
+        if "CodeQwen" in model_version:
+            for partial in stream_code_qwen(python_code, target_language, model_version):
+                yield partial
+        else:
+            for partial in stream_huggingface(python_code, target_language, model_version):
+                yield partial
+    else:
+        raise ValueError("Unknown model provider")
+
+def execute_python(code):
+    """Execute Python code and return its output."""
+    env = {}  # Dedicated global namespace
+    try:
+        output = io.StringIO()
+        sys.stdout = output
+        exec(code, env)
+    finally:
+        sys.stdout = sys.__stdout__
+    return output.getvalue()
+
+def execute_cpp(code):
+    write_output(code, target_language="C++")
+    try:
+        compile_cmd = [
+            "clang++", "-Ofast", "-std=c++17", "-march=armv8.5-a",
+            "-mtune=apple-m1", "-mcpu=apple-m1", "-o", "optimized", "optimized.cpp"
+        ]
+        subprocess.run(compile_cmd, check=True, text=True, capture_output=True)
+        run_cmd = ["./optimized"]
+        run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)
+        return run_result.stdout
+    except subprocess.CalledProcessError as e:
+        return f"Error:\n{e.stderr}"
+
+def execute_c(code):
+    cleaned_code = clean_code(code, "C")
+    with open("optimized.c", "w") as f:
+        f.write(cleaned_code)
+    try:
+        compile_cmd = ["clang", "-O2", "-std=c11", "-o", "optimized_c", "optimized.c"]
+        subprocess.run(compile_cmd, check=True, text=True, capture_output=True)
+        run_cmd = ["./optimized_c"]
+        run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)
+        return run_result.stdout
+    except subprocess.CalledProcessError as e:
+        return f"Error:\n{e.stderr}"
+
+def process_rust_code(code):
+    code = code.replace("{:.6f}", "{:.6}")
+    code = re.sub(
+        r'(println!$begin:math:text$"Execution Time: \\{\\:\\.6\\} seconds", duration\\.as_secs_f64)(\\s*)$',
+        r'\\1())',
+        code,
+        flags=re.MULTILINE,
+    )
+    code = code.replace("max_val - min_val as u32 + 1", "((max_val - min_val + 1) as u32)")
+    code = code.replace("1 << 32", "1u64 << 32")
+    code = re.sub(r'($end:math:text$\s*as i64)\)', r'\1', code)
+    return code
+
+def execute_rust(code):
+    code = code.replace("```rust\n", "").replace("```", "")
+    lines = code.split('\n', 1)
+    if lines and lines[0].strip().lower() == "rust":
+        code = lines[1] if len(lines) > 1 else ""
+    code = process_rust_code(code)
+    with open("optimized.rs", "w") as f:
+        f.write(code)
+    try:
+        compile_cmd = ["rustc", "optimized.rs", "-O", "-o", "optimized_rust"]
+        subprocess.run(compile_cmd, check=True, text=True, capture_output=True)
+        run_cmd = ["./optimized_rust"]
+        run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)
+        return run_result.stdout
+    except subprocess.CalledProcessError as e:
+        return f"Error:\n{e.stderr}"
+
+def execute_target_code(code, target_language):
+    """Select the appropriate execution function based on target language."""
+    if target_language == "C++":
+        return execute_cpp(code)
+    elif target_language == "C":
+        return execute_c(code)
+    elif target_language == "Rust":
+        return execute_rust(code)
+    else:
+        return "Unsupported language"
+
+# Gradio UI setup
+css = """
+.python {background-color: #306998;}
+.code {background-color: #050;}
+"""
+
+def launch_ui():
+    with gr.Blocks(css=css) as ui:
+        gr.Markdown("## Convert Python Code to C/C++/Rust")
+        with gr.Row():
+            python_box = gr.Textbox(label="Python code:", value=PYTHON_HARD, lines=10)
+            converted_box = gr.Textbox(label="Converted Code:", lines=10)
+        with gr.Row():
+            model_dropdown = gr.Dropdown(
+                ["GPT: gpt-4o", "GPT: gpt-4o-mini", "CLAUDE: claude-3-5-sonnet-20240620", "CLAUDE: claude-3-haiku-20240307", "HF: CodeQwen1.5-7B-Chat", "HF: bigcode/starcoder"],
+                label="Select Model",
+                value="GPT: gpt-4o"
+            )
+            target_lang_dropdown = gr.Dropdown(
+                ["C++", "C", "Rust"],
+                label="Select target language",
+                value="C++"
+            )
+        with gr.Row():
+            convert_btn = gr.Button("Convert code")
+        with gr.Row():
+            python_run_btn = gr.Button("Run Python")
+            run_converted_btn = gr.Button("Run Converted Code")
+        with gr.Row():
+            python_out = gr.TextArea(label="Python result:", elem_classes=["python"])
+            converted_out = gr.TextArea(label="Converted Code result:", elem_classes=["code"])
+        convert_btn.click(
+            optimize,
+            inputs=[python_box, model_dropdown, target_lang_dropdown],
+            outputs=[converted_box],
+        )
+        python_run_btn.click(execute_python, inputs=[python_box], outputs=[python_out])
+        run_converted_btn.click(
+            execute_target_code,
+            inputs=[converted_box, target_lang_dropdown],
+            outputs=[converted_out],
+        )
+    ui.launch()
+
+# Example Python code blocks
+PYTHON_HARD = """
+# Support large number sizes
+def lcg(seed, a=1664525, c=1013904223, m=2**32):
+    value = seed
+    while True:
+        value = (a * value + c) % m
+        yield value
+def max_subarray_sum(n, seed, min_val, max_val):
+    lcg_gen = lcg(seed)
+    random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val for _ in range(n)]
+    max_sum = float('-inf')
+    for i in range(n):
+        current_sum = 0
+        for j in range(i, n):
+            current_sum += random_numbers[j]
+            if current_sum > max_sum:
+                max_sum = current_sum
+    return max_sum
+def total_max_subarray_sum(n, initial_seed, min_val, max_val):
+    total_sum = 0
+    lcg_gen = lcg(initial_seed)
+    for _ in range(20):
+        seed = next(lcg_gen)
+        total_sum += max_subarray_sum(n, seed, min_val, max_val)
+    return total_sum
+n = 10000
+initial_seed = 42
+min_val = -10
+max_val = 10
+import time
+start_time = time.time()
+result = total_max_subarray_sum(n, initial_seed, min_val, max_val)
+end_time = time.time()
+print("Total Maximum Subarray Sum (20 runs):", result)
+print("Execution Time: {:.6f} seconds".format(end_time - start_time))
+"""
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(
+        description="Single script with multiple executable sections and target language support"
+    )
+    parser.add_argument(
+        "--mode",
+        choices=["direct", "ui"],
+        default="ui",
+        help="Run direct conversion or launch Gradio UI",
+    )
+    args = parser.parse_args()
+
+    if args.mode == "direct":
+        print("\nExecuting Python code (PYTHON_HARD)...")
+        exec(PYTHON_HARD)
+        for partial in optimize(PYTHON_HARD, "GPT: gpt-4o", "C++"):
+            print(partial, end="")
+    elif args.mode == "ui":
+        launch_ui()

community-contributions/week4-day4-challenge.ipynb

@@ -0,0 +1,689 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4a6ab9a2-28a2-445d-8512-a0dc8d1b54e9",
+   "metadata": {},
+   "source": [
+    "# Code Generator\n",
+    "\n",
+    "The requirement: use an Open Source model to generate high performance C++ code from Python code\n",
+    "\n",
+    "To replicate this, you'll need to set up a HuggingFace endpoint as I do in the video. It's simple to do, and it's quite satisfying to see the results!\n",
+    "\n",
+    "It's also an important part of your learning; this is the first example of deploying an open source model to be behind an API. We'll return to this in Week 8, but this should plant a seed in your mind for what's involved in moving open source models into production."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22e1567b-33fd-49e7-866e-4b635d15715a",
+   "metadata": {},
+   "source": [
+    "<table style=\"margin: 0; text-align: left;\">\n",
+    "    <tr>\n",
+    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
+    "            <img src=\"../../important.jpg\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
+    "        </td>\n",
+    "        <td>\n",
+    "            <h1 style=\"color:#900;\">Important - Pause Endpoints when not in use</h1>\n",
+    "            <span style=\"color:#900;\">\n",
+    "            If you do decide to use HuggingFace endpoints for this project, you should stop or pause the endpoints when you are done to avoid accruing unnecessary running cost. The costs are very low as long as you only run the endpoint when you're using it. Navigate to the HuggingFace endpoint UI <a href=\"https://ui.endpoints.huggingface.co/\">here,</a> open your endpoint, and click Pause to put it on pause so you no longer pay for it.  \n",
+    "Many thanks to student John L. for raising this.\n",
+    "<br/><br/>\n",
+    "In week 8 we will use Modal instead of HuggingFace endpoints; with Modal you only pay for the time that you use it and you should get free credits.\n",
+    "            </span>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "e610bf56-a46e-4aff-8de1-ab49d62b1ad3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import io\n",
+    "import sys\n",
+    "import json\n",
+    "import requests\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import google.generativeai\n",
+    "import anthropic\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "import gradio as gr\n",
+    "import subprocess\n",
+    "import platform"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "4f672e1c-87e9-4865-b760-370fa605e614",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv()\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['HF_TOKEN'] = os.getenv('HF_TOKEN', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "8aa149ed-9298-4d69-8fe2-8f5de0f667da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize\n",
+    "\n",
+    "openai = OpenAI()\n",
+    "claude = anthropic.Anthropic()\n",
+    "OPENAI_MODEL = \"gpt-4o\"\n",
+    "CLAUDE_MODEL = \"claude-3-5-sonnet-20240620\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 166,
+   "id": "6896636f-923e-4a2c-9d6c-fac07828a201",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the different actions available\n",
+    "\n",
+    "prompt_options = [\"Convert to C\", \"Add comments\", \"Write unit tests\"]\n",
+    "\n",
+    "system_prompts = {\n",
+    "    prompt_options[0]:  \"\"\"\n",
+    "You are an assistant that reimplements Python code in high performance C++.\n",
+    "Respond only with C++ code; use comments sparingly and do not provide any explanation other than occasional comments.\n",
+    "The C++ response needs to produce an identical output in the fastest possible time. Keep implementations of random number generators identical so that results match exactly.\n",
+    "\"\"\",\n",
+    "    \n",
+    "    prompt_options[1]:  \"\"\"\n",
+    "You are an assistant that adds succinct comments and docstrings to Python code. Respond only with valid Python code.\n",
+    "\"\"\",\n",
+    "    \n",
+    "    prompt_options[2]:  \"\"\"\n",
+    "You are an assistant that creates unit tests for Python code. Respond only with valid Python code.\n",
+    "\"\"\"\n",
+    "}\n",
+    "\n",
+    "user_prompts = {\n",
+    "    prompt_options[0]: \"\"\"\n",
+    "Rewrite this Python code in C++ with the fastest possible implementation that produces identical output in the least time. \n",
+    "Respond only with C++ code; do not explain your work other than a few comments.\n",
+    "Pay attention to number types to ensure no int overflows. Remember to #include all necessary C++ packages such as iomanip.\\n\\n\n",
+    "\"\"\",\n",
+    "    \n",
+    "    prompt_options[1]:  \"\"\"\n",
+    "Keep this Python code but insert appropriate comments and docstrings.\n",
+    "\"\"\",\n",
+    "    \n",
+    "    prompt_options[2]:  \"\"\"\n",
+    "Create unit tests for this Python code.\n",
+    "\"\"\"\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 157,
+   "id": "a1cbb778-fa57-43de-b04b-ed523f396c38",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python_sample_options = [\"Hello, World\", \"Calculate pi\", \"Kadane's Algorithm\", \"Sieve of Eratosthenes\"]\n",
+    "\n",
+    "python_code_samples = {\n",
+    "    python_sample_options[0]: \"\"\"\n",
+    "import time\n",
+    "\n",
+    "start_time = time.time()\n",
+    "\n",
+    "print(\"Hello, world\")\n",
+    "\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n",
+    "\"\"\",\n",
+    "\n",
+    "    python_sample_options[1]:  \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def calculate(iterations, param1, param2):\n",
+    "    result = 1.0\n",
+    "    for i in range(1, iterations+1):\n",
+    "        j = i * param1 - param2\n",
+    "        result -= (1/j)\n",
+    "        j = i * param1 + param2\n",
+    "        result += (1/j)\n",
+    "    return result\n",
+    "\n",
+    "start_time = time.time()\n",
+    "result = calculate(100_000_000, 4, 1) * 4\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(f\"Result: {result:.12f}\")\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n",
+    "\"\"\",\n",
+    "\n",
+    "    python_sample_options[2]:  \"\"\"\n",
+    "# Be careful to support large number sizes\n",
+    "\n",
+    "def lcg(seed, a=1664525, c=1013904223, m=2**32):\n",
+    "    value = seed\n",
+    "    while True:\n",
+    "        value = (a * value + c) % m\n",
+    "        yield value\n",
+    "        \n",
+    "def max_subarray_sum(n, seed, min_val, max_val):\n",
+    "    lcg_gen = lcg(seed)\n",
+    "    random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val for _ in range(n)]\n",
+    "    max_sum = float('-inf')\n",
+    "    for i in range(n):\n",
+    "        current_sum = 0\n",
+    "        for j in range(i, n):\n",
+    "            current_sum += random_numbers[j]\n",
+    "            if current_sum > max_sum:\n",
+    "                max_sum = current_sum\n",
+    "    return max_sum\n",
+    "\n",
+    "def total_max_subarray_sum(n, initial_seed, min_val, max_val):\n",
+    "    total_sum = 0\n",
+    "    lcg_gen = lcg(initial_seed)\n",
+    "    for _ in range(20):\n",
+    "        seed = next(lcg_gen)\n",
+    "        total_sum += max_subarray_sum(n, seed, min_val, max_val)\n",
+    "    return total_sum\n",
+    "\n",
+    "# Parameters\n",
+    "n = 10000         # Number of random numbers\n",
+    "initial_seed = 42 # Initial seed for the LCG\n",
+    "min_val = -10     # Minimum value of random numbers\n",
+    "max_val = 10      # Maximum value of random numbers\n",
+    "\n",
+    "# Timing the function\n",
+    "import time\n",
+    "start_time = time.time()\n",
+    "result = total_max_subarray_sum(n, initial_seed, min_val, max_val)\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(\"Total Maximum Subarray Sum (20 runs):\", result)\n",
+    "print(\"Execution Time: {:.6f} seconds\".format(end_time - start_time))\n",
+    "\"\"\",\n",
+    "\n",
+    "    python_sample_options[3]:  \"\"\"\n",
+    "import time\n",
+    "start_time = time.time()\n",
+    "stop_at=100_000_000\n",
+    "prime = [True] * (stop_at + 1)\n",
+    "p = 2\n",
+    "\n",
+    "while p * p <= stop_at:\n",
+    "    # If prime[p] is True, then p is a prime\n",
+    "    if prime[p]:\n",
+    "        # Mark all multiples of p as non-prime\n",
+    "        for i in range(p * p, stop_at + 1, p):\n",
+    "            prime[i] = False\n",
+    "    p += 1\n",
+    "\n",
+    "# Collect all prime numbers\n",
+    "primes = [p for p in range(2, stop_at + 1) if prime[p]]\n",
+    "\n",
+    "end_time = time.time()\n",
+    "print(\"Maximum prime:, {:,}\".format(primes[-1]))\n",
+    "print(\"Execution Time: {:.6f} seconds\".format(end_time - start_time))\n",
+    "\"\"\"\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "e33565c0-cba8-46d3-a0c5-9440d7fe4d2c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a complete user prompt given descriptive text plus the python code to convert.\n",
+    "def create_user_prompt(user_prompt, python_code):\n",
+    "    return user_prompt + '\\n' + python_code\n",
+    "\n",
+    "# Create the list the GPT. Claude doesn't need this because it does not combine the system and user prompts.\n",
+    "def create_messages_for_gpt(system_prompt, user_prompt):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_prompt},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "id": "71e1ba8c-5b05-4726-a9f3-8d8c6257350b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def write_cpp_file(filename_base, cpp_code):\n",
+    "    code_to_write = cpp.replace(\"```cpp\",\"\").replace(\"```\",\"\")\n",
+    "    with open(f\"{filename_base}.cpp\", \"w\") as f:\n",
+    "        f.write(code)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 164,
+   "id": "e7d2fea8-74c6-4421-8f1e-0e76d5b201b9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is where additional models can be easily added. \n",
+    "# Just update the model_options list, add a streaming function, and update the call_llm function. \n",
+    "\n",
+    "model_options = [\"GPT\", \"Claude\"]\n",
+    "# model_options = [\"GPT\", \"Claude\", \"CodeQwen\"]\n",
+    "default_model = model_options[0]\n",
+    "\n",
+    "def stream_gpt(system_prompt, user_prompt, python_code):    \n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=create_messages_for_gpt(system_prompt, create_user_prompt(user_prompt, python_code)), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        yield reply.replace('```cpp\\n','').replace('```','')\n",
+    "\n",
+    "def stream_claude(system_prompt, user_prompt, python_code):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_prompt,\n",
+    "        messages=[{\"role\": \"user\", \"content\": create_user_prompt(user_prompt, python_code)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            yield reply.replace('```cpp\\n','').replace('```','')\n",
+    "\n",
+    "def call_llm(system_prompt, user_prompt, python_code, model):\n",
+    "    if model==\"GPT\":\n",
+    "        result = stream_gpt(system_prompt, user_prompt, python_code)\n",
+    "    elif model==\"Claude\":\n",
+    "        result = stream_claude(system_prompt, user_prompt, python_code)\n",
+    "    # elif model==\"CodeQwen\":\n",
+    "    #     result = stream_code_qwen(python)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bb8c5b4e-ec51-4f21-b3f8-6aa94fede86d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import login, InferenceClient\n",
+    "from transformers import AutoTokenizer\n",
+    "\n",
+    "code_qwen = \"Qwen/CodeQwen1.5-7B-Chat\"\n",
+    "code_gemma = \"google/codegemma-7b-it\"\n",
+    "CODE_QWEN_URL = \"https://h1vdol7jxhje3mpn.us-east-1.aws.endpoints.huggingface.cloud\"\n",
+    "CODE_GEMMA_URL = \"https://c5hggiyqachmgnqg.us-east-1.aws.endpoints.huggingface.cloud\"\n",
+    "\n",
+    "hf_token = os.environ['HF_TOKEN']\n",
+    "login(hf_token, add_to_git_credential=True)\n",
+    "\n",
+    "def stream_code_qwen(python):\n",
+    "    tokenizer = AutoTokenizer.from_pretrained(code_qwen)\n",
+    "    messages = messages_for(python)\n",
+    "    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+    "    client = InferenceClient(CODE_QWEN_URL, token=hf_token)\n",
+    "    stream = client.text_generation(text, stream=True, details=True, max_new_tokens=3000)\n",
+    "    result = \"\"\n",
+    "    for r in stream:\n",
+    "        result += r.token.text\n",
+    "        yield result    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "id": "19bf2bff-a822-4009-a539-f003b1651383",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_python(code):\n",
+    "    try:\n",
+    "        output = io.StringIO()\n",
+    "        sys.stdout = output\n",
+    "        exec(code)\n",
+    "    finally:\n",
+    "        sys.stdout = sys.__stdout__\n",
+    "    return output.getvalue()\n",
+    "\n",
+    "def execute_cpp(code):\n",
+    "    write_output(code)\n",
+    "    try:\n",
+    "        compile_result = subprocess.run(compiler_cmd[2], check=True, text=True, capture_output=True)\n",
+    "        run_cmd = [\"./optimized\"]\n",
+    "        run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)\n",
+    "        return run_result.stdout\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        return f\"An error occurred:\\n{e.stderr}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "id": "4ba311ec-c16a-4fe0-946b-4b940704cf65",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def select_python_sample(python_sample):\n",
+    "    if python_sample in python_sample_options:\n",
+    "        return python_code_samples[python_sample]\n",
+    "    else:\n",
+    "        return next(iter(donedone.values()), \"# Type in your Python program here\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "id": "e42286bc-085c-45dc-b101-234308e58269",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import platform\n",
+    "\n",
+    "VISUAL_STUDIO_2022_TOOLS = \"C:\\\\Program Files\\\\Microsoft Visual Studio\\\\2022\\\\Community\\\\Common7\\Tools\\\\VsDevCmd.bat\"\n",
+    "VISUAL_STUDIO_2019_TOOLS = \"C:\\\\Program Files (x86)\\\\Microsoft Visual Studio\\\\2019\\\\BuildTools\\\\Common7\\\\Tools\\\\VsDevCmd.bat\"\n",
+    "\n",
+    "simple_cpp = \"\"\"\n",
+    "#include <iostream>\n",
+    "\n",
+    "int main() {\n",
+    "    std::cout << \"Hello\";\n",
+    "    return 0;\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "def run_cmd(command_to_run):\n",
+    "    try:\n",
+    "        run_result = subprocess.run(command_to_run, check=True, text=True, capture_output=True)\n",
+    "        return run_result.stdout if run_result.stdout else \"SUCCESS\"\n",
+    "    except:\n",
+    "        return \"\"\n",
+    "\n",
+    "def c_compiler_cmd(filename_base):\n",
+    "    my_platform = platform.system()\n",
+    "    my_compiler = []\n",
+    "\n",
+    "    try:\n",
+    "        with open(\"simple.cpp\", \"w\") as f:\n",
+    "            f.write(simple_cpp)\n",
+    "            \n",
+    "        if my_platform == \"Windows\":\n",
+    "            if os.path.isfile(VISUAL_STUDIO_2022_TOOLS):\n",
+    "                if os.path.isfile(\"./simple.exe\"):\n",
+    "                    os.remove(\"./simple.exe\")\n",
+    "                compile_cmd = [\"cmd\", \"/c\", VISUAL_STUDIO_2022_TOOLS, \"&\", \"cl\", \"simple.cpp\"]\n",
+    "                if run_cmd(compile_cmd):\n",
+    "                    if run_cmd([\"./simple.exe\"]) == \"Hello\":\n",
+    "                        my_compiler = [\"Windows\", \"Visual Studio 2022\", [\"cmd\", \"/c\", VISUAL_STUDIO_2022_TOOLS, \"&\", \"cl\", f\"{filename_base}.cpp\"]]\n",
+    "        \n",
+    "            if not my_compiler:\n",
+    "                if os.path.isfile(VISUAL_STUDIO_2019_TOOLS):\n",
+    "                    if os.path.isfile(\"./simple.exe\"):\n",
+    "                        os.remove(\"./simple.exe\")\n",
+    "                    compile_cmd = [\"cmd\", \"/c\", VISUAL_STUDIO_2019_TOOLS, \"&\", \"cl\", \"simple.cpp\"]\n",
+    "                    if run_cmd(compile_cmd):\n",
+    "                        if run_cmd([\"./simple.exe\"]) == \"Hello\":\n",
+    "                            my_compiler = [\"Windows\", \"Visual Studio 2019\", [\"cmd\", \"/c\", VISUAL_STUDIO_2019_TOOLS, \"&\", \"cl\", f\"{filename_base}.cpp\"]]\n",
+    "    \n",
+    "            if not my_compiler:\n",
+    "                my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "                \n",
+    "        elif my_platform == \"Linux\":\n",
+    "            if os.path.isfile(\"./simple\"):\n",
+    "                os.remove(\"./simple\")\n",
+    "            compile_cmd = [\"g++\", \"simple.cpp\", \"-o\", \"simple\"]\n",
+    "            if run_cmd(compile_cmd):\n",
+    "                if run_cmd([\"./simple\"]) == \"Hello\":\n",
+    "                    my_compiler = [\"Linux\", \"GCC (g++)\", [\"g++\", f\"{filename_base}.cpp\", \"-o\", f\"{filename_base}\" ]]\n",
+    "    \n",
+    "            if not my_compiler:\n",
+    "                if os.path.isfile(\"./simple\"):\n",
+    "                    os.remove(\"./simple\")\n",
+    "                compile_cmd = [\"clang++\", \"simple.cpp\", \"-o\", \"simple\"]\n",
+    "                if run_cmd(compile_cmd):\n",
+    "                    if run_cmd([\"./simple\"]) == \"Hello\":\n",
+    "                        my_compiler = [\"Linux\", \"Clang++\", [\"clang++\", f\"{filename_base}.cpp\", \"-o\", f\"{filename_base}\"]]\n",
+    "        \n",
+    "            if not my_compiler:\n",
+    "                my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "    \n",
+    "        elif my_platform == \"Darwin\":\n",
+    "            if os.path.isfile(\"./simple\"):\n",
+    "                os.remove(\"./simple\")\n",
+    "            compile_cmd = [\"clang++\", \"-Ofast\", \"-std=c++17\", \"-march=armv8.5-a\", \"-mtune=apple-m1\", \"-mcpu=apple-m1\", \"-o\", \"simple\", \"simple.cpp\"]\n",
+    "            if run_cmd(compile_cmd):\n",
+    "                if run_cmd([\"./simple\"]) == \"Hello\":\n",
+    "                    my_compiler = [\"Macintosh\", \"Clang++\", [\"clang++\", \"-Ofast\", \"-std=c++17\", \"-march=armv8.5-a\", \"-mtune=apple-m1\", \"-mcpu=apple-m1\", \"-o\", f\"{filename_base}\", f\"{filename_base}.cpp\"]]\n",
+    "    \n",
+    "            if not my_compiler:\n",
+    "                my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "    except:\n",
+    "        my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "        \n",
+    "    if my_compiler:\n",
+    "        return my_compiler\n",
+    "    else:\n",
+    "        return [\"Unknown\", \"Unavailable\", []]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 167,
+   "id": "f9ca2e6f-60c1-4e5f-b570-63c75b2d189b",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7916/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 167,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "css = \"\"\"\n",
+    ".python {background-color: #306998;}\n",
+    ".cpp {background-color: #050;}\n",
+    "\"\"\"\n",
+    "\n",
+    "model = default_model\n",
+    "selected_tab = prompt_options[0]\n",
+    "\n",
+    "# Determine the C (C++, really) compiler to use based on the platform\n",
+    "compiler_cmd = c_compiler_cmd(\"optimized\")\n",
+    "\n",
+    "def any_tab_on_select(evt: gr.SelectData):\n",
+    "    global selected_tab\n",
+    "    selected_tab = evt.value\n",
+    "\n",
+    "def reset_prompts():\n",
+    "    return system_prompts[selected_tab], user_prompts[selected_tab]\n",
+    "\n",
+    "def change_python_sample(python_sample, python_code):\n",
+    "    if not python_sample == \"Custom\":\n",
+    "        if python_sample in python_sample_options:\n",
+    "            return python_code_samples[python_sample]\n",
+    "        else:\n",
+    "            return python_code\n",
+    "    else:\n",
+    "        return python_code\n",
+    "\n",
+    "def change_python_sample_to_custom():\n",
+    "    return \"Custom\"\n",
+    "\n",
+    "# Display the interface\n",
+    "with gr.Blocks(css=css) as ui:\n",
+    "    with gr.Tab(prompt_options[0]) as first_tab:\n",
+    "        gr.Markdown(\"# \" + prompt_options[0])\n",
+    "        with gr.Group():\n",
+    "            with gr.Row():\n",
+    "                first_system_prompt_txt = gr.Textbox(label=\"System prompt\", value=system_prompts[prompt_options[0]], lines=10, interactive=True )\n",
+    "                first_user_prompt_txt = gr.Textbox(label=\"User prompt\", value=user_prompts[prompt_options[0]], lines=10, interactive=True )\n",
+    "            with gr.Row():\n",
+    "                first_reset_prompts_btn = gr.Button(\"Reset prompts\")\n",
+    "        with gr.Row():\n",
+    "            with gr.Column():\n",
+    "                first_sample_program_rad = gr.Radio(python_sample_options + [\"Custom\"], label=\"Sample program\", value=python_sample_options[0])\n",
+    "                first_python_code_txt = gr.Textbox(label=\"Python code:\", value=python_code_samples[python_sample_options[0]], lines=10, interactive=True)\n",
+    "            with gr.Column():\n",
+    "                first_model_drp = gr.Dropdown(model_options, label=\"Select model\", value=default_model, interactive=True)\n",
+    "                first_convert_btn = gr.Button(\"Convert code\", interactive=True)\n",
+    "                first_cpp_txt = gr.Textbox(label=\"C++ code:\", lines=10, interactive=True)\n",
+    "        with gr.Row():\n",
+    "            with gr.Column():\n",
+    "                with gr.Group():\n",
+    "                    first_python_run_btn = gr.Button(\"Run Python\", interactive=True)\n",
+    "                    first_python_out_txt = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "            with gr.Column():\n",
+    "                with gr.Group():\n",
+    "                    if not compiler_cmd[1] == \"Unavailable\":\n",
+    "                        first_cpp_run_btn = gr.Button(\"Run C++\")\n",
+    "                    else:\n",
+    "                        first_cpp_run_btn = gr.Button(\"No compiler to run C++\", interactive=False)\n",
+    "                    first_cpp_out_txt = gr.TextArea(label=\"C++ result:\", elem_classes=[\"cpp\"])\n",
+    "                    first_architecture_rad = gr.Radio([compiler_cmd[0]], label=\"Architecture\", interactive=False, value=compiler_cmd[0])\n",
+    "                    first_compiler_rad = gr.Radio([compiler_cmd[1]], label=\"Compiler\", interactive=False, value=compiler_cmd[1])\n",
+    "            \n",
+    "    with gr.Tab(prompt_options[1]) as second_tab:\n",
+    "        gr.Markdown(\"# \" + prompt_options[1])\n",
+    "        with gr.Group():\n",
+    "            with gr.Row():\n",
+    "                second_system_prompt_txt = gr.Textbox(label=\"System prompt\", value=system_prompts[prompt_options[1]], lines=10, interactive=True )\n",
+    "                second_user_prompt_txt = gr.Textbox(label=\"User prompt\", value=user_prompts[prompt_options[1]], lines=10, interactive=True )\n",
+    "            with gr.Row():\n",
+    "                second_reset_prompts_btn = gr.Button(\"Reset prompts\")\n",
+    "        with gr.Row():\n",
+    "            with gr.Column():\n",
+    "                second_sample_program_rad = gr.Radio(python_sample_options + [\"Custom\"], label=\"Sample program\", value=python_sample_options[1])\n",
+    "                second_python_code_txt = gr.Textbox(label=\"Python code:\", value=python_code_samples[python_sample_options[1]], lines=10)\n",
+    "            with gr.Column():\n",
+    "                second_model_drp = gr.Dropdown(model_options, label=\"Select model\", value=default_model)\n",
+    "                second_comment_btn = gr.Button(\"Comment code\")\n",
+    "                second_python_code_comments_txt = gr.Textbox(label=\"Commented code\", lines=20)\n",
+    "\n",
+    "                    \n",
+    "    with gr.Tab(prompt_options[2]) as third_tab:\n",
+    "        gr.Markdown(\"# \" + prompt_options[2])\n",
+    "        with gr.Group():\n",
+    "            with gr.Row():\n",
+    "                third_system_prompt_txt = gr.Textbox(label=\"System prompt\", value=system_prompts[prompt_options[2]], lines=10, interactive=True )\n",
+    "                third_user_prompt_txt = gr.Textbox(label=\"User prompt\", value=user_prompts[prompt_options[2]], lines=10, interactive=True )\n",
+    "            with gr.Row():\n",
+    "                third_reset_prompts_btn = gr.Button(\"Reset prompts\")\n",
+    "        with gr.Row():\n",
+    "            with gr.Column():\n",
+    "                third_sample_program_rad = gr.Radio(python_sample_options + [\"Custom\"], label=\"Sample program\", value=python_sample_options[1])\n",
+    "                third_python_code_txt = gr.Textbox(label=\"Python code:\", value=python_code_samples[python_sample_options[1]], lines=10)\n",
+    "            with gr.Column():\n",
+    "                third_model_drp = gr.Dropdown(model_options, label=\"Select model\", value=default_model)\n",
+    "                third_unit_test_btn = gr.Button(\"Create unit tests\")\n",
+    "                third_python_unit_tests_txt = gr.Textbox(label=\"Unit tests\", lines=20)\n",
+    "\n",
+    "    first_tab.select(any_tab_on_select)\n",
+    "    second_tab.select(any_tab_on_select)\n",
+    "    third_tab.select(any_tab_on_select)\n",
+    "    \n",
+    "    first_reset_prompts_btn.click(reset_prompts, outputs=[first_system_prompt_txt, first_user_prompt_txt])\n",
+    "    second_reset_prompts_btn.click(reset_prompts, outputs=[second_system_prompt_txt, second_user_prompt_txt])\n",
+    "    third_reset_prompts_btn.click(reset_prompts, outputs=[third_system_prompt_txt, third_user_prompt_txt])\n",
+    "\n",
+    "    first_sample_program_rad.input(change_python_sample, inputs=[first_sample_program_rad, first_python_code_txt], outputs=[first_python_code_txt])\n",
+    "    first_python_code_txt.input(change_python_sample_to_custom, inputs=[], outputs=[first_sample_program_rad])\n",
+    "    first_convert_btn.click(call_llm, inputs=[first_system_prompt_txt, first_user_prompt_txt, first_python_code_txt, first_model_drp], outputs=[first_cpp_txt])\n",
+    "    first_python_run_btn.click(execute_python, inputs=[first_python_code_txt], outputs=[first_python_out_txt])\n",
+    "    first_cpp_run_btn.click(execute_cpp, inputs=[first_cpp_txt], outputs=[first_cpp_out_txt])\n",
+    "\n",
+    "    second_sample_program_rad.input(change_python_sample, inputs=[second_sample_program_rad, second_python_code_txt], outputs=[second_python_code_txt])\n",
+    "    second_python_code_txt.input(change_python_sample_to_custom, inputs=[], outputs=[second_sample_program_rad])\n",
+    "    second_comment_btn.click(call_llm, inputs=[second_system_prompt_txt, second_user_prompt_txt, second_python_code_txt, second_model_drp], outputs=[second_python_code_comments_txt])\n",
+    "\n",
+    "    third_sample_program_rad.input(change_python_sample, inputs=[third_sample_program_rad, third_python_code_txt], outputs=[third_python_code_txt])\n",
+    "    third_python_code_txt.input(change_python_sample_to_custom, inputs=[], outputs=[second_sample_program_rad])\n",
+    "    third_unit_test_btn.click(call_llm, inputs=[third_system_prompt_txt, third_user_prompt_txt, third_python_code_txt, third_model_drp], outputs=[third_python_unit_tests_txt])\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 152,
+   "id": "9d0ad093-425b-488e-8c3f-67f729dd9c06",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "\n",
+    "start_time = time.time()\n",
+    "    \n",
+    "print(\"Hello, world\")\n",
+    "    \n",
+    "end_time = time.time()\n",
+    "    \n",
+    "\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")"
+   ]
+  }
+ ],
+ "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

community-contributions/week4-day5-code-commenter.ipynb

@@ -0,0 +1,401 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4a6ab9a2-28a2-445d-8512-a0dc8d1b54e9",
+   "metadata": {},
+   "source": [
+    "# Code Commenter\n",
+    "\n",
+    "The requirement: use an LLM to generate docstring and comments for Python code\n",
+    "\n",
+    "This is my week 4 day 5 project. \n",
+    "\n",
+    "Note: I used gpt to find out the most effective system and user prompt (very effective). I also decided not to use the open source models due to inference api costs with HF"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e610bf56-a46e-4aff-8de1-ab49d62b1ad3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import io\n",
+    "import sys\n",
+    "import json\n",
+    "import requests\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import google.generativeai\n",
+    "import anthropic\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "import gradio as gr\n",
+    "import subprocess"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4f672e1c-87e9-4865-b760-370fa605e614",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv()\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "google_api_key = os.getenv('GOOGLE_API_KEY')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "8aa149ed-9298-4d69-8fe2-8f5de0f667da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize\n",
+    "\n",
+    "openai = OpenAI()\n",
+    "claude = anthropic.Anthropic()\n",
+    "google.generativeai.configure()\n",
+    "\n",
+    "OPENAI_MODEL = \"gpt-4o\"\n",
+    "CLAUDE_MODEL = \"claude-3-5-sonnet-20240620\"\n",
+    "GOOGLE_MODEL = \"gemini-1.5-pro\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "6896636f-923e-4a2c-9d6c-fac07828a201",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_message = \"You are a Python code assistant. Your task is to analyze Python code and generate high-quality, concise comments and docstrings. Follow these guidelines:\"\n",
+    "system_message += \"Docstrings: Add a docstring for every function, class, and module. Describe the purpose of the function/class, its parameters, and its return value. Keep the description concise but informative, using proper Python docstring conventions (e.g., Google, NumPy, or reStructuredText format).\"\n",
+    "system_message += \"Inline Comments: Add inline comments only where necessary to clarify complex logic, important steps, or non-obvious behavior. Avoid commenting on obvious operations like x += 1 unless it involves a nuanced concept. Keep comments short, clear, and relevant.\"\n",
+    "system_message += \"General Instructions: Maintain consistency in style and tone. Use technical terminology where appropriate, but ensure clarity for someone with intermediate Python knowledge. Do not over-explain or add redundant comments for self-explanatory code. Follow PEP 257 and PEP 8 standards for style and formatting.\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "8e7b3546-57aa-4c29-bc5d-f211970d04eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def user_prompt_for(python):\n",
+    "    user_prompt = \"Analyze the following Python code and enhance it by adding high-quality, concise docstrings and comments. \"\n",
+    "    user_prompt += \"Ensure all functions, classes, and modules have appropriate docstrings describing their purpose, parameters, and return values. \"\n",
+    "    user_prompt += \"Add inline comments only for complex or non-obvious parts of the code. \"\n",
+    "    user_prompt += \"Follow Python's PEP 257 and PEP 8 standards for documentation and formatting. \"\n",
+    "    user_prompt += \"Do not modify the code itself; only add annotations.\\n\\n\"\n",
+    "    user_prompt += python\n",
+    "    return user_prompt\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "c6190659-f54c-4951-bef4-4960f8e51cc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def messages_for(python):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_message},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for(python)}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "a1cbb778-fa57-43de-b04b-ed523f396c38",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pi = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def calculate(iterations, param1, param2):\n",
+    "    result = 1.0\n",
+    "    for i in range(1, iterations+1):\n",
+    "        j = i * param1 - param2\n",
+    "        result -= (1/j)\n",
+    "        j = i * param1 + param2\n",
+    "        result += (1/j)\n",
+    "    return result\n",
+    "\n",
+    "start_time = time.time()\n",
+    "result = calculate(100_000_000, 4, 1) * 4\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(f\"Result: {result:.12f}\")\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "c3b497b3-f569-420e-b92e-fb0f49957ce0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python_hard = \"\"\"# Be careful to support large number sizes\n",
+    "\n",
+    "def lcg(seed, a=1664525, c=1013904223, m=2**32):\n",
+    "    value = seed\n",
+    "    while True:\n",
+    "        value = (a * value + c) % m\n",
+    "        yield value\n",
+    "        \n",
+    "def max_subarray_sum(n, seed, min_val, max_val):\n",
+    "    lcg_gen = lcg(seed)\n",
+    "    random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val for _ in range(n)]\n",
+    "    max_sum = float('-inf')\n",
+    "    for i in range(n):\n",
+    "        current_sum = 0\n",
+    "        for j in range(i, n):\n",
+    "            current_sum += random_numbers[j]\n",
+    "            if current_sum > max_sum:\n",
+    "                max_sum = current_sum\n",
+    "    return max_sum\n",
+    "\n",
+    "def total_max_subarray_sum(n, initial_seed, min_val, max_val):\n",
+    "    total_sum = 0\n",
+    "    lcg_gen = lcg(initial_seed)\n",
+    "    for _ in range(20):\n",
+    "        seed = next(lcg_gen)\n",
+    "        total_sum += max_subarray_sum(n, seed, min_val, max_val)\n",
+    "    return total_sum\n",
+    "\n",
+    "# Parameters\n",
+    "n = 10000         # Number of random numbers\n",
+    "initial_seed = 42 # Initial seed for the LCG\n",
+    "min_val = -10     # Minimum value of random numbers\n",
+    "max_val = 10      # Maximum value of random numbers\n",
+    "\n",
+    "# Timing the function\n",
+    "import time\n",
+    "start_time = time.time()\n",
+    "result = total_max_subarray_sum(n, initial_seed, min_val, max_val)\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(\"Total Maximum Subarray Sum (20 runs):\", result)\n",
+    "print(\"Execution Time: {:.6f} seconds\".format(end_time - start_time))\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0be9f47d-5213-4700-b0e2-d444c7c738c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_gpt(python):    \n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        yield reply.replace('```python\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "8669f56b-8314-4582-a167-78842caea131",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_claude(python):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_message,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            yield reply.replace('```python\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "25f8d215-67a8-4179-8834-0e1da5a7dd32",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_google(python):\n",
+    "    # Initialize empty reply string\n",
+    "    reply = \"\"\n",
+    "    \n",
+    "    # The API for Gemini has a slightly different structure\n",
+    "    gemini = google.generativeai.GenerativeModel(\n",
+    "        model_name=GOOGLE_MODEL,\n",
+    "        system_instruction=system_message\n",
+    "    )\n",
+    "    \n",
+    "    response = gemini.generate_content(\n",
+    "        user_prompt_for(python),\n",
+    "        stream=True\n",
+    "    )\n",
+    "    \n",
+    "    # Process the stream\n",
+    "    for chunk in response:\n",
+    "        # Extract text from the chunk\n",
+    "        if chunk.text:\n",
+    "            reply += chunk.text\n",
+    "            yield reply.replace('```python\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "2f1ae8f5-16c8-40a0-aa18-63b617df078d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(python, model):\n",
+    "    if model==\"GPT\":\n",
+    "        result = stream_gpt(python)\n",
+    "    elif model==\"Claude\":\n",
+    "        result = stream_claude(python)\n",
+    "    elif model==\"Gemini\":\n",
+    "        result = stream_google(python)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "43a6b5f5-5d7c-4511-9d0c-21640070b3cf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_python(code):\n",
+    "        try:\n",
+    "            output = io.StringIO()\n",
+    "            sys.stdout = output\n",
+    "            exec(code)\n",
+    "        finally:\n",
+    "            sys.stdout = sys.__stdout__\n",
+    "        return output.getvalue()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "f35b0602-84f9-4ed6-aa35-87be4290ed24",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "css = \"\"\"\n",
+    ".python {background-color: #306998;}\n",
+    ".cpp {background-color: #050;}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "62488014-d34c-4de8-ba72-9516e05e9dde",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7860\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7860/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++\")\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=pi, lines=10)\n",
+    "        commented_python = gr.Textbox(label=\"Commented code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\", \"Claude\", \"Gemini\"], label=\"Select model\", value=\"GPT\")\n",
+    "    with gr.Row():\n",
+    "        comment = gr.Button(\"Comment code\")\n",
+    "    with gr.Row():\n",
+    "        python_run = gr.Button(\"Check Commented Python\")\n",
+    "    with gr.Row():\n",
+    "        python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "\n",
+    "    comment.click(optimize, inputs=[python, model], outputs=[commented_python])\n",
+    "    python_run.click(execute_python, inputs=[python], outputs=[python_out])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b084760b-c327-4fe7-9b7c-a01b1a383dc3",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

day3.ipynb

@@ -0,0 +1,785 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4a6ab9a2-28a2-445d-8512-a0dc8d1b54e9",
+   "metadata": {},
+   "source": [
+    "# Code Generator\n",
+    "\n",
+    "The requirement: use a Frontier model to generate high performance C++ code from Python code\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d5ccb926-7b49-44a4-99ab-8ef20b5778c0",
+   "metadata": {},
+   "source": [
+    "<table style=\"margin: 0; text-align: left;\">\n",
+    "    <tr>\n",
+    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
+    "            <img src=\"../resources.jpg\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
+    "        </td>\n",
+    "        <td>\n",
+    "            <h2 style=\"color:#f71;\">Reminder: fetch latest code</h2>\n",
+    "            <span style=\"color:#f71;\">I'm continually improving these labs, adding more examples and exercises.\n",
+    "            At the start of each week, it's worth checking you have the latest code.<br/>\n",
+    "            First do a <a href=\"https://chatgpt.com/share/6734e705-3270-8012-a074-421661af6ba9\">git pull and merge your changes as needed</a>. Any problems? Try asking ChatGPT to clarify how to merge - or contact me!<br/><br/>\n",
+    "            After you've pulled the code, from the llm_engineering directory, in an Anaconda prompt (PC) or Terminal (Mac), run:<br/>\n",
+    "            <code>conda env update --f environment.yml --prune</code><br/>\n",
+    "            Or if you used virtualenv rather than Anaconda, then run this from your activated environment in a Powershell (PC) or Terminal (Mac):<br/>\n",
+    "            <code>pip install -r requirements.txt</code>\n",
+    "            <br/>Then restart the kernel (Kernel menu >> Restart Kernel and Clear Outputs Of All Cells) to pick up the changes.\n",
+    "            </span>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d90e04a2-5b8a-4fd5-9db8-27c02f033313",
+   "metadata": {},
+   "source": [
+    "<table style=\"margin: 0; text-align: left;\">\n",
+    "    <tr>\n",
+    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
+    "            <img src=\"../important.jpg\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
+    "        </td>\n",
+    "        <td>\n",
+    "            <h1 style=\"color:#900;\">Important Note</h1>\n",
+    "            <span style=\"color:#900;\">\n",
+    "            In this lab, I use GPT-4o and Claude-3.5-Sonnet, which are the slightly higher priced models. The costs are still low, but if you'd prefer to keep costs ultra low, please make the suggested switches to the models (3 cells down from here).\n",
+    "            </span>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e610bf56-a46e-4aff-8de1-ab49d62b1ad3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import io\n",
+    "import sys\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import google.generativeai\n",
+    "import anthropic\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "import gradio as gr\n",
+    "import subprocess"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f672e1c-87e9-4865-b760-370fa605e614",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv(override=True)\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8aa149ed-9298-4d69-8fe2-8f5de0f667da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize\n",
+    "# NOTE - option to use ultra-low cost models by uncommenting last 2 lines\n",
+    "\n",
+    "openai = OpenAI()\n",
+    "claude = anthropic.Anthropic()\n",
+    "OPENAI_MODEL = \"gpt-4o\"\n",
+    "CLAUDE_MODEL = \"claude-3-5-sonnet-20240620\"\n",
+    "\n",
+    "# Want to keep costs ultra-low? Uncomment these lines:\n",
+    "# OPENAI_MODEL = \"gpt-4o-mini\"\n",
+    "# CLAUDE_MODEL = \"claude-3-haiku-20240307\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6896636f-923e-4a2c-9d6c-fac07828a201",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_message = \"You are an assistant that reimplements Python code in high performance C++ for an M1 Mac. \"\n",
+    "system_message += \"Respond only with C++ code; use comments sparingly and do not provide any explanation other than occasional comments. \"\n",
+    "system_message += \"The C++ response needs to produce an identical output in the fastest possible time.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e7b3546-57aa-4c29-bc5d-f211970d04eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def user_prompt_for(python):\n",
+    "    user_prompt = \"Rewrite this Python code in C++ with the fastest possible implementation that produces identical output in the least time. \"\n",
+    "    user_prompt += \"Respond only with C++ code; do not explain your work other than a few comments. \"\n",
+    "    user_prompt += \"Pay attention to number types to ensure no int overflows. Remember to #include all necessary C++ packages such as iomanip.\\n\\n\"\n",
+    "    user_prompt += python\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c6190659-f54c-4951-bef4-4960f8e51cc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def messages_for(python):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_message},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for(python)}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71e1ba8c-5b05-4726-a9f3-8d8c6257350b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# write to a file called optimized.cpp\n",
+    "\n",
+    "def write_output(cpp):\n",
+    "    code = cpp.replace(\"```cpp\",\"\").replace(\"```\",\"\")\n",
+    "    with open(\"optimized.cpp\", \"w\") as f:\n",
+    "        f.write(code)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e7d2fea8-74c6-4421-8f1e-0e76d5b201b9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_gpt(python):    \n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        print(fragment, end='', flush=True)\n",
+    "    write_output(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7cd84ad8-d55c-4fe0-9eeb-1895c95c4a9d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_claude(python):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_message,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            print(text, end=\"\", flush=True)\n",
+    "    write_output(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a1cbb778-fa57-43de-b04b-ed523f396c38",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pi = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def calculate(iterations, param1, param2):\n",
+    "    result = 1.0\n",
+    "    for i in range(1, iterations+1):\n",
+    "        j = i * param1 - param2\n",
+    "        result -= (1/j)\n",
+    "        j = i * param1 + param2\n",
+    "        result += (1/j)\n",
+    "    return result\n",
+    "\n",
+    "start_time = time.time()\n",
+    "result = calculate(100_000_000, 4, 1) * 4\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(f\"Result: {result:.12f}\")\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "7fe1cd4b-d2c5-4303-afed-2115a3fef200",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Result: 3.141592658589\n",
+      "Execution Time: 52.224082 seconds\n"
+     ]
+    }
+   ],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "105db6f9-343c-491d-8e44-3a5328b81719",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf26ee95-0c77-491d-9a91-579a1e96a8a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf8f8018-f64d-425c-a0e1-d7862aa9592d",
+   "metadata": {},
+   "source": [
+    "# Compiling C++ and executing\n",
+    "\n",
+    "This next cell contains the command to compile a C++ file on my M1 Mac.  \n",
+    "It compiles the file `optimized.cpp` into an executable called `optimized`  \n",
+    "Then it runs the program called `optimized`\n",
+    "\n",
+    "In the next lab (day4), a student has contributed a full solution that compiles to efficient code on Mac, PC and Linux!\n",
+    "\n",
+    "You can wait for this, or you can google (or ask ChatGPT!) for how to do this on your platform, then replace the lines below.\n",
+    "If you're not comfortable with this step, you can skip it for sure - I'll show you exactly how it performs on my Mac.\n",
+    "\n",
+    "\n",
+    "OR alternatively: student Sandeep K.G. points out that you can run Python and C++ code online to test it out that way. Thank you Sandeep!  \n",
+    "> Not an exact comparison but you can still get the idea of performance difference.\n",
+    "> For example here: https://www.programiz.com/cpp-programming/online-compiler/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4194e40c-04ab-4940-9d64-b4ad37c5bb40",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Compile C++ and run the executable\n",
+    "\n",
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "983a11fe-e24d-4c65-8269-9802c5ef3ae6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_claude(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5a766f9-3d23-4bb4-a1d4-88ec44b61ddf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Repeat for Claude - again, use the right approach for your platform\n",
+    "\n",
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c3b497b3-f569-420e-b92e-fb0f49957ce0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python_hard = \"\"\"# Be careful to support large number sizes\n",
+    "\n",
+    "def lcg(seed, a=1664525, c=1013904223, m=2**32):\n",
+    "    value = seed\n",
+    "    while True:\n",
+    "        value = (a * value + c) % m\n",
+    "        yield value\n",
+    "        \n",
+    "def max_subarray_sum(n, seed, min_val, max_val):\n",
+    "    lcg_gen = lcg(seed)\n",
+    "    random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val for _ in range(n)]\n",
+    "    max_sum = float('-inf')\n",
+    "    for i in range(n):\n",
+    "        current_sum = 0\n",
+    "        for j in range(i, n):\n",
+    "            current_sum += random_numbers[j]\n",
+    "            if current_sum > max_sum:\n",
+    "                max_sum = current_sum\n",
+    "    return max_sum\n",
+    "\n",
+    "def total_max_subarray_sum(n, initial_seed, min_val, max_val):\n",
+    "    total_sum = 0\n",
+    "    lcg_gen = lcg(initial_seed)\n",
+    "    for _ in range(20):\n",
+    "        seed = next(lcg_gen)\n",
+    "        total_sum += max_subarray_sum(n, seed, min_val, max_val)\n",
+    "    return total_sum\n",
+    "\n",
+    "# Parameters\n",
+    "n = 10000         # Number of random numbers\n",
+    "initial_seed = 42 # Initial seed for the LCG\n",
+    "min_val = -10     # Minimum value of random numbers\n",
+    "max_val = 10      # Maximum value of random numbers\n",
+    "\n",
+    "# Timing the function\n",
+    "import time\n",
+    "start_time = time.time()\n",
+    "result = total_max_subarray_sum(n, initial_seed, min_val, max_val)\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(\"Total Maximum Subarray Sum (20 runs):\", result)\n",
+    "print(\"Execution Time: {:.6f} seconds\".format(end_time - start_time))\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dab5e4bc-276c-4555-bd4c-12c699d5e899",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8d24ed5-2c15-4f55-80e7-13a3952b3cb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e0b3d073-88a2-40b2-831c-6f0c345c256f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Replace this with the right C++ compile + execute command for your platform\n",
+    "\n",
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9305446-1d0c-4b51-866a-b8c1e299bf5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_claude(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c181036-8193-4fdd-aef3-fc513b218d43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Replace this with the right C++ compile + execute command for your platform\n",
+    "\n",
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0be9f47d-5213-4700-b0e2-d444c7c738c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_gpt(python):    \n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        yield reply.replace('```cpp\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8669f56b-8314-4582-a167-78842caea131",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_claude(python):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_message,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            yield reply.replace('```cpp\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2f1ae8f5-16c8-40a0-aa18-63b617df078d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(python, model):\n",
+    "    if model==\"GPT\":\n",
+    "        result = stream_gpt(python)\n",
+    "    elif model==\"Claude\":\n",
+    "        result = stream_claude(python)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f1ddb38e-6b0a-4c37-baa4-ace0b7de887a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with gr.Blocks() as ui:\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", lines=10, value=python_hard)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\", \"Claude\"], label=\"Select model\", value=\"GPT\")\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "19bf2bff-a822-4009-a539-f003b1651383",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_python(code):\n",
+    "    try:\n",
+    "        output = io.StringIO()\n",
+    "        sys.stdout = output\n",
+    "        exec(code)\n",
+    "    finally:\n",
+    "        sys.stdout = sys.__stdout__\n",
+    "    return output.getvalue()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77f3ab5d-fcfb-4d3f-8728-9cacbf833ea6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# You'll need to change the code in the try block to compile the C++ code for your platform\n",
+    "# I pasted this into Claude's chat UI with a request for it to give me a version for an Intel PC,\n",
+    "# and it responded with something that looks perfect - you can try a similar approach for your platform.\n",
+    "\n",
+    "# M1 Mac version to compile and execute optimized C++ code:\n",
+    "\n",
+    "def execute_cpp(code):\n",
+    "        write_output(code)\n",
+    "        try:\n",
+    "            compile_cmd = [\"clang++\", \"-Ofast\", \"-std=c++17\", \"-march=armv8.5-a\", \"-mtune=apple-m1\", \"-mcpu=apple-m1\", \"-o\", \"optimized\", \"optimized.cpp\"]\n",
+    "            compile_result = subprocess.run(compile_cmd, check=True, text=True, capture_output=True)\n",
+    "            run_cmd = [\"./optimized\"]\n",
+    "            run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)\n",
+    "            return run_result.stdout\n",
+    "        except subprocess.CalledProcessError as e:\n",
+    "            return f\"An error occurred:\\n{e.stderr}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9a2274f1-d03b-42c0-8dcc-4ce159b18442",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "css = \"\"\"\n",
+    ".python {background-color: #306998;}\n",
+    ".cpp {background-color: #050;}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f1303932-160c-424b-97a8-d28c816721b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++\")\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=python_hard, lines=10)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\", \"Claude\"], label=\"Select model\", value=\"GPT\")\n",
+    "    with gr.Row():\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "    with gr.Row():\n",
+    "        python_run = gr.Button(\"Run Python\")\n",
+    "        cpp_run = gr.Button(\"Run C++\")\n",
+    "    with gr.Row():\n",
+    "        python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "        cpp_out = gr.TextArea(label=\"C++ result:\", elem_classes=[\"cpp\"])\n",
+    "\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "    python_run.click(execute_python, inputs=[python], outputs=[python_out])\n",
+    "    cpp_run.click(execute_cpp, inputs=[cpp], outputs=[cpp_out])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "f6e69518-a44f-4a8b-b016-da87a78c152e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7860\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7860/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import gradio as gr\n",
+    "import ollama\n",
+    "\n",
+    "llama_system = \"You are an assistant who solve quadratic equations provided. Just tell the steps and the answer and nothing else\"\n",
+    "deepseek_system = \"You are an assistant who solve quadratic equations provided. Just tell the steps and the answer and nothing else\"\n",
+    "llama_user = \"Please solve this quadratic equation: \"\n",
+    "deepseek_user = \"Please solve this quadratic equation: \"\n",
+    "\n",
+    "\n",
+    "def solver_e(model, equation):\n",
+    "    if model == \"LLAMA\":\n",
+    "        res = ollama.chat(model=\"llama3.2\", messages=[{'role':'system', 'content':llama_system}, {'role':'user','content':llama_user + equation}])\n",
+    "        return res['content']['message']\n",
+    "    else:\n",
+    "        res = ollama.chat(model=\"deepseek-r1:1.5b\", messages=[{'role':'system', 'content':llama_system}, {'role':'user','content':llama_user + equation}])\n",
+    "        return res['content']['message']\n",
+    "        \n",
+    "\n",
+    "qua_equ = \"x² - 5x + 6\"\n",
+    "\n",
+    "with gr.Blocks() as ui:\n",
+    "    gr.Markdown(\"## Solve quadratic equations\")\n",
+    "    with gr.Row():\n",
+    "        llama_text = gr.Textbox(label=\"Llama_Equation\", value=qua_equ, lines=2)\n",
+    "        deepseek_text = gr.Textbox(label=\"Deepseek_equation\", value=qua_equ, lines=2)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"LLAMA\", \"DEEPSEEK\"], label=\"Select model\", value=\"LLAMA\")\n",
+    "    with gr.Row():\n",
+    "        solver = gr.Button(\"Solve Equation\")\n",
+    "    with gr.Row():\n",
+    "        convert_llama = gr.Button(\"Say Deepseek to solve Lamma's equation\")\n",
+    "        convert_deepseek = gr.Button(\"Say Llama to solve Deepseek's equation\")\n",
+    "    with gr.Row():\n",
+    "        llama_dis = gr.TextArea(label = \"LLama result: \")\n",
+    "        DeepSeek_dis = gr.TextArea(label = \"DeepSeek result: \")\n",
+    "\n",
+    "    solver.click(solver_e, inputs=[model, ])\n",
+    "    \n",
+    "\n",
+    "    \n",
+    "        \n",
+    "        \n",
+    "     \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "8bca3390-d61a-45e5-911d-ed1e2a3778b1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting pygame\n",
+      "  Downloading pygame-2.6.1-cp311-cp311-win_amd64.whl.metadata (13 kB)\n",
+      "Downloading pygame-2.6.1-cp311-cp311-win_amd64.whl (10.6 MB)\n",
+      "   ---------------------------------------- 0.0/10.6 MB ? eta -:--:--\n",
+      "    --------------------------------------- 0.3/10.6 MB ? eta -:--:--\n",
+      "   - -------------------------------------- 0.5/10.6 MB 1.9 MB/s eta 0:00:06\n",
+      "   --- ------------------------------------ 1.0/10.6 MB 1.6 MB/s eta 0:00:06\n",
+      "   ----- ---------------------------------- 1.6/10.6 MB 1.9 MB/s eta 0:00:05\n",
+      "   ------ --------------------------------- 1.8/10.6 MB 1.9 MB/s eta 0:00:05\n",
+      "   -------- ------------------------------- 2.4/10.6 MB 1.9 MB/s eta 0:00:05\n",
+      "   --------- ------------------------------ 2.6/10.6 MB 1.9 MB/s eta 0:00:05\n",
+      "   ---------- ----------------------------- 2.9/10.6 MB 1.9 MB/s eta 0:00:05\n",
+      "   ------------ --------------------------- 3.4/10.6 MB 1.8 MB/s eta 0:00:04\n",
+      "   -------------- ------------------------- 3.9/10.6 MB 1.8 MB/s eta 0:00:04\n",
+      "   --------------- ------------------------ 4.2/10.6 MB 1.9 MB/s eta 0:00:04\n",
+      "   ----------------- ---------------------- 4.7/10.6 MB 1.8 MB/s eta 0:00:04\n",
+      "   ------------------ --------------------- 5.0/10.6 MB 1.9 MB/s eta 0:00:04\n",
+      "   --------------------- ------------------ 5.8/10.6 MB 1.9 MB/s eta 0:00:03\n",
+      "   ----------------------- ---------------- 6.3/10.6 MB 1.9 MB/s eta 0:00:03\n",
+      "   ------------------------ --------------- 6.6/10.6 MB 1.9 MB/s eta 0:00:03\n",
+      "   ------------------------- -------------- 6.8/10.6 MB 1.9 MB/s eta 0:00:02\n",
+      "   --------------------------- ------------ 7.3/10.6 MB 1.9 MB/s eta 0:00:02\n",
+      "   ----------------------------- ---------- 7.9/10.6 MB 1.9 MB/s eta 0:00:02\n",
+      "   ------------------------------ --------- 8.1/10.6 MB 2.0 MB/s eta 0:00:02\n",
+      "   ------------------------------- -------- 8.4/10.6 MB 1.9 MB/s eta 0:00:02\n",
+      "   --------------------------------- ------ 8.9/10.6 MB 1.9 MB/s eta 0:00:01\n",
+      "   ----------------------------------- ---- 9.4/10.6 MB 1.9 MB/s eta 0:00:01\n",
+      "   ------------------------------------- -- 10.0/10.6 MB 1.9 MB/s eta 0:00:01\n",
+      "   ---------------------------------------  10.5/10.6 MB 1.9 MB/s eta 0:00:01\n",
+      "   ---------------------------------------- 10.6/10.6 MB 1.9 MB/s eta 0:00:00\n",
+      "Installing collected packages: pygame\n",
+      "Successfully installed pygame-2.6.1\n",
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "pip install pygame"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "dfda28fd-ec36-4b59-a047-3ae69b690b6c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hi Hello\n"
+     ]
+    }
+   ],
+   "source": [
+    "hi = \"Hi \"\n",
+    "hello = \"Hello\"\n",
+    "print(hi + hello)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "09463243-6cca-4778-b76b-5e3aa0e304e1",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

day4.ipynb

@@ -0,0 +1,848 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4a6ab9a2-28a2-445d-8512-a0dc8d1b54e9",
+   "metadata": {},
+   "source": [
+    "# Code Generator\n",
+    "\n",
+    "The requirement: use an Open Source model to generate high performance C++ code from Python code\n",
+    "\n",
+    "To replicate this, you'll need to set up a HuggingFace endpoint as I do in the video. It's simple to do, and it's quite satisfying to see the results!\n",
+    "\n",
+    "It's also an important part of your learning; this is the first example of deploying an open source model to be behind an API. We'll return to this in Week 8, but this should plant a seed in your mind for what's involved in moving open source models into production."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22e1567b-33fd-49e7-866e-4b635d15715a",
+   "metadata": {},
+   "source": [
+    "<table style=\"margin: 0; text-align: left;\">\n",
+    "    <tr>\n",
+    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
+    "            <img src=\"../important.jpg\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
+    "        </td>\n",
+    "        <td>\n",
+    "            <h1 style=\"color:#900;\">Important - Pause Endpoints when not in use</h1>\n",
+    "            <span style=\"color:#900;\">\n",
+    "            If you do decide to use HuggingFace endpoints for this project, you should stop or pause the endpoints when you are done to avoid accruing unnecessary running cost. The costs are very low as long as you only run the endpoint when you're using it. Navigate to the HuggingFace endpoint UI <a href=\"https://ui.endpoints.huggingface.co/\">here,</a> open your endpoint, and click Pause to put it on pause so you no longer pay for it.  \n",
+    "Many thanks to student John L. for raising this.\n",
+    "<br/><br/>\n",
+    "In week 8 we will use Modal instead of HuggingFace endpoints; with Modal you only pay for the time that you use it and you should get free credits.\n",
+    "            </span>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e610bf56-a46e-4aff-8de1-ab49d62b1ad3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import io\n",
+    "import sys\n",
+    "import json\n",
+    "import requests\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import google.generativeai\n",
+    "import anthropic\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "import gradio as gr\n",
+    "import subprocess"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f672e1c-87e9-4865-b760-370fa605e614",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv(override=True)\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['HF_TOKEN'] = os.getenv('HF_TOKEN', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8aa149ed-9298-4d69-8fe2-8f5de0f667da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize\n",
+    "\n",
+    "openai = OpenAI()\n",
+    "claude = anthropic.Anthropic()\n",
+    "OPENAI_MODEL = \"gpt-4o\"\n",
+    "CLAUDE_MODEL = \"claude-3-5-sonnet-20240620\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6896636f-923e-4a2c-9d6c-fac07828a201",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_message = \"You are an assistant that reimplements Python code in high performance C++ for an M1 Mac. \"\n",
+    "system_message += \"Respond only with C++ code; use comments sparingly and do not provide any explanation other than occasional comments. \"\n",
+    "system_message += \"The C++ response needs to produce an identical output in the fastest possible time. Keep implementations of random number generators identical so that results match exactly.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e7b3546-57aa-4c29-bc5d-f211970d04eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def user_prompt_for(python):\n",
+    "    user_prompt = \"Rewrite this Python code in C++ with the fastest possible implementation that produces identical output in the least time. \"\n",
+    "    user_prompt += \"Respond only with C++ code; do not explain your work other than a few comments. \"\n",
+    "    user_prompt += \"Pay attention to number types to ensure no int overflows. Remember to #include all necessary C++ packages such as iomanip.\\n\\n\"\n",
+    "    user_prompt += python\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c6190659-f54c-4951-bef4-4960f8e51cc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def messages_for(python):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_message},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for(python)}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71e1ba8c-5b05-4726-a9f3-8d8c6257350b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# write to a file called optimized.cpp\n",
+    "\n",
+    "def write_output(cpp):\n",
+    "    code = cpp.replace(\"```cpp\",\"\").replace(\"```\",\"\")\n",
+    "    with open(\"optimized.cpp\", \"w\") as f:\n",
+    "        f.write(code)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e7d2fea8-74c6-4421-8f1e-0e76d5b201b9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_gpt(python):    \n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        print(fragment, end='', flush=True)\n",
+    "    write_output(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7cd84ad8-d55c-4fe0-9eeb-1895c95c4a9d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize_claude(python):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_message,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            print(text, end=\"\", flush=True)\n",
+    "    write_output(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a1cbb778-fa57-43de-b04b-ed523f396c38",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pi = \"\"\"\n",
+    "import time\n",
+    "\n",
+    "def calculate(iterations, param1, param2):\n",
+    "    result = 1.0\n",
+    "    for i in range(1, iterations+1):\n",
+    "        j = i * param1 - param2\n",
+    "        result -= (1/j)\n",
+    "        j = i * param1 + param2\n",
+    "        result += (1/j)\n",
+    "    return result\n",
+    "\n",
+    "start_time = time.time()\n",
+    "result = calculate(100_000_000, 4, 1) * 4\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(f\"Result: {result:.12f}\")\n",
+    "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7fe1cd4b-d2c5-4303-afed-2115a3fef200",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "105db6f9-343c-491d-8e44-3a5328b81719",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf26ee95-0c77-491d-9a91-579a1e96a8a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4194e40c-04ab-4940-9d64-b4ad37c5bb40",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "983a11fe-e24d-4c65-8269-9802c5ef3ae6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_claude(pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5a766f9-3d23-4bb4-a1d4-88ec44b61ddf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c3b497b3-f569-420e-b92e-fb0f49957ce0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python_hard = \"\"\"# Be careful to support large number sizes\n",
+    "\n",
+    "def lcg(seed, a=1664525, c=1013904223, m=2**32):\n",
+    "    value = seed\n",
+    "    while True:\n",
+    "        value = (a * value + c) % m\n",
+    "        yield value\n",
+    "        \n",
+    "def max_subarray_sum(n, seed, min_val, max_val):\n",
+    "    lcg_gen = lcg(seed)\n",
+    "    random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val for _ in range(n)]\n",
+    "    max_sum = float('-inf')\n",
+    "    for i in range(n):\n",
+    "        current_sum = 0\n",
+    "        for j in range(i, n):\n",
+    "            current_sum += random_numbers[j]\n",
+    "            if current_sum > max_sum:\n",
+    "                max_sum = current_sum\n",
+    "    return max_sum\n",
+    "\n",
+    "def total_max_subarray_sum(n, initial_seed, min_val, max_val):\n",
+    "    total_sum = 0\n",
+    "    lcg_gen = lcg(initial_seed)\n",
+    "    for _ in range(20):\n",
+    "        seed = next(lcg_gen)\n",
+    "        total_sum += max_subarray_sum(n, seed, min_val, max_val)\n",
+    "    return total_sum\n",
+    "\n",
+    "# Parameters\n",
+    "n = 10000         # Number of random numbers\n",
+    "initial_seed = 42 # Initial seed for the LCG\n",
+    "min_val = -10     # Minimum value of random numbers\n",
+    "max_val = 10      # Maximum value of random numbers\n",
+    "\n",
+    "# Timing the function\n",
+    "import time\n",
+    "start_time = time.time()\n",
+    "result = total_max_subarray_sum(n, initial_seed, min_val, max_val)\n",
+    "end_time = time.time()\n",
+    "\n",
+    "print(\"Total Maximum Subarray Sum (20 runs):\", result)\n",
+    "print(\"Execution Time: {:.6f} seconds\".format(end_time - start_time))\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dab5e4bc-276c-4555-bd4c-12c699d5e899",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exec(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8d24ed5-2c15-4f55-80e7-13a3952b3cb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_gpt(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e0b3d073-88a2-40b2-831c-6f0c345c256f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9305446-1d0c-4b51-866a-b8c1e299bf5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimize_claude(python_hard)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c181036-8193-4fdd-aef3-fc513b218d43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!clang++ -O3 -std=c++17 -march=armv8.3-a -o optimized optimized.cpp\n",
+    "!./optimized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0be9f47d-5213-4700-b0e2-d444c7c738c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_gpt(python):    \n",
+    "    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python), stream=True)\n",
+    "    reply = \"\"\n",
+    "    for chunk in stream:\n",
+    "        fragment = chunk.choices[0].delta.content or \"\"\n",
+    "        reply += fragment\n",
+    "        yield reply.replace('```cpp\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8669f56b-8314-4582-a167-78842caea131",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_claude(python):\n",
+    "    result = claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=system_message,\n",
+    "        messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n",
+    "    )\n",
+    "    reply = \"\"\n",
+    "    with result as stream:\n",
+    "        for text in stream.text_stream:\n",
+    "            reply += text\n",
+    "            yield reply.replace('```cpp\\n','').replace('```','')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2f1ae8f5-16c8-40a0-aa18-63b617df078d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(python, model):\n",
+    "    if model==\"GPT\":\n",
+    "        result = stream_gpt(python)\n",
+    "    elif model==\"Claude\":\n",
+    "        result = stream_claude(python)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f1ddb38e-6b0a-4c37-baa4-ace0b7de887a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with gr.Blocks() as ui:\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", lines=10, value=python_hard)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\", \"Claude\"], label=\"Select model\", value=\"GPT\")\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "19bf2bff-a822-4009-a539-f003b1651383",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_python(code):\n",
+    "    try:\n",
+    "        output = io.StringIO()\n",
+    "        sys.stdout = output\n",
+    "        exec(code)\n",
+    "    finally:\n",
+    "        sys.stdout = sys.__stdout__\n",
+    "    return output.getvalue()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77f3ab5d-fcfb-4d3f-8728-9cacbf833ea6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def execute_cpp(code):\n",
+    "    write_output(code)\n",
+    "    compiler_cmd = [\"clang++\", \"-O3\", \"-std=c++17\", \"-march=armv8.3-a\", \"-o\", \"optimized\", \"optimized.cpp\"]\n",
+    "    try:\n",
+    "        compile_result = subprocess.run(compiler_cmd, check=True, text=True, capture_output=True)\n",
+    "        run_cmd = [\"./optimized\"]\n",
+    "        run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)\n",
+    "        return run_result.stdout\n",
+    "    except subprocess.CalledProcessError as e:\n",
+    "        return f\"An error occurred:\\n{e.stderr}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9a2274f1-d03b-42c0-8dcc-4ce159b18442",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "css = \"\"\"\n",
+    ".python {background-color: #306998;}\n",
+    ".cpp {background-color: #050;}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f1303932-160c-424b-97a8-d28c816721b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++\")\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=python_hard, lines=10)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        model = gr.Dropdown([\"GPT\", \"Claude\"], label=\"Select model\", value=\"GPT\")\n",
+    "    with gr.Row():\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "    with gr.Row():\n",
+    "        python_run = gr.Button(\"Run Python\")\n",
+    "        cpp_run = gr.Button(\"Run C++\")\n",
+    "    with gr.Row():\n",
+    "        python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "        cpp_out = gr.TextArea(label=\"C++ result:\", elem_classes=[\"cpp\"])\n",
+    "\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "    python_run.click(execute_python, inputs=[python], outputs=[python_out])\n",
+    "    cpp_run.click(execute_cpp, inputs=[cpp], outputs=[cpp_out])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bb8c5b4e-ec51-4f21-b3f8-6aa94fede86d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import login, InferenceClient\n",
+    "from transformers import AutoTokenizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "13347633-4606-4e38-9927-80c39e65c1f1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hf_token = os.environ['HF_TOKEN']\n",
+    "login(hf_token, add_to_git_credential=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ef60a4df-6267-4ebd-8eed-dcb917af0a5e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "code_qwen = \"Qwen/CodeQwen1.5-7B-Chat\"\n",
+    "code_gemma = \"google/codegemma-7b-it\"\n",
+    "CODE_QWEN_URL = \"https://h1vdol7jxhje3mpn.us-east-1.aws.endpoints.huggingface.cloud\"\n",
+    "CODE_GEMMA_URL = \"https://c5hggiyqachmgnqg.us-east-1.aws.endpoints.huggingface.cloud\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "695ce389-a903-4533-a2f1-cd9e2a6af8f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenizer = AutoTokenizer.from_pretrained(code_qwen)\n",
+    "messages = messages_for(pi)\n",
+    "text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4548e96-0b32-4793-bdd6-1b072c2f26ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bb2a126b-09e7-4966-bc97-0ef5c2cc7896",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "client = InferenceClient(CODE_QWEN_URL, token=hf_token)\n",
+    "stream = client.text_generation(text, stream=True, details=True, max_new_tokens=3000)\n",
+    "for r in stream:\n",
+    "    print(r.token.text, end = \"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "127a52e5-ad85-42b7-a0f5-9afda5efe090",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_code_qwen(python):\n",
+    "    tokenizer = AutoTokenizer.from_pretrained(code_qwen)\n",
+    "    messages = messages_for(python)\n",
+    "    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+    "    client = InferenceClient(CODE_QWEN_URL, token=hf_token)\n",
+    "    stream = client.text_generation(text, stream=True, details=True, max_new_tokens=3000)\n",
+    "    result = \"\"\n",
+    "    for r in stream:\n",
+    "        result += r.token.text\n",
+    "        yield result    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a82387d1-7651-4923-995b-fe18356fcaa6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimize(python, model):\n",
+    "    if model==\"GPT\":\n",
+    "        result = stream_gpt(python)\n",
+    "    elif model==\"Claude\":\n",
+    "        result = stream_claude(python)\n",
+    "    elif model==\"CodeQwen\":\n",
+    "        result = stream_code_qwen(python)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b0a6a97-5b8a-4a9b-8ee0-7561e0ced673",
+   "metadata": {},
+   "source": [
+    "<table style=\"margin: 0; text-align: left;\">\n",
+    "    <tr>\n",
+    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
+    "            <img src=\"../thankyou.jpg\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
+    "        </td>\n",
+    "        <td>\n",
+    "            <h2 style=\"color:#090;\">Thank you to @CloudLlama for an amazing contribution</h2>\n",
+    "            <span style=\"color:#090;\">\n",
+    "                A student has contributed a chunk of code to improve this, in the next 2 cells. You can now select which Python porgram to run,\n",
+    "                and a compiler is automatically selected that will work on PC, Windows and Mac. Massive thank you @CloudLlama!\n",
+    "            </span>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ba311ec-c16a-4fe0-946b-4b940704cf65",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def select_sample_program(sample_program):\n",
+    "    if sample_program==\"pi\":\n",
+    "        return pi\n",
+    "    elif sample_program==\"python_hard\":\n",
+    "        return python_hard\n",
+    "    else:\n",
+    "        return \"Type your Python program here\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e42286bc-085c-45dc-b101-234308e58269",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import platform\n",
+    "\n",
+    "VISUAL_STUDIO_2022_TOOLS = \"C:\\\\Program Files\\\\Microsoft Visual Studio\\\\2022\\\\Community\\\\Common7\\Tools\\\\VsDevCmd.bat\"\n",
+    "VISUAL_STUDIO_2019_TOOLS = \"C:\\\\Program Files (x86)\\\\Microsoft Visual Studio\\\\2019\\\\BuildTools\\\\Common7\\\\Tools\\\\VsDevCmd.bat\"\n",
+    "\n",
+    "simple_cpp = \"\"\"\n",
+    "#include <iostream>\n",
+    "\n",
+    "int main() {\n",
+    "    std::cout << \"Hello\";\n",
+    "    return 0;\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "def run_cmd(command_to_run):\n",
+    "    try:\n",
+    "        run_result = subprocess.run(command_to_run, check=True, text=True, capture_output=True)\n",
+    "        return run_result.stdout if run_result.stdout else \"SUCCESS\"\n",
+    "    except:\n",
+    "        return \"\"\n",
+    "\n",
+    "def c_compiler_cmd(filename_base):\n",
+    "    my_platform = platform.system()\n",
+    "    my_compiler = []\n",
+    "\n",
+    "    try:\n",
+    "        with open(\"simple.cpp\", \"w\") as f:\n",
+    "            f.write(simple_cpp)\n",
+    "            \n",
+    "        if my_platform == \"Windows\":\n",
+    "            if os.path.isfile(VISUAL_STUDIO_2022_TOOLS):\n",
+    "                if os.path.isfile(\"./simple.exe\"):\n",
+    "                    os.remove(\"./simple.exe\")\n",
+    "                compile_cmd = [\"cmd\", \"/c\", VISUAL_STUDIO_2022_TOOLS, \"&\", \"cl\", \"simple.cpp\"]\n",
+    "                if run_cmd(compile_cmd):\n",
+    "                    if run_cmd([\"./simple.exe\"]) == \"Hello\":\n",
+    "                        my_compiler = [\"Windows\", \"Visual Studio 2022\", [\"cmd\", \"/c\", VISUAL_STUDIO_2022_TOOLS, \"&\", \"cl\", f\"{filename_base}.cpp\"]]\n",
+    "        \n",
+    "            if not my_compiler:\n",
+    "                if os.path.isfile(VISUAL_STUDIO_2019_TOOLS):\n",
+    "                    if os.path.isfile(\"./simple.exe\"):\n",
+    "                        os.remove(\"./simple.exe\")\n",
+    "                    compile_cmd = [\"cmd\", \"/c\", VISUAL_STUDIO_2019_TOOLS, \"&\", \"cl\", \"simple.cpp\"]\n",
+    "                    if run_cmd(compile_cmd):\n",
+    "                        if run_cmd([\"./simple.exe\"]) == \"Hello\":\n",
+    "                            my_compiler = [\"Windows\", \"Visual Studio 2019\", [\"cmd\", \"/c\", VISUAL_STUDIO_2019_TOOLS, \"&\", \"cl\", f\"{filename_base}.cpp\"]]\n",
+    "    \n",
+    "            if not my_compiler:\n",
+    "                my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "                \n",
+    "        elif my_platform == \"Linux\":\n",
+    "            if os.path.isfile(\"./simple\"):\n",
+    "                os.remove(\"./simple\")\n",
+    "            compile_cmd = [\"g++\", \"simple.cpp\", \"-o\", \"simple\"]\n",
+    "            if run_cmd(compile_cmd):\n",
+    "                if run_cmd([\"./simple\"]) == \"Hello\":\n",
+    "                    my_compiler = [\"Linux\", \"GCC (g++)\", [\"g++\", f\"{filename_base}.cpp\", \"-o\", f\"{filename_base}\" ]]\n",
+    "    \n",
+    "            if not my_compiler:\n",
+    "                if os.path.isfile(\"./simple\"):\n",
+    "                    os.remove(\"./simple\")\n",
+    "                compile_cmd = [\"clang++\", \"simple.cpp\", \"-o\", \"simple\"]\n",
+    "                if run_cmd(compile_cmd):\n",
+    "                    if run_cmd([\"./simple\"]) == \"Hello\":\n",
+    "                        my_compiler = [\"Linux\", \"Clang++\", [\"clang++\", f\"{filename_base}.cpp\", \"-o\", f\"{filename_base}\"]]\n",
+    "        \n",
+    "            if not my_compiler:\n",
+    "                my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "    \n",
+    "        elif my_platform == \"Darwin\":\n",
+    "            if os.path.isfile(\"./simple\"):\n",
+    "                os.remove(\"./simple\")\n",
+    "            compile_cmd = [\"clang++\", \"-Ofast\", \"-std=c++17\", \"-march=armv8.5-a\", \"-mtune=apple-m1\", \"-mcpu=apple-m1\", \"-o\", \"simple\", \"simple.cpp\"]\n",
+    "            if run_cmd(compile_cmd):\n",
+    "                if run_cmd([\"./simple\"]) == \"Hello\":\n",
+    "                    my_compiler = [\"Macintosh\", \"Clang++\", [\"clang++\", \"-Ofast\", \"-std=c++17\", \"-march=armv8.5-a\", \"-mtune=apple-m1\", \"-mcpu=apple-m1\", \"-o\", f\"{filename_base}\", f\"{filename_base}.cpp\"]]\n",
+    "    \n",
+    "            if not my_compiler:\n",
+    "                my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "    except:\n",
+    "        my_compiler=[my_platform, \"Unavailable\", []]\n",
+    "        \n",
+    "    if my_compiler:\n",
+    "        return my_compiler\n",
+    "    else:\n",
+    "        return [\"Unknown\", \"Unavailable\", []]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f9ca2e6f-60c1-4e5f-b570-63c75b2d189b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "compiler_cmd = c_compiler_cmd(\"optimized\")\n",
+    "\n",
+    "with gr.Blocks(css=css) as ui:\n",
+    "    gr.Markdown(\"## Convert code from Python to C++\")\n",
+    "    with gr.Row():\n",
+    "        python = gr.Textbox(label=\"Python code:\", value=python_hard, lines=10)\n",
+    "        cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "        with gr.Column():\n",
+    "            sample_program = gr.Radio([\"pi\", \"python_hard\"], label=\"Sample program\", value=\"python_hard\")\n",
+    "            model = gr.Dropdown([\"GPT\", \"Claude\", \"CodeQwen\"], label=\"Select model\", value=\"GPT\")\n",
+    "        with gr.Column():\n",
+    "            architecture = gr.Radio([compiler_cmd[0]], label=\"Architecture\", interactive=False, value=compiler_cmd[0])\n",
+    "            compiler = gr.Radio([compiler_cmd[1]], label=\"Compiler\", interactive=False, value=compiler_cmd[1])\n",
+    "    with gr.Row():\n",
+    "        convert = gr.Button(\"Convert code\")\n",
+    "    with gr.Row():\n",
+    "        python_run = gr.Button(\"Run Python\")\n",
+    "        if not compiler_cmd[1] == \"Unavailable\":\n",
+    "            cpp_run = gr.Button(\"Run C++\")\n",
+    "        else:\n",
+    "            cpp_run = gr.Button(\"No compiler to run C++\", interactive=False)\n",
+    "    with gr.Row():\n",
+    "        python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "        cpp_out = gr.TextArea(label=\"C++ result:\", elem_classes=[\"cpp\"])\n",
+    "\n",
+    "    sample_program.change(select_sample_program, inputs=[sample_program], outputs=[python])\n",
+    "    convert.click(optimize, inputs=[python, model], outputs=[cpp])\n",
+    "    python_run.click(execute_python, inputs=[python], outputs=[python_out])\n",
+    "    cpp_run.click(execute_cpp, inputs=[cpp], outputs=[cpp_out])\n",
+    "\n",
+    "ui.launch(inbrowser=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d0ad093-425b-488e-8c3f-67f729dd9c06",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

optimized.cpp

@@ -0,0 +1,65 @@
+#include <iostream>
+#include <vector>
+#include <chrono>
+#include <limits>
+#include <iomanip>
+
+class LCG {
+private:
+    uint64_t value;
+    const uint64_t a = 1664525;
+    const uint64_t c = 1013904223;
+    const uint64_t m = 1ULL << 32;
+
+public:
+    LCG(uint64_t seed) : value(seed) {}
+
+    uint64_t next() {
+        value = (a * value + c) % m;
+        return value;
+    }
+};
+
+int64_t max_subarray_sum(int n, uint64_t seed, int min_val, int max_val) {
+    LCG lcg(seed);
+    std::vector<int> random_numbers(n);
+    for (int i = 0; i < n; ++i) {
+        random_numbers[i] = static_cast<int>(lcg.next() % (max_val - min_val + 1) + min_val);
+    }
+
+    int64_t max_sum = std::numeric_limits<int64_t>::min();
+    int64_t current_sum = 0;
+    for (int i = 0; i < n; ++i) {
+        current_sum = std::max(static_cast<int64_t>(random_numbers[i]), current_sum + random_numbers[i]);
+        max_sum = std::max(max_sum, current_sum);
+    }
+    return max_sum;
+}
+
+int64_t total_max_subarray_sum(int n, uint64_t initial_seed, int min_val, int max_val) {
+    int64_t total_sum = 0;
+    LCG lcg(initial_seed);
+    for (int i = 0; i < 20; ++i) {
+        uint64_t seed = lcg.next();
+        total_sum += max_subarray_sum(n, seed, min_val, max_val);
+    }
+    return total_sum;
+}
+
+int main() {
+    int n = 10000;
+    uint64_t initial_seed = 42;
+    int min_val = -10;
+    int max_val = 10;
+
+    auto start_time = std::chrono::high_resolution_clock::now();
+    int64_t result = total_max_subarray_sum(n, initial_seed, min_val, max_val);
+    auto end_time = std::chrono::high_resolution_clock::now();
+
+    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
+
+    std::cout << "Total Maximum Subarray Sum (20 runs): " << result << std::endl;
+    std::cout << "Execution Time: " << std::fixed << std::setprecision(6) << duration.count() / 1e6 << " seconds" << std::endl;
+
+    return 0;
+}

requirements.txt

@@ -0,0 +1,2 @@
+ollama gradio
+ollama gradio 

simple.cpp

@@ -0,0 +1,7 @@
+
+#include <iostream>
+
+int main() {
+    std::cout << "Hello";
+    return 0;
+}

week6/.ipynb_checkpoints/Untitled-checkpoint.ipynb

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week6/.ipynb_checkpoints/day1-checkpoint.ipynb

@@ -0,0 +1,437 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "28a0673e-96b5-43f2-8a8b-bd033bf851b0",
+   "metadata": {},
+   "source": [
+    "# The Big Project begins!!\n",
+    "\n",
+    "## The Product Pricer\n",
+    "\n",
+    "A model that can estimate how much something costs, from its description.\n",
+    "\n",
+    "## Data Curation Part 1\n",
+    "\n",
+    "Today we'll begin our scrubbing and curating our dataset by focusing on a subset of the data: Home Appliances.\n",
+    "\n",
+    "The dataset is here:  \n",
+    "https://huggingface.co/datasets/McAuley-Lab/Amazon-Reviews-2023\n",
+    "\n",
+    "And the folder with all the product datasets is here:  \n",
+    "https://huggingface.co/datasets/McAuley-Lab/Amazon-Reviews-2023/tree/main/raw/meta_categories"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "67cedf85-8125-4322-998e-9375fe745597",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "from dotenv import load_dotenv\n",
+    "from huggingface_hub import login\n",
+    "from datasets import load_dataset, Dataset, DatasetDict\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7390a6aa-79cb-4dea-b6d7-de7e4b13e472",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv(override=True)\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['HF_TOKEN'] = os.getenv('HF_TOKEN', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0732274a-aa6a-44fc-aee2-40dc8a8e4451",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Log in to HuggingFace\n",
+    "\n",
+    "hf_token = os.environ['HF_TOKEN']\n",
+    "login(hf_token, add_to_git_credential=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e7cb2e20-7fac-44c1-8a4b-131dd37ee06e",
+   "metadata": {},
+   "source": [
+    "## One more import - the Item class\n",
+    "\n",
+    "If you get an error that you need to agree to Meta's terms when you run this, then follow the link it provides you and follow their instructions. You should get approved by Meta within minutes.\n",
+    "\n",
+    "See the last cell in [this colab](https://colab.research.google.com/drive/1deJO03YZTXUwcq2vzxWbiBhrRuI29Vo8?usp=sharing#scrollTo=FqyF5jZQkIl_) for steps to take if Meta doesn't approve.\n",
+    "\n",
+    "Any problems - message me or email me!  \n",
+    "\n",
+    "With thanks to student Dr John S. for pointing out that this import needs to come after signing in to HF"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5521526-0da9-42d7-99e3-f950fab71662",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from items import Item"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1adcf323-de9d-4c24-a9c3-d7ae554d06ca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "049885d4-fdfa-4ff0-a932-4a2ed73928e2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load in our dataset\n",
+    "\n",
+    "dataset = load_dataset(\"McAuley-Lab/Amazon-Reviews-2023\", f\"raw_meta_Appliances\", split=\"full\", trust_remote_code=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cde08860-b393-49b8-a620-06a8c0990a64",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(f\"Number of Appliances: {len(dataset):,}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3e29a5ab-ca61-41cc-9b33-22d374681b85",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Investigate a particular datapoint\n",
+    "datapoint = dataset[2]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "40a4e10f-6710-4780-a95e-6c0030c3fb87",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Investigate\n",
+    "\n",
+    "print(datapoint[\"title\"])\n",
+    "print(datapoint[\"description\"])\n",
+    "print(datapoint[\"features\"])\n",
+    "print(datapoint[\"details\"])\n",
+    "print(datapoint[\"price\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d356c6f-b6e8-4e01-98cd-c562d132aafa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# How many have prices?\n",
+    "\n",
+    "prices = 0\n",
+    "for datapoint in dataset:\n",
+    "    try:\n",
+    "        price = float(datapoint[\"price\"])\n",
+    "        if price > 0:\n",
+    "            prices += 1\n",
+    "    except ValueError as e:\n",
+    "        pass\n",
+    "\n",
+    "print(f\"There are {prices:,} with prices which is {prices/len(dataset)*100:,.1f}%\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bd890259-aa25-4097-9524-f91c2bdd719b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# For those with prices, gather the price and the length\n",
+    "\n",
+    "prices = []\n",
+    "lengths = []\n",
+    "for datapoint in dataset:\n",
+    "    try:\n",
+    "        price = float(datapoint[\"price\"])\n",
+    "        if price > 0:\n",
+    "            prices.append(price)\n",
+    "            contents = datapoint[\"title\"] + str(datapoint[\"description\"]) + str(datapoint[\"features\"]) + str(datapoint[\"details\"])\n",
+    "            lengths.append(len(contents))\n",
+    "    except ValueError as e:\n",
+    "        pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "89078cb1-9679-4eb0-b295-599b8586bcd1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the distribution of lengths\n",
+    "\n",
+    "plt.figure(figsize=(15, 6))\n",
+    "plt.title(f\"Lengths: Avg {sum(lengths)/len(lengths):,.0f} and highest {max(lengths):,}\\n\")\n",
+    "plt.xlabel('Length (chars)')\n",
+    "plt.ylabel('Count')\n",
+    "plt.hist(lengths, rwidth=0.7, color=\"lightblue\", bins=range(0, 6000, 100))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c38e0c43-9f7a-450e-a911-c94d37d9b9c3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the distribution of prices\n",
+    "\n",
+    "plt.figure(figsize=(15, 6))\n",
+    "plt.title(f\"Prices: Avg {sum(prices)/len(prices):,.2f} and highest {max(prices):,}\\n\")\n",
+    "plt.xlabel('Price ($)')\n",
+    "plt.ylabel('Count')\n",
+    "plt.hist(prices, rwidth=0.7, color=\"orange\", bins=range(0, 1000, 10))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eabc7c61-0cd2-41f4-baa1-b85400bbf87f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# So what is this item??\n",
+    "\n",
+    "for datapoint in dataset:\n",
+    "    try:\n",
+    "        price = float(datapoint[\"price\"])\n",
+    "        if price > 21000:\n",
+    "            print(datapoint['title'])\n",
+    "    except ValueError as e:\n",
+    "        pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3668ae25-3461-4e6e-9ccb-221c1925a497",
+   "metadata": {},
+   "source": [
+    "This is the closest I can find - looks like it's going at a bargain price!!\n",
+    "\n",
+    "https://www.amazon.com/TurboChef-Electric-Countertop-Microwave-Convection/dp/B01D05U9NO/"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a0d02f58-23f6-4f81-a779-7c0555afd13d",
+   "metadata": {},
+   "source": [
+    "## Now it's time to curate our dataset\n",
+    "\n",
+    "We select items that cost between 1 and 999 USD\n",
+    "\n",
+    "We will be create Item instances, which truncate the text to fit within 180 tokens using the right Tokenizer\n",
+    "\n",
+    "And will create a prompt to be used during Training.\n",
+    "\n",
+    "Items will be rejected if they don't have sufficient characters.\n",
+    "\n",
+    "## But why 180 tokens??\n",
+    "\n",
+    "A student asked me a great question - why are we truncating to 180 tokens? How did we determine that number? (Thank you Moataz A. for the excellent question).\n",
+    "\n",
+    "The answer: this is an example of a \"hyper-parameter\". In other words, it's basically trial and error! We want a sufficiently large number of tokens so that we have enough useful information to gauge the price. But we also want to keep the number low so that we can train efficiently. You'll see this in action in Week 7.\n",
+    "\n",
+    "I started with a number that seemed reasonable, and experimented with a few variations before settling on 180. If you have time, you should do the same! You might find that you can beat my results by finding a better balance. This kind of trial-and-error might sound a bit unsatisfactory, but it's a crucial part of the data science R&D process.\n",
+    "\n",
+    "There's another interesting reason why we might favor a lower number of tokens in the training data. When we eventually get to use our model at inference time, we'll want to provide new products and have it estimate a price. And we'll be using short descriptions of products - like 1-2 sentences. For best performance, we should size our training data to be similar to the inputs we will provide at inference time.\n",
+    "\n",
+    "## But I see in items.py it constrains inputs to 160 tokens?\n",
+    "\n",
+    "Another great question from Moataz A.! The description of the products is limited to 160 tokens because we add some more text before and after the description to turn it into a prompt. That brings it to around 180 tokens in total.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "430b432f-b769-41da-9506-a238cb5cf1b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create an Item object for each with a price\n",
+    "\n",
+    "items = []\n",
+    "for datapoint in dataset:\n",
+    "    try:\n",
+    "        price = float(datapoint[\"price\"])\n",
+    "        if price > 0:\n",
+    "            item = Item(datapoint, price)\n",
+    "            if item.include:\n",
+    "                items.append(item)\n",
+    "    except ValueError as e:\n",
+    "        pass\n",
+    "\n",
+    "print(f\"There are {len(items):,} items\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d570794-6f1d-462e-b567-a46bae3556a1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Look at the first item\n",
+    "\n",
+    "items[1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "70219e99-22cc-4e08-9121-51f9707caef0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Investigate the prompt that will be used during training - the model learns to complete this\n",
+    "\n",
+    "print(items[100].prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d9998b8d-d746-4541-9ac2-701108e0e8fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Investigate the prompt that will be used during testing - the model has to complete this\n",
+    "\n",
+    "print(items[100].test_prompt())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7a116369-335a-412b-b70c-2add6675c2e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the distribution of token counts\n",
+    "\n",
+    "tokens = [item.token_count for item in items]\n",
+    "plt.figure(figsize=(15, 6))\n",
+    "plt.title(f\"Token counts: Avg {sum(tokens)/len(tokens):,.1f} and highest {max(tokens):,}\\n\")\n",
+    "plt.xlabel('Length (tokens)')\n",
+    "plt.ylabel('Count')\n",
+    "plt.hist(tokens, rwidth=0.7, color=\"green\", bins=range(0, 300, 10))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8d1744aa-71e7-435e-876e-91f06583211a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the distribution of prices\n",
+    "\n",
+    "prices = [item.price for item in items]\n",
+    "plt.figure(figsize=(15, 6))\n",
+    "plt.title(f\"Prices: Avg {sum(prices)/len(prices):,.1f} and highest {max(prices):,}\\n\")\n",
+    "plt.xlabel('Price ($)')\n",
+    "plt.ylabel('Count')\n",
+    "plt.hist(prices, rwidth=0.7, color=\"purple\", bins=range(0, 300, 10))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b58dc61-747f-46f7-b9e0-c205db4f3e5e",
+   "metadata": {},
+   "source": [
+    "## Sidenote\n",
+    "\n",
+    "If you like the variety of colors that matplotlib can use in its charts, you should bookmark this:\n",
+    "\n",
+    "https://matplotlib.org/stable/gallery/color/named_colors.html\n",
+    "\n",
+    "## Todos for you:\n",
+    "\n",
+    "- Review the Item class and check you're comfortable with it\n",
+    "- Examine some Item objects, look at the training prompt with `item.prompt` and test prompt with `item.test_prompt()`\n",
+    "- Make some more histograms to better understand the data\n",
+    "\n",
+    "## Next time we will combine with many other types of product\n",
+    "\n",
+    "Like Electronics and Automotive. This will give us a massive dataset, and we can then be picky about choosing a subset that will be most suitable for training."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "01401283-d111-40a7-96e5-0ca05bb20857",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week6/.ipynb_checkpoints/day2-checkpoint.ipynb

@@ -0,0 +1,632 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "28a0673e-96b5-43f2-8a8b-bd033bf851b0",
+   "metadata": {},
+   "source": [
+    "# The Product Pricer Continued\n",
+    "\n",
+    "A model that can estimate how much something costs, from its description.\n",
+    "\n",
+    "## Data Curation Part 2\n",
+    "\n",
+    "Today we'll extend our dataset to a greater coverage, and craft it into an excellent dataset for training.  \n",
+    "Data curation can seem less exciting than other things we work on, but it's a crucial part of the LLM engineers' responsibility and an important craft to hone, so that you can build your own commercial solutions with high quality datasets.\n",
+    "\n",
+    "The dataset is here:  \n",
+    "https://huggingface.co/datasets/McAuley-Lab/Amazon-Reviews-2023\n",
+    "\n",
+    "And the folder with all the product datasets is here:  \n",
+    "https://huggingface.co/datasets/McAuley-Lab/Amazon-Reviews-2023/tree/main/raw/meta_categories\n",
+    "\n",
+    "## Important Note - read me first please\n",
+    "\n",
+    "We are about to craft a massive dataset of 400,000 items covering multiple types of product. In Week 7 we will be using this data to train our own model. It's a pretty big dataset, and depending on the GPU you select, training could take 20+ hours. It will be really good fun, but it could cost a few dollars in compute units.\n",
+    "\n",
+    "As an alternative, if you want to keep things quick & low cost, you can work with a smaller dataset focused only on Home Appliances. You'll be able to cover the same learning points; the results will be good -- not quite as good as the full dataset, but still pretty amazing! If you'd prefer to do this, I've set up an alternative jupyter notebook in this folder called `lite.ipynb` that you should use in place of this one.\n",
+    "\n",
+    "Also, if you'd prefer, you can shortcut running all this data curation by downloading the pickle files that we save in the last cell. The pickle files are available here: https://drive.google.com/drive/folders/1f_IZGybvs9o0J5sb3xmtTEQB3BXllzrW"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "67cedf85-8125-4322-998e-9375fe745597",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import random\n",
+    "from dotenv import load_dotenv\n",
+    "from huggingface_hub import login\n",
+    "from datasets import load_dataset, Dataset, DatasetDict\n",
+    "from loaders import ItemLoader\n",
+    "import matplotlib.pyplot as plt\n",
+    "from collections import Counter, defaultdict\n",
+    "import numpy as np\n",
+    "import pickle"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7390a6aa-79cb-4dea-b6d7-de7e4b13e472",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv(override=True)\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['HF_TOKEN'] = os.getenv('HF_TOKEN', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0732274a-aa6a-44fc-aee2-40dc8a8e4451",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Log in to HuggingFace\n",
+    "\n",
+    "hf_token = os.environ['HF_TOKEN']\n",
+    "login(hf_token, add_to_git_credential=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6746144c-2e19-485a-8086-368c144722b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# One more import after HF login\n",
+    "\n",
+    "from items import Item"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1adcf323-de9d-4c24-a9c3-d7ae554d06ca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "01065d69-765c-42c8-9f90-68b8c8754068",
+   "metadata": {},
+   "source": [
+    "## The ItemLoader code\n",
+    "\n",
+    "Look in loaders.py - there's some useful code to make life easier for us"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "049885d4-fdfa-4ff0-a932-4a2ed73928e2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load in the same dataset as last time\n",
+    "\n",
+    "items = ItemLoader(\"Appliances\").load()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ffba41b5-ddb6-4359-9790-9b2db900eee1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Look for a familiar item..\n",
+    "print(items[1].prompt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e2b6dc50-ac5c-4cf2-af2e-968ed8ef86d7",
+   "metadata": {},
+   "source": [
+    "## Now to SCALE UP\n",
+    "\n",
+    "Let's look at all datasets of all the items that you might find in a large home retail store - electrical, electronic, office and related, but not clothes / beauty / books."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d1d06cd3-f3c2-44f0-a9f2-13b54ff8be5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset_names = [\n",
+    "    \"Automotive\",\n",
+    "    \"Electronics\",\n",
+    "    \"Office_Products\",\n",
+    "    \"Tools_and_Home_Improvement\",\n",
+    "    \"Cell_Phones_and_Accessories\",\n",
+    "    \"Toys_and_Games\",\n",
+    "    \"Appliances\",\n",
+    "    \"Musical_Instruments\",\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aa8fd0f0-509a-4298-8fcc-e499a061e1be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "items = []\n",
+    "for dataset_name in dataset_names:\n",
+    "    loader = ItemLoader(dataset_name)\n",
+    "    items.extend(loader.load())\n",
+    "\n",
+    "# Now, time for a coffee break!!\n",
+    "# By the way, I put the biggest datasets first.. it gets faster."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3e29a5ab-ca61-41cc-9b33-22d374681b85",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(f\"A grand total of {len(items):,} items\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "89078cb1-9679-4eb0-b295-599b8586bcd1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the distribution of token counts again\n",
+    "\n",
+    "tokens = [item.token_count for item in items]\n",
+    "plt.figure(figsize=(15, 6))\n",
+    "plt.title(f\"Token counts: Avg {sum(tokens)/len(tokens):,.1f} and highest {max(tokens):,}\\n\")\n",
+    "plt.xlabel('Length (tokens)')\n",
+    "plt.ylabel('Count')\n",
+    "plt.hist(tokens, rwidth=0.7, color=\"skyblue\", bins=range(0, 300, 10))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c38e0c43-9f7a-450e-a911-c94d37d9b9c3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the distribution of prices\n",
+    "\n",
+    "prices = [item.price for item in items]\n",
+    "plt.figure(figsize=(15, 6))\n",
+    "plt.title(f\"Prices: Avg {sum(prices)/len(prices):,.1f} and highest {max(prices):,}\\n\")\n",
+    "plt.xlabel('Price ($)')\n",
+    "plt.ylabel('Count')\n",
+    "plt.hist(prices, rwidth=0.7, color=\"blueviolet\", bins=range(0, 1000, 10))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eabc7c61-0cd2-41f4-baa1-b85400bbf87f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "category_counts = Counter()\n",
+    "for item in items:\n",
+    "    category_counts[item.category]+=1\n",
+    "\n",
+    "categories = category_counts.keys()\n",
+    "counts = [category_counts[category] for category in categories]\n",
+    "\n",
+    "# Bar chart by category\n",
+    "plt.figure(figsize=(15, 6))\n",
+    "plt.bar(categories, counts, color=\"goldenrod\")\n",
+    "plt.title('How many in each category')\n",
+    "plt.xlabel('Categories')\n",
+    "plt.ylabel('Count')\n",
+    "\n",
+    "plt.xticks(rotation=30, ha='right')\n",
+    "\n",
+    "# Add value labels on top of each bar\n",
+    "for i, v in enumerate(counts):\n",
+    "    plt.text(i, v, f\"{v:,}\", ha='center', va='bottom')\n",
+    "\n",
+    "# Display the chart\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e5b6e987-83ba-4262-a082-57c6b0741062",
+   "metadata": {},
+   "source": [
+    "# Objective\n",
+    "\n",
+    "Craft a dataset which is more balanced in terms of prices. Less heavily scewed to cheap items, with an average that's higher than $60. Try to balance out the categories - fewer Automotive items."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3b9424c1-44e0-499a-b45e-a35246655469",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a dict with a key of each price from $1 to $999\n",
+    "# And in the value, put a list of items with that price (to nearest round number)\n",
+    "\n",
+    "slots = defaultdict(list)\n",
+    "for item in items:\n",
+    "    slots[round(item.price)].append(item)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7805a7f1-4ad8-48f6-bea3-d64b64894804",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a dataset called \"sample\" which tries to more evenly take from the range of prices\n",
+    "# And gives more weight to items from categories other than Automotive\n",
+    "# Set random seed for reproducibility\n",
+    "\n",
+    "np.random.seed(42)\n",
+    "random.seed(42)\n",
+    "sample = []\n",
+    "for i in range(1, 1000):\n",
+    "    slot = slots[i]\n",
+    "    if i>=240:\n",
+    "        sample.extend(slot)\n",
+    "    elif len(slot) <= 1200:\n",
+    "        sample.extend(slot)\n",
+    "    else:\n",
+    "        weights = np.array([1 if item.category=='Automotive' else 5 for item in slot])\n",
+    "        weights = weights / np.sum(weights)\n",
+    "        selected_indices = np.random.choice(len(slot), size=1200, replace=False, p=weights)\n",
+    "        selected = [slot[i] for i in selected_indices]\n",
+    "        sample.extend(selected)\n",
+    "\n",
+    "print(f\"There are {len(sample):,} items in the sample\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "430b432f-b769-41da-9506-a238cb5cf1b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the distribution of prices in sample\n",
+    "\n",
+    "prices = [float(item.price) for item in sample]\n",
+    "plt.figure(figsize=(15, 10))\n",
+    "plt.title(f\"Avg {sum(prices)/len(prices):.2f} and highest {max(prices):,.2f}\\n\")\n",
+    "plt.xlabel('Price ($)')\n",
+    "plt.ylabel('Count')\n",
+    "plt.hist(prices, rwidth=0.7, color=\"darkblue\", bins=range(0, 1000, 10))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d570794-6f1d-462e-b567-a46bae3556a1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# OK, we did well in terms of raising the average price and having a smooth-ish population of prices\n",
+    "# Let's see the categories\n",
+    "\n",
+    "category_counts = Counter()\n",
+    "for item in sample:\n",
+    "    category_counts[item.category]+=1\n",
+    "\n",
+    "categories = category_counts.keys()\n",
+    "counts = [category_counts[category] for category in categories]\n",
+    "\n",
+    "# Create bar chart\n",
+    "plt.figure(figsize=(15, 6))\n",
+    "plt.bar(categories, counts, color=\"lightgreen\")\n",
+    "\n",
+    "# Customize the chart\n",
+    "plt.title('How many in each category')\n",
+    "plt.xlabel('Categories')\n",
+    "plt.ylabel('Count')\n",
+    "\n",
+    "plt.xticks(rotation=30, ha='right')\n",
+    "\n",
+    "# Add value labels on top of each bar\n",
+    "for i, v in enumerate(counts):\n",
+    "    plt.text(i, v, f\"{v:,}\", ha='center', va='bottom')\n",
+    "\n",
+    "# Display the chart\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6609d77c-3e0a-4679-9129-c7cdc3273070",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Automotive still in the lead, but improved somewhat\n",
+    "# For another perspective, let's look at a pie\n",
+    "\n",
+    "plt.figure(figsize=(12, 10))\n",
+    "plt.pie(counts, labels=categories, autopct='%1.0f%%', startangle=90)\n",
+    "\n",
+    "# Add a circle at the center to create a donut chart (optional)\n",
+    "centre_circle = plt.Circle((0,0), 0.70, fc='white')\n",
+    "fig = plt.gcf()\n",
+    "fig.gca().add_artist(centre_circle)\n",
+    "plt.title('Categories')\n",
+    "\n",
+    "# Equal aspect ratio ensures that pie is drawn as a circle\n",
+    "plt.axis('equal')  \n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ac046cc1-2717-415b-96ad-b73b2950d235",
+   "metadata": {},
+   "source": [
+    "# Dataset Curated!\n",
+    "\n",
+    "We've crafted an excellent dataset.\n",
+    "\n",
+    "Let's do some final checks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "70219e99-22cc-4e08-9121-51f9707caef0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# How does the price vary with the character count of the prompt?\n",
+    "\n",
+    "sizes = [len(item.prompt) for item in sample]\n",
+    "prices = [item.price for item in sample]\n",
+    "\n",
+    "# Create the scatter plot\n",
+    "plt.figure(figsize=(15, 8))\n",
+    "plt.scatter(sizes, prices, s=0.2, color=\"red\")\n",
+    "\n",
+    "# Add labels and title\n",
+    "plt.xlabel('Size')\n",
+    "plt.ylabel('Price')\n",
+    "plt.title('Is there a simple correlation?')\n",
+    "\n",
+    "# Display the plot\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "30ae1453-b9fc-40db-8310-65d850c4b1da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def report(item):\n",
+    "    prompt = item.prompt\n",
+    "    tokens = Item.tokenizer.encode(item.prompt)\n",
+    "    print(prompt)\n",
+    "    print(tokens[-10:])\n",
+    "    print(Item.tokenizer.batch_decode(tokens[-10:]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d9998b8d-d746-4541-9ac2-701108e0e8fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "report(sample[398000])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7aa0a3fc-d2fe-4e6e-8fdb-96913df2f588",
+   "metadata": {},
+   "source": [
+    "## Observation\n",
+    "\n",
+    "An interesting thing about the Llama tokenizer is that every number from 1 to 999 gets mapped to 1 token, much as we saw with gpt-4o. The same is not true of qwen2, gemma and phi3, which all map individual digits to tokens. This does turn out to be a bit useful for our project, although it's not an essential requirement."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0f03c0ee-3103-4603-af5c-b484884a3aa2",
+   "metadata": {},
+   "source": [
+    "# Finally\n",
+    "\n",
+    "It's time to break down our data into a training, test and validation dataset.\n",
+    "\n",
+    "It's typical to use 5%-10% of your data for testing purposes, but actually we have far more than we need at this point. We'll take 400,000 points for training, and we'll reserve 2,000 for testing, although we won't use all of them.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3b163ca2-18ef-4c26-8e9d-88eb55f114f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "random.seed(42)\n",
+    "random.shuffle(sample)\n",
+    "train = sample[:400_000]\n",
+    "test = sample[400_000:402_000]\n",
+    "print(f\"Divided into a training set of {len(train):,} items and test set of {len(test):,} items\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "299b9816-8885-4798-829a-69d66d60eb01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(train[0].prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "97222da3-9f2c-4d15-a5cd-5e5f8dbde6cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(test[0].test_prompt())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7a116369-335a-412b-b70c-2add6675c2e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the distribution of prices in the first 250 test points\n",
+    "\n",
+    "prices = [float(item.price) for item in test[:250]]\n",
+    "plt.figure(figsize=(15, 6))\n",
+    "plt.title(f\"Avg {sum(prices)/len(prices):.2f} and highest {max(prices):,.2f}\\n\")\n",
+    "plt.xlabel('Price ($)')\n",
+    "plt.ylabel('Count')\n",
+    "plt.hist(prices, rwidth=0.7, color=\"darkblue\", bins=range(0, 1000, 10))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d522d752-6f66-4786-a4dc-8ef51842558c",
+   "metadata": {},
+   "source": [
+    "# Finally - upload your brand new dataset\n",
+    "\n",
+    "Convert to prompts and upload to HuggingFace hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fa11b3e5-fcf4-4efc-a573-f6f67fec3e73",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_prompts = [item.prompt for item in train]\n",
+    "train_prices = [item.price for item in train]\n",
+    "test_prompts = [item.test_prompt() for item in test]\n",
+    "test_prices = [item.price for item in test]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b020ab1b-7153-4e5f-b8a3-d5bc2fafb6df",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a Dataset from the lists\n",
+    "\n",
+    "train_dataset = Dataset.from_dict({\"text\": train_prompts, \"price\": train_prices})\n",
+    "test_dataset = Dataset.from_dict({\"text\": test_prompts, \"price\": test_prices})\n",
+    "dataset = DatasetDict({\n",
+    "    \"train\": train_dataset,\n",
+    "    \"test\": test_dataset\n",
+    "})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "17639641-fb55-44e2-a463-b0b394d00f32",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Uncomment these lines if you're ready to push to the hub, and replace my name with your HF username\n",
+    "\n",
+    "# HF_USER = \"ed-donner\"\n",
+    "# DATASET_NAME = f\"{HF_USER}/pricer-data\"\n",
+    "# dataset.push_to_hub(DATASET_NAME, private=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b85733ba-d165-4f07-b055-46803543edfe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# One more thing!\n",
+    "# Let's pickle the training and test dataset so we don't have to execute all this code next time!\n",
+    "\n",
+    "with open('train.pkl', 'wb') as file:\n",
+    "    pickle.dump(train, file)\n",
+    "\n",
+    "with open('test.pkl', 'wb') as file:\n",
+    "    pickle.dump(test, file)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b58dc61-747f-46f7-b9e0-c205db4f3e5e",
+   "metadata": {},
+   "source": [
+    "## Todos for you:\n",
+    "\n",
+    "- Investigate the dataset more!\n",
+    "- Confirm that the tokenizer tokenizes all 3 digit prices into 1 token"
+   ]
+  }
+ ],
+ "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week6/.ipynb_checkpoints/day3-checkpoint.ipynb

@@ -0,0 +1,926 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "db8736a7-ed94-441c-9556-831fa57b5a10",
+   "metadata": {},
+   "source": [
+    "# The Product Pricer Continued\n",
+    "\n",
+    "A model that can estimate how much something costs, from its description.\n",
+    "\n",
+    "## Baseline Models\n",
+    "\n",
+    "Today we work on the simplest models to act as a starting point that we will beat."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "681c717b-4c24-4ac3-a5f3-3c5881d6e70a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import math\n",
+    "import json\n",
+    "import random\n",
+    "from dotenv import load_dotenv\n",
+    "from huggingface_hub import login\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import pickle\n",
+    "from collections import Counter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "933b6e75-3661-4f30-b0b5-c28d04e3748e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# More imports for our traditional machine learning\n",
+    "\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from sklearn.linear_model import LinearRegression\n",
+    "from sklearn.metrics import mean_squared_error, r2_score\n",
+    "from sklearn.preprocessing import StandardScaler"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b3c87c11-8dbe-4b8c-8989-01e3d3a60026",
+   "metadata": {},
+   "source": [
+    "## NLP imports\n",
+    "\n",
+    "In the next cell, we have more imports for our NLP related machine learning.  \n",
+    "If the gensim import gives you an error like \"Cannot import name 'triu' from 'scipy.linalg' then please run in another cell:  \n",
+    "`!pip install \"scipy<1.13\"`  \n",
+    "As described on StackOverflow [here](https://stackoverflow.com/questions/78279136/importerror-cannot-import-name-triu-from-scipy-linalg-when-importing-gens).  \n",
+    "Many thanks to students Arnaldo G and Ard V for sorting this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "42cf33b7-7abd-44ba-9780-c156b70473b5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# NLP related imports\n",
+    "\n",
+    "from sklearn.feature_extraction.text import CountVectorizer\n",
+    "from gensim.models import Word2Vec\n",
+    "from gensim.utils import simple_preprocess"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a1ac3ec0-183c-4a12-920b-b06397f86815",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Finally, more imports for more advanced machine learning\n",
+    "\n",
+    "from sklearn.svm import LinearSVR\n",
+    "from sklearn.ensemble import RandomForestRegressor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6c01ee5f-c4fc-44fe-9d3a-907e8a0426d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Constants - used for printing to stdout in color\n",
+    "\n",
+    "GREEN = \"\\033[92m\"\n",
+    "YELLOW = \"\\033[93m\"\n",
+    "RED = \"\\033[91m\"\n",
+    "RESET = \"\\033[0m\"\n",
+    "COLOR_MAP = {\"red\":RED, \"orange\": YELLOW, \"green\": GREEN}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36d05bdc-0155-4c72-a7ee-aa4e614ffd3c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv(override=True)\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['HF_TOKEN'] = os.getenv('HF_TOKEN', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4dd3aad2-6f99-433c-8792-e461d2f06622",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Log in to HuggingFace\n",
+    "\n",
+    "hf_token = os.environ['HF_TOKEN']\n",
+    "login(hf_token, add_to_git_credential=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ff3942d8-b010-46b5-a665-15554eae9776",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# One more import after logging in\n",
+    "\n",
+    "from items import Item"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c830ed3e-24ee-4af6-a07b-a1bfdcd39278",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5105e13c-bca0-4c70-bfaa-649345f53322",
+   "metadata": {},
+   "source": [
+    "# Loading the pkl files\n",
+    "\n",
+    "Let's avoid curating all our data again! Load in the pickle files\n",
+    "\n",
+    "If you didn't already create these in Day 2, you can also download them from my google drive (you'll also find the slides here):  \n",
+    "https://drive.google.com/drive/folders/1JwNorpRHdnf_pU0GE5yYtfKlyrKC3CoV?usp=sharing\n",
+    "\n",
+    "But note that the files are quite large - you might need to get a coffee!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c9b05f4-c9eb-462c-8d86-de9140a2d985",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open('train.pkl', 'rb') as file:\n",
+    "    train = pickle.load(file)\n",
+    "\n",
+    "with open('test.pkl', 'rb') as file:\n",
+    "    test = pickle.load(file)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a84638f7-5ff7-4f54-8751-3ef156264aee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Remind ourselves the training prompt\n",
+    "\n",
+    "print(train[0].prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b7619c85-6e9e-48a1-8efe-c6a60471b87c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Remind a test prompt\n",
+    "\n",
+    "print(train[0].price)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bcccf130-125a-4958-bac3-f46dfcb29b3f",
+   "metadata": {},
+   "source": [
+    "## Unveiling a mighty script that we will use a lot!\n",
+    "\n",
+    "A rather pleasing Test Harness that will evaluate any model against 250 items from the Test set\n",
+    "\n",
+    "And show us the results in a visually satisfying way.\n",
+    "\n",
+    "You write a function of this form:\n",
+    "\n",
+    "```\n",
+    "def my_prediction_function(item):\n",
+    "    # my code here\n",
+    "    return my_estimate\n",
+    "```\n",
+    "\n",
+    "And then you call:\n",
+    "\n",
+    "`Tester.test(my_prediction_function)`\n",
+    "\n",
+    "To evaluate your model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5793f5c-e23e-4a74-9496-1e30dd1e8935",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Tester:\n",
+    "\n",
+    "    def __init__(self, predictor, title=None, data=test, size=250):\n",
+    "        self.predictor = predictor\n",
+    "        self.data = data\n",
+    "        self.title = title or predictor.__name__.replace(\"_\", \" \").title()\n",
+    "        self.size = size\n",
+    "        self.guesses = []\n",
+    "        self.truths = []\n",
+    "        self.errors = []\n",
+    "        self.sles = []\n",
+    "        self.colors = []\n",
+    "\n",
+    "    def color_for(self, error, truth):\n",
+    "        if error<40 or error/truth < 0.2:\n",
+    "            return \"green\"\n",
+    "        elif error<80 or error/truth < 0.4:\n",
+    "            return \"orange\"\n",
+    "        else:\n",
+    "            return \"red\"\n",
+    "    \n",
+    "    def run_datapoint(self, i):\n",
+    "        datapoint = self.data[i]\n",
+    "        guess = self.predictor(datapoint)\n",
+    "        truth = datapoint.price\n",
+    "        error = abs(guess - truth)\n",
+    "        log_error = math.log(truth+1) - math.log(guess+1)\n",
+    "        sle = log_error ** 2\n",
+    "        color = self.color_for(error, truth)\n",
+    "        title = datapoint.title if len(datapoint.title) <= 40 else datapoint.title[:40]+\"...\"\n",
+    "        self.guesses.append(guess)\n",
+    "        self.truths.append(truth)\n",
+    "        self.errors.append(error)\n",
+    "        self.sles.append(sle)\n",
+    "        self.colors.append(color)\n",
+    "        print(f\"{COLOR_MAP[color]}{i+1}: Guess: ${guess:,.2f} Truth: ${truth:,.2f} Error: ${error:,.2f} SLE: {sle:,.2f} Item: {title}{RESET}\")\n",
+    "\n",
+    "    def chart(self, title):\n",
+    "        max_error = max(self.errors)\n",
+    "        plt.figure(figsize=(12, 8))\n",
+    "        max_val = max(max(self.truths), max(self.guesses))\n",
+    "        plt.plot([0, max_val], [0, max_val], color='deepskyblue', lw=2, alpha=0.6)\n",
+    "        plt.scatter(self.truths, self.guesses, s=3, c=self.colors)\n",
+    "        plt.xlabel('Ground Truth')\n",
+    "        plt.ylabel('Model Estimate')\n",
+    "        plt.xlim(0, max_val)\n",
+    "        plt.ylim(0, max_val)\n",
+    "        plt.title(title)\n",
+    "        plt.show()\n",
+    "\n",
+    "    def report(self):\n",
+    "        average_error = sum(self.errors) / self.size\n",
+    "        rmsle = math.sqrt(sum(self.sles) / self.size)\n",
+    "        hits = sum(1 for color in self.colors if color==\"green\")\n",
+    "        title = f\"{self.title} Error=${average_error:,.2f} RMSLE={rmsle:,.2f} Hits={hits/self.size*100:.1f}%\"\n",
+    "        self.chart(title)\n",
+    "\n",
+    "    def run(self):\n",
+    "        self.error = 0\n",
+    "        for i in range(self.size):\n",
+    "            self.run_datapoint(i)\n",
+    "        self.report()\n",
+    "\n",
+    "    @classmethod\n",
+    "    def test(cls, function):\n",
+    "        cls(function).run()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "066fef03-8338-4526-9df3-89b649ad4f0a",
+   "metadata": {},
+   "source": [
+    "# Now for something basic\n",
+    "\n",
+    "What's the very simplest model you could imagine?\n",
+    "\n",
+    "Let's start with a random number generator!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "66ea68e8-ab1b-4f0d-aba4-a59574d8f85e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def random_pricer(item):\n",
+    "    return random.randrange(1,1000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "53d941cb-5b73-44ea-b893-3a0ce9997066",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set the random seed\n",
+    "\n",
+    "random.seed(42)\n",
+    "\n",
+    "# Run our TestRunner\n",
+    "Tester.test(random_pricer)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "97451c73-9c1b-43a8-b3b9-9c41942e48a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# That was fun!\n",
+    "# We can do better - here's another rather trivial model\n",
+    "\n",
+    "training_prices = [item.price for item in train]\n",
+    "training_average = sum(training_prices) / len(training_prices)\n",
+    "\n",
+    "def constant_pricer(item):\n",
+    "    return training_average"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8cf384eb-30c2-40d8-b7e5-48942ac6a969",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Run our constant predictor\n",
+    "Tester.test(constant_pricer)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6173a4b9-f0b9-407b-a1de-dc8f045adb8f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train[0].details"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ce16eee8-bb34-4914-9aa5-57e30a567842",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a new \"features\" field on items, and populate it with json parsed from the details dict\n",
+    "\n",
+    "for item in train:\n",
+    "    item.features = json.loads(item.details)\n",
+    "for item in test:\n",
+    "    item.features = json.loads(item.details)\n",
+    "\n",
+    "# Look at one"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ac702a10-dccb-43d4-887b-6f92a0fb298f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train[0].features.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fd7a41c5-0c51-41be-a61d-8e80c3e90930",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Look at 20 most common features in training set\n",
+    "\n",
+    "feature_count = Counter()\n",
+    "for item in train:\n",
+    "    for f in item.features.keys():\n",
+    "        feature_count[f]+=1\n",
+    "\n",
+    "feature_count.most_common(40)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3cef84a9-4932-48fd-9f7a-51cfc06e3216",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Now some janky code to pluck out the Item Weight\n",
+    "# Don't worry too much about this: spoiler alert, it's not going to be much use in training!\n",
+    "\n",
+    "def get_weight(item):\n",
+    "    weight_str = item.features.get('Item Weight')\n",
+    "    if weight_str:\n",
+    "        parts = weight_str.split(' ')\n",
+    "        amount = float(parts[0])\n",
+    "        unit = parts[1].lower()\n",
+    "        if unit==\"pounds\":\n",
+    "            return amount\n",
+    "        elif unit==\"ounces\":\n",
+    "            return amount / 16\n",
+    "        elif unit==\"grams\":\n",
+    "            return amount / 453.592\n",
+    "        elif unit==\"milligrams\":\n",
+    "            return amount / 453592\n",
+    "        elif unit==\"kilograms\":\n",
+    "            return amount / 0.453592\n",
+    "        elif unit==\"hundredths\" and parts[2].lower()==\"pounds\":\n",
+    "            return amount / 100\n",
+    "        else:\n",
+    "            print(weight_str)\n",
+    "    return None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f4848b4a-3c5a-4168-83a5-57a1f3ff270d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "weights = [get_weight(t) for t in train]\n",
+    "weights = [w for w in weights if w]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0cd11cc8-f16e-4991-b531-482189ddc4b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "average_weight = sum(weights)/len(weights)\n",
+    "average_weight"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "efe8ec7f-9777-464f-a809-b06b7033bdb2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_weight_with_default(item):\n",
+    "    weight = get_weight(item)\n",
+    "    return weight or average_weight"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c2659fef-a455-431a-9a0e-59342b80084b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_rank(item):\n",
+    "    rank_dict = item.features.get(\"Best Sellers Rank\")\n",
+    "    if rank_dict:\n",
+    "        ranks = rank_dict.values()\n",
+    "        return sum(ranks)/len(ranks)\n",
+    "    return None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20b9b5be-30bc-4d3a-8492-fbae119421a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ranks = [get_rank(t) for t in train]\n",
+    "ranks = [r for r in ranks if r]\n",
+    "average_rank = sum(ranks)/len(ranks)\n",
+    "average_rank"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "081e646a-ea50-4ec3-9512-6d5f96f8aef6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_rank_with_default(item):\n",
+    "    rank = get_rank(item)\n",
+    "    return rank or average_rank"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "afd5daf7-cb2b-47af-bf17-dd71a9db65d0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_text_length(item):\n",
+    "    return len(item.test_prompt())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "85c89012-a922-401b-8a3b-94af641bf27a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# investigate the brands\n",
+    "\n",
+    "brands = Counter()\n",
+    "for t in train:\n",
+    "    brand = t.features.get(\"Brand\")\n",
+    "    if brand:\n",
+    "        brands[brand]+=1\n",
+    "\n",
+    "# Look at most common 40 brands\n",
+    "\n",
+    "brands.most_common(40)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "386dde54-e028-4a6d-b291-cce889ac1fa3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "TOP_ELECTRONICS_BRANDS = [\"hp\", \"dell\", \"lenovo\", \"samsung\", \"asus\", \"sony\", \"canon\", \"apple\", \"intel\"]\n",
+    "def is_top_electronics_brand(item):\n",
+    "    brand = item.features.get(\"Brand\")\n",
+    "    return brand and brand.lower() in TOP_ELECTRONICS_BRANDS"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c31c9c59-9d0d-47a8-a046-f20ed8d38d4c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_features(item):\n",
+    "    return {\n",
+    "        \"weight\": get_weight_with_default(item),\n",
+    "        \"rank\": get_rank_with_default(item),\n",
+    "        \"text_length\": get_text_length(item),\n",
+    "        \"is_top_electronics_brand\": 1 if is_top_electronics_brand(item) else 0\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "88850855-f5bd-4be2-9d7c-75bf8a21609b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Look at features in a training item\n",
+    "get_features(train[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee9b5298-68b7-497d-8b2e-875287bb25b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A utility function to convert our features into a pandas dataframe\n",
+    "\n",
+    "def list_to_dataframe(items):\n",
+    "    features = [get_features(item) for item in items]\n",
+    "    df = pd.DataFrame(features)\n",
+    "    df['price'] = [item.price for item in items]\n",
+    "    return df\n",
+    "\n",
+    "train_df = list_to_dataframe(train)\n",
+    "test_df = list_to_dataframe(test[:250])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cc1d68e0-ab33-40f4-9334-461d426af25c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Traditional Linear Regression!\n",
+    "\n",
+    "np.random.seed(42)\n",
+    "\n",
+    "# Separate features and target\n",
+    "feature_columns = ['weight', 'rank', 'text_length', 'is_top_electronics_brand']\n",
+    "\n",
+    "X_train = train_df[feature_columns]\n",
+    "y_train = train_df['price']\n",
+    "X_test = test_df[feature_columns]\n",
+    "y_test = test_df['price']\n",
+    "\n",
+    "# Train a Linear Regression\n",
+    "model = LinearRegression()\n",
+    "model.fit(X_train, y_train)\n",
+    "\n",
+    "for feature, coef in zip(feature_columns, model.coef_):\n",
+    "    print(f\"{feature}: {coef}\")\n",
+    "print(f\"Intercept: {model.intercept_}\")\n",
+    "\n",
+    "# Predict the test set and evaluate\n",
+    "y_pred = model.predict(X_test)\n",
+    "mse = mean_squared_error(y_test, y_pred)\n",
+    "r2 = r2_score(y_test, y_pred)\n",
+    "\n",
+    "print(f\"Mean Squared Error: {mse}\")\n",
+    "print(f\"R-squared Score: {r2}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6561c3c7-ac7f-458b-983c-4a164b9d02c3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function to predict price for a new item\n",
+    "\n",
+    "def linear_regression_pricer(item):\n",
+    "    features = get_features(item)\n",
+    "    features_df = pd.DataFrame([features])\n",
+    "    return model.predict(features_df)[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9bf2caa4-657a-4fc6-9dcb-bed7eaf8dd65",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# test it\n",
+    "\n",
+    "Tester.test(linear_regression_pricer)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "79e1574b-52ef-49cc-bfb5-e97252ed5db8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# For the next few models, we prepare our documents and prices\n",
+    "# Note that we use the test prompt for the documents, otherwise we'll reveal the answer!!\n",
+    "\n",
+    "prices = np.array([float(item.price) for item in train])\n",
+    "documents = [item.test_prompt() for item in train]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e126c22e-53e7-4967-9ebb-6b7dd7fe4ade",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Use the CountVectorizer for a Bag of Words model\n",
+    "\n",
+    "np.random.seed(42)\n",
+    "vectorizer = CountVectorizer(max_features=1000, stop_words='english')\n",
+    "X = vectorizer.fit_transform(documents)\n",
+    "regressor = LinearRegression()\n",
+    "regressor.fit(X, prices)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4b7148d3-3202-4536-a75c-1627495c51d3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def bow_lr_pricer(item):\n",
+    "    x = vectorizer.transform([item.test_prompt()])\n",
+    "    return max(regressor.predict(x)[0], 0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "38f7f7d0-d22c-4282-92e5-9666a7b8535d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# test it\n",
+    "\n",
+    "Tester.test(bow_lr_pricer)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b623079e-54fa-418f-b209-7d54ebbcc23a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The amazing word2vec model, implemented in gensim NLP library\n",
+    "\n",
+    "np.random.seed(42)\n",
+    "\n",
+    "# Preprocess the documents\n",
+    "processed_docs = [simple_preprocess(doc) for doc in documents]\n",
+    "\n",
+    "# Train Word2Vec model\n",
+    "w2v_model = Word2Vec(sentences=processed_docs, vector_size=400, window=5, min_count=1, workers=8)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3de4efc7-68a6-4443-b9fd-70ee9d722362",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This step of averaging vectors across the document is a weakness in our approach\n",
+    "\n",
+    "def document_vector(doc):\n",
+    "    doc_words = simple_preprocess(doc)\n",
+    "    word_vectors = [w2v_model.wv[word] for word in doc_words if word in w2v_model.wv]\n",
+    "    return np.mean(word_vectors, axis=0) if word_vectors else np.zeros(w2v_model.vector_size)\n",
+    "\n",
+    "# Create feature matrix\n",
+    "X_w2v = np.array([document_vector(doc) for doc in documents])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9f05eeec-dab8-4007-8e8c-dcf4175b8861",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Run Linear Regression on word2vec\n",
+    "\n",
+    "word2vec_lr_regressor = LinearRegression()\n",
+    "word2vec_lr_regressor.fit(X_w2v, prices)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e43d3fb9-e013-4573-90bf-9a522132b555",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def word2vec_lr_pricer(item):\n",
+    "    doc = item.test_prompt()\n",
+    "    doc_vector = document_vector(doc)\n",
+    "    return max(0, word2vec_lr_regressor.predict([doc_vector])[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6740319d-5c8e-4125-9106-97e2e8ab72c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Tester.test(word2vec_lr_pricer)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d6d3265-37c1-464c-a489-5be4df0a7276",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Support Vector Machines\n",
+    "\n",
+    "np.random.seed(42)\n",
+    "svr_regressor = LinearSVR()\n",
+    "\n",
+    "svr_regressor.fit(X_w2v, prices)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fcc289e6-56a1-4119-864f-2fdf8efde643",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def svr_pricer(item):\n",
+    "    np.random.seed(42)\n",
+    "    doc = item.test_prompt()\n",
+    "    doc_vector = document_vector(doc)\n",
+    "    return max(float(svr_regressor.predict([doc_vector])[0]),0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "80286a48-7cca-40e6-af76-a814a23bb9dc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Tester.test(svr_pricer)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c6c44fe4-e4d9-4559-a8ed-d8f97e25b69f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# And the powerful Random Forest regression\n",
+    "\n",
+    "rf_model = RandomForestRegressor(n_estimators=100, random_state=42, n_jobs=8)\n",
+    "rf_model.fit(X_w2v, prices)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a38812d0-913b-400b-804f-51434d895d05",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def random_forest_pricer(item):\n",
+    "    doc = item.test_prompt()\n",
+    "    doc_vector = document_vector(doc)\n",
+    "    return max(0, rf_model.predict([doc_vector])[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "88b51c01-c791-4fdc-8010-00b2e486b8ce",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Tester.test(random_forest_pricer)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bc85b271-4c92-480c-8843-2d7713b0fa57",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week6/.ipynb_checkpoints/day4-checkpoint.ipynb

@@ -0,0 +1,406 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "db8736a7-ed94-441c-9556-831fa57b5a10",
+   "metadata": {},
+   "source": [
+    "# The Product Pricer Continued\n",
+    "\n",
+    "A model that can estimate how much something costs, from its description.\n",
+    "\n",
+    "## Enter The Frontier!\n",
+    "\n",
+    "And now - we put Frontier Models to the test.\n",
+    "\n",
+    "### 2 important points:\n",
+    "\n",
+    "It's important to appreciate that we aren't Training the frontier models. We're only providing them with the Test dataset to see how they perform. They don't gain the benefit of the 400,000 training examples that we provided to the Traditional ML models.\n",
+    "\n",
+    "HAVING SAID THAT...\n",
+    "\n",
+    "It's entirely possible that in their monstrously large training data, they've already been exposed to all the products in the training AND the test set. So there could be test \"contamination\" here which gives them an unfair advantage. We should keep that in mind."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "681c717b-4c24-4ac3-a5f3-3c5881d6e70a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import re\n",
+    "import math\n",
+    "import json\n",
+    "import random\n",
+    "from dotenv import load_dotenv\n",
+    "from huggingface_hub import login\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import pickle\n",
+    "from collections import Counter\n",
+    "from openai import OpenAI\n",
+    "from anthropic import Anthropic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36d05bdc-0155-4c72-a7ee-aa4e614ffd3c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv(override=True)\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['HF_TOKEN'] = os.getenv('HF_TOKEN', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4dd3aad2-6f99-433c-8792-e461d2f06622",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Log in to HuggingFace\n",
+    "\n",
+    "hf_token = os.environ['HF_TOKEN']\n",
+    "login(hf_token, add_to_git_credential=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6985bdc7-fa45-49a3-ae97-84bdeb9b2083",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# moved our Tester into a separate package\n",
+    "# call it with Tester.test(function_name, test_dataset)\n",
+    "\n",
+    "from items import Item\n",
+    "from testing import Tester"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b0a6fb86-74a4-403c-ab25-6db2d74e9d2b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "openai = OpenAI()\n",
+    "claude = Anthropic()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c830ed3e-24ee-4af6-a07b-a1bfdcd39278",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c9b05f4-c9eb-462c-8d86-de9140a2d985",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Let's avoid curating all our data again! Load in the pickle files:\n",
+    "\n",
+    "with open('train.pkl', 'rb') as file:\n",
+    "    train = pickle.load(file)\n",
+    "\n",
+    "with open('test.pkl', 'rb') as file:\n",
+    "    test = pickle.load(file)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e5856173-e68c-4975-a769-5f1736e227a5",
+   "metadata": {},
+   "source": [
+    "# Before we look at the Frontier\n",
+    "\n",
+    "## There is one more model we could consider"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f3e81ee0-828a-4af8-9ccf-177af6c78a0c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Write the test set to a CSV\n",
+    "\n",
+    "import csv\n",
+    "with open('human_input.csv', 'w', encoding=\"utf-8\") as csvfile:\n",
+    "    writer = csv.writer(csvfile)\n",
+    "    for t in test[:250]:\n",
+    "        writer.writerow([t.test_prompt(), 0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aeafac31-1a10-4029-b190-030378e2fe01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Read it back in\n",
+    "\n",
+    "human_predictions = []\n",
+    "with open('human_output.csv', 'r', encoding=\"utf-8\") as csvfile:\n",
+    "    reader = csv.reader(csvfile)\n",
+    "    for row in reader:\n",
+    "        human_predictions.append(float(row[1]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a9709da2-28f0-419e-af71-4ef6c02246ad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def human_pricer(item):\n",
+    "    idx = test.index(item)\n",
+    "    return human_predictions[idx]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e1ba3b3e-4b08-4f0b-9e51-ebb03a86085d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Tester.test(human_pricer, test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "066fef03-8338-4526-9df3-89b649ad4f0a",
+   "metadata": {},
+   "source": [
+    "## First, the humble but mighty GPT-4o-mini\n",
+    "\n",
+    "It's called mini, but it packs a punch."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "66ea68e8-ab1b-4f0d-aba4-a59574d8f85e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# First let's work on a good prompt for a Frontier model\n",
+    "# Notice that I'm removing the \" to the nearest dollar\"\n",
+    "# When we train our own models, we'll need to make the problem as easy as possible, \n",
+    "# but a Frontier model needs no such simplification.\n",
+    "\n",
+    "def messages_for(item):\n",
+    "    system_message = \"You estimate prices of items. Reply only with the price, no explanation\"\n",
+    "    user_prompt = item.test_prompt().replace(\" to the nearest dollar\",\"\").replace(\"\\n\\nPrice is $\",\"\")\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_message},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt},\n",
+    "        {\"role\": \"assistant\", \"content\": \"Price is $\"}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "add7bc0a-71fb-49cc-a49b-9548fd0fe949",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ff92d61-0d27-4b0d-8b32-c9891016509b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Try this out\n",
+    "\n",
+    "messages_for(test[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b1af1888-f94a-4106-b0d8-8a70939eec4e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A utility function to extract the price from a string\n",
+    "\n",
+    "def get_price(s):\n",
+    "    s = s.replace('$','').replace(',','')\n",
+    "    match = re.search(r\"[-+]?\\d*\\.\\d+|\\d+\", s)\n",
+    "    return float(match.group()) if match else 0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f138c5b7-bcc1-4085-aced-68dad1bf36b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "get_price(\"The price is roughly $99.99 because blah blah\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "501a2a7a-69c8-451b-bbc0-398bcb9e1612",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The function for gpt-4o-mini\n",
+    "\n",
+    "def gpt_4o_mini(item):\n",
+    "    response = openai.chat.completions.create(\n",
+    "        model=\"gpt-4o-mini\", \n",
+    "        messages=messages_for(item),\n",
+    "        seed=42,\n",
+    "        max_tokens=5\n",
+    "    )\n",
+    "    reply = response.choices[0].message.content\n",
+    "    return get_price(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "843d88b4-364a-431b-b48b-8a7c1f68b786",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test[0].price"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36bdd2c9-1859-4f99-a09f-3ec83b845b30",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Tester.test(gpt_4o_mini, test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f49e90d6-6749-4eb8-9347-5922b189d379",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def gpt_4o_frontier(item):\n",
+    "    response = openai.chat.completions.create(\n",
+    "        model=\"gpt-4o-2024-08-06\", \n",
+    "        messages=messages_for(item),\n",
+    "        seed=42,\n",
+    "        max_tokens=5\n",
+    "    )\n",
+    "    reply = response.choices[0].message.content\n",
+    "    return get_price(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "766e697e-55bf-4521-b301-3b07d20045e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The function for gpt-4o - the August model\n",
+    "# Note that it cost me about 1-2 cents to run this (pricing may vary by region)\n",
+    "# You can skip this and look at my results instead\n",
+    "\n",
+    "Tester.test(gpt_4o_frontier, test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "53d941cb-5b73-44ea-b893-3a0ce9997066",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def claude_3_point_5_sonnet(item):\n",
+    "    messages = messages_for(item)\n",
+    "    system_message = messages[0]['content']\n",
+    "    messages = messages[1:]\n",
+    "    response = claude.messages.create(\n",
+    "        model=\"claude-3-5-sonnet-20240620\",\n",
+    "        max_tokens=5,\n",
+    "        system=system_message,\n",
+    "        messages=messages\n",
+    "    )\n",
+    "    reply = response.content[0].text\n",
+    "    return get_price(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "11dba25d-f562-40f9-9855-40b715b7fc86",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The function for Claude 3.5 Sonnet\n",
+    "# It also cost me about 1-2 cents to run this (pricing may vary by region)\n",
+    "# You can skip this and look at my results instead\n",
+    "\n",
+    "Tester.test(claude_3_point_5_sonnet, test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77428dfb-d8f4-4477-8265-77b4b0badd39",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week6/.ipynb_checkpoints/day5-checkpoint.ipynb

@@ -0,0 +1,555 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "db8736a7-ed94-441c-9556-831fa57b5a10",
+   "metadata": {},
+   "source": [
+    "# The Product Pricer Continued\n",
+    "\n",
+    "A model that can estimate how much something costs, from its description.\n",
+    "\n",
+    "## AT LAST - it's time for Fine Tuning!\n",
+    "\n",
+    "After all this data preparation, and old school machine learning, we've finally arrived at the moment you've been waiting for. Fine-tuning a model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "681c717b-4c24-4ac3-a5f3-3c5881d6e70a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import re\n",
+    "import math\n",
+    "import json\n",
+    "import random\n",
+    "from dotenv import load_dotenv\n",
+    "from huggingface_hub import login\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import pickle\n",
+    "from collections import Counter\n",
+    "from openai import OpenAI\n",
+    "from anthropic import Anthropic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36d05bdc-0155-4c72-a7ee-aa4e614ffd3c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv(override=True)\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['HF_TOKEN'] = os.getenv('HF_TOKEN', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4dd3aad2-6f99-433c-8792-e461d2f06622",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Log in to HuggingFace\n",
+    "\n",
+    "hf_token = os.environ['HF_TOKEN']\n",
+    "login(hf_token, add_to_git_credential=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "884a50bd-8cae-425e-8e56-f079fc3e65ce",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# moved our Tester into a separate package\n",
+    "# call it with Tester.test(function_name, test_dataset)\n",
+    "\n",
+    "from items import Item\n",
+    "from testing import Tester"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b0a6fb86-74a4-403c-ab25-6db2d74e9d2b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "openai = OpenAI()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c830ed3e-24ee-4af6-a07b-a1bfdcd39278",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c9b05f4-c9eb-462c-8d86-de9140a2d985",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Let's avoid curating all our data again! Load in the pickle files:\n",
+    "\n",
+    "with open('train.pkl', 'rb') as file:\n",
+    "    train = pickle.load(file)\n",
+    "\n",
+    "with open('test.pkl', 'rb') as file:\n",
+    "    test = pickle.load(file)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8367135-f40e-43e1-8f3c-09e990ab1194",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# OpenAI recommends fine-tuning with populations of 50-100 examples\n",
+    "# But as our examples are very small, I'm suggesting we go with 200 examples (and 1 epoch)\n",
+    "\n",
+    "fine_tune_train = train[:200]\n",
+    "fine_tune_validation = train[200:250]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8be4a889-81c3-42b1-a2fc-034cdc7321a6",
+   "metadata": {},
+   "source": [
+    "# Step 1\n",
+    "\n",
+    "Prepare our data for fine-tuning in JSONL (JSON Lines) format and upload to OpenAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8ae2fb3c-1cff-4ce3-911e-627c970edd7b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# First let's work on a good prompt for a Frontier model\n",
+    "# Notice that I'm removing the \" to the nearest dollar\"\n",
+    "# When we train our own models, we'll need to make the problem as easy as possible, \n",
+    "# but a Frontier model needs no such simplification.\n",
+    "\n",
+    "def messages_for(item):\n",
+    "    system_message = \"You estimate prices of items. Reply only with the price, no explanation\"\n",
+    "    user_prompt = item.test_prompt().replace(\" to the nearest dollar\",\"\").replace(\"\\n\\nPrice is $\",\"\")\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_message},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt},\n",
+    "        {\"role\": \"assistant\", \"content\": f\"Price is ${item.price:.2f}\"}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1aa280f6-1227-426a-a2e2-1ce985feba1e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "messages_for(train[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c0e5b56c-8a0b-4d8e-a112-ce87efb4e152",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Convert the items into a list of json objects - a \"jsonl\" string\n",
+    "# Each row represents a message in the form:\n",
+    "# {\"messages\" : [{\"role\": \"system\", \"content\": \"You estimate prices...\n",
+    "\n",
+    "\n",
+    "def make_jsonl(items):\n",
+    "    result = \"\"\n",
+    "    for item in items:\n",
+    "        messages = messages_for(item)\n",
+    "        messages_str = json.dumps(messages)\n",
+    "        result += '{\"messages\": ' + messages_str +'}\\n'\n",
+    "    return result.strip()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5e72de93-a6a6-4b35-855e-15786b97bf5f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(make_jsonl(train[:3]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7734bff0-95c4-4e67-a87e-7e2254e2c67d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Convert the items into jsonl and write them to a file\n",
+    "\n",
+    "def write_jsonl(items, filename):\n",
+    "    with open(filename, \"w\") as f:\n",
+    "        jsonl = make_jsonl(items)\n",
+    "        f.write(jsonl)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "393d3ad8-999a-4f99-8c04-339d9166d604",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "write_jsonl(fine_tune_train, \"fine_tune_train.jsonl\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e23927f-d73e-4668-ac20-abe6f14a56cb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "write_jsonl(fine_tune_validation, \"fine_tune_validation.jsonl\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d59ad8d2-c61a-448e-b7ed-232f1606970f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"fine_tune_train.jsonl\", \"rb\") as f:\n",
+    "    train_file = openai.files.create(file=f, purpose=\"fine-tune\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "083fefba-fd54-47ce-9ff3-aabbc200846f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "97df3360-0760-4422-a556-5f26d23de6dc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"fine_tune_validation.jsonl\", \"rb\") as f:\n",
+    "    validation_file = openai.files.create(file=f, purpose=\"fine-tune\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a1abb8f3-9e52-4061-970c-fcf399d8ffa3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "validation_file"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "466052b9-9fb9-48f6-8cf9-c74e6ddc1394",
+   "metadata": {},
+   "source": [
+    "# Step 2\n",
+    "\n",
+    "I love Weights and Biases - a beautiful, free platform for monitoring training runs.  \n",
+    "Weights and Biases is integrated with OpenAI for fine-tuning.\n",
+    "\n",
+    "First set up your weights & biases free account at:\n",
+    "\n",
+    "https://wandb.ai\n",
+    "\n",
+    "From the Avatar >> Settings menu, near the bottom, you can create an API key.\n",
+    "\n",
+    "Then visit the OpenAI dashboard at:\n",
+    "\n",
+    "https://platform.openai.com/account/organization\n",
+    "\n",
+    "In the integrations section, you can add your Weights & Biases key.\n",
+    "\n",
+    "## And now time to Fine-tune!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c7add1a7-a746-4d6e-a5f8-e25629b8b527",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "wandb_integration = {\"type\": \"wandb\", \"wandb\": {\"project\": \"gpt-pricer\"}}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "49801e69-9277-4deb-9f33-99efb6b45ac2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_file.id"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "45421b86-5531-4e42-ab19-d6abbb8f4c13",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "openai.fine_tuning.jobs.create(\n",
+    "    training_file=train_file.id,\n",
+    "    validation_file=validation_file.id,\n",
+    "    model=\"gpt-4o-mini-2024-07-18\",\n",
+    "    seed=42,\n",
+    "    hyperparameters={\"n_epochs\": 1},\n",
+    "    integrations = [wandb_integration],\n",
+    "    suffix=\"pricer\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aeb9de2e-542c-4e83-81c7-b6745133e48b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "openai.fine_tuning.jobs.list(limit=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "40d24873-8ff5-413f-b0d4-8f77c28f18e1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "job_id = openai.fine_tuning.jobs.list(limit=1).data[0].id"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a32aef35-4b38-436c-ad00-d082f758efa7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "job_id"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a7e01247-c133-48e1-93d3-c79c399e6178",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "openai.fine_tuning.jobs.retrieve(job_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0f5150e1-b8de-485f-8eba-cf1e5b00c117",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "openai.fine_tuning.jobs.list_events(fine_tuning_job_id=job_id, limit=10).data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "066fef03-8338-4526-9df3-89b649ad4f0a",
+   "metadata": {},
+   "source": [
+    "# Step 3\n",
+    "\n",
+    "Test our fine tuned model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fa4488cb-3c17-4eda-abd1-53c1c68a491b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fine_tuned_model_name = openai.fine_tuning.jobs.retrieve(job_id).fine_tuned_model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9370937-5a6f-4724-8265-b208663b4450",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fine_tuned_model_name"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "66ea68e8-ab1b-4f0d-aba4-a59574d8f85e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The prompt\n",
+    "\n",
+    "def messages_for(item):\n",
+    "    system_message = \"You estimate prices of items. Reply only with the price, no explanation\"\n",
+    "    user_prompt = item.test_prompt().replace(\" to the nearest dollar\",\"\").replace(\"\\n\\nPrice is $\",\"\")\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_message},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt},\n",
+    "        {\"role\": \"assistant\", \"content\": \"Price is $\"}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ff92d61-0d27-4b0d-8b32-c9891016509b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Try this out\n",
+    "\n",
+    "messages_for(test[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b1af1888-f94a-4106-b0d8-8a70939eec4e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A utility function to extract the price from a string\n",
+    "\n",
+    "def get_price(s):\n",
+    "    s = s.replace('$','').replace(',','')\n",
+    "    match = re.search(r\"[-+]?\\d*\\.\\d+|\\d+\", s)\n",
+    "    return float(match.group()) if match else 0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f138c5b7-bcc1-4085-aced-68dad1bf36b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "get_price(\"The price is roughly $99.99 because blah blah\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "501a2a7a-69c8-451b-bbc0-398bcb9e1612",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The function for gpt-4o-mini\n",
+    "\n",
+    "def gpt_fine_tuned(item):\n",
+    "    response = openai.chat.completions.create(\n",
+    "        model=fine_tuned_model_name, \n",
+    "        messages=messages_for(item),\n",
+    "        seed=42,\n",
+    "        max_tokens=7\n",
+    "    )\n",
+    "    reply = response.choices[0].message.content\n",
+    "    return get_price(reply)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "843d88b4-364a-431b-b48b-8a7c1f68b786",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(test[0].price)\n",
+    "print(gpt_fine_tuned(test[0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "edd7ada0-15b7-42ec-bbbb-1250e0eb9af1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(test[0].test_prompt())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36bdd2c9-1859-4f99-a09f-3ec83b845b30",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Tester.test(gpt_fine_tuned, test)"
+   ]
+  }
+ ],
+ "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week6/.ipynb_checkpoints/items-checkpoint.py

@@ -0,0 +1,103 @@
+from typing import Optional
+from transformers import AutoTokenizer
+import re
+
+BASE_MODEL = "meta-llama/Meta-Llama-3.1-8B"
+
+MIN_TOKENS = 150 # Any less than this, and we don't have enough useful content
+MAX_TOKENS = 160 # Truncate after this many tokens. Then after adding in prompt text, we will get to around 180 tokens
+
+MIN_CHARS = 300
+CEILING_CHARS = MAX_TOKENS * 7
+
+class Item:
+    """
+    An Item is a cleaned, curated datapoint of a Product with a Price
+    """
+    
+    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True)
+    PREFIX = "Price is $"
+    QUESTION = "How much does this cost to the nearest dollar?"
+    REMOVALS = ['"Batteries Included?": "No"', '"Batteries Included?": "Yes"', '"Batteries Required?": "No"', '"Batteries Required?": "Yes"', "By Manufacturer", "Item", "Date First", "Package", ":", "Number of", "Best Sellers", "Number", "Product "]
+
+    title: str
+    price: float
+    category: str
+    token_count: int = 0
+    details: Optional[str]
+    prompt: Optional[str] = None
+    include = False
+
+    def __init__(self, data, price):
+        self.title = data['title']
+        self.price = price
+        self.parse(data)
+
+    def scrub_details(self):
+        """
+        Clean up the details string by removing common text that doesn't add value
+        """
+        details = self.details
+        for remove in self.REMOVALS:
+            details = details.replace(remove, "")
+        return details
+
+    def scrub(self, stuff):
+        """
+        Clean up the provided text by removing unnecessary characters and whitespace
+        Also remove words that are 7+ chars and contain numbers, as these are likely irrelevant product numbers
+        """
+        stuff = re.sub(r'[:\[\]"{}【】\s]+', ' ', stuff).strip()
+        stuff = stuff.replace(" ,", ",").replace(",,,",",").replace(",,",",")
+        words = stuff.split(' ')
+        select = [word for word in words if len(word)<7 or not any(char.isdigit() for char in word)]
+        return " ".join(select)
+    
+    def parse(self, data):
+        """
+        Parse this datapoint and if it fits within the allowed Token range,
+        then set include to True
+        """
+        contents = '\n'.join(data['description'])
+        if contents:
+            contents += '\n'
+        features = '\n'.join(data['features'])
+        if features:
+            contents += features + '\n'
+        self.details = data['details']
+        if self.details:
+            contents += self.scrub_details() + '\n'
+        if len(contents) > MIN_CHARS:
+            contents = contents[:CEILING_CHARS]
+            text = f"{self.scrub(self.title)}\n{self.scrub(contents)}"
+            tokens = self.tokenizer.encode(text, add_special_tokens=False)
+            if len(tokens) > MIN_TOKENS:
+                tokens = tokens[:MAX_TOKENS]
+                text = self.tokenizer.decode(tokens)
+                self.make_prompt(text)
+                self.include = True
+
+    def make_prompt(self, text):
+        """
+        Set the prompt instance variable to be a prompt appropriate for training
+        """
+        self.prompt = f"{self.QUESTION}\n\n{text}\n\n"
+        self.prompt += f"{self.PREFIX}{str(round(self.price))}.00"
+        self.token_count = len(self.tokenizer.encode(self.prompt, add_special_tokens=False))
+
+    def test_prompt(self):
+        """
+        Return a prompt suitable for testing, with the actual price removed
+        """
+        return self.prompt.split(self.PREFIX)[0] + self.PREFIX
+
+    def __repr__(self):
+        """
+        Return a String version of this Item
+        """
+        return f"<{self.title} = ${self.price}>"
+
+        
+
+    
+    

week6/.ipynb_checkpoints/lite-checkpoint.ipynb

@@ -0,0 +1,424 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "28a0673e-96b5-43f2-8a8b-bd033bf851b0",
+   "metadata": {},
+   "source": [
+    "# The Product Pricer Continued\n",
+    "\n",
+    "A model that can estimate how much something costs, from its description.\n",
+    "\n",
+    "## Data Curation Part 2\n",
+    "\n",
+    "Today we'll extend our dataset to a greater coverage, and craft it into an excellent dataset for training.\n",
+    "\n",
+    "The dataset is here:  \n",
+    "https://huggingface.co/datasets/McAuley-Lab/Amazon-Reviews-2023\n",
+    "\n",
+    "And the folder with all the product datasets is here:  \n",
+    "https://huggingface.co/datasets/McAuley-Lab/Amazon-Reviews-2023/tree/main/raw/meta_categories\n",
+    "\n",
+    "## The Lite dataset\n",
+    "\n",
+    "This notebook is an alternative to `day2.ipynb` that creates a smaller dataset for Home Appliances only, to keep training fast and costs low. You may need to update names of future notebooks to reflect that you have built the \"lite\" dataset not the full dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "67cedf85-8125-4322-998e-9375fe745597",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import random\n",
+    "from dotenv import load_dotenv\n",
+    "from huggingface_hub import login\n",
+    "from datasets import load_dataset, Dataset, DatasetDict\n",
+    "from items import Item\n",
+    "from loaders import ItemLoader\n",
+    "import matplotlib.pyplot as plt\n",
+    "from collections import Counter, defaultdict\n",
+    "import numpy as np\n",
+    "import pickle"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7390a6aa-79cb-4dea-b6d7-de7e4b13e472",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "\n",
+    "load_dotenv()\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')\n",
+    "os.environ['HF_TOKEN'] = os.getenv('HF_TOKEN', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0732274a-aa6a-44fc-aee2-40dc8a8e4451",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Log in to HuggingFace\n",
+    "\n",
+    "hf_token = os.environ['HF_TOKEN']\n",
+    "login(hf_token, add_to_git_credential=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1adcf323-de9d-4c24-a9c3-d7ae554d06ca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "01065d69-765c-42c8-9f90-68b8c8754068",
+   "metadata": {},
+   "source": [
+    "## The ItemLoader code\n",
+    "\n",
+    "Look in loaders.py - there's some useful code to make life easier for us"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e2b6dc50-ac5c-4cf2-af2e-968ed8ef86d7",
+   "metadata": {},
+   "source": [
+    "## Now to SCALE UP\n",
+    "\n",
+    "Let's look at all datasets of all the items that you might find in a large home retail store - electrical, electronic, office and related, but not clothes / beauty / books."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d1d06cd3-f3c2-44f0-a9f2-13b54ff8be5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset_names = [\n",
+    "    # \"Automotive\",\n",
+    "    # \"Electronics\",\n",
+    "    # \"Office_Products\",\n",
+    "    # \"Tools_and_Home_Improvement\",\n",
+    "    # \"Cell_Phones_and_Accessories\",\n",
+    "    # \"Toys_and_Games\",\n",
+    "    \"Appliances\",\n",
+    "    # \"Musical_Instruments\",\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aa8fd0f0-509a-4298-8fcc-e499a061e1be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "items = []\n",
+    "for dataset_name in dataset_names:\n",
+    "    loader = ItemLoader(dataset_name)\n",
+    "    items.extend(loader.load())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3e29a5ab-ca61-41cc-9b33-22d374681b85",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(f\"A grand total of {len(items):,} items\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "89078cb1-9679-4eb0-b295-599b8586bcd1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the distribution of token counts again\n",
+    "\n",
+    "tokens = [item.token_count for item in items]\n",
+    "plt.figure(figsize=(15, 6))\n",
+    "plt.title(f\"Token counts: Avg {sum(tokens)/len(tokens):,.1f} and highest {max(tokens):,}\\n\")\n",
+    "plt.xlabel('Length (tokens)')\n",
+    "plt.ylabel('Count')\n",
+    "plt.hist(tokens, rwidth=0.7, color=\"skyblue\", bins=range(0, 300, 10))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c38e0c43-9f7a-450e-a911-c94d37d9b9c3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the distribution of prices\n",
+    "\n",
+    "prices = [item.price for item in items]\n",
+    "plt.figure(figsize=(15, 6))\n",
+    "plt.title(f\"Prices: Avg {sum(prices)/len(prices):,.1f} and highest {max(prices):,}\\n\")\n",
+    "plt.xlabel('Price ($)')\n",
+    "plt.ylabel('Count')\n",
+    "plt.hist(prices, rwidth=0.7, color=\"blueviolet\", bins=range(0, 1000, 10))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ac046cc1-2717-415b-96ad-b73b2950d235",
+   "metadata": {},
+   "source": [
+    "# Dataset Curated!\n",
+    "\n",
+    "We've crafted an excellent dataset.\n",
+    "\n",
+    "Let's do some final checks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "70219e99-22cc-4e08-9121-51f9707caef0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# How does the price vary with the character count of the prompt?\n",
+    "\n",
+    "sample = items\n",
+    "\n",
+    "sizes = [len(item.prompt) for item in sample]\n",
+    "prices = [item.price for item in sample]\n",
+    "\n",
+    "# Create the scatter plot\n",
+    "plt.figure(figsize=(15, 8))\n",
+    "plt.scatter(sizes, prices, s=0.2, color=\"red\")\n",
+    "\n",
+    "# Add labels and title\n",
+    "plt.xlabel('Size')\n",
+    "plt.ylabel('Price')\n",
+    "plt.title('Is there a simple correlation?')\n",
+    "\n",
+    "# Display the plot\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "30ae1453-b9fc-40db-8310-65d850c4b1da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def report(item):\n",
+    "    prompt = item.prompt\n",
+    "    tokens = Item.tokenizer.encode(item.prompt)\n",
+    "    print(prompt)\n",
+    "    print(tokens[-10:])\n",
+    "    print(Item.tokenizer.batch_decode(tokens[-10:]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d9998b8d-d746-4541-9ac2-701108e0e8fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "report(sample[50])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7aa0a3fc-d2fe-4e6e-8fdb-96913df2f588",
+   "metadata": {},
+   "source": [
+    "## Observation\n",
+    "\n",
+    "An interesting thing about the Llama tokenizer is that every number from 1 to 999 gets mapped to 1 token, much as we saw with gpt-4o. The same is not true of qwen2, gemma and phi3, which all map individual digits to tokens. This does turn out to be a bit useful for our project, although it's not an essential requirement."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0f03c0ee-3103-4603-af5c-b484884a3aa2",
+   "metadata": {},
+   "source": [
+    "# Finally\n",
+    "\n",
+    "It's time to break down our data into a training, test and validation dataset.\n",
+    "\n",
+    "It's typical to use 5%-10% of your data for testing purposes, but actually we have far more than we need at this point. We'll take 25,000 points for training, and we'll reserve 2,000 for testing, although we won't use all of them.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3b163ca2-18ef-4c26-8e9d-88eb55f114f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "random.seed(42)\n",
+    "random.shuffle(sample)\n",
+    "train = sample[:25_000]\n",
+    "test = sample[25_000:27_000]\n",
+    "print(f\"Divided into a training set of {len(train):,} items and test set of {len(test):,} items\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "299b9816-8885-4798-829a-69d66d60eb01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(train[0].prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "97222da3-9f2c-4d15-a5cd-5e5f8dbde6cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(test[0].test_prompt())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7a116369-335a-412b-b70c-2add6675c2e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the distribution of prices in the first 250 test points\n",
+    "\n",
+    "prices = [float(item.price) for item in test[:250]]\n",
+    "plt.figure(figsize=(15, 6))\n",
+    "plt.title(f\"Avg {sum(prices)/len(prices):.2f} and highest {max(prices):,.2f}\\n\")\n",
+    "plt.xlabel('Price ($)')\n",
+    "plt.ylabel('Count')\n",
+    "plt.hist(prices, rwidth=0.7, color=\"darkblue\", bins=range(0, 1000, 10))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d522d752-6f66-4786-a4dc-8ef51842558c",
+   "metadata": {},
+   "source": [
+    "# Finally - upload your brand new dataset\n",
+    "\n",
+    "Convert to prompts and upload to HuggingFace hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fa11b3e5-fcf4-4efc-a573-f6f67fec3e73",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_prompts = [item.prompt for item in train]\n",
+    "train_prices = [item.price for item in train]\n",
+    "test_prompts = [item.test_prompt() for item in test]\n",
+    "test_prices = [item.price for item in test]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b020ab1b-7153-4e5f-b8a3-d5bc2fafb6df",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a Dataset from the lists\n",
+    "\n",
+    "train_dataset = Dataset.from_dict({\"text\": train_prompts, \"price\": train_prices})\n",
+    "test_dataset = Dataset.from_dict({\"text\": test_prompts, \"price\": test_prices})\n",
+    "dataset = DatasetDict({\n",
+    "    \"train\": train_dataset,\n",
+    "    \"test\": test_dataset\n",
+    "})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "17639641-fb55-44e2-a463-b0b394d00f32",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "DATASET_NAME = \"ed-donner/lite-data\"\n",
+    "dataset.push_to_hub(DATASET_NAME, private=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b85733ba-d165-4f07-b055-46803543edfe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# One more thing!\n",
+    "# Let's pickle the training and test dataset so we don't have to execute all this code next time!\n",
+    "\n",
+    "with open('train_lite.pkl', 'wb') as file:\n",
+    "    pickle.dump(train, file)\n",
+    "\n",
+    "with open('test_lite.pkl', 'wb') as file:\n",
+    "    pickle.dump(test, file)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b58dc61-747f-46f7-b9e0-c205db4f3e5e",
+   "metadata": {},
+   "source": [
+    "## Todos for you:\n",
+    "\n",
+    "- Investigate the dataset more!\n",
+    "- Confirm that the tokenizer tokenizes all 3 digit prices into 1 token"
+   ]
+  }
+ ],
+ "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.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week6/.ipynb_checkpoints/loaders-checkpoint.py

@@ -0,0 +1,81 @@
+from datetime import datetime
+from tqdm import tqdm
+from datasets import load_dataset
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
+from items import Item
+
+CHUNK_SIZE = 1000
+MIN_PRICE = 0.5
+MAX_PRICE = 999.49
+
+class ItemLoader:
+
+
+    def __init__(self, name):
+        self.name = name
+        self.dataset = None
+
+    def from_datapoint(self, datapoint):
+        """
+        Try to create an Item from this datapoint
+        Return the Item if successful, or None if it shouldn't be included
+        """
+        try:
+            price_str = datapoint['price']
+            if price_str:
+                price = float(price_str)
+                if MIN_PRICE <= price <= MAX_PRICE:
+                    item = Item(datapoint, price)
+                    return item if item.include else None
+        except ValueError:
+            return None
+
+    def from_chunk(self, chunk):
+        """
+        Create a list of Items from this chunk of elements from the Dataset
+        """
+        batch = []
+        for datapoint in chunk:
+            result = self.from_datapoint(datapoint)
+            if result:
+                batch.append(result)
+        return batch
+
+    def chunk_generator(self):
+        """
+        Iterate over the Dataset, yielding chunks of datapoints at a time
+        """
+        size = len(self.dataset)
+        for i in range(0, size, CHUNK_SIZE):
+            yield self.dataset.select(range(i, min(i + CHUNK_SIZE, size)))
+
+    def load_in_parallel(self, workers):
+        """
+        Use concurrent.futures to farm out the work to process chunks of datapoints -
+        This speeds up processing significantly, but will tie up your computer while it's doing so!
+        """
+        results = []
+        chunk_count = (len(self.dataset) // CHUNK_SIZE) + 1
+        with ProcessPoolExecutor(max_workers=workers) as pool:
+            for batch in tqdm(pool.map(self.from_chunk, self.chunk_generator()), total=chunk_count):
+                results.extend(batch)
+        for result in results:
+            result.category = self.name
+        return results
+            
+    def load(self, workers=8):
+        """
+        Load in this dataset; the workers parameter specifies how many processes
+        should work on loading and scrubbing the data
+        """
+        start = datetime.now()
+        print(f"Loading dataset {self.name}", flush=True)
+        self.dataset = load_dataset("McAuley-Lab/Amazon-Reviews-2023", f"raw_meta_{self.name}", split="full", trust_remote_code=True)
+        results = self.load_in_parallel(workers)
+        finish = datetime.now()
+        print(f"Completed {self.name} with {len(results):,} datapoints in {(finish-start).total_seconds()/60:.1f} mins", flush=True)
+        return results
+        
+
+    
+    

week6/.ipynb_checkpoints/similarity search-checkpoint.ipynb

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week6/Untitled.ipynb

@@ -0,0 +1,103 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "dc1bc613-e014-425d-a95e-3f7a0860b1ca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ollama"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f3766e3b-7a0e-4c09-b465-818d0bfa70e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def chat(topic):\n",
+    "    system = \"You are a therapist, your client is very lonely and addicted\"\n",
+    "    user = \"Here's the topic on which you have to say a joke: \"\n",
+    "    user += topic\n",
+    "    messag = [{'role':'system', 'content':system}, {'role':'user','content':user}]\n",
+    "    res = ollama.chat(model = 'llama3.2', messages=messag)\n",
+    "    return res['message']['content']\n",
+    "         \n",
+    "        \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "650ff21b-b5c1-4812-838e-f5fc3479d06f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7863\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7863/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import gradio as gr\n",
+    "gr.Interface(fn=chat, inputs='textbox',outputs='textbox').launch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "81c55600-483b-4c12-825d-ab2b58de9daf",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week6/community-contributions/ems_week6_day4_gemini_results.ipynb

@@ -0,0 +1,313 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "db8736a7-ed94-441c-9556-831fa57b5a10",
+   "metadata": {},
+   "source": [
+    "# The Product Pricer Continued...\n",
+    "\n",
+    "## Testing Gemini-1.5-pro model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "681c717b-4c24-4ac3-a5f3-3c5881d6e70a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import re\n",
+    "from dotenv import load_dotenv\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pickle\n",
+    "import google.generativeai as google_genai\n",
+    "import time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21a3833e-4093-43b0-8f7b-839c50b911ea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from items import Item\n",
+    "from testing import Tester "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36d05bdc-0155-4c72-a7ee-aa4e614ffd3c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# environment\n",
+    "load_dotenv()\n",
+    "os.environ['GOOGLE_API_KEY'] = os.getenv('GOOGLE_API_KEY', 'your-key-if-not-using-env')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b0a6fb86-74a4-403c-ab25-6db2d74e9d2b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "google_genai.configure()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c830ed3e-24ee-4af6-a07b-a1bfdcd39278",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c9b05f4-c9eb-462c-8d86-de9140a2d985",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load in the pickle files that are located in the `pickled_dataset` folder\n",
+    "with open('train.pkl', 'rb') as file:\n",
+    "    train = pickle.load(file)\n",
+    "\n",
+    "with open('test.pkl', 'rb') as file:\n",
+    "    test = pickle.load(file)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fc5c807b-c14c-458e-8cca-32bc0cc5b7c3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function to create the messages format required for Gemini 1.5 Pro\n",
+    "# This function prepares the system and user messages in the format expected by Gemini models.\n",
+    "def gemini_messages_for(item):\n",
+    "    system_message = \"You estimate prices of items. Reply only with the price, no explanation\"\n",
+    "    \n",
+    "    # Modify the test prompt by removing \"to the nearest dollar\" and \"Price is $\"\n",
+    "    # This ensures that the model receives a cleaner, simpler prompt.\n",
+    "    user_prompt = item.test_prompt().replace(\" to the nearest dollar\", \"\").replace(\"\\n\\nPrice is $\", \"\")\n",
+    "\n",
+    "    # Reformat messages to Gemini’s expected format: messages = [{'role':'user', 'parts': ['hello']}]\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"parts\": [system_message]},  # System-level instruction\n",
+    "        {\"role\": \"user\", \"parts\": [user_prompt]},       # User's query\n",
+    "        {\"role\": \"model\", \"parts\": [\"Price is $\"]}  # Assistant's expected prefix for response\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d6da66bb-bc4b-49ad-9224-a388470ef20b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example usage of the gemini_messages_for function\n",
+    "gemini_messages_for(test[0])  # Generate message structure for the first test item"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b1af1888-f94a-4106-b0d8-8a70939eec4e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Utility function to extract the numerical price from a given string\n",
+    "# This function removes currency symbols and commas, then extracts the first number found.\n",
+    "def get_price(s):\n",
+    "    s = s.replace('$', '').replace(',', '')  # Remove currency symbols and formatting\n",
+    "    match = re.search(r\"[-+]?\\d*\\.\\d+|\\d+\", s)  # Regular expression to find a number\n",
+    "    return float(match.group()) if match else 0  # Convert matched value to float, return 0 if no match"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a053c1a9-f86e-427c-a6be-ed8ec7bd63a5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example usage of get_price function\n",
+    "get_price(\"The price is roughly $99.99 because blah blah\")  # Expected output: 99.99"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "34a88e34-1719-4d08-adbe-adb69dfe5e83",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function to get the estimated price using Gemini 1.5 Pro\n",
+    "def gemini_1_point_5_pro(item):\n",
+    "    messages = gemini_messages_for(item)  # Generate messages for the model\n",
+    "    system_message = messages[0]['parts'][0]  # Extract system-level instruction\n",
+    "    user_messages = messages[1:]  # Remove system message from messages list\n",
+    "    \n",
+    "    # Initialize Gemini 1.5 Pro model with system instruction\n",
+    "    gemini = google_genai.GenerativeModel(\n",
+    "        model_name=\"gemini-1.5-pro\",\n",
+    "        system_instruction=system_message\n",
+    "    )\n",
+    "\n",
+    "    # Generate response using Gemini API\n",
+    "    response = gemini.generate_content(\n",
+    "        contents=user_messages,\n",
+    "        generation_config=google_genai.GenerationConfig(max_output_tokens=5)\n",
+    "    )\n",
+    "\n",
+    "    # Extract text response and convert to numerical price\n",
+    "    return get_price(response.text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d89b10bb-8ebb-42ef-9146-f6e64e6849f9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example usage:\n",
+    "gemini_1_point_5_pro(test[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "89ad07e6-a28a-4625-b61e-d2ce12d440fc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Retrieve the actual price of the test item (for comparison)\n",
+    "test[0].price    # Output: 374.41"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "384f28e5-e51f-4cd3-8d74-30a8275530db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test the function for gemini-1.5 pro using the Tester framework\n",
+    "Tester.test(gemini_1_point_5_pro, test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9b627291-b02e-48dd-9130-703498135ddf",
+   "metadata": {},
+   "source": [
+    "## Five, Gemini-2.0-flash"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ee393a9-7afd-404f-92f2-a64bb4d5fb8b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function to get the estimated price using Gemini-2.0-flash-exp\n",
+    "def gemini_2_point_0_flash_exp(item):\n",
+    "    messages = gemini_messages_for(item)  # Generate messages for the model\n",
+    "    system_message = messages[0]['parts'][0]  # Extract system-level instruction\n",
+    "    user_messages = messages[1:]  # Remove system message from messages list\n",
+    "    \n",
+    "    # Initialize Gemini-2.0-flash-exp model with system instruction\n",
+    "    gemini = google_genai.GenerativeModel(\n",
+    "        model_name=\"gemini-2.0-flash-exp\",\n",
+    "        system_instruction=system_message\n",
+    "    )\n",
+    "\n",
+    "    # Adding a delay to avoid hitting the API rate limit and getting a \"ResourceExhausted: 429\" error\n",
+    "    time.sleep(5)\n",
+    "    \n",
+    "    # Generate response using Gemini API\n",
+    "    response = gemini.generate_content(\n",
+    "        contents=user_messages,\n",
+    "        generation_config=google_genai.GenerationConfig(max_output_tokens=5)\n",
+    "    )\n",
+    "\n",
+    "    # Extract text response and convert to numerical price\n",
+    "    return get_price(response.text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "203dc6f1-309e-46eb-9957-e06eed803cc8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example usage:\n",
+    "gemini_2_point_0_flash_exp(test[0])  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a844df09-d347-40b9-bb79-006ec4160aab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Retrieve the actual price of the test item (for comparison)\n",
+    "test[0].price    # Output: 374.41"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "500b45c7-e5c1-44f2-95c9-1c3c06365339",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test the function for gemini-2.0-flash-exp using the Tester framework\n",
+    "Tester.test(gemini_2_point_0_flash_exp, test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "746b2d12-ba92-48e2-9065-c9a108d1593b",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}