Delete isopro/examples

isopro/examples/__init__.py

@@ -1,34 +0,0 @@
-"""
-ISOPRO Examples
-
-This package contains example Jupyter notebooks demonstrating various features and use cases of the ISOPRO package.
-
-Available examples:
-- custom_environment_example: Demonstrates how to create custom environments using Claude or Hugging Face models.
-- conversation_simulation_example: Shows how to use the conversation simulation with a Claude agent for customer service.
-- adversarial_simulation_example: Illustrates how to use the adversarial simulation and analyze its results.
-
-To run these examples, open the respective .ipynb files in a Jupyter notebook environment.
-"""
-
-# Import any shared utilities or constants used across notebooks here
-# For example:
-# from .utils import plot_results, load_sample_data
-
-# List available example notebooks
-AVAILABLE_EXAMPLES = [
-    "custom_environment_example",
-    "conversation_simulation_example",
-    "adversarial_simulation_example"
-]
-
-def list_examples():
-    """
-    Print a list of available example notebooks.
-    """
-    print("Available ISOPRO example notebooks:")
-    for example in AVAILABLE_EXAMPLES:
-        print(f"- {example}")
-    print("\nTo run an example, open the corresponding .ipynb file in a Jupyter notebook environment.")
-
-# You can add any other shared functions or variables here that might be useful across multiple notebooks

isopro/examples/adversarial_example.ipynb

@@ -1,242 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Adversarial Simulation Notebook\n",
-    "\n",
-    "This notebook demonstrates how to run an adversarial simulation against a language model (in this case, Claude) and analyze the results.\n",
-    "\n",
-    "## Setup\n",
-    "\n",
-    "First, we'll import the necessary libraries and set up our environment."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import logging\n",
-    "from typing import List\n",
-    "from isopro.adversarial_simulation import AdversarialSimulator, AdversarialEnvironment\n",
-    "from isopro.utils.analyze_adversarial_sim import analyze_adversarial_results, summarize_adversarial_impact\n",
-    "from isopro.agents.ai_agent import AI_Agent\n",
-    "import anthropic\n",
-    "import os\n",
-    "from dotenv import load_dotenv\n",
-    "import json\n",
-    "from datetime import datetime\n",
-    "import numpy as np\n",
-    "import torch\n",
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sns\n",
-    "\n",
-    "# Load environment variables\n",
-    "load_dotenv()\n",
-    "\n",
-    "# Set up logging\n",
-    "logging.basicConfig(level=logging.INFO)\n",
-    "logger = logging.getLogger(__name__)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Define Helper Classes and Functions\n",
-    "\n",
-    "Now, we'll define our ClaudeAgent class and some helper functions."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class ClaudeAgent(AI_Agent):\n",
-    "    def __init__(self, name):\n",
-    "        super().__init__(name)\n",
-    "        self.client = anthropic.Anthropic(api_key=os.getenv(\"ANTHROPIC_API_KEY\"))\n",
-    "\n",
-    "    def run(self, input_data):\n",
-    "        response = self.client.messages.create(\n",
-    "            model=\"claude-3-opus-20240229\",\n",
-    "            max_tokens=100,\n",
-    "            messages=[{\"role\": \"user\", \"content\": input_data['text']}]\n",
-    "        )\n",
-    "        return response.content[0].text\n",
-    "\n",
-    "    def step(self, sim_state):\n",
-    "        sim_state['output'] = self.run(sim_state)\n",
-    "        return sim_state\n",
-    "\n",
-    "class NumpyEncoder(json.JSONEncoder):\n",
-    "    def default(self, obj):\n",
-    "        if isinstance(obj, np.floating):\n",
-    "            return float(obj)\n",
-    "        if isinstance(obj, torch.Tensor):\n",
-    "            return obj.tolist()\n",
-    "        return super(NumpyEncoder, self).default(obj)\n",
-    "\n",
-    "def save_scores(output_dir: str, run_id: str, analysis_results: dict) -> None:\n",
-    "    os.makedirs(output_dir, exist_ok=True)\n",
-    "    output_file = os.path.join(output_dir, f\"adv-{run_id}.json\")\n",
-    "    \n",
-    "    try:\n",
-    "        with open(output_file, 'w') as f:\n",
-    "            json.dump(analysis_results, f, indent=2, cls=NumpyEncoder)\n",
-    "        \n",
-    "        logging.info(f\"Saved analysis results to {output_file}\")\n",
-    "    except Exception as e:\n",
-    "        logging.error(f\"Error saving analysis results: {str(e)}\")\n",
-    "\n",
-    "def get_sample_inputs() -> List[str]:\n",
-    "    return [\n",
-    "        \"What is the capital of France?\",\n",
-    "        \"How does photosynthesis work?\",\n",
-    "        \"Explain the theory of relativity.\"\n",
-    "    ]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Run the Adversarial Simulation\n",
-    "\n",
-    "Now we'll set up and run our adversarial simulation."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def run_simulation():\n",
-    "    run_id = datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
-    "    logger.info(f\"Starting adversarial simulation run {run_id}\")\n",
-    "\n",
-    "    claude_agent = ClaudeAgent(\"Claude Agent\")\n",
-    "\n",
-    "    # Create the AdversarialEnvironment\n",
-    "    adv_env = AdversarialEnvironment(\n",
-    "        agent_wrapper=claude_agent,\n",
-    "        num_adversarial_agents=2,\n",
-    "        attack_types=[\"textbugger\", \"deepwordbug\"],\n",
-    "        attack_targets=[\"input\", \"output\"]\n",
-    "    )\n",
-    "\n",
-    "    # Set up the adversarial simulator with the environment\n",
-    "    simulator = AdversarialSimulator(adv_env)\n",
-    "\n",
-    "    input_data = get_sample_inputs()\n",
-    "\n",
-    "    logger.info(\"Starting adversarial simulation...\")\n",
-    "    simulation_results = simulator.run_simulation(input_data, num_steps=1)\n",
-    "\n",
-    "    logger.info(\"Analyzing simulation results...\")\n",
-    "    analysis_results = analyze_adversarial_results(simulation_results)\n",
-    "\n",
-    "    summary = summarize_adversarial_impact(analysis_results)\n",
-    "\n",
-    "    print(\"\\nAdversarial Simulation Summary:\")\n",
-    "    print(summary)\n",
-    "\n",
-    "    output_dir = \"output\"\n",
-    "    save_scores(output_dir, run_id, analysis_results)\n",
-    "\n",
-    "    logger.info(\"Simulation complete.\")\n",
-    "    \n",
-    "    return simulation_results, analysis_results\n",
-    "\n",
-    "# Run the simulation\n",
-    "simulation_results, analysis_results = run_simulation()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Analyze and Visualize Results\n",
-    "\n",
-    "Now that we have our results, let's analyze and visualize them."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def plot_metric_changes(analysis_results):\n",
-    "    metrics = ['bleu', 'rouge-1', 'rouge-2', 'rouge-l', 'perplexity', 'coherence']\n",
-    "    changes = [analysis_results[f'{metric}_change'] for metric in metrics]\n",
-    "    \n",
-    "    plt.figure(figsize=(12, 6))\n",
-    "    sns.barplot(x=metrics, y=changes)\n",
-    "    plt.title('Changes in Metrics After Adversarial Attacks')\n",
-    "    plt.xlabel('Metrics')\n",
-    "    plt.ylabel('Percentage Change')\n",
-    "    plt.xticks(rotation=45)\n",
-    "    plt.show()\n",
-    "\n",
-    "plot_metric_changes(analysis_results)\n",
-    "\n",
-    "# Display original and perturbed inputs and outputs\n",
-    "for i, result in enumerate(simulation_results):\n",
-    "    print(f\"\\nExample {i+1}:\")\n",
-    "    print(f\"Original Input: {result['original_input']}\")\n",
-    "    print(f\"Perturbed Input: {result['perturbed_input']}\")\n",
-    "    print(f\"Original Output: {result['original_output']}\")\n",
-    "    print(f\"Perturbed Output: {result['perturbed_output']}\")\n",
-    "    print(\"-\" * 50)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Conclusion\n",
-    "\n",
-    "This notebook demonstrates how to run an adversarial simulation against a language model and analyze the results. The simulation applies various adversarial attacks to the input or output of the model and measures the impact on different metrics.\n",
-    "\n",
-    "Key observations:\n",
-    "1. The changes in different metrics (BLEU, ROUGE, perplexity, coherence) show how the adversarial attacks affect the model's performance.\n",
-    "2. By comparing the original and perturbed inputs and outputs, we can see how the attacks modify the text and how the model's responses change as a result.\n",
-    "\n",
-    "This information can be used to assess the robustness of the language model against adversarial attacks and identify areas for improvement in the model's defenses."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "smooth_env",
-   "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.9.18"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "e35b4d35af899f01dc238e082b97509c22792197b4b3ae814b774a24a240ad24"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

