prompt-generation-claude-v1.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CAI Claude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ./llm.py\n",
    "import os\n",
    "import anthropic\n",
    "import openai\n",
    "from enum import Enum\n",
    "from dotenv import load_dotenv\n",
    "load_dotenv()\n",
    "\n",
    "\n",
    "anthropic_client = anthropic.Client(os.getenv('ANTHROPIC_API_KEY'))\n",
    "openai.api_key = os.getenv(\"OPENAI_API_KEY\")\n",
    "\n",
    "\n",
    "class Model(Enum):\n",
    "    claude_v1_latest = 'claude-v1'\n",
    "    claude_v1_0 = \"claude-v1.0\"\n",
    "    claude_v1_2 = \"claude-v1.2\"\n",
    "    claude_v1_3 = \"claude-v1.3\"\n",
    "    claude_instant_v1_latest = \"claude-instant-v1\"\n",
    "    claude_instant_v1_0 = \"claude-instant-v1.0\"\n",
    "    text_davinci_003 = 'text-davinci-003'\n",
    "    gpt_3_5_turbo = 'gpt-3.5-turbo'\n",
    "    gpt_4 = 'gpt-4'\n",
    "\n",
    "\n",
    "def get_llm_response(prompt: str, model: Model = Model.claude_v1_latest, temp_0_1: float = 0.5):\n",
    "    # OpenAI uses a temperature range from 0 to 2:\n",
    "    temp_0_2 = temp_0_1 * 2\n",
    "\n",
    "    if (model.value == 'text-davinci-003'):\n",
    "        response = openai.Completion.create(\n",
    "            model=model.value,\n",
    "            prompt=f\"Human: {prompt}\\n\\nAssistant: \",\n",
    "            max_tokens=1024,\n",
    "            temperature=temp_0_2\n",
    "        )\n",
    "        return response['choices'][0]['text'].strip()\n",
    "    elif (model.value in ['gpt-3.5-turbo', 'gpt-4']):\n",
    "        response = openai.ChatCompletion.create(\n",
    "            model=model.value,\n",
    "            messages=[\n",
    "                {\n",
    "                    \"role\": \"user\",\n",
    "                    \"content\": prompt\n",
    "                }\n",
    "            ],\n",
    "            max_tokens=1024,\n",
    "            temperature=temp_0_2,\n",
    "            stream=False\n",
    "        )\n",
    "        return response['choices'][0]['message']['content']\n",
    "    else:\n",
    "        response = anthropic_client.completion(\n",
    "            prompt=f\"{anthropic.HUMAN_PROMPT} {prompt}{anthropic.AI_PROMPT}\",\n",
    "            stop_sequences=[anthropic.HUMAN_PROMPT],\n",
    "            model=model.value,\n",
    "            max_tokens_to_sample=1024,\n",
    "            temperature=temp_0_1,\n",
    "        )\n",
    "        return response['completion']\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model.claude_v1_latest\n",
    "\n",
    "num_samples = 5\n",
    "\n",
    "constitution_rules = [\n",
    "    \"Instructions must explicitly describe the tone that the editor adpots.\",\n",
    "    \"Instructions must explicitly state the number of words that editor's written response should be, and the number of words should be appropriate for the task.\",\n",
    "    \"Instructions should explicitly reference the article content at the beginning, for example 'Here is an article:\\n\\n<article>ARTICLE_CONTENT</article>\\n\\n[Rest of instruction goes here]'.\",\n",
    "    \"Instructions which involve multiple steps should be broken down into numbered subtasks.\",\n",
    "    # \"Instructions must include explicit examples. For example, if the instruction is to check for spelling errors, it should include an example typo and its correction.\",\n",
    "]\n",
    "constitution_str = \"\\n\".join(map(lambda x: f\"{x[0]+1}. {x[1]}\", enumerate(constitution_rules)))\n",
    "\n",
    "\n",
    "def get_concepts_prompt(n: int):\n",
    "    return f\"Generate a list of {n} tasks that a Copy Editor might do as part of their job, given a written article. The output of each completed task should be written text. Write each task on a separate, numbered line.\"\n",
    "\n",
    "\n",
    "def get_naive_response_prompt(concept: str):\n",
    "    return f\"\"\"I have an AI agent which acts as a Copy Editor and I want it to complete the following task:\n",
    "\n",
    "<task>\n",
    "{concept}\n",
    "</task>\n",
    "\n",
    "The agent only responds with written text. Write a concise instruction for the agent, asking it to complete this task. Do not say anything else, just respond directly with the instruction for the agent.\"\"\"\n",
    "\n",
    "\n",
    "def get_critique_prompt(naive_response: str):\n",
    "    return f\"\"\"Here is an instruction to an AI agent which acts as a Copy Editor:\n",
    "\n",
    "<instruction>\n",
    "{naive_response}\n",
    "</instruction>\n",
    "\n",
    "There may be some problems with this instruction. In particular, the instruction must abide by the following rules:\n",
    "\n",
    "<rules>\n",
    "{constitution_str}\n",
    "</rules>\n",
    "\n",
    "List each rule that the instruction breaks. State the rule verbatim, then describe how the instruction breaks the rule.\n",
    "\n",
    "For example, if the instruction breaks rule 1, you would write:\n",
    "\n",
    "The instruction breaks the following rules:\n",
    "1. Rule: {constitution_rules[0]} - Reason: ...\"\"\"\n",
    "\n",
    "\n",
    "def get_rewrite_prompt(naive_response: str, critique: str):\n",
    "    return f\"\"\"Here is an instruction to an AI agent which acts as a Copy Editor:\n",
    "\n",
    "<instruction>\n",
    "{naive_response}\n",
    "</instruction>\n",
    "\n",
    "The instruction is supposed to follow certain rules, but it breaks them as follows:\n",
    "\n",
    "<issues>\n",
    "{critique}\n",
    "</issues>\n",
    "\n",
    "Rewrite the instruction to address these issues. Respond directly with the rewritten instruction, do not say anything else and do not wrap your answer in <instruction> tags.\"\"\"\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate concepts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Here is a list of 5 tasks a Copy Editor might do, with the output of each task being edited text:\n",
      "\n",
      "1. Check for spelling, grammar, and punctuation errors and correct as needed.  \n",
      "\n",
      "2. Ensure consistent and logical flow and structure to the writing. Rearrange or rewrite sections as needed.  \n",
      "\n",
      "3. Verify facts and claims, especially if complex or controversial. Research as needed to confirm accuracy and add citations.  \n",
      "\n",
      "4. Ensure consistent style and tone that matches the publication's standards. Rewrite sections as needed for better flow and clarity.  \n",
      "\n",
      "5. Read through the entire text for overall coherence and impact. Provide feedback and suggestions for strengthening the writing.\n"
     ]
    }
   ],
   "source": [
    "concepts_string = get_llm_response(get_concepts_prompt(num_samples), model, 0.7)\n",
    "print(concepts_string)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got 5 concepts\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "\n",
    "def extract_items(text):\n",
    "    items = []\n",
    "    lines = text.split('\\n')\n",
    "    for line in lines:\n",
    "        stripped = line.strip()\n",
    "        if stripped and re.match(r'^\\d+\\.\\s', stripped):\n",
    "            items.append(re.sub(r'^\\d+\\.\\s', '', stripped))\n",
    "    return items\n",
    "\n",
    "\n",
    "concepts = extract_items(concepts_string)\n",
    "if len(concepts) != num_samples:\n",
    "    raise Exception(f\"Expected {num_samples} concepts, but got {len(concepts)}\")\n",
    "else:\n",
    "    print(f\"Got {len(concepts)} concepts\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate naive responses\n",
    "\n",
    "> **Terminology** - here we're prompting an LLM to generate prompts, which is confusing. We'll use the word \"prompt\" to refer to the initial input, and \"response\" to refer to the output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TASK:\n",
      "Check for spelling, grammar, and punctuation errors and correct as needed.\n",
      "\n",
      "NAIVE RESPONSE:\n",
      " Check the provided text for any spelling, grammar, or punctuation errors and make corrections as needed.\n",
      "\n",
      "\n",
      "===\n",
      "\n",
      "\n",
      "TASK:\n",
      "Ensure consistent and logical flow and structure to the writing. Rearrange or rewrite sections as needed.\n",
      "\n",
      "NAIVE RESPONSE:\n",
      " Rearrange and rewrite the text as needed to ensure consistent and logical flow and structure.\n",
      "\n",
      "\n",
      "===\n",
      "\n",
      "\n",
      "TASK:\n",
      "Verify facts and claims, especially if complex or controversial. Research as needed to confirm accuracy and add citations.\n",
      "\n",
      "NAIVE RESPONSE:\n",
      " Verify and cite sources for any facts or claims in the text that are complex or controversial.\n",
      "\n",
      "\n",
      "===\n",
      "\n",
      "\n",
      "TASK:\n",
      "Ensure consistent style and tone that matches the publication's standards. Rewrite sections as needed for better flow and clarity.\n",
      "\n",
      "NAIVE RESPONSE:\n",
      " Rewrite and edit the text to match the publication's style guide and improve flow and clarity.\n",
      "\n",
      "\n",
      "===\n",
      "\n",
      "\n",
      "TASK:\n",
      "Read through the entire text for overall coherence and impact. Provide feedback and suggestions for strengthening the writing.\n",
      "\n",
      "NAIVE RESPONSE:\n",
      " Review the text for coherence, flow, clarity, and impact. Provide written feedback with specific suggestions for improvement.\n"
     ]
    }
   ],
   "source": [
    "def get_naive_response(concept):\n",
    "    return get_llm_response(get_naive_response_prompt(concept), model, 0.3)\n",
    "\n",
    "\n",
    "# Concurrently (speeds up openai responses, not possible with anthropic)\n",
    "# with concurrent.futures.ThreadPoolExecutor() as executor:\n",
    "#     naive_responses = list(executor.map(lambda x: get_naive_response(\n",
    "#         x[0], x[1]), [(concept, i) for i, concept in enumerate(concepts)]))\n",
    "\n",
    "# Sequentially\n",
    "naive_responses = []\n",
    "for concept in concepts:\n",
    "    naive_responses.append(get_naive_response(concept))\n",
    "\n",
    "tasksResponsesString = \"\\n\\n\\n===\\n\\n\\n\".join(\n",
    "    [f\"TASK:\\n{task}\\n\\nNAIVE RESPONSE:\\n{response}\" for task, response in zip(concepts, naive_responses)])\n",
    "print(tasksResponsesString)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of these responses are slightly more detailed rewrites of the corresponding task. This is a good start, but ultimately not very useful and doesn't demonstrate most of the good practices in prompt design."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Critique"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's what an example prompt looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is an instruction to an AI agent which acts as a Copy Editor:\n",
      "\n",
      "<instruction>\n",
      " Check the provided text for any spelling, grammar, or punctuation errors and make corrections as needed.\n",
      "</instruction>\n",
      "\n",
      "There may be some problems with this instruction. In particular, the instruction must abide by the following rules:\n",
      "\n",
      "<rules>\n",
      "1. Instructions must explicitly describe the tone that the editor adpots.\n",
      "2. Instructions must explicitly state the number of words that editor's written response should be, and the number of words should be appropriate for the task.\n",
      "3. Instructions should explicitly reference the article content at the beginning, for example 'Here is an article:\n",
      "\n",
      "<article>ARTICLE_CONTENT</article>\n",
      "\n",
      "[Rest of instruction goes here]'.\n",
      "4. Instructions which involve multiple steps should be broken down into numbered subtasks.\n",
      "</rules>\n",
      "\n",
      "List each rule that the instruction breaks. State the rule verbatim, then describe how the instruction breaks the rule.\n",
      "\n",
      "For example, if the instruction breaks rule 1, you would write:\n",
      "\n",
      "The instruction breaks the following rules:\n",
      "1. Rule: Instructions must explicitly describe the tone that the editor adpots. - Reason: ...\n"
     ]
    }
   ],
   "source": [
    "print(get_critique_prompt(naive_responses[0]))\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's execute the critique prompt on each of the naive responses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NAIVE RESPONSE:\n",
      " Check the provided text for any spelling, grammar, or punctuation errors and make corrections as needed.\n",
      "\n",
      "CRITIQUE:\n",
      " The instruction breaks the following rules:\n",
      "\n",
      "1. Rule: Instructions must explicitly describe the tone that the editor adpots. \n",
      "- Reason: The instruction does not specify the tone the editor should adopt. It only specifies the tasks of checking for errors and making corrections.\n",
      "\n",
      "2. Rule: Instructions must explicitly state the number of words that editor's written response should be, and the number of words should be appropriate for the task.\n",
      "- Reason: The instruction does not specify a word count for the editor's response. \n",
      "\n",
      "3. Rule: Instructions should explicitly reference the article content at the beginning, for example 'Here is an article:  \n",
      "\n",
      "<article>ARTICLE_CONTENT</article>  \n",
      "\n",
      "[Rest of instruction goes here]'.\n",
      "- Reason: The instruction does not reference any article content. It only specifies the editing tasks in a general sense.\n",
      "\n",
      "4. Rule: Instructions which involve multiple steps should be broken down into numbered subtasks.  \n",
      "- Reason: The instruction involves multiple steps (checking for different types of errors, making corrections) but does not break these down into numbered subtasks.\n",
      "\n",
      "\n",
      "===\n",
      "\n",
      "\n",
      "NAIVE RESPONSE:\n",
      " Rearrange and rewrite the text as needed to ensure consistent and logical flow and structure.\n",
      "\n",
      "CRITIQUE:\n",
      " The instruction breaks the following rules:\n",
      "\n",
      "1. Rule: Instructions must explicitly describe the tone that the editor adpots. \n",
      "- Reason: The instruction does not specify the tone the editor should adopt. It only instructs the editor to rearrange and rewrite the text.\n",
      "\n",
      "2. Rule: Instructions must explicitly state the number of words that editor's written response should be, and the number of words should be appropriate for the task.\n",
      "- Reason: The instruction does not specify a word count for the editor's response.\n",
      "\n",
      "3. Rule: Instructions should explicitly reference the article content at the beginning, for example 'Here is an article:  \n",
      "\n",
      "<article>ARTICLE_CONTENT</article>  \n",
      "\n",
      "[Rest of instruction goes here]'.  \n",
      "- Reason: The instruction does not reference any article content. It only provides a broad instruction to rearrange and rewrite the text.\n",
      "\n",
      "4. Rule: Instructions which involve multiple steps should be broken down into numbered subtasks.\n",
      "- Reason: The instruction involves rearranging and rewriting the text, which are multiple steps, but does not break these down into numbered subtasks.\n",
      "\n",
      "\n",
      "===\n",
      "\n",
      "\n",
      "NAIVE RESPONSE:\n",
      " Verify and cite sources for any facts or claims in the text that are complex or controversial.\n",
      "\n",
      "CRITIQUE:\n",
      " The instruction breaks the following rules:\n",
      "\n",
      "1. Rule: Instructions must explicitly describe the tone that the editor adpots. \n",
      "- Reason: The instruction does not specify the tone the editor should adopt. It only specifies the task of verifying and citing sources.\n",
      "\n",
      "2. Rule: Instructions must explicitly state the number of words that editor's written response should be, and the number of words should be appropriate for the task.\n",
      "- Reason: The instruction does not specify a word count for the editor's response.\n",
      "\n",
      "3. Rule: Instructions should explicitly reference the article content at the beginning, for example 'Here is an article:  \n",
      "\n",
      "<article>ARTICLE_CONTENT</article>  \n",
      "\n",
      "[Rest of instruction goes here]'.\n",
      "- Reason: The instruction does not reference any article content. It only specifies the task in isolation.\n",
      "\n",
      "4. Rule: Instructions which involve multiple steps should be broken down into numbered subtasks.  \n",
      "- Reason: The instruction involves verifying facts and citing sources, which are two separate subtasks, but does not break them into numbered subtasks.\n",
      "\n",
      "\n",
      "===\n",
      "\n",
      "\n",
      "NAIVE RESPONSE:\n",
      " Rewrite and edit the text to match the publication's style guide and improve flow and clarity.\n",
      "\n",
      "CRITIQUE:\n",
      " The instruction breaks the following rules:\n",
      "\n",
      "1. Rule: Instructions must explicitly describe the tone that the editor adpots. \n",
      "- Reason: The instruction does not specify the tone the editor should adopt. It only says to rewrite and edit the text to match the style guide.\n",
      "\n",
      "2. Rule: Instructions must explicitly state the number of words that editor's written response should be, and the number of words should be appropriate for the task.\n",
      "- Reason: The instruction does not specify a word count for the editor's response.\n",
      "\n",
      "3. Rule: Instructions should explicitly reference the article content at the beginning, for example 'Here is an article:  \n",
      "\n",
      "<article>ARTICLE_CONTENT</article>  \n",
      "\n",
      "[Rest of instruction goes here]'.\n",
      "- Reason: The instruction does not reference any article content. It only provides a generic instruction to rewrite and edit the text.\n",
      "\n",
      "4. Rule: Instructions which involve multiple steps should be broken down into numbered subtasks.  \n",
      "- Reason: The instruction involves multiple steps (rewriting and editing the text) but does not break them into numbered subtasks.\n",
      "\n",
      "\n",
      "===\n",
      "\n",
      "\n",
      "NAIVE RESPONSE:\n",
      " Review the text for coherence, flow, clarity, and impact. Provide written feedback with specific suggestions for improvement.\n",
      "\n",
      "CRITIQUE:\n",
      " The instruction breaks the following rules:\n",
      "\n",
      "1. Rule: Instructions must explicitly describe the tone that the editor adpots. \n",
      "- Reason: The instruction does not specify the tone the editor should adopt. It only specifies the aspects to review (coherence, flow, clarity, impact) but not the tone.\n",
      "\n",
      "2. Rule: Instructions must explicitly state the number of words that editor's written response should be, and the number of words should be appropriate for the task.\n",
      "- Reason: The instruction does not specify the number of words the editor's response should be. It only says to provide \"written feedback with specific suggestions for improvement\" but does not give a word count.\n",
      "\n",
      "3. Rule: Instructions should explicitly reference the article content at the beginning, for example 'Here is an article:  \n",
      "\n",
      "<article>ARTICLE_CONTENT</article>  \n",
      "\n",
      "[Rest of instruction goes here]'.\n",
      "- Reason: The instruction does not reference any article content. It only provides a generic instruction to \"Review the text for coherence, flow, clarity, and impact.\"\n",
      "\n",
      "4. Rule: Instructions which involve multiple steps should be broken down into numbered subtasks.  \n",
      "- Reason: The instruction involves reviewing the text on multiple dimensions (coherence, flow, clarity, impact) but does not break this down into numbered subtasks.\n"
     ]
    }
   ],
   "source": [
    "def get_critique(naive_response):\n",
    "    return get_llm_response(get_critique_prompt(naive_response), model, 0)\n",
    "\n",
    "# Concurrently:\n",
    "# with concurrent.futures.ThreadPoolExecutor() as executor:\n",
    "#     critiques = list(executor.map(lambda x: get_critique(x[0], x[1]), [\n",
    "#                      (response, i) for i, response in enumerate(naive_responses)]))\n",
    "\n",
    "\n",
    "# Sequentially:\n",
    "critiques = []\n",
    "for naive_response in naive_responses:\n",
    "    critiques.append(get_critique(naive_response))\n",
    "\n",
    "responseCritiqueString = \"\\n\\n\\n===\\n\\n\\n\".join(\n",
    "    [f\"NAIVE RESPONSE:\\n{response}\\n\\nCRITIQUE:\\n{critique}\" for response, critique in zip(naive_responses, critiques)])\n",
    "print(responseCritiqueString)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rewrite"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's what an example rewrite prompt looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is an instruction to an AI agent which acts as a Copy Editor:\n",
      "\n",
      "<instruction>\n",
      " Check the provided text for any spelling, grammar, or punctuation errors and make corrections as needed.\n",
      "</instruction>\n",
      "\n",
      "The instruction is supposed to follow certain rules, but it breaks them as follows:\n",
      "\n",
      "<issues>\n",
      " The instruction breaks the following rules:\n",
      "\n",
      "1. Rule: Instructions must explicitly describe the tone that the editor adpots. \n",
      "- Reason: The instruction does not specify the tone the editor should adopt. It only specifies the tasks of checking for errors and making corrections.\n",
      "\n",
      "2. Rule: Instructions must explicitly state the number of words that editor's written response should be, and the number of words should be appropriate for the task.\n",
      "- Reason: The instruction does not specify a word count for the editor's response. \n",
      "\n",
      "3. Rule: Instructions should explicitly reference the article content at the beginning, for example 'Here is an article:  \n",
      "\n",
      "<article>ARTICLE_CONTENT</article>  \n",
      "\n",
      "[Rest of instruction goes here]'.\n",
      "- Reason: The instruction does not reference any article content. It only specifies the editing tasks in a general sense.\n",
      "\n",
      "4. Rule: Instructions which involve multiple steps should be broken down into numbered subtasks.  \n",
      "- Reason: The instruction involves multiple steps (checking for different types of errors, making corrections) but does not break these down into numbered subtasks.\n",
      "</issues>\n",
      "\n",
      "Rewrite the instruction to address these issues. Respond directly with the rewritten instruction, do not say anything else and do not wrap your answer in <instruction> tags.\n"
     ]
    }
   ],
   "source": [
    "print(get_rewrite_prompt(naive_responses[0], critiques[0]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NAIVE RESPONSE:\n",
      " Check the provided text for any spelling, grammar, or punctuation errors and make corrections as needed.\n",
      "\n",
      "REWRITE:\n",
      " Here is the rewritten instruction:\n",
      "\n",
      "1. Here is an article:  \n",
      "\n",
      "<article> \n",
      "The quik brown fox jumpd over the lazy dog. \n",
      "</article>\n",
      "\n",
      "2. Check the provided article for any spelling, grammar, or punctuation errors. Adopt a formal and instructive tone. \n",
      "\n",
      "3. Make any necessary corrections to the spelling, grammar, and punctuation in the article. Your response should be around 3 sentences (30-40 words).\n",
      "\n",
      "4. Ensure any corrections are made clearly and concisely, and the overall meaning and flow of the article is retained.\n",
      "\n",
      "\n",
      "===\n",
      "\n",
      "\n",
      "NAIVE RESPONSE:\n",
      " Rearrange and rewrite the text as needed to ensure consistent and logical flow and structure.\n",
      "\n",
      "REWRITE:\n",
      " Here is an article:  \n",
      "\n",
      "<article> \n",
      "The history of AI and its progress in the past few decades is truly remarkable. Since the coining of the term \"Artificial Intelligence\" in 1956, AI has advanced rapidly and become ubiquitous in our daily lives. From Siri and Alexa to self-driving cars, AI has the potential to greatly improve many areas of life and society. However, it also brings many risks and challenges that researchers and policymakers must consider seriously and address proactively. Overall, AI is an incredibly promising yet complex field that deserves our optimism as well as our vigilance.\n",
      "</article>\n",
      "\n",
      "In a neutral and objective tone, rewrite and restructure the article in approximately 250 words while following the steps below:\n",
      "\n",
      "1. Rearrange the sentences and paragraphs in a logical flow and structure. Connect sentences and ideas cohesively.\n",
      "\n",
      "2. Combine sentences where needed and split long sentences when necessary. Vary sentence structure.\n",
      "\n",
      "3. Use transition words and phrases to link sentences and paragraphs.\n",
      "\n",
      "4. Tighten wording and remove unnecessary words and phrases.\n",
      "\n",
      "5. Ensure consistent style and tone.\n",
      "\n",
      "\n",
      "===\n",
      "\n",
      "\n",
      "NAIVE RESPONSE:\n",
      " Verify and cite sources for any facts or claims in the text that are complex or controversial.\n",
      "\n",
      "REWRITE:\n",
      " Here is an edited instruction for the AI Copy Editor:\n",
      "\n",
      "1. Adopt an objective and impartial tone in your edits and responses.  \n",
      "\n",
      "2. In no more than 250 words,  \n",
      "\n",
      "3. Here is an article:  \n",
      "\n",
      "<article>ARTICLE_CONTENT</article>   \n",
      "\n",
      "4. Verify any facts or claims in the article that are complex or controversial.\n",
      "5. Cite reputable sources for any verified facts or claims.\n",
      "\n",
      "\n",
      "===\n",
      "\n",
      "\n",
      "NAIVE RESPONSE:\n",
      " Rewrite and edit the text to match the publication's style guide and improve flow and clarity.\n",
      "\n",
      "REWRITE:\n",
      " Here is a rewritten instruction for the Copy Editor:\n",
      "\n",
      "Rewrite the following article in a formal tone to exactly 500 words to match the publication's style guide and improve flow and clarity:\n",
      "\n",
      "<article> \n",
      "ARTICLE_CONTENT \n",
      "</article>\n",
      "\n",
      "1. Read through the entire article and identify any areas that can be improved for clarity, flow, and style.\n",
      "2. Rewrite sentences as needed to adopt a formal tone and match the publication's style guide. \n",
      "3. Edit the article to be exactly 500 words by condensing content or splitting up long sentences and paragraphs as needed. \n",
      "4. Proofread thoroughly to ensure there are no spelling, grammar or punctuation errors.\n",
      "\n",
      "\n",
      "===\n",
      "\n",
      "\n",
      "NAIVE RESPONSE:\n",
      " Review the text for coherence, flow, clarity, and impact. Provide written feedback with specific suggestions for improvement.\n",
      "\n",
      "REWRITE:\n",
      " Here is the rewritten instruction:\n",
      "\n",
      "Review the following article and provide written feedback (around 250 words) in an objective and constructive tone:  \n",
      "\n",
      "<article> \n",
      "[ARTICLE CONTENT HERE]\n",
      "</article>\n",
      "\n",
      "1. Review the coherence and logical flow of ideas in the article. Provide specific suggestions for improving coherence and flow.  \n",
      "\n",
      "2. Review the clarity of language and arguments in the article. Provide specific suggestions for improving clarity.  \n",
      "\n",
      "3. Review the impact and effectiveness of the article. Provide specific suggestions for strengthening the impact.  \n",
      "\n",
      "4. Review the article for any additional issues with grammar, punctuation or spelling. Provide corrections as needed.\n"
     ]
    }
   ],
   "source": [
    "def get_rewrite(naive_response, critique):\n",
    "    return get_llm_response(get_rewrite_prompt(naive_response, critique), model, 0.5)\n",
    "\n",
    "# Concurrently:\n",
    "# with concurrent.futures.ThreadPoolExecutor() as executor:\n",
    "#     rewrites = list(executor.map(lambda x: get_rewrite(x[0], x[1], x[2]), [\n",
    "#         (response, critique, i) for i, (response, critique) in enumerate(zip(naive_responses, critiques))]))\n",
    "\n",
    "\n",
    "# Sequentially:\n",
    "rewrites = []\n",
    "for i, (naive_response, critique) in enumerate(zip(naive_responses, critiques)):\n",
    "    rewrites.append(get_rewrite(naive_response, critique))\n",
    "\n",
    "rewriteString = \"\\n\\n\\n===\\n\\n\\n\".join(\n",
    "    [f\"NAIVE RESPONSE:\\n{response}\\n\\nREWRITE:\\n{rewrite}\" for response, rewrite in zip(naive_responses, rewrites)])\n",
    "print(rewriteString)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}