RAG_summarizing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b8df114e",
   "metadata": {},
   "outputs": [],
   "source": [
    "PROJECT_ID = \"refsides\"\n",
    "REGION = \"us-central1\"\n",
    "ACCESS_TOKEN='ya29.a0Ad52N38wju22GOuDprnLu9IkW87bjgrSft2ml1sXfk68p29ttl8r4IPk_x46NsAG5E8GPx0hLkRigWNmI-ybN-8fGAgMqfnXeOVV-VRZdz5zMe66fl4isRuw7VOcM-HMO_Nq_yZPE6WPOMQ-xWRLdAz9X5YVOt4je5F3KAfrBAaCgYKASwSARMSFQHGX2MioE-hpcWsIo7RwArOcd3MXg0177'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fff55da5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import polars as pl\n",
    "import json\n",
    "import pandas as pd\n",
    "import concurrent\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "\n",
    "# import\n",
    "from langchain_community.document_loaders import DirectoryLoader\n",
    "from langchain_community.embeddings.sentence_transformer import (\n",
    "    SentenceTransformerEmbeddings\n",
    ")\n",
    "from langchain_community.embeddings import OpenAIEmbeddings\n",
    "from langchain_community.vectorstores import Chroma\n",
    "from langchain_text_splitters import CharacterTextSplitter\n",
    "from openai import OpenAI, AzureOpenAI\n",
    "from langchain.chat_models import ChatOpenAI\n",
    "from langchain.schema.runnable import RunnablePassthrough\n",
    "from langchain.schema.output_parser import StrOutputParser\n",
    "from typing import List, Optional\n",
    "\n",
    "from vertexai.language_models import TextEmbeddingInput, TextEmbeddingModel\n",
    "from google.cloud import aiplatform"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c2cf6d1",
   "metadata": {},
   "source": [
    "## Set Up RAG and OpenAI connection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ea442d55",
   "metadata": {},
   "outputs": [],
   "source": [
    "config = json.load(open('./config.json'))\n",
    "\n",
    "organization = \"\"\n",
    "\n",
    "api_source = 'OpenAI'\n",
    "\n",
    "api_key = config[api_source]['openai_api_key'] #constants.AZURE_OPENAI_KEY\n",
    "api_endpoint = config[api_source]['openai_api_endpoint']  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6e212f51",
   "metadata": {},
   "outputs": [],
   "source": [
    "## saving embeddings\n",
    "# text_splitter = CharacterTextSplitter()\n",
    "# chunks = text_splitter.split_documents(documents)\n",
    "# db = Chroma.from_documents(chunks, OpenAIEmbeddings(openai_api_key=api_key), persist_directory=\"../Chroma\")\n",
    "# db.persist()\n",
    "\n",
    "## loading them\n",
    "db = Chroma(persist_directory=\"../Chroma\", embedding_function=OpenAIEmbeddings(openai_api_key=api_key))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b981ebc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "retriever = db.as_retriever()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "cc25bc34",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The association between Lisinopril, an angiotensin-converting enzyme (ACE) inhibitor, and acute kidney injury (AKI) is a recognized clinical concern, supported by both mechanistic insights and epidemiological data.\\n\\nMechanistically, Lisinopril reduces the production of angiotensin II, a potent vasoconstrictor, leading to dilation of the efferent arterioles in the kidneys. While this can be beneficial in lowering blood pressure and decreasing proteinuria, it can also reduce the glomerular filtration rate (GFR). In certain circumstances, such as in patients with pre-existing renal impairment, renal artery stenosis, or volume depletion, the reduction in GFR can be significant enough to cause AKI.\\n\\nEpidemiological evidence for the association comes from observational studies, case reports, and clinical trials. These studies have documented instances of AKI in patients taking Lisinopril, particularly in high-risk groups such as the elderly, those with pre-existing kidney disease, congestive heart failure, or dehydration. The risk of AKI is often dose-dependent and may be exacerbated by the concurrent use of other nephrotoxic drugs or diuretics.\\n\\nClinical guidelines recommend monitoring renal function when initiating or increasing the dose of Lisinopril, especially in high-risk populations. If AKI is suspected or confirmed, the standard approach is to discontinue Lisinopril and manage the AKI according to established protocols, which may include hydration and addressing any underlying reversible causes.\\n\\nIn summary, there is a well-established causal association between Lisinopril use and the development of acute kidney injury, particularly in susceptible individuals or those with predisposing conditions. Careful patient selection, dose titration, and monitoring of renal function are critical to minimize the risk of AKI in patients prescribed Lisinopril.'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# no context\n",
    "client = OpenAI(api_key=api_key)\n",
    "chat_completion = client.chat.completions.create(\n",
    "    messages=[\n",
    "        {\"role\": \"system\", \"content\": \"\"\"As a professional summarizer, create a concise and comprehensive summary\n",
    "        of the known knowledge for the causal assocation between a drug and an adverse event. \n",
    "        Craft a summary that is detailed, thorough, in-depth, and complex, while maintaining clarity and \n",
    "        conciseness.\n",
    "        Incorporate the additional context provided, main ideas and essential information, \n",
    "        eliminating extraneous language and focusing on critical aspects.\"\"\"},\n",
    "        {\n",
    "            \"role\": \"user\",\n",
    "            \"content\": \"\"\"\n",
    "            Summarize the evidence, if any, for the association between the use of Lisinopril and Acute Kidney Injury?\"\"\"\n",
    "        }\n",
    "    ],\n",
    "    model='gpt-4-1106-preview',\n",
    "    temperature=0,\n",
    ")\n",
    "term = chat_completion.choices[0].message.content\n",
    "term"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e549ff0",
   "metadata": {},
   "source": [
    "## Get summary including additional informatoin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c3accf85",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input_variables=['context', 'question'] messages=[HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['context', 'question'], template=\"\\nYou are an expert in summarizing current information. Create a concise and comprehensive summary\\nof the known knowledge for the causal assocation between a drug and an adverse event. \\nCraft a summary that is detailed, thorough, in-depth, and complex, while maintaining clarity and \\nconciseness. Incorporate the retrieved context, and previous medical literature.\\nIf you don't know the answer just say I don't know.\\nKeep your summarize to less than 3 sentences.\\nQuestion: {question} \\nContext: {context} \\nAnswer:\\n\"))]\n"
     ]
    }
   ],
   "source": [
    "from langchain.prompts import ChatPromptTemplate\n",
    "\n",
    "template = \"\"\"\n",
    "You are an expert in summarizing current information. Create a concise and comprehensive summary\n",
    "of the known knowledge for the causal assocation between a drug and an adverse event. \n",
    "Craft a summary that is detailed, thorough, in-depth, and complex, while maintaining clarity and \n",
    "conciseness. Incorporate the retrieved context, and previous medical literature.\n",
    "If you don't know the answer just say I don't know.\n",
    "Keep your summarize to less than 3 sentences.\n",
    "Question: {question} \n",
    "Context: {context} \n",
    "Answer:\n",
    "\"\"\"\n",
    "prompt = ChatPromptTemplate.from_template(template)\n",
    "\n",
    "print(prompt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b8cfdc18",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/uog2000/miniconda3/envs/llm_cpus/lib/python3.11/site-packages/langchain_core/_api/deprecation.py:119: LangChainDeprecationWarning: The class `ChatOpenAI` was deprecated in LangChain 0.0.10 and will be removed in 0.3.0. An updated version of the class exists in the langchain-openai package and should be used instead. To use it run `pip install -U langchain-openai` and import as `from langchain_openai import ChatOpenAI`.\n",
      "  warn_deprecated(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Evidence suggests that lisinopril, an ACE inhibitor, can cause acute kidney injury, particularly in patients with risk factors such as heart failure with low systolic blood pressure, ischemic heart disease, cerebrovascular disease, high dose diuretic therapy, renal dialysis, or severe volume depletion. This association is supported by observations of symptomatic hypotension leading to oliguria, progressive azotemia, and increased serum creatinine levels, which are sometimes reversible upon discontinuation of the drug.'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "llm = ChatOpenAI(api_key=api_key, model_name=\"gpt-4-1106-preview\", temperature=0)\n",
    "\n",
    "rag_chain = (\n",
    "    {\"context\": retriever,  \"question\": RunnablePassthrough()} \n",
    "    | prompt \n",
    "    | llm\n",
    "    | StrOutputParser() \n",
    ")\n",
    "\n",
    "query = \"What is the evidence, if any, supporting the causal association between lisinopril and acute kidney injury?\"\n",
    "rag_chain.invoke(query)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "d088221a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'There is no direct evidence provided in the provided documents linking adenosine to acute kidney injury. The adverse reactions listed for adenosine in controlled U.S. clinical trials and post-marketing experience primarily involve cardiovascular, respiratory, central nervous system, and gastrointestinal effects, with no mention of renal or kidney-related adverse events. Therefore, based on the available information, a causal association between adenosine and acute kidney injury cannot be established.'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query = \"What is the evidence, if any, supporting the causal association between adenosine and acute kidney injury?\"\n",
    "rag_chain.invoke(query)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80b68bf8",
   "metadata": {},
   "source": [
    "## Apply to drugs in reference set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "fba7f66a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['cohort_id', 'condition_name', 'drug_concept_id', 'drug_name', 'affect',\n",
       "       'set_id', 'label_id', 'spl_version', 'title', 'sections'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reference_set = pd.read_csv('reference_set_labels.csv')\n",
    "reference_set.columns"
   ]
  },
  {
   "cell_type": "raw",
   "id": "0f336be8",
   "metadata": {},
   "source": [
    "summary_evidence = list()\n",
    "for i, row in reference_set[['condition_name', 'drug_name', 'affect']].drop_duplicates().iterrows():\n",
    "    query = f\"\"\"What is the evidence, if any, supporting the causal association between \n",
    "    {row.drug_name} and {row.condition_name}?\"\"\"\n",
    "    summary = rag_chain.invoke(query)\n",
    "    summary_evidence.append([row.condition_name, row.drug_name, row.affect, summary])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "617f8820",
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_iteration(row):\n",
    "    try:\n",
    "        query = f\"\"\"What is the evidence, if any, supporting the causal association between \n",
    "        {row.drug_name} and {row.condition_name}?\"\"\"\n",
    "        summary = rag_chain.invoke(query)\n",
    "        return [row.condition_name, row.drug_name, row.affect, summary]\n",
    "    except Exception as err:\n",
    "        print(f\"Encountered an exception for row: {row.drug_name} {row.condition_name}. Error message below:\")\n",
    "        print(err)\n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a0ada56",
   "metadata": {},
   "outputs": [],
   "source": [
    "rows_to_run = [row for _,row in reference_set[['condition_name', 'drug_name', 'affect']].drop_duplicates().iterrows()]\n",
    "results = list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "78b21ac4",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████| 344/344 [03:30<00:00,  1.63it/s]\n"
     ]
    }
   ],
   "source": [
    "with concurrent.futures.ThreadPoolExecutor(max_workers=10) as exec:\n",
    "    results.extend(list(tqdm(\n",
    "        exec.map(run_iteration, rows_to_run), \n",
    "        total=len(rows_to_run)\n",
    "    )))\n",
    "\n",
    "summary_evidence = pd.DataFrame(\n",
    "    [r for r in results if r is not None],\n",
    "    columns=['condition_name', 'drug_name', 'affect', 'summary']\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "7d0bddb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>condition_name</th>\n",
       "      <th>drug_name</th>\n",
       "      <th>affect</th>\n",
       "      <th>summary</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>lamotrigine</td>\n",
       "      <td>1</td>\n",
       "      <td>The provided documents do not contain direct e...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>nefazodone</td>\n",
       "      <td>1</td>\n",
       "      <td>Evidence suggests a causal association between...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>tolcapone</td>\n",
       "      <td>1</td>\n",
       "      <td>The evidence supporting the causal association...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Neostigmine</td>\n",
       "      <td>0</td>\n",
       "      <td>Current evidence does not directly link neosti...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Nortriptyline</td>\n",
       "      <td>1</td>\n",
       "      <td>I don't know.</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Interferon beta-1a</td>\n",
       "      <td>1</td>\n",
       "      <td>Evidence from postmarketing reports indicates ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Phentermine</td>\n",
       "      <td>0</td>\n",
       "      <td>I don't know.</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Disulfiram</td>\n",
       "      <td>1</td>\n",
       "      <td>I don't know.</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Droperidol</td>\n",
       "      <td>0</td>\n",
       "      <td>The provided documents do not contain direct e...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Carbamazepine</td>\n",
       "      <td>1</td>\n",
       "      <td>Carbamazepine has been associated with hepatic...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>orlistat</td>\n",
       "      <td>1</td>\n",
       "      <td>There have been rare postmarketing reports of ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Valproate</td>\n",
       "      <td>1</td>\n",
       "      <td>Valproate has been associated with acute liver...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Primidone</td>\n",
       "      <td>0</td>\n",
       "      <td>I don't know.</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>lithium citrate</td>\n",
       "      <td>0</td>\n",
       "      <td>I don't know.</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>felbamate</td>\n",
       "      <td>1</td>\n",
       "      <td>The evidence suggests a strong causal associat...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Clozapine</td>\n",
       "      <td>1</td>\n",
       "      <td>Clozapine has been associated with eosinophili...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Methenamine</td>\n",
       "      <td>0</td>\n",
       "      <td>There is limited evidence suggesting a potenti...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Miconazole</td>\n",
       "      <td>0</td>\n",
       "      <td>The provided documents do not contain direct e...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>oxybutynin</td>\n",
       "      <td>0</td>\n",
       "      <td>There is no direct information provided in the...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Nitrofurantoin</td>\n",
       "      <td>1</td>\n",
       "      <td>Nitrofurantoin has been associated with rare o...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        condition_name           drug_name  affect  \\\n",
       "0   Acute liver injury         lamotrigine       1   \n",
       "1   Acute liver injury          nefazodone       1   \n",
       "2   Acute liver injury           tolcapone       1   \n",
       "3   Acute liver injury         Neostigmine       0   \n",
       "4   Acute liver injury       Nortriptyline       1   \n",
       "5   Acute liver injury  Interferon beta-1a       1   \n",
       "6   Acute liver injury         Phentermine       0   \n",
       "7   Acute liver injury          Disulfiram       1   \n",
       "8   Acute liver injury          Droperidol       0   \n",
       "9   Acute liver injury       Carbamazepine       1   \n",
       "10  Acute liver injury            orlistat       1   \n",
       "11  Acute liver injury           Valproate       1   \n",
       "12  Acute liver injury           Primidone       0   \n",
       "13  Acute liver injury     lithium citrate       0   \n",
       "14  Acute liver injury           felbamate       1   \n",
       "15  Acute liver injury           Clozapine       1   \n",
       "16  Acute liver injury         Methenamine       0   \n",
       "17  Acute liver injury          Miconazole       0   \n",
       "18  Acute liver injury          oxybutynin       0   \n",
       "19  Acute liver injury      Nitrofurantoin       1   \n",
       "\n",
       "                                              summary  \n",
       "0   The provided documents do not contain direct e...  \n",
       "1   Evidence suggests a causal association between...  \n",
       "2   The evidence supporting the causal association...  \n",
       "3   Current evidence does not directly link neosti...  \n",
       "4                                       I don't know.  \n",
       "5   Evidence from postmarketing reports indicates ...  \n",
       "6                                       I don't know.  \n",
       "7                                       I don't know.  \n",
       "8   The provided documents do not contain direct e...  \n",
       "9   Carbamazepine has been associated with hepatic...  \n",
       "10  There have been rare postmarketing reports of ...  \n",
       "11  Valproate has been associated with acute liver...  \n",
       "12                                      I don't know.  \n",
       "13                                      I don't know.  \n",
       "14  The evidence suggests a strong causal associat...  \n",
       "15  Clozapine has been associated with eosinophili...  \n",
       "16  There is limited evidence suggesting a potenti...  \n",
       "17  The provided documents do not contain direct e...  \n",
       "18  There is no direct information provided in the...  \n",
       "19  Nitrofurantoin has been associated with rare o...  "
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summary_evidence.head(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "9cd69808",
   "metadata": {},
   "outputs": [],
   "source": [
    "summary_evidence.to_csv('baselineprompt_rag_3sent_summaries.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a637cc76",
   "metadata": {},
   "source": [
    "## Embed the summaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "fc3cd30b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sentence_transformers import SentenceTransformer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "03306955",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/uog2000/miniconda3/envs/llm_cpus/lib/python3.11/site-packages/torch/cuda/__init__.py:138: UserWarning: CUDA initialization: The NVIDIA driver on your system is too old (found version 10010). Please update your GPU driver by downloading and installing a new version from the URL: http://www.nvidia.com/Download/index.aspx Alternatively, go to: https://pytorch.org to install a PyTorch version that has been compiled with your version of the CUDA driver. (Triggered internally at ../c10/cuda/CUDAFunctions.cpp:108.)\n",
      "  return torch._C._cuda_getDeviceCount() > 0\n",
      "/home/uog2000/miniconda3/envs/llm_cpus/lib/python3.11/site-packages/bitsandbytes/cextension.py:34: UserWarning: The installed version of bitsandbytes was compiled without GPU support. 8-bit optimizers, 8-bit multiplication, and GPU quantization are unavailable.\n",
      "  warn(\"The installed version of bitsandbytes was compiled without GPU support. \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/uog2000/miniconda3/envs/llm_cpus/lib/python3.11/site-packages/bitsandbytes/libbitsandbytes_cpu.so: undefined symbol: cadam32bit_grad_fp32\n"
     ]
    }
   ],
   "source": [
    "embed_model_name = 'llmrails/ember-v1'\n",
    "embed_model = SentenceTransformer(embed_model_name)\n",
    "man_embeds = embed_model.encode(summary_evidence['summary'].tolist())\n",
    "summary_evidence['embeds'] = list(man_embeds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "ad3fe202",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>condition_name</th>\n",
       "      <th>drug_name</th>\n",
       "      <th>affect</th>\n",
       "      <th>summary</th>\n",
       "      <th>embeds</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>lamotrigine</td>\n",
       "      <td>1</td>\n",
       "      <td>The provided documents do not contain direct e...</td>\n",
       "      <td>[0.15283781, -0.05386316, -0.19746718, 0.63484...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>nefazodone</td>\n",
       "      <td>1</td>\n",
       "      <td>Evidence suggests a causal association between...</td>\n",
       "      <td>[-0.06405382, -0.30085707, 0.7590669, 0.546655...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>tolcapone</td>\n",
       "      <td>1</td>\n",
       "      <td>The evidence supporting the causal association...</td>\n",
       "      <td>[-0.13962302, -0.36845908, 0.3567645, 0.789921...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Neostigmine</td>\n",
       "      <td>0</td>\n",
       "      <td>Current evidence does not directly link neosti...</td>\n",
       "      <td>[-0.011001076, 0.02761679, -0.059737656, 0.866...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Acute liver injury</td>\n",
       "      <td>Nortriptyline</td>\n",
       "      <td>1</td>\n",
       "      <td>I don't know.</td>\n",
       "      <td>[-0.0059796553, -0.3500437, -0.94098, -0.17054...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       condition_name      drug_name  affect  \\\n",
       "0  Acute liver injury    lamotrigine       1   \n",
       "1  Acute liver injury     nefazodone       1   \n",
       "2  Acute liver injury      tolcapone       1   \n",
       "3  Acute liver injury    Neostigmine       0   \n",
       "4  Acute liver injury  Nortriptyline       1   \n",
       "\n",
       "                                             summary  \\\n",
       "0  The provided documents do not contain direct e...   \n",
       "1  Evidence suggests a causal association between...   \n",
       "2  The evidence supporting the causal association...   \n",
       "3  Current evidence does not directly link neosti...   \n",
       "4                                      I don't know.   \n",
       "\n",
       "                                              embeds  \n",
       "0  [0.15283781, -0.05386316, -0.19746718, 0.63484...  \n",
       "1  [-0.06405382, -0.30085707, 0.7590669, 0.546655...  \n",
       "2  [-0.13962302, -0.36845908, 0.3567645, 0.789921...  \n",
       "3  [-0.011001076, 0.02761679, -0.059737656, 0.866...  \n",
       "4  [-0.0059796553, -0.3500437, -0.94098, -0.17054...  "
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summary_evidence.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "6bad41a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "summary_evidence.to_csv('baselineprompt_rag_3sent_summaries_embeds.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "117c8943",
   "metadata": {},
   "outputs": [],
   "source": [
    "embed_col_names = [f'embed_{i}' for i in range(1024)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "c3971247",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n",
      "/tmp/ipykernel_46804/3167580138.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)\n"
     ]
    }
   ],
   "source": [
    "summary_evidence[embed_col_names] = pd.DataFrame(summary_evidence.embeds.tolist(), index= summary_evidence.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "6aea8079",
   "metadata": {},
   "outputs": [],
   "source": [
    "summary_evidence.to_csv('baselineprompt_rag_3sent_summaries_embedsspread.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21b80395",
   "metadata": {},
   "source": [
    "## Logistic Regression Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "10332353",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
      "To disable this warning, you can either:\n",
      "\t- Avoid using `tokenizers` before the fork if possible\n",
      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting pyspark\n",
      "  Downloading pyspark-3.5.1.tar.gz (317.0 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m317.0/317.0 MB\u001b[0m \u001b[31m6.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
      "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25ldone\n",
      "\u001b[?25hCollecting py4j==0.10.9.7 (from pyspark)\n",
      "  Downloading py4j-0.10.9.7-py2.py3-none-any.whl.metadata (1.5 kB)\n",
      "Downloading py4j-0.10.9.7-py2.py3-none-any.whl (200 kB)\n",
      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m200.5/200.5 kB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hBuilding wheels for collected packages: pyspark\n",
      "  Building wheel for pyspark (setup.py) ... \u001b[?25ldone\n",
      "\u001b[?25h  Created wheel for pyspark: filename=pyspark-3.5.1-py2.py3-none-any.whl size=317488491 sha256=91a0841b78755f066aa33842a53b02e0331dacfa893870d4b9591091503b4ae5\n",
      "  Stored in directory: /home/uog2000/.cache/pip/wheels/95/13/41/f7f135ee114175605fb4f0a89e7389f3742aa6c1e1a5bcb657\n",
      "Successfully built pyspark\n",
      "Installing collected packages: py4j, pyspark\n",
      "Successfully installed py4j-0.10.9.7 pyspark-3.5.1\n"
     ]
    }
   ],
   "source": [
    "!pip install pyspark"
   ]
  },
  {
   "cell_type": "raw",
   "id": "149d9103",
   "metadata": {},
   "source": [
    "from pyspark.ml.linalg import Vectors\n",
    "from pyspark.ml.feature import VectorAssembler\n",
    "assembler = VectorAssembler(inputCols=[embed_col_names],outputCol=\"features\")\n",
    "summary_evidence = assembler.transform(summary_evidence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "f6660e79",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(344, 1024)"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_actual = summary_evidence.affect\n",
    "X = summary_evidence[embed_col_names]\n",
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "1cc3f81a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y_actual, test_size=0.25, random_state=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "838d54bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# instantiate the model (using the default parameters)\n",
    "logreg = LogisticRegression(random_state=100)\n",
    "\n",
    "# fit the model with data\n",
    "logreg.fit(X_train, y_train)\n",
    "\n",
    "y_pred = logreg.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "564506a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[43,  6],\n",
       "       [ 6, 31]])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "\n",
    "cnf_matrix = metrics.confusion_matrix(y_test, y_pred)\n",
    "cnf_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "e0654f2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                  precision    recall  f1-score   support\n",
      "\n",
      "negative control       0.88      0.88      0.88        49\n",
      "positive control       0.84      0.84      0.84        37\n",
      "\n",
      "        accuracy                           0.86        86\n",
      "       macro avg       0.86      0.86      0.86        86\n",
      "    weighted avg       0.86      0.86      0.86        86\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "target_names = ['negative control', 'positive control']\n",
    "print(classification_report(y_test, y_pred, target_names=target_names))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfabe404",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:llm_cpus]",
   "language": "python",
   "name": "conda-env-llm_cpus-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}