Docs cleanup

.gitignore

@@ -1,4 +0,0 @@
-venv/
-.env
-output.xlsx
-.gradio/

README.md

@@ -8,50 +8,6 @@ sdk_version: 5.9.1
 app_file: app.py
 pinned: false
 short_description: Tags phrases from study respondents.
-python_version: 3.13.1
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-
-# TFT Tagging app by Kenneth Lee, PercepTech.AI
-
-## What it does
-Uses a LLM to tag each quote in a column of an Excel file with zero or more tags from a given list, and returns the quotes tags on the app and also in a new file, along with some statistics and translations of randomly selected quotes for each tag.
-
-Inputs:
--Single sheet Excel file
--Column header to identify which column of data should be tagged
--List of tags to be assigned to the data
--List of columns to retain in the output file(these will not be changed from the input file)
-
-Outputs:
--List of quotes and tagged tags
--Count of number of instances tagged for eachtag
--Excel file containing the above data together with translations of some quotes corresponding to each tag that was used
-
-## Notables
-### Authentication: 
-- Private spaces require a HF account to access, hence this space is set as public. However anyone without a username and password will be stuck at a login screen.
-- The username and password are stored as secrets on HF itself. You may also refer to emails I have sent.
-- A temporary username, password, and login expiry time may be set in the secrets in order to give temporary access to TFT contractors. The time should be entered as Singapore time in ISO8601 format and any logins with the temporary account after this time will be prevented.
-Progress bar only takes into account tagging time and not translation time; thus it may hang for a short while at 100% while doing translation.
-
-### Quality of tagging:
-- Ideally we want the LLM's tags to match exactly what a trained market researcher would tag. There are however two difficulties in this:
-1)even two market researchers will not give identical tags for the same tags and the same dataset, and 
-2)the LLM has some variation in tags even when running the same tags and dataset twice, due to its non-deterministic nature. 
-- As such, to address the above difficulties, we assessed the quality of the LLM's tags by calculating precision, recall, and F1 of 8 aggregated runs of the LLM vs a trained market researcher(credit to Yong Li of TFT for providing the data), and also by calculating these for myself vs Yong Li.
-- By doing so we are able to get an estimate of the amount of agreement between humans on the same tags and dataset, and if the LLM is able to match this on average, then it can be considered to be equal to a human for this task.
-- We achieved an F1 of approximately 90 for myself vs Yong Li and about 70 for the AI vs Yong Li, indicating that the AI has room for improvement.
-- Refer to Perceptech AI driver/TFT tagging app reference material for the data
-
-### Sample input file and corresponding output:
-- Refer to Perceptech AI driver/TFT tagging app reference material
-
-### Branching behaviour: 
-- HF doesn't allow storage of any branches other than main online, to my knowledge. As such I usually update the repo by git push origin main - so be sure it works before pushing!
-
-## Future work
-- In the future we hope to improve the tagging so that the LLM-human F1 score matches human-human F1 scores.
-- I had explored fine tuning using 10 responses from the OE US dataset and Yong Li's model answers; this improves performance on the training set from F1 70 to F1 85 but I do not have a test set, the model name is "ft:gpt-4o-mini-2024-07-18:percepsense::BsDwvH1E"; just substitute it where the model eg "gpt-4o-mini" is specified
-- If TFT is able to retrieve any historical tagging data of their own human researchers on survey responses, this may be good training material also.

app.py

@@ -1,283 +1,145 @@
-# Import necessary modules
-import gradio as gr # For creating the interactive user interface
-import os # For accessing environment variables
-import pandas as pd # For easier data handling
-from openai import OpenAI # For sending the quotes to OpenAI for tagging
-import openpyxl # Requirement for reading Excel files into pandas Dataframes
-import json # For conversion of OpenAI responses into json/dictionary objects so the contents can be extracted
-from dotenv import load_dotenv # For loading environment variables in local environment
-from collections import Counter # For tabulating tag occurrences
-import logging
-import time
-import random
-from datetime import datetime
-from typing import Generator
-from concurrent.futures import ThreadPoolExecutor, as_completed
+import gradio as gr
+import os
+import pandas as pd
+from openai import OpenAI
+import openpyxl
+import json
 