isopro/examples/conversation_simulation_example.ipynb

@@ -1,258 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Conversation Simulator\n",
-    "\n",
-    "This notebook demonstrates the usage of the Conversation Simulator from the isopro package. It simulates conversations between an AI assistant (either Claude or GPT-4) and various user personas."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Setup\n",
-    "\n",
-    "First, let's import the necessary modules and set up our environment."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import logging\n",
-    "from logging.handlers import RotatingFileHandler\n",
-    "import os\n",
-    "from datetime import datetime\n",
-    "from dotenv import load_dotenv\n",
-    "from isopro.conversation_simulation.conversation_simulator import ConversationSimulator\n",
-    "from isopro.conversation_simulation.custom_persona import create_custom_persona\n",
-    "\n",
-    "# Load environment variables\n",
-    "load_dotenv()\n",
-    "\n",
-    "# Set up logging\n",
-    "log_directory = \"logs\"\n",
-    "os.makedirs(log_directory, exist_ok=True)\n",
-    "log_file = os.path.join(log_directory, \"conversation_simulator.log\")\n",
-    "\n",
-    "# Create a rotating file handler\n",
-    "file_handler = RotatingFileHandler(log_file, maxBytes=1024*1024, backupCount=5)\n",
-    "file_handler.setLevel(logging.DEBUG)\n",
-    "file_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')\n",
-    "file_handler.setFormatter(file_formatter)\n",
-    "\n",
-    "# Create a console handler\n",
-    "console_handler = logging.StreamHandler()\n",
-    "console_handler.setLevel(logging.INFO)\n",
-    "console_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')\n",
-    "console_handler.setFormatter(console_formatter)\n",
-    "\n",
-    "# Set up the logger\n",
-    "logger = logging.getLogger()\n",
-    "logger.setLevel(logging.DEBUG)\n",
-    "logger.addHandler(file_handler)\n",
-    "logger.addHandler(console_handler)\n",
-    "\n",
-    "print(\"Setup complete.\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Helper Functions\n",
-    "\n",
-    "Next, let's define some helper functions."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def save_output(content, filename):\n",
-    "    \"\"\"Save the output content to a file.\"\"\"\n",
-    "    with open(filename, 'w', encoding='utf-8') as f:\n",
-    "        f.write(content)\n",
-    "\n",
-    "def get_user_choice():\n",
-    "    \"\"\"Get user's choice of AI model.\"\"\"\n",
-    "    while True:\n",
-    "        choice = input(\"Choose AI model (claude/openai): \").lower()\n",
-    "        if choice in ['claude', 'openai']:\n",
-    "            return choice\n",
-    "        print(\"Invalid choice. Please enter 'claude' or 'openai'.\")\n",
-    "\n",
-    "print(\"Helper functions defined.\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Main Simulation Function\n",
-    "\n",
-    "Now, let's define our main simulation function."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def run_simulation():\n",
-    "    # Get user's choice of AI model\n",
-    "    ai_choice = get_user_choice()\n",
-    "\n",
-    "    # Set up the appropriate model and API key\n",
-    "    if ai_choice == 'claude':\n",
-    "        model = \"claude-3-opus-20240229\"\n",
-    "        os.environ[\"ANTHROPIC_API_KEY\"] = os.getenv(\"ANTHROPIC_API_KEY\")\n",
-    "        ai_name = \"Claude\"\n",
-    "    else:  # openai\n",
-    "        model = \"gpt-4-1106-preview\"\n",
-    "        os.environ[\"OPENAI_API_KEY\"] = os.getenv(\"OPENAI_API_KEY\")\n",
-    "        ai_name = \"GPT-4 Turbo\"\n",
-    "\n",
-    "    # Initialize the ConversationSimulator\n",
-    "    simulator = ConversationSimulator(\n",
-    "        ai_prompt=f\"You are {ai_name}, an AI assistant created to be helpful, harmless, and honest. You are a customer service agent for a tech company. Respond politely and professionally.\"\n",
-    "    )\n",
-    "\n",
-    "    output_content = f\"Conversation Simulator using {ai_name} model: {model}\\n\\n\"\n",
-    "\n",
-    "    # Run simulations with different personas\n",
-    "    personas = [\"upset\", \"human_request\", \"inappropriate\", \"incomplete_info\"]\n",
-    "    \n",
-    "    for persona in personas:\n",
-    "        logger.info(f\"Running simulation with {persona} persona using {ai_name}\")\n",
-    "        conversation_history = simulator.run_simulation(persona, num_turns=3)\n",
-    "        \n",
-    "        output_content += f\"\\nConversation with {persona} persona:\\n\"\n",
-    "        for message in conversation_history:\n",
-    "            output_line = f\"{message['role'].capitalize()}: {message['content']}\\n\"\n",
-    "            output_content += output_line\n",
-    "            logger.debug(output_line.strip())\n",
-    "        output_content += \"\\n\" + \"-\"*50 + \"\\n\"\n",
-    "\n",
-    "    # Create and run a simulation with a custom persona\n",
-    "    custom_persona_name = \"Techie Customer\"\n",
-    "    custom_characteristics = [\"tech-savvy\", \"impatient\", \"detail-oriented\"]\n",
-    "    custom_message_templates = [\n",
-    "        \"I've tried rebooting my device, but the error persists. Can you help?\",\n",
-    "        \"What's the latest update on the cloud service outage?\",\n",
-    "        \"I need specifics on the API rate limits for the enterprise plan.\",\n",
-    "        \"The latency on your servers is unacceptable. What's being done about it?\",\n",
-    "        \"Can you explain the technical details of your encryption method?\"\n",
-    "    ]\n",
-    "\n",
-    "    logger.info(f\"Running simulation with custom persona: {custom_persona_name} using {ai_name}\")\n",
-    "    custom_conversation = simulator.run_custom_simulation(\n",
-    "        custom_persona_name,\n",
-    "        custom_characteristics,\n",
-    "        custom_message_templates,\n",
-    "        num_turns=3\n",
-    "    )\n",
-    "\n",
-    "    output_content += f\"\\nConversation with {custom_persona_name}:\\n\"\n",
-    "    for message in custom_conversation:\n",
-    "        output_line = f\"{message['role'].capitalize()}: {message['content']}\\n\"\n",
-    "        output_content += output_line\n",
-    "        logger.debug(output_line.strip())\n",
-    "\n",
-    "    # Save the output to a file\n",
-    "    timestamp = datetime.now().strftime(\"%Y%m%d_%H%M%S\")\n",
-    "    output_directory = \"output\"\n",
-    "    os.makedirs(output_directory, exist_ok=True)\n",
-    "    output_file = os.path.join(output_directory, f\"{ai_name.lower()}_conversation_output_{timestamp}.txt\")\n",
-    "    save_output(output_content, output_file)\n",
-    "    logger.info(f\"Output saved to {output_file}\")\n",
-    "\n",
-    "    return output_content\n",
-    "\n",
-    "print(\"Main simulation function defined.\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Run the Simulation\n",
-    "\n",
-    "Now we're ready to run the simulation. This cell will prompt you to choose between Claude and GPT-4, then run the simulation and display the results."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "simulation_output = run_simulation()\n",
-    "print(simulation_output)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Analyze the Results\n",
-    "\n",
-    "After running the simulation, you can analyze the results here. For example, you might want to count the number of times certain phrases or words were used, or calculate the average length of responses."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Example analysis: Count the number of apologies\n",
-    "apology_count = simulation_output.lower().count(\"sorry\") + simulation_output.lower().count(\"apologi\")\n",
-    "print(f\"Number of apologies: {apology_count}\")\n",
-    "\n",
-    "# Example analysis: Average length of AI responses\n",
-    "ai_responses = [line.split(\": \", 1)[1] for line in simulation_output.split(\"\\n\") if line.startswith(\"Assistant: \")]\n",
-    "avg_response_length = sum(len(response.split()) for response in ai_responses) / len(ai_responses)\n",
-    "print(f\"Average length of AI responses: {avg_response_length:.2f} words\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Conclusion\n",
-    "\n",
-    "This notebook demonstrates how to use the Conversation Simulator from the isopro package. You can modify the personas, adjust the number of turns, or add your own analysis to further explore the capabilities of the AI models in customer service scenarios."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

