copycat_demo.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kRPNTO24VHCE"
      },
      "source": [
        "*Copyright 2024 Google LLC.*\n",
        "\n",
        "*Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "you may not use this file except in compliance with the License.\n",
        "You may obtain a copy of the License at*\n",
        "\n",
        "     http://www.apache.org/licenses/LICENSE-2.0\n",
        "\n",
        "*Unless required by applicable law or agreed to in writing, software\n",
        "distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "See the License for the specific language governing permissions and\n",
        "limitations under the License.*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uzwEzrYm03Ka"
      },
      "source": [
        "![unnamed.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1C7E2skW03Ka"
      },
      "source": [
        "# Copycat Python Demo\n",
        "\n",
        "[![Open in Colab](https://img.shields.io/badge/Open_in_Colab-blue?style=flat\u0026logo=google%20colab\u0026labelColor=grey)](https://colab.research.google.com/github/google-marketing-solutions/copycat/blob/main/copycat_demo.ipynb)  \n",
        "[![Open in Github](https://img.shields.io/badge/Open_in_Github-blue?style=flat\u0026logo=Github\u0026labelColor=grey)](https://github.com/google-marketing-solutions/copycat/blob/main/copycat_demo.ipynb)  \n",
        "\n",
        "This is a demo of the copycat AI using python directly. This is useful if you are looking for examples of how to integrate copycat with other solutions, or you want to do something that is not supported by the UI. **Otherwise, we recommend you try the UI first.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "upM0kbGG03Ka"
      },
      "outputs": [],
      "source": [
        "# @title Install Copycat\n",
        "%pip install --quiet gtech-copycat[google_sheets]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hGm2-PvkzSKh"
      },
      "outputs": [],
      "source": [
        "# @title Import Packages\n",
        "\n",
        "import copycat\n",
        "from copycat.data import sheets\n",
        "from copycat.data import utils\n",
        "\n",
        "import nest_asyncio\n",
        "nest_asyncio.apply()\n",
        "\n",
        "from IPython.display import display, Markdown\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GAs4PTXeUh0x"
      },
      "outputs": [],
      "source": [
        "# @title Authenticate with Google Drive\n",
        "from google.colab import auth\n",
        "from google.auth import default\n",
        "import vertexai\n",
        "\n",
        "auth.authenticate_user()\n",
        "creds, _ = default()\n",
        "project_id = input(\"Enter your google cloud project ID.\").strip()\n",
        "project_location = input(\"Enter your google cloud project location, for example: us-central1.\").strip()\n",
        "vertexai.init(project=project_id, location=project_location)\n",
        "\n",
        "sheets.set_google_auth_credentials(creds)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aieO2rTOBY8h"
      },
      "source": [
        "# Load data from google sheets\n",
        "\n",
        "In this example I am going to create some synthetic demo data in a google sheet, and then load it in. You can replace this with your own method to load your own data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zUBtxXHi03Ka"
      },
      "source": [
        "## Create Demo Data in Google Sheets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jsPcxJh_03Ka"
      },
      "outputs": [],
      "source": [
        "demo_data_url = sheets.create_template_copycat_sheet()\n",
        "print(f\"Demo data created in Google Sheets. URL: {demo_data_url}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ubfVCFJS03Ka"
      },
      "source": [
        "## Load data into Colab"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "95bGoA3Z03Ka"
      },
      "outputs": [],
      "source": [
        "sheet = sheets.GoogleSheet.load(demo_data_url)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eg6-pM8G03Ka"
      },
      "source": [
        "The training ads (below) contain the high quality existing ads for Copycat to learn from. There is one row per ad."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_KuN3ge1VnOy"
      },
      "outputs": [],
      "source": [
        "training_ads_data = sheet[\"Training Ads\"]\n",
        "training_ads_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "637ELX0a03Ka"
      },
      "source": [
        "The new keywords (below) contain the new keywords that Copycat will generate ads for. These should be a single keyword per row."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EqtSD4ZUV9S6"
      },
      "outputs": [],
      "source": [
        "new_keywords_data = sheet[\"New Keywords\"]\n",
        "new_keywords_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Uo_oepw03Ka"
      },
      "source": [
        "The additional instructions data contain (optional) additional instructions to use when generating ads."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FtPTz7co03Ka"
      },
      "outputs": [],
      "source": [
        "additional_instructions_data = sheet[\"Extra Instructions for New Ads\"]\n",
        "# We need to do an extra step here to cast the version to a string instead of an integer\n",
        "# because pandas assumes it an integer but Copycat wants a string.\n",
        "additional_instructions_data.index = (\n",
        "    additional_instructions_data.index.set_levels(\n",
        "        additional_instructions_data.index.get_level_values(\"Version\").astype(\n",
        "            str\n",
        "        ),\n",
        "        level=\"Version\",\n",
        "        verify_integrity=False,\n",
        "    )\n",
        ")\n",
        "additional_instructions_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kNgUDDsIFXD7"
      },
      "source": [
        "Lastly I'll set a few parameters which we will re-use throughout this notebook for generating ads."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vIwxoK-oFaEO"
      },
      "outputs": [],
      "source": [
        "COMPANY_NAME = \"Furniture Land\"\n",
        "AD_FORMAT = copycat.google_ads.get_google_ad_format(\"responsive_search_ad\")\n",
        "LANGUAGE = \"english\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rtsvr0NKzEpW"
      },
      "source": [
        "# Create Copycat Instance\n",
        "\n",
        "The copycat instance is created from the existing ads. It will select a subset of the existing ads to be \"Exemplar Ads\", which it will then use when generating the style guide and generating new ads. There are two methods available for doing this, Affinity Propogation and Random. Affinity Propogation is best unless you have a very small number of exising ads (20 or fewer), in which case Random is better because it will just keep all of your ads as exemplar ads."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DxTRgHNrzaZ_"
      },
      "outputs": [],
      "source": [
        "# First construct the training data in the correct format. It must have three columns:\n",
        "\n",
        "# keywords: a comma separated string containing all the keywords for the ad\n",
        "# headlines: a list of strings, where each element of the list is a headline\n",
        "# descriptions: a list of strings, where each element of the list is a description\n",
        "\n",
        "prepared_training_ads = utils.collapse_headlines_and_descriptions(\n",
        "    training_ads_data\n",
        ").rename(columns={\"Keywords\": \"keywords\"})[[\"keywords\", \"headlines\", \"descriptions\"]]\n",
        "\n",
        "# Now create the copycat instance.\n",
        "\n",
        "copycat_instance = copycat.Copycat.create_from_pandas(\n",
        "    training_data=prepared_training_ads,\n",
        "    embedding_model_name=copycat.EmbeddingModelName.TEXT_EMBEDDING,\n",
        "    ad_format=AD_FORMAT,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jVnMYTjK1pNR"
      },
      "source": [
        "# Generate Style Guide\n",
        "\n",
        "Now we can generate the style guide. By default, Copycat will use the exemplar ads for this, and the style guide will be based on what Copycat can learn by analyzing the exemplar ads.\n",
        "\n",
        "If you have additional documentation available, for example brand style guidelines, then you can include those too by uploading them to a Google Cloud Storage Bucket and then providing the bucket URI in the `files_uri` argument. If you only want Copycat to look a the brand style guidelines and not at the existing ads, you can set `use_exemplar_ads=False`. You can also provide any additional instructions for generating the style guide via text with the `additional_style_instructions` argument.\n",
        "\n",
        "Note: Generating the style guide is optional, you can use Copycat without a style guide and it will just learn the style by including in context examples from the exemplar ads at generation time. However we strongly recommend using a Style guide as it gives more control over the results, since you can review and edit the style guide as you see fit."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "woR5ufY22kYL"
      },
      "outputs": [],
      "source": [
        "copycat_instance.generate_style_guide(company_name=COMPANY_NAME)\n",
        "\n",
        "display(Markdown(copycat_instance.style_guide))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LWq-E3Ml03Ka"
      },
      "source": [
        "# Prepare data for generation\n",
        "\n",
        "Now I'm going to combine the addditonal instructions and new keywords into a new ads dataset, which is the dataset that contains all the information required for generating new ads. This will be set up to generate 2 versions of every ad group.\n",
        "\n",
        "Note, this can incorporate existing headlines and descriptions too, via the `existing_generations_data` argument. This is useful if you already have some existing headlines and descriptions for these ads, and you just want Copycat to add to them. However, in this case we are going to generate the ads from scratch, so the existing headlines and existing descriptions will automatically be filled with empty lists.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hJppDnXj03Ka"
      },
      "outputs": [],
      "source": [
        "new_ads_data = utils.construct_generation_data(\n",
        "    new_keywords_data=new_keywords_data,\n",
        "    additional_instructions_data=additional_instructions_data,\n",
        "    keyword_column=\"Keyword\",\n",
        "    additional_instructions_column=\"Extra Instructions\",\n",
        "    version_column=\"Version\",\n",
        "    n_versions=2,\n",
        ")\n",
        "new_ads_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-0EOaS1X3vKn"
      },
      "source": [
        "# Generate New Ads\n",
        "\n",
        "## Inspect the prompt\n",
        "\n",
        "Before generating a new ad, it's a good idea to inspect the prompt and other parameters that are going to be used."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2oAo2HfI3xB-"
      },
      "outputs": [],
      "source": [
        "example_request = copycat_instance.construct_text_generation_requests_for_new_ad_copy(\n",
        "    keywords=[new_ads_data[\"keywords\"].values[0]],\n",
        "    keywords_specific_instructions=[new_ads_data[\"keywords\"].values[0]],\n",
        "    system_instruction_kwargs=dict(\n",
        "        company_name=COMPANY_NAME,\n",
        "        language=LANGUAGE,\n",
        "    )\n",
        ")[0]\n",
        "\n",
        "display(Markdown(example_request.to_markdown()))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W1atfHfw4_cH"
      },
      "source": [
        "## Generate a single ad\n",
        "\n",
        "Now it's good to test that everything looks good for a single generation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lgYOT7824-xX"
      },
      "outputs": [],
      "source": [
        "example_response = copycat_instance.generate_new_ad_copy(\n",
        "    keywords=[new_ads_data[\"keywords\"].values[0]],\n",
        "    keywords_specific_instructions=[new_ads_data[\"keywords\"].values[0]],\n",
        "    system_instruction_kwargs=dict(\n",
        "        company_name=COMPANY_NAME,\n",
        "        language=LANGUAGE,\n",
        "    )\n",
        ")[0]\n",
        "\n",
        "print(example_response.model_dump_json(indent=2))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0iNbR73iqtG1"
      },
      "source": [
        "## Generate all the ads in batches\n",
        "\n",
        "This will iterate over batches of the dataframe and generate ads for each batch. You can also apply a limit with the limit argument, but here we only have a small number of generations so we wont use it.\n",
        "\n",
        "Usually a batch size of around 15 is good. Higher batch sizes will mean faster generation, but might hit Google Cloud quota's. For this example I'll use a batch size of 3 just to show the batches working."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VDHJAMIKqset"
      },
      "outputs": [],
      "source": [
        "new_ads_with_generations_data = new_ads_data.copy()\n",
        "new_ads_with_generations_data[\"generated_ad_object\"]= None\n",
        "for batch_number, generation_batch in enumerate(utils.iterate_over_batches(new_ads_data, batch_size=3, limit_rows=100)):\n",
        "  print(f\"Batch Number {batch_number+1}\")\n",
        "  new_ads = copycat_instance.generate_new_ad_copy_for_dataframe(\n",
        "      data=generation_batch,\n",
        "      keywords_specific_instructions_column=\"additional_instructions\",\n",
        "      system_instruction_kwargs=dict(\n",
        "          company_name=COMPANY_NAME,\n",
        "          language=LANGUAGE,\n",
        "      )\n",
        "  )\n",
        "  new_ads_with_generations_data.loc[new_ads.index, \"generated_ad_object\"] = new_ads\n",
        "\n",
        "new_ads_with_generations_data = (\n",
        "    new_ads_with_generations_data\n",
        "    .pipe(utils.explode_generated_ad_object)\n",
        "    .pipe(utils.explode_headlines_and_descriptions)\n",
        "    .drop(columns=[\"existing_headlines\", \"existing_descriptions\", \"generated_ad_object\"])\n",
        ")\n",
        "new_ads_with_generations_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zvzfMmkl1bqb"
      },
      "source": [
        "# Saving and Loading\n",
        "\n",
        "## Save and load the copycat instance\n",
        "\n",
        "You can serialize the copycat instance to and from json if you want to save it and re-use it later."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Zkmwnl3H1eZi"
      },
      "outputs": [],
      "source": [
        "copycat_as_json = copycat_instance.to_json()\n",
        "copycat_instance = copycat.Copycat.from_json(copycat_as_json)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WBjnoqJAtkFH"
      },
      "source": [
        "## Store generated ads in google sheet\n",
        "\n",
        "You can use the sheets module to save the generated ads to the google sheet."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UValE8FRtjNM"
      },
      "outputs": [],
      "source": [
        "sheet[\"Generated Ads\"] = new_ads_with_generations_data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T8Lak36tt07m"
      },
      "outputs": [],
      "source": [
        "print(sheet)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TihHVB7y0FGh"
      },
      "source": [
        "# Advanced Topics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EV4fiOsk0G5f"
      },
      "source": [
        "## Organising keywords into ad groups\n",
        "\n",
        "If you have a set of new keywords that are not yet structured into ad groups, you can use copycat to create ad groups for you.\n",
        "\n",
        "Copycat does this by learning from the existing ad groups in the training data, to see how similar two keywords should be to each other to be in the same group."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "w4kgZmCG0GKZ"
      },
      "outputs": [],
      "source": [
        "new_keywords_with_new_ad_groups = new_keywords_data.copy()\n",
        "new_keywords_with_new_ad_groups[\"embedding\"] = copycat_instance.ad_copy_vectorstore.embed_queries(new_keywords_with_new_ad_groups[\"Keyword\"].values.tolist())\n",
        "new_keywords_with_new_ad_groups.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7DLlKuYK0dnH"
      },
      "outputs": [],
      "source": [
        "existing_keywords_exploded = training_ads_data[[\"Keywords\"]].copy().reset_index(drop=True)\n",
        "existing_keywords_exploded[\"Keywords\"] = existing_keywords_exploded[\"Keywords\"].apply(lambda x: list(map(lambda x: x.strip(), x.split(\",\"))))\n",
        "existing_keywords_exploded = existing_keywords_exploded.explode(\"Keywords\").reset_index(names=\"Ad Group Index\")\n",
        "existing_keywords_exploded[\"embedding\"] = copycat_instance.ad_copy_vectorstore.embed_queries(existing_keywords_exploded[\"Keywords\"].values.tolist())\n",
        "\n",
        "existing_keywords_exploded.head(10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "N7IPdFbL0rRr"
      },
      "outputs": [],
      "source": [
        "clusterer = copycat.BirchAgglomerativeKeywordClusterer(birch_scale=0)\n",
        "clusterer.fit(\n",
        "    np.array(existing_keywords_exploded[\"embedding\"].values.tolist()),\n",
        "    existing_keywords_exploded[\"Ad Group Index\"].values,\n",
        ")\n",
        "new_keywords_with_new_ad_groups[\"Suggested Ad Groups\"] = clusterer.predict(np.array(new_keywords_with_new_ad_groups[\"embedding\"].values.tolist()))\n",
        "\n",
        "new_keywords_with_new_ad_groups"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "last_runtime": {
        "build_target": "//third_party/professional_services/solutions/copycat:colab",
        "kind": "private"
      },
      "private_outputs": true,
      "provenance": [
        {
          "file_id": "1D5VIaYdoTPPNDVeTyNBaohVxmi3a4ogc",
          "timestamp": 1716289128687
        }
      ]
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}