-logger = logging.getLogger()
-logger.setLevel(logging.INFO)
-logging.basicConfig(level=logging.INFO, force=True)
-
-# Load environment variables from local .env file if it exists; otherwise this does nothing
-load_dotenv()
-
-# Import prompt for requesting the tags from OpenAI
-with open("prompts/prompt_030725.txt", "r") as prompt_file:
-    PROMPT = prompt_file.read()
-    logger.info(f"Loaded prompt: {PROMPT}")
-
-# Import user instructions for display on screen
-with open("user_instructions.txt", "r") as user_instruction_file:
-    INSTRUCTIONS = user_instruction_file.read()
-
-#Initialising the OpenAI client
 client = OpenAI(
   api_key=os.getenv('OPENAI_KEY'),
   organization=os.getenv('ORG_KEY'),
   project=os.getenv('PROJ_KEY')
 )
-logger.info("Initialised OpenAI client")
-
-# Function to send the prompt with quote and tag list to OpenAI and get the tags for that quote back
-def tag_quote(quote: str, tags_list: list) -> list:
-    """
-    Generates a list of tags for a given quote based on a predefined list of potential tags.
-
-    This function uses a GPT-based language model to analyze the input quote and determine 
-    the most relevant tags from the provided list. The response is parsed from the JSON 
-    output of the model and returned as a list of tags. This list is checked to ensure
-    all tags tagged are taken from the input tags_list.
 
-    Args:
-        quote (str): The quote or text to be analyzed.
-        tags_list (list): A list of potential tags to match against the quote.
-
-    Returns:
-        valid_tags: A list of tags that are relevant to the quote, as determined by the model.
-    """
-    logger.info(f"Tagging quote {quote}")
+# Static Username and Password
+VALID_USERNAME = "tft@perceptech.ai"
+VALID_PASSWORD = "Perceptech@2024!"
+
+#need to give info on how to convert to CSV
+title = "Automated Research Code Tagger"
+description = """
+ABOUT:\n
+This automated tagger takes in a list of tags and a list of input quotes. Each input quote is individually fed to OpenAI's ChatGPT together with the list of tags, 
+and ChatGPT will respond with the subset of the input tags which are related to the content of the quote.\n
+
+HOW TO USE:\n
+1)Upload a single sheet Excel file containing quotes in a column.(It is ok for the file to contain other data also)\n
+2)Type in the name of the column where the quotes are located\n
+3)Type in a list of tags separated by commas. For proper names/slogans/other tags that should be treated as an inseparable unit eg. Nike's "Just Do It", add a * in front of the tag eg. tag1, *Just Do It, tag3, etc.
+This will ensure only quotes containing "Just Do It" exactly are tagged and not other quotes about doing other things.\n
+4)All the responses from ChatGPT will be collated and displayed in the table on the right, together with the original quotes.
+You may then copy them into an Excel file for further processing. Please allow 5-10 min for processing, especially if you are giving upwards of 100 quotes!\n
+
+Please bear in mind that the tags are AI generated so check your results to ensure they make sense before using them. 
+I will not be responsible for mistakes made by the AI, but I can try to fix them if you alert me.
+-Kenneth
+"""
+
+prompt = """
+Given the quote below and the regular tag list below, evaluate each tag in the tag list and determine if the meaning of the quote can be described by that tag topic.
+If so, return the relevant tag in your response. Use only the tags provided in the list. Under no circumstances should you create new tag names.
+
+For the tags starting with a *, these tags should be treated as proper nouns(usually product names or slogans) and should not be used unless the quote explicitly contains the entire tag.
+For quotes with meanings that are more ambiguous and can relate to multiple tags, make no assumptions about their meanings and only add tags if the topic of the tag is actually mentioned in the quote.
+If there are no relevant tags to the quote, return an empty list.
+
+Quote:
+{quote}
+
+Tag list:
+{tags_list}
+
+Respond in the following format:
+{{
+  "tags":[<tagName1>, <tagName2>]
+}}
+"""
+def tag_quote(quote, tags_list):
     response = client.chat.completions.create(
         model = "gpt-4o-mini",
         response_format={"type": "json_object"},
         messages=[
             {"role": "system", "content": "You are a helpful assistant designed to output JSON."},
-            {"role": "user", "content": PROMPT.format(tags_list=tags_list,  quote=quote)}
+            {"role": "user", "content": prompt.format(tags_list=tags_list,  quote=quote)}
         ]
     )