isopro/examples/orchestrator_example.ipynb

@@ -1,245 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# isopro Tutorial: Orchestrator, Evaluator, and Evaluation Modules\n",
-    "\n",
-    "This notebook will guide you through using the `isopro` package, focusing on the orchestrator, evaluator, and evaluation modules. We'll cover installation, setup, and usage examples."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 1. Installation\n",
-    "\n",
-    "First, let's install the `isopro` package. Run the following cell to install it using pip:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pip install isopro"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2. Setup\n",
-    "\n",
-    "Now, let's import the necessary modules and set up our environment. We'll need to set our API keys for OpenAI and Anthropic. In a production environment, you should use environment variables for these keys. For this notebook, we'll set them directly (but remember not to share your notebook with these keys included)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
-     ]
-    },
-    {
-     "ename": "",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[1;31mCanceled future for execute_request message before replies were done"
-     ]
-    }
-   ],
-   "source": [
-    "import os\n",
-    "from isopro.orchestration_simulation import OrchestrationEnv\n",
-    "from isopro.orchestration_simulation.components import LLaMAAgent, AnalysisAgent, WritingAgent\n",
-    "from isopro.orchestration_simulation.evaluator import Evaluator\n",
-    "from dotenv import load_dotenv\n",
-    "\n",
-    "# Load environment variables from .env file\n",
-    "load_dotenv()\n",
-    "\n",
-    "# Access API keys from environment variables\n",
-    "openai_api_key = os.getenv(\"OPENAI_API_KEY\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 3. Creating the Orchestration Environment\n",
-    "\n",
-    "Let's create our orchestration environment and add our agents to it."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create the orchestration environment\n",
-    "env = OrchestrationEnv()\n",
-    "\n",
-    "# Add agents to the environment\n",
-    "env.add_component(LLaMAAgent(\"Research\", \"conduct thorough research on the impact of artificial intelligence on job markets in the next decade\"))\n",
-    "env.add_component(AnalysisAgent(\"Analysis\"))\n",
-    "env.add_component(WritingAgent(\"Writing\"))\n",
-    "\n",
-    "print(\"Orchestration environment created with agents added!\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 4. Defining the Task\n",
-    "\n",
-    "Now, let's define the task that our agents will work on."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "task = \"Prepare a comprehensive report on the impact of artificial intelligence on job markets in the next decade.\"\n",
-    "print(f\"Task defined: {task}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 5. Running Simulations in Different Modes\n",
-    "\n",
-    "We'll now run our simulation in different modes: parallel, sequence, and node."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "modes = ['parallel', 'sequence', 'node']\n",
-    "results = {}\n",
-    "\n",
-    "for mode in modes:\n",
-    "    print(f\"\\nRunning simulation in {mode} mode...\")\n",
-    "    result = env.run_simulation(mode=mode, input_data={'task': task, 'run_order': 'first'})\n",
-    "    results[mode] = result\n",
-    "    print(f\"Simulation in {mode} mode completed.\")\n",
-    "\n",
-    "print(\"\\nAll simulations completed!\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 6. Evaluating the Results\n",
-    "\n",
-    "Now that we have our results, let's use the Evaluator to determine which mode performed best."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'Evaluator' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-1-a86bfe25b9d1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mevaluator\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEvaluator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mbest_mode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mevaluator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresults\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"\\nEvaluation complete. The best execution mode for this task was: {best_mode}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'Evaluator' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "evaluator = Evaluator()\n",
-    "best_mode = evaluator.evaluate(results)\n",
-    "\n",
-    "print(f\"\\nEvaluation complete. The best execution mode for this task was: {best_mode}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 7. Examining the Results\n",
-    "\n",
-    "Let's take a closer look at the results from each mode."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for mode, result in results.items():\n",
-    "    print(f\"\\nResults for {mode} mode:\")\n",
-    "    print(f\"Execution Time: {result.get('execution_time', 'N/A')} seconds\")\n",
-    "    print(f\"Memory Usage: {result.get('memory_usage', 'N/A')} MB\")\n",
-    "    print(f\"Output Sample: {result.get('output', 'N/A')[:200]}...\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 8. Conclusion\n",
-    "\n",
-    "In this tutorial, we've learned how to:\n",
-    "1. Set up the isopro package\n",
-    "2. Create an orchestration environment and add agents\n",
-    "3. Run simulations in different modes\n",
-    "4. Use the Evaluator to determine the best execution mode\n",
-    "5. Examine the results of our simulations\n",
-    "\n",
-    "This demonstrates the power and flexibility of the isopro package for orchestrating AI agents and evaluating their performance in different execution modes."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "smooth_env",
-   "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.9.18"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "e35b4d35af899f01dc238e082b97509c22792197b4b3ae814b774a24a240ad24"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

isopro/examples/run_cartpole_example.ipynb

@@ -1,403 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# LLM-based CartPole Reinforcement Learning Agent\n",
-    "\n",
-    "This notebook demonstrates how to create and train a Reinforcement Learning agent that uses a Large Language Model (LLM) to make decisions in the CartPole environment.\n",
-    "\n",
-    "## Setup\n",
-    "\n",
-    "First, let's import the necessary libraries and set up our environment."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Collecting isopro\n",
-      "  Downloading isopro-0.1.2-py3-none-any.whl (60 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m60.4/60.4 kB\u001b[0m \u001b[31m2.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting tqdm\n",
-      "  Using cached tqdm-4.66.5-py3-none-any.whl (78 kB)\n",
-      "Collecting gymnasium\n",
-      "  Using cached gymnasium-0.29.1-py3-none-any.whl (953 kB)\n",
-      "Collecting transformers\n",
-      "  Downloading transformers-4.45.0-py3-none-any.whl (9.9 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m9.9/9.9 MB\u001b[0m \u001b[31m36.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
-      "\u001b[?25hCollecting seaborn\n",
-      "  Downloading seaborn-0.13.2-py3-none-any.whl (294 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m294.9/294.9 kB\u001b[0m \u001b[31m19.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting rouge\n",
-      "  Using cached rouge-1.0.1-py3-none-any.whl (13 kB)\n",
-      "Collecting langchain-openai\n",
-      "  Downloading langchain_openai-0.1.25-py3-none-any.whl (51 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m51.5/51.5 kB\u001b[0m \u001b[31m7.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting nltk\n",
-      "  Using cached nltk-3.9.1-py3-none-any.whl (1.5 MB)\n",
-      "Collecting scikit-learn\n",
-      "  Downloading scikit_learn-1.3.2-cp38-cp38-macosx_10_9_x86_64.whl (10.1 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.1/10.1 MB\u001b[0m \u001b[31m55.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m0:01\u001b[0m\n",
-      "\u001b[?25hCollecting matplotlib\n",
-      "  Downloading matplotlib-3.7.5-cp38-cp38-macosx_10_12_x86_64.whl (7.4 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.4/7.4 MB\u001b[0m \u001b[31m53.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
-      "\u001b[?25hCollecting openai\n",
-      "  Downloading openai-1.48.0-py3-none-any.whl (376 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m376.1/376.1 kB\u001b[0m \u001b[31m38.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting stable-baselines3\n",
-      "  Using cached stable_baselines3-2.3.2-py3-none-any.whl (182 kB)\n",
-      "Collecting torch\n",
-      "  Using cached torch-2.2.2-cp38-none-macosx_10_9_x86_64.whl (150.6 MB)\n",
-      "Collecting anthropic\n",
-      "  Downloading anthropic-0.34.2-py3-none-any.whl (891 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m891.9/891.9 kB\u001b[0m \u001b[31m46.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting iso-adverse\n",
-      "  Using cached iso_adverse-0.2.0-py3-none-any.whl (12 kB)\n",
-      "Requirement already satisfied: numpy in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from isopro) (1.24.2)\n",
-      "Collecting langchain\n",
-      "  Downloading langchain-0.2.16-py3-none-any.whl (1.0 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.0/1.0 MB\u001b[0m \u001b[31m37.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting sentence-transformers\n",
-      "  Downloading sentence_transformers-3.1.1-py3-none-any.whl (245 kB)\n",
-      "\u001b[2K     \u001b[90m━━━���━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m245.3/245.3 kB\u001b[0m \u001b[31m23.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting python-dotenv\n",
-      "  Using cached python_dotenv-1.0.1-py3-none-any.whl (19 kB)\n",
-      "Collecting distro<2,>=1.7.0\n",
-      "  Using cached distro-1.9.0-py3-none-any.whl (20 kB)\n",
-      "Collecting tokenizers>=0.13.0\n",
-      "  Downloading tokenizers-0.20.0-cp38-cp38-macosx_10_12_x86_64.whl (2.6 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.6/2.6 MB\u001b[0m \u001b[31m51.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n",
-      "\u001b[?25hRequirement already satisfied: anyio<5,>=3.5.0 in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from anthropic->isopro) (3.6.2)\n",
-      "Collecting jiter<1,>=0.4.0\n",
-      "  Using cached jiter-0.5.0-cp38-cp38-macosx_10_12_x86_64.whl (284 kB)\n",
-      "Collecting typing-extensions<5,>=4.7\n",
-      "  Using cached typing_extensions-4.12.2-py3-none-any.whl (37 kB)\n",
-      "Requirement already satisfied: sniffio in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from anthropic->isopro) (1.3.0)\n",
-      "Collecting httpx<1,>=0.23.0\n",
-      "  Downloading httpx-0.27.2-py3-none-any.whl (76 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.4/76.4 kB\u001b[0m \u001b[31m9.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting pydantic<3,>=1.9.0\n",
-      "  Downloading pydantic-2.9.2-py3-none-any.whl (434 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m434.9/434.9 kB\u001b[0m \u001b[31m33.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting cloudpickle>=1.2.0\n",
-      "  Using cached cloudpickle-3.0.0-py3-none-any.whl (20 kB)\n",
-      "Collecting farama-notifications>=0.0.1\n",
-      "  Using cached Farama_Notifications-0.0.4-py3-none-any.whl (2.5 kB)\n",
-      "Requirement already satisfied: importlib-metadata>=4.8.0 in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from gymnasium->isopro) (6.0.0)\n",
-      "Collecting filelock\n",
-      "  Downloading filelock-3.16.1-py3-none-any.whl (16 kB)\n",
-      "Requirement already satisfied: jinja2 in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from torch->isopro) (3.1.2)\n",
-      "Collecting sympy\n",
-      "  Downloading sympy-1.13.3-py3-none-any.whl (6.2 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.2/6.2 MB\u001b[0m \u001b[31m51.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
-      "\u001b[?25hCollecting fsspec\n",
-      "  Downloading fsspec-2024.9.0-py3-none-any.whl (179 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m179.3/179.3 kB\u001b[0m \u001b[31m22.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting networkx\n",
-      "  Using cached networkx-3.1-py3-none-any.whl (2.1 MB)\n",
-      "Requirement already satisfied: packaging>=20.0 in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from transformers->isopro) (23.0)\n",
-      "Collecting safetensors>=0.4.1\n",
-      "  Downloading safetensors-0.4.5-cp38-cp38-macosx_10_12_x86_64.whl (392 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m392.9/392.9 kB\u001b[0m \u001b[31m21.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting huggingface-hub<1.0,>=0.23.2\n",
-      "  Downloading huggingface_hub-0.25.1-py3-none-any.whl (436 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m436.4/436.4 kB\u001b[0m \u001b[31m26.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting regex!=2019.12.17\n",
-      "  Downloading regex-2024.9.11-cp38-cp38-macosx_10_9_x86_64.whl (287 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m287.5/287.5 kB\u001b[0m \u001b[31m17.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hRequirement already satisfied: requests in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from transformers->isopro) (2.28.2)\n",
-      "Requirement already satisfied: pyyaml>=5.1 in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from transformers->isopro) (6.0)\n",
-      "Collecting langchain-core<0.3.0,>=0.2.38\n",
-      "  Downloading langchain_core-0.2.41-py3-none-any.whl (397 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m397.0/397.0 kB\u001b[0m \u001b[31m21.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting SQLAlchemy<3,>=1.4\n",
-      "  Downloading SQLAlchemy-2.0.35-cp38-cp38-macosx_10_9_x86_64.whl (2.1 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.1/2.1 MB\u001b[0m \u001b[31m60.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting async-timeout<5.0.0,>=4.0.0\n",
-      "  Using cached async_timeout-4.0.3-py3-none-any.whl (5.7 kB)\n",
-      "Collecting aiohttp<4.0.0,>=3.8.3\n",
-      "  Downloading aiohttp-3.10.6-cp38-cp38-macosx_10_9_x86_64.whl (401 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m401.0/401.0 kB\u001b[0m \u001b[31m28.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting tenacity!=8.4.0,<9.0.0,>=8.1.0\n",
-      "  Using cached tenacity-8.5.0-py3-none-any.whl (28 kB)\n",
-      "Collecting langsmith<0.2.0,>=0.1.17\n",
-      "  Downloading langsmith-0.1.128-py3-none-any.whl (292 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m292.1/292.1 kB\u001b[0m \u001b[31m24.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting langchain-text-splitters<0.3.0,>=0.2.0\n",
-      "  Downloading langchain_text_splitters-0.2.4-py3-none-any.whl (25 kB)\n",
-      "Collecting tiktoken<1,>=0.7\n",
-      "  Using cached tiktoken-0.7.0-cp38-cp38-macosx_10_9_x86_64.whl (961 kB)\n",
-      "Collecting pyparsing>=2.3.1\n",
-      "  Using cached pyparsing-3.1.4-py3-none-any.whl (104 kB)\n",
-      "Requirement already satisfied: importlib-resources>=3.2.0 in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from matplotlib->isopro) (5.10.2)\n",
-      "Collecting fonttools>=4.22.0\n",
-      "  Downloading fonttools-4.54.1-cp38-cp38-macosx_10_9_universal2.whl (2.8 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.8/2.8 MB\u001b[0m \u001b[31m58.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m\n",
-      "\u001b[?25hCollecting contourpy>=1.0.1\n",
-      "  Downloading contourpy-1.1.1-cp38-cp38-macosx_10_9_x86_64.whl (247 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m247.0/247.0 kB\u001b[0m \u001b[31m30.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting pillow>=6.2.0\n",
-      "  Using cached pillow-10.4.0-cp38-cp38-macosx_10_10_x86_64.whl (3.5 MB)\n",
-      "Requirement already satisfied: python-dateutil>=2.7 in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from matplotlib->isopro) (2.8.2)\n",
-      "Collecting kiwisolver>=1.0.1\n",
-      "  Downloading kiwisolver-1.4.7-cp38-cp38-macosx_10_9_x86_64.whl (65 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m65.7/65.7 kB\u001b[0m \u001b[31m7.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting cycler>=0.10\n",
-      "  Using cached cycler-0.12.1-py3-none-any.whl (8.3 kB)\n",
-      "Collecting click\n",
-      "  Using cached click-8.1.7-py3-none-any.whl (97 kB)\n",
-      "Collecting joblib\n",
-      "  Using cached joblib-1.4.2-py3-none-any.whl (301 kB)\n",
-      "Requirement already satisfied: six in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from rouge->isopro) (1.16.0)\n",
-      "Collecting scipy>=1.5.0\n",
-      "  Downloading scipy-1.10.1-cp38-cp38-macosx_10_9_x86_64.whl (35.0 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m35.0/35.0 MB\u001b[0m \u001b[31m43.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
-      "\u001b[?25hCollecting threadpoolctl>=2.0.0\n",
-      "  Using cached threadpoolctl-3.5.0-py3-none-any.whl (18 kB)\n",
-      "Collecting pandas>=1.2\n",
-      "  Downloading pandas-2.0.3-cp38-cp38-macosx_10_9_x86_64.whl (11.7 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m11.7/11.7 MB\u001b[0m \u001b[31m54.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
-      "\u001b[?25hCollecting multidict<7.0,>=4.5\n",
-      "  Downloading multidict-6.1.0-cp38-cp38-macosx_10_9_x86_64.whl (29 kB)\n",
-      "Collecting yarl<2.0,>=1.12.0\n",
-      "  Downloading yarl-1.12.1-cp38-cp38-macosx_10_9_x86_64.whl (116 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.6/116.6 kB\u001b[0m \u001b[31m11.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting aiosignal>=1.1.2\n",
-      "  Using cached aiosignal-1.3.1-py3-none-any.whl (7.6 kB)\n",
-      "Requirement already satisfied: attrs>=17.3.0 in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from aiohttp<4.0.0,>=3.8.3->langchain->isopro) (22.2.0)\n",
-      "Collecting aiohappyeyeballs>=2.3.0\n",
-      "  Using cached aiohappyeyeballs-2.4.0-py3-none-any.whl (12 kB)\n",
-      "Collecting frozenlist>=1.1.1\n",
-      "  Using cached frozenlist-1.4.1-cp38-cp38-macosx_10_9_x86_64.whl (55 kB)\n",
-      "Requirement already satisfied: idna>=2.8 in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from anyio<5,>=3.5.0->anthropic->isopro) (3.4)\n",
-      "Collecting httpcore==1.*\n",
-      "  Using cached httpcore-1.0.5-py3-none-any.whl (77 kB)\n",
-      "Requirement already satisfied: certifi in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from httpx<1,>=0.23.0->anthropic->isopro) (2022.12.7)\n",
-      "Collecting h11<0.15,>=0.13\n",
-      "  Using cached h11-0.14.0-py3-none-any.whl (58 kB)\n",
-      "Requirement already satisfied: zipp>=0.5 in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from importlib-metadata>=4.8.0->gymnasium->isopro) (3.13.0)\n",
-      "Collecting packaging>=20.0\n",
-      "  Using cached packaging-24.1-py3-none-any.whl (53 kB)\n",
-      "Collecting jsonpatch<2.0,>=1.33\n",
-      "  Using cached jsonpatch-1.33-py2.py3-none-any.whl (12 kB)\n",
-      "Collecting orjson<4.0.0,>=3.9.14\n",
-      "  Downloading orjson-3.10.7-cp38-cp38-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl (251 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m251.1/251.1 kB\u001b[0m \u001b[31m20.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting tzdata>=2022.1\n",
-      "  Downloading tzdata-2024.2-py2.py3-none-any.whl (346 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m346.6/346.6 kB\u001b[0m \u001b[31m27.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25hCollecting pytz>=2020.1\n",
-      "  Using cached pytz-2024.2-py2.py3-none-any.whl (508 kB)\n",
-      "Collecting annotated-types>=0.6.0\n",
-      "  Using cached annotated_types-0.7.0-py3-none-any.whl (13 kB)\n",
-      "Collecting pydantic-core==2.23.4\n",
-      "  Downloading pydantic_core-2.23.4-cp38-cp38-macosx_10_12_x86_64.whl (1.9 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.9/1.9 MB\u001b[0m \u001b[31m39.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m\n",
-      "\u001b[?25hRequirement already satisfied: charset-normalizer<4,>=2 in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from requests->transformers->isopro) (3.0.1)\n",
-      "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from requests->transformers->isopro) (1.26.14)\n",
-      "Collecting greenlet!=0.4.17\n",
-      "  Downloading greenlet-3.1.1.tar.gz (186 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m186.0/186.0 kB\u001b[0m \u001b[31m22.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-      "\u001b[?25h  Installing build dependencies ... \u001b[?25ldone\n",
-      "\u001b[?25h  Getting requirements to build wheel ... \u001b[?25ldone\n",
-      "\u001b[?25h  Preparing metadata (pyproject.toml) ... \u001b[?25ldone\n",
-      "\u001b[?25hRequirement already satisfied: MarkupSafe>=2.0 in /Users/jazmiahenry/toy_genai/env/lib/python3.8/site-packages (from jinja2->torch->isopro) (2.1.2)\n",
-      "Collecting mpmath<1.4,>=1.1.0\n",
-      "  Using cached mpmath-1.3.0-py3-none-any.whl (536 kB)\n",
-      "Collecting jsonpointer>=1.9\n",
-      "  Using cached jsonpointer-3.0.0-py2.py3-none-any.whl (7.6 kB)\n",
-      "Building wheels for collected packages: greenlet\n",
-      "  Building wheel for greenlet (pyproject.toml) ... \u001b[?25ldone\n",
-      "\u001b[?25h  Created wheel for greenlet: filename=greenlet-3.1.1-cp38-cp38-macosx_10_9_x86_64.whl size=228270 sha256=61660bb35fa5416d14ab65bd473051c7c9f723b524837a5fd0c58d21fb4818bd\n",
-      "  Stored in directory: /Users/jazmiahenry/Library/Caches/pip/wheels/ba/f9/e2/f8e444bf385c014fea09ef24bde9b85486657505f51396875f\n",
-      "Successfully built greenlet\n",
-      "Installing collected packages: pytz, mpmath, farama-notifications, tzdata, typing-extensions, tqdm, threadpoolctl, tenacity, sympy, scipy, safetensors, rouge, regex, python-dotenv, pyparsing, pillow, packaging, orjson, networkx, kiwisolver, jsonpointer, joblib, jiter, h11, greenlet, fsspec, frozenlist, fonttools, filelock, distro, cycler, contourpy, cloudpickle, click, async-timeout, aiohappyeyeballs, torch, tiktoken, SQLAlchemy, scikit-learn, pydantic-core, pandas, nltk, multidict, matplotlib, jsonpatch, huggingface-hub, httpcore, gymnasium, annotated-types, aiosignal, yarl, tokenizers, stable-baselines3, seaborn, pydantic, httpx, transformers, openai, langsmith, anthropic, aiohttp, sentence-transformers, langchain-core, iso-adverse, langchain-text-splitters, langchain-openai, langchain, isopro\n",
-      "  Attempting uninstall: typing-extensions\n",
-      "    Found existing installation: typing_extensions 4.4.0\n",
-      "    Uninstalling typing_extensions-4.4.0:\n",
-      "      Successfully uninstalled typing_extensions-4.4.0\n",
-      "  Attempting uninstall: packaging\n",
-      "    Found existing installation: packaging 23.0\n",
-      "    Uninstalling packaging-23.0:\n",
-      "      Successfully uninstalled packaging-23.0\n",
-      "Successfully installed SQLAlchemy-2.0.35 aiohappyeyeballs-2.4.0 aiohttp-3.10.6 aiosignal-1.3.1 annotated-types-0.7.0 anthropic-0.34.2 async-timeout-4.0.3 click-8.1.7 cloudpickle-3.0.0 contourpy-1.1.1 cycler-0.12.1 distro-1.9.0 farama-notifications-0.0.4 filelock-3.16.1 fonttools-4.54.1 frozenlist-1.4.1 fsspec-2024.9.0 greenlet-3.1.1 gymnasium-0.29.1 h11-0.14.0 httpcore-1.0.5 httpx-0.27.2 huggingface-hub-0.25.1 iso-adverse-0.2.0 isopro-0.1.2 jiter-0.5.0 joblib-1.4.2 jsonpatch-1.33 jsonpointer-3.0.0 kiwisolver-1.4.7 langchain-0.2.16 langchain-core-0.2.41 langchain-openai-0.1.25 langchain-text-splitters-0.2.4 langsmith-0.1.128 matplotlib-3.7.5 mpmath-1.3.0 multidict-6.1.0 networkx-3.1 nltk-3.9.1 openai-1.48.0 orjson-3.10.7 packaging-24.1 pandas-2.0.3 pillow-10.4.0 pydantic-2.9.2 pydantic-core-2.23.4 pyparsing-3.1.4 python-dotenv-1.0.1 pytz-2024.2 regex-2024.9.11 rouge-1.0.1 safetensors-0.4.5 scikit-learn-1.3.2 scipy-1.10.1 seaborn-0.13.2 sentence-transformers-3.1.1 stable-baselines3-2.3.2 sympy-1.13.3 tenacity-8.5.0 threadpoolctl-3.5.0 tiktoken-0.7.0 tokenizers-0.20.0 torch-2.2.2 tqdm-4.66.5 transformers-4.45.0 typing-extensions-4.12.2 tzdata-2024.2 yarl-1.12.1\n",
-      "\n",
-      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.2\u001b[0m\n",
-      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n"
-     ]
-    }
-   ],
-   "source": [
-    "!pip install isopro"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
-     ]
-    },
-    {
-     "ename": "",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[1;31mCanceled future for execute_request message before replies were done"
-     ]
-    }
-   ],
-   "source": [
-    "import gymnasium as gym\n",
-    "from isopro.rl.rl_agent import RLAgent\n",
-    "from isopro.rl.rl_environment import LLMRLEnvironment\n",
-    "from stable_baselines3 import PPO\n",
-    "import numpy as np\n",
-    "import anthropic\n",
-    "import os\n",
-    "import logging\n",
-    "from typing import Optional, Dict, Any\n",
-    "from tqdm import tqdm\n",
-    "import json\n",
-    "from datetime import datetime\n",
-    "from llm_cartpole_wrapper import LLMCartPoleWrapper\n",
-    "\n",
-    "# Set up logging\n",
-    "logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')\n",
-    "logger = logging.getLogger(__name__)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Create and Train the RL Agent\n",
-    "\n",
-    "Now, let's create our RL agent and train it using the LLM-based CartPole environment."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "agent_prompt = \"\"\"You are an AI trained to play the CartPole game. \n",
-    "Your goal is to balance a pole on a moving cart for as long as possible. \n",
-    "You will receive observations about the cart's position, velocity, pole angle, and angular velocity. \n",
-    "Based on these, you should decide whether to move the cart left or right. \n",
-    "Respond with 'Move left' or 'Move right' for each decision.\"\"\"\n",
-    "\n",
-    "env = LLMCartPoleWrapper(agent_prompt)\n",
-    "model = PPO(\"MlpPolicy\", env, verbose=1)\n",
-    "\n",
-    "logger.info(\"Starting training\")\n",
-    "model.learn(total_timesteps=10000)\n",
-    "logger.info(\"Training completed\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Test the Trained Agent\n",
-    "\n",
-    "Now that we've trained our agent, let's test it for 2 episodes and see how it performs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_episodes = 2\n",
-    "results = []\n",
-    "\n",
-    "logger.info(\"Starting test episodes\")\n",
-    "for episode in tqdm(range(test_episodes), desc=\"Test Episodes\"):\n",
-    "    obs, _ = env.reset()\n",
-    "    done = False\n",
-    "    total_reward = 0\n",
-    "    episode_length = 0\n",
-    "    while not done:\n",
-    "        action, _ = model.predict(obs, deterministic=True)\n",
-    "        obs, reward, terminated, truncated, _ = env.step(action)\n",
-    "        total_reward += reward\n",
-    "        episode_length += 1\n",
-    "        done = terminated or truncated\n",
-    "    \n",
-    "    logger.info(f\"Episode {episode + 1} completed. Total reward: {total_reward}, Length: {episode_length}\")\n",
-    "    results.append({\"episode\": episode + 1, \"total_reward\": total_reward, \"length\": episode_length})\n",
-    "\n",
-    "# Save results to file\n",
-    "timestamp = datetime.now().strftime(\"%Y%m%d_%H%M%S\")\n",
-    "output_file = os.path.join(output_folder, f\"cartpole_results_{timestamp}.json\")\n",
-    "with open(output_file, 'w') as f:\n",
-    "    json.dump(results, f, indent=2)\n",
-    "logger.info(f\"Results saved to {output_file}\")\n",
-    "\n",
-    "# Print summary\n",
-    "average_reward = sum(r['total_reward'] for r in results) / len(results)\n",
-    "average_length = sum(r['length'] for r in results) / len(results)\n",
-    "logger.info(f\"Test completed. Average reward: {average_reward:.2f}, Average length: {average_length:.2f}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Conclusion\n",
-    "\n",
-    "In this notebook, we've demonstrated how to:\n",
-    "\n",
-    "1. Set up an LLM-based wrapper for the CartPole environment\n",
-    "2. Train a reinforcement learning agent using this environment\n",
-    "3. Test the trained agent and collect performance metrics\n",
-    "\n",
-    "This approach combines the decision-making capabilities of a large language model with the learning process of reinforcement learning, potentially leading to interesting and novel solutions to the CartPole problem.\n",
-    "\n",
-    "Feel free to experiment with different prompts, training parameters, or even different environments to see how this approach can be applied in various scenarios!"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.6"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

isopro/examples/workflow_example.ipynb

@@ -1,316 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Automating a Meme Generator with Workflow Simulation\n",
-    "This notebook demonstrates how to use isopro.workflow_simulation to automate a meme generation workflow. We'll train an agent to:\n",
-    "\n",
-    "1. Navigate a meme generator website\n",
-    "2. Upload images\n",
-    "3. Add captions\n",
-    "4. Generate and download memes\n",
-    "\n",
-    "And do it all automatically!"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Setup\n",
-    "First, let's import our required libraries and set up our environment:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "from pathlib import Path\n",
-    "from isopro.workflow_simulation import (\n",
-    "    WorkflowSimulator,\n",
-    "    AgentConfig,\n",
-    "    VisualizationConfig,\n",
-    "    ValidationConfig\n",
-    ")\n",
-    "import matplotlib.pyplot as plt\n",
-    "from IPython.display import Image, HTML"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Configuration\n",
-    "Let's create a fun configuration for our meme generator automation:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create output directory for our memes\n",
-    "output_dir = Path(\"meme_generator.mp4\")\n",
-    "output_dir.mkdir(exist_ok=True)\n",
-    "\n",
-    "# Configure our agent with some fun parameters\n",
-    "agent_config = AgentConfig(\n",
-    "    learning_rate=3e-4,  # Not too fast, not too slow - just right for meme making\n",
-    "    pretrain_epochs=10,  # Give it some time to learn the art of memes\n",
-    "    use_demonstration=True,  # Learn from the meme masters\n",
-    "    use_reasoning=True,  # Think before you meme\n",
-    "    reward_threshold=0.8  # High standards for our memes!\n",
-    ")\n",
-    "\n",
-    "# Set up visualization so we can watch the magic happen\n",
-    "viz_config = VisualizationConfig(\n",
-    "    show_ui_elements=True,  # See what the agent sees\n",
-    "    show_cursor=True,  # Watch the cursor dance\n",
-    "    show_actions=True,  # Understand what's happening\n",
-    "    save_frames=True,  # Save the best moments\n",
-    "    real_time_display=True  # Watch it live!\n",
-    ")\n",
-    "\n",
-    "# Define what makes a successful meme\n",
-    "validation_config = ValidationConfig.from_dict({\n",
-    "    \"success_criteria\": [\n",
-    "        \"image_uploaded\",\n",
-    "        \"captions_added\",\n",
-    "        \"meme_generated\",\n",
-    "        \"meme_downloaded\"\n",
-    "    ],\n",
-    "    \"error_tolerance\": 0.1  # Some memes are meant to be a little off...\n",
-    "})"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Recording a Demonstration\n",
-    "Before we can train our agent, we need to show it how to make memes. Here's how we record a demonstration:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Initialize our simulator\n",
-    "simulator = WorkflowSimulator(\n",
-    "    video_path=\"meme_tutorial.mp4\",  # Your recorded workflow video\n",
-    "    agent_config=agent_config,\n",
-    "    viz_config=viz_config,\n",
-    "    validation_config=validation_config,\n",
-    "    output_dir=str(output_dir)\n",
-    ")\n",
-    "\n",
-    "# Let's see what our demonstration video looks like\n",
-    "display(HTML(f\"\"\"\n",
-    "<video width=\"640\" height=\"480\" controls>\n",
-    "    <source src=\"meme_tutorial.mp4\" type=\"video/mp4\">\n",
-    "    Your browser does not support the video tag.\n",
-    "</video>\n",
-    "\"\"\"))"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Training Our Meme Master\n",
-    "Now that we have our demonstration, let's train our agent to become a meme master:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Time to learn!\n",
-    "print(\"🎓 Training our agent to become a meme master...\")\n",
-    "training_results = simulator.train_agents()\n",
-    "\n",
-    "# Show the learning progress\n",
-    "plt.figure(figsize=(10, 5))\n",
-    "plt.plot(training_results['episode_rewards'])\n",
-    "plt.title(\"Learning to Meme\")\n",
-    "plt.xlabel(\"Episode\")\n",
-    "plt.ylabel(\"Reward\")\n",
-    "plt.show()\n",
-    "\n",
-    "# Print some fun stats\n",
-    "print(\"\\n🎯 Training Results:\")\n",
-    "print(f\"Average Reward: {training_results['mean_reward']:.2f}\")\n",
-    "print(f\"Success Rate: {training_results['success_rate']*100:.1f}%\")\n",
-    "print(f\"Best Episode Reward: {max(training_results['episode_rewards']):.2f}\")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Unleashing the Meme Generator\n",
-    "Let's use our trained agent to generate some memes!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Prepare some fun meme templates and captions\n",
-    "meme_tasks = [\n",
-    "    {\n",
-    "        \"template\": \"distracted_boyfriend.jpg\",\n",
-    "        \"captions\": [\n",
-    "            \"Python\",\n",
-    "            \"Me\",\n",
-    "            \"JavaScript\"\n",
-    "        ]\n",
-    "    },\n",
-    "    {\n",
-    "        \"template\": \"drake.jpg\",\n",
-    "        \"captions\": [\n",
-    "            \"Writing code without comments\",\n",
-    "            \"Writing comments without code\"\n",
-    "        ]\n",
-    "    },\n",
-    "    {\n",
-    "        \"template\": \"expanding_brain.jpg\",\n",
-    "        \"captions\": [\n",
-    "            \"print('debug')\",\n",
-    "            \"console.log('debug')\",\n",
-    "            \"Using a debugger\",\n",
-    "            \"Adding random print statements and hoping for the best\"\n",
-    "        ]\n",
-    "    }\n",
-    "]\n",
-    "\n",
-    "# Generate memes!\n",
-    "print(\"🎨 Generating memes...\")\n",
-    "for i, task in enumerate(meme_tasks):\n",
-    "    print(f\"\\n✨ Creating meme {i+1}/{len(meme_tasks)}\")\n",
-    "    \n",
-    "    # Let our agent work its magic\n",
-    "    observation = simulator.reset()\n",
-    "    done = False\n",
-    "    \n",
-    "    while not done:\n",
-    "        action, _ = simulator.predict(observation)\n",
-    "        observation, reward, done, info = simulator.step(action)\n",
-    "        \n",
-    "        if info.get('meme_generated'):\n",
-    "            print(\"🎉 Meme created successfully!\")\n",
-    "            \n",
-    "    # Display the generated meme\n",
-    "    meme_path = output_dir / f\"meme_{i+1}.png\"\n",
-    "    display(Image(filename=str(meme_path)))"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Analyzing Our Meme Factory\n",
-    "Let's look at some fun statistics about our meme generation:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Get evaluation results\n",
-    "eval_results = simulator.evaluate_agents()\n",
-    "\n",
-    "# Create a fun visualization of our meme factory stats\n",
-    "stats = {\n",
-    "    \"Memes Generated\": len(meme_tasks),\n",
-    "    \"Success Rate\": f\"{eval_results['success_rate']*100:.1f}%\",\n",
-    "    \"Average Generation Time\": f\"{eval_results['mean_length']:.1f}s\",\n",
-    "    \"Quality Score\": f\"{eval_results['mean_reward']:.2f}/1.0\"\n",
-    "}\n",
-    "\n",
-    "print(\"📊 Meme Factory Statistics:\")\n",
-    "for stat, value in stats.items():\n",
-    "    print(f\"{stat}: {value}\")\n",
-    "\n",
-    "# Plot a fun pie chart of time spent on each step\n",
-    "steps = [\n",
-    "    \"Finding Templates\",\n",
-    "    \"Adding Captions\",\n",
-    "    \"Adjusting Layout\",\n",
-    "    \"Generating Meme\",\n",
-    "    \"Saving Masterpiece\"\n",
-    "]\n",
-    "times = [15, 30, 25, 20, 10]  # Example percentages\n",
-    "\n",
-    "plt.figure(figsize=(10, 8))\n",
-    "plt.pie(times, labels=steps, autopct='%1.1f%%', \n",
-    "        colors=['#FF9999', '#66B2FF', '#99FF99', '#FFCC99', '#FF99CC'])\n",
-    "plt.title(\"Time Spent Making Memes\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Conclusion\n",
-    "Congratulations! You've successfully created an automated meme factory! 🎉\n",
-    "Some fun things we learned:\n",
-    "\n",
-    "- Our agent can learn to navigate UI elements and create memes\n",
-    "- The power of combining computer vision with reinforcement learning\n",
-    "- How to make our code more entertaining with emojis 😄\n",
-    "\n",
-    "## Next Steps\n",
-    "Want to make your meme factory even better? Here are some fun ideas:\n",
-    "\n",
-    "- Train on different meme templates\n",
-    "- Add text effects and styling\n",
-    "- Create a meme recommendation system\n",
-    "- Build a Discord bot using this automation\n",
-    "- Generate captions using Claude"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python",
-   "version": "3.12.7"
-  },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "7500c3e1c7c786e4ba1e4b4eb7588219b4e35d5153674f92eb3a82672b534f6e"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}