diff --git a/gemini/README.md b/gemini/README.md
new file mode 100644
index 0000000..308c0c4
--- /dev/null
+++ b/gemini/README.md
@@ -0,0 +1,59 @@
+# Gemini-generated data
+
+### Overview
+
+You'll find three scripts in this directory for creating egocentric video understanding data using Gemini:
+1. `prepare_ego4d_nlq_for_gemini.py`: prepare the Ego4D NLQ video clips for Gemini prompting.
+2. `generate_gemini_data.py`: zero-shot multimodal prompting of Gemini to generate the training data. We used version `gemini-1.5-pro-preview-0409` for the published dataset, but we've updated the default to `gemini-1.5-pro-001`.
+3. `prepare_ego4d_vqa_gemini_dataset.py`: post-processing Gemini output to prepare for training.
+
+### Prerequisites
+
+The following are required to run the above scripts:
+1. Ego4D access, request it [here](https://ego4d-data.org/docs/start-here/). The files ego4d.json and nlq_train.json are required locally, as are the AWS credentials for access to the videos.
+2. An [VertexAI](https://cloud.google.com/vertex-ai) API key for prompting Gemini.
+3. A [GCS bucket](https://cloud.google.com/storage) for storing output Ego4D NLQ clips used for prompting Gemini.
+
+### How to run
+
+Perform the following steps, executing from the `gemini` directory:
+``` python
+# Create and activate virtual environment if you haven't already
+python -m venv venv
+source venv/bin/activate
+pip install -r ../requirements.txt
+
+# Prepare the Ego4D NLQ data, the video clips will be uploaded to GCS, ready for prompting with VertexAI
+python ./prepare_ego4d_nlq_for_gemini.py \
+  --ego4d_path [relative path to ego4d.json] \                  # Default: ../data/ego4d.json
+  --ego4d_nlq_path [relative path to nlq_train.json] \          # Default: ../data/nlq_train.json
+  --ego4d_output_videos_path [path to output clips] \           # Output video object path on GCS (and local path). Default: ego4d_vqa_gemini_videos.
+  --output_json_path [path to output JSON file] \               # Default: ego4d_vqa_gemini.json
+  --ego4d_aws_access_key_id [EGO4D_AWS_ACCESS_KEY_ID] \         # Required, obtained from Ego4D
+  --ego4d_aws_secret_access_key [EGO4D_AWS_SECRET_ACCESS_KEY] \ # Required, obtained from Ego4D
+  --ego4d_aws_region_name [EGO4D_AWS_REGION_NAME] \             # Required, obtained from Ego4D
+  --gcs_bucket_name [GCS_BUCKET_NAME] \                         # Required, GCS bucket the clips will be saved to
+  --keep-local-clips                                            # Optional flag to specify keeping the clips locally (requires about 130 Gb of storage)
+
+# Call VertexAI to generate training data
+python ./generate_gemini_data.py \
+  --gcs_project_id [GCS_PROJECT_ID] \                           # Required, your Google Cloud project ID
+  --gcs_bucket_name [GCS_BUCKET_NAME] \                         # Required, GCS bucket with Ego4D NLQ clips
+  --gcs_location [GCS_LOCATION] \                               # Required, GCS location to use with VertexAI
+  --resume \                                                    # Optional flag to specify resuming from last clip
+  --ego4d_vqa_gemini_path [path to Ego4D clips JSON file] \     # Outputted from previous script. Default: ./ego4d_vqa_gemini.json
+  --output_path [path to output JSON file] \                    # Default: gemini_responses.json
+  --gemini_model GEMINI_MODEL \                                 # Default: gemini-1.5-pro-001
+  --vertexai_quota VERTEXAI_QUOTA                               # VertexAI request quota per minute. Default: 5
+
+# Post-process the Gemini data to create JSON used for training
+python ./prepare_ego4d_vqa_gemini_dataset.py \
+  --ego4d_path [path to ego4d.json] \                           # Default: ../data/ego4d.json
+  --ego4d_nlq_path [path to nlq_train.json] \                   # Default: ../data/nlq_train.json
+  --gemini_data_path [path to Gemini responses JSON file] \     # Outputted from previous script. Default: gemini_responses.json
+  --output_path [path to output JSON file]                      # Default: ego4d_nlq_train.gemini_pro_1.5.json
+```
+
+#### Note
+
+After performing human annotation, we manually replaced the Gemini-generated answers with the gold standard answers for inclusion in the EVUD dataset.
\ No newline at end of file
diff --git a/gemini/generate_gemini_data.py b/gemini/generate_gemini_data.py
new file mode 100644
index 0000000..c75f0a2
--- /dev/null
+++ b/gemini/generate_gemini_data.py
@@ -0,0 +1,161 @@
+import json
+import vertexai
+from vertexai.generative_models import GenerativeModel
+from tqdm import tqdm
+import argparse
+import time
+import math
+import os
+
+
+################################################################################
+# Instruction for prompting Gemini Pro
+INSTRUCTION = """You are an intelligent embodied agent that can answer questions. You will be shown a video that was collected from a single location.
+
+Your task is to generate a question for each of the following categories: object recognition, attribute recognition, object state recognition, object localisation, spatial reasoning, functional reasoning, world knowledge.
+
+Ask diverse questions and give corresponding short answers. Include questions asking about the visual content of the video. The questions you posed can include the actions and behaviors of people or objects in the video, the chronological order of events, and causal relationships. Only include questions that have definite answers. Do not ask any questions that cannot be answered confidently.
+
+Don't use headers. You should use the following format for each category:
+Category: <category>
+Question: <question>
+Short answer: <answer>
+
+Assistant:
+"""
+
+
+################################################################################
+# Parse arguments
+parser = argparse.ArgumentParser(
+    description="Prompt Gemini Pro 1.5 to generate egocentric video understanding training data"
+)
+parser.add_argument(
+    "--gcs_project_id", type=str, required=True, help="Your Google Cloud project ID"
+)
+parser.add_argument(
+    "--gcs_bucket_name", type=str, required=True, help="GCS bucket with Ego4D NLQ clips"
+)
+parser.add_argument(
+    "--gcs_location", type=str, required=True, help="GCS location to use with VertexAI"
+)
+parser.add_argument("--resume", action="store_true", help="Resume from last clip")
+parser.add_argument(
+    "--ego4d_vqa_gemini_path",
+    type=str,
+    default="./ego4d_vqa_gemini.json",
+    help="Path to ego4d_vqa_gemini.json. Default: ./ego4d_vqa_gemini.json",
+)
+parser.add_argument(
+    "--output_path",
+    type=str,
+    default="gemini_responses.json",
+    help="Output path for Gemini responses. Default: gemini_responses.json",
+)
+parser.add_argument(
+    "--gemini_model",
+    type=str,
+    default="gemini-1.5-pro-001",
+    help="Gemini Pro model. Default: gemini-1.5-pro-001",
+)
+parser.add_argument(
+    "--vertexai_quota",
+    type=int,
+    default=5,
+    help="VertexAI request quota per minute. Default: 5",
+)
+
+args = parser.parse_args()
+GCS_PROJECT_ID = args.gcs_project_id
+GCS_BUCKET_NAME = args.gcs_bucket_name
+GCS_LOCATION = args.gcs_location
+RESUME = args.resume
+NLQ_VQA_PATH = args.ego4d_vqa_gemini_path
+OUTPUT_PATH = args.output_path
+GEMINI_MODEL = args.gemini_model
+QUOTA = args.vertexai_quota
+
+
+################################################################################
+# Load the NLQ VQA data
+with open(NLQ_VQA_PATH, "r") as file:
+    vqa = json.load(file)
+
+
+################################################################################
+# Initialize Vertex AI
+vertexai.init(project=GCS_PROJECT_ID, location=GCS_LOCATION)
+
+# Load the model
+gemini = GenerativeModel(GEMINI_MODEL)
+
+
+################################################################################
+# Resume progress
+if RESUME and os.path.exists(OUTPUT_PATH):
+    with open(OUTPUT_PATH, "r") as file:
+        responses = json.load(file)
+
+else:
+    responses = []
+
+processed_clips = [r["example"]["id"] for r in responses]
+
+if RESUME:
+    print("-----------------------------------------------------------------------")
+    print(f"Skipping {len(processed_clips)} already processed!")
+    print("-----------------------------------------------------------------------")
+
+
+################################################################################
+# Process examples
+time_limit = 60
+time_queue = []
+
+for idx, example in enumerate(tqdm(vqa, total=len(vqa))):
+    if example["id"] in processed_clips:
+        continue
+
+    # record start time
+    start_time = time.time()
+
+    # Limit the requests to the specified quota
+    if len(time_queue) == QUOTA:
+        total_time = sum(time_queue)
+        sleep_time = math.ceil(time_limit - total_time)
+        if sleep_time > 0:
+            time.sleep(sleep_time)
+        time_queue.pop(0)
+
+    clip_path = f"gs://{GCS_BUCKET_NAME}/{example['video_filename']}"
+    clip = vertexai.generative_models.Part.from_uri(
+        uri=clip_path, mime_type="video/mp4"
+    )
+
+    try:
+        response = gemini.generate_content([clip, INSTRUCTION])
+    except Exception:
+        time.sleep(10)
+        response = gemini.generate_content([clip, INSTRUCTION])
+
+    responses.append(
+        {
+            "example": example,
+            "response": response.to_dict(),
+        }
+    )
+
+    # Output results every five responses
+    if (idx + 1) % 5 == 0:
+        # store results to JSON file
+        with open(OUTPUT_PATH, "w") as out_file:
+            json.dump(responses, out_file)
+
+    # append duration to time queue to keep requests within specified quota
+    time_queue.append(math.ceil(time.time() - start_time))
+
+# store the last results to JSON file
+with open(OUTPUT_PATH, "w") as out_file:
+    json.dump(responses, out_file)
+
+print("Done!")
diff --git a/gemini/prepare_ego4d_nlq_for_gemini.py b/gemini/prepare_ego4d_nlq_for_gemini.py
new file mode 100644
index 0000000..0201e5b
--- /dev/null
+++ b/gemini/prepare_ego4d_nlq_for_gemini.py
@@ -0,0 +1,216 @@
+import argparse
+import json
+import math
+import os
+
+import boto3
+from moviepy.editor import VideoFileClip
+from tqdm import tqdm
+from google.cloud import storage
+
+
+################################################################################
+# GCS utility function
+def upload_blob(bucket_name, source_file_name, destination_blob_name):
+    """Uploads a file to the bucket."""
+    try:
+        storage_client = storage.Client()
+        bucket = storage_client.bucket(bucket_name)
+        blob = bucket.blob(destination_blob_name)
+        blob.upload_from_filename(source_file_name, timeout=180)
+    except Exception as e:
+        print(
+            f"Failed to upload {source_file_name} to {bucket_name}/{destination_blob_name}: {e}"
+        )
+        raise
+
+
+################################################################################
+# Parse arguments
+parser = argparse.ArgumentParser(
+    description="Process Ego4D NLQ Train clips for use with Gemini Pro"
+)
+parser.add_argument(
+    "--ego4d_path",
+    type=str,
+    default="../data/ego4d.json",
+    help="Path to ego4d.json. Default: ../data/ego4d.json",
+)
+parser.add_argument(
+    "--ego4d_nlq_path",
+    type=str,
+    default="../data/nlq_train.json",
+    help="Path to nlq_train.json. Default: ../data/nlq_train.json",
+)
+parser.add_argument(
+    "--ego4d_output_videos_path",
+    type=str,
+    default="ego4d_vqa_gemini_videos/",
+    help="Output video object path on GCS (and local path). Default: ego4d_vqa_gemini_videos",
+)
+parser.add_argument(
+    "--output_json_path",
+    type=str,
+    default="ego4d_vqa_gemini.json",
+    help="Path to output JSON file",
+)
+parser.add_argument(
+    "--ego4d_aws_access_key_id",
+    type=str,
+    required=True,
+    help="Ego4D AWS access key ID, obtained from Ego4D",
+)
+parser.add_argument(
+    "--ego4d_aws_secret_access_key",
+    type=str,
+    required=True,
+    help="Ego4D AWS secret access key, obtained from Ego4D",
+)
+parser.add_argument(
+    "--ego4d_aws_region_name",
+    type=str,
+    required=True,
+    help="Ego4D AWS region name, obtained from Ego4D",
+)
+parser.add_argument(
+    "--gcs_bucket_name",
+    type=str,
+    required=True,
+    help="GCS bucket the clips will be saved to",
+)
+parser.add_argument(
+    "--keep-local-clips",
+    action="store_true",
+    help="Optional flag to specify keeping the clips locally (requires about 130 Gb of storage)",
+)
+args = parser.parse_args()
+
+
+################################################################################
+# Load the data
+with open(args.ego4d_path) as in_file:
+    ego4d_videos = json.load(in_file)
+    video_uid2video = {video["video_uid"]: video for video in ego4d_videos["videos"]}
+
+with open(args.ego4d_nlq_path) as in_file:
+    ego4d_nlq = json.load(in_file)
+
+
+################################################################################
+# Process videos
+dataset = []
+
+# init JSON file
+with open(args.output_json_path, "w") as in_file:
+    pass
+
+s3 = boto3.client(
+    "s3",
+    aws_access_key_id=args.ego4d_aws_access_key_id,
+    aws_secret_access_key=args.ego4d_aws_secret_access_key,
+    region_name=args.ego4d_aws_region_name,
+)
+
+last_downloaded_video_filename = None
+
+for video in tqdm(ego4d_nlq["videos"], total=len(ego4d_nlq["videos"])):
+    for clip in video["clips"]:
+        for annotation in clip["annotations"]:
+            for language_query_index, language_query in enumerate(
+                annotation["language_queries"]
+            ):
+                idx = len(dataset)
+                try:
+                    s3_video_path_parts = video_uid2video[video["video_uid"]][
+                        "s3_path"
+                    ].split("/")
+                    s3_bucket_name = s3_video_path_parts[2]
+                    s3_key = "/".join(s3_video_path_parts[3:])
+                    s3_filename = s3_video_path_parts[-3]
+
+                    video_filename = os.path.join(
+                        args.ego4d_output_videos_path,
+                        video["video_uid"],
+                    )
+
+                    if video_filename != last_downloaded_video_filename:
+                        if last_downloaded_video_filename:
+                            os.remove(last_downloaded_video_filename)
+                        s3.download_file(s3_bucket_name, s3_key, video_filename)
+                        last_downloaded_video_filename = video_filename
+
+                    video_start_sec = max(
+                        math.floor(language_query["video_start_sec"]),
+                        0,
+                    )
+                    video_end_sec = min(
+                        math.ceil(language_query["video_end_sec"]),
+                        video_uid2video[video["video_uid"]]["duration_sec"],
+                    )
+
+                    clip_filename = os.path.join(
+                        args.ego4d_output_videos_path,
+                        video["video_uid"],
+                        clip["clip_uid"],
+                        annotation["annotation_uid"],
+                        f"{language_query_index}.mp4",
+                    )
+
+                    video_clip = VideoFileClip(last_downloaded_video_filename)
+                    video_clip = video_clip.subclip(video_start_sec, video_end_sec)
+                    video_clip.write_videofile(
+                        clip_filename, remove_temp=True, logger=None
+                    )
+
+                    # Upload to GCS
+                    if args.gcs_bucket_name:
+                        upload_blob(args.gcs_bucket_name, clip_filename, clip_filename)
+
+                    human_value = (f"<video>\n",)
+                    if "query" in language_query:
+                        human_value = f"<video>\n{language_query['query']}"
+
+                    gpt_value = ""
+                    if "answer" in language_query:
+                        gpt_value = language_query["answer"].replace(
+                            "Answer (Optional):", ""
+                        )
+
+                    dataset.append(
+                        {
+                            "id": idx,
+                            "video_uid": video["video_uid"],
+                            "clip_uid": clip["clip_uid"],
+                            "annotation_uid": annotation["annotation_uid"],
+                            "language_query_index": language_query_index,
+                            "video_filename": clip_filename,
+                            "conversations": [
+                                {
+                                    "from": "human",
+                                    "value": human_value,
+                                },
+                                {
+                                    "from": "gpt",
+                                    "value": gpt_value,
+                                },
+                            ],
+                        }
+                    )
+
+                    with open(args.output_json_path, "w") as out_file:
+                        json.dump(dataset, out_file)
+
+                    if not args.keep_local_clips:
+                        os.remove(clip_filename)
+
+                except Exception as e:
+                    print(f"Error with {idx}!")
+                    print(e)
+
+if os.path.exists(last_downloaded_video_filename):
+    os.remove(last_downloaded_video_filename)
+
+with open(args.output_json_path, "w") as out_file:
+    json.dump(dataset, out_file)
+
+print("Done!")
diff --git a/gemini/prepare_ego4d_vqa_gemini_dataset.py b/gemini/prepare_ego4d_vqa_gemini_dataset.py
new file mode 100644
index 0000000..95bc2d2
--- /dev/null
+++ b/gemini/prepare_ego4d_vqa_gemini_dataset.py
@@ -0,0 +1,231 @@
+import math
+import random
+import json
+import copy
+import argparse
+
+random.seed(42)
+
+
+################################################################################
+# Utility/processing functions
+def sort_dicts_by_category_list(dict_list, category_list):
+    """Sorts a list of dictionaries based on the order of categories in a category list."""
+    category_order = {category: i for i, category in enumerate(category_list)}
+    sorted_dicts = sorted(
+        dict_list, key=lambda item: category_order.get(item["category"], float("inf"))
+    )
+    return sorted_dicts
+
+
+def preprocess_data(gen_data):
+    """Process the generated text - check how many responses fit the expected format and return the missing data too"""
+    categories = [
+        "object recognition",
+        "attribute recognition",
+        "object state recognition",
+        "object localisation",
+        "spatial reasoning",
+        "functional reasoning",
+        "world knowledge",
+    ]
+
+    processed_data = []
+    missing = []
+
+    for g in gen_data:
+        try:
+            if len(g["response"]["candidates"]) < 1:
+                missing.append(g)
+                continue
+            if "content" not in g["response"]["candidates"][0]:
+                missing.append(g)
+                continue
+
+            response = g["response"]["candidates"][0]["content"]["parts"][0]["text"]
+            category_data = response.split("\n\n")
+            examples = []
+
+            for c_data in category_data:
+                c_lines = c_data.splitlines()
+                # drop empty lines
+                c_lines = [c_line for c_line in c_lines if bool(c_line)]
+                example = {}
+                for c_line in c_lines:
+                    key, value = c_line.split(": ", 1)
+                    example[key.strip().lower()] = (
+                        value.strip().lower().replace("localization", "localisation")
+                    )
+                examples.append(example)
+
+            # set the order of the examples to categories
+            sorted_examples = sort_dicts_by_category_list(examples, categories)
+
+            for example, category in zip(sorted_examples, categories):
+                assert category == example["category"].lower()
+
+            pd = copy.deepcopy(g)
+            pd["processed_examples"] = sorted_examples
+            processed_data.append(pd)
+
+        except Exception:
+            print(g)
+            raise
+
+    if len(missing) > 0:
+        print(f"There are {len(missing)} examples which do not have a Gemini response")
+
+    return processed_data, missing
+
+
+def prepare_durations(train, missing_data, video_uid2video):
+    """Get the durations, indexed by clip ID"""
+    missing_keys = [
+        f"{m['example']['video_uid']}-{m['example']['clip_uid']}-{m['example']['annotation_uid']}-{m['example']['language_query_index']}"
+        for m in missing_data
+    ]
+
+    durations = {}
+    for video in train["videos"]:
+        for clip in video["clips"]:
+            for annotation in clip["annotations"]:
+                for language_query_index, language_query in enumerate(
+                    annotation["language_queries"]
+                ):
+                    # check the video isn't in the missing set
+                    key = f"{video['video_uid']}-{clip['clip_uid']}-{annotation['annotation_uid']}-{language_query_index}"
+                    if key in missing_keys:
+                        continue
+                    start = max(math.floor(language_query["video_start_sec"]), 0)
+                    end = min(
+                        math.ceil(language_query["video_end_sec"]),
+                        video_uid2video[video["video_uid"]]["duration_sec"],
+                    )
+                    duration = end - start
+                    durations[key] = duration
+    return durations
+
+
+def prepare_turns(example):
+    """Prepare a single example - shuffling categories randomly"""
+    human_values = []
+    gpt_values = []
+
+    for pe in example["processed_examples"]:
+        human_values.append({"from": "human", "value": pe["question"].capitalize()})
+        gpt_values.append({"from": "gpt", "value": pe["short answer"].capitalize()})
+
+    random_order = [0, 1, 2, 3, 4, 5, 6]
+    random.shuffle(random_order)
+
+    conversation = []
+    for i, ro in enumerate(random_order):
+        if i == 0:
+            human_value = human_values[ro]
+            human_value["value"] = f"<video>\n{human_value['value']}"
+            conversation.append(human_value)
+            conversation.append(gpt_values[ro])
+        else:
+            conversation.append(human_values[ro])
+            conversation.append(gpt_values[ro])
+
+    return conversation
+
+
+def process_data(processed_data, durations):
+    """Prepare all the examples into turned based dialogue that can be used for training"""
+    dataset = []
+
+    for d in processed_data:
+        key = f"{d['example']['video_uid']}-{d['example']['clip_uid']}-{d['example']['annotation_uid']}-{d['example']['language_query_index']}"
+        duration = durations[key]
+        video_filename = d["example"]["video_filename"].replace(
+            "ego4d_vqa_videos", "ego4d_vqa_gen_videos"
+        )
+
+        data_point = {
+            "id": d["example"]["id"],
+            "video": video_filename,
+            "ego4d_video_uid": d["example"]["video_uid"],
+            "ego4d_clip_uid": d["example"]["clip_uid"],
+            "ego4d_annotation_uid": d["example"]["annotation_uid"],
+            "ego4d_language_query_index": d["example"]["language_query_index"],
+            "duration_(s)": duration,
+            "human_annotated": False,
+            "conversations": prepare_turns(d),
+        }
+
+        data_point["category_question_answer_tuples"] = d["processed_examples"]
+
+        dataset.append(data_point)
+
+    # shuffle the dataset
+    random.shuffle(dataset)
+
+    # now reindex the ids
+    for idx, d in enumerate(dataset):
+        d["id"] = idx
+
+    return dataset
+
+
+################################################################################
+# Parse arguments
+parser = argparse.ArgumentParser(description="")
+parser.add_argument(
+    "--ego4d_path",
+    type=str,
+    default="../data/ego4d.json",
+    help="Path to ego4d.json. Default: ../data/ego4d.json",
+)
+parser.add_argument(
+    "--ego4d_nlq_path",
+    type=str,
+    default="../data/nlq_train.json",
+    help="Path to nlq_train.json. Default: ../data/nlq_train.json",
+)
+parser.add_argument(
+    "--gemini_data_path",
+    type=str,
+    default="gemini_responses.json",
+    help="Path to Gemini responses. Default: gemini_responses.json",
+)
+parser.add_argument(
+    "--output_path",
+    type=str,
+    default="ego4d_nlq_train.gemini_pro_1.5.json",
+    help="Output path for processed data. Default: ego4d_nlq_train.gemini_pro_1.5.json",
+)
+
+args = parser.parse_args()
+EGO4D_META_PATH = args.ego4d_path
+NLQ_TRAIN_PATH = args.ego4d_nlq_path
+GEN_DATA_PATH = args.gemini_data_path
+OUTPUT_PATH = args.output_path
+
+
+################################################################################
+# Load the required data
+with open(EGO4D_META_PATH, "r") as file:
+    meta = json.load(file)
+video_uid2video = {video["video_uid"]: video for video in meta["videos"]}
+
+with open(NLQ_TRAIN_PATH, "r") as file:
+    train = json.load(file)
+
+with open(GEN_DATA_PATH, "r") as file:
+    gen_data = json.load(file)
+
+
+################################################################################
+# Process data
+processed_data, missing_data = preprocess_data(gen_data)
+durations = prepare_durations(train, missing_data, video_uid2video)
+dataset = process_data(processed_data, durations)
+
+# Dump to JSON file
+with open(OUTPUT_PATH, "w") as f:
+    json.dump(dataset, f, indent=2)
+
+print(f"Outputted {len(dataset)} to {OUTPUT_PATH}")
+print("Done!")
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..6b1ad64
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,4 @@
+boto3==1.28.44
+moviepy==1.0.3
+tqdm==4.65.0
+vertexai==1.48.0