-
-    tags = json.loads(response.choices[0].message.content)['tags']
-    valid_tags = []
-    for tag in tags: # filter out any hallucinated tags
-        if tag in tags_list:
-            valid_tags.append(tag)
-        else:
-            logger.warning(f"Invalid tag {tag} found and has been filtered out.")
-    return valid_tags
-
-def translate_quote(quote: str) -> str:
-    """
-    Translates a quote to English.
-    """
-    logger.info(f"Translating quote {quote}")
-    response = client.chat.completions.create(
-        model = "gpt-4o-mini",
-        messages=[
-            {"role": "user", "content": f"Translate the following quote into English. Do not return anything other than the translated quote. {quote}"}
-        ]
-    )
-    logger.info("Content")
-    logger.info(response.choices[0].message.content)
-    return response.choices[0].message.content
-
-def count_tags(tags_list: list, tags_col: pd.Series )->pd.DataFrame:
-    """
-    Creates a DataFrame indicating number of occurences of each tag from a DataFrame column containing lists of tags.
-
-    This function also takes in a tags_list; all tags in the tags_list will be in the output 
-    DataFrame even if they do not occur in the input tags_col. There may be some tags appearing 
-    in the output which were not in the original tag_list; these will be marked with a ! prefix.
-
-    Args:
-        tags_list (list): The list of tags given by the user
-        tags_col (pd.Series): A column of lists where each list contains tags which are 
-        (ideally but not always; depending on OpenAI) selected from the tags_list.
+    print(response.choices[0].message.content)
+    return json.loads(response.choices[0].message.content)['tags']
     
-    Returns:
-        pd.DataFrame: A DataFrame with two columns. The first contains individual tags(str) which have 
-        appeared either in the tags_list, the lists within the tags_col, or both. The second
-        contains the number of occurrences(int) of that tag within the lists in the tags_col.    
-    """
-    # Initialise Counter hash table
-    tags_counter = Counter({tag: 0 for tag in tags_list})
-    # Iterate over the lists in tags_col
-    for sublist in tags_col:
-        # Iterate over the tags in each list
-        for tag in sublist:
-            # Update the tags_counter for each tag
-            if tag in tags_list:
-                tags_counter.update([tag])
-            # If the tag was not in the tags_list given by the user, prefix it with a ! before updating
-            else:
-                tags_counter.update([f"!{tag}"])
-    # Convert the tags_counter to a DataFrame and return it
-    tags_counter_df = pd.DataFrame(tags_counter.items(), columns=['Tag', 'Count'])
-    return tags_counter_df
-
-
-# Function that takes in a list of tags and an Excel file of quotes, calls tag_quote() on each quote, and returns all the quotes and tags in a DataFrame     
-def process_quotes(quotes_file_path: str, quotes_col_name: str, retained_columns: str, tags_string: str) -> Generator[tuple[str, pd.DataFrame, pd.DataFrame, str]]:
-    """
-    Processes quotes from an Excel file and assigns relevant tags to each quote.
-
-    This function reads an Excel file containing quotes, validates the column containing
-    the quotes, and applies the `tag_quote` function to assign tags to each quote.
-    The tags are derived from a user-provided newline-separated string.
-
-    Args:
-        quotes_file_path (str): Path to the Excel file containing the quotes.
-        quotes_col_name (str): The name of the column containing the quotes.
-        retained_columns (str): The names of the columns in the Excel file which are to be added to the output file.
-        tags_string (str): A newline-separated string of potential tags.
-
-    Yields:
-        tuple: A 4-element tuple containing:
-        - str: A progress indicator (or "Not running" if tagging is complete)
-        - pd.DataFrame: A DataFrame with two columns: (or None if tagging is incomplete)
-            - The original column containing the quotes.
-            - A new column 'Tags' with the tags assigned to each quote.
-        - pd.DataFrame: A DataFrame with two columns: (or None if tagging is incomplete)
-            -"Tag" - The list of tags that was passed in.
-            -"Count" - The total number of times each tag was used in tagging all the quotes.
-        - str: A path to an Excel file containing sheets derived from the previous 2 DataFrames. (or None if tagging is incomplete)
-
-    Raises:
-        gr.Error: If the specified column name does not exist or is not unique.
-    """
-    tags_list = tags_string.split('\n')
+def process_quotes(quotes_file_path, quotes_col_name, tags_string):
+    print(quotes_file_path)
+    print(quotes_col_name)
+    print(tags_string)
+    tags_list = tags_string.split(',')
     tags_list = [tag.strip() for tag in tags_list]
 
-    if retained_columns:
-        retained_cols_list = retained_columns.split(',')
-        retained_cols_list = [colname.strip() for colname in retained_cols_list]
-    else:
-        retained_cols_list = []
-
-    # Transfer quotes data from Excel file into pandas DataFrame, handling potential duplicate column names in the Excel file
-    # pd.read_excel will rename duplicates eg foo -> foo.1, causing a mismatch between quotes_col_name and the actual column name
-    # Extract the first row(the actual header for the DataFrame) as a DataFrame without header.
-    quotes_df_cols= pd.read_excel(quotes_file_path, header=None, nrows=1).values[0] 
-    # Extract all the other rows of the Excel file as a DataFrame without header
-    quotes_df = pd.read_excel(quotes_file_path, header=None, skiprows=1) 
-    # Set the extracted first row as the header for the DataFrame resultant from the other rows
-    quotes_df.columns = quotes_df_cols
-    # Verify that all column names given are found in the quotes DF exactly once each
-    for colname in retained_cols_list + [quotes_col_name]:
-        count = quotes_df.columns.tolist().count(colname)
-        if count == 0:
-            raise gr.Error(f"No columns with name {colname} found, check your inputs")
-        elif count > 1:
-            raise gr.Error(f"Multiple columns with name {colname} found, please rename these columns to something unique")
-
+    #next 3 lines are necessary as pd.read_excel will rename duplicate columns found in the excel file eg foo -> foo.1, hence we need to extract the first row alone and not as header, and then set it as header for the rest of the DF later.
+    quotes_df_cols= pd.read_excel(quotes_file_path, header=None, nrows=1).values[0] #creates a df without header from the excel and takes the first row
+    quotes_df = pd.read_excel(quotes_file_path, header=None, skiprows=1) # converts row 2 onwards into the DF, without specifying a header
+    quotes_df.columns = quotes_df_cols # sets the first row of excel file as header
+
+    count = quotes_df.columns.tolist().count(quotes_col_name)
+    if count == 0:
+        raise gr.Error("No columns with this name found")
+    elif count > 1:
+        print("Count>1!!")
+        raise gr.Error("Multiple columns with this name found, please rename to something unique")
     quotes_data = quotes_df[quotes_col_name]
+    quotes_df['Tags'] = quotes_data.apply(tag_quote, args=(tags_list,))
+    return quotes_df[[quotes_col_name, 'Tags']]
     
-    # Tag all the quotes one by one using tag_quote function
-    tags_results = [None]*len(quotes_data)
-
-    # Threading execution of tag_quotes with {max_workers} threads: we send {max_workers} requests to the LLM concurrently.
-    with ThreadPoolExecutor() as executor:
-        # Generate futures for each of the quotes and map them to the quote indices
-        future_to_index = {
-            executor.submit(tag_quote, quote, tags_list): i for i, quote in enumerate(quotes_data)
-        }
-        # Enumerate the completed futures(ordered as completed which may be different from submitted order)
-        # This step waits for the tag_quote functions to complete
-        for completed, future in enumerate(as_completed(future_to_index), 1):
-            # Retrieve index of the completed future from above map
-            i = future_to_index[future]
-            # Insert the result of the completed future into the results list at its quote's original position
-            try:
-                tags_results[i] = future.result()
-            except Exception as e:
-                tags_results[i] = f"Error:{e}"
-            # Update UI by yielding a status update
-            yield (f"Tagged {completed}/{len(quotes_data)} quotes: {quotes_data[i]}", None, None, None)
-
-    quotes_df['Tags'] = tags_results
-
-    # One hot encoding of tagged tags
-    for tag in tags_list:
-        quotes_df[tag]=quotes_df['Tags'].apply(lambda quote_tags: int(tag in quote_tags))
-    logger.info("Quotes tagged")
-
-    # Create hash table of tag occurrences using count_tags function
-    tags_counter_df = count_tags(tags_list, quotes_df['Tags'])
-
-    # Retrieve 2 quotes at random for each tag and put them in the tags counter DF
-    for tag in tags_counter_df['Tag']:
-        tagged_quotes_list = quotes_df.loc[quotes_df[tag]==1, quotes_col_name].tolist()
-        sample_quotes = random.sample(tagged_quotes_list, min(2, len(tagged_quotes_list)))
-        translated_quotes = [translate_quote(quote) for quote in sample_quotes]
-        while len(sample_quotes) < 2:
-            sample_quotes.append(None)
-            translated_quotes.append(None)
-        [tags_counter_df.loc[tags_counter_df['Tag'] == tag, 'Quote 1'], tags_counter_df.loc[tags_counter_df['Tag'] == tag, 'Quote 2']] = sample_quotes
-        [tags_counter_df.loc[tags_counter_df['Tag'] == tag, 'Translated Quote 1'], tags_counter_df.loc[tags_counter_df['Tag'] == tag, 'Translated Quote 2']] = translated_quotes
-
-    #Convert values in tags column from list to str
-    quotes_df['Tags'] = quotes_df["Tags"].apply(lambda x: ", ".join(x))
-
-    # Return only the quotes column, the new tags column, and any other specified cols to retain
-    output_df = quotes_df[retained_cols_list+[quotes_col_name, 'Tags']+tags_list] 
-    output_file_path = "output.xlsx"
-    with pd.ExcelWriter(output_file_path) as writer:
-        output_df.to_excel(writer, sheet_name='Coded Quotes', index=False)
-        tags_counter_df.to_excel(writer, sheet_name='Tag Count', index=False)
-    logger.info('Results written to Excel')
-    yield ("Not running", output_df[[quotes_col_name, 'Tags']], tags_counter_df, output_file_path)
-
-def check_auth(username:str, password:str):
-    """
-    Authenticate the user.
-    
-    Verifies the user's credentials against the values stored in the environment variables.
-    User may authenticate with permanent username and password(for TFT team) or temporary username and password.
-    For temporary username and password, they will only be valid before the expiry time as set in the environment variables.
-
-    Returns True or False depending on authentication success.
-    """
-    # Check permanent credentials
-    if username == os.getenv('APP_USERNAME') and password == os.getenv('APP_PASSWORD'):
-        return True
-
-    # Check temporary credentials
-    if (
-        username == os.getenv('TEMP_USERNAME') and 
-        password == os.getenv('TEMP_PASSWORD') and 
-        time.time() < datetime.fromisoformat(os.getenv('TEMP_EXPIRY_TIME_SG_ISO_8601').replace("Z", "+08:00")).timestamp()
-    ):
-        return True
-
-    # Invalid credentials
-    return False
-    
-# Define user interface structure
+# def authenticate(username, password):
+#     """Authenticate the user using static username and password"""
+#     if username == VALID_USERNAME and password == VALID_PASSWORD:
+#         return True
+#     else:
+#         return False
+        
+# def auth_interface(username, password):
+#     """Handle the authentication and proceed with the main function if valid"""
+#     if authenticate(username, password):
+#         return gr.Interface(
+#             fn=process_quotes, 
+#             inputs=[
+#                 gr.File(label="Quotes Excel File"),  # File as generated by TFT software
+#                 gr.Textbox(label="Name of quotes column"),  # use this to identify the col with the quotes 
+#                 gr.Textbox(label="List of tags separated by commas")
+#             ],
+#             outputs=gr.Dataframe(headers=["Quote", "Tags"], column_widths=["70%", "30%"], scale=2),
+#             title=title,
+#             description=description
+#         ).launch()
+#     else:
+#         return "Invalid username or password!"
+
+# # Create the authentication fields before launching the main app
+# auth_app = gr.Interface(
+#     fn=auth_interface,
+#     inputs=[
+#         gr.Textbox(label="Username", type="text"),
+#         gr.Textbox(label="Password", type="password")
+#     ],
+#     outputs="text",
+#     title="Login to Automated Research Code Tagger",
+#     description="Please enter the correct username and password to access the tool."
+# )
+
+# auth_app.launch()
 demo = gr.Interface(
     fn=process_quotes, 
     inputs=[
-        gr.File(label="Quotes Excel File"),
-        gr.Textbox(label="Name of quotes column"),
-        gr.Textbox(label = "Names of columns(eg respondentID) to retain in output, separated by commas"),
-        gr.Textbox(label = "List of tags, each tag on a new line"),
+        gr.File(label="Quotes Excel File"), # File as generated by TFT software
+        gr.Textbox(label="Name of quotes column"), # use this to identify the col with the quotes 
+        gr.Textbox(label = "List of tags separated by commas")
     ],
-    outputs=[
-        gr.Textbox(label="Progress", value = "Not running"),
-        gr.Dataframe(headers=["Quote", "Tags"], column_widths=["70%", "30%"], scale=2, label='Coded Quotes'),
-        gr.Dataframe(headers=["Tag", "Count"], label='Tag Count'),
-        gr.File(label="Output data in file format")
-        
-    ],
-    title="Automated Research Code Tagger",
-    description=INSTRUCTIONS 
+    outputs=gr.Dataframe(headers=["Quote", "Tags"], column_widths=["70%", "30%"], scale=2),
+    title=title,
+    description=description 
     )
 
-demo.launch(share=True, auth=check_auth, ssr_mode=False)
+demo.launch()
+
+# For later when I enable usage of own API key
+# api_key = gr.Textbox(
+#         type="password", label="Enter your OpenAI API key here (Optional for Perceptech users)"
+#     )

prompts/base_prompt.txt

@@ -1,17 +0,0 @@
-Given the quote below and the regular tag list below, evaluate each tag in the tag list and determine if the meaning of the quote can be described by that tag topic.
-If so, return the relevant tag in your response. Use only the tags provided in the list. Under no circumstances should you create new tag names.
-
-For the tags starting with a *, these tags should be treated as proper nouns(usually product names or slogans) and should not be used unless the quote explicitly contains the entire tag.
-For quotes with meanings that are more ambiguous and can relate to multiple tags, make no assumptions about their meanings and only add tags if the topic of the tag is actually mentioned in the quote.
-If there are no relevant tags to the quote, return an empty list.
-
-Quote:
-{quote}
-
-Tag list:
-{tags_list}
-
-Respond in the following format:
-{{
-  "tags":[<tagName1>, <tagName2>]
-}}

prompts/prompt_030725.txt

@@ -1,21 +0,0 @@
-Given the quote below and the regular tag list below, evaluate each tag in the tag list and determine if the meaning of the quote can be described by that tag topic.
-If so, return the relevant tag in your response. Use only the tags provided in the list. Under no circumstances should you create new tag names.
-
-IMPORTANT: Do NOT infer the respondent's meaning based on brand reputation, public knowledge, or commonly associated attributes (e.g., don't assume "natural" just because a brand is known for it). Only use a tag if the specific idea or topic is **explicitly stated** or clearly implied **by the respondent**, not by external associations.
-
-Tags starting with a * are proper nouns (usually product names or slogans) and should only be used if the quote contains the entire tag exactly.
-
-If the quote is vague or ambiguous, do not guess. Only add tags if the topic of the tag is clearly and unambiguously expressed in the quote.
-
-If there are no relevant tags, return an empty list.
-
-Quote:
-{quote}
-
-Tag list:
-{tags_list}
-
-Respond in the following format:
-{{
-  "tags":[<tagName1>, <tagName2>]
-}}

requirements.txt

@@ -1,5 +1,3 @@
-gradio==5.12.0
+gradio==4.31.5
 openai==1.59.3
-openpyxl==3.1.5
-python-dotenv==1.0.1
-pydantic==2.10.6
+openpyxl==3.1.5

user_instructions.txt

@@ -1,22 +0,0 @@
-ABOUT:
-This automated tagger takes in a list of tags and a list of input quotes. Each input quote is individually fed to OpenAI's ChatGPT together with the list of tags, 
-and ChatGPT will respond with the subset of the input tags which are related to the content of the quote.
-
-HOW TO USE:<br>
-1)Upload a single sheet Excel file containing quotes in a column.(It is ok for the file to contain other data also)<br>
-2)Type in the name of the column where the quotes are located<br>
-3)Type in the names of any other columns which you wish to retain in the output <br>
-4)Type in a list of tags, each tag on a new line. For proper names/slogans/other tags that should be treated as an inseparable unit eg. Nike's "Just Do It", add a * in front of the tag eg. tag1, *Just Do It, tag3, etc. <br>
-This will ensure only quotes containing "Just Do It" exactly are tagged and not other quotes about doing other things.<br>
-Please allow 5-10 min for processing, especially if you are giving upwards of 100 quotes!<br>
-
-READING THE OUTPUT(in the right-side column): <br>
-Progress bar: Indicates which quote is currently being processed <br>
-First table: All the responses are collated and displayed here, together with the original quotes.<br>
-Second table: Displays all the tags used and the number of occurrences of each tag. <br>
-You may also retrieve both tables in a single Excel file via the link below them.<br>
-
-DISCLAIMER:<br>
-Please bear in mind that the tags are AI generated so check your results to ensure they make sense before using them. 
-I will not be responsible for mistakes made by the AI, but I can try to fix them if you alert me.<br>
--Kenneth Lee, Perceptech.AI