diff --git a/.gitattributes b/.gitattributes index c7d9f3332a950355d5a77d85000f05e6f45435ea..338964404899f86fb20b81c252a8c23cbd5dc26e 100644 --- a/.gitattributes +++ b/.gitattributes @@ -32,3 +32,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +MiniGPT_4.pdf filter=lfs diff=lfs merge=lfs -text diff --git a/CODEOWNERS b/CODEOWNERS new file mode 100644 index 0000000000000000000000000000000000000000..41016a6bcf7375d0a3fb3115b303791930e93c2d --- /dev/null +++ b/CODEOWNERS @@ -0,0 +1,2 @@ +# Comment line immediately above ownership line is reserved for related gus information. Please be careful while editing. +#ECCN:Open Source \ No newline at end of file diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..9ba97919e5b9568c8b9c42ea85251f01049a220e --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,14 @@ +BSD 3-Clause License + +Copyright (c) 2022 Salesforce, Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + +3. Neither the name of Salesforce.com nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000000000000000000000000000000000000..481e101713e7fef33d177aa5f107480c9919a474 --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,7 @@ +recursive-include minigpt4/configs *.yaml *.json +recursive-include minigpt4/projects *.yaml *.json + +recursive-exclude minigpt4/datasets/download_scripts * +recursive-exclude minigpt4/output * + +include requirements.txt diff --git a/MiniGPT_4.pdf b/MiniGPT_4.pdf new file mode 100644 index 0000000000000000000000000000000000000000..3ec99b0bf46a595b643e132daff041d77437a8ea --- /dev/null +++ b/MiniGPT_4.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5ef8de6eeefee0dcf33dea53e8de2a884939dc20617362052232e7a223941260 +size 6614913 diff --git a/README.md b/README.md index 37c851295b02e70829e1089ad0a3c26458f0ce0c..75e26209461a0c2ff662712dca8fc6c19335ae12 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,139 @@ ---- -title: Minigpt4 -emoji: 🌖 -colorFrom: purple -colorTo: pink -sdk: gradio -sdk_version: 3.24.1 -app_file: app.py -pinned: false ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference +# MiniGPT-4: Enhancing Vision-language Understanding with Advanced Large Language Models +[Deyao Zhu](https://tsutikgiau.github.io/)* (On Job Market!), [Jun Chen](https://junchen14.github.io/)* (On Job Market!), Xiaoqian Shen, Xiang Li, and Mohamed Elhoseiny. *Equal Contribution + +**King Abdullah University of Science and Technology** + +[[Project Website]](https://minigpt-4.github.io/) [[Paper]](MiniGPT_4.pdf) [Online Demo] + + +## Online Demo + +Chat with MiniGPT-4 around your images + + +## Examples + | | | +:-------------------------:|:-------------------------: +![find wild](examples/wop_2.png) | ![write story](examples/ad_2.png) +![solve problem](examples/fix_1.png) | ![write Poem](examples/rhyme_1.png) + + + + + +## Abstract +The recent GPT-4 has demonstrated extraordinary multi-modal abilities, such as directly generating websites from handwritten text and identifying humorous elements within images. These features are rarely observed in previous vision-language models. We believe the primary reason for GPT-4's advanced multi-modal generation capabilities lies in the utilization of a more advanced large language model (LLM). To examine this phenomenon, we present MiniGPT-4, which aligns a frozen visual encoder with a frozen LLM, Vicuna, using just one projection layer. +Our findings reveal that MiniGPT-4 processes many capabilities similar to those exhibited by GPT-4 like detailed image description generation and website creation from hand-written drafts. Furthermore, we also observe other emerging capabilities in MiniGPT-4, including writing stories and poems inspired by given images, providing solutions to problems shown in images, teaching users how to cook based on food photos, etc. +These advanced capabilities can be attributed to the use of a more advanced large language model. +Furthermore, our method is computationally efficient, as we only train a projection layer using roughly 5 million aligned image-text pairs and an additional 3,500 carefully curated high-quality pairs. + + + + + + + + +## Getting Started +### Installation + +1. Prepare the code and the environment + +Git clone our repository, creating a python environment and ativate it via the following command + +```bash +git clone https://github.com/Vision-CAIR/MiniGPT-4.git +cd MiniGPT-4 +conda env create -f environment.yml +conda activate minigpt4 +``` + + +2. Prepare the pretrained Vicuna weights + +The current version of MiniGPT-4 is built on the v0 versoin of Vicuna-13B. +Please refer to their instructions [here](https://huggingface.co/lmsys/vicuna-13b-delta-v0) to obtaining the weights. +The final weights would be in a single folder with the following structure: + +``` +vicuna_weights +├── config.json +├── generation_config.json +├── pytorch_model.bin.index.json +├── pytorch_model-00001-of-00003.bin +... +``` + +Then, set the path to the vicuna weight in the model config file +[here](minigpt4/configs/models/minigpt4.yaml#L21) at Line 21. + +3. Prepare the pretrained MiniGPT-4 checkpoint + +To play with our pretrained model, download the pretrained checkpoint +[here](https://drive.google.com/file/d/1a4zLvaiDBr-36pasffmgpvH5P7CKmpze/view?usp=share_link). +Then, set the path to the pretrained checkpoint in the evaluation config file +in [eval_configs/minigpt4.yaml](eval_configs/minigpt4.yaml#L15) at Line 15. + + + + + +### Launching Demo Locally + +Try out our demo [demo.py](app.py) with your images for on your local machine by running + +``` +python demo.py --cfg-path eval_configs/minigpt4.yaml +``` + + + + + +### Training +The training of MiniGPT-4 contains two-stage alignments. +In the first stage, the model is trained using image-text pairs from Laion and CC datasets +to align the vision and language model. To download and prepare the datasets, please check +[here](dataset/readme.md). +After the first stage, the visual features are mapped and can be understood by the language +model. +To launch the first stage training, run + +```bash +torchrun --nproc-per-node NUM_GPU train.py --cfg-path train_config/minigpt4_stage1_laion.yaml +``` + +In the second stage, we use a small high quality image-text pair dataset created by ourselves +and convert it to a conversation format to further align MiniGPT-4. +Our second stage dataset can be download from +[here](https://drive.google.com/file/d/1RnS0mQJj8YU0E--sfH08scu5-ALxzLNj/view?usp=share_link). +After the second stage alignment, MiniGPT-4 is able to talk about the image in +a smooth way. +To launch the second stage alignment, run + +```bash +torchrun --nproc-per-node NUM_GPU train.py --cfg-path train_config/minigpt4_stage2_align.yaml +``` + + + + + +## Acknowledgement + ++ [BLIP2](https://huggingface.co/docs/transformers/main/model_doc/blip-2) ++ [Vicuna](https://github.com/lm-sys/FastChat) + + +If you're using MiniGPT-4 in your research or applications, please cite using this BibTeX: +```bibtex +@misc{zhu2022minigpt4, + title={MiniGPT-4: Enhancing the Vision-language Understanding with Advanced Large Language Models}, + author={Deyao Zhu and Jun Chen and Xiaoqian Shen and xiang Li and Mohamed Elhoseiny}, + year={2023}, +} +``` + +## License +This repository is built on [Lavis](https://github.com/salesforce/LAVIS) with BSD 3-Clause License +[BSD 3-Clause License](LICENSE.txt) diff --git a/app.py b/app.py new file mode 100644 index 0000000000000000000000000000000000000000..7e73082911f187477fee7e45cf9ec86ae919cd61 --- /dev/null +++ b/app.py @@ -0,0 +1,146 @@ +import argparse +import os +import random + +import numpy as np +import torch +import torch.backends.cudnn as cudnn +import gradio as gr + +from minigpt4.common.config import Config +from minigpt4.common.dist_utils import get_rank +from minigpt4.common.registry import registry +from minigpt4.conversation.conversation import Chat, CONV_VISION + +# imports modules for registration +from minigpt4.datasets.builders import * +from minigpt4.models import * +from minigpt4.processors import * +from minigpt4.runners import * +from minigpt4.tasks import * + + +def parse_args(): + parser = argparse.ArgumentParser(description="Demo") + parser.add_argument("--cfg-path", type=str, default='eval_configs/minigpt4.yaml', help="path to configuration file.") + parser.add_argument( + "--options", + nargs="+", + help="override some settings in the used config, the key-value pair " + "in xxx=yyy format will be merged into config file (deprecate), " + "change to --cfg-options instead.", + ) + args = parser.parse_args() + return args + + +def setup_seeds(config): + seed = config.run_cfg.seed + get_rank() + + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + + cudnn.benchmark = False + cudnn.deterministic = True + + +# ======================================== +# Model Initialization +# ======================================== + +print('Initializing Chat') +cfg = Config(parse_args()) + +model_config = cfg.model_cfg +model_cls = registry.get_model_class(model_config.arch) +model = model_cls.from_config(model_config).to('cuda:0') + +vis_processor_cfg = cfg.datasets_cfg.cc_align.vis_processor.train +vis_processor = registry.get_processor_class(vis_processor_cfg.name).from_config(vis_processor_cfg) +chat = Chat(model, vis_processor) +print('Initialization Finished') + +# ======================================== +# Gradio Setting +# ======================================== + +def gradio_reset(chat_state, img_list): + chat_state.messages = [] + img_list = [] + return None, gr.update(value=None, interactive=True), gr.update(placeholder='Please upload your image first', interactive=False), gr.update(value="Upload & Start Chat", interactive=True), chat_state, img_list + +def upload_img(gr_img, text_input, chat_state): + if gr_img is None: + return None, None, gr.update(interactive=True) + chat_state = CONV_VISION.copy() + img_list = [] + llm_message = chat.upload_img(gr_img, chat_state, img_list) + return gr.update(interactive=False), gr.update(interactive=True, placeholder='Type and press Enter'), gr.update(value="Start Chatting", interactive=False), chat_state, img_list + +def gradio_ask(user_message, chatbot, chat_state): + if len(user_message) == 0: + return gr.update(interactive=True, placeholder='Input should not be empty!'), chatbot, chat_state + chat.ask(user_message, chat_state) + chatbot = chatbot + [[user_message, None]] + return '', chatbot, chat_state + + +def gradio_answer(chatbot, chat_state, img_list, num_beams, temperature): + llm_message = chat.answer(conv=chat_state, img_list=img_list, max_new_tokens=1000, num_beams=num_beams, temperature=temperature)[0] + chatbot[-1][1] = llm_message + return chatbot, chat_state, img_list + +title = """

Demo of MiniGPT-4

""" +description = """

This is the demo of MiniGPT-4. Upload your images and start chatting!

""" +article = """Paper: Here +Code: Here +Project Page: Here +""" + +#TODO show examples below + +with gr.Blocks() as demo: + gr.Markdown(title) + gr.Markdown(description) + gr.Markdown(article) + + with gr.Row(): + with gr.Column(scale=0.5): + image = gr.Image(type="pil") + upload_button = gr.Button(value="Upload & Start Chat", interactive=True, variant="primary") + clear = gr.Button("Restart") + + num_beams = gr.Slider( + minimum=1, + maximum=16, + value=5, + step=1, + interactive=True, + label="beam search numbers)", + ) + + temperature = gr.Slider( + minimum=0.1, + maximum=2.0, + value=1.0, + step=0.1, + interactive=True, + label="Temperature", + ) + + + with gr.Column(): + chat_state = gr.State() + img_list = gr.State() + chatbot = gr.Chatbot(label='MiniGPT-4') + text_input = gr.Textbox(label='User', placeholder='Please upload your image first', interactive=False) + + upload_button.click(upload_img, [image, text_input, chat_state], [image, text_input, upload_button, chat_state, img_list]) + + text_input.submit(gradio_ask, [text_input, chatbot, chat_state], [text_input, chatbot, chat_state]).then( + gradio_answer, [chatbot, chat_state, img_list, num_beams, temperature], [chatbot, chat_state, img_list] + ) + clear.click(gradio_reset, [chat_state, img_list], [chatbot, image, text_input, upload_button, chat_state, img_list], queue=False) + +demo.launch(share=True, enable_queue=True) \ No newline at end of file diff --git a/create_align_dataset.py b/create_align_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..16a5de1eecb979937692731dd0f13bc85f99d3fd --- /dev/null +++ b/create_align_dataset.py @@ -0,0 +1,134 @@ +import argparse +import os +import json +from tqdm import tqdm +import random +import numpy as np +from PIL import Image +import webdataset as wds +import torch +from torchvision.datasets import ImageFolder +import torchvision.transforms as transforms + +import openai +from tenacity import ( + retry, + stop_after_attempt, + wait_random_exponential, +) # for exponential backoff + +from minigpt4.common.config import Config +from minigpt4.common.registry import registry +from minigpt4.conversation.conversation import Chat + +openai.api_key = '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' + + +def prepare_chatgpt_message(task_prompt, paragraph): + messages = [{"role": "system", "content": task_prompt}, + {"role": "user", "content": paragraph}] + return messages + + +@retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(6)) +def call_chatgpt(chatgpt_messages, max_tokens=200, model="gpt-3.5-turbo"): + response = openai.ChatCompletion.create(model=model, messages=chatgpt_messages, temperature=0.7, max_tokens=max_tokens) + reply = response['choices'][0]['message']['content'] + total_tokens = response['usage']['total_tokens'] + return reply, total_tokens + + +def main(args): + + print('Initializing Chat') + cfg = Config(args) + + model_config = cfg.model_cfg + model_cls = registry.get_model_class(model_config.arch) + model = model_cls.from_config(model_config).to('cuda:{}'.format(args.device)) + + ckpt_path = '/ibex/project/c2133/vicuna_ckpt_test/Vicuna_pretrain_stage2_cc/20230405233_3GPU40kSTEP_MAIN/checkpoint_3.pth' + ckpt = torch.load(ckpt_path) + msg = model.load_state_dict(ckpt['model'], strict=False) + + + vis_processor_cfg = cfg.datasets_cfg.cc_combine.vis_processor.train + vis_processor = registry.get_processor_class(vis_processor_cfg.name).from_config(vis_processor_cfg) + + text_processor_cfg = cfg.datasets_cfg.laion.text_processor.train + text_processor = registry.get_processor_class(text_processor_cfg.name).from_config(text_processor_cfg) + + chat = Chat(model, vis_processor, args.device) + print('Initialization Finished') + + + + texts = {} + negative_list = [] + + for i in tqdm(range(args.begin_id, args.end_id)): + image = Image.open(os.path.join(args.save_dir, 'image/{}.jpg'.format(i))).convert('RGB') + + fix_prompt = \ + "Fix the error in the given paragraph. " \ + "Remove any repeating sentences, meanless characters, not English sentences, and so on." \ + "Remove unnecessary repetition." \ + "Rewrite any incomplete sentences." \ + "Return directly the results WITHOUT explanation." \ + "Return directly the input paragraph if it is already correct WITHOUT explanation." + + answers = [] + answer_tokens = 0 + chat.reset() + chat.upload_img(image) + chat.ask("Describe this image in detail. Give as many details as possible. Say everything you see.") + answer, tokens = chat.answer() + answers.append(answer) + answer_tokens += tokens + if len(answer_tokens) < 80: + chat.ask("Continue") + answer, answer_token = chat.answer() + answers.append(answer) + answer_tokens += tokens + answer = ' '.join(answers) + + chatgpt_message = prepare_chatgpt_message(fix_prompt, answer) + improved_answer, num_token = call_chatgpt(chatgpt_message) + + if 'already correct' in improved_answer: + if 'repetition' in improved_answer: + continue + improved_answer = answer + if 'incomplete' in improved_answer or len(improved_answer) < 50: + negative_list.append(improved_answer) + else: + texts[i] = improved_answer + + with open(os.path.join(args.save_dir, "cap_{}_{}.json".format(args.begin_id, args.end_id)), "w") as outfile: + # write the dictionary to the file in JSON format + json.dump(texts, outfile) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Create Alignment") + + parser.add_argument("--cfg-path", default='train_config/minigpt4_stage2_align.yaml') + parser.add_argument("--save-dir", default="/ibex/project/c2133/blip_dataset/image_alignment") + parser.add_argument("--begin-id", type=int) + parser.add_argument("--end-id", type=int) + parser.add_argument("--device", type=int) + parser.add_argument( + "--options", + nargs="+", + help="override some settings in the used config, the key-value pair " + "in xxx=yyy format will be merged into config file (deprecate), " + "change to --cfg-options instead.", + ) + + args = parser.parse_args() + + print("begin_id: ", args.begin_id) + print("end_id: ", args.end_id) + print("device:", args.device) + + main(args) diff --git a/dataset/convert_cc_sbu.py b/dataset/convert_cc_sbu.py new file mode 100644 index 0000000000000000000000000000000000000000..8c325ed3afa3ddb81c5535b5a6febc23d3d5ceee --- /dev/null +++ b/dataset/convert_cc_sbu.py @@ -0,0 +1,20 @@ +import json +import csv + +# specify input and output file paths +input_file = 'ccs_synthetic_filtered_large.json' +output_file = 'ccs_synthetic_filtered_large.tsv' + +# load JSON data from input file +with open(input_file, 'r') as f: + data = json.load(f) + +# extract header and data from JSON +header = data[0].keys() +rows = [x.values() for x in data] + +# write data to TSV file +with open(output_file, 'w') as f: + writer = csv.writer(f, delimiter='\t') + writer.writerow(header) + writer.writerows(rows) diff --git a/dataset/convert_laion.py b/dataset/convert_laion.py new file mode 100644 index 0000000000000000000000000000000000000000..b793579ce276b72a4313bba4f237b8cb0becb294 --- /dev/null +++ b/dataset/convert_laion.py @@ -0,0 +1,20 @@ +import json +import csv + +# specify input and output file paths +input_file = 'laion_synthetic_filtered_large.json' +output_file = 'laion_synthetic_filtered_large.tsv' + +# load JSON data from input file +with open(input_file, 'r') as f: + data = json.load(f) + +# extract header and data from JSON +header = data[0].keys() +rows = [x.values() for x in data] + +# write data to TSV file +with open(output_file, 'w') as f: + writer = csv.writer(f, delimiter='\t') + writer.writerow(header) + writer.writerows(rows) diff --git a/dataset/download_cc_sbu.sh b/dataset/download_cc_sbu.sh new file mode 100644 index 0000000000000000000000000000000000000000..ec102bde61c5a65aafb56545dc3f62d6d6cb4494 --- /dev/null +++ b/dataset/download_cc_sbu.sh @@ -0,0 +1,6 @@ +#!/bin/bash + +img2dataset --url_list ccs_synthetic_filtered_large.tsv --input_format "tsv"\ + --url_col "url" --caption_col "caption" --output_format webdataset\ + --output_folder cc_sbu_dataset --processes_count 16 --thread_count 128 --image_size 256 \ + --enable_wandb True diff --git a/dataset/download_laion.sh b/dataset/download_laion.sh new file mode 100644 index 0000000000000000000000000000000000000000..5de38e2cbbb55083a819374192f2943ec8ead9cd --- /dev/null +++ b/dataset/download_laion.sh @@ -0,0 +1,6 @@ +#!/bin/bash + +img2dataset --url_list laion_synthetic_filtered_large.tsv --input_format "tsv"\ + --url_col "url" --caption_col "caption" --output_format webdataset\ + --output_folder laion_dataset --processes_count 16 --thread_count 128 --image_size 256 \ + --enable_wandb True diff --git a/dataset/readme.md b/dataset/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..7b94182c482b993e0a91d1f0802d2dc901badedb --- /dev/null +++ b/dataset/readme.md @@ -0,0 +1,92 @@ +## Download the filtered Conceptual Captions, SBU, LAION datasets + +### Pre-training datasets download: +We use the filtered synthetic captions prepared by BLIP. For more details about the dataset, please refer to [BLIP](https://github.com/salesforce/BLIP). + +It requires ~2.3T to store LAION and CC3M+CC12M+SBU datasets + +Image source | Filtered synthetic caption by ViT-L +--- | :---: +CC3M+CC12M+SBU | Download +LAION115M | Download + +This will download two json files +``` +ccs_synthetic_filtered_large.json +laion_synthetic_filtered_large.json +``` + +## prepare the data step-by-step + + +### setup the dataset folder and move the annotation file to the data storage folder +``` +export MINIGPT4_DATASET=/YOUR/PATH/FOR/LARGE/DATASET/ +mkdir ${MINIGPT4_DATASET}/cc_sbu +mkdir ${MINIGPT4_DATASET}/laion +mv ccs_synthetic_filtered_large.json ${MINIGPT4_DATASET}/cc_sbu +mv laion_synthetic_filtered_large.json ${MINIGPT4_DATASET}/laion +``` + +### Convert the scripts to data storate folder +``` +cp convert_cc_sbu.py ${MINIGPT4_DATASET}/cc_sbu +cp download_cc_sbu.sh ${MINIGPT4_DATASET}/cc_sbu +cp convert_laion.py ${MINIGPT4_DATASET}/laion +cp download_laion.sh ${MINIGPT4_DATASET}/laion +``` + + +### Convert the laion and cc_sbu annotation file format to be img2dataset format +``` +cd ${MINIGPT4_DATASET}/cc_sbu +python convert_cc_sbu.py + +cd ${MINIGPT4_DATASET}/laion +python convert_laion.py +``` + +### Download the datasets with img2dataset +``` +cd ${MINIGPT4_DATASET}/cc_sbu +sh download_cc_sbu.sh +cd ${MINIGPT4_DATASET}/laion +sh download_laion.sh +``` + + +The final dataset structure + +``` +. +├── ${MINIGPT4_DATASET} +│ ├── cc_sbu +│ ├── convert_cc_sbu.py +│ ├── download_cc_sbu.sh +│ ├── ccs_synthetic_filtered_large.json +│ ├── ccs_synthetic_filtered_large.tsv +│ └── cc_sbu_dataset +│ ├── 00000.tar +│ ├── 00000.parquet +│ ... +│ ├── laion +│ ├── convert_laion.py +│ ├── download_laion.sh +│ ├── laion_synthetic_filtered_large.json +│ ├── laion_synthetic_filtered_large.tsv +│ └── laion_dataset +│ ├── 00000.tar +│ ├── 00000.parquet +│ ... +... +``` + + +## Set up the dataset configuration files + +Then, set up the LAION dataset loading path in [here](../minigpt4/configs/datasets/laion/defaults.yaml#L13) at Line 13 as ${MINIGPT4_DATASET}/laion/laion_dataset/{00000..10488}.tar + +Then, set up the Conceptual Captoin and SBU datasets loading path in [here](../minigpt4/configs/datasets/cc_sbu/defaults.yaml#L13) at Line 13 as ${MINIGPT4_DATASET}/cc_sbu/cc_sbu_dataset/{00000..01255}.tar + + + diff --git a/demo_dev.ipynb b/demo_dev.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..5a0138228afa89fae0f7e9180a81b59871b630fe --- /dev/null +++ b/demo_dev.ipynb @@ -0,0 +1,3491 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "1d3a1f40", + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "import os\n", + "import random\n", + "import requests\n", + "from io import BytesIO\n", + "\n", + "import numpy as np\n", + "from PIL import Image\n", + "import torch\n", + "import torch.backends.cudnn as cudnn\n", + "import gradio as gr\n", + "\n", + "import minigpt4.tasks as tasks\n", + "from minigpt4.common.config import Config\n", + "from minigpt4.common.dist_utils import get_rank, init_distributed_mode\n", + "from minigpt4.common.logger import setup_logger\n", + "from minigpt4.common.optims import (\n", + " LinearWarmupCosineLRScheduler,\n", + " LinearWarmupStepLRScheduler,\n", + ")\n", + "from minigpt4.common.registry import registry\n", + "from minigpt4.common.utils import now\n", + "from minigpt4.conversation.conversation import Conversation, SeparatorStyle, StoppingCriteriaList, StoppingCriteriaSub\n", + "\n", + "# imports modules for registration\n", + "from minigpt4.datasets.builders import *\n", + "from minigpt4.models import *\n", + "from minigpt4.processors import *\n", + "from minigpt4.runners import *\n", + "from minigpt4.tasks import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "af62dac2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "_StoreAction(option_strings=['--options'], dest='options', nargs='+', const=None, default=None, type=None, choices=None, required=False, help='override some settings in the used config, the key-value pair in xxx=yyy format will be merged into config file (deprecate), change to --cfg-options instead.', metavar=None)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "parser = argparse.ArgumentParser(description=\"Demo\")\n", + "parser.add_argument(\"--cfg-path\", required=True, help=\"path to configuration file.\")\n", + "parser.add_argument(\n", + " \"--options\",\n", + " nargs=\"+\",\n", + " help=\"override some settings in the used config, the key-value pair \"\n", + " \"in xxx=yyy format will be merged into config file (deprecate), \"\n", + " \"change to --cfg-options instead.\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1d50fdae", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initializing Chat\n", + "Loading VIT\n", + "Loading VIT Done\n", + "Loading Q-Former\n", + "Loading Q-Former Done\n", + "Loading LLAMA\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ac6a4d59a5bc49b3ba420537c3a7dbc0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading checkpoint shards: 0%| | 0/3 [00:00 Could you describe the contents of this image for me? ###Assistant: \n", + "Load BLIP2-LLM Checkpoint: /ibex/project/c2133/vicuna_ckpt_test/Vicuna_stage3_align/20230412191_laion_ckpt3/checkpoint_1.pth\n", + "Initialization Finished\n" + ] + } + ], + "source": [ + "print('Initializing Chat')\n", + "cfg = Config(parser.parse_args(['--cfg-path', 'eval_configs/minigpt4.yaml']))\n", + "\n", + "model_config = cfg.model_cfg\n", + "model_cls = registry.get_model_class(model_config.arch)\n", + "model = model_cls.from_config(model_config).to('cuda:0')\n", + "\n", + "vis_processor_cfg = cfg.datasets_cfg.cc_align.vis_processor.train\n", + "vis_processor = registry.get_processor_class(vis_processor_cfg.name).from_config(vis_processor_cfg)\n", + "\n", + "# chat = Chat(model, vis_processor)\n", + "print('Initialization Finished')" + ] + }, + { + "cell_type": "code", + "execution_count": 462, + "id": "ea32d3b0", + "metadata": {}, + "outputs": [], + "source": [ + "ckpt_path = '/ibex/project/c2133/vicuna_ckpt_test/Vicuna_prompt_stage2_quick_laion/20230411114/checkpoint_0.pth'\n", + "# ckpt_path = '/ibex/project/c2133/vicuna_ckpt_test/Vicuna_prompt_stage2_laion/20230410145/checkpoint_0.pth'\n", + "ckpt_path = '/ibex/project/c2133/vicuna_ckpt_test/Vicuna_prompt_stage2_cc/20230408151_3GPU50kStep_Multi/checkpoint_19.pth'\n", + "ckpt_path = '/ibex/project/c2133/vicuna_ckpt_test/Vicuna_pretrain_stage2_cc/20230405233_3GPU40kSTEP_MAIN/checkpoint_3.pth'\n", + "ckpt_path = '/ibex/project/c2133/vicuna_ckpt_test/Vicuna_stage3_align/20230412172/checkpoint_0.pth'\n", + "ckpt_path = '/ibex/project/c2133/vicuna_ckpt_test/Vicuna_stage3_align/20230412191_laion_ckpt3/checkpoint_1.pth'\n", + "# ckpt_path = '/ibex/project/c2133/vicuna_ckpt_test/Vicuna_stage3_align/20230412203_laion_prompt_ckpt12/checkpoint_1.pth'\n", + "# ckpt_path = '/ibex/project/c2133/vicuna_ckpt_test/minigpt4_stage2_align/20230415090/checkpoint_2.pth'\n", + "\n", + "\n", + "ckpt = torch.load(ckpt_path)\n", + "msg = model.load_state_dict(ckpt['model'], strict=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "41e3a310", + "metadata": {}, + "outputs": [], + "source": [ + "# from transformers.generation.configuration_utils import GenerationConfig\n", + "# new_generation_config = GenerationConfig.from_model_config(chat.model.llama_model.config)\n", + "# chat.model.llama_model.generation_config\n", + "# new_generation_config" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a1a25602", + "metadata": {}, + "outputs": [], + "source": [ + "CONV_VISION = Conversation(\n", + " system=\"Give the following image: ImageContent. \"\n", + " \"You will be able to see the image once I provide it to you. Please answer my questions.\",\n", + " roles=(\"Human\", \"Assistant\"),\n", + " messages=[],\n", + " offset=2,\n", + " sep_style=SeparatorStyle.SINGLE,\n", + " sep=\"###\",\n", + ")\n", + "\n", + "\n", + "class Chat:\n", + " def __init__(self, model, vis_processor, device='cuda:0'):\n", + " self.device = device\n", + " self.model = model\n", + " self.vis_processor = vis_processor\n", + "\n", + " self.conv = CONV_VISION.copy()\n", + " self.img_list = []\n", + " self.raw_answers = []\n", + "\n", + " stop_words_ids = [torch.tensor([835]).to(self.device),\n", + " torch.tensor([2277, 29937]).to(self.device)] # '###' can be encoded in two different ways.\n", + " self.stopping_criteria = StoppingCriteriaList([StoppingCriteriaSub(stops=stop_words_ids)])\n", + "\n", + " def reset(self):\n", + " self.conv.messages = []\n", + " self.img_list = []\n", + " # self.img_list = [img for img in self.conv.system_img]\n", + " self.raw_answers = []\n", + "\n", + " def ask(self, text):\n", + " if len(self.conv.messages) > 0 and self.conv.messages[-1][0] == self.conv.roles[0] \\\n", + " and self.conv.messages[-1][1][-6:] == '': # last message is image.\n", + " self.conv.messages[-1][1] = ' '.join([self.conv.messages[-1][1], text])\n", + " else:\n", + " self.conv.append_message(self.conv.roles[0], text)\n", + "\n", + " def answer(self, max_new_tokens=200, num_beams=5, min_length=1, top_p=0.9,\n", + " repetition_penalty=1.0, length_penalty=1, temperature=1):\n", + " self.conv.append_message(self.conv.roles[1], None)\n", + " embs = self.get_context_emb()\n", + " outputs = self.model.llama_model.generate(\n", + " inputs_embeds=embs,\n", + " max_new_tokens=max_new_tokens,\n", + " stopping_criteria=self.stopping_criteria,\n", + " num_beams=num_beams,\n", + " min_length=min_length,\n", + " top_p=top_p,\n", + " repetition_penalty=repetition_penalty,\n", + " length_penalty=length_penalty,\n", + " temperature=temperature,\n", + " )\n", + " output_token = outputs[0]\n", + " if output_token[0] == 0:\n", + " output_token = output_token[1:]\n", + " output_text = self.model.llama_tokenizer.decode(output_token, add_special_tokens=False)\n", + " self.raw_answers.append(output_text)\n", + " output_text = output_text.split('###')[0] # remove the stop sign '###'\n", + " output_text = output_text.split('Assistant:')[-1].strip()\n", + " self.conv.messages[-1][1] = output_text\n", + " return output_text, output_token.cpu().numpy()\n", + "\n", + " def upload_img(self, image):\n", + " if isinstance(image, str): # is a image path\n", + " raw_image = Image.open(image).convert('RGB')\n", + " image = self.vis_processor(raw_image).unsqueeze(0).to(self.device)\n", + " elif isinstance(image, Image.Image):\n", + " raw_image = image\n", + " image = self.vis_processor(raw_image).unsqueeze(0).to(self.device)\n", + " elif isinstance(image, torch.Tensor):\n", + " if len(image.shape) == 3:\n", + " image = image.unsqueeze(0)\n", + " image = image.to(self.device)\n", + " \n", + " image_emb, _ = self.model.encode_img(image)\n", + " self.img_list.append(image_emb)\n", + " self.conv.append_message(self.conv.roles[0], \"\")\n", + " msg = \"Received.\"\n", + " # self.conv.append_message(self.conv.roles[1], msg)\n", + " return msg\n", + "\n", + " def get_context_emb(self):\n", + " prompt = self.conv.get_prompt()\n", + " prompt_segs = prompt.split('')\n", + " assert len(prompt_segs) == len(self.img_list) + 1, \"Unmatched numbers of image placeholders and images.\"\n", + " seg_tokens = [\n", + " self.model.llama_tokenizer(\n", + " seg, return_tensors=\"pt\", add_special_tokens=i==0).to(self.device).input_ids # only add bos to the first seg\n", + " for i, seg in enumerate(prompt_segs)\n", + " ]\n", + " seg_embs = [self.model.llama_model.model.embed_tokens(seg_t) for seg_t in seg_tokens]\n", + " mixed_embs = [emb for pair in zip(seg_embs[:-1], self.img_list) for emb in pair] + [seg_embs[-1]]\n", + "\n", + " mixed_embs = torch.cat(mixed_embs, dim=1)\n", + " return mixed_embs" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9f4378a8", + "metadata": {}, + "outputs": [], + "source": [ + "import requests\n", + "from io import BytesIO" + ] + }, + { + "cell_type": "code", + "execution_count": 362, + "id": "99b48b03", + "metadata": {}, + "outputs": [], + "source": [ + "chat = Chat(model, vis_processor)" + ] + }, + { + "cell_type": "code", + "execution_count": 489, + "id": "b157b73b", + "metadata": {}, + "outputs": [], + "source": [ + "img_url = 'https://newsfeed.time.com/wp-content/uploads/sites/9/2010/11/grandma-dj.jpg?w=720&h=480&crop=1'\n", + "img_url = 'https://newsfeed.time.com/wp-content/uploads/sites/9/2010/11/grandma-dj.jpg?w=720&h=480&crop=1'" + ] + }, + { + "cell_type": "code", + "execution_count": 497, + "id": "aa998179", + "metadata": {}, + "outputs": [], + "source": [ + "response = requests.get(img_url)\n", + "image_buffer = BytesIO(response.content)\n", + "image = Image.open(image_buffer).convert(\"RGB\")" + ] + }, + { + "cell_type": "code", + "execution_count": 504, + "id": "4822c36d", + "metadata": {}, + "outputs": [], + "source": [ + "chat.reset()" + ] + }, + { + "cell_type": "code", + "execution_count": 505, + "id": "c0cff044", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Received.'" + ] + }, + "execution_count": 505, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "chat.upload_img(image)" + ] + }, + { + "cell_type": "code", + "execution_count": 506, + "id": "2afe06ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sure, here's a rap song based on the image you provided:\n", + "\n", + "Verse 1:\n", + "I'm an old lady, but I'm still flyin'\n", + "I've got my headphones on and I'm feelin' high\n", + "I'm in the studio, makin' some beats\n", + "I'm the queen of hip hop, can't nobody touch my feet\n", + "\n", + "Chorus:\n", + "I'm the grandma of rap, I'm still spittin' fire\n", + "I've got my green jacket on, I'm lookin' fly\n", + "I've got my sunglasses on, I'm shining bright\n", + "I'm the queen of the game, I'm makin' it right\n", + "\n", + "Verse 2:\n", + "I've been in the game for years, I've paid my dues\n", + "I've got a microphone in my hand and I'm singin' the blues\n", + "I've got the crowd in the palm of my hand\n", + "I'm the queen of rap, I'm takin' over the land\n", + "\n", + "Chorus:\n", + "I'm the grandma of rap, I'm still spittin' fire\n", + "I've got my green jacket on, I'm lookin' fly\n", + "I've got my sunglasses on, I'm shining bright\n", + "I'm the queen of the game, I'm makin' it right\n", + "\n", + "Verse 3:\n", + "I've got my beats in my headphones, I'm feelin' the vibe\n", + "I'm in the zone, I'm in my element, I'm in my ride\n", + "I'm the queen of rap, I'm in control\n", + "I'm makin' hits, I'm takin' over the world\n", + "\n", + "Chorus:\n", + "I'm the grandma of rap, I'm still spittin' fire\n", + "I've got my green jacket on, I'm lookin' fly\n", + "I've got my sunglasses on, I'm shining bright\n", + "I'm the queen of the game, I'm makin' it right\n", + "\n", + "Outro:\n", + "I'm the grandma of rap, I'm still spittin' fire\n", + "I've got my green jacket on, I'm lookin' fly\n", + "I've got my sunglasses on, I'm shining bright\n", + "I'm the queen of the game, I'm makin' it right.\n" + ] + } + ], + "source": [ + "# chat.ask(\"How old is this DJ in this image?\")\n", + "chat.ask(\"Can you write me a master rap song that rhymes very well based on this image?\")\n", + "a, a_token = chat.answer(max_new_tokens=800, temperature=2)\n", + "print(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "id": "4805b5a8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "962bd3c0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 508, + "id": "b10e1974", + "metadata": {}, + "outputs": [], + "source": [ + "conv = []\n", + "for role, message in chat.conv.messages:\n", + " message = message.split('')[-1].strip()\n", + " conv.append(message)\n", + " \n", + "total_data.append({'img': img_url, 'conv': conv})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b04b8155", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 509, + "id": "5144bf9f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'img': 'https://brandforma.com/wp-content/uploads/2019/04/flamingo_logo_for_sale.png',\n", + " 'conv': ['What do you think of this logo design.',\n", + " \"The logo design is simple and minimalistic, with a pink line drawing of a flamingo standing on one leg in the water. The design is clean and easy to recognize, making it suitable for use in various contexts such as a logo for a beach resort or a flamingo-themed event. The use of a flamingo as a symbol adds a touch of whimsy and fun to the design, making it memorable and eye-catching. Overall, it's a well-designed logo that effectively communicates the brand's message.\"]},\n", + " {'img': 'https://i.imgflip.com/c37k1.jpg',\n", + " 'conv': ['Explain why this meme is funny.',\n", + " 'This meme is funny because it shows a dog laying on the floor with its head resting on its paws, as if it is tired or sleepy. The caption, \"monday just monday,\" adds to the humor by suggesting that the dog is feeling the same way as many people do on Mondays, which are often considered to be the most dreaded day of the week. The meme is relatable and humorous, making it a popular one among internet users.']},\n", + " {'img': 'https://contentcenter-drcn.dbankcdn.cn/img/pub_1/Browser_contentImg_1019_8/3f/v3/10510195ebff150e9eb42d6ae2da8bac4979d23/5e1515931d554ff1bcdf94a82e5ef223_5_1/hd.webp',\n", + " 'conv': ['Describe this image as detailed as possible.',\n", + " 'The image shows a busy city street with a clock tower in the background. The street is lined with shops and restaurants on both sides. There are several motorcycles parked on the side of the road, and people are walking down the street. The clock tower has a large clock face with Roman numerals and a small spire on top. The buildings on either side of the street have ornate facades and balconies. The street is paved with cobblestones and there are streetlights on either side of the road. The sky is clear and blue, and there are a few clouds in the distance.']},\n", + " {'img': 'https://cdn.ttv.com.tw/manasystem/FileData/News/c232e38d-0239-4681-bc28-0f55a3331e3d.jpg',\n", + " 'conv': ['Describe this image as detailed as possible.',\n", + " \"The image shows a group of musicians performing on stage in front of a large audience. The musicians are playing electric guitars and are wearing black and white clothing. The audience is made up of people of different ages and ethnicities who are watching the performance and taking photos with their phones. The stage is lit up with bright lights and there is a large screen displaying the band's name and lyrics in Chinese characters. The atmosphere is lively and energetic, with the audience cheering and singing along to the music.\"]},\n", + " {'img': 'https://newsfeed.time.com/wp-content/uploads/sites/9/2010/11/grandma-dj.jpg?w=720&h=480&crop=1',\n", + " 'conv': ['Can you write me a master rap song that rhymes very well based on this image?',\n", + " \"Sure, here's a rap song based on the image you provided:\\n\\nVerse 1:\\nI'm an old lady, but I'm still flyin'\\nI've got my headphones on and I'm feelin' high\\nI'm in the studio, makin' some beats\\nI'm the queen of hip hop, can't nobody touch my feet\\n\\nChorus:\\nI'm the grandma of rap, I'm still spittin' fire\\nI've got my green jacket on, I'm lookin' fly\\nI've got my sunglasses on, I'm shining bright\\nI'm the queen of the game, I'm makin' it right\\n\\nVerse 2:\\nI've been in the game for years, I've paid my dues\\nI've got a microphone in my hand and I'm singin' the blues\\nI've got the crowd in the palm of my hand\\nI'm the queen of rap, I'm takin' over the land\\n\\nChorus:\\nI'm the grandma of rap, I'm still spittin' fire\\nI've got my green jacket on, I'm lookin' fly\\nI've got my sunglasses on, I'm shining bright\\nI'm the queen of the game, I'm makin' it right\\n\\nVerse 3:\\nI've got my beats in my headphones, I'm feelin' the vibe\\nI'm in the zone, I'm in my element, I'm in my ride\\nI'm the queen of rap, I'm in control\\nI'm makin' hits, I'm takin' over the world\\n\\nChorus:\\nI'm the grandma of rap, I'm still spittin' fire\\nI've got my green jacket on, I'm lookin' fly\\nI've got my sunglasses on, I'm shining bright\\nI'm the queen of the game, I'm makin' it right\\n\\nOutro:\\nI'm the grandma of rap, I'm still spittin' fire\\nI've got my green jacket on, I'm lookin' fly\\nI've got my sunglasses on, I'm shining bright\\nI'm the queen of the game, I'm makin' it right.\"]}]" + ] + }, + "execution_count": 509, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total_data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2d6dbcf", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "1d4af846", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[['Human', ' What do you think of this logo design.'],\n", + " ['Assistant',\n", + " \"The logo design is simple and minimalistic, with a pink line drawing of a flamingo standing on one leg in the water. The design is clean and easy to recognize, making it suitable for use in various contexts such as a logo for a beach resort or a flamingo-themed event. The use of a flamingo as a symbol adds a touch of whimsy and fun to the design, making it memorable and eye-catching. Overall, it's a well-designed logo that effectively communicates the brand's message.\"]]" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "chat.conv.messages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "90a8aa05", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1019cfaf", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 434, + "id": "b50f755c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'img': 'https://iso.500px.com/wp-content/uploads/2016/11/stock-photo-159533631-1500x1000.jpg',\n", + " 'conv': ['Can you write me a beautiful poem about this image?',\n", + " \"Sure, here is a poem about the image you provided:\\n\\nA man sits on a hill, with his dog by his side\\nThe sun sets behind them, casting a golden light\\nThe city below is bustling, but they are at peace\\nEnjoying the moment, in each other's embrace\\n\\nThe man's arms are wrapped around his furry friend\\nAs they watch the world go by, with a gentle bend\\nThe dog's head rests on the man's shoulder\\nA symbol of their unbreakable bond, forever\\n\\nThe sky is ablaze with color, a beautiful sight\\nBut it's the love between the man and his dog that shines bright\\nIt's a moment of pure joy, a memory to keep\\nForever etched in their hearts, as they sit and weep\\n\\nSo let us cherish these moments, with our four-legged friends\\nFor they bring us so much happiness, until the very end\\nAnd even when they're gone, their love will live on\\nIn the memories we hold, forever and strong.\"]},\n", + " {'img': 'https://f.i.uol.com.br/fotografia/2023/03/25/1679774982641f55063b5cd_1679774982_2x3_md.jpg',\n", + " 'conv': ['Who is him?',\n", + " 'The person in the image is Pope Francis, the current Pope of the Catholic Church.',\n", + " 'Based on this photo, write me a short rap song that rhymes well.',\n", + " \"(Verse 1)\\n\\nI'm Pope Francis, the man of the hour\\nWalking down the street in my puffer coat\\nPeople stare, they can't believe their eyes\\nSeeing the Pope in all this disguise\\n\\n(Chorus)\\n\\nPope Francis, the man of the hour\\nWalking down the street in my puffer coat\\nPeople stare, they can't believe their eyes\\nSeeing the Pope in all this disguise\\n\\n(Verse 2)\\n\\nI'm the leader of the Catholic Church\\nBut today I'm dressed like a bum\\nI'm spreading the word of God in my own way\\nWalking down the street in my puffer coat today\\n\\n(Chorus)\\n\\nPope Francis, the man of the hour\\nWalking down the street in my puffer coat\\nPeople stare, they can't believe their eyes\\nSeeing the Pope in all this disguise\\n\\n(Bridge)\\n\\nI may be the Pope, but I'm just like you\\nI walk the streets, I do my thing too\\nI may be different, but we're all the same\\nWalking down the street in my puffer coat in this game\\n\\n(Chorus)\\n\\nPope Francis, the man of the hour\\nWalking down the street in my puffer coat\\nPeople stare, they can't believe their eyes\\nSeeing the Pope in all this disguise\"]},\n", + " {'img': 'https://i.pinimg.com/236x/d5/fa/3d/d5fa3d292466eeb048048c42d774b03f--hot-dog-buns-hot-dogs.jpg',\n", + " 'conv': ['Why does this image look funny?',\n", + " \"The image looks funny because it appears to be a small dog sitting on a plate of bread, which is an unusual and humorous sight. The dog's expression and the way it is sitting on the bread also adds to the humor of the image.\\n\\nIt's possible that the image was intended to be humorous or playful, or it could simply be a candid shot of a dog enjoying a meal. Regardless of the intention behind the image, it is likely to elicit a smile or chuckle from anyone who sees it.\"]},\n", + " {'img': 'https://i.etsystatic.com/5220905/r/il/6e5166/2603519433/il_fullxfull.2603519433_7i6k.jpg',\n", + " 'conv': ['Can you write a story around this image for my child?',\n", + " 'Sure, here\\'s a story based on the image:\\n\\nOnce upon a time, there was a brown bear, a white rabbit, and a black cat who lived in a forest. They were good friends and loved to spend time together. One day, they decided to have a picnic under a tree. The bear brought some honey, the rabbit brought some carrots, and the cat brought some milk.\\n\\nAs they sat around the table, the bear said, \"I\\'m so hungry, I could eat a whole honey pot!\" The rabbit giggled and said, \"I\\'m so hungry, I could eat a whole bag of carrots!\" The cat meowed and said, \"I\\'m so hungry, I could drink a whole bowl of milk!\"\\n\\nThey all laughed and dug in to their food. The bear loved the honey, the rabbit loved the carrots, and the cat loved the milk. They were all very happy and content.\\n\\nAfter they finished their meal, they decided to go for a walk in the forest. They came across a stream and the bear said, \"Let\\'s go for a swim!\" The rabbit and cat were a bit hesitant, but the bear convinced them to join in.\\n\\nThey all had a great time swimming and playing in the water. The bear loved to splash around, the rabbit loved to dive, and the cat loved to chase the splashes. They were all very happy and had a lot of fun.\\n\\nAfter their swim, they decided to go back to their picnic spot and have some more food. They sat around the table and the bear said, \"I\\'m so hungry, I could eat a whole honey pot again!\" The rabbit giggled and said, \"I\\'m so hungry, I could eat a whole bag of carrots again!\" The cat meowed and said, \"I\\'m so hungry, I could drink a whole bowl of milk again!\"\\n\\nThey all laughed and dug in to their food. They were all very happy and content. And they lived happily ever after.']},\n", + " {'img': 'https://media.discordapp.net/attachments/1008571152479826060/1096134597626036274/Sam1_A_Monk_has_a_huge_brain_Full_body_shot_pray_sharp_colors_r_dc6d519b-edc6-48b2-9401-b58998f311b6.png?width=1280&height=1280',\n", + " 'conv': ['I designed a character for my game as shown in the image. Can you write me a background story for him?',\n", + " \"Sure, here's a possible background story for the character in the image:\\n\\nThe monk in the image is a wise and enlightened being who has spent many years studying the workings of the mind. He has spent countless hours meditating and contemplating the nature of consciousness, and as a result, he has gained a deep understanding of the inner workings of the mind.\\n\\nThe brain in his hand is a symbol of his deep understanding of the mind. He uses it to help others understand the nature of their own thoughts and emotions, and to guide them on the path to enlightenment.\\n\\nDespite his great wisdom, the monk is a humble and compassionate being. He uses his knowledge to help others, and is always willing to share his insights with those who seek his guidance. He is a revered figure in his community, and many come to him seeking his help and guidance.\\n\\nThe monk's robes are a symbol of his commitment to his spiritual path. He wears them as a reminder of his vows of poverty, chastity, and obedience, and as a symbol of his commitment to living a life of service to others.\\n\\nOverall, the monk in the image is a wise and compassionate being who has dedicated his life to understanding the nature of the mind and helping others on the path to enlightenment.\"]},\n", + " {'img': 'https://cdn.britannica.com/55/188355-050-D5E49258/Salvatore-Corsitto-The-Godfather-Marlon-Brando-Francis.jpg',\n", + " 'conv': ['Can you give me a short introduction to this movie?',\n", + " 'The Godfather is a classic American crime drama film directed by Francis Ford Coppola and released in 1972. It is based on the novel of the same name by Mario Puzo and follows the story of the Corleone family, a powerful mafia clan in New York City. The film stars Marlon Brando as the patriarch of the family, Vito Corleone, and Al Pacino as his son, Michael Corleone. The Godfather is known for its iconic performances, memorable dialogue, and its portrayal of the American mafia lifestyle. It is considered one of the greatest films of all time and has had a lasting impact on popular culture.']},\n", + " {'img': 'https://therecipecritic.com/wp-content/uploads/2020/01/broiled_lobster.jpg',\n", + " 'conv': ['How should I make something like this?',\n", + " 'To make this dish, you will need the following ingredients:\\n\\n* 4 large lobsters\\n* 2 tablespoons olive oil\\n* 2 cloves garlic, minced\\n* 1 teaspoon dried thyme\\n* 1 teaspoon dried oregano\\n* 1/2 teaspoon paprika\\n* Salt and pepper, to taste\\n* 4 lemon wedges, for serving\\n\\n1. Preheat the oven to 400°F (200°C).\\n2. In a large baking dish, toss the lobsters with the olive oil, garlic, thyme, oregano, paprika, salt, and pepper.\\n3. Roast the lobsters in the preheated oven for 20-25 minutes, or until they are cooked through.\\n4. Remove the lobsters from the oven and let them cool for a few minutes.\\n5. Serve the lobsters with the lemon wedges on the side.\\n\\nI hope this helps! Let me know if you have any other questions.']},\n", + " {'img': 'https://www.kazoart.com/blog/wp-content/uploads/2019/04/Dali-persistance-of-memory.jpg',\n", + " 'conv': ['Can you give me a detailed introduction to this painting, and also the artist?',\n", + " 'This is a surrealist painting by Salvador Dali, titled \"The Persistence of Memory.\" It is one of Dali\\'s most famous works and is considered one of the greatest works of surrealist art. The painting depicts melting clocks and other objects in a desert landscape, with the sun setting in the background. The overall theme of the painting is the idea that time is not fixed and that it can be distorted and manipulated. The painting is considered a masterpiece of surrealism and is widely recognized as one of Dali\\'s most important works.\\n\\nThe artist, Salvador Dali, was a Spanish surrealist painter and sculptor. He is considered one of the most important figures in the history of art and is known for his unique and imaginative works. Dali was born in 1904 in Spain and began painting at a young age. He is best known for his surrealist paintings, which often feature melting clocks, distorted figures, and other strange and fantastical elements. Dali\\'s work has had a significant influence on the art world and continues to be widely admired and studied today.']}]" + ] + }, + "execution_count": 434, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total_data" + ] + }, + { + "cell_type": "code", + "execution_count": 383, + "id": "61f4bb45", + "metadata": {}, + "outputs": [], + "source": [ + "import yaml" + ] + }, + { + "cell_type": "code", + "execution_count": 510, + "id": "e9179d57", + "metadata": {}, + "outputs": [], + "source": [ + "to_save = {j: info for j, info in enumerate(total_data)}" + ] + }, + { + "cell_type": "code", + "execution_count": 511, + "id": "fb7537e8", + "metadata": {}, + "outputs": [], + "source": [ + "with open('/home/zhud/project/blip2/demo_example/others3/samples.yaml', 'w') as f:\n", + " yaml.dump(to_save, f)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5e8f3c30", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2e7034f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dfa0ad2c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 244, + "id": "81458521", + "metadata": {}, + "outputs": [], + "source": [ + "total_data = []" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab09fdf3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "91f0b955", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 186, + "id": "fb2f8452", + "metadata": {}, + "outputs": [], + "source": [ + "text = \\\n", + "\"### Human: What's your name?\" \\\n", + "\"### Assistant: \"\n", + "\n", + "\n", + "llama_tokens = model.llama_tokenizer(\n", + " text, \n", + " return_tensors=\"pt\", \n", + " ).to('cuda:0')" + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "id": "0e2976a9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "### Human: What's your name?### Assistant: ​\n", + "\n", + "I'm sorry, I am an AI language model and do not have a\n" + ] + } + ], + "source": [ + "outputs = model.llama_model.generate(\n", + " input_ids=llama_tokens.input_ids,\n", + " query_embeds=None,\n", + " attention_mask=llama_tokens.attention_mask,\n", + " max_new_tokens=20,\n", + " )\n", + "output_text = model.llama_tokenizer.decode(outputs[0])\n", + "print(output_text)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "037a901f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 132, + "id": "b2f93372", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'input_ids': [1533, 25518, 29958], 'attention_mask': [1, 1, 1]}" + ] + }, + "execution_count": 132, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "chat.model.llama_tokenizer('', add_special_tokens=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "3b6f10df", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['Assistant: This is a photograph of a person standing in the rain on a city street. The person is holding an umbrella and is standing in the middle of the street. There are tall buildings on either side of the street and the sky is cloudy.\\n\\nThe photograph was taken in the evening, as the sky is dark and the streetlights are on. The rain is coming down in large drops and the person is standing in the middle of the street, looking down at their phone. The buildings on either side of the street are tall and have many windows. The street is wet and there are puddles on the ground.\\n###',\n", + " 'Assistant: This is a photograph of a horse standing in front of a barn. The horse is standing on its hind legs and has a large harness on its back. There are two men standing next to the horse, one of them is holding a whip. The other man is holding a bucket of water. The barn has a large door and a small window on the side. The sky is cloudy and there are trees in the background.\\n###',\n", + " 'Assistant: The horse is standing on its hind legs and has a large harness on its back.\\n###',\n", + " 'Assistant: A whiteboard with a joke written on it\\nthe joke is written in black ink on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na joke written on a whiteboard\\na',\n", + " 'Human: a man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit drinking a glass of wine\\na man in a suit',\n", + " \"Human: a man in a suit drinking a glass of wine\\nsays when people say they don't drink wine they're\\n###\",\n", + " \"Human: a man in a suit holding a glass of wine\\nsays when people say they're not drinking, they're\\n###\"]" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "chat.raw_answers" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "53264936", + "metadata": {}, + "outputs": [], + "source": [ + "# ========================================\n", + "# Gradio Setting\n", + "# ========================================\n", + "def gradio_reset():\n", + " chat.reset()\n", + " return None\n", + "\n", + "\n", + "def gradio_ask(user_message, chatbot):\n", + " chat.ask(user_message)\n", + " chatbot = chatbot + [[user_message, None]]\n", + " return '', chatbot\n", + "\n", + "\n", + "def gradio_answer(chatbot):\n", + " llm_message = chat.answer(1000)\n", + " chatbot[-1][1] = llm_message\n", + " return chatbot\n", + "\n", + "\n", + "def gradio_upload_img(gr_img, chatbot):\n", + " llm_message = chat.upload_img(gr_img)\n", + " chatbot = chatbot + [[(gr_img,), None]]\n", + " chatbot[-1][1] = llm_message\n", + " return chatbot\n", + "\n", + "\n", + "with gr.Blocks() as demo:\n", + " gr.Markdown(\"## GPT-4 Mini\")\n", + " with gr.Row():\n", + " with gr.Column(scale=0.5):\n", + " image = gr.Image(type=\"filepath\")\n", + " upload = gr.Button(\"Upload Image\")\n", + " clear = gr.Button(\"Restart\")\n", + " with gr.Column():\n", + " chatbot = gr.Chatbot()\n", + " text_input = gr.Textbox()\n", + "\n", + " text_input.submit(gradio_ask, [text_input, chatbot], [text_input, chatbot], queue=False).then(\n", + " gradio_answer, chatbot, chatbot\n", + " )\n", + "\n", + " upload.click(gradio_upload_img, [image, chatbot], chatbot)\n", + " clear.click(gradio_reset, None, chatbot, queue=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e34fc8ce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running on local URL: http://127.0.0.1:7860\n", + "Running on public URL: https://6261e2449344bfbe7a.gradio.live\n", + "\n", + "This share link expires in 72 hours. For free permanent hosting and GPU upgrades (NEW!), check out Spaces: https://huggingface.co/spaces\n" + ] + }, + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/zhud/anaconda3/envs/eye/lib/python3.9/site-packages/transformers/generation/utils.py:1219: UserWarning: You have modified the pretrained model configuration to control generation. This is a deprecated strategy to control generation and will be removed soon, in a future version. Please use a generation configuration file (see https://huggingface.co/docs/transformers/main_classes/text_generation)\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "demo.launch(share=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "86943179", + "metadata": {}, + "outputs": [], + "source": [ + "demo.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b815e52c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "233c9f93", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4298ba71", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6eea726c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "b3251a51", + "metadata": {}, + "source": [ + "### Alignment Dataset Prepare" + ] + }, + { + "cell_type": "code", + "execution_count": 256, + "id": "11b36de5", + "metadata": {}, + "outputs": [], + "source": [ + "import openai\n", + "from tenacity import (\n", + " retry,\n", + " stop_after_attempt,\n", + " wait_random_exponential,\n", + ") # for exponential backoff\n", + "openai.api_key = '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'\n", + "\n", + "\n", + "def prepare_chatgpt_message(task_prompt, paragraph):\n", + " messages = [{\"role\": \"system\", \"content\": task_prompt},\n", + " {\"role\": \"user\", \"content\": paragraph}]\n", + " return messages\n", + "\n", + "\n", + "@retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(6))\n", + "def call_chatgpt(chatgpt_messages, max_tokens=200, model=\"gpt-3.5-turbo\"):\n", + " response = openai.ChatCompletion.create(model=model, messages=chatgpt_messages, temperature=0.7, max_tokens=max_tokens)\n", + " reply = response['choices'][0]['message']['content']\n", + " total_tokens = response['usage']['total_tokens']\n", + " return reply, total_tokens" + ] + }, + { + "cell_type": "code", + "execution_count": 413, + "id": "b30c475e", + "metadata": {}, + "outputs": [], + "source": [ + "import webdataset as wds\n", + "from lavis.datasets.datasets.base_dataset import BaseDataset\n", + "class PILDataset(BaseDataset):\n", + " def __init__(self, vis_processor, text_processor, location):\n", + " super().__init__(vis_processor=vis_processor, text_processor=text_processor)\n", + "\n", + " self.inner_dataset = wds.DataPipeline(\n", + " wds.ResampledShards(location),\n", + " wds.tarfile_to_samples(handler=wds.warn_and_continue),\n", + " wds.shuffle(1000, handler=wds.warn_and_continue),\n", + " wds.decode(\"pilrgb\", handler=wds.warn_and_continue),\n", + " wds.to_tuple(\"jpg\", \"json\", handler=wds.warn_and_continue),\n", + " wds.map(self.to_dict, handler=wds.warn_and_continue),\n", + " )\n", + "\n", + " def to_dict(self, sample):\n", + " return {\n", + " \"image\": sample[0],\n", + " \"text_input\": self.text_processor(sample[1][\"caption\"]),\n", + " }\n", + " \n", + "vis_processor_cfg = cfg.datasets_cfg.cc_combine.vis_processor.train\n", + "vis_processor = registry.get_processor_class(vis_processor_cfg.name).from_config(vis_processor_cfg)\n", + "\n", + "text_processor_cfg = cfg.datasets_cfg.cc_combine.text_processor.train\n", + "text_processor = registry.get_processor_class(text_processor_cfg.name).from_config(text_processor_cfg)\n", + "\n", + "dataset = PILDataset(vis_processor, text_processor, cfg.datasets_cfg.cc_combine.build_info.storage).inner_dataset\n" + ] + }, + { + "cell_type": "code", + "execution_count": 332, + "id": "5b967080", + "metadata": {}, + "outputs": [], + "source": [ + "from tqdm import tqdm" + ] + }, + { + "cell_type": "code", + "execution_count": 291, + "id": "fd8e84f5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'/ibex/project/c2133/blip_dataset/laion_1b/laion_gpu/{00000..10488}.tar'" + ] + }, + "execution_count": 291, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cfg.datasets_cfg.laion.build_info.storage" + ] + }, + { + "cell_type": "code", + "execution_count": 408, + "id": "18315556", + "metadata": {}, + "outputs": [], + "source": [ + "builder = registry.get_builder_class('cc_combine')(cfg.datasets_cfg['cc_combine'])\n", + "dataset = builder.build_datasets()['train']" + ] + }, + { + "cell_type": "code", + "execution_count": 416, + "id": "2f6386b4", + "metadata": {}, + "outputs": [], + "source": [ + "data_iter = iter(dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 417, + "id": "bd81ba4c", + "metadata": {}, + "outputs": [], + "source": [ + "data_point = next(data_iter)" + ] + }, + { + "cell_type": "code", + "execution_count": 418, + "id": "247b872f", + "metadata": {}, + "outputs": [], + "source": [ + "image = data_point['image']" + ] + }, + { + "cell_type": "code", + "execution_count": 419, + "id": "51d9fb01", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 419, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 324, + "id": "b0d47ad6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'a hiker pauses along the rim of the grand canyon'" + ] + }, + "execution_count": 324, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_point['text_input']" + ] + }, + { + "cell_type": "code", + "execution_count": 381, + "id": "fffa9245", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [02:14<00:00, 6.72s/it]\n" + ] + } + ], + "source": [ + "save_dir = '/ibex/project/c2133/blip_dataset/image_alignment'\n", + "\n", + "\n", + "image_list = []\n", + "text_list = []\n", + "description_list = []\n", + "negative_list = []\n", + "verify_list = []\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "for i in tqdm(range(20)):\n", + " data_point = next(data_iter)\n", + " image = data_point['image']\n", + " text = data_point['text_input']\n", + " \n", + " fix_prompt = \\\n", + " \"Fix the error in given paragraph. \" \\\n", + " \"Remove any repeating sentences, meanless characters, not English sentences, and so on.\" \\\n", + " \"Rewrite any incompleted sentences.\" \\\n", + " \"Return directly the results WITHOUT explaination.\" \\\n", + " \"Return directly the input paragraph if it is already correct WITHOUT explaination.\"\n", + "\n", + " answers = []\n", + " answer_tokens = 0\n", + " chat.reset()\n", + " chat.upload_img(image)\n", + " chat.ask(\"Describe this image in detail. Give as many details as possible. Say everything you see.\")\n", + " answer, tokens = chat.answer()\n", + " answers.append(answer)\n", + " answer_tokens += tokens\n", + " if len(answer_tokens) < 80:\n", + " chat.ask(\"Continue\")\n", + " answer, answer_token = chat.answer()\n", + " answers.append(answer)\n", + " answer_tokens += tokens\n", + " answer = ' '.join(answers)\n", + "\n", + " chatgpt_message = prepare_chatgpt_message(fix_prompt, answer)\n", + " improved_answer, num_token = call_chatgpt(chatgpt_message)\n", + " \n", + " if 'is already correct' in improved_answer:\n", + " improved_answer = answer\n", + " if 'incomplete' in improved_answer or len(improved_answer) < 50:\n", + " negative_list.append(improved_answer)\n", + " else:\n", + " image_list.append(image)\n", + " text_list.append(text)\n", + " description_list.append(improved_answer)" + ] + }, + { + "cell_type": "code", + "execution_count": 329, + "id": "1fc5f266", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "' This This is an image of a person hiking on a trail in the grand canyon. The person is wearing a backpack and has a hiking pole in their hand. They are looking out over the canyon, which is visible in the background. The sky is cloudy and there are some dark clouds in the distance. The landscape is rugged and rocky, with steep cliffs and valleys visible in the distance. The trail is narrow and winds through the rocky terrain. There are no other people visible in the image.'" + ] + }, + "execution_count": 329, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "answer" + ] + }, + { + "cell_type": "code", + "execution_count": 330, + "id": "d2651aa6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'This is an image of a person hiking on a trail in the grand canyon. The person is wearing a backpack and has a hiking pole in their hand. They are looking out over the canyon, which is visible in the background. The sky is cloudy and there are some dark clouds in the distance. The landscape is rugged and rocky, with steep cliffs and valleys visible in the distance. The trail is narrow and winds through the rocky terrain. There are no other people visible in the image.'" + ] + }, + "execution_count": 330, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "improved_answer" + ] + }, + { + "cell_type": "code", + "execution_count": 389, + "id": "34b6f1f6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'and protect\" tube also contains NovaMin technology, which is designed to help repair and protect sensitive teeth.'" + ] + }, + "execution_count": 389, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "description_list[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 383, + "id": "320368ce", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['This is an incomplete sentence. Please provide the complete paragraph for correction.',\n", + " 'no specific action or activity taking place.',\n", + " 'The image shows a woman standing in front of a',\n", + " 'touch of sophistication to the look.',\n", + " 'This is an image of a car.',\n", + " 'Input paragraph is incomplete. Please provide a complete paragraph to fix.']" + ] + }, + "execution_count": 383, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "negative_list" + ] + }, + { + "cell_type": "code", + "execution_count": 372, + "id": "ff92e94a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "34" + ] + }, + "execution_count": 372, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len('The input paragraph is incomplete.')" + ] + }, + { + "cell_type": "code", + "execution_count": 420, + "id": "b0223541", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:08<00:00, 583.08it/s]\n" + ] + } + ], + "source": [ + "save_dir = '/ibex/project/c2133/blip_dataset/image_alignment_cc'\n", + "texts = {}\n", + "for i in tqdm(range(5000)):\n", + " data_point = next(data_iter)\n", + " image = data_point['image']\n", + " texts[i] = data_point['text_input']\n", + " image.save(os.path.join(save_dir, \"image/{}.jpg\".format(i)))" + ] + }, + { + "cell_type": "code", + "execution_count": 394, + "id": "12933b52", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: 'spinach and artichoke fippers on a white plate'}" + ] + }, + "execution_count": 394, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 397, + "id": "75971b3c", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "\n", + "\n", + "# open a file in write mode\n", + "with open(os.path.join(save_dir,\"old_cap.json\"), \"w\") as outfile:\n", + " # write the dictionary to the file in JSON format\n", + " json.dump(texts, outfile)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d0eb5390", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d8911c5d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1bdb050e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "744da257", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "131dad16", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 516, + "id": "a88ca86a", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import shutil" + ] + }, + { + "cell_type": "code", + "execution_count": 514, + "id": "56db0857", + "metadata": {}, + "outputs": [], + "source": [ + "with open('/ibex/project/c2133/blip_dataset/image_alignment_cc_prepare/filter_cap.json', 'r') as f:\n", + " caps = json.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 517, + "id": "110b2eb6", + "metadata": {}, + "outputs": [], + "source": [ + "root = '/ibex/project/c2133/blip_dataset/image_alignment_cc_prepare/'\n", + "for content in caps['annotations']:\n", + " src_file = root + 'train/{}.jpg'.format(content['image_id'])\n", + " dest_file = root + 'used_train/{}.jpg'.format(content['image_id'])\n", + " \n", + " shutil.copy(src_file, dest_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 518, + "id": "1824499f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'annotations': [{'image_id': '2',\n", + " 'caption': 'The image shows a man fishing on a lawn next to a river with a bridge in the background. Trees can be seen on the other side of the river, and the sky is cloudy.'},\n", + " {'image_id': '3',\n", + " 'caption': 'This image shows a kitchen with stainless steel appliances, including a refrigerator, oven, and dishwasher. The countertops are made of black granite, and there is a white backsplash behind the stove. The floor is made of beige tiles, and the walls are painted white. There is a door that leads to the outside.'},\n", + " {'image_id': '4',\n", + " 'caption': \"The image shows a group of people walking down a sidewalk, holding signs that read `get scientific right'. They are wearing red shirts and carrying banners with the same message. The people in the image appear to be young adults and children, and they are walking in a line, with some people in front and some behind. The image is taken from a distance, so it's difficult to see their faces, but it's clear that they are all holding up their signs and walking in the same direction. The background of the image is a residential neighborhood with trees and houses visible in the distance.\"},\n", + " {'image_id': '5',\n", + " 'caption': 'This image shows a group of people standing in front of a building with pink and white balloons in the air. The people are dressed in formal attire, with the men wearing black tuxedos and the women wearing white dresses. There is a large tree in the background, and several cars parked in front of the building. The atmosphere of the image is joyful and celebratory.'},\n", + " {'image_id': '8',\n", + " 'caption': 'This image is a cartoon illustration of an astronaut floating in the air with his arms outstretched. The astronaut wears a white spacesuit with a helmet and gloves, and the background is a gradient of light blue and white. This vector illustration can be scaled to any size without losing quality, making it suitable for use in various contexts.'},\n", + " {'image_id': '10',\n", + " 'caption': 'The image depicts two ducks flying over a body of water. One duck is in the foreground and the other is in the background. The duck in the foreground is flying towards the left side of the image, while the duck in the background is flying towards the right side of the image. Both ducks have their wings outstretched and their beaks open, as if they are calling out to each other. The background of the image is a dark blue sky with a few clouds in it. The water below the ducks is a light blue color with some ripples in it. There are some trees on the left side of the image, and some bushes on the right side. Overall, the image is a beautiful depiction of two ducks flying over a peaceful body of water. It could be used as a wallpaper or as part of a larger design.'},\n", + " {'image_id': '11',\n", + " 'caption': 'This image shows a bedroom with a balcony overlooking the ocean. The room has white walls, a wooden floor, and a large glass door that leads to the balcony. The bed is made with white sheets.'},\n", + " {'image_id': '12',\n", + " 'caption': \"The image depicts a watch with a red leather strap, a green dial, and a gold case and buckle. The face of the watch displays two hands, one pointing to 12 o'clock and the other pointing to 6 o'clock, with a small red dot at the 12 o'clock position. The watch is set against a white background.\"},\n", + " {'image_id': '13',\n", + " 'caption': 'The image shows a slice of cheesecake on a red and white checkered plate with a fork next to it. The cheesecake appears to be baked in a cast iron skillet and is topped with a sprinkle of powdered sugar. The plate is sitting on top of a striped napkin on a wooden surface.'},\n", + " {'image_id': '14',\n", + " 'caption': 'This image shows a man in a blue suit and a red tie standing at a podium with his hands in the air. He has a serious expression on his face and is speaking into a microphone. Behind him, there is a blue curtain and a Canadian flag hanging on the wall. The image is well lit and the colors are bright and vivid.'},\n", + " {'image_id': '16',\n", + " 'caption': 'This image shows a silhouette of a crane on top of a building. The crane appears to be lifting something off the roof of the building. The sky in the background appears to be cloudy, with dark clouds in the distance. The crane appears to be made of metal and has a long arm with a hook on the end. The building appears to be made of brick and has several windows on the top floor. There is a ladder leading up to the roof of the building.'},\n", + " {'image_id': '20',\n", + " 'caption': 'This image depicts an open wooden door in the middle of a dark blue room. Light shines through the door and illuminates the surrounding area. The walls are painted light blue, and there are no windows. The floor is tiled, with a small area rug in front of the door. The image creates a sense of mystery and intrigue, leaving the viewer to wonder what lies beyond the open door.'},\n", + " {'image_id': '21',\n", + " 'caption': 'The image shows a young boy sitting at a table with several rolls of toilet paper in front of him. He is wearing a medical face mask.'},\n", + " {'image_id': '22',\n", + " 'caption': 'This image shows a wall made of concrete blocks stacked on top of each other to form a gray, rough-textured solid structure. There are no windows or doors on the wall. It is located on the side of a building with a sidewalk in front of it. No other visible objects are present in the image.'},\n", + " {'image_id': '23',\n", + " 'caption': 'The image shows a beautiful sunset over the ocean, with the sun setting behind a row of palm trees on the horizon. The sky is a mix of orange, pink, and purple hues, with a few clouds scattered throughout. The buildings in the foreground are small, colorful houses with red roofs and white walls, and there are a few people standing on the balconies, watching the sunset. The overall mood of the image is peaceful and serene, with a sense of calm and tranquility.'},\n", + " {'image_id': '24',\n", + " 'caption': 'The image shows a group of planets in different sizes and colors. The largest planet appears to be made up of red and orange flames, while the smaller planets appear to be made up of different shades of blue and green. The planets are arranged in a circular formation, with the largest planet in the center and the smaller planets orbiting around it. The planets appear to be floating in space, with no visible background or other objects in the image.'},\n", + " {'image_id': '25',\n", + " 'caption': 'This image depicts a wooden tree house with a ladder, small window, and door. The roof is made of wooden shingles with a chimney on top. The tree house is situated among trees with a small path leading up to it.'},\n", + " {'image_id': '26',\n", + " 'caption': 'The image displays a wedding cake with white frosting decorated with purple and white flowers on a gold plated tray. The cake is placed on a white tablecloth on a wooden table.'},\n", + " {'image_id': '28',\n", + " 'caption': 'This image shows a female chef preparing food in a professional kitchen. She is wearing a white apron and has a smile on her face. The kitchen is well equipped with stainless steel countertops, sinks, and cooking utensils. There are several pots and pans on the stove, and a cutting board on the counter in front of the chef. The lighting in the kitchen is bright, and there are several windows letting in natural light. The overall atmosphere is clean, organized, and professional.'},\n", + " {'image_id': '29',\n", + " 'caption': 'This is a black and white photograph of a lone tree in the middle of a field. The tree appears to be dead, with no leaves or branches. The sky behind the tree is dark and stormy, with dark clouds and lightning in the distance. The ground is dry and cracked, with no signs of water or life. The overall mood of the image is one of loneliness and desolation.'},\n", + " {'image_id': '31',\n", + " 'caption': 'The image is a video game cover for the game \"Wayne Gretzky\\'s 3D Hockey\". It features a black and white image of a hockey player wearing a red and white jersey with the number 99 on the back. The player is holding a hockey stick and appears to be skating towards the right side of the image. The title of the game, \"Wayne Gretzky\\'s 3D Hockey,\" is written in white letters above the player\\'s head. The game\\'s publisher, Electronic Arts, is written in small white letters at the bottom of the image.'},\n", + " {'image_id': '32',\n", + " 'caption': 'A dark brown horse with a black mane and tail standing on all four legs in a lush green field with tall grass and trees in the distance. The horse has a muscular build and is holding its head high. A white fence surrounds the field in the background.'},\n", + " {'image_id': '33',\n", + " 'caption': 'This image appears to be a waving flag of the country of Poland. The flag is made up of horizontal red and white stripes with a red and white diagonal stripe in the top left corner. There is a small white emblem in the center of the flag, but it is difficult to make out what it is.'},\n", + " {'image_id': '34',\n", + " 'caption': 'This image shows a classroom with students sitting at desks and a teacher standing at the front of the room. The walls are painted white and there are windows on either side of the room, letting in natural light. The room is well lit with fixtures hanging from the ceiling. The desks are arranged in rows and there is a whiteboard at the front. The teacher is holding a piece of chalk and facing the students who are focused on their work and appear engaged in the lesson.'},\n", + " {'image_id': '35',\n", + " 'caption': 'This image is an abstract painting with orange, yellow, and pink colors on a white background. There are circular shapes in different sizes and shades of orange, yellow, and pink on the painting, which appear to be floating on the surface and overlapping each other. Various brush strokes and techniques have been used to create the shapes and colors, resulting in a vibrant and energetic effect.'},\n", + " {'image_id': '37',\n", + " 'caption': 'The image shows a woman holding an old book titled \"The Living and the Dead\" with a serious expression on her face. The book\\'s worn cover suggests signs of wear and tear, and the woman may be reading it with a sense of sadness or nostalgia. The book could be a memoir, biography, or story about people who have passed away and their impact on the living.'},\n", + " {'image_id': '38',\n", + " 'caption': 'The image shows a large, modern hotel building with several floors and a large parking lot in front of it. The hotel\\'s name, \"Courtyard by Marriott,\" is written in large letters on the front of the building. There are several windows on the upper floors, and the building appears to have an atrium or lobby area in the center. The building is surrounded by trees and other landscaping, and there is a sidewalk leading to the entrance.'},\n", + " {'image_id': '39',\n", + " 'caption': 'This image shows a pregnant woman sitting on a bed with her hands on her stomach. She is wearing a white shirt and blue jeans, and has her hair pulled back in a ponytail. The woman is smiling and appears to be in good spirits.'},\n", + " {'image_id': '40',\n", + " 'caption': 'This image shows a woman wearing a black shirt and a purple bow tie. She is posing with her hands on her chin, looking at the camera with a serious expression. The background is black, and there are no other objects or people visible in the image.\\n\\nDescription: This image shows a woman wearing a black shirt and a purple bow tie. She is posing with her hands on her chin, looking at the camera with a serious expression. The background is black, and there are no other objects or people visible in the image.'},\n", + " {'image_id': '43',\n", + " 'caption': \"The image is a black and white silhouette of two swans in the shape of a heart, with the sun in the background. The swans face each other with their necks intertwined, while the sun is in the shape of a circle. It is a simple and elegant image that could be used as a logo for companies or organizations that promote love, romance, relationships, peace, harmony, or unity. Additionally, it could be used as a symbol for wedding or anniversary celebrations, or as a decoration for Valentine's Day or other romantic occasions.\"},\n", + " {'image_id': '44',\n", + " 'caption': 'This image is a colorful and dynamic abstract design with a yellow and green background, various shapes and lines made with brush strokes, and a white circle in the center. The colors used are bright and bold, with a mix of yellow, green, and black, and the shapes and lines are varied and playful. This design could be used for a variety of purposes, such as a background for a website or social media post, or as a design element in a print or digital project.'},\n", + " {'image_id': '45',\n", + " 'caption': \"This is an image of a man wearing a black suit with a white shirt and a black tie. He is standing with his hands in his pockets, looking down at the ground. The image is in black and white, and the background is not visible. The man's face is not visible, but he appears to have a serious expression. He is wearing a black hat that is tilted slightly to the side, and his hair appears to be short and neatly styled. The man's hands are visible in his pockets, and he appears to be wearing black gloves. This image could be used for advertising a clothing brand or promoting a business event.\"},\n", + " {'image_id': '47',\n", + " 'caption': 'In the image, a small wooden hut sits atop a hill, overlooking a valley with mountains in the background. The hut has a small chimney on top, and a person stands on its porch, gazing at the view. The sky is clear and blue, with some distant clouds. The snow-covered mountains have a glacier visible on the side of one of the peaks, while the green valley below has scattered trees.'},\n", + " {'image_id': '48',\n", + " 'caption': 'This is a photograph of a residential street with houses on either side and a car parked on the side of the road. The houses are all different colors and styles, some having red, white, or blue roofs. The road is narrow with no sidewalks. The sky is cloudy with dark clouds in the background.\\n\\nA small white car with tinted windows is parked on the side of the road at an angle with one side facing the camera and the other side facing away.\\n\\nSeveral houses are visible in the background with different colors, styles, and some with balconies or porches. A few trees are also visible.'},\n", + " {'image_id': '49',\n", + " 'caption': 'The image shows a beautiful garden with a fountain in the center. The fountain is surrounded by lush green plants and flowers. Several umbrellas and chairs are set up around the fountain for people to sit and relax in the shade. The sky is dark and cloudy with a few visible stars, creating a peaceful and serene mood.'},\n", + " {'image_id': '50',\n", + " 'caption': \"The image shows a group of young women sitting on a staircase. They are all wearing different clothing, with some wearing red and white outfits and others wearing black and white outfits. They are all smiling and looking at the camera. The image is well lit and the colors are bright and vibrant.\\n\\nThe girls are sitting on the stairs in a casual pose, with their legs crossed and their arms resting on their knees. They are all wearing different shoes, with some wearing sneakers and others wearing boots. The background is white and there are no other objects or people visible in the image.\\n\\nOverall, the image is a cheerful and upbeat representation of a group of young women enjoying each other's company. The bright colors and natural lighting give the image a lively and energetic feel.\"},\n", + " {'image_id': '52',\n", + " 'caption': \"The man in the image is wearing a yellow shirt and brown pants. He is holding a trophy in his left hand and smiling at the camera. There is a red carpet on the ground in front of him. Behind him, there is a wall with a banner that reads 'Indian Film Academy Awards' in white letters. There are several people in the background, some of whom are clapping and others are standing around. The overall mood of the image is celebratory and joyful.\"},\n", + " {'image_id': '55',\n", + " 'caption': 'This is a black and white photograph of a bride and groom standing next to each other in formal attire. The bride is wearing a long, white dress with a veil and carrying a bouquet of flowers. The groom is wearing a black tuxedo with a white shirt and bow tie. They are both smiling at the camera. In the background, there is a large, ornate mirror hanging on the wall.'},\n", + " {'image_id': '56',\n", + " 'caption': 'The image shows a small outdoor office space with a white desk and chair, surrounded by green grass and trees in the background. The walls of the office are made of wood and have large windows that allow natural light to enter. The roof of the office is made of corrugated metal and has a skylight in the center. The floor of the office is made of wood and has a rug on it. There is a white door on the side of the office that leads to the outside.'},\n", + " {'image_id': '57',\n", + " 'caption': 'Input: This image is a painting of a baby boy sitting in a bathtub filled with water. The baby is wearing a white diaper and is looking up at the viewer with a curious expression. The background of the painting is a blue and white tiled bathroom with a sink and toilet in the corner. There is also a shower head on the wall above the bathtub. The overall mood of the painting is calm and peaceful.\\n\\nOutput: This image is a painting of a baby boy sitting in a bathtub filled with water. The baby is wearing a white diaper and is looking up at the viewer with a curious expression. The background of the painting is a blue and white tiled bathroom with a sink, toilet, and shower head. The overall mood of the painting is calm and peaceful.'},\n", + " {'image_id': '58',\n", + " 'caption': 'This image shows a group of people sitting around a long wooden table. They are all wearing casual clothing and appear to be engrossed in conversation. The room has large windows that let in a lot of natural light, and there are plants in pots on the windowsill. The walls are painted a light color, and there are wooden beams on the ceiling. The overall atmosphere of the room is warm and inviting.'},\n", + " {'image_id': '59',\n", + " 'caption': 'The image shows a woman walking down a hallway wearing a yellow dress with a pleated skirt and black shoes. The dress has a v-neckline and short sleeves. The woman is wearing a pair of black sunglasses and has her hair styled in a messy bun. The walls of the hallway are made of white tiles and there are black and white tiles on the floor. There is a large window on one side of the hallway that lets in a lot of natural light. The overall atmosphere of the image is bright and cheerful.'},\n", + " {'image_id': '60',\n", + " 'caption': 'This is a photo of a young woman lying on the floor with her daughter on her back. They are both smiling and looking at the camera. The woman is wearing a white shirt and jeans, and her daughter is wearing a pink dress. They are in a living room with a couch and a coffee table in the background. The walls are painted white and there are some plants in pots on the floor. The lighting is bright and natural, coming from the windows on the left and right sides of the room. The overall mood of the photo is happy and relaxed.'},\n", + " {'image_id': '62',\n", + " 'caption': 'This is a black and white image of a young girl with a crown on her head. She is wearing a white dress and has her hands on her hips. The girl is looking down and has a serious expression on her face.'},\n", + " {'image_id': '63',\n", + " 'caption': 'The image shows a coral reef with a variety of fish swimming around it. The coral reef is made up of many different types of coral, including brain coral, star coral, and mushroom coral. There are also many different types of fish swimming around the reef, including angelfish, butterflyfish, and parrotfish. The water is clear and blue, and there is a lot of sunlight shining down on the reef. The overall scene is very colorful and vibrant, with a lot of different textures and shapes in the coral and fish.'},\n", + " {'image_id': '64',\n", + " 'caption': 'The image shows a bulletin board with various items on it. At the top, there is a red and white sign that reads \"Working Wall.\" Below the sign, there are several pieces of paper and posters pinned to the board. One poster has a drawing of a person with a speech bubble coming out of their mouth. Another poster has a quote that reads, \"Believe in yourself and all that you are. Know that there is something inside you that is greater than any obstacle.\" The board also has several notes and reminders pinned to it, including one that reads, \"Don\\'t let yesterday take up too much of today.\"'},\n", + " {'image_id': '65',\n", + " 'caption': 'The image shows a small body of water in the middle of a snowy forest. The water has a reddish color and is surrounded by trees and rocks. There is a small stream flowing into the water from the left side. The sky is clear and blue.'},\n", + " {'image_id': '66',\n", + " 'caption': 'The woman in the image is wearing ripped jeans and a white t-shirt with a black and white graphic on the front. She is standing with her hands on her hips and looking at the camera. The jeans are frayed at the knees and have holes in the thighs.'},\n", + " {'image_id': '68',\n", + " 'caption': \"The image depicts a construction site with a large crane lifting heavy equipment. The crane has a long arm with a hook at the end, which is being used to lift a large metal beam. The beam is suspended from the crane's hook and is being lowered onto a pile of other metal beams on the ground.\"},\n", + " {'image_id': '69',\n", + " 'caption': 'This is an architectural drawing of a building. It shows the front and side elevations of the building. The building is made up of several floors, each with multiple windows and balconies. There is a central staircase that leads to the upper floors. The building has a symmetrical facade, with a large central entrance and two smaller entrances on either side. The roof is flat and has several skylights.'},\n", + " {'image_id': '70',\n", + " 'caption': 'The image shows a desk with a stack of books on it. There is a red apple sitting on top of the stack of books with a pencil next to it. There is a painting on the wall behind the desk of a landscape with mountains in the background and a river running through it. The window behind the desk looks out onto the same landscape. The room is well lit with natural light coming in from the window.'},\n", + " {'image_id': '71',\n", + " 'caption': 'The building in the image appears to be a multi-storey commercial building with several shops on the ground floor and offices on the upper floors. The facade of the building is white with blue accents, and there are several windows on each floor. The building appears to be well-maintained with clean windows and fresh paint. There are several people walking on the sidewalk and a few cars parked on the street, suggesting a bustling commercial area with a mix of shops and offices.'},\n", + " {'image_id': '72',\n", + " 'caption': 'This image shows a doctor and a patient sitting at a table in a hospital or clinic. The doctor is wearing a white lab coat and has a stethoscope around his neck. The patient is wearing a pink headscarf and is seated in front of the doctor. There is a table between them with various medical equipment on it, including a syringe and a vial of liquid. The room has a white wall and a window with blinds in the background.'},\n", + " {'image_id': '73',\n", + " 'caption': 'The image shows a woman The woman has long, wavy, blonde hair and is wearing a grey sweater. She has a serious expression and is looking directly at the camera. The background is dark and the room appears to be dimly lit. There are no other objects or people visible in the image.'},\n", + " {'image_id': '75',\n", + " 'caption': 'The image shows a group of men wearing black suits and orange socks standing in a circle. One of the men is wearing a white shirt and black pants, while the others are wearing black pants and white shirts. They are all looking at the camera and smiling. The background is a brick wall with graffiti on it.'},\n", + " {'image_id': '77',\n", + " 'caption': 'This image shows a dirt road surrounded by pine trees. Two cars are parked on the side of the road. The road is in good condition with no visible potholes or debris. The trees on either side are tall and full, providing shade. The sky is clear and blue with a few fluffy clouds visible in the distance.'},\n", + " {'image_id': '78',\n", + " 'caption': 'The image shows a cluster of glowing green mushrooms of various shapes and sizes growing out of the ground in the dark. The mushrooms overlap each other, creating an eerie and mysterious atmosphere.'},\n", + " {'image_id': '79',\n", + " 'caption': 'The image shows a night sky with stars and constellations visible in the sky. The constellations are labeled with their names, such as Orion, Cassiopeia, and Andromeda. The stars in the sky are also visible, with some of them labeled with their names, such as Alpha Centauri and Betelgeuse. The sky appears to be clear, with no clouds or other obstructions visible.'},\n", + " {'image_id': '80',\n", + " 'caption': 'This image shows a dining room with dark wood paneling on the walls.'},\n", + " {'image_id': '82',\n", + " 'caption': 'The image shows a pink slice of cake with a crumbly texture on a plate with a fork on top. The plate is on a table with a white tablecloth, and there is a cake stand with more slices of cake in the background.'},\n", + " {'image_id': '84',\n", + " 'caption': 'This image is a geometric pattern made up of triangles arranged in a symmetrical pattern. The triangles are white and made up of straight lines against a light gray background. The image gives a modern and simple feel.'},\n", + " {'image_id': '85',\n", + " 'caption': 'This image is a quote from the book of Psalms in the Bible, which reads, \"For the Lord your God is a sun and shield; the Lord bestows favor and honor. No good thing does he withhold from those who walk uprightly\" (Psalm 84:11). The quote is written in black ink on a white background.'},\n", + " {'image_id': '86',\n", + " 'caption': 'the second row are all tails up. The tails of the coins in the first row face the heads of the coins in the second row, and vice versa.'},\n", + " {'image_id': '87',\n", + " 'caption': 'The image is outdoors.\\n* There is a clear blue sky in the background.'},\n", + " {'image_id': '88',\n", + " 'caption': 'This image shows two people sitting at a desk in front of two computer monitors in an office or workspace with white walls, ceiling, and floor. The people are dressed in business attire, with the woman wearing a blue shirt and black pants, and the man wearing a white shirt and black pants. Both are looking at the computer screens intently, with the woman pointing at something on the left monitor and the man looking at something on the right monitor.'},\n", + " {'image_id': '89',\n", + " 'caption': 'This image shows a bowl of noodles with shrimp, mushrooms, and other vegetables, cooked and ready to eat. The bowl is sitting on a dark surface, likely a table or countertop. No other items are visible in the image.'},\n", + " {'image_id': '90',\n", + " 'caption': 'The image shows a storefront window with posters of various musicians and bands displayed on it. The posters are of different sizes and designs, with some featuring images of the musicians and others featuring their names and album covers. The posters are arranged in a haphazard manner, creating a vibrant and colorful display in the window.'},\n", + " {'image_id': '91',\n", + " 'caption': 'This image shows a woman walking down a city street wearing a white coat, black boots, and carrying a black handbag. The street is lined with tall buildings, trees, and parked cars. The sky is cloudy, and there are no other people visible.'},\n", + " {'image_id': '92',\n", + " 'caption': 'The image shows a cartoon fox pulling a sled with a Christmas tree through a snowy forest. The fox wears a red scarf and has a happy expression. Pine trees are in the background and the sky is cloudy.'},\n", + " {'image_id': '93',\n", + " 'caption': 'The image shows a floor plan of a two bedroom, two bathroom apartment with an open concept living and dining area, and a kitchen with an island. The bedrooms are located at the back of the apartment, with one having a walk in closet and the other having a balcony. The bathrooms are located at the front of the apartment, with one having a shower and the other having a bathtub. There is also a laundry room with a washer and dryer. The apartment has hardwood floors throughout and a large balcony with a view of the city.'},\n", + " {'image_id': '94',\n", + " 'caption': 'This image shows a group of women wearing pink hats standing in front of a market stall that sells various types of jewelry, including necklaces, bracelets, and earrings. The women are looking at the jewelry on display, and one of them is holding a pair of earrings. The background of the image is filled with other market stalls and people walking by.'},\n", + " {'image_id': '96',\n", + " 'caption': 'This is a black and white image of a military font, consisting of various block-style letters and numbers in different sizes and styles, arranged in a stylized manner, and standing out against the white background.'},\n", + " {'image_id': '97',\n", + " 'caption': 'This image depicts a group of people dressed in traditional Mexican clothing, including a woman with a guitar and a man with a sombrero. They are standing in front of a campfire and there are several horses in the background. The overall tone of the image is warm and inviting, with the orange and yellow flames of the fire casting a warm glow on the faces of the people.'},\n", + " {'image_id': '98',\n", + " 'caption': 'The image shows a group of football players in maroon and gold uniforms walking onto the field. They are carrying their helmets in their hands and walking in a line, with one player leading the way and the others following behind. The field is green with white lines on it. The stadium is in the background and there are people in the stands watching the game.'},\n", + " {'image_id': '99',\n", + " 'caption': 'This is a black and white photograph of a woman carrying a small child on her back as they walk down a dirt road surrounded by trees. The woman is wearing a white shirt and blue jeans, and the child is wearing a yellow shirt and blue overalls. The woman is smiling, and the child is looking up at her with a happy expression. There are trees on either side of the road, and the sky is visible in the background.'},\n", + " {'image_id': '101',\n", + " 'caption': 'The image shows a small island in the middle of the ocean, with palm trees and coral reefs surrounding it. There is a small boat floating in the water near the island, with fish swimming around it. The sky is dark and there is a full moon in the background.\\n\\nThe colors used in the image are mostly shades of blue and green, with some brown and yellow for the sand and coral. The overall mood of the image is peaceful and serene, with a sense of calmness and tranquility. The image could be used to depict a tropical paradise or a secluded island getaway.'},\n", + " {'image_id': '103',\n", + " 'caption': \"This image shows a bride standing in a park, wearing a white wedding dress and holding a bouquet of flowers. The bride's veil is blowing in the wind and her hair is styled in loose waves. The trees in the background are covered in green leaves and there is a path leading through the park. The colors are bright and vivid.\"},\n", + " {'image_id': '105',\n", + " 'caption': 'The image shows a close up view of a flower. The flower appears to be in full bloom and is a vibrant pink color. The petals are delicately arranged and the center of the flower is a darker pink. The image is taken from a low angle, giving the viewer a sense of the size and beauty of the flower.\\n\\nThe flower appears to be in full bloom and is a vibrant pink color. The petals are delicately arranged and the center of the flower is a darker pink. The image is taken from a low angle, giving the viewer a sense of the size and beauty of the flower.'},\n", + " {'image_id': '107',\n", + " 'caption': 'The image shows a watch with a silver case, black leather strap, white dial, black hands and hour markers, and a small red dot on the face of the watch.'},\n", + " {'image_id': '108',\n", + " 'caption': \"This image is a sunset over a body of water with a large bridge in the distance. The sun is setting behind the bridge, casting a warm orange glow over the water. The sky is filled with clouds, some of which are lit up by the sun's rays. There are no boats or other objects visible in the water. The bridge appears to be a suspension bridge, with cables running from the towers to the deck. The deck is wide and appears to be made of concrete or asphalt. The towers are tall and slender, with cables running from the top of each tower down to the deck. The bridge appears to be in good condition, with no visible damage or wear. The orange and pink hues of the sky contrast nicely with the deep blue of the water.\"},\n", + " {'image_id': '110',\n", + " 'caption': 'This is an image of a group of investors watching a number on a screen. They appear to be interested and focused on the information being presented. The image is in black and white, with the investors in suits and ties sitting at a table in front of a large screen displaying the number. There are no other details visible in the image.'},\n", + " {'image_id': '111',\n", + " 'caption': 'This image shows a person watering a small plant in a pot. The person is holding a watering can and spraying water onto the soil around the plant. There are other potted plants in the background, and a greenhouse or other structure can be seen in the distance.'},\n", + " {'image_id': '112',\n", + " 'caption': 'The image shows a red 2020 Audi S7 Sportback parked in front of a mountain range at sunset. The car has a sleek and modern design with sharp lines and a bold front grille. It has large alloy wheels and a spoiler on the back. The windows are tinted and the car has a panoramic sunroof. The car is parked on a rocky terrain with mountains in the background.'},\n", + " {'image_id': '113',\n", + " 'caption': \"The image shows a watch with an olive green nylon strap and a black dial. The dial has white hour markers and hands, as well as a date display at the 6 o'clock position and a small seconds subdial at the 9 o'clock position. The watch has a stainless steel case.\"},\n", + " {'image_id': '118',\n", + " 'caption': 'The woman in the image is wearing a black bikini and standing in front of a tall, spiky cactus. She poses with her hands on her hips, showcasing her long, dark hair. The bikini top features a deep V-neckline, while the bottoms are high-waisted.'},\n", + " {'image_id': '119',\n", + " 'caption': 'The image shows a yellow blimp flying in the sky with the words \"The Rolling Stones\" written on the side. The blimp has a large mouth with a tongue sticking out, and it appears to be smiling. The sky is a bright blue and there are a few clouds in the background. The Rolling Stones are a British rock band that formed in 1962. The band consists of Mick Jagger, Keith Richards, Charlie Watts, and Ronnie Wood. They have released many hit songs, including \"Satisfaction,\" \"Jumpin\\'Jack Flash,\" and \"Brown Sugar.\" The Rolling Stones are considered one of the most influential and iconic bands in rock music history.'},\n", + " {'image_id': '120',\n", + " 'caption': 'The image shows a wooden surface with various decorations on it. There are gold and silver stars hanging from the ceiling, as well as a red and white deer head hanging on the wall. There is also a white ceramic mug sitting on the wooden surface.'},\n", + " {'image_id': '121',\n", + " 'caption': 'The image shows a soccer game with two teams playing. The goalkeeper for the white team is diving to his left to make a save and stop the ball from going into the net. The ball is coming from the right side of the image. The blue team is trying to score while the white team is trying to defend.'},\n", + " {'image_id': '122',\n", + " 'caption': 'The image shows a group of children walking around the world, carrying books and backpacks. They are smiling and seem to be enjoying their journey. The background is a blue sky with clouds, and there are no other objects or people in the image.\\n\\nThe children are dressed in different clothing, with some wearing uniforms and others wearing casual clothes. They all have backpacks on their backs and are holding books in their hands. The image has a cartoon style, with exaggerated features and bright colors.\\n\\nThe overall theme of the image is education and travel, with the children representing students going on a field trip or exploring the world. The image could be used to promote a travel or education brand, or to encourage children to explore and learn about the world around them.'},\n", + " {'image_id': '124',\n", + " 'caption': 'The image shows a group of five coins, each with a different design on it. The coins are made of metal and have a shiny surface. The designs on the coins depict various historical events and figures, including the Statue of Liberty, the American flag, and a bald eagle. The coins are arranged in a row, with each coin slightly overlapping the one in front of it. The overall image is symmetrical, with the coins arranged in a straight line.'},\n", + " {'image_id': '126',\n", + " 'caption': 'This image shows a bride and groom standing under a gazebo during their wedding ceremony. The bride is wearing a white wedding dress and holding a bouquet of flowers, while the groom is wearing a black tuxedo and holding a single red rose. The couple is surrounded by a group of people in formal attire, who are watching the ceremony from the sidelines. The ceremony is taking place in an outdoor setting, with trees and greenery visible in the background. The sky is overcast, with clouds covering the sun.'},\n", + " {'image_id': '127',\n", + " 'caption': 'This image shows a clothing store with various clothing items hanging on racks and displayed on shelves. The walls are decorated with a large cityscape mural and several black and white photographs. The floor is made of wooden planks, and there is a black and white tiled pattern on the walls. The lighting in the room is dim, and there are several black and white lamps hanging from the ceiling. The atmosphere of the room is sophisticated and modern.'},\n", + " {'image_id': '128',\n", + " 'caption': 'The image depicts a person wearing a crown and holding a basketball in his right hand. He is standing in front of a blue and purple background with a pattern of stars and other celestial objects. The person is wearing a purple and gold jersey with the number 23 on the back and a crown on his head. He has a serious expression on his face and is looking directly at the camera.\\n\\nIn terms of details, the person is wearing a purple and gold jersey with the number 23 on the back and a crown on his head. He has a serious expression on his face and is looking directly at the camera. The background is a mix of blue and purple with a pattern of stars and other celestial objects.'},\n", + " {'image_id': '129',\n", + " 'caption': 'This is a black and white image of the logo for the fashion brand, Chanel. The logo is made up of the letters \"C\" and \"H\" in white, on a black background. The letters are stacked on top of each other, with the \"C\" on the left and the \"H\" on the right. This creates a sense of balance and symmetry in the design. The black and white color scheme gives it a sleek and sophisticated look.'},\n", + " {'image_id': '132',\n", + " 'caption': 'There are two dogs lying on the floor, a golden retriever and a black labrador, with the former wearing a harness and the latter wearing a collar. They seem relaxed and content. In the background, there is a brown leather couch, and in front of it, there is a wooden coffee table, indicating that the room is a living room.'},\n", + " {'image_id': '133',\n", + " 'caption': 'The image shows a dump truck carrying a load of dirt and rocks driving down a dirt road in a large open pit mine. The pit is surrounded by large piles of dirt and rocks, and there are no trees or other vegetation in the area. The sky is clear and blue.'},\n", + " {'image_id': '134',\n", + " 'caption': 'The image is a quote that reads, \"Being a mechanical engineer is easy, it\\'s like riding a bike you never forget how to do it.\" The quote is written in black text on a white background in large letters. It is meant to be inspirational and motivational, encouraging people to pursue careers in mechanical engineering and reminding them of the skills they have learned.'},\n", + " {'image_id': '135',\n", + " 'caption': 'The image shows a green hill with a tower on top of it. The tower is tall and has a pointed top. The sky is cloudy and there are some clouds in the background. The grass on the hill is long and lush. There are no other buildings or structures visible in the image.\\n\\nThe image shows a green hill with a tower on top of it. The tower is tall and has a pointed top. The sky is cloudy and there are some clouds in the background. The grass on the hill is long and lush. There are no other buildings or structures visible in the image.'},\n", + " {'image_id': '137',\n", + " 'caption': 'The image shows a white sandy beach with clear blue water and a few people walking along the shore. There are several buildings in the background, which appear to be hotels or resorts. The sky is a bright blue and there are a few clouds in the distance.'},\n", + " {'image_id': '138',\n", + " 'caption': 'the majority of the space in the foreground and the pot of stew and plate of herbs providing context in the background. The colors of the stew and herbs complement each other well, creating an appetizing and visually appealing image.'},\n", + " {'image_id': '139',\n", + " 'caption': 'This is an image of a tapered roller bearing. The bearing is made up of an outer ring, an inner ring, and a number of tapered rollers in between to support a heavy load while still being able to rotate smoothly. The outer ring is typically larger in diameter and made of steel or cast iron, while the inner ring is typically smaller in diameter and made of a softer material like brass or bronze. The rollers are made of hardened steel and positioned between the outer and inner rings. This type of bearing is commonly used in machinery, vehicles, and heavy equipment due to its ability to handle high loads.'},\n", + " {'image_id': '142',\n", + " 'caption': 'This is an image of three alpacas standing in a pen. The first alpaca is black with a white face, the second is white with a black face, and the third is brown with a white face. They are all standing next to each other and looking at the camera. There is a fence separating them from the viewer, and there is hay in the pen with them. The background is a mix of dirt and grass.'},\n", + " {'image_id': '143',\n", + " 'caption': 'This is a black dress with lace detailing on the neckline and sleeves. The dress has a fitted bodice and a flared skirt.'},\n", + " {'image_id': '145',\n", + " 'caption': 'The image shows a group of people standing around a large ice cream cone. The cone is green and has a scoop of ice cream on top. The people in the image are reaching out to touch the ice cream cone. They are all smiling and appear to be enjoying the ice cream. There is a white background behind the people and the ice cream cone.'},\n", + " {'image_id': '146',\n", + " 'caption': 'This image is a colorful striped background consisting of pastel shades of pink, yellow, blue, and green arranged vertically in a striped pattern with each color separated by a thin white line. The background appears to be a digital image giving the image a cheerful and playful feel. It could be used as a design element for a website or app, or as part of a graphic design project. It could also be used as a background for a social media post or as part of a marketing campaign to draw attention to a particular product or brand. In conclusion, the image is visually appealing and versatile for use in a variety of design contexts.'},\n", + " {'image_id': '147',\n", + " 'caption': 'This is an image of a man sitting on a bench with his knee wrapped in a bandage. He is wearing a white t-shirt and black shorts, and is holding his right arm with his left hand. The man appears to be in pain, as his facial expression is one of discomfort. The background of the image is a city street with trees and buildings visible in the distance.'},\n", + " {'image_id': '148',\n", + " 'caption': 'The image shows a pair of tan suede high top sneakers with laces on the front and no laces on the back. There is a small bow on the front of each shoe. The soles of the shoes are made of a light-colored material and have a small amount of dirt on them. The shoes appear to be in good condition.'},\n", + " {'image_id': '149',\n", + " 'caption': 'This image shows a man in a blue shirt and white shorts holding a tennis racket on a green tennis court. He is wearing white socks and black tennis shoes. The court has white lines on it and there is a net in the background.'},\n", + " {'image_id': '151',\n", + " 'caption': 'The image shows a group of men in white shirts standing on the balcony of a building. They are all smiling and posing for the camera. The building behind them appears to be made of stone and has arched windows and balconies. There are trees in the background and the sky appears to be cloudy.'},\n", + " {'image_id': '152',\n", + " 'caption': 'This image shows a crowd of people at a concert, with their hands raised in the air. The stage is lit up with bright blue and green lights, and the people in the crowd are wearing a variety of clothing. Some are holding up their phones to take pictures or record the concert. The atmosphere is lively and energetic, with the crowd cheering and singing along to the music.'},\n", + " {'image_id': '153',\n", + " 'caption': 'This is a toy truck with a trailer attached to the back. The trailer is made of plastic and has a small door on the side. The truck is white with red and black accents and has a small cab with a steering wheel and two seats. There is a small ladder attached to the back of the truck.'},\n", + " {'image_id': '154',\n", + " 'caption': 'There are several types of cakes and desserts in the box. The cakes include chocolate, vanilla, carrot, and cheesecake. All cakes are covered in frosting and decorated with toppings like sprinkles, chocolate chips, and nuts. Additionally, the cakes have pieces of fruit such as grapes, strawberries, and blueberries arranged on top. The box sits on a white tablecloth with a knife and plate nearby.'},\n", + " {'image_id': '155',\n", + " 'caption': 'This image shows The building in the image is a warehouse with a large parking lot in front of it. The warehouse appears to be made of concrete and steel, with large windows on the front and sides. There are several large trucks parked in front of the warehouse. The sky is cloudy and there are some trees in the background.'},\n", + " {'image_id': '158',\n", + " 'caption': 'This is a clear wine glass with the words \"best dad in the world\" engraved on the side. It has a stem and bowl and is of standard size.'},\n", + " {'image_id': '159',\n", + " 'caption': 'There is a bed in the room with a white comforter and pillows. There are two lamps on either side of the bed. The walls are painted green and there is a window with white curtains. There is a desk with a computer on it in the corner of the room.'},\n", + " {'image_id': '160',\n", + " 'caption': 'The image shows a resort with a large swimming pool surrounded by lounge chairs and umbrellas. There are several buildings in the background with white walls and blue roofs. There are sand dunes and palm trees in the background indicating that the resort is located in a desert area. The sky is clear and blue with a few fluffy clouds in the distance.'},\n", + " {'image_id': '161',\n", + " 'caption': 'The image is a menu for a restaurant, displaying a range of dishes and drinks.'},\n", + " {'image_id': '162',\n", + " 'caption': 'This image shows a large open space with high ceilings and exposed beams. The walls are painted white and there are large windows letting in natural light. The floor is made of wooden planks and there are several pieces of furniture in the room, including a couch, chairs, and a dining table. The room appears to be a loft apartment with an industrial feel.'},\n", + " {'image_id': '163',\n", + " 'caption': 'The image shows a purple dresser with gold accents and two framed mirrors hanging on the wall above it. The dresser has six drawers and is made of wood with a high gloss finish. The mirrors have ornate gold frames and beveled edges. The room has hardwood floors and white walls. There are no other pieces of furniture in the room.'},\n", + " {'image_id': '166',\n", + " 'caption': 'The image shows the front cover of a book with the title'},\n", + " {'image_id': '168',\n", + " 'caption': 'The image shows a bottle of Coca Cola and a glass of iced tea on a wooden table with a dark background.\\n\\nThe bottle of Coca Cola is made of clear glass and has a red and white label with the brand name and logo. The glass of iced tea is also made of clear glass and has a small amount of ice cubes floating in it.\\n\\nThe table is made of wood and has a rough, textured surface. The background is very dark, almost black, and there is no other visible objects in the image.'},\n", + " {'image_id': '169',\n", + " 'caption': 'The painting depicts a river with trees on either side. The water is calm and reflects the clouds in the sky. The sky is a bright blue with fluffy white clouds. The trees on the left side of the painting are tall and thin, while the trees on the right side are shorter and more spread out. There are no people or animals in the painting.'},\n", + " {'image_id': '170',\n", + " 'caption': 'The image shows a road at night with several cars driving on it. The headlights of the cars are shining brightly in the dark, and there are some streetlights on the side of the road. There are also some trees and buildings visible in the background. The image is taken at night, so the sky is dark and there are no stars visible.\\n\\nThe cars in the image are driving on the left side of the road, which is typical for countries that drive on the left side of the road. The headlights of the cars are shining brightly, which helps to illuminate the road and make it easier for the drivers to see where they are going. The streetlights on the side of the road also help to provide additional illumination.\\n\\nOverall, the image shows a typical night scene on a road with cars driving on it.'},\n", + " {'image_id': '171',\n", + " 'caption': 'a turban and has a serious expression on his face. Behind him are two flags on the wall, one of which is the Indian flag. The room is dimly lit with a red carpet and dark curtains on the windows. The man has a lot of medals and insignias on his chest and is holding a microphone in his left hand. The desk in front of him has a laptop and some papers on it.'},\n", + " {'image_id': '173',\n", + " 'caption': 'The image shows a man standing in front of an iron gate. The gate is old and rusty, with the words \"Grand Nefat\" engraved on it. The man is wearing a white shirt and black pants, and has his arms crossed in front of him. Behind him, you can see a vineyard with grapevines growing on it. The sky is clear and blue, and there are some clouds in the distance.'},\n", + " {'image_id': '174',\n", + " 'caption': 'This image shows a crab on the sand with an orange body, white spots, and a brown head with black eyes. Its legs are long and thin, and its claws are large and sharp. The sand around the crab is light brown, and there are small rocks and pebbles in the background. The sky is cloudy and overcast.'},\n", + " {'image_id': '175',\n", + " 'caption': 'The image is a bracelet made of white pearls that are strung together on a thin and delicate gold chain with a clasp that fastens the bracelet around the wrist. The pearls are large, round, and have a smooth, glossy surface. The overall design of the bracelet is simple and elegant, making it suitable for both casual and formal wear.'},\n", + " {'image_id': '177',\n", + " 'caption': 'The image shows a group of men dressed in red and black uniforms, carrying rifles and marching down a street. They are part of a military parade or ceremony. The uniforms are similar to those worn by soldiers in the British army during the 19th century. The men are wearing red coats with black facings, black trousers, and black boots. They are also wearing black helmets with plumes on top. The rifles they are carrying are also black, with brass fittings and bayonets. The men are marching in formation, with one leading the way and the others following closely behind. The street is lined with people watching the parade, and there are buildings on either side. The image is in black and white, which gives it a historical feel.'},\n", + " {'image_id': '178',\n", + " 'caption': 'This image is a collage of various landmarks from around the world including the Statue of Liberty, Big Ben, the Eiffel Tower, the Taj Mahal, the Great Wall of China, and the Sydney Opera House. The landmarks are depicted in a colorful, abstract style on a multicolored background. The Statue of Liberty is located in New York City and is a symbol of freedom and democracy in the United States. Big Ben is the nickname for the Great Bell of the clock at the north end of the Palace of Westminster in London, England. It is often used as a symbol of London. The Eiffel Tower is a wrought iron lattice tower located on the Champ de Mars in Paris, France.'},\n", + " {'image_id': '181',\n", + " 'caption': 'The image shows a mother and two children sitting on the grass in front of a brick wall. The mother is wearing a white and red striped shirt, and the children are wearing white shirts with red and white stripes. The mother is holding a baby in her arms, and the children are looking up at her with smiles on their faces.'},\n", + " {'image_id': '182',\n", + " 'caption': \"This is a picture of a woman's dark brown hair in a messy bun with some highlights. The hair is pulled back into a ponytail and then twisted into a bun, with some strands sticking out of it. The bun is held in place with a hair tie, and the woman's face is not visible in the picture.\"},\n", + " {'image_id': '185',\n", + " 'caption': 'The image shows a group of people standing in front of a desk in an office. They are all smiling and posing for the camera. The people are dressed in casual clothing, with one person wearing a blue shirt and another wearing a green shirt. There is a logo on the wall behind the desk that says \"Tesla\". The room appears to be well lit and spacious.'},\n", + " {'image_id': '187',\n", + " 'caption': 'This image shows a wallpaper with a floral pattern on a light blue background. The pattern features various birds, fruits, and leaves in shades of green, pink, and yellow. The birds are perched on branches and leaves, while the fruits are depicted as apples, pears, and peaches. The leaves are depicted in various sizes and shapes, with some of them being more detailed than others. The overall design of the wallpaper is elegant and sophisticated, with a focus on natural elements.'},\n", + " {'image_id': '189',\n", + " 'caption': 'This image shows a group of people, including three adults and two children, sitting on a wooden deck with a rope railing overlooking a body of water. The adults are sitting in chairs and the children are standing next to them. They all seem to be enjoying their time together and are smiling. The background includes trees and a dock that leads out into the water.'},\n", + " {'image_id': '191',\n", + " 'caption': 'The image shows a piece of cake on a plate with white frosting and sprinkles on top. The plate has a red and white checkered napkin on it. The cake appears to be moist and fluffy, and the frosting is smooth and creamy. There is a bite taken out of the cake, revealing the moist and fluffy cake inside. The cake appears to be homemade and made with fresh ingredients.'},\n", + " {'image_id': '192',\n", + " 'caption': 'The image shows a piece of chocolate cake with sprinkles on top, sitting on a white plate with a pink and white floral design on it. The plate is sitting on top of a pink and white polka dot tablecloth. There are also some colorful sprinkles scattered around the plate.\\n\\nThe cake appears to be made of chocolate, with a smooth and even texture. The sprinkles on top are a variety of colors, including pink, yellow, and blue. The plate has a floral design on it, with pink and white flowers. The tablecloth also has a pink and white polka dot pattern.\\n\\nOverall, the image depicts a sweet and colorful dessert on a pretty table setting.'},\n", + " {'image_id': '195',\n", + " 'caption': 'The image shows a man standing on a stage with a microphone in his hand, singing into a microphone. He is wearing a green shirt and has a serious expression on his face. The background is dark and there are no other people visible in the image.'},\n", + " {'image_id': '196',\n", + " 'caption': 'The woman is wearing a white tank top and pink headband, with loose wavy curls and pink lipstick. She is smiling and looking at the camera against a background of a white sink, mirror, and towels in what appears to be a bathroom.'},\n", + " {'image_id': '197',\n", + " 'caption': \"The image is a quote that reads, `'to the world you may be just one person, but to one person you may be the world.'\\n\\nIt is a motivational quote that emphasizes the importance of individuality and the impact that one person can have on the world. The quote is written in a decorative font and is surrounded by a variety of colors and patterns, including stripes, polka dots, and flowers. The background is a light blue color with white clouds and a yellow sun. The overall design is cheerful and uplifting.\"},\n", + " {'image_id': '198',\n", + " 'caption': \"This image shows a person's hand holding an oatmeal mixture in a glass.\"},\n", + " {'image_id': '199',\n", + " 'caption': 'The image shows a group of football players running on a field at night. The players are wearing maroon and white uniforms with numbers on the front and back. One player is carrying the ball and the others are chasing after him. The field is lit up by stadium lights and there are trees in the background.'},\n", + " {'image_id': '201',\n", + " 'caption': 'The image shows a vegetable garden in a raised bed made of wooden planks, filled with various types of plants such as kale, lettuce, and chard. The plants are growing in different sizes, some reaching up to the top of the bed. The garden is surrounded by a lawn and trees are visible in the background.'},\n", + " {'image_id': '202',\n", + " 'caption': 'This is a diagram of a cross section of a rectangular prism. The rectangular prism is made up of four rectangular faces that are perpendicular to each other. Each face is made up of two parallel lines, one horizontal and one vertical, that intersect at right angles. The rectangular prism also has four vertices and four edges.'},\n", + " {'image_id': '203',\n", + " 'caption': \"The image shows a woman in a white wedding dress sitting on a wooden bench under a large tree. The tree has a banner hanging from its branches that reads, `'to the moon and back.' The woman is looking off into the distance, and the image has a dreamy, ethereal quality to it.\"},\n", + " {'image_id': '204',\n", + " 'caption': 'The image shows a group of people standing on top of a large rock formation in the middle of the ocean, jutting out of the water. There is a small island visible in the distance. The clear, blue sky has some clouds in the distance. The people appear to be enjoying the view and taking in the scenery. The water around the formation is choppy with waves crashing against the rocks.'},\n", + " {'image_id': '206',\n", + " 'caption': 'This image shows a bride and groom cutting their wedding cake at an outdoor reception. The bride is wearing a long dress and the groom is wearing a black tuxedo with a white shirt and black tie. The multi-tiered cake has white frosting and is decorated with pink and white flowers. The table is covered with a white tablecloth and chairs are set up for guests to sit and watch. The background is a wooded area with trees and greenery.'},\n", + " {'image_id': '207',\n", + " 'caption': 'This is an image of a black deer standing in the middle of a lush and green forest. The deer has large antlers on its head and is looking straight at the camera with a curious expression on its face. The forest is surrounded by tall trees and bushes, and ferns and other vegetation are visible in the background. The sunlight is shining through the trees, casting dappled shadows on the ground.'},\n", + " {'image_id': '208',\n", + " 'caption': 'The image displays a wooden house with a red roof, two large windows on either side and a door in the middle. The house is surrounded by a well-maintained lawn and several trees. A pathway leads to the front door of the house.'},\n", + " {'image_id': '209',\n", + " 'caption': 'The image is a birthday cake decorated with purple and white frosting, featuring a fleur de lis symbol of the LSU Tigers football team. The words \"happy birthday\" are written on the cake in white frosting.'},\n", + " {'image_id': '212',\n", + " 'caption': 'The image shows a bedroom with pink walls and a white ceiling. There is a large window with white curtains and a balcony with a view of the city. The bed is made with white sheets and has two pillows on it. There is a small table next to the bed with a vase of yellow flowers on it. The room appears to be well lit and spacious.'},\n", + " {'image_id': '215',\n", + " 'caption': 'The image shows a dark grey 2019 volkswagen passat\\n\\nThe 2019 volkswagen passat is a midsize sedan that has a sleek and modern design. The front of the car has a large grille with the vw logo in the center, surrounded by LED headlights. The sides of the car have a flowing line that runs from the front to the back, giving the car a smooth and aerodynamic look. The back of the car has a sloping roofline and a pair of tailpipes on either side. The car is shown in a light grey color.'},\n", + " {'image_id': '216',\n", + " 'caption': 'This image shows a small island surrounded by turquoise water. The island is covered in green vegetation and has a sandy beach on one side. There is a small boat in the water near the island. The sky is clear and blue, with a few fluffy clouds visible in the distance.'},\n", + " {'image_id': '217',\n", + " 'caption': 'This image shows a group of people climbing on a rocky mountain. They are wearing climbing gear, including helmets, harnesses, and ropes. The sky is clear and blue, and there are some clouds in the distance. The landscape is rocky and barren, with no vegetation.'},\n", + " {'image_id': '218',\n", + " 'caption': 'There is a woman sitting in an armchair wearing a green dress and holding a phone to her ear. She appears to be talking on the phone. A bookshelf with several books is visible in the background.'},\n", + " {'image_id': '219',\n", + " 'caption': 'The image shows a man in a tuxedo The man in the image is wearing a black tuxedo with a white shirt and black tie. He has a beard and is holding an Oscar statuette in his left hand. The statuette is made of gold and is engraved with the name of the award and the year it was given. The man has a serious expression on his face and is looking directly at the camera. The background of the image is blurred and there are no other objects or people visible.'},\n", + " {'image_id': '223',\n", + " 'caption': 'The image displays the Sydney skyline at night, featuring the Sydney Harbour Bridge in the background. The bridge is illuminated with blue and white lights, and is a significant symbol of the city. The steel arch bridge serves as an important transportation link, connecting the north and south shores of Sydney. A concrete pier with a metal railing extends from the foreground into the harbour, with a few boats docked to it, and their lights reflecting in the water.'},\n", + " {'image_id': '224',\n", + " 'caption': 'The image shows a large, ornate room with high vaulted ceilings and large stained glass windows. The walls are made of stone and there are marble columns and arches throughout the room. The floor is made of checkerboard tiles and there are several people walking around the room. There is a large chandelier hanging from the center of the room and several other light fixtures on the walls. The room appears to be very grand and luxurious.'},\n", + " {'image_id': '225',\n", + " 'caption': 'The image shows a train traveling on tracks through a mountainous area with trees and mountains in the background. The train appears to be a commuter train, with a white body and red stripes. There are no passengers visible in the image.\\n\\nIn the foreground, there are some trees and bushes growing along the side of the tracks. The leaves on the trees are starting to change color, indicating that it is autumn. The mountains in the background are covered in a mix of evergreen and deciduous trees, with some of the leaves starting to change color as well. The sky is clear and blue, with a few fluffy clouds visible.\\n\\nOverall, the image depicts a peaceful scene of a train traveling through a beautiful mountainous area on a sunny autumn day.'},\n", + " {'image_id': '226',\n", + " 'caption': 'The image shows a group of people, including a woman in a white dress and a man in a suit, standing in front of a group of soldiers dressed in military uniforms. The woman is holding a bouquet of flowers and the man is standing next to her with his hands behind his back. The soldiers are standing at attention in a line behind the couple, with their arms at their sides. The image appears to have been taken in a formal setting, such as a military parade or ceremony.\\n\\nThe woman in the image is likely a member of a royal family or other high-ranking dignitary, given her formal attire and the presence of soldiers in military uniforms. The man standing next to her may be her spouse or a member of her entourage. The soldiers in the image are likely part of a ceremonial guard or honor guard, responsible for providing a visual display of military precision and discipline during public events.\\n\\nOverall, this'},\n", + " {'image_id': '229',\n", + " 'caption': 'This image shows a samurai helmet on a wooden stand. The helmet is made of metal and has intricate designs on the front and back. It has a pointed top, a curved brim, and two small horns on the top. The helmet is in good condition and appears to be well made.'},\n", + " {'image_id': '230',\n", + " 'caption': 'The image shows a garden with a wooden bench surrounded by white flowers and greenery. Tall trees and a stone wall make up the background, creating a peaceful and serene atmosphere.'},\n", + " {'image_id': '234',\n", + " 'caption': 'This is a photograph of a kitchen. The walls are painted white, and the floor is made of wooden planks. The countertops and cabinets are made of black granite and wood respectively. There is a stainless steel sink on top of the counter along with a faucet and garbage disposal. All the appliances including refrigerator, stove, and dishwasher are made of stainless steel. A large window above the sink allows natural light to come in making the room well lit. The overall design of the kitchen is modern and sleek with clean lines and a minimalist aesthetic.'},\n", + " {'image_id': '235',\n", + " 'caption': 'The image shows a group of people standing on a stage in front of a microphone. They are all dressed in formal attire, with one person holding a trophy and another person holding a microphone. Behind them, there is a curtain and a banner that reads \"Congratulations\" in large letters. The people in the image appear to be smiling and happy.'},\n", + " {'image_id': '238',\n", + " 'caption': 'This is a collage of various images, including a banana, a man in a suit, and a woman in a bikini.'},\n", + " {'image_id': '239',\n", + " 'caption': 'The image shows a man and a woman walking on the beach. The man is wearing a white robe and the woman is wearing a black robe. They are holding hands and walking towards the water. The beach is sandy and there are some rocks in the water. The sky is clear and there are some clouds in the distance. The sun is shining brightly and casting shadows on the sand.\\n\\nThe man and woman appear to be enjoying a leisurely walk on the beach. They are not in a hurry and seem to be taking in the sights and sounds of the ocean. The man is wearing a white robe and the woman is wearing a black robe. They are holding hands and walking towards the water. The beach is sandy and there are some rocks in the water. The sky is clear and there are some clouds in the distance. The sun is shining brightly and casting shadows on the sand.'},\n", + " {'image_id': '240',\n", + " 'caption': 'The image shows a gearbox, which is a mechanical device used to transmit power from one rotating shaft to another. The gearbox consists of several gears and shafts that work together to change the speed and torque of the rotating shafts. The gears are made of metal and have teeth that mesh with each other to transmit power. The shafts are used to hold the gears in place. The gearbox is used in automobiles, motorcycles, and industrial machinery.'},\n", + " {'image_id': '241',\n", + " 'caption': 'This is an image of Sonic the Hedgehog, a popular video game character known for his speed and agility. He is shown here in his classic form, with his trademark blue spikes and red shoes. The caption reads, \"\\'Lose rings fall into water die\\'\\' which is a reference to the game Sonic the Hedgehog, in which players must collect rings while avoiding obstacles and enemies. The Sonic the Hedgehog video game series was first released in 1991 for the Sega Genesis console and has since become a beloved franchise among gamers.'},\n", + " {'image_id': '242',\n", + " 'caption': 'This image appears to be a seamless pattern made up of various shades of green, purple, and brown. The colors are swirled together to create a flowing, organic design that could be used as a background or texture for a variety of projects. The overall effect is one of sophistication and elegance.'},\n", + " {'image_id': '243',\n", + " 'caption': 'This is an image of a man and a child sitting on a bench in front of a hut. The man is holding a bowl of food and the child is looking up at him. The image is in black and white.\\n\\nThe man is wearing a hat and a shirt, and the child is wearing a shirt and shorts. The hut in the background is made of wood and has a thatched roof. There is a small fence in front of the hut, and some trees can be seen in the background. The overall mood of the image is peaceful and serene.'},\n", + " {'image_id': '245',\n", + " 'caption': \"This image shows a man and a woman walking down the street holding hands. They are both wearing casual clothing, with the man wearing a white shirt and jeans, and the woman wearing a blue shirt and white pants. They are both smiling and looking at each other as they walk down the sidewalk. There is a building in the background with a large arched doorway, and there are trees and other buildings visible in the distance. The lighting in the image is natural, with the sun shining down from the right and casting shadows on the couple's faces. The overall mood of the image is happy and romantic, as the couple appears to be enjoying their time together.\"},\n", + " {'image_id': '246',\n", + " 'caption': 'This image shows a street scene in the French Quarter of New Orleans, Louisiana. The tall and ornate buildings on either side of the street have balconies and wrought iron railings. The street is lined with parked cars, and people are walking on the sidewalk. In the distance, a trolley car travels down the street. The sky is clear and blue without any clouds.'},\n", + " {'image_id': '248',\n", + " 'caption': 'The image depicts two hands holding a cat and a dog in the shape of a heart. The background is a red circle with the words \"love\" written in the center.\\n\\nThe image is a representation of the love between a cat and a dog. The cat and dog are holding hands in the shape of a heart, symbolizing their love and affection for each other. The background is a red circle with the word \"love\" written in the center, further emphasizing the theme of love and affection.'},\n", + " {'image_id': '250',\n", + " 'caption': 'The dress is a silver metallic dress with a plunging neckline and a thigh high slit. It has a fitted bodice and a flared skirt, made of shiny, reflective fabric that catches the eye. This modern statement piece is perfect for a night out or special occasion.'},\n", + " {'image_id': '251',\n", + " 'caption': \"The image shows a person sitting at a desk with a laptop open in front of them. They are wearing a suit and have a pen in their hand, which they are using to write on a piece of paper on the desk in front of them. Behind them, there is a window with a view of a city skyline.\\n\\nThe image is a representation of a business person working on their laptop, possibly analyzing data or working on a report. The graph on the laptop screen could be a representation of the company's financial performance, or any other type of data that the person is analyzing.\\n\\nOverall, the image is a representation of a business person working on their laptop, possibly analyzing data or working on a report. The graph on the laptop screen could be a representation of the company's financial performance, or any other type of data that the person is analyzing.\"},\n", + " {'image_id': '254',\n", + " 'caption': 'The image shows a row of red scooters parked on the side of a narrow street with buildings on either side. The scooters are lined up in a row, with some parked on the sidewalk and others parked on the street. The buildings on either side of the street are old and made of brick, with balconies and shutters on the windows. The street is lined with cobblestones, and there are no cars or other vehicles in sight. The sky is clear and blue, with a few fluffy clouds in the distance.'},\n", + " {'image_id': '257',\n", + " 'caption': 'This image shows a red lifted truck with large tires parked in a grassy area. The truck has a lifted suspension and large tires on both the front and rear axles. Additionally, the front bumper is lifted and has a winch mounted on it. The truck seems to be in good condition and is prepared for off-road use.'},\n", + " {'image_id': '260',\n", + " 'caption': 'This is a photograph of a rocky shoreline on a cloudy day. The waves are crashing against the shore and there is a small amount of foam on the water. The sky is overcast with clouds in the background. There are no people or other objects in the image.'},\n", + " {'image_id': '261',\n", + " 'caption': 'The image shows a map of the world with a golden airplane on top of it. The map displays the continents and countries of the world.'},\n", + " {'image_id': '262',\n", + " 'caption': \"This image shows a green frog sitting on a leaf in a puddle of water. The frog's body is translucent, allowing the viewer to see its internal organs, including its heart and lungs. The frog's eyes are large and black, and its legs are long and thin. The leaf has some water droplets on it, and the background is a blurred image of what appears to be a window or glass pane. The overall effect of the image is one of mystery and intrigue.\"},\n", + " {'image_id': '263',\n", + " 'caption': 'crumbling and destroyed, giving the impression that the city is under attack. The color scheme of the image is mostly black and grey, with hints of orange and red from the flames.\\n\\nOverall, the poster suggests that the movie or TV show is an action-packed, intense, and suspenseful adventure featuring the iconic character of Batman.'},\n", + " {'image_id': '265',\n", + " 'caption': 'The image shows a woman wearing a black and gold patterned midi skirt. The skirt has an asymmetrical hem and is worn with a pair of black ankle boots. The woman is also wearing a black top with long sleeves and a gold necklace with a pendant. The overall look is elegant and chic, perfect for a night out or a special occasion.'},\n", + " {'image_id': '266',\n", + " 'caption': 'The entrance to a brick hotel is shown in the image, with \"federal hotel\" written on the front of the building in large letters. The upper floors have several windows, and a large sign hangs above the entrance saying \"federal hotel\" in bold letters. The building is brightly lit at night.'},\n", + " {'image_id': '268',\n", + " 'caption': 'This image shows two scientists working in a laboratory. They are both wearing white lab coats and gloves, and one of them is holding a microscope while the other is holding a test tube with a liquid in it. The background of the image is a white, sterile laboratory with various equipment such as beakers, flasks, and test tubes. There is also a large window in the background that lets in natural light. The overall atmosphere of the image is professional and scientific.'},\n", + " {'image_id': '269',\n", + " 'caption': 'The image shows a circuit board with various electronic components attached to it, including capacitors, resistors, diodes, and transistors. The circuit board is connected to a power source, which is indicated by the positive and negative terminals on the left and right sides of the image. There is also a microcontroller on the circuit board, which is responsible for processing and controlling the various electronic components.\\n\\nThe image shows a circuit board with various electronic components attached to it, including capacitors, resistors, diodes, and transistors. The circuit board is connected to a power source, which is indicated by the positive and negative terminals on the left and right sides of the image. There is also a microcontroller on the circuit board, which is responsible for processing and controlling the various electronic components.'},\n", + " {'image_id': '270',\n", + " 'caption': 'The image shows a variety of ingredients for cooking, including rice, noodles, sauces, spices, a bottle of soy sauce, and a package of ramen noodles.'},\n", + " {'image_id': '271',\n", + " 'caption': \"This image shows a close-up view of a tiger's face. The tiger appears to be staring directly at the camera with a serious expression. The tiger's fur is dark brown and its eyes are yellow with black pupils. Its whiskers are long and bushy. The tiger's nose is black, and its mouth is open slightly, revealing its sharp teeth. The tiger's ears are perked up, and its head is tilted slightly to the side. The background is black and there is no other visible detail in the image.\"},\n", + " {'image_id': '272',\n", + " 'caption': 'cartoon astronaut waving in a welcoming gesture, wearing a helmet and a spacesuit, with a background gradient of blue and purple and stars and planets visible in the distance.\"'},\n", + " {'image_id': '276',\n", + " 'caption': 'The image shows a group of three people standing in front of a stone wall. They are all wearing long robes and holding swords. The person on the left is Harry Potter, the person in the middle is Hermione Granger, and the person on the right is Ron Weasley. They are all looking at the camera with serious expressions.\\n\\nIn the background, there is a castle with tall towers and a large gate. The castle is surrounded by a moat and there is a bridge leading to the gate. The sky is cloudy and there is a rainbow in the distance.\\n\\nOverall, the image depicts a scene from the Harry Potter series, with the main characters standing in front of Hogwarts School of Witchcraft and Wizardry.'},\n", + " {'image_id': '278',\n", + " 'caption': 'The image shows two people hugging One person is wearing a black leather jacket and the other is wearing a red sweater. They are both smiling and embracing each other in a hug.'},\n", + " {'image_id': '279',\n", + " 'caption': 'This image is a collage made up of different pieces of paper. The center of the collage is a picture of Abraham Lincoln, the 16th President of the United States, depicted in a suit and tie with a serious expression on his face. The background of the collage is made up of various papers with different colors, patterns, words, images, and designs. The overall effect is one of complexity and diversity with different elements coming together to create a cohesive whole.'},\n", + " {'image_id': '280',\n", + " 'caption': 'This image appears to be a retro distressed sticker of a cartoon bottle of whiskey. The bottle appears to be made of glass and has a cork in the top. There is a label on the front of the bottle that reads \"Whiskey\" in bold white letters. The background of the sticker is a distressed texture, giving it a vintage look. The overall design of the sticker is simple and straightforward, making it suitable for use in various applications such as logos, branding, and web design.'},\n", + " {'image_id': '282',\n", + " 'caption': \"The image shows a woman standing next to a car, smiling and holding a car key in her hand. She is wearing a business suit and has her hair styled in a bun. The car behind her is a sleek, black sedan with tinted windows and a shiny finish. The dealership's showroom is visible in the background, with several other cars parked in the lot.\\n\\nThe woman is likely a salesperson at the dealership, and the car she is standing next to is likely a new model that she is showing to a potential customer. The key she is holding is likely the key to the car, which she is offering to the customer as part of the sales pitch. The image suggests that the dealership is modern and well-equipped, with a clean and well-lit showroom and a variety of cars to choose from.\"},\n", + " {'image_id': '283',\n", + " 'caption': \"This image is a black and white photograph of a person's face with a serious expression, looking directly at the camera. The details of the person's face are clear and visible, with short, dark hair and a well-defined jawline. The well-composed image has no distracting elements in the background, creating an overall effect of simplicity and clarity.\"},\n", + " {'image_id': '284',\n", + " 'caption': 'This image depicts a wooden mannequin holding a large, grey hat with a red ribbon tied around the brim. The mannequin is wearing a white shirt and black pants. There is a white background behind the mannequin.\\n\\nDescription:\\n\\n* The mannequin is holding a large, grey hat with a red ribbon tied around the brim.\\n* The mannequin is wearing a white shirt and black pants.\\n* There is a white background behind the mannequin.\\n* The mannequin is made of wood.\\n* The hat is made of grey paper.\\n* The red ribbon is tied around the brim of the hat.'},\n", + " {'image_id': '286',\n", + " 'caption': 'This image shows a coastal area with sandy beaches and dunes, as well as a river flowing into the ocean. There are also some rocks and cliffs visible in the background. The water appears to be a deep blue color, and there are some waves crashing against the shore. The sand on the beach is a light brown color, and there are some small plants growing in the dunes. The sky appears to be cloudy, with some dark clouds in the distance. Overall, this is a beautiful image of a natural coastal area.'},\n", + " {'image_id': '287',\n", + " 'caption': 'This image depicts a patio area enclosed by a wrought iron fence.'},\n", + " {'image_id': '288',\n", + " 'caption': 'The image shows a white flower in full bloom, with a long curved petal and a thin straight stem attached to the base of the flower. The background is light green.'},\n", + " {'image_id': '290',\n", + " 'caption': \"The image shows a brightly colored building with blue walls and a green door. The sign above the door reads `poke bar'in white letters. There are several potted plants on the sidewalk in front of the building.\"},\n", + " {'image_id': '291',\n", + " 'caption': 'The image shows a man sitting on a chair with his legs crossed wearing traditional Indian attire. He has a serious expression on his face and is looking at something in the distance. Behind him is a wall with graffiti, and in the background, there is a city skyline with the sun setting behind it. Two dogs sit next to the man, one on each side. It appears to be a still from a movie or TV show set in an urban environment, possibly from a Bollywood film.'},\n", + " {'image_id': '292',\n", + " 'caption': 'The image depicts a green field with a white house on a hill overlooking the ocean. The house is small with a red roof and chimney, surrounded by green grass and trees in the foreground. The clear blue sky has some clouds and the ocean is visible in the background.'},\n", + " {'image_id': '293',\n", + " 'caption': 'This image shows a man playing a guitar in a recording studio. He is seated in a chair, wearing headphones, with a microphone in front of him and a recording device on a stand nearby. Other instruments and equipment are visible in the background.'},\n", + " {'image_id': '294',\n", + " 'caption': 'The image shows a basketball player wearing a white jersey with the number 23 on the back and black shorts, taking a shot at the hoop during a game. He is holding the ball in his right hand, ready to shoot. The hoop and backboard are in the background, with a crowd of people watching from the stands.'},\n", + " {'image_id': '296',\n", + " 'caption': 'The image is a black leather wallet with a clear plastic window on the front. The wallet has two compartments, one for cash and the other for cards. The wallet is made of high quality leather and has a sturdy zipper closure. The wallet also has a small pocket on the back for storing receipts or other small items. The wallet has a sleek and modern design, making it a great accessory for both casual and formal outfits.'},\n", + " {'image_id': '297',\n", + " 'caption': 'This image shows a small stream flowing through a wooded area. The trees on either side of the stream are in full autumn color, with orange, yellow, and red leaves. The sky above is cloudy, with dark clouds gathering in the distance. The overall mood of the image is peaceful and serene, with the sound of the stream providing a calming background.'},\n", + " {'image_id': '298',\n", + " 'caption': 'The image shows a soccer player in a red and blue jersey running with the ball at his feet. He is wearing white shorts and black cleats. The field behind him is green and there are spectators in the stands watching the game. The sky is blue and there are clouds in the background.'},\n", + " {'image_id': '300',\n", + " 'caption': 'The image shows a double rainbow over a campsite with several RVs parked in the foreground. The sky is clear and blue, with the rainbow stretching across it. The rainbow has a bright, vibrant color scheme, with shades of pink, orange, yellow, green, and blue. The RVs are parked in a row, with their awnings open and their doors closed. The grass in the foreground is green and lush, and there are some trees in the background. The overall mood of the image is peaceful and serene, with the rainbow adding a touch of magic and wonder to the scene.'},\n", + " {'image_id': '301',\n", + " 'caption': 'The image shows two kayaks on a sandy beach with palm trees in the background. The kayaks appear to be made of orange plastic and have paddles attached to them. There is a small building in the background that appears to be a beach hut or kiosk. The sky is blue and there are some clouds in the distance.'},\n", + " {'image_id': '302',\n", + " 'caption': 'This is a black and white photograph of a man in a suit and tie. He has a beard and is wearing a bow tie. He is looking directly at the camera with a serious expression on his face. The background is not visible in this image.'},\n", + " {'image_id': '304',\n", + " 'caption': 'This image shows a person wearing a backpack and standing in a park with a view of a city skyline in the background. The person appears to be looking down at something on the ground in front of them. There are several other people in the background, walking or sitting on the grass. The sky is cloudy and there are some trees in the foreground.'},\n", + " {'image_id': '305',\n", + " 'caption': 'The image shows a silhouette of a person standing on a tree stump in the middle of a forest. The person is wearing a headdress made of feathers and has their arms outstretched. The sun is setting in the background, casting a warm orange glow over the scene. The trees in the background are tall and thin, with branches that stretch up towards the sky. There are no other visible objects in the image.'},\n", + " {'image_id': '306',\n", + " 'caption': \"The image shows a full moon shining over a rocky coastline with a lighthouse in the distance. The sky is dark, but the moon's light illuminates the landscape. The water is calm and still, reflecting the moon's glow. The lighthouse is a tall, white structure with a red roof and a beacon on top. It stands on a rocky outcropping near the water's edge. In the foreground, there are several large rocks jutting out of the water, with smaller rocks and pebbles scattered around them. The overall mood of the image is peaceful and serene, with the moon casting a magical glow over the scene.\"},\n", + " {'image_id': '309',\n", + " 'caption': 'The image depicts a concrete and steel hydroelectric dam with turbines on top. Water flows over the dam creating a visible mist. On one side of the dam, there is a road and some trees. The sky is clear and blue.'},\n", + " {'image_id': '310',\n", + " 'caption': 'This image is a logo for a baby care company. It features a cute cartoon bee sitting on a flower with the words \"baby care\" written underneath it. The bee has a smiling face and is surrounded by colorful flowers and leaves. The design is simple and cute, making it suitable for use on a wide range of products.\\n\\nThe colors used in this logo are pastel shades of pink, yellow, and green. The font used for the text is playful and childlike, which fits well with the overall theme of the logo. This logo is a great representation of a baby care company and would be well suited for use on a wide range of products.'},\n", + " {'image_id': '312',\n", + " 'caption': 'This image shows a woman crossing the street at a crosswalk. She is wearing a black shirt, black pants, and black shoes. There is a yellow caution tape on the ground in front of her, indicating that there is a hole in the street. The woman is looking down at the ground as she walks, and there are cars and buildings in the background.'},\n", + " {'image_id': '315',\n", + " 'caption': 'The image shows a bedroom with a large white bed and two lamps on either side. The walls are painted light green and have floral wallpaper. The bed is made with a white comforter and pillows, and there is a white nightstand on each side. The room is well lit with two lamps and a large window.'},\n", + " {'image_id': '316',\n", + " 'caption': \"This is an image of a green leaf with a map of the world imprinted on it. The map is made up of different shades of green, with the continents and oceans depicted in different shades of the color. The leaf has a rough texture and appears to be from a plant that is native to a tropical or subtropical region. The image is a representation of the interconnectedness of the world's ecosystems and the importance of preserving the natural environment.\"},\n", + " {'image_id': '317',\n", + " 'caption': 'This image shows a woman wearing a white mask and pointing at something with her right hand. The woman is wearing a black top and brown pants, and her hair is pulled back into a ponytail. The background is black.'},\n", + " {'image_id': '318',\n", + " 'caption': 'The image shows a man sitting at a desk with a computer in front of him. He is wearing glasses and has a serious expression on his face. There is a lamp on the desk next to him, and a green background behind him. The image is in a flat, cartoon style.\\n\\nThe man is sitting at a desk with a computer in front of him. He is wearing glasses and has a serious expression on his face. There is a lamp on the desk next to him, and a green background behind him. The image is in a flat, cartoon style.'},\n", + " {'image_id': '320',\n", + " 'caption': 'This image shows a group of people, including a man, woman and two children, standing in front of a body of water. The man is wearing a black shirt, black pants, and black shoes. The woman is wearing a white shirt, black pants, and black shoes. The children are both wearing black shirts, black pants, and black shoes. They are all smiling and posing for the camera with a clear blue sky and mountains in the background.'},\n", + " {'image_id': '322',\n", + " 'caption': 'This is an image of a metal badge with a white background and a black star in the center. It is made of metal and has a shiny finish. There is no text or writing on the badge.'},\n", + " {'image_id': '323',\n", + " 'caption': 'This is a math talk mat with the number 10 written on it. There are 10 circles on the mat, each with a number from 1 to 10. The mat is surrounded by red and blue dots.'},\n", + " {'image_id': '324',\n", + " 'caption': 'branches and leaves depicted in a unique and artistic manner.'},\n", + " {'image_id': '325',\n", + " 'caption': 'The image shows three cans of olive oil, each with a different label. The first can is labeled \"Classic Olive Oil,\" the second can is labeled \"Premium Olive Oil,\" and the third can is labeled \"Organic Olive Oil.\" All three cans have a green cap on top and are sitting on a green surface.'},\n", + " {'image_id': '326',\n", + " 'caption': \"This image shows a butterfly resting on a flower in a field. The butterfly is a yellow and black tiger swallowtail, and it is perched on a pink flower with green leaves. The butterfly's wings are spread out and its antennae are extended. The background of the image is a grassy field with some trees in the distance. There are also some pink flowers and green leaves in the foreground. The lighting in the image is natural, with the sun shining down from the right and casting shadows on the butterfly's wings. The overall mood of the image is peaceful and serene, with the butterfly resting calmly on the flower.\"},\n", + " {'image_id': '327',\n", + " 'caption': \"The image shows a woman standing on \\u200b\\n\\nThe image shows a woman standing on a frozen lake with her dog. The woman is wearing a pink jacket, white pants, and red boots. She is holding the dog's leash in her left hand and petting the dog with her right hand. The dog is a husky breed and is wearing a collar with a tag on it. The lake is covered in ice and there are some trees visible in the background. The sky is cloudy and it appears to be cold weather.\"},\n", + " {'image_id': '328',\n", + " 'caption': \"The image displays a map of the German Empire in 1871, which was formed after the unification of various German states. It depicts the different regions of the empire, including Prussia, Bavaria, Saxony, and Württemberg. Kaiser Wilhelm I was crowned in 1871 as the ruler of the empire. It was dissolved in 1918 following Germany's defeat in World War I.\"},\n", + " {'image_id': '329',\n", + " 'caption': 'This image is of a young woman on a green surfboard in the ocean. She is wearing a black bikini and has long, curly brown hair. The water is a deep blue with waves in the background. The sun is shining and there are clouds in the sky. The woman is smiling and standing on the surfboard with one foot while holding onto the rope with her hand. The water is up to her waist. The image is clear and well lit.'},\n", + " {'image_id': '330',\n", + " 'caption': 'This image shows a dining room with a long wooden table and several chairs. The walls are lined with shelves filled with plates, bowls, and other kitchenware. The table is set for a meal, with plates, silverware, and glasses arranged on it. The room is well lit, with natural light coming in from large windows on one wall. The floor is made of wooden planks, and there is a rug in front of the table. The atmosphere of the room is cozy and welcoming.'},\n", + " {'image_id': '332',\n", + " 'caption': \"The man in the image is wearing a black leather jacket, black pants, and white sneakers. He is standing in front of a large black and white image on the wall behind him. The image appears to be a close up of a person's face. The man is smiling and his arms are crossed in front of him.\\n\\nThe image appears to have been taken in a dimly lit room, as the man's face is partially obscured by shadows. The wall behind him appears to be made of concrete or some other rough material. There are no other objects or people visible in the image.\"},\n", + " {'image_id': '333',\n", + " 'caption': 'This image depicts a skull wearing a traditional Mexican sombrero hat with flowers around it. The hat has a wide brim and can be made of straw or felt. The skull is also wearing sunglasses, perched on the brim of the hat.'},\n", + " {'image_id': '334',\n", + " 'caption': \"The image shows a farmer driving a tractor through a field of crops. The tractor is pulling a plow to till the soil for planting. The farmer is wearing a hat and a short-sleeved shirt, holding onto the steering wheel with both hands. Rows of crops that have already been plowed are visible in the background. The sky is clear and blue, and there are no other buildings or structures in the image.\\n\\nReasons for population growth:\\n\\n* Farming methods have increased the world's food supply\\n* Advances in transportation and communication have made travel and communication easier\\n* Medical advances have improved health and increased life expectancy\\n* Increased access to education has led to higher literacy and better job opportunities\"},\n", + " {'image_id': '335',\n", + " 'caption': 'The image shows a group of people rafting down a river in the middle of a canyon. The canyon walls are steep and rocky, and there are mountains in the background. The water is clear and the sky is blue. The people in the raft are wearing life jackets and helmets, and they appear to be enjoying the ride. There are no other boats or people visible in the image.'},\n", + " {'image_id': '336',\n", + " 'caption': 'This image shows a large, modern lobby with high ceilings and large windows letting in plenty of natural light. The floor is made of white and black tiles, while the walls are painted in a light shade of grey. The ceiling is made of wooden beams, with recessed lighting fixtures hanging from them. The furniture in the lobby consists of a large, round coffee table in the center, surrounded by several chairs and a sofa. There is also a reception desk in the corner of the room. The overall design of the lobby is sleek and modern, with clean lines and minimal decor.'},\n", + " {'image_id': '337',\n", + " 'caption': 'There are two beds in the room, one double and one single, both with black leather headboards and white linens. The room has white walls and a white tiled floor. In the corner of the room, there is a black leather couch and a black leather chair. A large window lets in plenty of natural light, and in front of the window is a black leather ottoman.'},\n", + " {'image_id': '340',\n", + " 'caption': 'This is a photograph of a city square in Prague, Czech Republic. There are several buildings in the background, including a large church with a tall steeple. People are walking around the square, and there is a statue in the center. The sky is cloudy and overcast.'},\n", + " {'image_id': '342',\n", + " 'caption': 'This image is a still life painting of a bowl of sliced lemons arranged in a symmetrical pattern. The background is white, and there are no other objects depicted. The composition is balanced with the lemons in the foreground and mostly white background. Natural lighting creates shadows on the table and lemons. The colors used are mostly shades of yellow, with the lemons being bright and vibrant. The overall impression is that of a well-executed still life painting.'},\n", + " {'image_id': '344',\n", + " 'caption': 'The image shows a small, white house with a blue light shining from the top of the roof, surrounded by trees and a dark sky in the background. In the foreground, a person wearing a black hoodie and pants stands on the grass, looking up at the light. The overall mood of the image is eerie and mysterious, with the blue light casting an otherworldly glow on the house and person. The dark sky and trees in the background add to the sense of isolation and uncertainty.'},\n", + " {'image_id': '348',\n", + " 'caption': 'This image depicts a large, ornate door with intricate carvings on it. The carvings appear to depict various figures, including angels, demons, and other mythical creatures. The door appears to be made of stone or some other type of material that has been carved to create the intricate designs. The carvings are very detailed, with attention paid to the facial expressions and body language of each figure. Some of the figures appear to be in motion, as if they are about to come to life and step out of the door.'},\n", + " {'image_id': '349',\n", + " 'caption': 'a suspenseful and thrilling horror story that will keep the audience on the edge of their seats. The poster features a woman standing in front of a dark, ominous forest. She is wearing a long, flowing dress and has her back turned to the viewer. Her hair is long and flowing down her back, and her face is obscured by shadows. The forest behind her is full of twisted, gnarled trees that seem to be reaching out towards her. The overall tone of the poster is ominous and foreboding, suggesting that the film will be a scary and suspenseful horror story.'},\n", + " {'image_id': '350',\n", + " 'caption': 'The woman in the image is wearing a denim shirt and jeans. She has long, curly hair and is posing with her hands on her hips. The shirt is a light blue color and has a button-down collar. The jeans are a dark blue color and have frayed hems. The woman is wearing a pair of silver hoop earrings and a necklace with a small pendant. She has a tattoo of a flower on her left wrist. The background is a light blue color.'},\n", + " {'image_id': '351',\n", + " 'caption': 'The image shows a beautiful autumn scene with colorful leaves on the trees and on the ground. The trees are in the foreground, with their branches and leaves in various shades of orange, yellow, and red. In the background, there is a winding path that leads through the woods. The path is lined with colorful foliage, and there are glimpses of other trees and shrubs in the distance. The overall effect is one of warmth and coziness, as if the viewer is standing in the midst of a beautiful fall forest.'},\n", + " {'image_id': '352',\n", + " 'caption': \"buttigieg president ' are written in white letters on a blue background. The hoodie is made of light grey material with a hood that can be pulled over the head.\"},\n", + " {'image_id': '353',\n", + " 'caption': 'This mug has the words \"Home is where the dog is\" written in black on a white background with pink triangles.'},\n", + " {'image_id': '355',\n", + " 'caption': 'The image shows a plate with bread and soup on a checkered tablecloth on a wooden table with beer glasses. The background is a brick wall with hanging plants. The atmosphere is cozy.'},\n", + " {'image_id': '356',\n", + " 'caption': 'decorative pattern on top of the cheesecake. The cheesecake appears to have a smooth and creamy texture, and the graham cracker crust is visible on the edges. The plate the cheesecake is on is pink in color and appears to be made of ceramic.\\n\\nThe colors in the image are bright and vibrant, with the strawberries being a deep red color and the cheesecake being a light pink color. The lighting in the image is also well done.\\n\\nOverall, the image is visually appealing and makes the viewer want to try a slice of the strawberry cheesecake.'},\n", + " {'image_id': '357',\n", + " 'caption': \"This image depicts a black and white silhouette of a man and a woman's head. The man's head is on the left side and facing towards the left, while the woman's head is on the right side and facing towards the right. Both heads are slightly tilted in opposite directions. The man has short, dark hair, while the woman has long, light hair. Both faces are expressionless. This symbolizes the concept of equality between men and women.\"},\n", + " {'image_id': '359',\n", + " 'caption': 'This is an image of a person swimming in a pool. The person is wearing a blue swimsuit and goggles, and they are holding their arms out in front of them as they swim. The water in the pool is clear and blue, and there are other people in the pool with the person in the image. Some of these people are swimming, while others are lounging on pool floats or sitting on the edge of the pool. In the background, there are several buildings and trees visible through the windows of the pool area.'},\n", + " {'image_id': '360',\n", + " 'caption': 'The painting depicts a serene scene of a large blue house with white trim and a tall tower on top, surrounded by a white picket fence and a small green lawn. A woman in a flowing dress stands on the porch, looking out at the view, with a contemplative expression. Behind her is a large window that frames a view of the ocean and some boats in the distance, with two pale blue curtains. The bright blue sky with fluffy white clouds adds to the peaceful mood of the image.'},\n", + " {'image_id': '361',\n", + " 'caption': 'This image shows a man in a black shirt and headphones standing in front of a DJ booth. The man is holding a pair of headphones and appears to be in the process of mixing music. The background is dark, with blue and purple lights illuminating the scene.'},\n", + " {'image_id': '362', 'caption': 'The image is a cartoon illustration'},\n", + " {'image_id': '363',\n", + " 'caption': 'es people to pursue their aspirations. The t-shirt features black color and bold gold lettering in the center of the chest that reads, \"we\\'re gonna do what we can\\'t be done.\" The design is made of a lightweight and thin material with short sleeves and no other visible graphics. The quote is often used in various contexts to inspire individuals to strive for their goals and push themselves beyond their limits.'},\n", + " {'image_id': '364',\n", + " 'caption': 'The image depicts a family riding bicycles in a park at sunset. The father is riding a bicycle with his son on the back, while the mother is riding a bicycle with her daughter on the back. The family is enjoying the beautiful sunset and the peaceful atmosphere of the park.\\n\\nIn the background, there is a tree with birds perched on its branches. The silhouette of the tree and the birds creates a beautiful contrast against the orange and pink sky of the sunset. The overall mood of the image is peaceful and happy, as the family is spending quality time together in nature.'},\n", + " {'image_id': '366',\n", + " 'caption': 'The image is of a blue backpack with a zipper on the top and two straps on the sides. It also features a small pocket on the front and a larger pocket on the back.'},\n", + " {'image_id': '368',\n", + " 'caption': 'This image is a purple background with white text that says \"all the good girls go to hell\". The text is written in a stylized font and appears to be glowing, as if it is made up of light trails. The overall effect of the image is dark and mysterious.'},\n", + " {'image_id': '369',\n", + " 'caption': 'This is a photo of a white boat with a sign on the side that says \"berkeley\" in black letters. The boat is docked at a pier and there are several people standing on the deck. The sky is cloudy and there are buildings in the background.'},\n", + " {'image_id': '370',\n", + " 'caption': 'This image shows a house with a red metal roof, surrounded by trees and mountains in the background. The house appears to be made of wood and has large windows on the front and side. There is a gravel driveway leading up to the house, and a small outdoor patio area with a table and chairs to the right of the house. The sun is setting behind the mountains, casting a warm orange glow on the scene.'},\n", + " {'image_id': '372',\n", + " 'caption': 'This The image shows a group of walnuts arranged in the shape of a heart on a wooden table. There are several walnuts on the left side of the heart, and one walnut on the right side. The walnuts are arranged in a way that they form the shape of a heart. The background is a wooden table with a rough texture.'},\n", + " {'image_id': '373',\n", + " 'caption': \"This is an image of a white swan swimming alone in a calm river. The swan's neck is stretched out and its beak is open as it swims towards the left side of the image. The water reflects the cloudy sky and some trees on the riverbank, as well as some buildings in the background. The swan's feathers look smooth and glossy in the water. It is a peaceful and serene image.\"},\n", + " {'image_id': '375',\n", + " 'caption': 'This is an image of a dollar bill with a syringe sitting on top of it. The syringe appears to be filled with a clear liquid and has a needle attached to the end. The dollar bill is lying on top of a white surface, and there is a small puddle of liquid next to the syringe. The background of the image is blurred, but it appears to be a light colored surface.'},\n", + " {'image_id': '376',\n", + " 'caption': 'This image is a silhouette of a raven, a black bird with a large beak and long legs, standing on the ground with its wings spread out. The raven is a symbol of death and mourning in many cultures and is often depicted as a scavenger, feeding on carrion. It is also known for its intelligence and ability to solve problems. The raven is a bird of the crow family and is found in many parts of the world. It is a common sight in urban areas and is often seen perched on telephone wires or on the ground searching for food. The raven is a symbol of mystery and magic in many cultures and is often associated with the occult and the supernatural. It is also a symbol of transformation and renewal, as it is often seen as a messenger between the physical and spiritual worlds.'},\n", + " {'image_id': '377',\n", + " 'caption': 'The image shows a circle with a diameter of 8cm. The center of the circle is at the origin (0,0) and the coordinates of the endpoints of the chord are (4,0) and (-4,0). The equation of the chord is x = 4 and y = 0. The equation of the circle is x^2 + y^2 = 16. The length of the chord is 8cm.'},\n", + " {'image_id': '378',\n", + " 'caption': 'The image shows a white rabbit with pink ears and a pink nose standing on its hind legs. The rabbit has a pink ribbon tied around its neck and is placed on a wooden surface.'},\n", + " {'image_id': '379',\n", + " 'caption': 'The image shows a man in a red and orange costume standing on a stage in front of a group of people. He is wearing a long, flowing cloak and holding a sword in his right hand. The people in the background are dressed in various costumes and are watching him on stage.'},\n", + " {'image_id': '380',\n", + " 'caption': 'This image displays a collection of military-related icons including tanks, helicopters, soldiers, and other equipment. The icons are arranged in a grid pattern on a beige background in a simple, flat style. It seems to be a design element for a website or application associated with the defense industry.'},\n", + " {'image_id': '382',\n", + " 'caption': 'This image shows a group of people standing in a boxing ring. Two men are boxing, one in a red shirt and black pants and the other in a white shirt and black pants, both wearing boxing gloves. There is a referee in a black and white striped shirt and black pants, standing in the corner of the ring with a whistle in his mouth, watching the match closely. Several people are sitting in the stands, wearing different clothing and cheering on the fighters. The room is dimly lit and shadows can be seen on the walls.'},\n", + " {'image_id': '383',\n", + " 'caption': 'This is an image of the Hulk, a superhero character from the Marvel Comics universe. The Hulk is a large, green figure with bulging muscles and a mean expression on his face. He is wearing green pants, revealing his muscular chest and shoulders. The Hulk is known for his incredible strength and ability to transform into a giant, rampaging monster when he becomes angry.\\n\\nIn the image, the Hulk is shown with his fists clenched and his eyes narrowed in a menacing expression. He appears ready to fight, and his muscles are bulging and tense. This image captures his strength and intensity well.'},\n", + " {'image_id': '384',\n", + " 'caption': 'This image shows a small room with a blue wall and a white ceiling. There is a red fire extinguisher hanging on the wall and a white cabinet with drawers underneath it. The floor is made of gray tiles and there is a white door on the right side of the room.'},\n", + " {'image_id': '385',\n", + " 'caption': 'This image shows a bedroom with yellow walls and wooden beams. There is a large bed with a wooden headboard and white linens. The room has large windows that let in a lot of natural light. There is a chandelier hanging from the ceiling and a small table with a vase of flowers on it. The room appears to be spacious and well lit.'},\n", + " {'image_id': '386',\n", + " 'caption': \"This is a black and white photograph of a man and woman standing under a tree in the snow. The man is holding the woman's hand and they are both looking at something in the distance. There is a streetlight in the background, casting a warm glow on the couple. The snow is falling heavily, covering the ground and the branches of the tree. The couple is dressed in winter clothing, with the man wearing a hat and scarf and the woman wearing a coat and boots.\"},\n", + " {'image_id': '387',\n", + " 'caption': 'This image depicts a room with a blue door and a chalkboard on the wall featuring various drawings and sketches of people, animals, and objects. A woman is standing in the doorway, observing the chalkboard. It seems to be an office or workspace.'},\n", + " {'image_id': '388',\n", + " 'caption': 'The image shows a table with a glass of wine and a bowl of nuts on it. The background is a green field with trees in the distance.'},\n", + " {'image_id': '389',\n", + " 'caption': \"The image shows a woman in a blue dress carrying a man on her back while wearing skates. They both seem to be enjoying themselves and smiling. The man is holding onto the woman's waist with his arms. The woman has long blonde hair and is wearing a pair of earrings. The man has short brown hair and is wearing a pair of sunglasses.\"},\n", + " {'image_id': '390',\n", + " 'caption': 'This image appears to be a graphic design with the words \"the earth laughs in flowers\" written in white letters on a gray background. The words are written in a stylized font with a vintage feel, and the graphic design appears to be a sticker or decal that can be placed on various surfaces. The phrase is often attributed to Ralph Waldo Emerson, who used it in his essay \"Nature,\" and it is interpreted as a reminder to appreciate the beauty and resilience of nature and find joy in the simple things in life. The image conveys a message of environmentalism and appreciation for the natural world.'},\n", + " {'image_id': '391',\n", + " 'caption': 'There are several people standing in the middle of a large, empty room. They are standing in a circle and facing each other. Several blue chairs are arranged in a circle around them. The walls are white and there are large windows on one side of the room. The floor is made of concrete. There are no other objects in the room.'},\n", + " {'image_id': '392',\n", + " 'caption': 'There are several potted plants on the shelf, including a spider plant, a snake plant, and a peace lily. There are also several books stacked on the shelf, including one with the title \"The Secret Life of Plants\" and another with the title \"How to Keep Your Houseplants Alive.\" There is a mug of coffee on the shelf as well.'},\n", + " {'image_id': '394',\n", + " 'caption': 'This is a diagram of a building with several floors, including the ground floor, first floor, second floor, third floor, and fourth floor. Each floor has several rooms with different functions, such as a kitchen, living room, bedroom, bathroom, and office. The building also has a rooftop terrace with a view of the city.'},\n", + " {'image_id': '395',\n", + " 'caption': 'The theme of this image is success and accomplishment.'},\n", + " {'image_id': '396',\n", + " 'caption': 'This painting depicts a group of people gathered around a table, enjoying a meal together. The colors used in the painting are vibrant and add to the joyful atmosphere of the scene. The artist has paid attention to detail, as seen in the intricate patterns on the tablecloth and the expressions on the faces of the people in the painting. The use of light and shadow creates a sense of depth and makes the painting come alive. Overall, it is a beautiful piece of art that captures a moment of happiness and togetherness.'},\n", + " {'image_id': '397',\n", + " 'caption': 'The image shows a table with a white tablecloth and two chairs. On the table, there is a photo of a woman in a wedding dress and a man in a tuxedo, as well as a bouquet of flowers. The wall behind the table is decorated with pictures of the bride and groom.'},\n", + " {'image_id': '398',\n", + " 'caption': 'The image shows a group of three people, two women and one man, standing together in a hallway. They are all wearing backpacks and smiling at each other. The woman on the left is wearing a white shirt and black pants, while the woman on the right is wearing a black shirt and white pants. The man in the middle is wearing a white shirt and black pants. They are all standing in a row, with the woman on the left standing closest to the camera and the man in the middle standing closest to the wall. The sun is shining through the windows behind them, casting a warm light on their faces.'},\n", + " {'image_id': '402',\n", + " 'caption': 'This image shows a close up view of a pork roast cooking in a slow cooker that is made of black plastic and has a removable lid. The pork roast has been seasoned with herbs and spices and is browning on the outside while cooking to perfection on the inside. The slow cooker is placed on a white countertop with other kitchen appliances visible in the background.'},\n", + " {'image_id': '403',\n", + " 'caption': 'The image shows a hotel room with a large bed, a desk, a chair, and a television. The walls are painted white and there is a large window with wooden blinds. The carpet is a light brown color and there are two lamps on either side of the bed. The room appears to be well lit and spacious.'},\n", + " {'image_id': '404',\n", + " 'caption': 'There are several rows of seats in the dining car, each with a table in front of them. The seats are upholstered in a light beige color with red and blue accents on the armrests. The tables are made of wood and have white tablecloths on them. There is a large window behind the seats that lets in natural light. The walls are painted in a light gray color and there are several light fixtures hanging from the ceiling.'},\n", + " {'image_id': '405',\n", + " 'caption': 'life and delicious cuisine, and many tourists visit the island specifically to experience both.\\n\\nThe image depicts a white windmill with a red and white striped body on top of a hill overlooking the ocean. A small building with white walls and a red roof is in the foreground. There are several boats in the water and some buildings on the shore in the background. The sky is clear and blue with a few fluffy clouds. The windmill is an iconic symbol of Mykonos, a Greek island in the Aegean Sea, and was used to grind wheat and other grains into flour. The small building in the foreground may be a taverna, a type of restaurant or cafe that serves traditional Greek food and drinks.'},\n", + " {'image_id': '406',\n", + " 'caption': 'The image shows a small plane flying over a body of water with clouds in the background. The plane appears to be flying at a low altitude, with its nose pointed down towards the water. The clouds in the background are white and fluffy, with some of them appearing to be shaped like cotton balls. The sky is a bright blue color, with a few small, white clouds scattered throughout it. The water below the plane is a deep blue color, with some small waves visible on its surface. There are no other objects visible in the image besides the plane and the clouds.'},\n", + " {'image_id': '408',\n", + " 'caption': 'The image shows a group of children in a boat on a river with ducks and geese swimming in the water. The children are smiling and enjoying their time on the river. There is a forest in the background with trees and greenery. The sky is clear and blue with fluffy clouds. The overall mood of the image is happy and carefree.'},\n", + " {'image_id': '409',\n", + " 'caption': 'This image depicts a set of stairs with colorful book covers on each step, which appear to be from the Harry Potter series by J.K. Rowling.'},\n", + " {'image_id': '412',\n", + " 'caption': 'The image shows a balcony or terrace with a table and chairs overlooking a lush green valley. There are trees and mountains in the background, and the sky appears to be clear and blue. The furniture on the balcony is made of wood, and there are plants in pots on the table. The overall feeling of the image is peaceful and serene, with a sense of being surrounded by nature.'},\n", + " {'image_id': '414',\n", + " 'caption': 'The image shows the entrance to a garden. The gate is made of wrought iron and decorated with vines and flowers. The garden walls are made of stone and covered in ivy. The path leading to the gate is made of cobblestones and lined with trees.'},\n", + " {'image_id': '415',\n", + " 'caption': 'The red brick building with large windows and a green lawn in front of it appears to be a well-maintained residential or office complex surrounded by trees. The building has several floors with apartments or offices on each floor, and the windows are made of glass, allowing natural light to enter the building. The sidewalk in front of the building is wide and has several benches, while the cars parked on the street are mostly sedans and SUVs.'},\n", + " {'image_id': '417',\n", + " 'caption': 'The image shows a dirt road lined with colorful trees on either side. The trees have bright red, orange, and yellow leaves. The sky is a bright blue with fluffy white clouds. There is a wooden fence on the left side of the road and a grassy area on the right. The road appears to be winding and going through a rural area.'},\n", + " {'image_id': '419',\n", + " 'caption': \"The image shows a table with different items on it, such as a book, a cup of coffee, a vinyl record, and a wooden keychain with the word 'person' engraved on it. The background is a wooden surface with scratches and imperfections.\"},\n", + " {'image_id': '421',\n", + " 'caption': \"This image shows a person's hand wearing purple gloves holding up a piece of metal that has been cut into the shape of a rectangle. The metal has a shiny surface and appears to be made of a thin sheet of metal. The person's hand is positioned in front of a green background.\"},\n", + " {'image_id': '424',\n", + " 'caption': 'The image shows a man sitting on the balcony of a building overlooking the ocean. The man is wearing a black t'},\n", + " {'image_id': '425',\n", + " 'caption': 'The image shows a person riding a mountain bike down a dirt trail in the middle of a lush green forest. The person is wearing a yellow shirt and black pants, and has a backpack on their back. The trail is narrow and winds through the trees, with dirt and rocks on either side. The sky is clear and blue, with fluffy clouds in the distance. There are no other people or objects in the image.\\n\\nDescription:\\n\\n* The image shows a person riding a mountain bike down a dirt trail in the middle of a lush green forest.\\n* The person is wearing a yellow shirt and black pants, and has a backpack on their back.\\n* The trail is narrow and winds through the trees, with dirt and rocks on either side.\\n* The sky is clear and blue, with fluffy clouds in the distance.\\n* There are no other people or objects in the image.'},\n", + " {'image_id': '426',\n", + " 'caption': 'This is an image of a hair clipper with a black and silver body and a cord attached to it, plugged into an electrical outlet on the right side of the image. The clipper has a rotating blade on the top that can be adjusted to different lengths. Its handle is made of black plastic and has a comfortable grip, with a switch that controls the power of the clipper.'},\n", + " {'image_id': '427',\n", + " 'caption': \"The image shows a view of a lake with mountains in the background. There is a wooden bench sitting on the grass next to the water's edge. The sky is clear and there are some clouds in the distance. It looks like a peaceful place to relax and enjoy the scenery.\"},\n", + " {'image_id': '429',\n", + " 'caption': 'The image shows a man in a tuxedo holding a trophy. The man is smiling and holding the trophy with both hands. He is wearing a black tuxedo with a white shirt and black tie. The trophy is made of metal and has a rectangular shape with rounded edges. It is engraved with the name of the award and the year it was given. The background is a dark color, possibly black, and there are no other objects or people visible in the image.'},\n", + " {'image_id': '431',\n", + " 'caption': 'The painting depicts a church with a tall steeple, a large stained glass window, and a cemetery with several graves and headstones. The sky is a deep blue with a few white clouds, and the sun is setting behind the church, casting a warm orange glow on the building and the surrounding area.'},\n", + " {'image_id': '433',\n", + " 'caption': 'This image depicts a robotic hand reaching out to a human hand. The robotic hand is made of metal and plastic, with fingers that can move and grip objects. The human hand is also made of metal and plastic, with fingers that can move and grip objects. Both hands appear to be reaching out to each other, as if they are trying to touch or shake hands. The image is in black and white, with a white background.\\n\\nThe image shows a robotic hand reaching out to a human hand. The robotic hand is made of metal and plastic, with fingers that can move and grip objects. The human hand is also made of metal and plastic, with fingers that can move and grip objects. Both hands appear to be reaching out to each other, as if they are trying to touch or shake hands. The image is in black and white, with a white background.'},\n", + " {'image_id': '434',\n", + " 'caption': 'This is a living room with white furniture, including a couch, chairs, and a coffee table. The walls are painted in a light beige color, and there is a fireplace in the corner of the room. The flooring is hardwood, and there is a rug on the floor in front of the couch. The windows are large and let in a lot of natural light.'},\n", + " {'image_id': '435',\n", + " 'caption': 'The image shows a group of people in brightly colored kayaks on a large body of water. The sky is overcast and cloudy, with dark clouds in the background. The people in the kayaks appear to be smiling and enjoying their time on the water. There are several other kayaks in the background, as well as a few people standing on the shore. The water is calm and still, with no waves or ripples visible. The overall mood of the image is one of relaxation and enjoyment.'},\n", + " {'image_id': '438',\n", + " 'caption': 'The image is a pair of sunglasses. The frame is made of tortoiseshell acetate and has a rectangular shape with rounded edges. The lenses are tinted in a gradient shade of purple. The sunglasses have no visible branding or logos on them.\\n\\nIn terms of style, the sunglasses have a classic, timeless look that would work well with a variety of outfits, from casual to formal. The tortoiseshell acetate frame gives the sunglasses a sophisticated, elegant look, while the purple lenses add a touch of playfulness and personality.\\n\\nOverall, these sunglasses are a great choice for anyone looking for a versatile, stylish pair of sunglasses that can be worn in a variety of settings.'},\n", + " {'image_id': '442',\n", + " 'caption': 'The woman is wearing a white shirt and blue jeans while holding a straw basket. She stands in front of a stone building with arches and a wooden door on a cobblestone street. Trees are visible in the cloudy background.'},\n", + " {'image_id': '443',\n", + " 'caption': 'The image shows a group of people standing on top of a snow-covered mountain at sunset. The sun is setting in the background, casting a warm orange glow over the scene. The people in the image are wearing winter clothing and appear to be enjoying the view from the top of the mountain. There are some rocks and boulders in the foreground, as well as some trees in the background. The overall mood of the image is peaceful and serene.'},\n", + " {'image_id': '445',\n", + " 'caption': 'The image shows a large group of people standing in front of a white building. They are holding signs and looking at the camera. There is a large American flag hanging from the top of the building. The people in the image are diverse in age and ethnicity. They are standing in front of the building, which appears to be the White House.'},\n", + " {'image_id': '448',\n", + " 'caption': 'This image shows a woman sitting on a large mat in the middle of a desert. The mat is covered in colorful pillows and blankets. The sky is clear with a few clouds in the distance. The woman is wearing a white shirt and black pants, with her hair tied back in a ponytail. No other people or structures are visible.'},\n", + " {'image_id': '449',\n", + " 'caption': 'The image is a black and white illustration of an old fashioned pickup truck. The truck appears to be vintage and has an open bed with a wooden tailgate. The front of the truck has a large grille and headlights, while the sides have large fenders and tires. The back of the truck has a bumper with a license plate and a pair of taillights. The truck appears to be in good condition, with no major dents or scratches. The tires appear to be in good shape, with no signs of wear or tear. The overall appearance of the truck suggests that it is a classic, vintage vehicle that has been well maintained over the years.'},\n", + " {'image_id': '451',\n", + " 'caption': 'The image shows a withered red tulip in a clear glass vase on a bright green background.'},\n", + " {'image_id': '452',\n", + " 'caption': \"This image is a hand-drawn doodle of different objects like food, drinks, and other items. The objects are depicted in a cartoon style with simple lines and basic shapes. The colors used are mostly black and white, with some shading and highlights added to provide depth and dimension. The overall effect is a playful and whimsical design suitable for various purposes like children's books, party decorations, or greeting cards.\"},\n", + " {'image_id': '454',\n", + " 'caption': 'This image shows a microphone in a recording studio. The microphone has a black body with a silver grille and a silver stand that is adjustable. The background of the image is a green screen mounted on the wall behind the microphone and extends to the top of the image. There are no other objects or people visible.'},\n", + " {'image_id': '456',\n", + " 'caption': 'The man in the image is wearing a red coat, black pants, and a black hat with a feather. He is holding a sword in one hand and a pistol in the other. He is standing on a rock in the middle of a body of water. The sky is dark and stormy, with lightning flashing in the distance. The man appears to be a pirate, with a long beard and a scruffy appearance.'},\n", + " {'image_id': '457',\n", + " 'caption': 'The image shows a woman wearing a white wedding dress with spaghetti straps and a plunging neckline. The dress has a lace bodice and a long, flowing skirt. The woman is smiling and holding the train of her dress, which is draped behind her. She is standing in front of a white backdrop.'},\n", + " {'image_id': '458',\n", + " 'caption': 'The woman in the image is wearing a lilac colored dress with a cowl neck and long sleeves. The dress has a high slit on the side, revealing her legs. She is also wearing a pair of beige suede ankle boots with a small heel. Her hair is styled in loose waves and she has a pair of sunglasses perched on her head. She is holding a small white purse and standing in front of a white door with a wreath on it.'},\n", + " {'image_id': '460',\n", + " 'caption': \"This image is a red shirt with white lettering that reads, `'all i want for christmas is to sleep in heavenly peace'. The lettering is written in a casual, handwritten style and is centered on the front of the shirt. The shirt appears to be a standard, short-sleeved t-shirt with a crew neckline. It is not clear from the image what material the shirt is made of, but it appears to be a thin, lightweight fabric. The image does not show any other details about the shirt.\"},\n", + " {'image_id': '461',\n", + " 'caption': 'The image shows a dart hitting a bullseye on a target. There are three darts in the bullseye, with one in the center and two on either side. The darts are colored red, blue, and green. The background is a blue sky with clouds. The image is a flat design, with no shading or texture. It is a simple illustration of a target with darts hitting the bullseye.'},\n", + " {'image_id': '463',\n", + " 'caption': 'white jersey with a red, white, and blue design on it, along with black shorts and shoes with white soles. The man is wearing a black and white helmet with a red and white stripe, black gloves with white stripes, and a black and white cap with a red and white stripe. He is also wearing black socks with white stripes and black and white sunglasses. The bicycle he is riding has black handlebars and black wheels, and the track he is riding on is made of asphalt with white lines. The background of the image is a blue sky.'},\n", + " {'image_id': '464',\n", + " 'caption': 'The bike in the image is a full suspension mountain bike with a silver frame and black and blue accents. It has 26 inch knobby tires on both the front and rear. The bike is equipped with a dropper post, which enables the rider to lower the saddle for better control on steep descents.'},\n", + " {'image_id': '466',\n", + " 'caption': 'This image shows a large crowd of people gathered on a grassy area in front of a row of white tents. In the background, there are several large buildings with balconies and windows. The sky is cloudy and there are a few fluffy clouds. The people in the image are dressed in a variety of clothing, including shorts, t shirts, and hats. Some are carrying drinks and others are chatting with each other. There are also a few vendors selling food and other items.'},\n", + " {'image_id': '467',\n", + " 'caption': 'The image shows a small garden area with chairs and an umbrella. The grass is well-kept and the area is surrounded by trees and a fence. The sky is clear and blue with a few distant clouds visible.'},\n", + " {'image_id': '468',\n", + " 'caption': 'There are several items on the table, including a watch, a bracelet, and a pair of earrings. The watch has a black face with white numbers and a gold band. The bracelet is made of black leather and has a gold clasp. The earrings are made of white gold and have small diamonds on them.\\n\\nThe watch has a black face with white numbers and a gold band. The bracelet is made of black leather and has a gold clasp. The earrings are made of white gold and have small diamonds on them.'},\n", + " {'image_id': '469',\n", + " 'caption': 'The image depicts a wooden shelf with clear glass objects, such as a vase, glass, and bottle, on it. The shelf has a light brown color and is set against a white background.'},\n", + " {'image_id': '470',\n", + " 'caption': 'This image depicts a cartoon character standing in front of an exit sign in a hospital corridor. The character is wearing a business suit and holding a briefcase with his arms crossed and a look of determination on his face. The exit sign has an arrow pointing to the right, indicating that it leads to the outside of the building. The image could be used to represent the idea of leaving a place or completing a task, symbolizing determination and readiness to move on to the next stage. The exit sign could also symbolize the end of a journey or a difficult situation.'},\n", + " {'image_id': '471',\n", + " 'caption': 'This image shows a large, luxurious house made of wood and stone, with large windows overlooking the ocean. A swimming pool in the front yard, surrounded by lush greenery and trees. The beach is visible in the distance, with waves crashing against the shore. The sky is clear and blue, with a few fluffy clouds floating in the distance.'},\n", + " {'image_id': '472',\n", + " 'caption': 'ard is chasing the hyenas, while the hyenas are trying to escape. The environment around them appears to be dry and rocky, with dust and dirt in the air.'},\n", + " {'image_id': '474',\n", + " 'caption': 'The image shows a table with a white tablecloth, two glasses of red wine, a plate of sliced oranges and lemons, and a small bowl of olives. A painting of a landscape with mountains and a river is hanging on the wall in the background. There is also a small vase of flowers on the table. The image depicts a cozy and inviting atmosphere with a focus on wine and food.'},\n", + " {'image_id': '475',\n", + " 'caption': 'The image shows a white building with balconies and stairs leading up to the second floor. There is a large palm tree in front of the building, and several potted plants on the ground. The building appears to be in a residential area, with other houses visible in the background.'},\n", + " {'image_id': '476',\n", + " 'caption': \"This image is a diagram of the earth's energy balance. It shows the incoming energy from the sun (solar radiation) and the outgoing energy from the earth (longwave radiation). The diagram displays the earth's atmosphere, which absorbs and reflects some of the incoming energy. The earth's surface also absorbs and reflects some of the incoming energy.\"},\n", + " {'image_id': '477',\n", + " 'caption': 'a natural backdrop. The colors are vivid and eye-catching, with the green and black of the butterfly contrasting nicely with the various shades of green in the background. The image is a beautiful representation of nature and the delicate balance of life within it.'},\n", + " {'image_id': '478',\n", + " 'caption': 'The image shows a woman wearing a white dress with a plunging neckline, standing at a red carpet event. Her hair is styled in loose, wavy waves and she has a smokey eye makeup look with dark eyeliner and brown eyeshadow. She is wearing a pair of silver earrings and a bracelet on her left wrist. She is looking directly at the camera with a serious expression on her face.'},\n", + " {'image_id': '479',\n", + " 'caption': 'The image is a seamless pattern of blue and gray roller skates on a white background, with black wheels and silver laces. It can be used for various purposes such as wallpaper, upholstery, or clothing design.'},\n", + " {'image_id': '481',\n", + " 'caption': 'This is a screenshot of a first person shooter video game set in a post-apocalyptic world. The player is standing in front of a ruined building with debris and rubble scattered around. They are holding a gun and aiming at a target in the center of the screen.'},\n", + " {'image_id': '482',\n", + " 'caption': 'This image shows a young man sitting on the grass in a park. He is wearing a black hoodie.'},\n", + " {'image_id': '483',\n", + " 'caption': 'This image shows a hotel room with a large bed, a desk, a chair, and a television. The walls are painted white and there is a large window with a view of the city. The bed is made with white linens and there are two pillows on it. The desk has a lamp and a computer on it, and there is a chair in front of it. The television is mounted on the wall and there is a small table next to it with a vase of flowers on it. The room appears to be spacious and comfortable.'},\n", + " {'image_id': '484',\n", + " 'caption': 'This image depicts a group of men posing in front of a red and white striped tent in a grassy field with trees in the distance. They are all dressed in floral shirts and shorts, and one of them is holding a beer can.'},\n", + " {'image_id': '485',\n", + " 'caption': 'This image is a seamless pattern of coffee cups with steam coming out of the top. The cups are brown and have a brown steam coming out of the top. The background is white.\\n\\nThis pattern could be used for a variety of purposes, such as wallpaper, fabric, or wrapping paper. It could also be used as a design element in a website or graphic design project.'},\n", + " {'image_id': '487',\n", + " 'caption': 'This image shows a shelf with several bottles of different types of drinks. The bottles are lined up in a row on the shelf, with some of them stacked on top of each other. The labels on the bottles indicate that they contain various types of drinks, including juices, sodas, and other beverages. The bottles are made of glass and have different colors and designs on them. The shelf appears to be made of wood, and there are some small shelves on the wall behind the bottles. The overall color scheme of the image is warm and inviting, with a mix of natural and artificial lighting.'},\n", + " {'image_id': '488',\n", + " 'caption': 'The woman in the image is wearing a grey coat, black tights, and knee-high boots. She is carrying a black handbag and standing next to a wooden fence made of wooden planks. There is a row of bushes growing along the side of the fence. The woman is looking down at her black phone with a white screen. The image is taken from a distance, and the woman is standing in front of the fence with her back to the camera.'},\n", + " {'image_id': '489',\n", + " 'caption': 'This image is a photograph of a white bowl filled with a salad made up of a variety of greens, including romaine lettuce, red radishes, and thin slices of red onion. The bowl is sitting on top of a wooden table with a white tablecloth. There is a fork and knife in the bowl, as well as a sprig of fresh rosemary on the side of the bowl. The overall color scheme of the image is bright and fresh, with the green of the lettuce and radishes contrasting with the white of the bowl and tablecloth.'},\n", + " {'image_id': '490',\n", + " 'caption': 'The image shows a white convertible car parked in a large, white room. The car has a sleek and modern design, with a long hood and a sloping roofline. The front of the car has a large grille and headlights, and the sides have large wheels and tires. The car appears to be in excellent condition, with no visible scratches or dents.'},\n", + " {'image_id': '492',\n", + " 'caption': 'The image shows three white bowls filled with different spices, including turmeric, cinnamon, and ginger. There is also a wooden spoon in one of the bowls, which appears to be stirring the mixture. The background is a wooden table with a rustic texture.'},\n", + " {'image_id': '494',\n", + " 'caption': 'The image shows a young boy sitting on the floor with a pacifier in his mouth. He is wearing a yellow shirt and green overalls. The background is white. The image is a cartoon illustration.'},\n", + " {'image_id': '495',\n", + " 'caption': \"woman in a military uniform, wearing a long coat, hat, gloves, and belt with a buckle. She is standing with her hands on her hips and looking directly at the camera. Her hair is styled in a bob and she is wearing a pair of sunglasses. The background is not visible, but it appears to be a studio setting. The photograph is of high quality and the details of the woman's uniform and accessories are clearly visible.\"},\n", + " {'image_id': '496',\n", + " 'caption': 'This is a large, red brick house with a green lawn and palm trees in the front yard. There is a driveway leading up to the house and a garage on the right side. The windows have white shutters, and the roof is tiled with a chimney on the left side. The lawn is well-manicured with a sprinkler system in place, and the street is lined with palm trees and a sidewalk leading up to the house.'},\n", + " {'image_id': '497',\n", + " 'caption': \"The image depicts a person standing before a large sphinx statue made of stone. The statue is in the shape of a lion with a human head. The person is gazing up at the night sky filled with stars and constellations, including the Big Dipper and Orion's Belt. The person seems to be enjoying the view.\"},\n", + " {'image_id': '498',\n", + " 'caption': 'This is an image of a woman holding a trophy. She is wearing a blue dress and standing in front of a red and black background. The trophy is made of metal and has an engraved design on it. The woman is smiling and holding the trophy with both hands. There are other people in the background, but they are not visible in this image.'},\n", + " {'image_id': '500',\n", + " 'caption': \"This image appears to be a page from a book, with a black and white illustration of a cat sitting on a windowsill. The cat is looking out the window and appears to be staring at something outside. The image is in black and white, with the cat's fur and the scenery outside sketched in intricate detail.\"},\n", + " {'image_id': '501',\n", + " 'caption': 'This is a collage of four different characters from the TV show Arrow. From left to right, the characters are: 1. Oliver Queen, also known as the Arrow, 2. Barry Allen, also known as the Flash, 3. Kara Danvers, also known as Supergirl, and 4. Clark Kent, also known as Superman. These characters are all part of the DC Comics universe and have appeared in various TV shows and movies.'},\n", + " {'image_id': '502',\n", + " 'caption': 'The image shows a white 2020 Infiniti QX80 driving on a dirt road surrounded by trees. The vehicle has a large grille and headlights, with the Infiniti logo on the front. It has large wheels and tires, and there is a spare tire on the back. The windows are tinted, and there is a sunroof on the top. The vehicle appears to be in good condition, with no visible damage.'},\n", + " {'image_id': '503',\n", + " 'caption': 'The painting depicts the ruins of an ancient temple on a hill overlooking a lake at sunset. The temple is in a state of disrepair, with crumbling columns and broken pediments. The sky is a vibrant orange and pink at sunset, with clouds in the distance. The water in the lake is calm and reflects the sky. There are no people or animals in the scene.'},\n", + " {'image_id': '504',\n", + " 'caption': 'This image shows a lion standing on its hind legs with its front paws resting on the ground. The lion has a large mane and is looking to the left. The image is in front of a white background.'},\n", + " {'image_id': '506',\n", + " 'caption': 'This image shows a group of people on an airplane. They are all sitting in the aisle, with some standing in the back of the plane. They are all looking at the camera, with some smiling and others looking serious. The plane appears to be a small one, with only a few rows of seats. The windows are tinted, making it difficult to see outside. The interior of the plane appears to be clean and well maintained.'},\n", + " {'image_id': '507',\n", + " 'caption': \"The image is a silhouette of an eagle in flight, with its wings spread out and its talons open, appearing to be soaring through the sky with the sun shining behind it. The eagle's body and wings are outlined in brown against a black and white background.\\n\\nThe eagle is a symbol of strength, courage, and freedom in various cultures around the world and is often used as a symbol of the United States. It is known for its sharp vision to spot prey from high up in the sky and its powerful talons to catch and kill its prey. The eagle is a majestic and powerful bird that is frequently depicted in art and other forms of media.\"},\n", + " {'image_id': '508',\n", + " 'caption': 'The image shows a night scene with a full moon shining brightly in the sky. In the foreground, there is a silhouette of a tree standing alone on a hill.'},\n", + " {'image_id': '509',\n", + " 'caption': 'The painting depicts a group of people sitting in the shade of a tree in a park. There is a woman holding a small plant in her hand, sitting on the ground with her back to the viewer. Behind her, a man and another woman are sitting on a bench, with the latter facing the viewer. In the background, there is a row of trees and a path leading into the distance. The colors used in the painting are muted and earthy, with green and brown tones dominating. The figures are depicted realistically, with attention paid to their clothing and facial expressions. The tree in the foreground is detailed, with individual leaves and branches visible. The painting has a peaceful and serene mood, with a well-balanced composition.'},\n", + " {'image_id': '510',\n", + " 'caption': 'The image shows a large cave with a river flowing through it. The walls of the cave are made up of large boulders and rock formations. The water in the river is crystal clear and there is a small waterfall coming down from the top of the cave. The cave is surrounded by lush greenery and trees. There is a small path leading to the entrance of the cave.'},\n", + " {'image_id': '511',\n", + " 'caption': \"This image shows a wedding ceremony taking place in a large room with a long aisle lined with chairs. The aisle is decorated with flowers and there are two large windows on either side of the room, letting in natural light. The bride and groom are standing at the end of the aisle, facing each other and holding hands. The bride is wearing a white wedding dress and the groom is wearing a black tuxedo. The guests are seated in the chairs and watching the ceremony. On the wall behind the bride and groom, there is a large banner with the words 'I remember this day forever and always' written on it.\"},\n", + " {'image_id': '513',\n", + " 'caption': 'This image depicts a man in a suit and glasses standing with his arms outstretched and a big smile on his face. He is wearing a beige suit and brown shoes. The background is white.\\n\\nThe man is wearing glasses and a beige suit. He is standing with his arms outstretched and a big smile on his face. He is wearing a beige suit and brown shoes. The background is white.'},\n", + " {'image_id': '514',\n", + " 'caption': 'This image shows a blender filled with sliced cucumbers, watermelon, and other ingredients. The blender has a stainless steel blade and a clear plastic container with measurements on the side. The image is on a white background with a pink and white striped towel in the background.'},\n", + " {'image_id': '515',\n", + " 'caption': 'The image shows a map of the world made up of gold coins. The coins are arranged in the shape of the continents and countries on the map. The image is on a black background.'},\n", + " {'image_id': '516',\n", + " 'caption': 'The image shows a red silk or satin envelope adorned with gold heart-shaped decorations.'},\n", + " {'image_id': '517',\n", + " 'caption': 'This is an image of a person wearing a football helmet and holding a football. The text on the image reads, \"Kittle over the middle,\" which is likely a reference to a football play where the quarterback throws the ball to a tight end in the middle of the field. The person in the image is wearing the jersey of the San Francisco 49ers, a professional football team in the National Football League (NFL). The team\\'s colors are red, gold, and white, and their logo is a stylized version of the number 49. The helmet on the person\\'s head is also red and gold, with the team\\'s logo on the side. The football in the person\\'s hand is also red and white, with the team\\'s logo on it.'},\n", + " {'image_id': '518',\n", + " 'caption': 'The image is a black and white illustration of a bouquet of flowers on a black background. The flowers are drawn in a simple, stylized style, with each petal outlined in white. The bouquet is arranged in a loose, casual style, with the stems and leaves trailing off the sides of the image. The flowers include roses, peonies, and daisies, giving the bouquet a charming rustic look, perfect for country or rustic themed designs or events.'},\n", + " {'image_id': '519',\n", + " 'caption': 'The image shows a hallway with blue walls, a white door, and a black rubbish bin. The walls are painted in a light shade of blue, and the floor is made of wooden planks. The door has a white frame and a small window at the top. The rubbish bin is made of plastic and has a black lid. There are no other objects in the hallway.\\n\\nThe walls are painted in a light shade of blue.\\n\\nThe floor is made of wooden planks.\\n\\nThe door has a white frame and a small window at the top.\\n\\nThe rubbish bin is made of plastic and has a black lid.\\n\\nThere are no other objects in the hallway.'},\n", + " {'image_id': '520',\n", + " 'caption': 'The image shows a man wearing a top hat, trench coat, and boots walking down a city street with his back to the camera. He is carrying a large backpack and appears to be looking at something in the distance. There are several buildings in the background, including a tall one with a clock tower on top. The overall tone of the image is dark and mysterious.'},\n", + " {'image_id': '521',\n", + " 'caption': \"This image shows a sign hanging from the side of a brick building that says `future's closet boutique' in white letters on a black background. The letters are stylized and have a futuristic look. The sign appears to be made of metal or plastic. No other details are visible in the image.\"},\n", + " {'image_id': '522',\n", + " 'caption': 'The image shows a group of people dressed in formal attire, standing on a red carpet at a movie premiere. The men are wearing black tuxedos and the women are wearing a red dress. They are all smiling and posing for the camera. In the background, there are posters and banners for the movie they are at the premiere for.'},\n", + " {'image_id': '523',\n", + " 'caption': 'which make up the majority of their diet. Koalas are also known for their slow metabolism and low energy levels, which is why they spend most of their time sleeping in trees. Koalas are native to Australia and are considered a national symbol. However, they are listed as a vulnerable species due to habitat loss and disease. Conservation efforts are underway to protect koalas and their habitats.'},\n", + " {'image_id': '524',\n", + " 'caption': 'This image shows the superficial muscles of the human body, including the biceps, triceps, pectorals, and deltoids. The biceps bend the elbow and flex the forearm, while the triceps straighten the elbow and extend the forearm. The pectorals move the arms forward and upward, and the deltoids move the arms backward and downward.'},\n", + " {'image_id': '525',\n", + " 'caption': 'in a dimly lit room with a curtain in the background. The image depicts a romantic and intimate scene between the two actors.'},\n", + " {'image_id': '526',\n", + " 'caption': 'This image shows a living room with a fireplace and a chair in front of it. The walls are made of bricks and there is a clock on the wall above the fireplace. The floor is made of wooden planks and there is a rug in front of the fireplace. The room is well lit and there are curtains on the windows.'},\n", + " {'image_id': '527',\n", + " 'caption': 'This image is a set of thin line icons related to social media and communication. The icons include a speech bubble, a thought bubble, a heart, a speech balloon, a chat bubble, a smiley face, a thumbs up and a thumbs down. The icons are arranged in a grid pattern on a white background, and they are simple and minimalistic in design, making them suitable for use in various applications.\\n\\nThe icons can be used to create a consistent visual identity for a brand or product, and they can represent various actions and emotions related to social media, such as sharing, liking, commenting, and connecting with others. They are versatile and can be used in various contexts, such as in marketing materials, presentations, and infographics.'},\n", + " {'image_id': '529',\n", + " 'caption': \"This image is a black and white photograph of a man wearing a baseball cap and holding his hands up to his face, as if he's covering his eyes. The man's face is obscured by shadows, but you can see the outline of his features. The background of the image appears to be a dark, solid color. There are no other visible objects or elements in the image, except for the man's hands and the baseball cap he's wearing.\"},\n", + " {'image_id': '531',\n", + " 'caption': 'The image shows a dog and a cat lying on a red and black blanket on the floor. The dog has its mouth open and appears to be panting, while the cat is lying on its side with its paws tucked underneath it. The background of the image appears to be a living room with a couch and other furniture in the background.'},\n", + " {'image_id': '532',\n", + " 'caption': \"The image shows a luxurious resort on a lush green hillside. The resort comprises several wooden buildings with large windows providing natural light. The surroundings are filled with trees and greenery, creating a serene environment. The picture was taken at night, with the buildings' lights shining brightly against the dark sky.\"},\n", + " {'image_id': '534',\n", + " 'caption': \"The image shows a pregnant woman holding a piece of paper with two drawings on it. The drawings are of a man and a woman, with the man holding the woman's hand. The woman's stomach is visible in the image, and she is wearing a yellow shirt.\"},\n", + " {'image_id': '535',\n", + " 'caption': 'The image depicts a woman sitting at a sewing machine, surrounded by flowers. She is wearing a white apron and has a pair of scissors in her hand. The background is floral with pink, purple, and white flowers. The woman is smiling and appears to be happy while working on her sewing project. The theme of the image is creativity and craftsmanship, and the message is that creativity and hard work can lead to happiness and fulfillment.'},\n", + " {'image_id': '536',\n", + " 'caption': 'This image is a logo for a hair salon. The logo features a silhouette of a woman\\'s head with long, curly hair in shades of purple and blue. The words \"you gane hair\" are written in elegant script underneath the silhouette. The design is simple and elegant, with a focus on the hair and the salon\\'s name. It could be used on business cards, flyers, and other promotional materials for the salon.'},\n", + " {'image_id': '538',\n", + " 'caption': ', the image depicts glasses of green smoothie made with avocado and garnished with sliced avocado and mint leaves. The avocado provides healthy fats, vitamins, and minerals and adds creaminess to the smoothie. The mint leaves add freshness and a cooling sensation. Sliced avocado also adds texture and flavor to the drink.'},\n", + " {'image_id': '539',\n", + " 'caption': \"This is an image of a person holding a small black and tan dachshund's mouth open to reveal its teeth. The dog is wearing a collar with a tag on it. The person is using a toothbrush to brush the dog's teeth. The image is in focus, with the person and dog in sharp relief against the white background.\"},\n", + " {'image_id': '540',\n", + " 'caption': 'The woman in the image is wearing a white dress with a floral pattern on it, which has a high neckline and long sleeves. She is also wearing a black blazer over a white shirt with a collar, which is tucked into the dress. The woman is holding a brown bag in her left hand and has her right hand in her pocket. She is standing in front of a mirror, looking at herself. The room appears to be a bedroom with a bed, white comforter, and pillows in the background. The walls are painted a light color and there are white curtains on the windows. The floor is wooden with a white rug on the ground. Overall, the image depicts a woman taking a selfie in front of a mirror in a bedroom.'},\n", + " {'image_id': '541',\n", + " 'caption': 'This is a black and white photograph of an old car parked on a street in Havana, Cuba. The car appears to be a vintage model, possibly from the 1950s or 1960s. It is parked on the right side of the road, facing in the direction of the camera. There are no people or other vehicles visible in the image. The street is lined with old buildings on both sides, some of which appear to be in disrepair. The sky is cloudy and overcast, with the sun setting behind the buildings on the left side of the image. The overall mood of the image is one of nostalgia and decay.'},\n", + " {'image_id': '543',\n", + " 'caption': 'This is a photo of a room with a lot of old, rustic items in it. The walls are made of wooden planks and there is a wooden floor. The room is dimly lit by a few lanterns hanging from the ceiling. There is a large wooden table in the center of the room, covered in various items such as bottles, pots, and pans. Some old tools, such as hammers and saws, are hanging on the walls. The overall atmosphere of the room is very rustic and old fashioned.'},\n", + " {'image_id': '544',\n", + " 'caption': 'The image shows a group of plants growing in a garden. The plants are tall and green, with long, thin leaves. They appear to be growing in a row, with some of them leaning over the edge of the garden bed. There is a wooden fence in the background, and some trees can be seen in the distance. The overall color scheme of the image is green, with some brown and gray tones in the sky and the fence.'},\n", + " {'image_id': '546',\n", + " 'caption': 'This image shows a bride standing in front of a mirror, looking at her reflection. She is wearing a white wedding dress and has her hair styled in a loose bun. The bride is holding a bouquet of flowers in her hand. The room is decorated with white flowers and candles, and there is a window with white drapes in the background.'},\n", + " {'image_id': '548',\n", + " 'caption': 'The man in the image is wearing a gray suit, a black hat, and a white shirt. He is standing with his hands in his pockets and giving a thumbs up gesture. The background is white.'},\n", + " {'image_id': '549',\n", + " 'caption': 'The painting depicts a landscape with a river running through it, with trees on either side. The sky is dark and stormy, with clouds and lightning in the distance. In the foreground, there is a woman standing on the bank of the river, looking out at the storm. Behind her, there is a man standing on a bridge, looking out at the storm as well. In the background, there are mountains and more trees, with the stormy sky continuing into the distance.'},\n", + " {'image_id': '550',\n", + " 'caption': 'In the image, there is a bowl of cereal on a wooden table with a spoon next to it. The cereal appears to be a mixture of oatmeal, pomegranate seeds, and other ingredients. The background is a brown wooden surface.'},\n", + " {'image_id': '552',\n", + " 'caption': \"The image is a quote that reads, `'casting all your cares upon him, for he cares for you.' It is written in a calligraphy style, with the words cast and cares written in a bold, black font and the rest of the quote written in a lighter, cursive font. The background of the image is a light blue or turquoise color, and there is a white border around the text. The overall design of the image is simple and elegant, with the focus on the text and the message it conveys.\"},\n", + " {'image_id': '553',\n", + " 'caption': 'This is an image of a woman riding a horse in an indoor riding arena. The woman is wearing a helmet and riding gear, and the horse is wearing a bridle and saddle. The arena has a dirt floor and wooden walls, and there are other horses and riders in the background. The woman is holding the reins with her hands. The horse is standing still, and the woman is smiling. The lighting in the arena is bright, and there are shadows on the walls from the sunlight coming in through the windows. The overall mood of the image is peaceful and happy.'},\n", + " {'image_id': '555',\n", + " 'caption': 'This is a pair of sunglasses sitting on top of a wooden table. The sunglasses have a black frame and brown lenses. The lenses are tinted and the frame is made of metal. The sunglasses have a brown leather strap that goes around the back of the head. There is also a brown leather case on the table next to the sunglasses. The case is open and you can see the sunglasses inside.'},\n", + " {'image_id': '556',\n", + " 'caption': \"This is an image of a female doctor examining a patient's neck. The doctor is wearing a white lab coat and has a stethoscope around her neck. The patient is lying on an examination table and is looking up at the doctor, who is holding a stethoscope to the patient's neck. The room is well lit and has a white background.\"},\n", + " {'image_id': '557',\n", + " 'caption': 'This image is a photograph of a courtyard with a rectangular stone fountain in the center. The courtyard is surrounded by arches and domes, adorned with intricate geometric patterns on the walls. The water in the fountain is clear and reflects the blue sky above. A person, wearing a blue shirt and pants with their hands in their pockets, stands on the edge of the fountain, looking at the camera. The courtyard is otherwise empty except for the fountain and the person.'},\n", + " {'image_id': '558',\n", + " 'caption': ' The bike in the image is a full suspension mountain bike with a blue and white color scheme. The frame is made of aluminum and has a carbon fiber front triangle. The bike has 27.5 inch wheels and a dropper post, which allows the rider to lower the saddle for better control on steep descents.'},\n", + " {'image_id': '560',\n", + " 'caption': 'This image is a cartoon illustration of a baby sleeping on the crescent of the moon. The baby is wearing a blue and white outfit and has a pacifier in its mouth. The background is a starry night sky.'},\n", + " {'image_id': '564',\n", + " 'caption': 'The woman in the image is sitting on a wooden chair with her legs crossed and smiling. She has long, curly brown hair and is wearing a black velvet top with silver embroidery, blue jeans, and white sneakers. The background is black and the lighting is dim.'},\n", + " {'image_id': '566',\n", + " 'caption': 'The image shows a football player in a blue and gold uniform running with the ball during a game. The player is wearing a helmet and has a number on the back of his jersey. The stadium in the background is filled with fans watching the game.'},\n", + " {'image_id': '567',\n", + " 'caption': \"The power lines and towers lead the viewer's eye towards the sunset, and the mix of orange and purple in the sky adds to the beauty of the scene. The colors are vibrant and the lighting is well done, with the sun casting a warm glow over the power plant.\"},\n", + " {'image_id': '568',\n", + " 'caption': 'The image shows a drawing on a cement wall. The drawing depicts a red heart with a black arrow pointing downwards towards the bottom of the heart. The cement wall is grey and has some cracks in it. There are no other objects or people in the image.'},\n", + " {'image_id': '569',\n", + " 'caption': 'The image shows a modern dining room with a white marble dining table and chairs. The table top has a rectangular shape and is made of white marble. The legs of the table are made of metal and have a sleek modern design. The chairs are also sleek and modern in design, made of black leather. The walls of the room are painted in a light gray color, and there is a white fur rug on the floor. In the corner of the room, there is a large white Christmas tree decorated with silver and white ornaments.'},\n", + " {'image_id': '570',\n", + " 'caption': 'This image shows a group of people gathered on the deck of a large sailboat in a harbor or marina. The boat has several masts and sails, and the people are dressed in a variety of clothing, including shorts, t-shirts, and hats. Some of them are holding drinks and chatting with each other, while others are simply standing and looking out over the water. The overall atmosphere of the image is relaxed and casual, with people enjoying a day out on the water.'},\n", + " {'image_id': '571',\n", + " 'caption': 'This is an image of a person using a screwdriver to remove the propeller from a small RC plane. The person is holding the propeller with their left hand and using the screwdriver with their right hand to loosen the screws that hold the propeller in place. The plane has a black body and green wings, and the propeller is made of black plastic with three green blades. The person is wearing black gloves and a black shirt, and there is a white table in the background with some tools on it.'},\n", + " {'image_id': '572',\n", + " 'caption': \"This image shows a bride and groom sitting in the back of a vintage car. The bride is wearing a white wedding dress with a long veil, and the groom is wearing a black tuxedo with a white shirt and black tie. They are both smiling and looking at each other. The car appears to be a classic convertible, with the top down and the wind blowing through the bride's hair. The background is blurred, but it appears to be a city street with buildings and trees in the distance.\"},\n", + " {'image_id': '575',\n", + " 'caption': \"This image appears to be a drawing of a person wearing a mask and holding a cat. The person is wearing a black and white striped shirt, black pants, and black boots. The cat is sitting on the person's shoulder and appears to be looking up at the person's face. The image is in black and white and appears to have been drawn with a pen or pencil.\"},\n", + " {'image_id': '576',\n", + " 'caption': 'The image shows two flags, one green and the other white with a red crescent and star on it. The flags are waving in the wind against a dark cloudy sky.\\n\\nThe green flag has a white crescent and star in the center. The white flag has a green crescent and star in the center. The flags are waving in the wind against a dark cloudy sky.'},\n", + " {'image_id': '577',\n", + " 'caption': 'The image shows a bedroom with a black carpet and white walls. There is a large window with white curtains and a small table with a lamp on it. The bed is made with a black and white striped comforter, and there is a black and white striped rug on the floor. A black and white striped chair is placed in the corner of the room, with a cushion on it. The bed also has a black and white striped blanket and pillow. On the nightstand, there is a black and white striped lamp and vase. The window has a black and white striped curtain, and the bathroom door has a black and white striped shower curtain. Additionally, there is a black and white striped towel on the towel rack.'},\n", + " {'image_id': '578',\n", + " 'caption': 'This image shows a man wearing glasses and a denim shirt, leaning against a wall with his hands in his pockets.'},\n", + " {'image_id': '579',\n", + " 'caption': 'This image shows a man in a grey suit and tie standing next to a yellow vintage car from the 1920s or 1930s. The man is holding a briefcase in one hand and a cell phone in the other. The image was taken on a city street with buildings and other cars visible in the background.'},\n", + " {'image_id': '581',\n", + " 'caption': 'The image shows two hands holding a bowl of popcorn'},\n", + " {'image_id': '582',\n", + " 'caption': 'The image shows a plate with a sandwich on it. Slices of bananas are on the sandwich, and a jar of peanut butter and a knife are next to it. The plate is sitting on a kitchen counter.'},\n", + " {'image_id': '585',\n", + " 'caption': 'The image is a top view of a modern garden design featuring a large pond with a fountain in the center, surrounded by a variety of trees, shrubs, and flowers. There is also a patio area with outdoor furniture, including a table and chairs. The color scheme is neutral and the design has clean lines.'},\n", + " {'image_id': '586',\n", + " 'caption': 'This image appears to be an illustration of a woman standing on a rooftop, looking down at the ground below. The woman is wearing a long, flowing dress and has her hair pulled back into a ponytail. She is holding a sword in one hand and has a determined expression on her face. The sky behind her is dark and stormy, with lightning flashing in the distance. The rooftop appears to be made of shingles or tiles, and there are several chimneys visible in the background. The overall mood of the image is ominous and tense, as if the woman is preparing for a battle or confrontation.'},\n", + " {'image_id': '587',\n", + " 'caption': 'The image shows a close up of a red velvet cupcake with white frosting on top and a bite taken out of it. The cupcake is on a black background and there are other cupcakes in the background.\\n\\nThe cupcake appears to be made with red velvet cake mix and topped with cream cheese frosting. The frosting has a smooth, creamy texture and is piped onto the cupcake in swirls. The cupcake itself is a deep red color and has a smooth, glossy finish. The overall appearance of the cupcake is visually appealing and appetizing.'},\n", + " {'image_id': '590',\n", + " 'caption': 'This image is a pattern of princesses in various poses on a white background.'},\n", + " {'image_id': '591',\n", + " 'caption': 'This image shows a pile of old rope made up of several strands twisted and knotted together. Some strands are frayed and broken, while others are still intact. The rope appears to be made of natural fibers such as hemp or jute and is covered in dirt and debris. A small amount of green twine is wrapped around the base of the pile, giving it an overall effect of neglect and abandonment.'},\n", + " {'image_id': '592',\n", + " 'caption': 'This is a photo of a shelf in a grocery store. The shelf is filled with jars of spices and seasonings, including salt, pepper, and various herbs and spices. The jars are stacked in a grid pattern and placed on a wooden shelf with a metal frame. Above the shelf, there is a sign that says \"Spices\" in large letters. It is located in the spice aisle of the grocery store.'},\n", + " {'image_id': '593',\n", + " 'caption': 'This image shows a group of people standing in front of a brick building. The building has a sign on it that reads, \"Canterbury Hospital Medical Centre.\" Some people are wearing hats. There are also plants and flowers in front of the building.'},\n", + " {'image_id': '594',\n", + " 'caption': 'This The image shows a small body of water surrounded by tall reeds and other vegetation. The water is shallow and appears to be stagnant. There is a small tree growing out of the water in the center of the image. The sky is clear and there are some clouds visible in the distance.\\n\\nIn the foreground, there are some small plants growing in the water, including some lily pads and other aquatic vegetation. There are also some small fish swimming in the water.\\n\\nIn the background, there are some trees and other vegetation visible on the banks of the water. It appears to be a wetland or marsh area.\\n\\nOverall, this is a peaceful and serene image of a natural body of water surrounded by plants and wildlife.'},\n", + " {'image_id': '595',\n", + " 'caption': 'This image shows a night scene of a beach restaurant with a thatched roof, wooden tables and chairs, and a view of the ocean in the background. The lighting is provided by lanterns hanging from the roof, casting a warm glow over the area. The atmosphere is relaxed and peaceful, with the sound of waves crashing against the shore in the background.'},\n", + " {'image_id': '596',\n", + " 'caption': 'This image shows a man wearing a blue shirt with a pattern of horses on it. The shirt has short sleeves and is unbuttoned at the collar. He is wearing pink shorts and white sneakers, and standing with his hands in his pockets while looking directly at the camera. The shirt is made of lightweight material and has a slim fit with small brown horses on a navy blue background. The pattern on the shirt is made up of small brown horses on a navy blue background. The shorts are also made of lightweight material with an elastic waistband. The sneakers are white with a rubber sole and laces. The man has short, dark hair and a well-groomed beard, and a serious expression on his face. The background is not visible.'},\n", + " {'image_id': '597',\n", + " 'caption': 'This is an image of a market stall with colorful beads hanging from the ceiling. The stall appears to be selling various types of beads and other jewelry items. There are several customers browsing through the items on display. The overall atmosphere of the image is lively and vibrant, with bright colors and a lot of activity.'},\n", + " {'image_id': '598',\n", + " 'caption': 'symbol of innocence, purity, and beauty, which makes it a popular choice for jewelry.\\n\\nOverall, the postage stamp image portrays a graceful and refined young woman, adorned with pearls and exuding a sense of tranquility.'},\n", + " {'image_id': '599',\n", + " 'caption': \"C's. The Gucci logo features the brand's name in a bold, serif font, while the Prada logo features the brand's name in a simple, sans-serif font. Overall, the image serves as a visual representation of some of the most well-known and iconic brands in the fashion industry.\"},\n", + " {'image_id': '600',\n", + " 'caption': 'This image displays a pair of grey combat boots with a floral design on the side. They have a side zipper and top laces. The rubber soles have treads for improved traction. The boots are in good shape.'},\n", + " {'image_id': '601',\n", + " 'caption': 'The image shows a The image depicts a cityscape with colorful houses and buildings on either side of the road. There is a police car parked on the side of the road, and a man walking towards it. The sky is clear and blue, with a few clouds in the distance. The image is set against a white background.'},\n", + " {'image_id': '603',\n", + " 'caption': \"The image depicts a futuristic city featuring a large floating globe surrounded by a halo of light in the foreground. The cityscape in the background showcases a combination of modern and futuristic architecture, neon lights, and towering skyscrapers that illuminate the night sky. The image conveys a sense of progress and innovation, with the globe symbolizing the world's interconnectedness and the city representing humanity's advancement towards a brighter, more technologically advanced future.\"},\n", + " {'image_id': '604',\n", + " 'caption': 'This is a red dress with white lace detailing on the sleeves and hem, featuring a sweetheart neckline and a flared skirt. The model completes the outfit with white tights and red shoes with white laces, resulting in a cute and feminine look.'},\n", + " {'image_id': '605',\n", + " 'caption': 'The sun is shining brightly in the blue sky, and there is a single sunflower in the foreground. The sunflower is standing tall and proud, with its bright yellow petals and dark brown center. The sky is a bright blue, with fluffy white clouds floating in the distance. There is a sense of peace and tranquility in this image.'},\n", + " {'image_id': '606',\n", + " 'caption': 'The image shows a large, dimly lit auditorium with rows of seats facing a stage. The stage is empty without actors or props. The auditorium has large windows that let in natural light and a high ceiling. The walls are white without decorations, and the floor is made of wooden planks without carpets or rugs. The atmosphere is empty and still.'},\n", + " {'image_id': '608',\n", + " 'caption': 'The building in the image appears to be a hotel or restaurant. It has a red brick facade with large windows and a balcony on the second floor. There are several tables and chairs on the sidewalk in front of the building, and a few cars are parked in the parking lot. The building is surrounded by trees and greenery, and there is a clear blue sky in the background.'},\n", + " {'image_id': '609',\n", + " 'caption': 'This image shows a group of women standing around a table with plates of food on it. They appear to be preparing the food for a meal. The women are wearing aprons and hats, and one of them is holding a tray of drinks. There is a large window behind them that lets in a lot of natural light. The room appears to be a kitchen or dining area.'},\n", + " {'image_id': '610',\n", + " 'caption': 'There is a white plate with chicken, rice, and green beans on it. The chicken is delicious.'},\n", + " {'image_id': '612',\n", + " 'caption': \"This is an image of a person's wrist with a metal chain attached to it. The chain has a clasp at the end and the person's hand is holding it. They are also wearing a watch on their other wrist. The background of the image is a wooden table with various objects on it.\"},\n", + " {'image_id': '613',\n", + " 'caption': 'stillness in the scene, as the tree stands alone in the vast expanse of the plain.'},\n", + " {'image_id': '614',\n", + " 'caption': 'This is an aerial view of a large, luxurious mansion made of stone surrounded by lush green trees and shrubs. It has several windows and balconies. There is a large swimming pool in the front yard and a small pond in the backyard. The property is surrounded by a tall fence and there is a gate leading to the driveway.'},\n", + " {'image_id': '615',\n", + " 'caption': 'This is a photo of a bedroom on a boat. The bed is made up with white sheets and blankets, and there are two pillows on the bed. There is a small table next to the bed with a vase of flowers on it. The walls are painted white and there is a large window that lets in a lot of natural light. The floor is made of wood and there is a rug on the floor.\\n\\nThis is a photo of a small bedroom on a boat. The bed is made up with white sheets and blankets, and there are two pillows on the bed. There is a small table next to the bed with a vase of flowers on it. The walls are painted white and there is a large window that lets in a lot of natural light. The floor is made of wood and there is a rug on the floor.'},\n", + " {'image_id': '616',\n", + " 'caption': 'The image shows a clear phone case with a red strap attached to it, lying on a white surface next to a green leafy plant. The phone case appears to be made of clear plastic and has a sleek, modern design. The red strap is made of a thick, braided material and is attached to the phone case with a metal clasp. The leafy plant in the background is a large, tropical plant with broad, green leaves and a thick, woody stem. The plant appears to be healthy and well cared for.'},\n", + " {'image_id': '617',\n", + " 'caption': 'This image shows the interior of a restaurant with a long bar and several tables with white tablecloths and black chairs. The walls are made of exposed brick and the ceiling is made of wood beams. There are several large windows letting in natural light.'},\n", + " {'image_id': '618',\n", + " 'caption': \"The image shows a man wearing a black suit with a white shirt and a green tie. The tie has a pattern of small green dots on it. He is holding the tie in his left hand and appears to be adjusting it with his right hand. The man has short, dark hair and a serious expression on his face while looking directly at the camera. The background is a dark grey and the lighting in the image is slightly dim, with shadows on the man's face and the tie. The overall mood of the image is professional and serious.\"},\n", + " {'image_id': '619',\n", + " 'caption': 'The image shows a small, white house made of wood with a pitched roof and chimney on top. The house is surrounded by lush green trees and shrubs. The windows have white frames and shutters and the front door is wooden with a small porch in front of it. The lawn in front of the house is overgrown with moss and weeds, and there is a small path leading up to the front door. The trees in the background are tall and leafy, with branches that stretch up towards the sky.'},\n", + " {'image_id': '620',\n", + " 'caption': 'This is a map that shows the location of a village in the countryside. The village is surrounded by fields and forests, and there are several roads that lead to it. The map also shows the location of a river that runs through the area. There are several buildings marked on the map, including a church, a school, and a few houses. The map also shows the location of a cemetery, which is located on the outskirts of the village.'},\n", + " {'image_id': '621',\n", + " 'caption': 'the surrounding landscape is beautifully depicted with tall trees and a gray, cloudy sky.'},\n", + " {'image_id': '622',\n", + " 'caption': 'The image shows a silver coin with a tree image on it, specifically a silver fern which is a symbol of New Zealand. It could be a commemorative or collectible item.'},\n", + " {'image_id': '623',\n", + " 'caption': 'The image depicts a two-story house with blue exterior and white trim, featuring a balcony on the second floor. The front gate is made of metal and has a sign that reads \"person\". A small garden with plants and a fountain is visible in front of the house. The sky is cloudy and it seems to be dusk.'},\n", + " {'image_id': '625',\n", + " 'caption': 'shows a rocky coastline with a small town in the background. There are some boats in the water and a few people standing on the shore. The sky is cloudy and there are some mountains in the distance.'},\n", + " {'image_id': '626',\n", + " 'caption': 'The image shows two large telescopes on top of a snowy mountain. The telescopes are white and have large domes on top of them. The sky is cloudy and there is snow on the ground. The telescopes are pointed towards the sky, as if they are being used to observe the stars.'},\n", + " {'image_id': '627',\n", + " 'caption': 'This image depicts a decorative wallpaper design featuring a large, stylized floral motif in shades of purple and gold. The pattern is made up of a series of overlapping petals and leaves, arranged in an intricate, swirling design. The background of the wallpaper is a neutral, off-white color. The overall effect is a luxurious, ornate look that would be suitable for use in a formal setting such as a dining room or living room.'},\n", + " {'image_id': '629',\n", + " 'caption': 'This image is a shirt design of a cute koala bear wearing a flower crown and sitting on a tree branch. The words \"save the koalas\" are written in a playful font. The design would make a great gift for anyone interested in conservation efforts.'},\n", + " {'image_id': '630',\n", + " 'caption': 'The image shows a pile of video game controllers, including NES, SNES, and GBA controllers in good condition with no visible damage or wear. The controllers are arranged haphazardly and have a mix of black, white, and gray colors, with the NES controller having a distinctive red and white design. The image suggests a collection of vintage video game controllers gathered together for a purpose such as display or sale.'},\n", + " {'image_id': '631',\n", + " 'caption': 'This image depicts a dark and eerie scene, with a large twisted tree in the center of the frame. The sky above is dark and stormy, with lightning flashes illuminating the scene. In the foreground, there is a figure standing on a rocky outcropping, looking down at the tree. The figure is dressed in dark, tattered robes and holds a scythe in one hand. The overall mood of the image is ominous and foreboding.'},\n", + " {'image_id': '632',\n", + " 'caption': 'This image shows a woman standing outside of a building, wearing a black coat, black pants, and white sneakers. She is carrying a red tote bag and has a pair of black sunglasses on her head. The building in the background has a white wall and a large window. There are some plants in pots on the sidewalk in front of the building.'},\n", + " {'image_id': '633',\n", + " 'caption': 'This image is a stained glass window depicting a whirlpool in the ocean. The colors used in the window are blues, greens, and yellows. The whirlpool is depicted in the center of the window, with waves and bubbles swirling around it. On the left side of the window, there is a large fish swimming in the ocean. On the right side, there is a smaller fish swimming near the whirlpool. The overall effect of the window is one of peacefulness and serenity.'},\n", + " {'image_id': '634',\n", + " 'caption': 'The image depicts a yellow flower growing in a rocky mountain landscape with a cloudy and misty mountain range in the background. The petals of the flower are long and thin, with a slightly wavy texture, and the center of the flower is a darker yellow color. Small green plants surround the base of the flower, some of which appear to be moss or lichen. The angle of the image is low, looking up at the flower, which is the main focus of the image.'},\n", + " {'image_id': '635',\n", + " 'caption': 'be an old fashioned machine used for weaving fabric. There are several spools of thread hanging from the loom, and the woman on the left is holding a piece of fabric that has been woven on the loom. The background of the photograph appears to be a factory or workshop, with pipes and other machinery visible.'},\n", + " {'image_id': '636',\n", + " 'caption': 'This image is a black tank top with the words \"training for the class wars\" written in yellow on the front. The words are written in a bold font and are centered on the chest of the shirt. The shirt is made of 100% cotton and has a relaxed fit. It is a unisex tank top that can be worn by both men and women.'},\n", + " {'image_id': '637',\n", + " 'caption': 'This The image shows a group of papaya trees growing in a field. The trees are tall, with long, thin trunks and large, green leaves. The fruit on the trees is not yet ripe, as it is still small and green. The trees are surrounded by dirt and grass, and there is a clear blue sky in the background.\\n\\nThe papaya trees are a type of tropical fruit tree that is commonly grown in many parts of the world. They are known for their sweet, juicy fruit, which is often used in smoothies, salads, and other dishes. The trees can grow to be very tall, and they require a lot of sunlight and water to thrive.\\n\\nOverall, this image shows a group of papaya trees growing in a field, with the fruit still unripe. The trees are surrounded by dirt and grass, and there is a clear blue sky in the background.'},\n", + " {'image_id': '638',\n", + " 'caption': 'This image shows a hotel room with a large bed, a desk, and a television. The walls are covered in a beige patterned wallpaper, and there are two lamps on either side of the bed. The room is spacious and well lit, with large windows letting in natural light.'},\n", + " {'image_id': '639',\n", + " 'caption': 'The image shows a muscular man holding an orange in one hand and a glass of orange juice in the other. He is standing in front of a white background and is wearing a sleeveless shirt that reveals his toned abs. He has a serious expression on his face and is holding the orange in a way that suggests he is about to take a bite out of it. The glass of orange juice is half full and appears to be freshly squeezed. The overall impression of the image is one of health and vitality.'},\n", + " {'image_id': '640',\n", + " 'caption': 'This image is a close up of a white background with pink and purple cherry blossom flowers in full bloom. The petals are delicate and have a soft, feathery texture. The flowers are arranged randomly, some hanging down and others standing upright. The colors used in this image are soft and pastel, providing a pop of color against the white background. The overall effect is tranquil and beautiful, with a delicate, almost ethereal quality to the flowers. The composition is well done, drawing the eye towards the flowers.'},\n", + " {'image_id': '641',\n", + " 'caption': 'This image shows a pair of grey and white leather shoes with a blue sole, designed for golfing. The lace-up closure and small brand logo on the side of the shoe are visible. The shoes are in good condition and suitable for use on the golf course.'},\n", + " {'image_id': '642',\n", + " 'caption': 'This image shows a wooden swing set with a wooden frame and a wooden seat, located outside in front of a building with a large garage door open. The swing set appears to be in good condition and is ready for use.'},\n", + " {'image_id': '644',\n", + " 'caption': 'The image shows a group of people playing a game of basketball on a court. The players are wearing different colored jerseys and are dribbling the ball.'},\n", + " {'image_id': '645',\n", + " 'caption': \"The image shows two tote bags with colorful designs on them. One bag has the words 'happy birthday' written on it in pink letters, while the other has the words 'sweet baby' written on it in blue letters. Both bags have large bows on them, one pink and the other blue. The bags are on top of a wooden surface, which appears to be a table or easel. There are various colors and shapes of paintbrushes and art supplies scattered around.\"},\n", + " {'image_id': '646',\n", + " 'caption': 'This image is a map of the world. It shows the different countries and their capitals. The countries are colored in different shades of blue, green, yellow, red, and orange, and are labeled with their respective names. The map is divided into different regions, including Europe, Asia, Africa, North America, South America, Australia, and Antarctica. The capitals of the countries are highlighted in a different color. The map also shows the oceans and the equator, which divides the world into the northern and southern hemispheres.'},\n", + " {'image_id': '647',\n", + " 'caption': 'This image shows a group of people playing a game of shuffleboard in a bar. The table is made of wood and has a green felt surface. The players are dressed in casual clothing, with one man wearing a white t-shirt and jeans, and the other wearing a black t-shirt and shorts. There is a beer bottle and glasses on the table in front of them. The room has a wooden floor and a high ceiling with exposed beams. There is a large window behind the players that lets in a lot of natural light. The overall atmosphere of the image is relaxed and casual.'},\n", + " {'image_id': '650',\n", + " 'caption': 'This is an image of a woman standing in a fenced-in area with several small goats around her. The woman is wearing a black and white striped shirt with her hair tied back in a ponytail. The goats are different colors and sizes, nibbling on the grass in the enclosure. A wooden fence surrounds the area with some trees visible in the background.'},\n", + " {'image_id': '651',\n", + " 'caption': \"The image shows a bouquet of red roses in a vase. The roses have long stems and are tied together with a ribbon. There are a few baby's breath flowers in the bouquet as well. The vase is clear glass and has a curved shape. The background is white.\"},\n", + " {'image_id': '652',\n", + " 'caption': 'This is a black and white drawing of a large brick building with several windows and a tall, pointed roof. It has a large entrance and appears to be an office or government building. Several palm trees are in front of the building and a sidewalk leads up to the entrance.'},\n", + " {'image_id': '654',\n", + " 'caption': 'This is an image of a green rectangle with a black border on the top and bottom, and a white border on the left and right sides. There is a small black square in the top left corner of the image, and a small white square in the bottom right corner.\\n\\nThe green color of the rectangle creates a sense of calm and tranquility, while the black border adds a sense of sophistication and elegance. The white border also adds a sense of cleanliness and purity. The small black square in the top left corner adds a sense of mystery and intrigue, while the small white square in the bottom right corner adds a sense of balance and symmetry.\\n\\nOverall, this image is visually pleasing and creates a sense of harmony and balance.'},\n", + " {'image_id': '655',\n", + " 'caption': 'This is a photograph of a farm field with rows of soybean crops growing. The sun is setting in the background, casting a warm orange glow over the scene. The straight and evenly spaced rows indicate that the crops have been planted and tended to with care. The dark and rich soil suggests fertility, allowing the crops to grow. This peaceful and picturesque image captures a farm at sunset.'},\n", + " {'image_id': '656',\n", + " 'caption': 'city contrasting with the dark sky. The water in the foreground adds a sense of tranquility to the scene, while the bridge in the distance gives a sense of depth to the image.'},\n", + " {'image_id': '657',\n", + " 'caption': \"This image shows a sunset over an oil field with pump jacks in the foreground. The sun is setting behind the pump jacks, casting a warm glow over the scene. The sky is filled with clouds, some of which are lit up by the sun's rays. The pump jacks are tall, metal structures with arms that move up and down to pump oil out of the ground. They are arranged in a row, with some of them visible in the foreground and others in the background. The oil field is surrounded by flat, barren land. There are no other buildings or structures visible in the image.\"},\n", + " {'image_id': '660',\n", + " 'caption': 'This image shows a group of black and white sheep standing on a dirt path next to a fence. The sheep are all facing the same direction and appear to be looking at something outside of the frame. The fence is made of metal bars and there is a small opening in it where the sheep are standing. The ground is covered in dirt and there is a small patch of grass visible in the foreground. The sky is cloudy and overcast.'},\n", + " {'image_id': '661',\n", + " 'caption': 'The image shows a cityscape with tall concrete and glass buildings in the background, some with balconies on the upper floors. The foreground features a small park with a fountain and a few benches surrounded by a mix of deciduous and evergreen trees such as oak, maple, and pine. The sky is clear and blue with a few fluffy clouds visible in the distance.'},\n", + " {'image_id': '662',\n", + " 'caption': \"This image shows a young man wearing a black suit and white shirt, smiling at the camera. He has short, dark hair and is clean shaven. He is wearing a pair of black shoes and his hands are in his pockets. The background of the image appears to be an outdoor event or party, with people milling around in the background. The image is well lit and the man's face is clearly visible.\"},\n", + " {'image_id': '663',\n", + " 'caption': 'The image shows a grassy hill with a view of a city in the distance. The hill is covered in green grass and there are no trees or other vegetation in the foreground. The sky is clear and blue, with a few fluffy clouds visible in the distance. The sun is shining down on the hill, casting long shadows across the grass. The city in the distance appears to be quite large, with several tall buildings visible. There is a road running along the base of the hill, and a few cars can be seen driving along it. Overall, the scene is peaceful and serene, with the green grass and blue sky creating a calming atmosphere.'},\n", + " {'image_id': '664',\n", + " 'caption': 'This image shows the words \"Magic Warriors\" written in white, glowing letters on a dark background. The letters seem to be floating and are stylized with the \"W\" in \"Warriors\" forming into a sword, creating a mysterious and magical effect.'},\n", + " {'image_id': '665',\n", + " 'caption': \"The image shows a race car driving on a race track. The car is blue and white with a green stripe down the side. It has a number 22 on the side and a sponsor's logo on the hood. The wheels are black and the tires are white. The track is made of asphalt and has painted lines on it. There are trees in the background and the sky appears to be cloudy.\"},\n", + " {'image_id': '666',\n", + " 'caption': \"This image shows the London skyline at night, with the London Eye ferris wheel in the foreground and the Houses of Parliament in the background. The London Eye is a large ferris wheel located on the south bank of the River Thames in London, England. It is one of the city's most recognizable landmarks and a popular tourist attraction. The Houses of Parliament, also known as the Palace of Westminster, is the seat of the British government and is located on the north bank of the River Thames. It is a complex of buildings that includes the House of Commons, the House of Lords, and the clock tower known as Big Ben.\"},\n", + " {'image_id': '667',\n", + " 'caption': 'The painting depicts a view of a canal in Venice, Italy, lined with buildings on both sides with balconies overlooking the water. A gondola with two people sitting in it is in the middle of the canal. The left buildings are taller and more ornate than the right. The sky is overcast with mostly muted colors of browns, grays, and blues. The overall mood is quiet and peaceful, with a sense of stillness in the water and air.'},\n", + " {'image_id': '668',\n", + " 'caption': \"a red collar with a bell on it and is depicted in various facial expressions including happiness, sadness, surprise, anger, and confusion while standing on its hind legs with front paws on its hips. The cat has large expressive eyes, whiskers, an open mouth as if meowing, perked up ears, and a fluffy tail. Its body is orange, with a white belly, paws, and a white patch on its chest. The cat's cheeks have black whiskers, and its fur is fluffy and well-groomed.\"},\n", + " {'image_id': '669',\n", + " 'caption': 'This is an image of a person sitting in a green tent in the snow. The person is wearing snowshoes and has skis leaning against the tent wall. There is a small amount of snow on the ground in front of the tent, and trees can be seen in the background.'},\n", + " {'image_id': '670',\n", + " 'caption': 'The image depicts a collage of various plants, including potted plants, hanging plants, and plants growing in a garden. The plants are a mix of different species, such as ferns, succulents, and flowering plants, arranged in a haphazard manner, with some overlapping and some standing alone. The result is a lush and vibrant display of greenery.'},\n", + " {'image_id': '672',\n", + " 'caption': 'This image shows a plate of food on a wooden table. The plate has a steak, french fries, and a tomato on it. There are also two glasses of drinks on the table, one of which has a straw in it. The background of the image is a wooden wall and a window with curtains.'},\n", + " {'image_id': '673',\n", + " 'caption': 'This is a photograph of a baseball game being played in a large stadium. The stadium is filled with people sitting in the stands and watching the game. The field is green and the players are on it playing the game. The sky is clear and blue with no clouds. The sun is setting in the background, casting long shadows on the field. The stadium lights are on, illuminating the field.'},\n", + " {'image_id': '674',\n", + " 'caption': 'The image is a blue and purple background with the words \"I am a recovering perfectionist\" written on it in white letters. The words are centered and slightly raised above the background. There are no other visible objects or elements in the image.'},\n", + " {'image_id': '675',\n", + " 'caption': \"This is an image of a white sedan car with a sleek and modern design. It has a large front grille, headlights, and a spoiler on the back. The car's wheels are equipped with black rims. The car is parked on a grey background.\"},\n", + " {'image_id': '676',\n", + " 'caption': 'This image shows a bracelet made of green emeralds and white diamonds. The emeralds and diamonds are set in white gold. The bracelet has a clasp made of white gold. The emeralds are oval shaped, bright green, and have a total weight of approximately 1.5 carats. The diamonds are round shaped and have a total weight of approximately 0.5 carats. The overall look of the bracelet is elegant and sophisticated.'},\n", + " {'image_id': '678',\n", + " 'caption': 'This is an image of a kite with a red, white, and blue design featuring an eagle at the center, holding a ribbon in its beak and having its wings spread out. The kite has a long tail made of red and white ribbons and is suspended from a string that is attached to the top of the image. The image is on a white background.'},\n", + " {'image_id': '679',\n", + " 'caption': \"This is an image of a person wearing shoes with flames coming out of the bottom. The shoes have a yellow and black design on them and appear to be made of rubber or plastic. The person is standing on a dark surface, possibly asphalt or concrete, and there is a car parked in the background. The image appears to have been taken at night with streetlights in the background, and the person's face is partially obscured by shadows.\"},\n", + " {'image_id': '680',\n", + " 'caption': 'This image shows a living room with a couch, coffee table, and shelves on the wall. There is a man standing in the middle of the room, looking at the shelves. The room has a neutral color scheme with white walls, beige carpet, and brown furniture. There are two windows on either side of the room, letting in natural light. The shelves are made of wood and have various items on them, including books, vases, and a clock. The coffee table has a lamp on it, and there is a throw pillow on the couch. The overall atmosphere of the room is cozy and welcoming.'},\n", + " {'image_id': '682',\n", + " 'caption': 'This is an image of a large, cylindrical machine in a laboratory setting. The machine appears to be made of metal and has several gauges and dials on the front. There are several pipes and tubes coming out of the top and bottom of the machine. The machine is sitting on a wheeled stand and there is a chain attached to the bottom of it. There are also several other machines and equipment visible in the background.'},\n", + " {'image_id': '684',\n", + " 'caption': 'The image shows a pair of white sandals with a braided design on the straps. The straps are made of woven rope and have a tassel at the end. The soles of the sandals appear to be made of a light colored material, possibly leather. The overall design of the sandals is simple and elegant.'},\n", + " {'image_id': '685',\n", + " 'caption': 'The image shows a gold necklace with small white pearls hanging from it. The pearls are arranged in a row, with a small gap between each one. The necklace has a delicate, dainty look to it.'},\n", + " {'image_id': '687',\n", + " 'caption': \"The image shows two cats, one is black and white and the other is grey and white. The black and white cat is laying on its back with its paws in the air, while the grey and white cat is sitting next to it with its head tilted to the side. Both cats have their eyes open and appear to be looking at the camera. The caption reads, `'do you want to know something funny? nope.'''\"},\n", + " {'image_id': '688',\n", + " 'caption': 'This image is a birthday greeting with the words \"happy birthday\" written in colorful letters in a playful, childlike font. The background is white with no other design elements, making it a simple and fun way to wish someone a happy birthday.'},\n", + " {'image_id': '689',\n", + " 'caption': 'The image shows a large, ornate cathedral with intricate, gold mosaics on the walls and ceiling depicting various religious scenes, including the crucifixion and resurrection of Jesus. The cathedral also has large stained glass windows that let in a warm, golden light. Rows of pews are in front of the altar where people can sit and pray, creating an overall atmosphere of grandeur and reverence.'},\n", + " {'image_id': '690',\n", + " 'caption': \"There are several tables with black chairs in the center of a modern and minimalist room. Large windows surround the tables, letting in natural light. The walls are painted white with a few black and white photographs hanging on them. The room's floor is made of wooden planks with some potted plants scattered around.\"},\n", + " {'image_id': '691',\n", + " 'caption': 'The image shows a man standing in front of a cash register with a shopping cart full of groceries in the background. The man is wearing a suit and holding a shopping list in his hand. The cash register has a screen displaying the total cost of the items in the cart.\\n\\nThe image depicts a scene from a supermarket or grocery store, where customers can pay for their purchases at the cash register. The cash register has a screen that displays the total cost of the items in the cart, and the man is standing in front of it, ready to pay for his groceries. The shopping cart behind him is full of various items, such as bread, milk, eggs, and other groceries.\\n\\nThe image could be used to illustrate various concepts related to shopping, such as paying for groceries, checking out at the cash register, or buying items at a supermarket'},\n", + " {'image_id': '692',\n", + " 'caption': \"The image shows a group of rugby players huddled together on the field, with one player sitting on the ground with his head in his hands. The players are wearing blue and red jerseys, with the number 10 on the back of one player's jersey. The field is green and there are spectators in the stands watching the game.\"},\n", + " {'image_id': '694',\n", + " 'caption': 'The image shows a dish of fish with vegetables such as broccoli and carrots on a white plate. A lemon wedge is on the side of the plate, and a small bowl of sauce next to it. The fish is grilled or baked, with a crispy brown exterior and a moist interior. The vegetables are cooked but still crisp, and the sauce is creamy and flavorful. The presentation of the dish is visually appealing and appetizing.'},\n", + " {'image_id': '695',\n", + " 'caption': 'This image shows a stack of whole wheat pancakes with sliced bananas on top. A hand is pouring golden honey syrup over them. The pancakes are on a blue and white checkered plate.'},\n", + " {'image_id': '696',\n", + " 'caption': 'This is an image of a broken egg. It appears to have cracked open and the yolk is leaking out of it. The egg is lying on the ground and there is dirt and debris around it. The image is in black and white.'},\n", + " {'image_id': '697',\n", + " 'caption': 'This image is a drawing of a military truck. The truck is a large vehicle with a box on the back. The front of the truck has a hood, grille, and headlights. The windshield wraps around the front. Large wheels and tires are on the sides. The back of the truck has a box with a ramp and a winch.\\n\\nDimensions: 20 feet long, 8 feet wide, and 10 feet tall. Box: 8 feet wide and 12 feet long. Wheels: 4 feet in diameter.'},\n", + " {'image_id': '698',\n", + " 'caption': 'The image shows a large school of fish swimming in clear blue water. The fish are of different sizes and are swimming together in a coordinated manner. The water is clear and the sunlight is shining down on the fish, making them appear to be glistening in the sun. There are no other objects in the image except for the fish and the water.'},\n", + " {'image_id': '699',\n", + " 'caption': \"The Church of the Savior on Spilled Blood, also known as the Church of the Resurrection, is a Russian Orthodox church situated in St. Petersburg, Russia. Built in the late 19th century, it is one of the city's most recognizable landmarks. The church is located on the banks of the Griboyedva River and has brightly colored domes and intricate architecture.\\n\\nThe church was built to commemorate the assassination of Emperor Alexander II in 1881. Its design is a fusion of traditional Russian and Byzantine styles, with a large central dome and four smaller domes on the corners. The exterior is adorned with intricate mosaics and frescoes depicting scenes from the Bible and Russian history.\\n\\nThe interior of the church is equally impressive, with marble columns and intricate mosaics covering the walls and ceiling.\"},\n", + " {'image_id': '700',\n", + " 'caption': \"The image depicts a man performing an abdominal exercise on a machine. The man is wearing a blue workout suit and has his hands on the machine's handles. The machine has several cables and pulleys attached to it, which are used to provide resistance to the exerciser's movements. The man's body is in a bent position, with his legs extended behind him and his arms extended forward. The image is in a white background.\"},\n", + " {'image_id': '701',\n", + " 'caption': 'the image depicts a young girl in a fairy costume standing on a natural-looking globe while holding a wand with a star on the end. She is looking up at the stars in the night sky with a facial expression of awe and wonder. The background shows mountains and valleys. The mood of the image is one of wonder and magic.'},\n", + " {'image_id': '702',\n", + " 'caption': 'The image shows a group of businessmen climbing up a steep cliff, with one holding a red flag and the other holding a blue flag. They are trying to reach the top of the cliff, which is depicted as a large mountain in the background. The overall theme of the image appears to be one of determination and teamwork, as the men work together to reach the top of the mountain.\\n\\nThe colors used in the image are mostly shades of blue and red, with the red flag standing out prominently against the blue sky in the background. The overall mood of the image is one of determination and perseverance, as the men work together to achieve their goal of reaching the top of the mountain. The image could be used to convey a message of teamwork and the importance of working together to achieve a common goal.'},\n", + " {'image_id': '703',\n", + " 'caption': 'The image shows a police officer standing next to a car that has been involved in an accident. The car appears to have sustained significant damage to the front end, with the hood crumpled and the windshield shattered. The officer is standing next to the car, with his arms crossed and a look of concern on his face. Behind the car, there are several other vehicles parked in the lot, including a large truck with the letters \"pt\" on the side.'},\n", + " {'image_id': '705',\n", + " 'caption': 'The image shows a black car driving down a road with mountains in the background. The sun is shining brightly in the sky, and there are no other cars on the road. The car has dark tinted windows and a spoiler on the back. It appears to be a sports car, with a large engine and low profile tires. The license plate on the car is not visible, but it appears to be from a state in the United States.\\n\\nThe car appears to be in good condition, with no visible dents or scratches on the body. The tires are also in good shape, with no signs of wear or tear. The windows are tinted, so it is not possible to see inside the car. However, it appears to be a luxury sports car, with leather seats and a high tech dashboard.\\n\\nOverall, the image shows a sleek, black sports car driving down a desert road at sunset'},\n", + " {'image_id': '706',\n", + " 'caption': 'The image shows a white cosmetic pouch with gold foil lettering on the front that reads \"glamorous\".'},\n", + " {'image_id': '709',\n", + " 'caption': 'The image shows a large stone tower with a pointed top, surrounded by trees and a foggy sky. The tower has several windows and a small door on the side. There are no people or other objects in the image.'},\n", + " {'image_id': '710',\n", + " 'caption': 'The image shows a potted plant sitting on a windowsill'},\n", + " {'image_id': '711',\n", + " 'caption': \"The image depicts a silhouette of a person holding a star in their hand. The person is standing in front of a white background. The image is a simple, flat illustration with no shading or texture. The person's face is not visible, only the outline of their body and the star they are holding. The image could be used as a symbol for achievement, success, or recognition.\"},\n", + " {'image_id': '713',\n", + " 'caption': 'There is a bed with a blanket and pillows on it, a dresser with a television on top, a desk with a lamp and a chair in front of it, and a window with curtains and a view of the outside.'},\n", + " {'image_id': '714',\n", + " 'caption': 'The image depicts an elderly woman wearing a straw hat, green pants, and a red shirt. She is holding a map in her left hand and a suitcase in her right hand. The woman is standing with her legs apart and looking down at the map. The image is in a flat, cartoon style and is on a white background. The woman is wearing a straw hat, green pants, and a red shirt. She is holding a map in her left hand and a suitcase in her right hand. The woman is standing with her legs apart and looking down at the map. The image is in a flat, cartoon style and is on a white background.'},\n", + " {'image_id': '718',\n", + " 'caption': 'visible texture or patterns. The reflective quality of the oval gives it a three-dimensional appearance, as it appears to be raised off the surface it is placed on. Overall, the image showcases a bright and shiny yellow oval shape with a reflective surface, placed on a white background to create contrast.'},\n", + " {'image_id': '720',\n", + " 'caption': 'The image depicts a silhouette of a person riding a horse. The person is wearing a black cape and has a sword in their hand. The horse is galloping with its mane and tail flowing in the wind. The image is on a yellow background.\\n\\n'},\n", + " {'image_id': '723',\n", + " 'caption': 'This image is a 3D representation of a dental implant, which is a titanium post surgically placed into the jawbone to support a replacement tooth or bridge. The implant is connected to the jawbone through osseointegration, allowing the bone to grow around the implant and hold it in place. The implant is then capped with a crown, the visible part of the tooth in the mouth.'},\n", + " {'image_id': '724',\n", + " 'caption': \"This is an illustration of various objects hanging from strings, with the words 'things that art' written above them. The objects depicted include a pair of scissors, a paintbrush, a pencil, and a piece of paper. The words are written in a stylized font, with each letter hanging from a different string. The overall effect is one of creativity and inspiration, as if the objects are there as a reminder to create something beautiful.\"},\n", + " {'image_id': '726',\n", + " 'caption': \"The image shows an old, yellowed piece of paper with handwriting on it, which appears to be from the 1800s and is written in a formal, cursive style. The letter is addressed to someone named `person' from someone named `person' and is written in ink, possibly with a quill pen. Despite some stains and smudges, the words on the paper are still legible.\"},\n", + " {'image_id': '727',\n", + " 'caption': 'This is a photograph of a bedroom. The walls are painted white and there is a grey carpet on the floor. There is a large bed in the middle of the room with a yellow bedspread and white pillows. Two lamps are placed on either side of the bed, one of which is turned on. There is a door on the left and a window on the right. The room is well lit and appears to be clean and well kept.'},\n", + " {'image_id': '728',\n", + " 'caption': 'The image shows a close-up view of a small, green plant growing out of the ground. The plant has several small leaves and a stem that is covered in water droplets, which are reflecting the light in different directions. The leaves are also covered in water droplets, giving them a shiny appearance. The background is black. The plant appears to be a type of grass or weed, with thin, green leaves and a long, thin stem.'},\n", + " {'image_id': '730',\n", + " 'caption': 'The image shows a family sitting on the sand at the beach. The mother is holding a baby and the father is sitting next to her with his arm around her. They are all smiling and seem to be enjoying their time together. The sun is shining brightly in the background, casting long shadows on the sand. There are some tall grasses growing in the foreground, and some trees can be seen in the background.'},\n", + " {'image_id': '731',\n", + " 'caption': 'This is an image of a Boeing 747-8 airplane painted with a horse on the side parked on the tarmac at an airport.'},\n", + " {'image_id': '732',\n", + " 'caption': \"The image is a quote from a book or movie, written in white on a navy blue background. The quote reads, `'It is not the critic who counts; not the man who points out how the strong man stumbles, or where the doer of deeds could have done them better. The credit belongs to the man who is actually in the arena, whose face is marred by dust and sweat and blood; who strives valiantly; who errs, who comes short again and again, because there is no effort without error and shortcoming; but who does actually strive to do the deeds; who knows great enthusiasms, the great devotions; who spends himself in a worthy cause; who at the best knows in the end the triumph of high achievement, and who at the worst, if he fails, at least fails while daring greatly, so that his place shall never be with those cold and timid souls.\"},\n", + " {'image_id': '733',\n", + " 'caption': 'the image is calm and reflects the blue sky above. There are ripples in the water caused by the boats and the people walking on the dock. The picnic tables nearby are made of wood and have benches attached to them. Some of the people sitting at the tables are eating and drinking, while others are simply enjoying the view.'},\n", + " {'image_id': '734',\n", + " 'caption': 'This image shows a kitchen with white cabinets and countertops made of granite. There are three pendant lights hanging from the ceiling. The large island in the center of the kitchen has a stainless steel sink and a white refrigerator on the other side. The walls are painted in a light gray color with a white tile backsplash behind the stove. The hardwood floor has a rug in front of the island.'},\n", + " {'image_id': '735',\n", + " 'caption': 'This is a black and white line drawing of a cartoon girl throwing a frisbee. The girl is wearing a pink shirt and shorts, and she is holding a frisbee in her right hand. The frisbee is flying through the air, and the girl is looking up at it with a determined expression on her face. The background is empty, and there are no other objects or people in the image.'},\n", + " {'image_id': '736',\n", + " 'caption': 'This is an image of a machine being worked on in a factory. The machine is made of metal and has several pipes and hoses attached to it. A person stands next to the machine holding a wrench and looking at the pipes. The machine is being repaired or maintained.'},\n", + " {'image_id': '737',\n", + " 'caption': 'The image shows a group of people walking down a snowy sidewalk in front of a red brick building. The people are dressed in winter clothing, including hats, scarves, and coats. Some of them are carrying backpacks and other bags, while others have their hands in their pockets. In the background, there are several trees with snow on their branches, and a few cars parked on the street. The sky is cloudy and overcast, with no sun in sight.'},\n", + " {'image_id': '739',\n", + " 'caption': 'The image shows a large auditorium filled with people sitting in rows of chairs facing a stage. On the stage, there is a large orchestra with a conductor standing in front of them. The orchestra is playing instruments such as violins, violas, cellos, and double basses. The audience is watching the performance, and some people are clapping their hands. The ceiling of the auditorium is high, and there are large chandeliers hanging from it. The walls are decorated with paintings and murals, and there are large windows on either side of the auditorium letting in natural light.'},\n", + " {'image_id': '740',\n", + " 'caption': 'This is a diagram of a formal plot of a story. It shows the rising action, climax, falling action, and resolution of the story. The rising action is the beginning of the story, where the characters are introduced and the conflict is established. The climax is the turning point of the story, where the conflict is at its highest point and the outcome is uncertain. The falling action is the part of the story after the climax, where the conflict is resolved and the outcome is determined. The resolution is the ending of the story, where the loose ends are tied up and the story comes to a close. This diagram is a useful tool for visualizing the structure of a story and identifying its key elements.'},\n", + " {'image_id': '741',\n", + " 'caption': \"Constellation Leo is one of the twelve zodiac constellations in the night sky. It is named after the lion in Greek mythology and located in the northern hemisphere. Leo is easily recognizable by its seven bright stars, which form the shape of a lion's head and mane. The brightest star in Leo is Regulus at the base of the lion's tail. Leo covers an area of about 900 square degrees and is bordered by Cancer to the east, Hydra to the south, and Virgo to the west. It is visible in the northern hemisphere from around July to October and is best viewed in the early evening during the summer months. Leo has several interesting deep sky objects associated with it, including the Leo.\"},\n", + " {'image_id': '742',\n", + " 'caption': \"This image is a cartoon of a pig wearing overalls and a blue shirt with the text 'just a girl who loves pigs' written on it in white letters. The pig is standing on its hind legs, with its front legs resting on a wooden fence. The background is a grassy field with some trees in the distance. The overall theme of the image is cute and playful, with a focus on the love of pigs. It could be used for a variety of purposes, such as a social media post, a greeting card, or a t-shirt design.\"},\n", + " {'image_id': '743',\n", + " 'caption': 'The image displays a brown sign with a fish and an arrow pointing towards it, situated in a wooded area with fallen leaves on the ground.'},\n", + " {'image_id': '744',\n", + " 'caption': 'This image shows two women, one older and one younger, standing outside in front of a house. They are both smiling and posing for the camera. The older woman has gray hair and is wearing glasses, while the younger woman has blonde hair and is wearing a blue shirt and jeans. The house behind them has a white picket fence and a green lawn. The sky is cloudy and there are trees in the background.'},\n", + " {'image_id': '745',\n", + " 'caption': 'The image shows a group of people standing on top of a truck holding a trophy. They are all wearing blue shirts and one person is holding a microphone. The trophy appears to be made of metal and has a golden base. The people in the image are smiling and waving at the camera. There is a crowd of people in the background watching the scene.'},\n", + " {'image_id': '746',\n", + " 'caption': 'The woman in the image is wearing a black tank top, black tights, and black high heels. Her hair is styled in loose waves and she is wearing black sunglasses. She is posing with her hands on her hips and looking directly at the camera. The image is in black and white.'},\n", + " {'image_id': '747',\n", + " 'caption': 'The \"koleif\" logo is a modern and sleek design consisting of a letter \"k\" in green, blue, and red. The colors used in the logo represent growth, stability, trust, reliability, energy, and passion. The unique shape of the letter \"k\" is memorable and represents the company\\'s commitment to precision and accuracy.'},\n", + " {'image_id': '748',\n", + " 'caption': \"This image is a diagram of a person's brain, with different areas highlighted and labeled with terms related to psychology and neuroscience. The brain is depicted as a tree with branches and roots, with each area of the brain represented by a different shape and color. It is intended to be used as a visual aid for teaching or explaining brain functions.\"},\n", + " {'image_id': '750',\n", + " 'caption': 'This image shows a balcony with a table and chairs overlooking a body of water. The table is set for a meal, with plates, glasses, and silverware. The balcony is surrounded by a wooden railing, and there are trees in the background. The sky is clear, and the sun is shining down on the water.'},\n", + " {'image_id': '752',\n", + " 'caption': \"The image is a bangle bracelet with the words'baseball mom'engraved on it. The bracelet has three charms hanging from it, including a baseball, a heart, and a star. The charms are made of silver and have a shiny finish. The bracelet is adjustable and can be worn by anyone.\"},\n", + " {'image_id': '753',\n", + " 'caption': 'This is an image of a woman with a pink lipstick on her lips. She is wearing a blue shirt and has her hair styled in a messy bun. The image is well lit and the colors are bright and vibrant.\\n\\nIn the image, the woman is looking directly at the camera with a slight smile on her face. Her eyes are brown and her eyelashes are long and curled. The lipstick she is wearing is a bright pink shade with a glossy finish. The color looks great on her lips and complements her skin tone.\\n\\nOverall, this is a beautiful image of a woman with a great makeup look. The lighting, colors, and details are all well done.'},\n", + " {'image_id': '755',\n", + " 'caption': 'This is an image of a rectangular metal object sitting on a surface made of the same material. Metal pieces are attached to the top and bottom of the object to hold it in place. A ruler or measuring tool is placed next to the object to measure its dimensions.'},\n", + " {'image_id': '757',\n", + " 'caption': 'There are two women dressed in 18th century clothing standing next to each other. The woman on the left is wearing a black dress with a white apron and a red scarf around her neck. The woman on the right is wearing a blue and white striped dress with a yellow apron and a red scarf around her neck. Both women have their hair styled in loose curls and are wearing gold hoop earrings. They are standing on a street with a crowd of people in the background.'},\n", + " {'image_id': '758',\n", + " 'caption': 'This is a black t-shirt made of 100% cotton, featuring a skull and crossbones in the center. The words \"Feed the Meat Grinder\" are written in red above and below the skull. The shirt has a standard fit and is suitable for both casual and formal wear. It can be paired with jeans or shorts for a cool and edgy look. The design is bold and eye-catching, making it perfect for anyone who loves horror or punk style. It is a great t-shirt for anyone who wants to make a statement with their clothing.'},\n", + " {'image_id': '760',\n", + " 'caption': 'boy riding the horse through a desert with cacti in the background.'},\n", + " {'image_id': '761',\n", + " 'caption': 'This image is a photograph of a person on a rocky beach with the ocean in the background. The person is standing with their back to the camera, looking out at the water. The sky is bright blue, and the water is deep blue. The sand on the beach is light brown, and there are rocks in the foreground. The person appears lost in thought as they gaze out at the ocean, creating a peaceful and serene mood.'},\n", + " {'image_id': '763',\n", + " 'caption': 'This image shows a green, vintage military jeep with a large engine on the back parked in a parking lot. The jeep appears to be in good condition, with no visible damage or wear. The front of the jeep has a large grille and headlights, and the windshield appears to be in good condition. The tires on the jeep appear to be in good condition as well.'},\n", + " {'image_id': '764',\n", + " 'caption': 'The image shows a The image shows the interior of an airplane with three rows of seats. The seats are arranged in a 2 - 2 configuration, with each row having two seats on either side of the aisle. The seats are upholstered in a light grey fabric with blue and green accents on the headrests and armrests. There are two windows on either side of the plane, and each window has a shade that can be raised or lowered. There is a small table between the seats in the middle row, with a tray for drinks or other items. The carpet on the floor is a light beige color.'},\n", + " {'image_id': '765',\n", + " 'caption': 'image captures the essence of an extravagant and sophisticated lifestyle, with the grand staircase and lavish decor providing a backdrop for the elegant attire and social interaction of the people in the image.'},\n", + " {'image_id': '766',\n", + " 'caption': 'This is a photograph of a young girl playing in the sand on a beach. The girl is wearing a black and white dress and is sitting on her hands and knees in the sand. In the background, you can see the ocean and some palm trees. The girl appears to be building something out of the sand with her hands. The sand around her is smooth and flat, and there are no footprints or other marks in it. The sky is clear and blue, and there are a few fluffy clouds visible in the distance.'},\n", + " {'image_id': '767',\n", + " 'caption': \"This image is a logo for the Ram truck brand. It features a ram's head in the center of the logo, with the words 'RAM' written in bold letters above and below the image. The ram's head is shown in a profile view, with its horns and beard clearly visible. The overall design of the logo is sleek and modern, with a black and white color scheme that gives it a bold, eye-catching look.\"},\n", + " {'image_id': '768',\n", + " 'caption': \"The image depicts an abstract representation of a lighthouse. The lighthouse is made up of geometric shapes and lines, with the light shining from the top of the structure. The lighthouse stands on a rocky outcropping, with waves crashing against the shore in the foreground. The image is in black and white, with the lighthouse and waves standing out against the white background.\\n\\nThe lighthouse is a symbol of guidance and direction, and is often used as a metaphor for finding one's way in life. The waves represent the challenges and obstacles that we face in our journey, and the light from the lighthouse represents the hope and promise of a better future. The image could be interpreted as a reminder to keep moving forward, even in the face of adversity.\"},\n", + " {'image_id': '769',\n", + " 'caption': 'This image is of a bedroom with a yellow and white theme. The walls are painted yellow, and there is a white canopy bed with a red and white striped rug on the floor. The room has large windows that let in a lot of natural light. There is a white desk with a computer on it in the corner, as well as a red and white striped chair.'},\n", + " {'image_id': '770',\n", + " 'caption': 'This image is an abstract design composed of diagonal lines in different shades of purple, green, and white. The lines form a swirling and chaotic pattern that gives a sense of energy and movement. The design is dynamic and eye-catching, suitable for use in several contexts like a website background or a graphic element in a marketing campaign.'},\n", + " {'image_id': '771',\n", + " 'caption': 'This image appears The image is a painting of two people, a man and a woman, standing next to each other. The man is wearing a tuxedo and the woman is wearing a long, flowing dress. They are both looking at each other with smiles on their faces. The background of the painting is a golden, ornate frame.'},\n", + " {'image_id': '772',\n", + " 'caption': 'The painting depicts a snowy road in the woods at sunset. The sky is pink and there are trees on either side of the road. The road is covered in snow and there are tire tracks in the snow. There are no buildings or other structures visible in the painting. The overall mood of the painting is peaceful and serene.'},\n", + " {'image_id': '773',\n", + " 'caption': \"This is a close up shot of a bride's hands, adorned with intricate henna designs. The bride is wearing a red and gold lehnga, a traditional Indian outfit for brides. The henna designs on her hands symbolize good luck and prosperity in Indian culture. The bride's hands are also adorned with gold jewelry, including bangles and rings. The henna designs on her hands are intricate and detailed, featuring floral motifs and geometric patterns, creating a beautiful and traditional look for the bride on her wedding day.\"},\n", + " {'image_id': '774',\n", + " 'caption': \"The image shows a wire that is connected to a small, circular object. The object appears to be made of plastic and has a small hole in the center. The wire is connected to the object at one end and is looped around the object at the other end. The wire is thin and appears to be made of metal. There are no other objects visible in the image.'\"},\n", + " {'image_id': '775',\n", + " 'caption': 'the statue add to the sense of reverence for the player and his accomplishments. The building in the background also adds to the sense of importance and grandeur surrounding the statue.'},\n", + " {'image_id': '777', 'caption': 'This is an image of a postage'},\n", + " {'image_id': '778',\n", + " 'caption': \"This image shows a bride and groom standing on a wooden fence in the middle of a field. The bride is wearing a white dress and the groom is wearing a white shirt and black pants. The couple is embracing and looking into each other's eyes. The sky is blue and there are some clouds in the background. The grass is green and there are some trees in the distance. The image is taken from a low angle, looking up at the couple.\"},\n", + " {'image_id': '779',\n", + " 'caption': \"This is a framed picture with a brown wooden frame. Inside the frame, there is a black and white photograph of a man standing on a stage with a microphone in his hand. The man is wearing a suit and tie, and he is looking directly at the camera with a serious expression on his face. Behind the man, there is a large banner with the words 'person' printed on it in white letters. There is a spotlight shining down on the man from above, and it is casting a shadow on the floor in front of him. The background of the photograph is dark.\"},\n", + " {'image_id': '780',\n", + " 'caption': 'This image shows a small room with a bunk bed and a ladder leading to the top bunk. The walls are painted red, and there are curtains hanging from the ceiling. The room appears to be in a state of disarray, with clothes and other items scattered on the floor.'},\n", + " {'image_id': '781',\n", + " 'caption': 'The image shows a boat floating in the middle of a large body of water at sunset. The sun is setting behind the horizon, casting a warm orange glow on the water and the boat. The boat appears to be made of wood and has a curved shape with a pointed bow and stern. It has a single mast with a sail that is billowing in the breeze. The water is calm and there are no other boats or objects visible in the scene. The sky is a deep shade of purple with clouds that are tinged with pink and orange. The overall effect of the image is peaceful and serene, with a sense of stillness in the water and the sky.'},\n", + " {'image_id': '782',\n", + " 'caption': 'The image shows a living room with a table, chairs, and a lamp. There is also a window with a view of the outside. The room is decorated with a rug and a painting on the wall.'},\n", + " {'image_id': '784',\n", + " 'caption': 'This image shows a bathroom with a sink, toilet, and bathtub. Two beds are present in the room, one with a white bedspread and the other with a green blanket. The walls are painted white, and there are two windows with white curtains. The floor is tiled with white and grey tiles.'},\n", + " {'image_id': '785',\n", + " 'caption': 'The image shows a dart hitting a bullseye in the center of a yellow and black target with a red dot in the middle. The dart is stuck in the bullseye and the image is on a black background.'},\n", + " {'image_id': '787',\n", + " 'caption': 'This image shows a setup for an outdoor event. Tables covered in black tablecloths and white paper lanterns are hanging from the ceiling. Pink and white flowers adorn the tables, and chairs are set up for guests to sit in. It appears to be a wedding or other formal gathering.'},\n", + " {'image_id': '788',\n", + " 'caption': 'This image shows a bride and groom sharing a kiss at their wedding. The bride is wearing a white wedding dress and the groom is wearing a black tuxedo. They are standing in front of a fireplace with a large mirror above it. The room appears to be decorated in a rustic style, with wooden beams on the ceiling and a wooden floor. There are several pieces of furniture in the room, including a large wooden table and chairs.'},\n", + " {'image_id': '790',\n", + " 'caption': 'This image shows a bride and groom standing in a field of flowers. The bride is wearing a white dress and the groom is wearing a black suit with a white shirt and tie. They are both smiling and looking at each other. The sun is shining on their faces and there are flowers in the background.'},\n", + " {'image_id': '791',\n", + " 'caption': 'The image shows a bottle of hand sanitizer on a blue cloth. The bottle is clear and has a white cap with a spray nozzle on the top. The nozzle is open and there is a small amount of liquid coming out of it. The background is a white and blue striped cloth.'},\n", + " {'image_id': '792',\n", + " 'caption': \"This is an image of a disassembled laptop with the hard drive being removed from the motherboard. The hard drive is connected to the motherboard by two cables, with one being held by the person's hand in the image. The person is gently pulling on the cable to remove the hard drive.\\n\\nThe laptop has a black case with a silver keyboard and touchpad. There are vents on the bottom of the laptop to cool the components. The hard drive is on the right side of the laptop, and the power supply is on the left.\\n\\nSeveral screws hold the laptop together, which need to be removed to access the hard drive. The screws are near the vents on the bottom of the laptop.\"},\n", + " {'image_id': '793',\n", + " 'caption': 'The image shows a bowl filled with oatmeal, which is a type of cereal made from rolled oats. The oatmeal is a light brown color and appears to be uncooked. The bowl is made of dark brown clay and has a rough surface. There is a small amount of the oatmeal spilled out of the bowl onto the white surface below it. The image is a top down view of the bowl and the oatmeal inside it.'},\n", + " {'image_id': '794',\n", + " 'caption': \"This image depicts a close-up view of a person's face, with their eyes closed and their mouth slightly open. The person appears to be in a state of deep thought or contemplation. The lighting in the image is dim, with shadows cast on the person's face and the wall behind them. The person's skin appears to be smooth and unblemished, and their hair appears to be dark and straight. The overall mood of the image is introspective and thoughtful.\"},\n", + " {'image_id': '795',\n", + " 'caption': 'This image shows a bedroom with a beige carpet and white walls. There is a large window with wooden shutters on the left side of the room. The bed is made with a beige comforter and pillows, and there is a brown leather chair in the corner of the room. The room has a high ceiling with wooden beams, and there is a chandelier hanging from the center of the room.'},\n", + " {'image_id': '796',\n", + " 'caption': 'This image shows a wooden porch with two rocking chairs and a stone wall in the background. The chairs have cushions on them. The porch has a wooden railing and a wooden floor. The stone wall is made of large stones and has a wooden door in the center with a knob. Trees can be seen in the background and the sky is cloudy.'},\n", + " {'image_id': '799',\n", + " 'caption': 'The image shows a group of young men posing with a basketball in a gym. They are all wearing red and white uniforms, and one of them is holding a ball. They are all smiling and looking at the camera. The walls of the gym are made of wood and there are baskets hanging from the ceiling. The floor is made of hardwood and there are lines on it. There are windows on one side of the gym that let in natural light. The image is well lit and the colors are vibrant.'},\n", + " {'image_id': '800',\n", + " 'caption': 'This is a bathroom with a large bathtub, a sink, a toilet, and a walk-in shower. The walls are beige, and the floor is tiled. There is a large mirror on the wall above the sink, and a large window lets in plenty of natural light. The room is spacious and well-lit.'},\n", + " {'image_id': '801',\n", + " 'caption': 'The painting shows a group The painting depicts a group of people gathered around a table in a dimly lit room. They are dressed in period clothing and appear to be enjoying a meal together. The table is set with plates, glasses, and silverware. The room is decorated with tapestries on the walls and a chandelier hanging from the ceiling. The overall mood of the painting is warm and inviting.'},\n", + " {'image_id': '802',\n", + " 'caption': 'This cake is a yellow cake with a cartoon bird image on top. The bird is smiling and has blue eyes and a pink beak. The cake is decorated with white frosting and has yellow flowers on the sides.'},\n", + " {'image_id': '803',\n", + " 'caption': 'This is an image of a sunflower painted in watercolor style with yellow petals and a brown center on a light beige background. There is a green stem coming out of the top of the sunflower and leaves are scattered around it.'},\n", + " {'image_id': '804',\n", + " 'caption': 'This image shows a red fire truck parked in a lot, with a ladder on the back that indicates it may be used for aerial operations.'},\n", + " {'image_id': '805',\n", + " 'caption': 'This image shows two military vehicles parked next to each other in front of a large building. The first vehicle is a small, armored vehicle with tracks and a large gun mounted on top. The second vehicle is a larger, armored vehicle with tracks and a large gun mounted on top as well. The building behind them appears to be a warehouse or storage facility.'},\n", + " {'image_id': '806',\n", + " 'caption': 'This image shows an older man in a blue shirt pointing at a large, old, hand-drawn map of a city or town on the wall. The map has various streets, buildings, and landmarks marked on it. The man is pointing at a specific location, perhaps indicating where he lives or where he is from. He has a serious expression on his face and glasses perched on his nose. The room appears dimly lit with only a small amount of light coming in from the window behind him. The image suggests a sense of history and nostalgia.'},\n", + " {'image_id': '807',\n", + " 'caption': 'The image shows a group of people walking on a sandy beach next to a large body of water. The water is a bright blue and there are mountains in the background. The sky is clear and the sun is shining down on the scene. There are trees on the sides of the beach and some rocks in the water.'},\n", + " {'image_id': '808',\n", + " 'caption': 'The image shows a green clock with a white face and yellow hands mounted on a white wall. The clock has a round shape.'},\n", + " {'image_id': '809',\n", + " 'caption': 'This image shows a bedroom with a beige carpet and white walls. There is a large bed with a wooden frame and a beige bedspread. The bed is positioned in front of a large window that looks out onto a balcony or patio. There is a small table with a lamp on it next to the bed. The room is spacious and well lit.'},\n", + " {'image_id': '812',\n", + " 'caption': 'The image shows a group of people rafting down a river. They are all wearing life jackets and are smiling as they ride the rapids. The water is splashing up around them and they are holding onto the raft for dear life.'},\n", + " {'image_id': '813',\n", + " 'caption': 'This is an image of a modern and minimalist house with a wooden facade, a small garden, a large window on the second floor, and a small balcony on the first floor. The garden is filled with small trees and bushes, and there is a path leading to the front door.'},\n", + " {'image_id': '814',\n", + " 'caption': 'The image shows a group of men playing volleyball. They are all wearing red and white uniforms, with one player wearing a blue shirt. The player in the middle is reaching up to block the ball with his hand. The other players are positioned around the court, ready to hit the ball.'},\n", + " {'image_id': '818',\n", + " 'caption': 'There are several muffins on a white table with a plate of sliced strawberries in the background. The muffins have a crumbly texture and are topped with a sprinkle of sugar. The strawberries are sliced and arranged in a bowl on the table.'},\n", + " {'image_id': '819',\n", + " 'caption': 'This is a two-story house with a large front yard and a driveway leading to the garage. The exterior of the house is made of stucco and brick, with large windows on the front and side. The roof is made of shingles and there is a chimney on the left side. The front yard is landscaped with trees and shrubs, and there is a patio area in the back.'},\n", + " {'image_id': '820',\n", + " 'caption': \"The image shows a businessman in a suit and tie pressing a button on a touch screen. The background is a blue gradient with white squares and rectangles. The businessman's hand is pressed against the screen, with his index finger on the button. The image is a representation of technology and the use of touch screens.\"},\n", + " {'image_id': '821',\n", + " 'caption': 'This is an image of a bartender pouring a cocktail made with vodka, lime juice, and ice into a clear glass. The bartender is wearing a white shirt with black sleeves and a black apron and is holding a stainless steel cocktail shaker with a black handle in their right hand. The drink is garnished with a lemon wedge and a thin slice of lemon on the rim of the glass. The background is a wooden bar with a black countertop and shelves of liquor bottles behind the bartender.'},\n", + " {'image_id': '822',\n", + " 'caption': 'people in lab coats looking at beakers and test tubes filled with different colored liquids on a wall behind them. The background features a green and blue gradient circle.'},\n", + " {'image_id': '823',\n", + " 'caption': 'The image depicts a red Dodge Charger driving down a tree-lined road. The car is a large, four door sedan with a bold front grille, sleek lines, tinted windows, and a spoiler on the back. It appears to be in good condition.'},\n", + " {'image_id': '824',\n", + " 'caption': 'This image shows a bride and groom walking down the aisle at their wedding in front of a large, ornate building. The sun is shining brightly in the background, casting long shadows on the ground and illuminating the scene. The bride is wearing a white wedding gown and carrying a bouquet of flowers, while the groom is wearing a black tuxedo and holding a single red rose. The ceremony is taking place on a grassy area in front of the building, and there are several rows of chairs set up for guests to watch. The building has a large, arched entrance and several windows, and there are several trees and bushes in the foreground.'},\n", + " {'image_id': '825',\n", + " 'caption': 'The image depicts a colorful mural on the side of a building. The mural shows a group of people holding umbrellas and walking in the rain, with the umbrellas having intricate designs. The people in the mural are smiling and seem to be enjoying their walk in the rain. The background of the mural is a bright blue sky with fluffy clouds. The overall effect of the mural is cheerful and uplifting.'},\n", + " {'image_id': '826',\n", + " 'caption': 'This image shows a young boy standing in front of a fence with a group of cows behind him. The boy is reaching his hand out to pet one of the cows. The cows are in a pen, and there is hay on the ground in front of them. The boy is wearing a plaid shirt and jeans, and he has short brown hair. The cows are brown with white spots, and they have long tails. The fence is made of wood and has a gate in the middle. There are trees in the background, and the sky is cloudy.'},\n", + " {'image_id': '828',\n", + " 'caption': 'This image depicts a white hatchback car driving alongside a body of water on a road with a mountain in the background. The car has four doors, tinted windows, alloy wheels, and a small rear spoiler. It appears to be in good condition with a clean and shiny white finish, no visible scratches or dents, and a well-maintained appearance. The front grille of the car displays its logo, and the license plate is not visible.'},\n", + " {'image_id': '830',\n", + " 'caption': 'This image shows a bedroom with white walls, hardwood floors, and a large window with white curtains. The bed has a white headboard, blue and white striped bedspread, and blue pillows. There is also a small table with a lamp next to the bed.'},\n", + " {'image_id': '831',\n", + " 'caption': 'The image shows a couple standing on a grassy hill overlooking a body of water. The man is holding the woman in his arms and they are both smiling. The sky is cloudy and there are mountains in the background.'},\n", + " {'image_id': '832',\n", + " 'caption': 'The image shows a group of people standing on top of a snowy mountain. They are wearing backpacks and winter clothing, and are posing for a group photo. The sky is cloudy and there are mountains in the background.'},\n", + " {'image_id': '833',\n", + " 'caption': 'This image is a black and white photograph of a glass dome with a silhouette of a person inside it. The person is standing with their back to the viewer, and their head is tilted to the side. The words \"i am not a robot\" are written in white letters on the black background. The image is simple and minimalistic, with a clear focus on the person inside the dome.'},\n", + " {'image_id': '834',\n", + " 'caption': 'The image shows two ears of corn on the cob. The corn is yellow and appears to be freshly harvested. There are several kernels visible on each ear, and the husks are still attached. The ears are lying on top of each other, with one ear slightly tilted to the side. The background is a blue sky with fluffy white clouds.'},\n", + " {'image_id': '835',\n", + " 'caption': 'The image is a rubber stamp with the words blood sugar level written on it in blue ink. The stamp appears to have been stamped onto a transparent surface, such as a piece of paper or plastic. The words blood sugar level are written in capital letters, with the first letter of each word in a larger font than the rest of the words. The stamp appears to be made of rubber, with a slightly raised texture on the surface. The words blood sugar level are written in blue ink, with the first letter of each word in a slightly darker shade of blue than the rest of the words. The stamp appears to have been stamped onto the surface with some force, as there are small indentations in the rubber where the ink has been pressed down. The overall appearance of the stamp is slightly worn, with some scratches and scuffs on the surface.'},\n", + " {'image_id': '837',\n", + " 'caption': 'This is an image of a white plastic water filtration system with two hoses connected to the top. The words \"triple clear\" are written on it in blue letters. The filtration system removes impurities from water, making it safe to drink.'},\n", + " {'image_id': '838',\n", + " 'caption': 'The image depicts a rural field with fully grown crops, likely wheat or corn. No buildings or structures are visible. The sky is overcast, and the image was probably taken during the growing season. It is unclear whether the farm is small and independent or larger and commercial, or whether it grows crops for personal use or sale. The image highlights the important role of the agricultural industry in providing food for people worldwide.'},\n", + " {'image_id': '839',\n", + " 'caption': 'the background. The harness has a leash attached to it, and the dog is also wearing a yellow vest and collar with a tag. The background consists of trees and a cloudy sky.'},\n", + " {'image_id': '840',\n", + " 'caption': 'The image shows a group of young men standing on the deck of a ship. They are all wearing coats and scarves, and one of them is holding a guitar. The ship appears to be in a state of disrepair, with rust and debris visible on its hull and deck. The men are looking out to sea, as if they are waiting for something to happen. The overall mood of the image is one of anticipation and uncertainty.'},\n", + " {'image_id': '841',\n", + " 'caption': \"This image is a creative illustration of a cartoon tea kettle with steam coming out of its spout. The tea kettle is depicted in a stylized manner, with a round body and a curved spout. The steam coming out of the spout is depicted as a wavy line. The overall color scheme of the image is a warm gradient, with the tea kettle and steam depicted in shades of yellow and orange. The background of the image is not visible, as it is obscured by the steam. This image could be used in a variety of contexts, such as in a children's book illustration, on a product label, or as part of a graphic design. It could also be used as a decorative element in a home or office setting.\"},\n", + " {'image_id': '842',\n", + " 'caption': 'This is an image of gold and silver coins arranged in a pyramid shape on a black background. The gold coins are on the bottom and the silver coins are on top. The gold coins are shiny and reflective, while the silver coins are dull and matte. The image conveys a sense of wealth and prosperity.'},\n", + " {'image_id': '843',\n", + " 'caption': 'The image shows a group of cartoon characters The cartoon characters are all different animals, including a raccoon, a cat, a dog, and a rat. They are all wearing different outfits and posing in different positions. The background is a plain yellow color.'},\n", + " {'image_id': '846',\n", + " 'caption': 'The bride is wearing a white robe and standing in front of a window with a wreath hanging on it. The wreath is made of greenery and has a bow on top. The bride is looking at her reflection in the mirror.'},\n", + " {'image_id': '847',\n", + " 'caption': 'The image shows a female golfer hugging a male golfer on a golf course. The female golfer is wearing a green polo shirt and white pants, while the male golfer is wearing a white polo shirt and black pants. Both golfers have their arms around each other and are smiling at the camera. The background is a green golf course with trees and a blue sky.\\n\\nThe female golfer is wearing a green polo shirt and white pants, while the male golfer is wearing a white polo shirt and black pants. Both golfers have their arms around each other and are smiling at the camera. The background is a green golf course with trees and a blue sky.'},\n", + " {'image_id': '848',\n", + " 'caption': 'The image is of a woman wearing a black t-shirt with the words \"I\\'m a drummer\\'s wife\" written in pink letters on the front. The shirt has a relaxed fit and is made of a soft, breathable fabric. It is a simple and stylish design, which is suitable for anyone who loves music or wants to show their love for drumming. The shirt is comfortable and easy to wear, making it a great way to showcase your personality and style.'},\n", + " {'image_id': '850',\n", + " 'caption': 'This image shows a large, tan building with white columns and black shutters on the windows. The front of the building has a covered porch with white pillars and a balcony on the second floor. The building is surrounded by trees and landscaping, including bushes and flowers. There is a sidewalk leading up to the entrance of the building and a driveway on the right side. The building appears to be well maintained and in good condition.'},\n", + " {'image_id': '851',\n", + " 'caption': 'The image depicts a building with pink and blue bricks and a pool located at the center. The pool has pink and blue tiles surrounding it and a blue diving board at one end. A ladder with pink and blue painted rungs leads down to the pool. The building has windows on the top floor and a pink and blue roof. The sky is blue with clouds in the background.'},\n", + " {'image_id': '852',\n", + " 'caption': 'This image shows a man standing next to a table holding a trophy. The man is wearing a black leather jacket and is smiling at the camera. The trophy appears to be made of metal and has engravings on it. The background of the image is a dimly lit room with a white ceiling and walls.'},\n", + " {'image_id': '853',\n", + " 'caption': \"The image shows a small wooden house on a hill with a red roof and white walls overlooking a lake surrounded by green hills and flowers. A path leads down to the water's edge. The sky is bright blue with fluffy white clouds, creating a peaceful and serene mood.\"},\n", + " {'image_id': '854',\n", + " 'caption': 'This image shows a group of people standing outside in front of a building. They are all dressed in different clothing, with one person wearing a hat and sunglasses, another wearing a suit and tie, and the others wearing casual clothing. They are all smiling and appear to be having a good time. There is a car parked in front of the building and some trees in the background.'},\n", + " {'image_id': '855',\n", + " 'caption': 'The image shows a herd of bison grazing near a lake in a forest area. The bison are standing on the grassy shore of the lake, with their heads down as they eat. In the background, there are tall pine trees and mountains visible. The sky is clear and blue, with a few fluffy clouds visible. \\n\\nThere are several bison in the image, ranging in size from small calves to large adults. They have shaggy brown fur and large heads with distinctive humps on their backs. Some of the bison are standing on their hind legs, while others are lying down or grazing on the grass.\\n\\nThe lake is surrounded by lush green forest, with tall pine trees and other types of foliage visible. The water is clear and reflects the trees and mountains in the background.'},\n", + " {'image_id': '856',\n", + " 'caption': \"flowing through the valley and the surrounding hills and mountains providing a breathtaking backdrop. The crystal clear water, pink flowers, and lush greenery add to the scene's tranquility, while the rocky outcrop and trees provide a sense of stability and grounding. The presence of snow on the distant mountains also adds a touch of harshness and contrast to the otherwise peaceful scene.\"},\n", + " {'image_id': '857',\n", + " 'caption': 'The dress is made of a sheer, lacy material with intricate embroidery on the bodice and sleeves. It has a high neckline and a fitted waist, with a flared skirt that falls just above the knee. The dress has a zipper closure on the back. The color of the dress is a light grey with white and silver embroidery. The model is wearing a pair of strappy sandals with the dress.'},\n", + " {'image_id': '858',\n", + " 'caption': 'The image depicts a sliced orange on a white background. There are six slices of the orange in the image, each with its own unique shape and color. The orange slices are arranged in a circular pattern, with one slice in the center and the other slices surrounding it. The orange slices have a bright, vibrant color that stands out against the white background. The overall effect of the image is one of freshness and vitality, as the orange slices appear to be freshly sliced and ready to be enjoyed.'},\n", + " {'image_id': '860',\n", + " 'caption': \"The image is a white t-shirt with a red and orange design on the front that reads `libor university'. The design features a shield with the words `libor university' written on it in red and orange letters. The shield is surrounded by a red and orange border with the same words. The t-shirt also features the university's logo, which is a shield with the same words written on it in red and orange letters.\"},\n", + " {'image_id': '862',\n", + " 'caption': \"The image depicts a cartoon bear wearing a suit and bow tie, standing with his hands in his pockets. The bear is wearing a plaid jacket and brown pants, and has a brown bow tie around its neck. The bear's face is not visible, but it appears to be smiling. The image is in black and white, with a white background.\\n\\nThe bear is wearing a suit and bow tie, which suggests that it is dressed up for a formal occasion. The brown pants and jacket give the bear a rustic, outdoorsy look, while the bow tie adds a touch of sophistication. The bear appears to be smiling, which suggests that it is happy or excited about something. The white background helps to make the bear stand out and gives the image a clean, crisp look.\"},\n", + " {'image_id': '863',\n", + " 'caption': 'There are three tables in the image, all made of wood with round tops. One has a brown finish while the other two have a lighter color. The tables are arranged in a row, with the largest on the left and the smallest on the right. The room has concrete walls and a metal door on the left side. No chairs or other furniture are present.'},\n", + " {'image_id': '865',\n", + " 'caption': 'This image shows a metal pot filled with a white liquid being stirred by a wooden spoon. A measuring cup with an unidentified liquid is placed beside the pot on a wooden table with a brown surface.'},\n", + " {'image_id': '867',\n", + " 'caption': 'The image shows a man and a woman standing next to each other at a party. The man is wearing a black suit and the woman is wearing a brown dress. They are both holding drinks and smiling at the camera. There are other people in the background, sitting at tables and standing around them. The room is dimly lit and there are chandeliers hanging from the ceiling.'},\n", + " {'image_id': '869',\n", + " 'caption': \"This is a photo of a bookstore. The walls are painted white and there are shelves of books on the walls, filled with a variety of books, including fiction, nonfiction, and children's books. The floor is made of tiles and there is a carpeted area in the center of the room. The room is well lit with overhead lights and floor lamps on the shelves. There is a large window on one wall that lets in a lot of natural light. Two people are in the photo, one standing by the window and the other in front of the shelves.\"},\n", + " {'image_id': '870',\n", + " 'caption': 'This image is a flyer or poster advertising a yoga class or event. It features a photograph of a person in a yoga pose on the left side, with the words \"Sound Immersions at Brevard Yoga on the 3rd Sunday of the month at 7pm\" written above. On the right side, there is an image of a set of drums and other musical instruments, with the same text written above them. The overall design is clean and simple, with a white background and bold, black text.'},\n", + " {'image_id': '872',\n", + " 'caption': \"This is a white husky puppy sitting on the grass, looking up at the camera with its tongue out. The puppy's fur is fluffy and white, and its eyes are bright blue. The grass is green and lush, and there is a blue sky in the background. The puppy's ears are perked up and its tail is wagging. There is a fence and some trees in the distance.\"},\n", + " {'image_id': '875',\n", + " 'caption': 'The image depicts a glowing globe surrounded by a network of lines and dots. The lines and dots appear to be connected to the globe and to each other, forming a complex pattern. The globe is glowing with a bright blue light, and the lines and dots around it are also glowing in different shades of blue and green. The overall effect is a futuristic, high-tech image that suggests the interconnectedness of technology and the world.\\n\\nThe image could be used to represent a variety of concepts related to technology and the world, such as globalization, interconnectedness, and the role of technology in shaping our understanding of the world. It could also be used to represent the idea of a \"global village,\" in which technology has made the world smaller and more interconnected. Overall, the image suggests a futuristic, high-tech vision of the world that is connected and interdependent.'},\n", + " {'image_id': '876',\n", + " 'caption': 'This image shows the inside of a building with intricate carvings and decorations on the walls and ceiling. The floor is made of wooden planks and there are two large elephant tusks on either side of the entrance. The walls are decorated with carvings of various animals, including elephants, lions, and giraffes. There is a large red curtain hanging from the ceiling in the center of the room.'},\n", + " {'image_id': '877',\n", + " 'caption': 'This image depicts a person pushing a cart full of snow-covered boxes down a snowy street. The person is wearing a hooded sweatshirt and gloves, and is using both hands to push the cart. The boxes are stacked on top of each other. Cars are parked on both sides of the street, and buildings can be seen in the background. The sky is cloudy and snow is falling.'},\n", + " {'image_id': '878',\n", + " 'caption': 'The image shows a woman wearing a pink dress and a white hat. She has a serious expression on her face and is looking directly at the'},\n", + " {'image_id': '879',\n", + " 'caption': \"This image depicts the planet Mars, which is the fourth planet from the sun in our solar system. It is known for its reddish appearance and is often referred to as the Red Planet. The image shows a view of the planet from space, with the planet's surface visible in the foreground and the blackness of space in the background. There is a small satellite orbiting the planet, which can be seen in the upper left corner of the image. The satellite is equipped with various instruments to study the planet's atmosphere and surface.\"},\n", + " {'image_id': '880',\n", + " 'caption': 'This image depicts a djembe, which is a type of drum that originated in West Africa. The djembe is made from a hollowed tree trunk and has a goat skin head. It is played with sticks and is used in traditional African music. The image shows the djembe on a white background.'},\n", + " {'image_id': '881',\n", + " 'caption': 'The image shows a shoe organizer with six compartments, each containing a pair of shoes. The compartments are lined with beige fabric and have brown straps to keep the shoes in place. The bottom of the organizer has a zipper to close it.'},\n", + " {'image_id': '882',\n", + " 'caption': 'This image shows a clean desk, which is a sign of an organized and tidy workspace. The desk appears to be made of wood and has a computer, monitor, keyboard, mouse, and other office supplies on it. There is a lamp on the desk, and the room appears to be well lit. The walls of the room are painted white, and there is a window behind the desk that lets in natural light. The floor is made of wood or laminate, and there are no visible clutter or mess on the desk or surrounding area. The overall impression is one of cleanliness and organization.'},\n", + " {'image_id': '884',\n", + " 'caption': 'This image is a production cel from the animated film, \"Snow White and the Seven Dwarfs.\"'},\n", + " {'image_id': '885',\n", + " 'caption': 'This image shows a man sitting at a table with a plate of food in front of him. The man is wearing a suit and holding a glass of wine. There are several other plates of food on the table, including meat, vegetables, and bread. The table is covered with a white tablecloth and has a vase of flowers. The room appears to be a dining room, with a large window behind the man and a chandelier hanging from the ceiling. The walls are painted a light color, and there are several pieces of artwork. The overall atmosphere of the image is elegant and sophisticated.'},\n", + " {'image_id': '887',\n", + " 'caption': 'The image shows a group of people standing in a circle on a green lawn, holding hands and looking towards the center where a small tree with a red ribbon tied around it is located. They appear to be happy and smiling, while the sun shines down on the scene, casting long shadows on the grass. The mood of the image is joyful and unifying.'},\n", + " {'image_id': '888',\n", + " 'caption': 'The image shows a metal pegboard with tools arranged in the shape of the letter \"b\", including hammers, wrenches, and screwdrivers. It is mounted on a white background.'},\n", + " {'image_id': '889',\n", + " 'caption': \"This is a Lego model of a humanoid robot. It has a white and gray color scheme with black accents on the arms and legs. The robot is standing on its hind legs with its arms outstretched. It appears to be holding something, but it's unclear what it is. The robot has a sleek and futuristic design, with intricate details on the body and head, resembling a character from a science fiction movie or video game.\"},\n", + " {'image_id': '890',\n", + " 'caption': 'The image shows a beach with the ocean in the background. A large tree branch hangs over the sand, and a small dog stands on the beach in front of it. The sky is clear and blue with a few fluffy clouds in the distance. The water is deep blue with small waves washing up onto the shore. The sand is white with small rocks and shells scattered around. Palm trees and greenery are in the background.'},\n", + " {'image_id': '891',\n", + " 'caption': 'The image shows a rooftop garden surrounded by a metal fence with stairs leading up to it. The garden contains various plants, including grasses and shrubs. In the background, there is a construction site with cranes and scaffolding. The sky is clear and blue.'},\n", + " {'image_id': '892',\n", + " 'caption': 'This is a white mug with an image of a person wearing a red and white striped shirt and black hair. The mug is placed on a white background.'},\n", + " {'image_id': '893',\n", + " 'caption': 'This image depicts a young boy playing tennis with a racket on a white background. The boy is wearing blue shorts and a green shirt, and he is holding a tennis racket in his hand. The image is a simple illustration of a young boy playing tennis, and it could be used in a variety of contexts, such as on a website, in a book, or as part of a design for a poster or brochure. The image could also be used as a decorative element, or as a part of a larger illustration or design.'},\n", + " {'image_id': '894',\n", + " 'caption': 'The image shows a small waterfall flowing over rocks in a wooded area surrounded by lush green foliage and trees. The rocks are covered in moss and lichen. The water is clear and appears to be flowing from a higher elevation to a lower one, giving a sense of tranquility with the sound of the water and peaceful surroundings.'},\n", + " {'image_id': '895',\n", + " 'caption': \"The image is a movie poster for the comedy horror film Young Frankenstein, directed by Mel Brooks and starring Gene Wilder, Madeline Kahn, and Cloris Leachman. It was released in 1974 and parodies the classic Universal horror films of the 1930s and 1940s, specifically Frankenstein and Bride of Frankenstein. The story follows a young neurosurgeon who inherits his grandfather's castle in Transylvania and attempts to reanimate his grandfather's monster. The film features iconic characters such as the monster, played by Peter Boyle, and the mad scientist, played by Gene Wilder. Young Frankenstein was a box office success and has become a cult classic.\"},\n", + " {'image_id': '897',\n", + " 'caption': 'the foreground and a distant mountain range in the distance. The sky is a deep orange color, with a few clouds visible in the distance.'},\n", + " {'image_id': '898',\n", + " 'caption': 'The image shows a woman standing next to a car at a gas station. She is wearing a blue crop top and ripped jeans, and has her hair styled in a messy bun. There is a gas pump in the foreground, and the woman appears to be getting out of the car. The image is well lit and in focus, with a clear blue sky in the background.'},\n", + " {'image_id': '899',\n", + " 'caption': 'The image shows a group of people standing around a white Mercedes S Class Coupe on display at an auto show. The car has a sleek, modern design. Some people in the image are taking pictures of the car while others are just standing and looking at it. In the background, there are other cars on display, including a red sports car and a black sedan. The people in the image are dressed in a variety of clothing, including suits, dresses, and casual outfits. The overall atmosphere of the image is one of excitement and interest in the cars on display.'},\n", + " {'image_id': '902',\n", + " 'caption': 'This image shows a bride and groom walking through an olive grove at sunset. The bride is wearing a white wedding dress and the groom is wearing a black tuxedo. They are holding hands and looking at each other with smiles on their faces. The sun is setting behind them, casting a warm orange glow over the scene. The trees in the background are tall and thin with changing leaves for the fall. The ground is covered with dry leaves and twigs, and there is a dirt path that leads through the grove.'},\n", + " {'image_id': '904',\n", + " 'caption': \"This is an image of a police officer wearing a black uniform with a rainbow heart badge on the chest. The officer is holding a pair of handcuffs in one hand and a baton in the other. The officer's face is not visible in the image. The image is in black and white.\"},\n", + " {'image_id': '905',\n", + " 'caption': 'This is a black and white photograph of a man in ski gear kneeling on a snowy slope with skis and poles at his feet. The man is wearing a white helmet, goggles, gloves, and a black jacket with white stripes on the sleeves. He is also wearing black pants and boots. In the background, there are mountains with snow on them and a blue sky.\\n\\nThe man is kneeling on the snow with his skis and poles at his feet. He is wearing a white helmet, goggles, gloves, and a black jacket with white stripes on the sleeves. He is also wearing black pants and boots. In the background, there are mountains with snow on them and a blue sky.'},\n", + " {'image_id': '906',\n", + " 'caption': 'This image is a black and white photograph of a woman in a ball gown standing in front of a mirror. The woman is wearing a long, flowing dress with a low neckline and a slit up the side. The dress is adorned with beads and sequins, and the woman is holding a bouquet of flowers in her left hand. Behind the woman, there is a reflection of a young girl in a pink dress standing on the other side of the mirror. The girl is looking at the woman in the ball gown with a curious expression on her face. The overall tone of the image is elegant and sophisticated.'},\n", + " {'image_id': '908',\n", + " 'caption': 'This is an image of a fish. It has a long, slender body with a small head and large eyes. The fish has a brown and white striped pattern on its body.'},\n", + " {'image_id': '909',\n", + " 'caption': 'This image shows a group of people sitting in a theater watching a movie. They are all wearing casual clothing and smiling at the camera. Some of them are holding drinks and snacks, while others are holding their phones. The theater is dimly lit, with only the light from the screen illuminating the room. The people in the image appear to be enjoying themselves and having a good time.'},\n", + " {'image_id': '910',\n", + " 'caption': 'The woman in the image is wearing a green and gold patterned dress with a plunging neckline, long sleeves, a fitted bodice, and a flared skirt. She is also wearing a brown jacket with gold detailing on the lapels and pockets, which has long sleeves and is open at the front. Her black high heels complement her outfit, and her hair is styled in loose waves. She is posing with her hands on her hips and a smile on her face in a dimly lit room with tables and chairs set up for a party or event.'},\n", + " {'image_id': '911',\n", + " 'caption': 'There is a stack of old and worn books on a desk in front of a chalkboard in a dimly lit room. An apple with a bite taken out of it sits on top of the stack. The chalkboard has writing on it, but the words are unclear. A single lightbulb hangs from the ceiling.'},\n", + " {'image_id': '912',\n", + " 'caption': 'The bride and groom are standing in front of a large tree with colorful leaves in the background. They are both smiling and looking at the camera. The bride is wearing a white wedding dress with a long veil and the groom is wearing a black tuxedo with a white shirt and tie.'},\n", + " {'image_id': '914',\n", + " 'caption': \"The image is a black and white photograph of a woman wearing a dress with a tropical print. The dress has a high neckline, long sleeves, and a flared skirt. The woman is wearing a pair of black heels and has her hair styled in a bun. The photograph is taken from a low angle, looking up at the woman's face and the dress. The background is a blur of green leaves and plants.\"},\n", + " {'image_id': '915',\n", + " 'caption': \"This is an image of a television screen with a red background displaying an image of a person standing in front of a white wall. The person is wearing a red shirt and black pants. The image is clear, well-defined, and high-resolution with no pixelation or blurriness. Fine details such as the wrinkles in the person's shirt and the texture of the wall can be seen. The colors are vibrant and well-saturated, with the red background providing bold contrast to the white wall and the person's clothing. Overall, this is a well-composed and visually appealing image.\"},\n", + " {'image_id': '916',\n", + " 'caption': 'This is a small white church with a steeple on top and a cross on the front. The building is surrounded by green grass and trees.'},\n", + " {'image_id': '918',\n", + " 'caption': 'The image shows a group of colorful buttons arranged in a circular pattern on a white cloth. Each button has a different color and shape, and they are all tied together with a piece of yarn. The buttons appear to be made of plastic or some other synthetic material, and they have a smooth, glossy surface. The overall effect of the image is one of bright, cheerful colors and playful, whimsical design.'},\n", + " {'image_id': '919',\n", + " 'caption': \"The image shows a group of people standing together in a line, with their arms around each other's shoulders. They are all smiling and looking at the camera. The background is white and there is no text or other elements in the image. The people in the image appear to be a group of friends or colleagues, standing together in a casual pose. They are all dressed in different clothing, with some wearing jeans and t-shirts, and others wearing more formal attire such as suits and dresses. The overall mood of the image is one of happiness and camaraderie.\"},\n", + " {'image_id': '922',\n", + " 'caption': 'This image shows a bowl of zucchini noodles with beef and vegetables, topped with sliced beef and vegetables, served in a white bowl with a wooden spoon holding the noodles. The background is a wooden table with a white tablecloth.'},\n", + " {'image_id': '923',\n", + " 'caption': 'This image features three sailboats sailing towards the camera on a calm body of water. In the background, there are tall buildings made of brick or concrete with windows, balconies, and some flags or banners. The sky is overcast with dark clouds in the distance. The sailboats include a small white sailboat with a red hull, a larger white sailboat with a blue hull and white sails, and a small white sailboat with a blue hull and white sails.'},\n", + " {'image_id': '925',\n", + " 'caption': 'This image depicts a large white building with many windows and balconies, located on a city street at dusk. The building has several floors and appears to be made of concrete and steel. There are several cars parked on the street in front of the building, and people can be seen walking on the sidewalks. The sky is pink and orange, indicating a sunset.'},\n", + " {'image_id': '927',\n", + " 'caption': 'This is an image of a black and white cat with yellow eyes looking directly at the camera with a curious expression. The text on the image reads, \"the amazing adventures of Marcello the cat.\" The cat appears to be well groomed and in good health. Its fur is smooth and shiny, eyes are bright and alert, whiskers are long and bushy, and ears are perked up and attentive. The background is solid black, making the cat stand out. The overall effect of the image is one of playfulness and cuteness.'},\n", + " {'image_id': '928',\n", + " 'caption': \"This image shows a group of people sitting on the steps of a building. They are all dressed in white shirts and shorts, and one person is holding a dog on a leash. The building behind them appears to be made of stone and has several windows and a door. The sky is cloudy and there are some trees in the background. The people in the image appear to be relaxing and enjoying each other's company. They are sitting in a row, with the person holding the dog sitting at the end. The person on the left is wearing sunglasses and has their arm around the person next to them. The person in the middle is smiling and has their hand on the shoulder of the person on the right, who is looking down and appears to be petting the dog. This image is a snapshot of a group of friends or family members enjoying a moment together outside.\"},\n", + " {'image_id': '929',\n", + " 'caption': 'The image shows a group of people standing in front of a large body of water, with lightning flashing in the background. The people in the image are dressed in dark clothing, with one person holding a staff and another holding a sword. The image appears to be a scene from a movie.'},\n", + " {'image_id': '930',\n", + " 'caption': 'This image is a botanical illustration of a plant with large, green leaves and small, white flowers. The leaves are long and thin, and the flowers are small and white with yellow centers. The plant appears to be growing out of the ground and has a long, thin stem. The background of the image is white.'},\n", + " {'image_id': '931',\n", + " 'caption': 'The image shows a bowl of white whipped cream topped with sliced lemons. The lemons are scattered around the bowl and on the table in front of it. The background appears to be a wooden surface.'},\n", + " {'image_id': '934',\n", + " 'caption': 'The image shows a beige scooter parked on a gray surface. The scooter has a brown seat and black wheels. The scooter appears to be in good condition, with no visible scratches or dents.\\n\\nThe scooter has a sleek, modern design, with a streamlined body and a small, round headlight. The handlebars are low and wide, making it easy for the rider to control the scooter. The fuel tank is located under the seat, and there is a small storage compartment under the seat as well.\\n\\nOverall, the scooter appears to be a reliable and stylish mode of transportation.'},\n", + " {'image_id': '935',\n", + " 'caption': \"This image is a statue of an angel The statue is made of stone and depicts an angel holding a baby in its arms. The angel's face is serene and its wings are outstretched, as if it is about to take flight. The statue is located in a garden surrounded by shrubs and trees.\"},\n", + " {'image_id': '936',\n", + " 'caption': 'The image shows a man and The man is wearing a black suit with a white shirt and a black tie. The woman is wearing a black suit with a white blouse and a black tie. Both are wearing black shoes and have their hands in their pockets. They are standing in front of a white background.'},\n", + " {'image_id': '937',\n", + " 'caption': 'This image shows a man wearing a blue shirt, white pants, and white sneakers walking down a light blue hallway with a blue carpet. He has his hands in his pockets, wears sunglasses, and has a serious expression on his face. No other people are visible in the image.'},\n", + " {'image_id': '938',\n", + " 'caption': 'This is an image of a man wearing a white apron and gloves, standing in front of a kitchen counter. The man is holding a large knife in his right hand and appears to be preparing food. The kitchen behind him is well equipped with various utensils and appliances, including a stove, oven, and refrigerator. The overall atmosphere of the image is warm and inviting, with soft lighting and a cozy ambiance.'},\n", + " {'image_id': '939',\n", + " 'caption': 'This image shows an older man standing next to a wooden fence with a cross on it. The man is wearing a gray sweater and has gray hair and a beard. He is looking at the camera with a serious expression on his face. Behind him, there is a house with a white picket fence and a small garden with some flowers in it. The sky is cloudy and there are some trees in the background.'},\n", + " {'image_id': '940',\n", + " 'caption': 'The image is a handshake between two people, one wearing a shirt with the colors of the South African flag and the other wearing a shirt with the colors of the United States flag. The handshake is a symbol of unity and cooperation between the two countries.\\n\\nThe colors of the South African flag are black, green, yellow, red, and blue, while the colors of the United States flag are red, white, and blue. The handshake is taking place in front of a white background, and both people are looking at each other with smiles on their faces.\\n\\nThe image can be interpreted as a symbol of friendship and cooperation between South Africa and the United States, as well as a representation of the diversity and unity of the two countries.'},\n", + " {'image_id': '942',\n", + " 'caption': 'This is a black and white ink drawing of a gate in the middle of a field. The gate is made of metal and has a rusty appearance. Tall grasses and weeds are growing on either side of the gate. In the background, a hill with trees on it can be seen, and in the distance, there is a body of water. The overall mood of the image is peaceful and serene.'},\n", + " {'image_id': '945',\n", + " 'caption': 'The image shows a person standing on top of a rocky mountain with snow covered peaks in the background. The person is wearing a red jacket, black pants, and a backpack. The sky is cloudy and there are no trees or other vegetation visible.'},\n", + " {'image_id': '946',\n", + " 'caption': 'The image shows a body of water with a large glass building in the background. Several boats are in the water, and a few people are standing on the shore. The sky is clear and blue with clouds in the distance. Tall buildings and trees are visible on the other side of the water.'},\n", + " {'image_id': '948',\n", + " 'caption': 'This image shows a white wedding dress with lace detailing on the bodice and skirt hanging on a wooden rack in a dimly lit room with wooden beams. The strapless gown has a sweetheart neckline and is made of a delicate, sheer material. Light is coming in from the windows and chandelier hanging from the ceiling. The room has white walls and a wooden plank floor with a rug in front of the dress.'},\n", + " {'image_id': '949',\n", + " 'caption': \"This image is of a Paw Patrol themed birthday party. The plate features several characters from the show, including Chase, the main character, and various vehicles such as a fire truck and police car. The plate has a blue and white background with the Paw Patrol logo in the center. Balloons and streamers in blue, red, and yellow, the show's signature colors, decorate the plate.\"},\n", + " {'image_id': '950',\n", + " 'caption': 'The woman in the image is wearing a white dress and a wide-brimmed straw hat while standing on a sandy beach. She has her hands on her hips and is looking off into the distance. The dress has a high neckline and long sleeves, and the hat has a wide brim to shade her face from the sun. She is also wearing white sneakers and has a small bag slung over her shoulder. The background features sandy beach, rocks, and palm trees in the distance.'},\n", + " {'image_id': '951',\n", + " 'caption': 'This is a map of the city of Mumbai, India. Mumbai is located on the coast of the Arabian Sea and is the largest city in India. It is divided into several districts, including South Mumbai, North Mumbai, East Mumbai, and West Mumbai. The city is known for its bustling streets, vibrant culture, and iconic landmarks such as the Gateway of India and the Taj Mahal Palace Hotel.'},\n", + " {'image_id': '952',\n", + " 'caption': \"This image shows a silver 2005 Honda Odyssey minivan parked in front of a brick building with graffiti on the side. The license plate on the back of the car reads `person'. The car appears to be in good condition, with no visible dents or scratches. The windows are tinted and the wheels are silver. There is a small amount of graffiti on the side of the building.\"},\n", + " {'image_id': '953',\n", + " 'caption': 'The image shows heart-shaped sunglasses with metal frames in a matte finish. The lenses are tinted in shades of pink, brown, and purple. The sunglasses are displayed in a grid pattern against a white background.'},\n", + " {'image_id': '954',\n", + " 'caption': 'The image shows two hands, one holding a small plant in a pot, and the other hand placed on top of the plant as if to protect it. The background is plain white, and the overall tone is peaceful and serene.'},\n", + " {'image_id': '955',\n", + " 'caption': 'This image shows the inside of a large, ornate cathedral with high vaulted ceilings and large stained glass windows. The walls are made of stone and have intricate carvings and decorations. The floor is made of marble and there are several pews for people to sit on. The altar at the front of the cathedral has a large crucifix on it and there are several candles lit around it. The overall atmosphere of the image is one of grandeur and reverence.'},\n", + " {'image_id': '956',\n", + " 'caption': 'This is a black folding bicycle with white accents. The front wheel is removed and leaning against a white wall. The bike has a black frame, white wheels, and white accents on the handlebars, seat, and pedals. The tires are black and in good condition. The bike has a small amount of dirt but is in overall good condition.'},\n", + " {'image_id': '957',\n", + " 'caption': 'The image depicts a grey leather shoulder bag with silver studs on the sides and a zipper closure on the top. The bag has a long adjustable strap for wearing it as a shoulder or crossbody bag. It also features a small tassel on the zipper pull. The bag appears to be empty with no visible pockets or other features.'},\n", + " {'image_id': '958',\n", + " 'caption': \"This image is a representation of a computer screen with an image of a person's hand pointing towards it. The background is a colorful, abstract design with various shapes and lines. The hand appears to be reaching out towards the screen, as if it is trying to interact with the image.\"},\n", + " {'image_id': '959',\n", + " 'caption': 'The image is of an olive green canvas waist bag with multiple compartments and straps. It has a zipper closure on the top and two zippered pockets on the front - one on the left and one on the right. It also has two adjustable straps on the back made of the same material as the bag with metal buckles. The bottom of the bag is reinforced for extra support.'},\n", + " {'image_id': '960',\n", + " 'caption': 'This image appears to be a patchwork quilt hanging on a clothesline. The quilt is made up of different colored and patterned squares, with a blue, orange, and green color scheme. The overall design of the quilt appears to be random, with no discernible pattern or design.'},\n", + " {'image_id': '961',\n", + " 'caption': 'The image shows a soccer player standing on the field with his arms crossed in front of him. He is wearing a blue and white jersey with the number 10 on the back. Behind him, you can see a group of fans in the stands watching the game. The stadium is surrounded by green grass and trees, and there is a clear blue sky in the background.'},\n", + " {'image_id': '962',\n", + " 'caption': 'This is an image of a magazine cover titled \"Vogue\". It features a woman wearing a red dress and holding a red rose in front of a white background. The cover also includes a stylized black and white \"v\" logo. The design is modern with bold typography and a minimalist color scheme. The composition is well balanced, with the woman\\'s figure in the foreground and the title and logo in the background. The use of negative space draws attention to the woman and the title, creating an overall effect of sophistication and elegance.'},\n", + " {'image_id': '963',\n", + " 'caption': \"The image shows a baby lying on its stomach on a white blanket. The baby is wearing a white onesie and has its arms stretched out to the sides. The baby's eyes are closed and it appears to be sleeping. The image is well lit and the details of the baby's face and body are clear.\"},\n", + " {'image_id': '964',\n", + " 'caption': 'The image shows a woman wearing a leopard print long cardigan sweater over a black tank top and ripped jeans. She is standing with her hands in her pockets, looking at the camera with a neutral expression. The cardigan has a hood and long sleeves, and is open at the front to reveal a brown and tan striped shirt underneath. The jeans are ripped at the knees and have a frayed hem. The woman is wearing brown ankle boots with a square toe and low heel. The overall style of the outfit is casual and comfortable, with a mix of leopard print and neutral colors.'},\n", + " {'image_id': '965',\n", + " 'caption': \"This image shows a man standing on a balcony overlooking the city. He is wearing a black shirt with white sleeves and a hat, with his hands in his pockets. A table with a record player and records stacked next to it is in front of him. The man is looking into the distance with a thoughtful expression. The composition is well done, with the man in the foreground and the cityscape in the background. The lighting is bright, with the sun casting shadows on his body. The colors are muted, except for the man's clothing. The overall effect is one of calm and contemplation.\"},\n", + " {'image_id': '968',\n", + " 'caption': 'This is a black and white photograph of a room with a billiards table in the center. The walls are decorated with paintings and mirrors, and there are several pieces of furniture in the room, including a desk and chairs. The floor is covered with a rug, and there is a fireplace in the corner of the room.'},\n", + " {'image_id': '969',\n", + " 'caption': 'This image shows a large, ornate ballroom with high ceilings, chandeliers, and large windows. The walls are painted in a pale blue color, and the floors are made of marble. There is a large, round chandelier hanging from the center of the ceiling.'},\n", + " {'image_id': '970',\n", + " 'caption': 'The image shows a pair of white eggs on a white background. The eggs are oval in shape and have smooth, glossy surfaces indicating their freshness and unbroken state.'},\n", + " {'image_id': '972',\n", + " 'caption': 'The dress is a green and purple gown with a mermaid style bodice and a long, flowing skirt. The bodice has a sweetheart neckline and a purple bow at the waist. The skirt is made of layers of green and purple tulle, with a layer of purple tulle at the bottom. The dress has a long, flowing train in the back.'},\n", + " {'image_id': '974',\n", + " 'caption': 'There are two dogs sitting on the floor, one wearing a red sweater and the other wearing a green collar. They are both looking at the camera with their tongues out. The background is a wooden floor and there are some plants on the windowsill.'},\n", + " {'image_id': '975',\n", + " 'caption': 'The image shows a group of underwater creatures, including fish, turtles, and jellyfish, swimming in the ocean. There are also coral reefs and seaweed in the background. The image is colorful and vibrant, with a lot of detail in the sea creatures and the ocean floor. The overall mood of the image is peaceful and serene, as if the viewer is looking at a beautiful underwater scene.'},\n", + " {'image_id': '976',\n", + " 'caption': 'This image appears to be a logo for a business or brand. It features the letter \"i\" in a cursive font with a crown on top, which is a simple and elegant design that adds a regal touch to the logo. The color scheme is mostly white with a yellow background, and the overall design is simple and clean, making it easy to read and recognize.'},\n", + " {'image_id': '977',\n", + " 'caption': 'The image is a level 3 question that asks for a description of the image.'},\n", + " {'image_id': '978',\n", + " 'caption': 'This is a dish of grilled lamb chops on a white plate, garnished with parsley and black pepper. The lamb chops are cooked to perfection, with a crispy exterior and juicy interior. The parsley and black pepper add a fresh and aromatic flavor to the dish. The plate is surrounded by a white tablecloth, and there is a fork and knife on the side. The overall presentation of the dish is visually appealing and appetizing.'},\n", + " {'image_id': '979',\n", + " 'caption': 'The image shows a basketball player wearing a white jersey with the number 23 on the back and black shorts. He is holding a basketball in his right hand and appears to be walking on a court with a crowd in the background.'},\n", + " {'image_id': '980',\n", + " 'caption': 'etsuit and holding a surfboard under their arm. The ocean is a deep blue color with some waves, while the sky is a light blue with distant clouds. The image gives off a relaxed and peaceful vibe.'},\n", + " {'image_id': '981',\n", + " 'caption': 'The image shows a group of people engaging in various physical activities, such as running, jumping, and lifting weights. The people are diverse in age, gender, and ethnicity. They are all wearing athletic clothing, such as shorts, t-shirts, and sneakers. The setting is a gym or fitness center, with equipment such as treadmills, weights, and exercise balls visible in the background. The overall theme of the image is fitness and exercise.'},\n", + " {'image_id': '982',\n", + " 'caption': 'The image shows a large luxury yacht docked in a marina. The yacht is white with black accents and has several decks and balconies. There are several people standing on the dock, watching the yacht. The sky is clear and blue, with a few clouds in the distance. The water in the harbor is calm and still.'},\n", + " {'image_id': '983',\n", + " 'caption': \"This is a double decker bus. It is green with a yellow stripe down the side. The front of the bus has the words `person' written on it in white letters. The windows are tinted and the doors are open, revealing the inside of the bus. There is a sign on the front of the bus that says `person' in white letters. The bus is parked on the side of the road and there is a building in the background.\"},\n", + " {'image_id': '984',\n", + " 'caption': 'This is an image of a slow cooker with a reddish sauce in it. A metal spoon is visible, stirring the liquid. The slow cooker is made of black plastic and has a lid on it.'},\n", + " {'image_id': '986',\n", + " 'caption': 'The image shows a cyclist wearing an orange jersey and black shorts riding a bicycle on a dirt road. The cyclist is wearing a black helmet and gloves and has a black backpack on his back. There are trees on either side of the road and a blue sky in the background.\\n\\nThe cyclist is wearing an orange jersey with black shorts and a black helmet and gloves. He has a black backpack on his back and is riding a bicycle on a dirt road. There are trees on either side of the road and a blue sky in the background.'},\n", + " {'image_id': '987',\n", + " 'caption': 'The image shows a cartoon character holding a guitar on the stage of a theater. The character is wearing a black and white striped shirt, black pants, and black boots. The stage is empty and there are no other characters or objects in the image. The walls of the theater are made of wooden panels and there is a curtain hanging from the ceiling. The lighting in the theater is dim, with a few spotlights shining down on the stage.'},\n", + " {'image_id': '988',\n", + " 'caption': 'This image shows a bedroom with white walls, hardwood floors, and a large window. There is a white bed with a wooden headboard and white bedding. The walls have framed pictures hanging on them. The room is well lit, with a lamp on the bedside table. The bedroom is spacious and airy, with plenty of natural light coming in through the window. The hardwood floors add a warm and cozy feel to the room. The white walls and bedding create a clean and crisp look, while the wooden headboard adds a rustic touch. The framed pictures on the wall add a personal touch and make the room feel more inviting. This bedroom is a great example of a modern and stylish space that is both functional and aesthetically pleasing.'},\n", + " {'image_id': '989',\n", + " 'caption': 'The image shows a large stone slab with hieroglyphics carved into it. The hieroglyphics depict several figures, including a man and a woman. The stone is displayed in a glass case, surrounded by other artifacts in a museum.'},\n", + " {'image_id': '990',\n", + " 'caption': 'The image shows a group of birds perched on a wire fence, with palm trees in the background. The fence appears to be made of metal and has a diamond pattern. The birds are perched on the top of the fence, with their wings spread out, and some have their beaks open. The sky is clear and blue with a few fluffy clouds visible, and there is a small building in the distance with a red roof and white walls.'},\n", + " {'image_id': '991',\n", + " 'caption': 'The image shows a cocktail glass filled with a clear liquid and garnished with a slice of lime on the side, sitting on top of a wooden surface. The drink appears to be a mojito cocktail, with a small pile of ice cubes in the glass. Several other glasses and bottles are visible in the background.'},\n", + " {'image_id': '995',\n", + " 'caption': 'This is a bedroom with a bed, dresser, and television. The walls are painted purple, and there is a window with white curtains. The bed has a white comforter and pillows, and there is a lamp on the nightstand. The dresser has a mirror on top and several drawers. The television is mounted on the wall above the bed, and there is a small table next to it with a vase of flowers.'},\n", + " {'image_id': '997',\n", + " 'caption': 'characters in an engaging way. The use of bold typography and contrasting colors helps to make the title of the movie or show stand out, while the two characters provide a sense of intrigue and excitement.'},\n", + " {'image_id': '998',\n", + " 'caption': 'The image shows a pair of eels swimming in the ocean. The eels are brown in color and have long, slender bodies with small heads and large eyes. They appear to be swimming in a school, with one eel leading the way and the other following closely behind. The background of the image is a mix of rocks, coral, and sand, with various fish and other sea creatures visible in the distance. The overall mood of the image is peaceful and serene.'},\n", + " {'image_id': '999',\n", + " 'caption': \"This is a black and white photograph of a police officer standing next to a police car. The officer is wearing a uniform with a badge on his chest and a hat on his head. The car has the word'police'written on the side in white letters. The officer is standing with his arms crossed in front of him, looking at the camera. There is a chain link fence in the background.\"},\n", + " {'image_id': '1000',\n", + " 'caption': \"The image shows a family of four standing in front of a blue carpet with snowflakes on it. The father is wearing a white shirt and black pants, the mother is wearing a red dress, and the two children are wearing matching outfits. They all have smiles on their faces and are posing for the camera. In the background, there is a large movie poster with the title'frozen'written in white letters on a blue background.\"},\n", + " {'image_id': '1002',\n", + " 'caption': \"The image is a logo for a company called TLC West Boulevard, LLC. The logo features a colorful square with the company's initials, TLC, in the center. The letters are stacked on top of each other in a stylized font. The logo is designed to be modern and eye catching, with bright colors that stand out against a white background.\"},\n", + " {'image_id': '1004',\n", + " 'caption': 'The image shows a woman standing in front of a large glass door wearing a white shirt and black pants with her hands in her pockets. Behind her, there are several other glass doors, all of which are open. The walls of the building behind her are white, and there are some plants in pots on the ground in front of the doors. In the foreground, there are several people walking on the sidewalk outside the building, dressed in different clothing, and some of them are carrying bags or other items. The sidewalk is made of gray concrete, and there are some trees on either side of it. In the background, you can see other buildings and some cars driving on the street.'},\n", + " {'image_id': '1005',\n", + " 'caption': \"This image depicts a soccer ball with the flag of Singapore on it.\\n\\nThe flag of Singapore consists of a red field with a white crescent and five white stars in the center. The crescent and stars are arranged in a semicircle on the left side of the flag. The flag is a symbol of the country's independence and sovereignty.\\n\\nThe soccer ball has a red and white design, with the flag's colors and emblem in the center. The ball is a popular sport in Singapore and is often used in international competitions.\\n\\nOverall, this image depicts a soccer ball with the flag of Singapore, which represents the country's independence and sovereignty.\"},\n", + " {'image_id': '1006',\n", + " 'caption': 'This image depicts a large room with rows of black chairs lined up in front of a large window overlooking a city skyline. There is a man standing at the back of the room, looking out the window. The room is spacious and well lit, with a high ceiling and exposed beams. The walls are painted white and there are no decorations or furniture in the room. The floor is made of hardwood and there are no rugs or carpets. There are no other people in the room.'},\n", + " {'image_id': '1007',\n", + " 'caption': 'There are several buses parked on the side of the road at night. The buses are yellow and have the words \"ImageContent\" written on them. There are people walking on the sidewalk next to the buses. The buildings in the background are tall and have many windows. There are streetlights on the poles along the road. The sky is dark and there are no stars visible.'},\n", + " {'image_id': '1008',\n", + " 'caption': 'This image shows a clear glass jar filled with small white pills. The jar is sitting on top of a white surface, which appears to be a table or shelf. The pills are arranged in a neat, organized pattern inside the jar.'},\n", + " {'image_id': '1009',\n", + " 'caption': 'This is an image of a healthy fern plant with water droplets on its leaves, formed due to condensation in a humid environment.'},\n", + " {'image_id': '1011',\n", + " 'caption': 'whimsical image of a cartoon chef on a grey hoodie. The character is depicted as happy and skilled in the kitchen, adding a playful touch to the clothing item.'},\n", + " {'image_id': '1012',\n", + " 'caption': \"This image shows a close-up view of a woman's face wearing a green and blue mask with a feathered headdress. The mask is decorated with beads and sequins, and the woman's hair is styled in a long braid. The background is a blurred image of a crowd of people in colorful costumes.\"},\n", + " {'image_id': '1013',\n", + " 'caption': \"The image shows a group of children dressed in animal costumes performing on a stage. There is a lion, a zebra, a monkey, and a tiger on the stage. The children are wearing colorful costumes and masks, and they are all smiling. There is a rainbow in the background, and the stage is set up with a curtain and a microphone. The children are performing in front of an audience, which is not shown in the image. It could be used to illustrate a story about children performing in a play or a musical, or to promote a children's theater or a performance group.\"},\n", + " {'image_id': '1014',\n", + " 'caption': 'The image shows a bottle of wine with a black label that says \"ImageContent\" on it. Several silverware items, including forks, knives, and spoons, are arranged around the bottle, and there are some olive branches in the background.'},\n", + " {'image_id': '1016',\n", + " 'caption': 'This image is a silhouette of a group of people standing in a circle, with one person in the center raising their arms. The people in the image appear to be a mix of adults and children, and they are all wearing different clothing. The background of the image is white.\\n\\nThe people in the image are standing in a circle, with one person in the center raising their arms. The people in the image appear to be a mix of adults and children, and they are all wearing different clothing. The background of the image is white.'},\n", + " {'image_id': '1019',\n", + " 'caption': 'The image shows a residential area with houses on either side of the road. A fence separates the road from the well-maintained grassy area in front of the houses. The houses have white walls and red roofs, some even have balconies or patios. Trees on either side of the road provide shade to the houses, and a few cars are parked on the side of the road. The sky is clear and cloudless.'},\n", + " {'image_id': '1022',\n", + " 'caption': 'This is an image of a table with a game on top of it. The table is made of metal and has a grid pattern on top. The game is made up of different colored blocks of various shapes, including squares, rectangles, and triangles. Some blocks are stacked on top of each other, while others are placed next to each other. There is a small opening in the middle of the table where the blocks can be placed. A tree can be seen in the background, indicating that the table is outdoors.'},\n", + " {'image_id': '1023',\n", + " 'caption': 'The image shows a landscape with a large body of water in the foreground and a small island in the background. The water is a deep blue color with small waves on the surface. The island is covered in green grass and has a few trees on it, and there is a small path leading to the island from the shore. The sky is bright blue with fluffy clouds, creating a peaceful and serene atmosphere.'},\n", + " {'image_id': '1024',\n", + " 'caption': 'This is a white t-shirt with the words \"I am the bride\" printed in pink on the front in cursive font. A small pink heart is underneath the text. The model wears the untucked shirt with white pants and black shoes. The image is clear and well-lit, showcasing the details of the shirt and the model\\'s face.'},\n", + " {'image_id': '1025',\n", + " 'caption': 'This image depicts a man sitting at a desk in a factory, surrounded by machinery and tools. The man is wearing a suit and tie, and appears to be working on a document or piece of paper. There are other workers in the background, some of whom are also working on machinery. The overall tone of the image is one of industry and productivity.'},\n", + " {'image_id': '1026',\n", + " 'caption': \"This image appears to be a logo or emblem for a woodworking or carpentry company. The design features a wood grain pattern in the shape of a circle, with the company's name written in a stylized font inside the circle. The image is in black and white, with the wood grain pattern in shades of brown. The overall design is simple and clean, with a focus on the company's name and the woodworking theme.\"},\n", + " {'image_id': '1027',\n", + " 'caption': 'This image shows a pink and white bathroom with a sink, mirror, and walk-in shower. The walls are painted pink and there are pink tiles on the floor.'},\n", + " {'image_id': '1029',\n", + " 'caption': 'this is a set of three brochures, each with a different image on the cover. The first brochure is about the forest, describing its different types of trees and animals, and emphasizing the importance of preserving the forest and its ecosystem. The second brochure is about the river, describing its various aquatic animals and emphasizing the importance of preserving the river and its ecosystem. The third brochure is about the road, describing different types of vehicles and pedestrians, and emphasizing the importance of preserving the road and its infrastructure.'},\n", + " {'image_id': '1031',\n", + " 'caption': 'This image shows a man sitting at a table with his hands resting on his chin. He is wearing a blue shirt and has a serious expression on his face. Behind him, there is a whiteboard with several diagrams and equations written on it. The room appears to be an office or laboratory setting.'},\n", + " {'image_id': '1032',\n", + " 'caption': 'This image shows a group of people wearing helmets and standing in front of a fence at a carnival or event. The woman on the left is wearing a purple shirt and green pants, while the man on the right is wearing a yellow shirt and black pants. They both have yellow helmets on their heads. The image is well lit with bright sunlight shining on the people and the fence behind them, and the colors are vibrant.'},\n", + " {'image_id': '1033',\n", + " 'caption': 'This is an image of a female athlete running in a marathon. She is wearing a black and red swimsuit and has a number on her chest.'},\n", + " {'image_id': '1034',\n", + " 'caption': 'A rational number is a real number that can be written as a fraction.'},\n", + " {'image_id': '1035',\n", + " 'caption': \"The image shows a blue Toyota Corolla parked in front of a graffiti-covered wall. The car's design features a bold front grille and headlights, a sloping roofline that gives it a sporty appearance, and modern taillights and bumper. The car seems to be in good condition with no visible dents or scratches. The bright blue color contrasts well with the colorful graffiti behind it, making for an overall stylish image.\"},\n", + " {'image_id': '1038',\n", + " 'caption': 'The image shows a group of people gathered around a well. They are all dressed in traditional clothing, with the men wearing turbans and the women wearing saris. The men are holding buckets and the women are holding pots, which they are using to draw water from the well. The scene is set in a rural area, with trees and a few buildings visible in the background. The overall mood of the image is peaceful and serene, with the people going about their daily tasks in a calm and orderly manner.'},\n", + " {'image_id': '1039',\n", + " 'caption': 'This image shows a small, green camper trailer parked in a grassy area. The trailer has four wheels and appears to be a small, compact trailer that can be towed behind a vehicle for camping or other outdoor activities. There are no other details visible in this image.'},\n", + " {'image_id': '1040',\n", + " 'caption': 'The image shows a tall building with a curved facade made up of white, wavy lines creating a wave-like pattern. The building is made of white painted concrete or similar material with a small entrance opening at the top. There are no visible windows or doors on the facade. The foreground shows some vegetation including small trees and bushes. The overall impression of the image is a modern, sleek building with a unique, wave-like design.'},\n", + " {'image_id': '1041',\n", + " 'caption': 'The image shows two advertisements for a dental practice. The first advertisement has a blue background with white text that reads, \"IT support for your dental practice.\" The second advertisement has a white background with blue text that reads, \"Two Dogs IT Support for your dental practice.\" Both advertisements feature the same image of two dogs sitting next to each other. The first advertisement emphasizes the importance of IT support for a dental practice, while the second advertisement highlights the benefits of using Two Dogs IT Support for dental professionals.'},\n", + " {'image_id': '1042',\n", + " 'caption': 'This is an image of a house with white walls and a green garage door. There is a small driveway in front of the house that leads to the garage. The house appears to be in a rural area, surrounded by trees and greenery. The image is taken from the side of the house, looking down the driveway towards the garage.'},\n", + " {'image_id': '1045',\n", + " 'caption': 'The image is a round beach towel with the words \"let your dreams come true\" written in blue on a pink background.'},\n", + " {'image_id': '1046',\n", + " 'caption': 'This image shows a group of people in a meeting. They are dressed in business attire and sitting around a conference table in a well-lit office or conference room. A large television screen on the wall behind them displays a news program.'},\n", + " {'image_id': '1047',\n", + " 'caption': 'This is an image of a large bird, possibly a vulture, with its wings spread out and its head tilted to the side. The bird appears to be perched on something, possibly a tree branch or a rock. The image is in black and white.'},\n", + " {'image_id': '1049',\n", + " 'caption': 'The image shows a man and a woman standing in front of a large, ornate building. The man is wearing a black suit and the woman is wearing a black dress. They are both smiling and posing for the camera. The building behind them is a large, old mansion with many windows and a balcony. There are trees in the background and the sky is cloudy.'},\n", + " {'image_id': '1050',\n", + " 'caption': 'The image shows three people standing in front of a tree. The first person is wearing a black leather jacket and a red dress. The second person is wearing a black leather jacket and a white shirt. The third person is wearing a black leather jacket and black pants. All three people have their hands on their hips and are looking at the camera. Behind them, there is a large tree with branches and leaves. The background is a dark sky with stars.'},\n", + " {'image_id': '1051',\n", + " 'caption': 'The image shows a piece of pumpkin cake with cream cheese frosting on a white plate. The cake has a swirl of cream cheese frosting on top and is topped with a sprinkle of cinnamon sugar. There is a fork in the picture.'},\n", + " {'image_id': '1052',\n", + " 'caption': \"This is an image of a woman standing in front of a white background, holding up a sign that says, ` we are here to help '. The woman is wearing a gray shirt and has short, curly hair. She is smiling and looking directly at the camera.\"},\n", + " {'image_id': '1053',\n", + " 'caption': 'The image shows a set of six gargoyle figurines made of black metal. Each figurine has a unique pose and expression, with intricate details such as wings, horns, and fangs. The gargoyles are perched on small pedestals with their wings spread out and their mouths open in a roar or snarl, giving an ominous and menacing effect as if they are about to attack.'},\n", + " {'image_id': '1054',\n", + " 'caption': 'This is an image of a building with graffiti on the walls. It appears to be an abandoned building with broken windows and Arabic graffiti. Two people are sitting on the stairs in front of the building.'},\n", + " {'image_id': '1055',\n", + " 'caption': 'The image shows a group of cacti with different colored flowers on them. The cacti are all different sizes and shapes, and they are arranged in a circle. The flowers on the cacti are bright and colorful, and they are different types of flowers. There are also green leaves on the cacti. The background of the image is a light green color, and it looks like the cacti are growing in a pot.'},\n", + " {'image_id': '1056',\n", + " 'caption': 'The image is a book cover with the title \"The Guts to Create an Authentic Heart\" in red letters on a white background. The cover features a heart made out of gears.'},\n", + " {'image_id': '1058',\n", + " 'caption': 'This image depicts a woman holding a white sign with the word stop written on it. The woman is wearing a white shirt and has long blonde hair. She is holding the sign with both hands and looking directly at the camera. In the background, there is a blue wall.'},\n", + " {'image_id': '1060',\n", + " 'caption': 'This image shows a bathroom with a white sink, toilet, and bathtub. There is a large mirror on the wall above the sink. The floor is made of tiles and the walls are painted white. There is a window on one side of the room and a door on the other side that leads to another room.'},\n", + " {'image_id': '1061',\n", + " 'caption': 'The image shows a Christmas tree with presents underneath it. The tree is decorated with red and green ornaments and has a star on top. There are also presents wrapped in red and green paper with bows on them next to the tree.'},\n", + " {'image_id': '1063',\n", + " 'caption': \"This image shows a black dragon flying through a dark, stormy sky with its wings spread out. The dragon's eyes are glowing red and its mouth is open, revealing sharp teeth. The landscape below is rocky and rugged, with mountains and valleys visible in the distance. The overall mood of the image is ominous and foreboding.\"},\n", + " {'image_id': '1064',\n", + " 'caption': 'The image shows a black wallet with a zipper closure and multiple compartments inside. The wallet is made of leather and has gold accents on the zipper and around the edges. There is also a small pocket on the outside of the wallet with a zipper closure.\\n\\nInside the wallet, there are several compartments for storing cash, credit cards, and other small items. There is also a larger compartment with a zipper closure that can be used to store larger items such as a phone or passport. The wallet has a sleek, modern design and would be suitable for both casual and formal wear.'},\n", + " {'image_id': '1065',\n", + " 'caption': 'This image shows a group of people standing in front of a large tree in a park. They are all dressed in casual clothing and are smiling at the camera. The tree has a plaque on it that reads, \"In memory of those who gave their lives for our country.\"\\n\\nThe people in the image are a mix of ages and ethnicities. They are all standing in front of the tree, which has a thick trunk and branches that stretch up towards the sky. The background of the image is a mix of green grass and trees, with some buildings visible in the distance. It appears to be a sunny day.\\n\\nOverall, this image depicts a group of people paying their respects to those who have given their lives.'},\n", + " {'image_id': '1066',\n", + " 'caption': 'This image is a white t-shirt with black text that reads, \"only a ginger can call another ginger ginger\". The text is written in a bold, sans-serif font.'},\n", + " {'image_id': '1067',\n", + " 'caption': 'This image shows a room with a high ceiling and large windows that let in natural light. The walls are painted white and the floor is made of wooden planks. Several pieces of furniture, including a desk, chairs, and a bookshelf, are present in the room, indicating that it is a study or office area.'},\n", + " {'image_id': '1068',\n", + " 'caption': 'This is an image of an alpaca, a domesticated animal native to South America. Alpacas are known for their soft, woolly coats which are used to make clothing and textiles. They are also kept as pets due to their gentle nature. The alpaca in the image is light brown with a fluffy coat, large round eyes, a small pointed nose, long floppy ears, and a short curved tail. It is standing in a fenced enclosure, looking at the camera. Overall, this is a cute and appealing image of an alpaca.'},\n", + " {'image_id': '1070',\n", + " 'caption': 'The woman in the image is wearing a long, dark green velvet gown with a plunging neckline and long sleeves. The dress has a high slit on the side and is cinched at the waist with a belt. Her hair is styled in loose, curly waves and she is wearing high heels. She is posing with her hands on her hips and looking directly at the camera. The background is a dark grey.'},\n", + " {'image_id': '1071',\n", + " 'caption': 'This image depicts a person holding a fishing rod and reeling in a fish. The person is wearing a red shirt, blue jeans, and white sneakers. The background is a blank white paper.'},\n", + " {'image_id': '1072',\n", + " 'caption': \"This image is a quote that reads, 'the revolution will not be supervised'. It is written in white text on a black background, with the words 'revolution'and 'supervised'in bold letters. The font used is a sans serif font. The message conveyed by this image is one of rebellion and resistance against authority. It suggests that the people will not be controlled or monitored by those in power, and that they will take matters into their own hands to bring about change.\"},\n", + " {'image_id': '1074',\n", + " 'caption': 'This image is a screenshot of a PowerPoint presentation document in Microsoft Word. The document has a blue background with white text and an American flag in the center, waving in the wind with the stars and stripes visible. A text box with the title \"ImageContent\" is also present on the right side of the page.'},\n", + " {'image_id': '1075',\n", + " 'caption': 'The image shows a person sitting at a table with a white bowl filled with rice and vegetables in front of them. The person is wearing a white sweater and is eating the food in the bowl with a pair of metal chopsticks. The bowl has a pink and white pattern on it and appears to be made of ceramic. The chopsticks have a shiny finish and the table is made of wood with a white tablecloth. There are flowers in a vase on the table, but they are not visible in the image. The atmosphere of the image is cozy and relaxed, with the person enjoying their meal and the food looking appetizing.'},\n", + " {'image_id': '1076',\n", + " 'caption': 'This image is a stylized representation of a human skull depicted in a low polygonal style with sharp angles and clean lines. The skull is shown in profile with the left side visible and the right side obscured by the hairline. It appears to be made up of several geometric shapes, including triangles and rectangles. The background is a slightly lighter shade of the same color as the skull, creating an overall effect of simplicity and minimalism.'},\n", + " {'image_id': '1078',\n", + " 'caption': 'This image shows a group of people standing on the rooftop of a building with a city skyline in the background. The people are dressed in formal attire, and they appear to be chatting and enjoying the view. The skyline in the background is made up of tall buildings with lit up windows, and there are also some clouds in the sky. The overall mood of the image is one of relaxation and enjoyment.'},\n", + " {'image_id': '1079',\n", + " 'caption': 'This image shows a large conference room with a long wooden table and several chairs. The walls are made of stone and the floor is made of tiles. The room has large windows that let in a lot of natural light. There is a painting on the wall behind the table, and a sculpture on the floor in front of the table.'},\n", + " {'image_id': '1080',\n", + " 'caption': \"This image shows a black dog sitting in the snow, looking up at the camera with a curious expression on its face. The dog's fur is fluffy and white, and its eyes are bright and alert. The background is a blanket of white snow. The dog appears to be in good condition, with no visible injuries or signs of distress. It is wearing a collar with a tag, but it is not clear what the tag says. The dog's expression is friendly and curious.\"},\n", + " {'image_id': '1081',\n", + " 'caption': 'The image shows a group of clothing items hanging on a rack, including a striped shirt, a brown skirt, and a pair of black shoes. The shirt has a striped pattern and is tucked into the skirt. The skirt has a brown leather belt with a gold buckle. The shoes have a pointed toe and are made of black leather.'},\n", + " {'image_id': '1082',\n", + " 'caption': \"This image appears to be a movie poster for a French film, possibly from the 1950s or 1960s. The title of the film is written in large, bold letters at the top of the poster, with an image of a woman in a red dress and a man in a suit dancing in front of her.\\n\\nBelow the title, there is a tagline in French that reads `'un amour en paris'`, which translates to `'a love in Paris'`. The poster appears to be a romantic comedy or drama, set in the city of Paris.\"},\n", + " {'image_id': '1083',\n", + " 'caption': 'The image shows a view of the twelve apostles rock formations on the great ocean road in Australia. The cliffs are tall and rocky, jutting out into the deep blue ocean under a clear and sunny sky without any clouds. The cliffs are covered in green vegetation and some small plants grow on the ground. There are no people in the image. The apostles are a popular tourist attraction, visited by millions of people each year, and are a testament to the power of erosion and the forces of nature. They remind us of the beauty and majesty of the natural world and are a must-see for anyone visiting Australia.'},\n", + " {'image_id': '1084',\n", + " 'caption': 'The image depicts a stainless steel bracelet with a silver cross engraved in the center. The bracelet features a chain link design and a clasp closure, making it adjustable to fit different sizes. The image shows the bracelet on a white background.'},\n", + " {'image_id': '1085',\n", + " 'caption': \"The image shows two children, a boy and a girl, standing next to each other with their arms around each other. The boy is wearing a red shirt and blue jeans, while the girl is wearing a pink shirt and white shorts. They are both looking at the camera with smiles on their faces. The quote on the image reads, `'The best gift you could give your child is your time.'`\"},\n", + " {'image_id': '1086',\n", + " 'caption': 'The image depicts a yellow and black taxi with the words \"Tokyo Taxi\" written on the side. It is parked on the side of the road with a person standing next to it. The taxi sign on the roof indicates its readiness for use.'},\n", + " {'image_id': '1087',\n", + " 'caption': 'This image is a photograph of a person standing on a rocky beach with the ocean in the background. The person is standing with their back to the camera, looking out at the waves. The person is wearing a black hoodie and black pants, and their hair is pulled back into a ponytail. The beach is covered in large rocks and pebbles, and there are some small waves washing up onto the shore. The sky is a deep shade of blue, and there are some clouds visible in the distance. The overall mood of the image is peaceful and serene.'},\n", + " {'image_id': '1089',\n", + " 'caption': 'This image shows a woman in a garden, crouching down and tending to a flower bed. The woman is wearing a black shirt and brown pants, and is holding a watering can in her right hand. The garden is filled with a variety of colorful flowers, including red, orange, yellow, and pink. There are also some green leaves and stems visible in the background. The woman appears to be focused on her work, and is carefully watering each plant in the bed. The overall effect of the image is one of peace and tranquility, as the woman is surrounded by vibrant colors and the sound of water dripping from the can.'},\n", + " {'image_id': '1090',\n", + " 'caption': 'The image depicts a couple standing on top of a hill, looking out at a pink sky with a full moon in the background. The couple is holding hands and looking at each other with love in their eyes. The sky is filled with clouds and stars, and there is a silhouette of a tree in the foreground. The overall mood of the image is romantic and dreamy.'},\n", + " {'image_id': '1091',\n", + " 'caption': 'The image shows a cup and saucer with a floral design on it. The cup has a curved handle and the saucer has a scalloped edge. The design on the cup and saucer is red and white, with pink roses and green leaves. There is a small spoon resting on the saucer. The overall style of the cup and saucer appears to be vintage or antique.'},\n", + " {'image_id': '1092',\n", + " 'caption': \"The image is a drawing of a person's head with a map of a city on it. The person's head is shown in profile, with their eyes, nose, and mouth visible. The map is shown on the right side of the image, with various streets and landmarks labeled. The image is in black and white, with the map shown in shades of gray.\\n\\nThe image appears to be a representation of a person's mental map of a city, with the various streets and landmarks representing different memories or experiences that the person has had in that city. The use of black and white gives the image a stark, minimalist feel, emphasizing the simplicity of the map and the person's mental representation of the city.\\n\\nOverall, the image is a creative and interesting representation of the concept of mental mapping, and could be used in a variety of contexts, such as in psychology or urban planning.\"},\n", + " {'image_id': '1093',\n", + " 'caption': 'The image shows a small room with a wooden shelf on the wall, several rolls of wrapping paper stacked on it, a door on the right side, and a window on the left side. The walls are painted white and there is a wooden floor.'},\n", + " {'image_id': '1095',\n", + " 'caption': 'The image shows a woman in a The image shows a woman standing in a field of purple flowers. She is wearing a straw hat and a plaid shirt, and is looking down at the flowers in front of her. The flowers are in full bloom and appear to be a type of orchid. The woman is standing in the middle of the field, surrounded by the flowers on all sides. The background of the image is a clear blue sky with a few fluffy clouds.'},\n", + " {'image_id': '1097',\n", + " 'caption': 'This image shows a wooden bridge in the middle of a swampy area surrounded by mangrove trees. The bridge appears to be old and weathered, with wooden planks and ropes hanging from it. The water below is murky and full of debris, including sticks, leaves, and other vegetation. The trees on either side of the bridge are tall and thin, with their branches reaching out over the water. The sky is cloudy and overcast, casting a gloomy mood over the scene.'},\n", + " {'image_id': '1098',\n", + " 'caption': 'The woman is wearing a colorful shirt, blue leggings, and white sneakers while carrying a black purse and looking at her phone. There are several parked cars in the background.'},\n", + " {'image_id': '1099',\n", + " 'caption': 'This is a hotel room with a red accent wall and a large bed with a white comforter. There is also a desk and chair in the corner.'},\n", + " {'image_id': '1101',\n", + " 'caption': 'The image shows a group of minerals found in nature. These minerals are made up of substances that were never living organisms. They are made up of elements such as calcium, sodium, and magnesium. Some of these minerals are found in rocks, while others can be found in soil or water.\\n\\nThe minerals in the image are likely to have been formed through geological processes, such as the solidification of magma or the precipitation of dissolved minerals from water. These minerals can be used in a variety of ways, such as in the production of glass, ceramics, and other materials.\\n\\nOverall, the image shows a group of minerals that are found in nature and are made up of elements that were never living organisms. These minerals can be used in a variety of ways and are likely to have been formed through geological processes.'},\n", + " {'image_id': '1102',\n", + " 'caption': 'This image shows a balcony with a view of a river. The balcony is made of wood and has a glass railing. There are two blue cushions on the bench and a small table with a vase of flowers on it. The trees on the other side of the river are reflected in the water. The sky is clear and there are some clouds in the distance.'},\n", + " {'image_id': '1103',\n", + " 'caption': 'This is a black lace dress with long sleeves and a deep V neckline. The dress has intricate lace detailing on the bodice and sleeves, with a sheer lace overlay on the skirt. It has a fitted bodice and a flared skirt, with a long train at the back. The dress also features a zipper closure at the back.'},\n", + " {'image_id': '1105',\n", + " 'caption': 'The image shows a pair of white shoes with gold glitter on the sides. The shoes have an open toe and a low heel. The soles are made of rubber and the insoles are made of leather. The shoes are designed for casual wear and are suitable for both men and women.'},\n", + " {'image_id': '1106',\n", + " 'caption': 'The woman in the image is standing in a field at sunset. She is wearing a long, flowing dress and has her hair pulled back in a ponytail. Her arms are crossed in front of her and she is looking off into the distance. The sky behind her is orange and pink, with clouds that look like they are on fire. There are no other objects or people in the image.'},\n", + " {'image_id': '1107',\n", + " 'caption': 'The image shows a man in a business suit walking across a wooden bridge suspended over a deep chasm. The man is walking towards the edge of the cliff and looking down at the ground below. The bridge has a handrail on one side and the sky is cloudy with no other objects in the scene. The image is in isometric perspective, with the man and bridge in the foreground and the cliff and sky in the background.'},\n", + " {'image_id': '1108',\n", + " 'caption': 'The image shows a circular diagram with the words one health, food, environment, and lifestyle written around it. The words are arranged in a circle with one health and food at the top, environment in the middle, and lifestyle at the bottom. The words are written in different colors, with one health in red, food in green, environment in blue, and lifestyle in yellow. In the center of the circle, there is an illustration of a person standing on top of a mountain, with their arms stretched out to the sides, surrounded by trees and a clear blue sky. The illustration is done in a cartoon style, with the person having a happy expression on their face.'},\n", + " {'image_id': '1109',\n", + " 'caption': 'The woman in the image is wearing a blue dress with a floral pattern on it. The dress has a v-neckline and short sleeves. She has her hair styled in loose waves and is wearing a pair of silver earrings. Her makeup consists of a light foundation, pink blush, and brown eyeshadow. She has a small smile on her face and is posing for the camera. The background of the image appears to be a blue carpet with a white wall behind it. There are no other objects or people visible in the image.'},\n", + " {'image_id': '1110',\n", + " 'caption': 'The image shows a group of babies sitting on clouds, holding balloons. The babies are wearing diapers and are smiling. The background is a blue sky with fluffy clouds.'},\n", + " {'image_id': '1111',\n", + " 'caption': 'This image shows a helicopter flying over the ocean with a large ship in the background. The helicopter appears to be a military.'},\n", + " {'image_id': '1113',\n", + " 'caption': 'The image shows a woman wearing a grey tank The woman is wearing a grey tank top and black skinny jeans. The tank top has a scoop neckline and is made of a thin, stretchy material. The jeans are fitted and have a high waist. The woman is standing with her hands in her pockets and is looking down at the ground.\\n\\nThe tank top is a simple, basic style that can be worn with a variety of outfits. It has a scoop neckline, which adds a touch of femininity to the design. The material is thin and stretchy, which makes it comfortable to wear and easy to move in.\\n\\nThe skinny jeans are a classic style that is popular for both casual and formal wear. They have a high waist, which helps to create a streamlined silhouette and elongate the legs. The jeans are fitted, which means they hug the body and create a slim, sleek look.'},\n", + " {'image_id': '1114',\n", + " 'caption': 'The painting depicts a group of people on a boat in the middle of the ocean. The sun is setting in the background, casting a warm orange glow over the scene. The people on the boat are dressed in period clothing, with some wearing hats and others holding onto ropes. In the foreground, there is a small rowboat with two people in it, heading towards the larger boat. The water is choppy, with waves crashing over the sides of the boat. The sky is filled with clouds, with the sun peeking out from behind them. The overall mood of the painting is one of adventure and exploration.'},\n", + " {'image_id': '1115',\n", + " 'caption': \"This image shows a plate with a piece of vanilla cake topped with whipped cream and sliced strawberries. In the background, there are several more slices of cake on a plate. A person's hand is shown dipping a spoon into the whipped cream on the top of the cake.\"},\n", + " {'image_id': '1116',\n", + " 'caption': \"This image shows a man sitting at a desk in an office. The man is wearing a suit and tie and is looking at a computer screen in front of him. There are several other desks and chairs in the room, as well as a map on the wall behind the man. The room appears to be dimly lit, and there is a clock on the wall above the man's head.\"},\n", + " {'image_id': '1118',\n", + " 'caption': \"This image shows a person's hand holding a gas nozzle at a gas pump. The hand is wearing a black bracelet and holding the nozzle with fingers. The gas pump is white with a hose connected to the car's gas tank. The car is parked next to the pump with a partially visible license plate.\"},\n", + " {'image_id': '1121',\n", + " 'caption': 'This image shows a group of people gathered around a table in a dimly lit room. A man in a grey suit and white shirt is standing at the head of the table, speaking into a microphone and holding a glass of wine. Several other people are sitting at the table and looking at him. A dog is sitting on the floor in front of the table, looking up at the man. The room has white walls with paintings hanging on them, wooden floors, and chandeliers hanging from the ceiling. Plants in pots are placed on the floor.'},\n", + " {'image_id': '1123',\n", + " 'caption': 'The image shows a blue leather jewelry box with a zipper closure on the top. The box has a rectangular shape with rounded corners and is made of a smooth, glossy material. The color of the box is a deep, navy blue. There are no visible markings or logos on the box. The box appears to be empty.'},\n", + " {'image_id': '1124',\n", + " 'caption': 'The image shows a person standing on a rope in the middle of a large indoor play area. The person is wearing a harness and is holding onto the rope with both hands. The rope is suspended from the ceiling, and there are several other ropes hanging down from the ceiling as well. The play area is filled with various obstacles, such as tunnels, slides, and climbing walls. There are also several other people in the image, some of whom are climbing on the ropes and others who are watching from the sidelines. The overall atmosphere of the image is one of fun and adventure.'},\n", + " {'image_id': '1125',\n", + " 'caption': 'The image shows a woman in a white shirt and black pants, wearing a hat and smoking a cigarette. She is standing outside in a grassy area with trees in the background.'},\n", + " {'image_id': '1127',\n", + " 'caption': 'This image shows a wooden cutting board with steak, vegetables, and herbs. The steak is sliced and seasoned with salt, pepper, and other spices. The vegetables include asparagus, bell peppers, and carrots. The herbs include rosemary and thyme. There is also a bottle of olive oil on the cutting board. In the background, there is a wooden table with a white tablecloth and a vase of fresh flowers. The table appears to be set for a meal. Overall, this image suggests a rustic, home cooked meal with fresh, seasonal ingredients.'},\n", + " {'image_id': '1130',\n", + " 'caption': \"This is a black and white photograph of a couple dancing in a living room. The man is wearing a white shirt and black pants, while the woman is wearing a black dress with white polka dots. They are both holding onto each other as they dance, with the woman's arms wrapped around the man's neck. There is a wooden floor in the background, and a window with curtains in the left corner of the image. The woman is wearing a pair of white sneakers, and the man is wearing a pair of black loafers. The photograph is well lit, with a bright light source coming from the left side of the image. The overall mood of the image is happy and carefree.\"},\n", + " {'image_id': '1131',\n", + " 'caption': \"The image shows a baby's crib with a dark wooden frame and a white mattress. The crib has a modern design with clean lines and a neutral color scheme. It is placed in a spacious room with white walls, hardwood flooring, and a large window that lets in natural light. There is a white dresser in the background.\"},\n", + " {'image_id': '1133',\n", + " 'caption': 'The image shows a green hill with a castle on top of it. The castle is made of stone and appears to be abandoned. The sky is dark with clouds and there is a full moon shining brightly in the sky. There are no other buildings or structures visible in the image. The hillside is covered in grass and there are no trees or other vegetation visible.\\n\\nIn the foreground of the image, there is a small path that leads up to the castle. The path is made of dirt and rocks and appears to be overgrown with weeds. There are no people or animals visible in the image.\\n\\nThe overall mood of the image is eerie and abandoned. The dark sky and the abandoned castle give the impression that the place has been abandoned for a long time. The lack of other buildings or structures in the image adds to this feeling of isolation.\\n\\nThe image is well composed, with the castle in the center of the frame'},\n", + " {'image_id': '1134',\n", + " 'caption': \"This image shows a close up view of a grasshopper's head. The grasshopper is a green insect with long antennae and large eyes. The grasshopper appears to be looking directly at the camera with a curious expression on its face.\"},\n", + " {'image_id': '1135',\n", + " 'caption': 'This image shows a group of people gathered in front of a building. There is a man standing in the center of the group, wearing a white robe and holding a staff. The other people in the group are dressed in a variety of clothing, including robes and hats. There is a woman standing on the left side of the image, wearing a long dress and holding a baby. On the right side of the image, there is a man standing in front of a wall, wearing a robe and holding a book. In the background, there is a city with buildings and people walking around. The overall mood of the image is peaceful and serene.'},\n", + " {'image_id': '1136',\n", + " 'caption': 'The image is a video game called Inquisition. It is developed by Bioware and published by Electronic Arts. The game is a role-playing game set in the fantasy world of Thedas. Players take on the role of an inquisitor, tasked with uncovering the truth behind a conspiracy that threatens to tear the world apart. The game features a vast open world to explore with a variety of characters and creatures to interact with, as well as a deep and engaging storyline to follow. Inquisition is available on multiple platforms, including PlayStation 4, Xbox One, and PC.'},\n", + " {'image_id': '1138',\n", + " 'caption': 'This is an illustration of a young girl with red hair, wearing a blue and white striped dress with a white apron and red and white striped stockings. She is standing with her arms crossed in front of her, looking down at the ground. The background is a light blue gradient.'},\n", + " {'image_id': '1139',\n", + " 'caption': 'The image shows a scenic view of a canyon with a river running through it. The canyon walls are made up of red rock formations and there are trees growing on the sides. In the distance, there is a large body of water with mountains in the background. The sky is clear and blue.'},\n", + " {'image_id': '1140',\n", + " 'caption': \"This image is a quote that reads 'these are difficult times' in white text on a black background. The text is written in a stylized font, with the words 'difficult' and 'times' written in capital letters. The overall design of the image is simple and minimalist, with the text standing out against the dark background. It could be interpreted as a statement about the challenges and struggles that people face in their lives, or as a reminder to stay strong and persevere through difficult times.\"},\n", + " {'image_id': '1141',\n", + " 'caption': 'The bike in the image is a road bike with a carbon fiber frame and disc brakes. It has a dropper post, allowing for a more aggressive riding position. The handlebars are also dropper and can be adjusted for a more upright riding position. The bike has a full carbon fiber fork and wheels, with deep section rims for improved aerodynamics and stiffness. The tires are tubeless, providing better grip and traction at lower pressures. The saddle is lightweight and ergonomic with a cutout to reduce pressure on the perineum.'},\n", + " {'image_id': '1142',\n", + " 'caption': 'This image depicts a hallway in a hotel or office building. The walls are painted in light beige, and the floor is covered with light brown carpet. The ceiling has wooden beams with light fixtures hanging from it. Modern artwork decorates the walls. Doors on either side of the hallway are made of wood and have frosted glass panels. A chandelier hangs from the ceiling center with several lights shining down onto the floor. Potted plants are placed on either side of the corridor.'},\n", + " {'image_id': '1143',\n", + " 'caption': 'The image shows a couple standing in front of a body of water, with mountains in the background. The woman is wearing a green jacket and black pants, while the man is wearing a black jacket and blue jeans. They are both looking at each other with smiles on their faces. The water is clear and there are some rocks visible in the foreground. The mountains in the background are covered in snow, and there are some trees visible on the left side of the image.'},\n", + " {'image_id': '1144',\n", + " 'caption': 'The woman is wearing a white t-shirt, ripped jeans, and a black cardigan sweater. She is holding a cell phone in her right hand and has her left hand in her pocket. The background is a mirror.'},\n", + " {'image_id': '1145',\n", + " 'caption': 'The image shows a green road sign with the words Chicago County written on it. The sign is a standard road sign with white lettering on a green background. The word Chicago is written in large letters at the top of the sign, while the word County is written in smaller letters below it. The sign is mounted on a green pole with a white base. There is no other information or context provided in the image.'},\n", + " {'image_id': '1146',\n", + " 'caption': 'The image shows a brown woven basket with a lid on top, sitting on a wooden floor. The basket has a handle on the side and is open, revealing the contents inside. There are no other objects in the image.'},\n", + " {'image_id': '1150',\n", + " 'caption': 'This image shows the engine compartment of a car, with the hood open to reveal the engine. The engine is a 4 cylinder, with a displacement of approximately 2.5 liters. It is equipped with a turbocharger and direct fuel injection, which helps to improve its performance and efficiency. The engine is connected to a 6 speed automatic transmission, which allows for smooth and seamless shifting.\\n\\nThe engine compartment also features several other components, including the air filter, which helps to clean the air that enters the engine, and the oil filter, which helps to remove impurities from the oil. There is also a radiator, which helps to cool the engine by circulating coolant through the engine and releasing heat into the air.\\n\\nOverall, this engine appears to be well designed and equipped to provide good performance and reliability in a variety of driving conditions.'},\n", + " {'image_id': '1151',\n", + " 'caption': 'The image shows a group of people playing music on stage. There are two men playing guitars and a woman playing a keyboard. They are all wearing casual clothing and appear to be enjoying themselves. There is a microphone in front of them and a drum set in the background. The lighting is dim and there are curtains hanging on either side of the stage.'},\n", + " {'image_id': '1152',\n", + " 'caption': \"The image shows a man holding an orange in front of his face with his mouth open, as if he's about to take a bite. The man is wearing a black t-shirt and has short, dark hair. He has a serious expression on his face and is looking directly at the camera. Behind him, there is a dark grey background.\"},\n", + " {'image_id': '1153',\n", + " 'caption': 'This is an empty room with white walls and hardwood floors. There is a large window on one side of the room and a sliding glass door on the other side. The room is empty and there is no furniture in it.'},\n", + " {'image_id': '1154',\n", + " 'caption': 'There is a dirt road in the middle of a field. On the left side of the road, there is a fence made of wooden poles with barbed wire on top. On the right side of the road, there is a person walking towards the camera. The person is wearing a blue shirt and shorts, and has a backpack on their back. Behind the person, there is a hill with some trees on it. The sky is clear and blue.'},\n", + " {'image_id': '1156',\n", + " 'caption': 'The image shows a tropical island with green hills and vegetation surrounding the coastline. Bright blue water and several boats are anchored in the bay. A small village can be seen in the distance on the other side of the island. The sky is clear with a few fluffy clouds.'},\n", + " {'image_id': '1157',\n", + " 'caption': 'The image shows a silver sports car parked on a dirt road in the middle of a forest. The car has tinted windows and the driver\\'s side door is open, revealing the interior of the car. The license plate on the front of the car reads \"TOP GEAR\" in white letters on a black background. The forest in the background is dense, with tall trees on either side of the road. The sky is overcast, with clouds covering the sun.'},\n", + " {'image_id': '1158',\n", + " 'caption': 'This image shows a large group of people sitting at long tables in a wooden structure. The tables have white tablecloths and candles. The walls are made of wood and there are strings of lights hanging from the ceiling. The people are dressed in formal attire and appear to be enjoying a meal.'},\n", + " {'image_id': '1159',\n", + " 'caption': 'The image shows a woman standing in front of a backdrop decorated with balloons in shades of blue, green, and gold. The woman is wearing a pink dress and has her hair styled in loose, wavy curls. She is looking down at her phone, which is sitting on a table in front of her. The table is covered with a white tablecloth and has a vase of pink and white flowers on it. Behind the woman, there are more balloons hanging from the ceiling, as well as streamers in the same colors as the balloons. The overall atmosphere of the image is festive and celebratory.'},\n", + " {'image_id': '1161',\n", + " 'caption': 'This image is a stylized representation of two people, one in blue and the other in orange, with their arms outstretched as if they are reaching out to each other. It could be used as a logo for a company or organization that promotes teamwork, cooperation, or partnership. The image is simple and easy to recognize, making it a good choice for a logo that needs to be easily recognizable and memorable. The colors are bright and eye-catching, which can help to make the logo stand out and be more memorable. Overall, this image is a good choice for a logo that needs to convey a sense of teamwork and cooperation.'},\n", + " {'image_id': '1165',\n", + " 'caption': 'The image shows a sweater with a color block design. The top part of the sweater is navy blue, while the bottom part is olive green. The collar and cuffs of the sweater are also navy blue. The sweater appears to be made of a knit material and has a slim fit.'},\n", + " {'image_id': '1167',\n", + " 'caption': 'This image shows a group of people gathered around a table in a hospital room. They are all dressed in professional attire, with some wearing lab coats and others in suits and ties. One person is standing at the head of the table, speaking to the group. The room is well lit and there are several pieces of medical equipment visible in the background, including a computer monitor and a printer.'},\n", + " {'image_id': '1168',\n", + " 'caption': 'The image shows a mason jar filled with carrots. The carrots are chopped into small pieces and appear to be floating in the liquid inside the jar. There is a small amount of liquid at the top of the jar. The jar is sitting on a white surface, which appears to be a table or countertop. There are no other objects visible in the image.'},\n", + " {'image_id': '1169',\n", + " 'caption': 'The woman is wearing an orange jacket and a black skirt. She is sitting on a stone wall and smiling at the camera. There is a tree in the background and some stairs leading up to a building.'},\n", + " {'image_id': '1170',\n", + " 'caption': \"The image is a yellow and grey geometric pattern on wallpaper. The pattern consists of triangles of varying sizes and shades of yellow and grey, arranged in a seemingly random way to form a cohesive design. The wallpaper has a subtle texture that adds depth and interest. The color scheme is bright and cheerful, making it suitable for a child's room or a playful living space.\"},\n", + " {'image_id': '1172',\n", + " 'caption': \"The image shows a farmer's field with various vegetables and fruits growing in it. The vegetables include tomatoes, peppers, carrots, and onions. The fruits include apples, pears, and grapes. There are also some flowers in the field, including daisies and sunflowers. The sky is clear and blue, and there is a barn in the background.\\n\\nThe image is a beautiful representation of a farm and the different crops that are grown there. The colors are vibrant and the details are clear, making it a very visually appealing image. The vegetables and fruits are arranged in a way that looks natural and realistic. The flowers add a touch of beauty to the scene, and the barn in the background gives a sense of scale and context. Overall, it is a very well composed image that captures the essence of a farm.\"},\n", + " {'image_id': '1173',\n", + " 'caption': 'The image shows a cartoon character from the TV show The Simpsons holding a hammer and standing in front of a black background. The character is wearing a yellow shirt and blue pants, and their face is not visible.'},\n", + " {'image_id': '1176',\n", + " 'caption': 'living room, perfect for relaxing or entertaining guests.'},\n", + " {'image_id': '1177',\n", + " 'caption': 'This image shows a plate of food with chicken, french fries, coleslaw, and a lemon wedge on the side. The plate is on a white tablecloth with a red and white checkered pattern. There is a red and white checkered napkin on the table next to the plate. The chicken appears to be baked or grilled and is served with a side of french fries and coleslaw. The coleslaw is made with shredded cabbage, carrots, and a creamy dressing. The lemon wedge adds a touch of acidity to the dish. Overall, this appears to be a hearty and satisfying meal.'},\n", + " {'image_id': '1179',\n", + " 'caption': 'The image shows a garden with sunflowers, daisies, and butterflies arranged in a vase. In the foreground, there is a chalkboard with the words \"14 February Valentine\\'s Day\" written on it. The background consists of a lush green meadow with tall grass and a clear blue sky.'},\n", + " {'image_id': '1180',\n", + " 'caption': \"The image shows a bride and groom standing in a field at sunset, with the groom kissing the bride's cheek\"},\n", + " {'image_id': '1184',\n", + " 'caption': \"This is a baby's room with white walls and a wooden floor. A crib is placed in the corner with a zebra print rug beneath it. Animal-themed artwork decorates the walls, featuring a giraffe and a zebra. A white chair and small table are positioned in another corner.\"},\n", + " {'image_id': '1185',\n", + " 'caption': 'image shows a man wearing a black coat with a grey and white pattern, black pants, and white sneakers with a white sole and laces. He is carrying a black backpack with white accents on the straps, which has a zipper closure. He is standing on a sidewalk next to a building with white walls and a grey roof. A black car with tinted windows is parked on the right side of the image.'},\n", + " {'image_id': '1187',\n", + " 'caption': 'This image shows a group of people throwing confetti at a bride and groom as they exit their wedding ceremony. The bride is wearing a white wedding dress and the groom is wearing a black tuxedo. They are surrounded by their friends and family who are throwing confetti at them as they walk down the street. The image is taken from a low angle and shows the bride and groom walking towards the camera with a big smile on their faces.'},\n", + " {'image_id': '1188',\n", + " 'caption': 'This image shows a black jeep with large tires parked in a parking lot. The jeep has a lifted suspension and large tires on both the front and back. The body of the jeep appears to be in good condition, with no visible scratches or dents. The windows are tinted, and the wheels are shiny and clean. The license plate on the jeep is not visible in this image.'},\n", + " {'image_id': '1189',\n", + " 'caption': 'This image shows a hotel room with a large bed, a desk, a chair, and a lamp. The bed is made with a white comforter and pillows, and there is a nightstand with a lamp on it. The desk has a laptop and a phone on it, and there is a chair in front of it. The room has a door that leads to a balcony with a view of the city.'},\n", + " {'image_id': '1190',\n", + " 'caption': 'The image shows a pile of soybeans, which are a type of legume that is commonly used in cooking and as a source of protein. The beans are arranged in a pile, with some of them spilling out of the pile and onto the ground. The beans are a light brown color and appear to be freshly harvested. The image has a white background, which helps to highlight the beans and make them appear more crisp and fresh. The overall effect of the image is one of abundance and wholesomeness, as the pile of beans suggests a bountiful harvest.'},\n", + " {'image_id': '1192',\n", + " 'caption': 'The image shows a person\\'s hand reaching into a glass jar filled with coins, with the words \"retirement savings\" written on a piece of paper next to it. The jar is sitting on top of a wooden table, surrounded by various other items such as a clock, a plant, and a book. The scene appears to be taking place outside, as there are trees and a blue sky visible in the background.'},\n", + " {'image_id': '1193',\n", + " 'caption': 'This image shows a series of photographs of a man riding a horse. The man is wearing a suit and a hat, and is holding the reins of the horse with both hands. The horse is also wearing a bridle and a saddle. The photographs show the man and horse in various poses, including jumping over obstacles, running, and standing still. The background of the photographs appears to be a grassy field with trees in the distance.'},\n", + " {'image_id': '1194',\n", + " 'caption': 'or he may be someone exploring the abandoned building. The cloudy and overcast sky adds to the overall dreary and desolate mood of the image.'},\n", + " {'image_id': '1195',\n", + " 'caption': 'The image shows a group of anime characters with different facial expressions, hairstyles, and clothing. Some characters are smiling, while others have serious or frowning expressions. The characters are wearing school uniforms or casual clothing, and the background is plain white.'},\n", + " {'image_id': '1196',\n", + " 'caption': 'The image is a cartoon of an ice cream cone with a scoop of vanilla ice cream on top and a cinnamon stick as a garnish, on a pink background. The image is simple, colorful, and the ice cream cone is the main focus, with the cinnamon stick being a small detail on top.'},\n", + " {'image_id': '1197',\n", + " 'caption': 'This image shows a large, white stone building with columns and a dome on top. Several windows are visible on the sides, and there are trees in front of the building. The background shows a cloudy sky.'},\n", + " {'image_id': '1198',\n", + " 'caption': 'The image shows a large group of people wearing masks and standing in front of a brick wall. The people are all wearing different types of masks, with some wearing full face masks and others wearing half masks. They are all standing in a line, with their arms crossed in front of them. The people in the image are all wearing black and white clothing, with some wearing black pants and white shirts, and others wearing black and white striped shirts. The people are also wearing different types of shoes, with some wearing sneakers and others wearing boots.'},\n", + " {'image_id': '1199',\n", + " 'caption': 'There are two birds walking on the sidewalk in front of a house. The birds are walking in the direction of the house. There is a car parked on the right side of the street in front of the house. The street is lined with trees on both sides and has a concrete sidewalk on the left side.'},\n", + " {'image_id': '1200',\n", + " 'caption': 'This image shows a bride and groom sharing their first dance at their wedding reception. The bride is wearing a white wedding dress and the groom is wearing a black tuxedo. They are both smiling and looking at each other as they dance. In the background, there is a crowd of people watching them. The room is decorated with white tablecloths, candles, and greenery. The walls are painted white and there are large windows with white drapes that go all the way up to the ceiling. The floor is made of wooden planks.'},\n", + " {'image_id': '1201',\n", + " 'caption': 'This image shows a woman standing in front of a mirror, looking at her reflection. She is wearing a black dress with a low neckline and long sleeves, and her hair is styled in loose waves. The room is dimly lit, with a chandelier hanging from the ceiling and a table with a vase of flowers on it in the foreground. The walls are adorned with paintings and mirrors, and there is a grandfather clock in the corner. The overall atmosphere is elegant and sophisticated.'},\n", + " {'image_id': '1202',\n", + " 'caption': 'The image shows two boxer dogs, one brown and white and the other black and white, sitting next to each other on a white background. Both dogs have their mouths open, as if they are barking or about to bark. The brown and white dog has a collar around its neck, while the black and white dog has no collar. The image is well lit and the dogs appear to be in good condition.'},\n", + " {'image_id': '1203',\n", + " 'caption': \"a Christian event or to show the importance of religion in people's lives. It could also be used in a historical context to show how people dressed for religious events in the past.\"},\n", + " {'image_id': '1205',\n", + " 'caption': 'This is a magazine cover featuring two women standing in front of a building. The woman on the left is holding a book and the woman on the right is holding a piece of paper. The title of the magazine is written in Arabic at the top of the cover, and the name of the magazine is written in English at the bottom of the cover. There is also a small illustration of a camera on the left side of the cover.'},\n", + " {'image_id': '1207',\n", + " 'caption': 'This is an image of an espresso machine made of stainless steel with a sleek, modern design.'},\n", + " {'image_id': '1208',\n", + " 'caption': \"The image is a black mug with white text on it that reads, `'takes a strong man to raise children, but an even stronger man to make his mother proud'`.\"},\n", + " {'image_id': '1209',\n", + " 'caption': 'In the image, a woman is seen sitting at a table with a plate of food in front of her. She wears a striped shirt and has short, curly hair. On the table, there is a plate with two pieces of chicken and french fries, as well as two glasses of drink - one water and one soda. The background seems to be a restaurant or diner.'},\n", + " {'image_id': '1210',\n", + " 'caption': 'and ready to eat. The bowl is made of black metal and has a handle on the side. The wooden table has a rough and textured surface. In the background, there is a black chalkboard with some writing on it.'},\n", + " {'image_id': '1211',\n", + " 'caption': \"The image shows a toy store window display with various toys, such as cars and dolls, arranged for easy viewing. The store's name is written in red letters at the top of the window, and posters and advertisements adorn the walls.\"},\n", + " {'image_id': '1212',\n", + " 'caption': 'The image shows a group of people sitting around a dining table, raising their glasses in a toast. They are all smiling and appear to be enjoying themselves. The table is set with plates, silverware, and glasses. There is a vase of flowers in the center of the table. The walls are painted a light color and there is a chandelier hanging from the ceiling. The room appears to be well lit and spacious.'},\n", + " {'image_id': '1214',\n", + " 'caption': 'This is a photograph of a man lying on a bed with his baby on his chest. The man is wearing a blue shirt and jeans, while the baby is wearing a white onesie. The baby is making a peace sign with its hand, while the man is looking down at it with a smile on his face. The background of the photo is a white wall.'},\n", + " {'image_id': '1215',\n", + " 'caption': 'This The image shows a seagull perched on a wooden post in front of a body of water. In the background, there is a small town with houses and boats in the water. The seagull has its wings spread out and appears to be looking at something in the distance. The sky is clear and blue, with a few fluffy clouds visible.'},\n", + " {'image_id': '1216',\n", + " 'caption': 'This is an image of a toilet with a child standing next to it. The toilet is white and has a tank on top and a bowl at the bottom. There is a handle on the side of the tank that is used to flush the toilet. The child appears to be reaching for something in the toilet, but it is not clear what they are reaching for. The room is a bathroom, as there is a sink and a shower in the background. The walls and floor are white and made of tile.'},\n", + " {'image_id': '1217',\n", + " 'caption': 'The image shows a computer monitor with a blank screen. There is nothing else in the image.'},\n", + " {'image_id': '1218',\n", + " 'caption': 'The image is a collage of various sports equipment, including a soccer ball, a basketball, a volleyball, a football, a tennis racket, and a baseball bat. There is also a text overlay on the image that reads,'},\n", + " {'image_id': '1221',\n", + " 'caption': 'The image shows a glass of aloe vera juice with a straw in it and some aloe vera leaves on the side. Aloe vera is a succulent plant with thick, fleshy leaves used for medicinal purposes. The juice is made from the inner leaves and is known for its soothing and healing properties. It is used to treat skin conditions such as sunburn, eczema, and psoriasis, as well as for digestive issues and as a natural remedy for colds and flu. The plant is native to tropical and subtropical regions and is widely cultivated for its medicinal properties. It has a long history of use in traditional medicine and is still used today as a natural remedy for a variety of ailments.'},\n", + " {'image_id': '1224',\n", + " 'caption': \"This is a children's bedroom with two twin beds, each with pink and white striped bedding. The walls are covered in a colorful floral wallpaper, and there are pink and white curtains on the windows. There is a white desk with a pink chair in the corner of the room, and a white bookshelf with pink and white books on it. The floor is covered in a light pink carpet, and there is a pink and white rug in front of the beds.\"},\n", + " {'image_id': '1225',\n", + " 'caption': 'The image shows a bowl of cooked onions, a knife, and a cutting board on a wooden surface. The onions are sliced and appear to have been cooked in a pan. The knife is next to the bowl and appears to have been used to cut the onions. The cutting board has a brown surface and appears to have been used to prepare the onions.\\n\\nThe image shows a bowl of cooked onions, a knife, and a cutting board on a wooden surface. The onions are sliced and appear to have been cooked in a pan. The knife is next to the bowl and appears to have been used to cut the onions. The cutting board has a brown surface and appears to have been used to prepare the onions.'},\n", + " {'image_id': '1226',\n", + " 'caption': 'The image is of a blue shirt with a pink \"soon to be dad\" design on the front in white letters. The shirt has short sleeves, a round neckline, and is made of a lightweight material like cotton or polyester. The design is centered on the chest.'},\n", + " {'image_id': '1228',\n", + " 'caption': 'The image shows a black and grey jacket with the words \"The North Face\" written on the left chest in white.'},\n", + " {'image_id': '1229',\n", + " 'caption': 'This image depicts a lineman working on an electrical pole. The lineman is wearing a yellow hard hat, safety glasses, gloves, and a harness. He is holding a bucket in one hand and using the other to climb up the pole. The pole is wooden and has metal crossbars for the lineman to hold onto while working. The sky is cloudy and there is a power line running from the pole to a nearby building.'},\n", + " {'image_id': '1230',\n", + " 'caption': \"This image shows a bride and groom standing in a field of tall grass at sunset. The couple is embracing and looking into each other's eyes. The bride is wearing a white wedding dress and the groom is wearing a black tuxedo. The sun is setting behind them, casting a warm orange light on their faces and the grass. There are trees in the background, and the sky is pink and orange from the sunset.\"},\n", + " {'image_id': '1231',\n", + " 'caption': 'The image depicts a red 2020 VW Tiguan SUV driving on a wet road with water splashing up from its tires. The SUV has a panoramic sunroof and two people are standing under an umbrella in front of it, looking at the car as it passes by. The VW Tiguan is a midsize SUV with spacious, comfortable interior and strong performance. It also boasts advanced features such as panoramic sunroof and safety features like lane departure warning and automatic emergency braking.'},\n", + " {'image_id': '1232',\n", + " 'caption': 'This image shows a living room with a wooden floor and a large window that lets in a lot of natural light. The walls are painted in a light blue color, and there are several shelves with books and other items on them. There is a large wooden table in the center of the room, with four chairs around it upholstered in a dark brown leather, and two lamps on the table. The room has a high ceiling with exposed wooden beams, and there is a chandelier hanging from the center. The overall style is modern and minimalist, with a focus on natural materials and neutral colors.'},\n", + " {'image_id': '1233',\n", + " 'caption': 'This image is a graphic design with the phrase \"you got this\" written in rainbow colors on a blue and pink background, using a stylized font.'},\n", + " {'image_id': '1234',\n", + " 'caption': 'The image shows a living room with two couches, a coffee table, and a piano. There are two children sitting on the couches, one playing on a tablet and the other playing with a toy. The room is well lit with natural light coming in from the windows. The walls are painted in a neutral color, and there is a rug on the floor. The overall atmosphere of the room is cozy and comfortable.'},\n", + " {'image_id': '1237',\n", + " 'caption': 'This image appears to be a photograph of a city skyline at dusk, with purple and pink hues in the sky. The text \"welcome to the broads\" is written in white letters on the image. The skyline appears to be that of a large city, with multiple skyscrapers and buildings visible in the distance. There are also some clouds in the sky, which are illuminated by the setting sun. The overall mood of the image is peaceful and serene, with the purple and pink hues giving it a dreamy, ethereal quality.'},\n", + " {'image_id': '1239',\n", + " 'caption': 'This image is a logo for a company or brand that uses the initials BM. The logo consists of a wreath made of laurel leaves with the initials BM in the center. The design is simple and elegant, making it suitable for use in various applications such as business cards, letterheads, and websites. The color scheme is black and white, with the initials in black and the laurel wreath in white. The overall design is modern and professional, conveying a sense of sophistication and elegance.'},\n", + " {'image_id': '1240',\n", + " 'caption': 'This is a photograph of a street in a small town. The buildings on either side of the street are different colors and styles. There are cars parked on the street and people walking on the sidewalk. The sky is clear and blue with a few distant clouds. The street is lined with trees and has small shops and restaurants.'},\n", + " {'image_id': '1241',\n", + " 'caption': 'image depicts a man walking a camel through the desert, with sand dunes and hills in the background, and a clear blue sky above. The man is wearing a white robe and headscarf, and is leading the camel by a rope. The camel is also wearing a rope around its neck and appears to be following behind the man. There are no other people or animals visible in the image.'},\n", + " {'image_id': '1242',\n", + " 'caption': 'This image shows a fallen tree in front of a house. The tree has fallen across the driveway, blocking access to the house. It appears to have been uprooted by strong winds, and its branches are scattered across the ground. The house is undamaged, and the surrounding area is littered with debris from the fallen tree. The sky is cloudy and overcast, casting a gloomy mood over the scene.'},\n", + " {'image_id': '1243',\n", + " 'caption': \"This image shows a large collection of nutcrackers on display in a store window. The nutcrackers are made of various materials such as wood, metal, and plastic, and they have different shapes, sizes, and colors. Some are standing, while others are hanging or sitting on shelves, forming a festive display for the holiday season. In the background, we can see the store's interior reflected in the window. There are some decorations hanging from the ceiling, but they are not visible in this image. The image depicts a festive atmosphere and the joy of the holiday season.\"},\n", + " {'image_id': '1244',\n", + " 'caption': 'The image shows a large, modern building with a glass facade and several floors. On the ground floor, there is a large open space with plants and trees growing in the middle. On the upper floors, there are several balconies with glass railings that offer a view of the city. The building appears to be part of a larger complex, with other buildings visible in the background. The interior of the building is well lit and spacious, with natural light coming in through the large windows. The walls are made of white and gray materials, and there are several pieces of modern furniture scattered throughout the space. The overall design of the building is sleek and modern.'},\n", + " {'image_id': '1245',\n", + " 'caption': 'This is a photograph of a cup of coffee and a muffin on a table. The coffee is in a white ceramic cup with a brown handle, while the muffin is on a plate next to the cup. There is a brown and white checkered napkin on the table next to them. A brown and white checkered box is also on the table in front of them, with a brown and white checkered label on it saying \"seed and sprout\" in brown letters. In front of the box, there is a brown and white checkered plate with a brown and white checkered fork, knife, and spoon on it.'},\n", + " {'image_id': '1248',\n", + " 'caption': 'The image shows a silhouette of a cat sitting on a windowsill looking out at the night sky with stars and a crescent moon. The background is a purple gradient with curtains hanging from the top of the window.'},\n", + " {'image_id': '1249',\n", + " 'caption': 'The image shows a metal sculpture of a globe on a stand. The globe is made of metal and has a polished finish. The stand is also made of metal and has a curved shape. The globe appears to be spinning on its axis. There are no other objects in the image. The background is white.'},\n", + " {'image_id': '1250',\n", + " 'caption': 'The image shows a map of a city with roads, buildings, parks, and landmarks. There is a large green area in the center of the map, surrounded by roads and buildings. The roads are labeled with different names and directions, and there are several parks marked on the map, including a hospital, a school, and a shopping center. The map is well-organized and easy to read.'},\n", + " {'image_id': '1251',\n", + " 'caption': 'horizontal and evenly spaced. The background behind the duck and carpet is white.'},\n", + " {'image_id': '1252',\n", + " 'caption': 'This image shows a large, modern building with several floors and many windows. It appears to be a hotel, with the word \"hotel\" written in large letters on the front of the building. There are several cars parked on the street in front of the building, and a few pedestrians can be seen walking on the sidewalk. The building is surrounded by trees and other buildings, and there is a clear blue sky in the background.'},\n", + " {'image_id': '1253',\n", + " 'caption': 'This is a tiny house made of wood with a porch on the front, a large window on the side, and a shingle roof. The house has wheels on the bottom for easy mobility.'},\n", + " {'image_id': '1254',\n", + " 'caption': 'This is an advertisement for a Canadian beer brand featuring a woman wearing a straw hat and holding a can of the beer. The image is in black and white, with the words \"the easy one from canada dry\" on the side of the can. The woman is smiling and appears to be enjoying the beer.'},\n", + " {'image_id': '1255',\n", + " 'caption': 'The image shows a group of children playing in the park. They are climbing on the tree and swinging on the swings. There is a fence surrounding the park and a white picket fence in the foreground. The sky is blue and there are clouds in the background.'},\n", + " {'image_id': '1258',\n", + " 'caption': 'This The image shows a red background with the words \"Welcome to the Blue Cat Lodge Marina\" written in blue letters. The words are written in a fun, playful font that matches the nautical theme of the marina. The image also features an illustration of a cat with a fishing rod in its mouth, swimming in the water in front of the marina. The cat looks happy and content, as if it has just caught a big fish. The overall design of the image is bright, colorful, and inviting, conveying a sense of fun and relaxation.'},\n", + " {'image_id': '1259',\n", + " 'caption': 'ce gown in a champagne color. The dress has a fitted bodice with a sweetheart neckline and a sheer lace overlay. The skirt of the dress is a mermaid style with a long train. She completed her look with a pair of silver heels and a matching clutch.'},\n", + " {'image_id': '1260',\n", + " 'caption': 'There are three penguins standing. The first penguin is standing on its hind legs with its beak open, calling out to the other penguins. The second penguin is standing on its hind legs with its beak closed. The third penguin is standing on all fours, with its head tilted to the side as if looking at the others. They are in a zoo enclosure with a fence and a gate in the background. The ground is covered in dirt and rocks, with some plants growing in the background. The image depicts a group of penguins in a zoo enclosure, with one of them calling out to the others.'},\n", + " {'image_id': '1261',\n", + " 'caption': 'people walking down a sidewalk next to a parked SUV. The car is a 2020 Ford Edge in a dark brown color with tinted windows. The license plate is not visible. The people are wearing casual clothing and carrying bags, with one person in a black hoodie and the other in a white shirt and black pants. The sidewalk is made of concrete with a yellow line down the middle and trees on either side. Buildings can be seen in the background and the sky is cloudy with no visible sun.'},\n", + " {'image_id': '1262',\n", + " 'caption': 'This image is a pattern or texture of green, blue, and purple shades. It can be used as a background or design element in graphic or web design.'},\n", + " {'image_id': '1264',\n", + " 'caption': \"This image is a map of the state of Wyoming in the United States. The state's name is written in white letters on a black background, with a white outline of the state's shape. Inside the state's shape, there is a white silhouette of the Rocky Mountains, which are located in the western part of Wyoming. The state's capital, Cheyenne, is marked with a white dot in the southeastern part of the state. There are also several white lines crisscrossing the state, which may represent highways or rivers. The overall design of the map is simple and easy to read, with clear labels and a minimalist style.\"},\n", + " {'image_id': '1265',\n", + " 'caption': 'The image shows a group of pink cherry blossom trees in full bloom, surrounded by tall, dark pine trees. A group of people can be seen walking along a path through the trees, enjoying the beauty of the blossoms. The sky is cloudy, with sunlight peeking through the clouds, casting a warm glow on the scene.'},\n", + " {'image_id': '1266',\n", + " 'caption': 'This is a living room with light pink walls, a white couch, and a grey carpet. A flat screen television is mounted on the wall, and a small white coffee table is placed in front of the couch. The room has large windows that provide ample natural light. No other furniture is present in the room.'},\n", + " {'image_id': '1267',\n", + " 'caption': 'This is an image of a room with many cardboard boxes stacked on top of each other, leaving some empty spaces. The room has wooden walls, a window on one side, wooden plank flooring with a rug on top, and a door on the other side that is not visible in the image.'},\n", + " {'image_id': '1268',\n", + " 'caption': 'This image depicts a person riding a skateboard. The person is wearing a yellow shirt and blue shorts, and is holding a bottle of water in one hand while riding the skateboard with the other. The background is a white surface. The overall mood of the image is casual and relaxed. The image could be used to depict a person enjoying a leisurely activity such as skateboarding.'},\n", + " {'image_id': '1269',\n", + " 'caption': 'The image is a black and white icon of a euro sign (€) with two arrows coming out of it. The arrow on the left points to the right, and the arrow on the right points to the left. The euro symbol is surrounded by a circle.\\n\\nThe euro symbol is the official currency of the European Union (EU). It was introduced in 1999 and is used by 19 of the 27 member states of the EU. The euro is the second largest and second most traded currency in the world after the US dollar. It is used as a medium of exchange in many countries, and its value is determined by the market demand for it.\\n\\nThe two arrows in the image represent the flow of currency, with one arrow pointing to the right indicating an increase in value and the other arrow pointing to the left indicating a decrease in value. The circle surrounding the euro symbol represents the stability and security of the currency.'},\n", + " {'image_id': '1271',\n", + " 'caption': 'The image shows a sunset over a city skyline. The sky is cloudy and the sun is setting behind the buildings, casting long shadows on the rooftops. The buildings are a mix of residential and commercial structures, with some tall skyscrapers in the background. There are also some trees and power lines visible in the foreground. The overall mood of the image is peaceful and serene, with the sun casting a warm glow over the scene.'},\n", + " {'image_id': '1272',\n", + " 'caption': \"The very hungry caterpillar is a popular children's book character created by author and illustrator Eric Carle. The book tells the story of a caterpillar who eats his way through different foods and then transforms into a beautiful butterfly, teaching children about the life cycle of a butterfly and the importance of eating healthy foods. The book has been translated into many languages and has become a classic in children's literature.\"},\n", + " {'image_id': '1273',\n", + " 'caption': \"The image shows the interior of a car with a steering wheel and dashboard in front of the driver's seat.\"},\n", + " {'image_id': '1274',\n", + " 'caption': 'The image shows a red beret commonly worn by military personnel, police officers, and other professionals. It is made of wool or cotton and has a flat top and a strap that goes around the back of the head. The beret is maroon in color and has a badge or emblem on the front, which appears to be a shield or crest with some sort of insignia or design on it. The strap that goes around the back of the head is not visible in this image.'},\n", + " {'image_id': '1275',\n", + " 'caption': 'This image depicts a The image shows a statue of the goddess of justice, holding a scale in one hand and a sword in the other. The statue is made of bronze and stands on a marble pedestal. The goddess is depicted in a classical pose, with a serious expression on her face and a flowing robe draped around her body. The background is a blurred image of trees and greenery, with sunlight filtering through the leaves. The overall effect is one of grandeur and reverence, conveying the idea of justice and fairness.'},\n", + " {'image_id': '1276',\n", + " 'caption': 'This image shows a person sitting in the back of a golf cart with a stuffed animal in their lap. The person is wearing a black and white striped shirt, black pants, and black shoes. They are holding a golf club in their right hand. The cart is parked on a grassy area with trees in the background. Other people can be seen playing golf in the distance.'},\n", + " {'image_id': '1278',\n", + " 'caption': \"The image is a logo for the Tampa Bay Lightning, a professional ice hockey team in the National Hockey League. The logo features a blue and white lightning bolt with the team's name in white letters on a black background. The team's colors are blue, white, and black. The Tampa Bay Lightning were founded in 1992 and have played in the NHL since 1993. They won one Stanley Cup championship in 2004. The team's home arena is the Amalie Arena in Tampa, Florida. The Lightning have a large fan base and are known for their fast and exciting style of play.\"},\n", + " {'image_id': '1282',\n", + " 'caption': 'The image shows an underwater housing for a camera, which is designed to protect the camera from water and other environmental factors. The housing has a large lens on the front, several buttons and controls to adjust the settings, and an LED light to illuminate subjects in low light conditions. It is made of durable materials, such as metal and plastic, to withstand the rigors of underwater use.'},\n", + " {'image_id': '1283',\n", + " 'caption': 'dimly lit bar or tavern with shelves of alcohol, people drinking and chatting at the bar, and a variety of clothing worn by the patrons.'},\n", + " {'image_id': '1285',\n", + " 'caption': 'This image shows two hands holding a small electronic device. The device has a black and green circuit board on the top and a white and green circuit board on the bottom. The hands are holding the device by the sides, with the thumb and index finger on one side and the middle and ring fingers on the other. The device appears to have a small screen on the front and several small buttons on the sides.'},\n", + " {'image_id': '1287',\n", + " 'caption': \"This is a pencil drawing of a woman wearing a Native American headdress and holding a leopard. The woman has long, straight hair and is wearing a feathered headdress with a leopard skin pattern on it. The leopard is also depicted in the drawing, with its head peeking out from behind the woman's shoulder. The overall style of the drawing is very detailed and realistic, with a lot of attention paid to the fur and feathers on the headdress and the leopard. The woman's face is also very well drawn, with a lot of attention paid to the details of her features and expression.\"},\n", + " {'image_id': '1288',\n", + " 'caption': 'This image shows a cabin in the woods at night, with snow covering the ground and trees around it. The cabin is lit up by the light coming through the windows, casting a warm glow on the surrounding area. It appears to be made of wood and has a pitched roof, with a chimney on top. There is a porch in front of the cabin, with a wooden railing and steps leading down to the ground. The trees around the cabin are tall and covered in snow, with branches hanging down from the top. The sky is clear and dark, with stars visible in the background.'},\n", + " {'image_id': '1289',\n", + " 'caption': 'The image depicts a body of water with a small island in the distance. The island features a lighthouse and there are rocks in the foreground. The background consists of a large body of water with mountains visible. The sky is cloudy and a boat is present in the water.'},\n", + " {'image_id': '1291',\n", + " 'caption': 'This image shows a man standing on a ladder in front of a colorful graffiti mural. The man is wearing a black hoodie and appears to be painting the mural. The mural features a variety of colors, including green, blue, and orange. There are also various shapes and designs in the mural, including letters, numbers, and abstract designs.'},\n", + " {'image_id': '1292',\n", + " 'caption': 'The car in the image is a BMW M4, which is a luxury sports car manufactured by the German automaker BMW. The car has a sleek and stylish design.'},\n", + " {'image_id': '1293',\n", + " 'caption': 'The image shows a beach with tall buildings in the background. People are walking on the sandy beach. The clear, blue sky has a few distant clouds. A tall, thin structure in the center appears to be a lighthouse.'},\n", + " {'image_id': '1294',\n", + " 'caption': \"This is a movie poster. The image shows a man and a woman in a romantic embrace. The man is wearing a white shirt and black pants, the woman a red dress. The background is a gradient of blue and purple. The title of the movie is written in large, bold letters at the top of the poster with the actors' names below. The poster appears to be from the 1960s or 1970s based on the style and fashion of the clothing.\"},\n", + " {'image_id': '1296',\n", + " 'caption': 'The image shows a silver necklace with a small anchor charm made of metal and coated with blue enamel. The silver chain has a lobster claw clasp and the anchor charm has a small hole at the top for hanging it on the necklace. The anchor symbolizes hope and strength, particularly associated with the sea and sailing. The blue enamel coating adds a pop of color to the piece, making it stand out, and the silver chain and lobster claw clasp complete the look, making it a stylish and durable piece of jewelry.'},\n", + " {'image_id': '1297',\n", + " 'caption': 'The image shows a group of people sitting around a long table. They are all dressed in formal attire, such as suits and ties for the men and dresses for the women. They are all looking at a piece of paper on the table in front of them. There are pens and other writing utensils on the table as well. The room is well lit and appears to be an office or meeting room.'},\n", + " {'image_id': '1301',\n", + " 'caption': 'The image shows a woman wearing a yellow The woman is wearing a yellow gown with a black belt around the waist. The gown has a deep v neckline and a long slit on the side. The woman is posing on the red carpet and has her hands on her hips. She is wearing high heels and a pair of earrings. The background is a blurred image of people and lights.'},\n", + " {'image_id': '1302',\n", + " 'caption': 'The image shows a set of plastic containers with different colored lids. The containers are stacked on top of each other and are filled with different types of fruits, such as grapes, strawberries, and raspberries. Each container has a different color lid, with some lids being green, blue, yellow, and red. The containers appear to be made of clear plastic, allowing the contents inside to be seen.'},\n", + " {'image_id': '1303',\n", + " 'caption': 'The image shows a group of people standing in front of a large banner with a cartoon character on it. The people in the image are all smiling and seem to be enjoying themselves. The person in the center of the image is holding a small child, who is looking up at the camera with a big smile on their face. The other people in the image are standing around the child and the person holding them, and they all seem to be part of the same group or family. The background of the image is not very clear, but it appears to be a large, open space with some trees and buildings visible in the distance.'},\n", + " {'image_id': '1304',\n", + " 'caption': 'The image depicts a young man wearing suspenders and a red shirt, standing with his arms crossed in front of him. He is looking up at something with a surprised expression on his face. The image is in a flat, cartoon style.\\n\\nThe man is wearing suspenders and a red shirt. He is standing with his arms crossed in front of him, looking up at something with a surprised expression on his face. The image is in a flat, cartoon style.'},\n", + " {'image_id': '1305',\n", + " 'caption': 'The image shows a wooden statue of a woman holding a book and standing on a pedestal. The statue is intricately carved with detailed clothing and facial features. The pedestal is also carved with a decorative design.'},\n", + " {'image_id': '1307',\n", + " 'caption': 'This is an image of a black and white cartoon cat with a big grin on its face, standing on its hind legs with its arms outstretched to the sides. The cat is wearing a blue shirt with white sleeves and a white collar. Its eyes are large and white with black pupils, and its mouth is open in a smile. The cat is also wearing black pants with white stripes down the sides, and is standing on a light blue background. There are no other objects or characters in the image.'},\n", + " {'image_id': '1308',\n", + " 'caption': 'The image shows a group of people hiking on a rocky mountain trail. They are wearing backpacks and hiking boots, and some of them are carrying trekking poles. The sky is clear and blue, and there are some clouds in the distance. The mountains in the background are rugged and rocky, with some trees and shrubs growing on them. The trail is steep and narrow, with large rocks and boulders on either side. It looks like a challenging hike, but the group seems to be enjoying themselves.'},\n", + " {'image_id': '1310',\n", + " 'caption': 'This is an image of a table with several columns and rows. The columns are labeled with different numbers and the rows are labeled with different countries.'},\n", + " {'image_id': '1311',\n", + " 'caption': \"This is an image of a black and white cow standing in a dirt field. The cow appears to be grazing on the grass in the middle of the field. There are no other cows visible in the image. The sky is cloudy and there are some trees in the background. The image appears to have been taken from a distance, as there is a fence in the foreground that blocks the view of the cow's face.\"},\n", + " {'image_id': '1315',\n", + " 'caption': 'image depicts a strong and masculine man with a rugged appearance and a serious expression, showcasing his muscular physique and tattoos.'},\n", + " {'image_id': '1316',\n", + " 'caption': 'The image shows a bunch of green asparagus spears in a brown paper bag on a wooden surface. The spears are long and thin, with a bright green color and no signs of damage or decay. There is moisture on the surface of the asparagus, which suggests that it has recently been harvested. The overall appearance of the asparagus is fresh and healthy.'},\n", + " {'image_id': '1317',\n", + " 'caption': 'The image shows a small garden area with a white building in the background. The building appears to be made of wood and has a thatched roof. There are several trees and plants in the garden, including a large palm tree in the center. The garden is surrounded by a white picket fence and there is a path leading to the front door of the building.'},\n", + " {'image_id': '1318',\n", + " 'caption': \"This is an image of a metal box with the letters 'c s a' engraved on it. The box is gray and rectangular with rounded corners. The bold, capitalized letters are engraved into the surface. The box sits on a wooden surface visible in the background.\"},\n", + " {'image_id': '1319',\n", + " 'caption': 'The image shows a woman wearing a pink kimono with a pattern of pink and white flowers on a white background. Her hair is styled in a bun on top of her head and she has pink lipstick on her lips. It appears to be a still from a fashion show or advertisement.'},\n", + " {'image_id': '1320',\n", + " 'caption': \"This image is a clay sculpture of a bull with horns and a long tail. The bull is standing on its hind legs, with its front legs resting on the ground. The sculpture appears to be made of clay and is painted with various colors, including red, brown, and yellow. The bull's body is long and slender, with a curved back and a small head. The horns are large and curved, and the tail is long and thin. The overall appearance of the sculpture is very detailed and realistic, with a lot of attention paid to the animal's anatomy and features.\"},\n", + " {'image_id': '1321',\n", + " 'caption': 'The woman in the image is wearing a white t-shirt, black jacket, ripped jeans, and white sneakers. She is holding a cellphone in one hand and a coffee cup in the other while standing in front of a building with a large window and metal door. The sidewalk in front of the building is made of cobblestones and there are no other people in the image.'},\n", + " {'image_id': '1322',\n", + " 'caption': \"The image is a pencil drawing of a woman's head with long, straight hair. The hair is drawn in pencil with shading and highlights to give it a realistic look. The woman's face is not shown, but the hair is drawn in great detail, with strands of hair hanging down from the top of her head. There is a pencil next to the drawing, which is used to create the image.\"},\n", + " {'image_id': '1323',\n", + " 'caption': 'The image shows a group of people standing around a tree that has been planted in the ground. One person is holding a hose and spraying water onto the roots of the tree, while another person is holding a shovel and digging around the base of the tree. The people are wearing yellow shirts and green hats, and there is a green tarp on the ground next to the tree. The background is a grassy field with some trees in the distance.'},\n", + " {'image_id': '1324',\n", + " 'caption': \"The image shows a group of people standing in a crowd. They appear to be looking at something in the distance. Some of them are wearing hats and coats, while others are not. The image is in black and white, with the exception of the people's faces, which are in color. The people in the image appear to be of different ages and ethnicities. There is a sense of tension in the image, as the people seem to be waiting for something to happen. Overall, the image is a snapshot of a moment in time, capturing the diversity and humanity of the people in the crowd.\"},\n", + " {'image_id': '1326',\n", + " 'caption': 'The image shows a view of a harbor with a large cruise ship docked in the foreground. Several smaller boats and yachts are also docked around it. In the background, there is a large cliff with a city built into the side of it. The water in the harbor is a deep blue color, and there are several small islands visible in the distance. The sky is clear and blue, with a few fluffy clouds visible.'},\n", + " {'image_id': '1327',\n", + " 'caption': 'This is an image of a brown leather bag with a zipper on the top, sitting on a wooden bench. The bag has a shoulder strap. Next to the bag, there are a pair of sunglasses, a water bottle, and a book on the bench. The background of the image is a park or outdoor area, with trees and greenery visible.'},\n", + " {'image_id': '1328',\n", + " 'caption': 'The image shows a clear glass vase sitting on a white surface with a pink flower arrangement inside it. The vase has a round shape and is made of clear glass. The arrangement inside the vase consists of small pink flowers and green leaves. There are no other objects in the image.'},\n", + " {'image_id': '1329',\n", + " 'caption': 'The image shows a set of different types of eyeglasses on a white background. The eyeglasses are arranged in a circle, with each one having a different shape, color, and material. Some of the eyeglasses have tinted lenses for specific purposes, such as driving or reading, while others have clear lenses. They are also designed as fashion accessories.'},\n", + " {'image_id': '1330',\n", + " 'caption': 'The image shows a plate with various fruits on it - watermelon, strawberries, grapes, kiwi, starfruit, and pineapple. The plate is set against a white background and is surrounded by a black border.'},\n", + " {'image_id': '1331',\n", + " 'caption': 'The image shows a black and brown dog standing on a leash outside a brick building with a wooden door and a small window. The dog is wearing a collar and its tail is wagging while its ears are perked up. The ground is made of cement and there are some puddles on it. The sky is cloudy and it appears to be raining.'},\n", + " {'image_id': '1332',\n", + " 'caption': 'The image shows a group of people standing behind a podium in front of a large screen displaying a map of the world. The people are dressed in business attire and appear to be listening to someone speaking at the podium. There are several laptops and other electronic devices on the table in front of them.'},\n", + " {'image_id': '1333',\n", + " 'caption': 'In the image, there is a body of water with a sandy beach next to it. The water is clear and calm, reflecting the blue sky above. On the other side of the water, there is a grassy area with some trees and bushes. In the background, there is a building with white walls and a red roof, which appears to be a house. There are no people visible in the image.'},\n", + " {'image_id': '1334',\n", + " 'caption': \"The building in the image is a large, modern hotel with several floors and many windows. It appears to be made of concrete and steel, with a gray and white color scheme. There are several balconies on the upper floors, and a large sign with the hotel's name is visible on the front of the building. There are several cars parked in front of the hotel, and a sidewalk runs along the front of the building.\"},\n", + " {'image_id': '1335',\n", + " 'caption': 'The image shows the River Thames in London at night with the Houses of Parliament and Big Ben in the background. Two people are sitting on a bench in the foreground, looking out over the river. The illuminated lights on the bridge and buildings create a festive atmosphere.'},\n", + " {'image_id': '1336',\n", + " 'caption': \"The image shows two hearts, one red and one black and white. The red heart is on the left side and the black and white heart is on the right side. The red heart has a black outline around it and the black and white heart has a white outline around it. The background is a black and white checkerboard pattern.\\n\\nA heart is a symbol of love and affection. It is often associated with romantic feelings and emotions. The red heart is a symbol of passion and desire, while the black and white heart is a symbol of balance and harmony. The black and white checkerboard pattern is a symbol of contrast and duality.\\n\\nThe image could be used to represent a romantic or passionate theme, such as a valentine's day card or a romantic movie poster. It could also be used to represent a theme of balance and harmony, such as a yin and yang symbol.\"},\n", + " {'image_id': '1337',\n", + " 'caption': 'The image shows a swimming pool in a hotel with a wooden deck, lounge chairs, and umbrellas. The building behind the pool has two floors with balconies on the second floor. The balconies have wooden railings and potted plants. The sky is clear and blue without any clouds.'},\n", + " {'image_id': '1338',\n", + " 'caption': 'The image shows a reception desk with two women standing behind it. The desk is made of wood with a white countertop and two chairs in front of it. The walls of the room are wood panels, and there is a large window behind the desk that lets in natural light. The floor is tiled, and there is a rug in front of the desk.'},\n", + " {'image_id': '1339',\n", + " 'caption': 'The image is a brown and pink floral scarf made of silk or silk blend material. The scarf has tassels on the ends and is draped over a white surface.'},\n", + " {'image_id': '1340',\n", + " 'caption': 'This image is a watercolor painting of a woman sitting on a bench in a park. The woman is wearing a white dress and has long, curly brown hair. She is looking down at her phone, which is sitting on the bench next to her. The background of the image is a park with trees and a path leading into the distance. There is a blue sky with fluffy clouds in the background. The overall mood of the image is one of relaxation and contemplation.'},\n", + " {'image_id': '1342',\n", + " 'caption': 'This is a dish of pork with orange sauce, served with rice and chopsticks on a white plate on a bamboo mat.'},\n", + " {'image_id': '1343',\n", + " 'caption': 'The image shows an open window with a view of a mountain range in the distance. The window is made of stone and has a wooden frame. The view through the window is of a valley with trees and a river running through it. The sky is clear and blue, with a few fluffy clouds in the distance. The sun is shining down on the landscape, casting long shadows on the ground. There are no other buildings or structures visible in the image.'},\n", + " {'image_id': '1345',\n", + " 'caption': 'The image shows a room with a black grand piano in the center, surrounded by black and white album covers hanging on the wall. There are several framed photographs on the wall, including one of a group of people in the 1960s. The room is dimly lit, with a single spotlight shining down on the piano.'},\n", + " {'image_id': '1346',\n", + " 'caption': 'The image shows a white candle with a gold ribbon wrapped around it, sitting on top of a stack of books. The books are stacked in a pyramid shape, with the largest book at the bottom and the smallest at the top. There is a gold star on the cover of each book. The background is a light grey.'},\n", + " {'image_id': '1347',\n", + " 'caption': 'The image shows a woman wearing a beige trench dress and black sunglasses standing on the street. The dress has a belt around the waist and the sleeves are rolled up to the elbows. The woman is wearing a pair of black sunglasses and carrying a black handbag. The background is a street with buildings and trees.\\n\\nAnswer: The image shows a woman wearing a beige trench dress and black sunglasses standing on the street. The dress has a belt around the waist and the sleeves are rolled up to the elbows. The woman is wearing a pair of black sunglasses and carrying a black handbag. The background is a street with buildings and trees.'},\n", + " {'image_id': '1348',\n", + " 'caption': 'The image shows a plate with several green and orange fruits on it. The fruits appear to be sliced in half and arranged in a circular pattern on the plate. The plate is sitting on top of a black and white checkered floor.'},\n", + " {'image_id': '1349',\n", + " 'caption': 'The image shows a man wearing sunglasses and a green polo shirt, sitting at a table with a laptop in front of him. He has short, curly hair and is wearing a watch on his left wrist. The background is not visible, but it appears to be a room with a white wall and some furniture. The image is well lit and the colors are bright and vivid.'},\n", + " {'image_id': '1351',\n", + " 'caption': \"This image is a bronze statue of a woman wearing a dress and holding a flower in her hand. The statue is standing on a black marble base. The woman's hair is styled in a bun and she has a serene expression on her face. The statue has intricate details, including the folds in the woman's dress and the petals of the flower. The overall effect is one of elegance and grace.\"},\n", + " {'image_id': '1352',\n", + " 'caption': 'little girl in a pink bikini holding a pink bag with a serious expression on her face. Her curly hair and pink sunglasses add to her cute appearance. The background is simple with a light gray color and a white wall.'},\n", + " {'image_id': '1356',\n", + " 'caption': 'The image shows a soccer player standing on a field with a ball at his feet. The player is wearing a yellow shirt and black shorts. The background is a dark night sky with a few stars visible. There is a crowd of people watching the game from behind a fence.'},\n", + " {'image_id': '1357',\n", + " 'caption': \"a gateway to another dimension. The Dark Side of the Moon remains one of Pink Floyd's most popular albums and is considered a classic of the rock genre.\"},\n", + " {'image_id': '1360',\n", + " 'caption': 'There are two beds in the room, one is a double bed and the other is a single bed. Both beds are made with white sheets.'},\n", + " {'image_id': '1361',\n", + " 'caption': 'This is a black and white photograph of a woman standing in front of a brick wall. She is wearing a white shirt and black pants, and has her arms crossed in front of her chest. Her hair is pulled back into a ponytail, and she has a serious expression on her face. The photograph is taken from a low angle, looking up at the woman from below her waist. There is a small amount of grain visible in the image, but it does not detract from the overall quality of the photograph. The image is well composed, with the woman standing in the center of the frame and the brick wall providing an interesting background.'},\n", + " ...]}" + ] + }, + "execution_count": 518, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "caps" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "acde12da", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a76d90b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7841cbd8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "eye", + "language": "python", + "name": "eye" + }, + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/develop.ipynb b/develop.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..074068320f5826debcc46dd6608cd1b4d1f0d500 --- /dev/null +++ b/develop.ipynb @@ -0,0 +1,929 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "d5ac353e", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import argparse\n", + "import os\n", + "import shutil\n", + "import random\n", + "from PIL import Image\n", + "\n", + "import numpy as np\n", + "import torch\n", + "import torch.backends.cudnn as cudnn\n", + "from transformers import StoppingCriteria, StoppingCriteriaList\n", + "\n", + "import lavis.tasks as tasks\n", + "from lavis.common.config import Config\n", + "from lavis.common.dist_utils import get_rank, init_distributed_mode\n", + "from lavis.common.logger import setup_logger\n", + "from lavis.common.optims import (\n", + " LinearWarmupCosineLRScheduler,\n", + " LinearWarmupStepLRScheduler,\n", + ")\n", + "from lavis.common.registry import registry\n", + "from lavis.common.utils import now\n", + "\n", + "# imports modules for registration\n", + "from lavis.datasets.builders import *\n", + "from lavis.models import *\n", + "from lavis.processors import *\n", + "from lavis.runners import *\n", + "from lavis.tasks import *" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4fdef7a6", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "shutil.copytree('/ibex/project/c2133/vicuna', '/tmp/vicuna')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "661f9e80", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "class StoppingCriteriaSub(StoppingCriteria):\n", + "\n", + " def __init__(self, stops = [], encounters=1):\n", + " super().__init__()\n", + " self.stops = stops\n", + "\n", + " def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor):\n", + " for stop in self.stops:\n", + " if torch.all((stop == input_ids[0][-len(stop):])).item():\n", + " return True\n", + "\n", + " return False\n", + "\n", + "\n", + "stop_words_ids = [torch.tensor([835]).to('cuda:0'), \n", + " torch.tensor([2277, 29937]).to('cuda:0')] # '###' can be encoded in different ways.\n", + "stopping_criteria = StoppingCriteriaList([StoppingCriteriaSub(stops=stop_words_ids)])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1822a77a", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "parser = argparse.ArgumentParser(description=\"Training\")\n", + "\n", + "parser.add_argument(\"--cfg-path\", required=True, help=\"path to configuration file.\")\n", + "parser.add_argument(\n", + " \"--options\",\n", + " nargs=\"+\",\n", + " help=\"override some settings in the used config, the key-value pair \"\n", + " \"in xxx=yyy format will be merged into config file (deprecate), \"\n", + " \"change to --cfg-options instead.\",\n", + ")\n", + "\n", + "args = parser.parse_args([\"--cfg-path\", \"lavis/projects/blip2/train/vicuna_pretrain_stage2_cc.yaml\"])\n", + "\n", + "cfg = Config(args)\n", + "device = 'cuda:0'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "57e90f19", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "vis_processor_cfg = cfg.datasets_cfg.cc_combine.vis_processor.train\n", + "vis_processor = registry.get_processor_class(vis_processor_cfg.name).from_config(vis_processor_cfg)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4cc521da", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading LLAMA\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "abeac6970d914446adc1fb73f7e5b5f9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading checkpoint shards: 0%| | 0/3 [00:00╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮\n", + "│ in <module>:2 │\n", + "│ │\n", + "│ 1 task = tasks.setup_task(cfg) │\n", + "│ ❱ 2 model = task.build_model(cfg) │\n", + "│ 3 │\n", + "│ │\n", + "│ /home/zhud/project/blip2/lavis/tasks/base_task.py:33 in build_model │\n", + "│ │\n", + "│ 30 │ │ model_config = cfg.model_cfg │\n", + "│ 31 │ │ │\n", + "│ 32 │ │ model_cls = registry.get_model_class(model_config.arch) │\n", + "│ ❱ 33 │ │ return model_cls.from_config(model_config) │\n", + "│ 34 │ │\n", + "│ 35 │ def build_datasets(self, cfg): │\n", + "│ 36 │ │ \"\"\" │\n", + "│ │\n", + "│ /home/zhud/project/blip2/lavis/models/blip2_models/blip2_llama.py:315 in from_config │\n", + "│ │\n", + "│ 312 │ │ ckpt_path = cfg.get(\"ckpt\", \"\") │\n", + "│ 313 │ │ if ckpt_path: │\n", + "│ 314 │ │ │ print(\"Load BLIP2-LLM Checkpoint: {}\".format(ckpt_path)) │\n", + "│ ❱ 315 │ │ │ ckpt = torch.load(ckpt_path, map_location=\"cpu\") │\n", + "│ 316 │ │ │ msg = model.load_state_dict(ckpt['model'], strict=False) │\n", + "│ 317 │ │ │\n", + "│ 318 │ │ return model │\n", + "│ │\n", + "│ /home/zhud/anaconda3/envs/eye/lib/python3.9/site-packages/torch/serialization.py:791 in load │\n", + "│ │\n", + "│ 788 │ if 'encoding' not in pickle_load_args.keys(): │\n", + "│ 789 │ │ pickle_load_args['encoding'] = 'utf-8' │\n", + "│ 790 │ │\n", + "│ ❱ 791 │ with _open_file_like(f, 'rb') as opened_file: │\n", + "│ 792 │ │ if _is_zipfile(opened_file): │\n", + "│ 793 │ │ │ # The zipfile reader is going to advance the current file position. │\n", + "│ 794 │ │ │ # If we want to actually tail call to torch.jit.load, we need to │\n", + "│ │\n", + "│ /home/zhud/anaconda3/envs/eye/lib/python3.9/site-packages/torch/serialization.py:271 in │\n", + "│ _open_file_like │\n", + "│ │\n", + "│ 268 │\n", + "│ 269 def _open_file_like(name_or_buffer, mode): │\n", + "│ 270 │ if _is_path(name_or_buffer): │\n", + "│ ❱ 271 │ │ return _open_file(name_or_buffer, mode) │\n", + "│ 272 │ else: │\n", + "│ 273 │ │ if 'w' in mode: │\n", + "│ 274 │ │ │ return _open_buffer_writer(name_or_buffer) │\n", + "│ │\n", + "│ /home/zhud/anaconda3/envs/eye/lib/python3.9/site-packages/torch/serialization.py:252 in __init__ │\n", + "│ │\n", + "│ 249 │\n", + "│ 250 class _open_file(_opener): │\n", + "│ 251 │ def __init__(self, name, mode): │\n", + "│ ❱ 252 │ │ super().__init__(open(name, mode)) │\n", + "│ 253 │ │\n", + "│ 254 │ def __exit__(self, *args): │\n", + "│ 255 │ │ self.file_like.close() │\n", + "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n", + "FileNotFoundError: [Errno 2] No such file or directory: \n", + "'/home/zhud/project/blip2/lavis/output/BLIP2/Vicuna_pretrain_stage2_cc/20230405233/checkpoint_3.pth'\n", + "\n" + ], + "text/plain": [ + "\u001B[31m╭─\u001B[0m\u001B[31m──────────────────────────────\u001B[0m\u001B[31m \u001B[0m\u001B[1;31mTraceback \u001B[0m\u001B[1;2;31m(most recent call last)\u001B[0m\u001B[31m \u001B[0m\u001B[31m───────────────────────────────\u001B[0m\u001B[31m─╮\u001B[0m\n", + "\u001B[31m│\u001B[0m in \u001B[92m\u001B[0m:\u001B[94m2\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m1 \u001B[0mtask = tasks.setup_task(cfg) \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m❱ \u001B[0m2 model = task.build_model(cfg) \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m3 \u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2;33m/home/zhud/project/blip2/lavis/tasks/\u001B[0m\u001B[1;33mbase_task.py\u001B[0m:\u001B[94m33\u001B[0m in \u001B[92mbuild_model\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 30 \u001B[0m\u001B[2m│ │ \u001B[0mmodel_config = cfg.model_cfg \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 31 \u001B[0m\u001B[2m│ │ \u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 32 \u001B[0m\u001B[2m│ │ \u001B[0mmodel_cls = registry.get_model_class(model_config.arch) \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m❱ \u001B[0m 33 \u001B[2m│ │ \u001B[0m\u001B[94mreturn\u001B[0m model_cls.from_config(model_config) \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 34 \u001B[0m\u001B[2m│ \u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 35 \u001B[0m\u001B[2m│ \u001B[0m\u001B[94mdef\u001B[0m \u001B[92mbuild_datasets\u001B[0m(\u001B[96mself\u001B[0m, cfg): \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 36 \u001B[0m\u001B[2;90m│ │ \u001B[0m\u001B[33m\"\"\"\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2;33m/home/zhud/project/blip2/lavis/models/blip2_models/\u001B[0m\u001B[1;33mblip2_llama.py\u001B[0m:\u001B[94m315\u001B[0m in \u001B[92mfrom_config\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m312 \u001B[0m\u001B[2m│ │ \u001B[0mckpt_path = cfg.get(\u001B[33m\"\u001B[0m\u001B[33mckpt\u001B[0m\u001B[33m\"\u001B[0m, \u001B[33m\"\u001B[0m\u001B[33m\"\u001B[0m) \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m313 \u001B[0m\u001B[2m│ │ \u001B[0m\u001B[94mif\u001B[0m ckpt_path: \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m314 \u001B[0m\u001B[2m│ │ │ \u001B[0m\u001B[96mprint\u001B[0m(\u001B[33m\"\u001B[0m\u001B[33mLoad BLIP2-LLM Checkpoint: \u001B[0m\u001B[33m{}\u001B[0m\u001B[33m\"\u001B[0m.format(ckpt_path)) \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m❱ \u001B[0m315 \u001B[2m│ │ │ \u001B[0mckpt = torch.load(ckpt_path, map_location=\u001B[33m\"\u001B[0m\u001B[33mcpu\u001B[0m\u001B[33m\"\u001B[0m) \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m316 \u001B[0m\u001B[2m│ │ │ \u001B[0mmsg = model.load_state_dict(ckpt[\u001B[33m'\u001B[0m\u001B[33mmodel\u001B[0m\u001B[33m'\u001B[0m], strict=\u001B[94mFalse\u001B[0m) \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m317 \u001B[0m\u001B[2m│ │ \u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m318 \u001B[0m\u001B[2m│ │ \u001B[0m\u001B[94mreturn\u001B[0m model \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2;33m/home/zhud/anaconda3/envs/eye/lib/python3.9/site-packages/torch/\u001B[0m\u001B[1;33mserialization.py\u001B[0m:\u001B[94m791\u001B[0m in \u001B[92mload\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 788 \u001B[0m\u001B[2m│ \u001B[0m\u001B[94mif\u001B[0m \u001B[33m'\u001B[0m\u001B[33mencoding\u001B[0m\u001B[33m'\u001B[0m \u001B[95mnot\u001B[0m \u001B[95min\u001B[0m pickle_load_args.keys(): \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 789 \u001B[0m\u001B[2m│ │ \u001B[0mpickle_load_args[\u001B[33m'\u001B[0m\u001B[33mencoding\u001B[0m\u001B[33m'\u001B[0m] = \u001B[33m'\u001B[0m\u001B[33mutf-8\u001B[0m\u001B[33m'\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 790 \u001B[0m\u001B[2m│ \u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m❱ \u001B[0m 791 \u001B[2m│ \u001B[0m\u001B[94mwith\u001B[0m _open_file_like(f, \u001B[33m'\u001B[0m\u001B[33mrb\u001B[0m\u001B[33m'\u001B[0m) \u001B[94mas\u001B[0m opened_file: \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 792 \u001B[0m\u001B[2m│ │ \u001B[0m\u001B[94mif\u001B[0m _is_zipfile(opened_file): \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 793 \u001B[0m\u001B[2m│ │ │ \u001B[0m\u001B[2m# The zipfile reader is going to advance the current file position.\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 794 \u001B[0m\u001B[2m│ │ │ \u001B[0m\u001B[2m# If we want to actually tail call to torch.jit.load, we need to\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2;33m/home/zhud/anaconda3/envs/eye/lib/python3.9/site-packages/torch/\u001B[0m\u001B[1;33mserialization.py\u001B[0m:\u001B[94m271\u001B[0m in \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[92m_open_file_like\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 268 \u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 269 \u001B[0m\u001B[94mdef\u001B[0m \u001B[92m_open_file_like\u001B[0m(name_or_buffer, mode): \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 270 \u001B[0m\u001B[2m│ \u001B[0m\u001B[94mif\u001B[0m _is_path(name_or_buffer): \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m❱ \u001B[0m 271 \u001B[2m│ │ \u001B[0m\u001B[94mreturn\u001B[0m _open_file(name_or_buffer, mode) \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 272 \u001B[0m\u001B[2m│ \u001B[0m\u001B[94melse\u001B[0m: \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 273 \u001B[0m\u001B[2m│ │ \u001B[0m\u001B[94mif\u001B[0m \u001B[33m'\u001B[0m\u001B[33mw\u001B[0m\u001B[33m'\u001B[0m \u001B[95min\u001B[0m mode: \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 274 \u001B[0m\u001B[2m│ │ │ \u001B[0m\u001B[94mreturn\u001B[0m _open_buffer_writer(name_or_buffer) \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2;33m/home/zhud/anaconda3/envs/eye/lib/python3.9/site-packages/torch/\u001B[0m\u001B[1;33mserialization.py\u001B[0m:\u001B[94m252\u001B[0m in \u001B[92m__init__\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 249 \u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 250 \u001B[0m\u001B[94mclass\u001B[0m \u001B[4;92m_open_file\u001B[0m(_opener): \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 251 \u001B[0m\u001B[2m│ \u001B[0m\u001B[94mdef\u001B[0m \u001B[92m__init__\u001B[0m(\u001B[96mself\u001B[0m, name, mode): \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[31m❱ \u001B[0m 252 \u001B[2m│ │ \u001B[0m\u001B[96msuper\u001B[0m().\u001B[92m__init__\u001B[0m(\u001B[96mopen\u001B[0m(name, mode)) \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 253 \u001B[0m\u001B[2m│ \u001B[0m \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 254 \u001B[0m\u001B[2m│ \u001B[0m\u001B[94mdef\u001B[0m \u001B[92m__exit__\u001B[0m(\u001B[96mself\u001B[0m, *args): \u001B[31m│\u001B[0m\n", + "\u001B[31m│\u001B[0m \u001B[2m 255 \u001B[0m\u001B[2m│ │ \u001B[0m\u001B[96mself\u001B[0m.file_like.close() \u001B[31m│\u001B[0m\n", + "\u001B[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001B[0m\n", + "\u001B[1;91mFileNotFoundError: \u001B[0m\u001B[1m[\u001B[0mErrno \u001B[1;36m2\u001B[0m\u001B[1m]\u001B[0m No such file or directory: \n", + "\u001B[32m'/home/zhud/project/blip2/lavis/output/BLIP2/Vicuna_pretrain_stage2_cc/20230405233/checkpoint_3.pth'\u001B[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "task = tasks.setup_task(cfg)\n", + "model = task.build_model(cfg)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ba874036", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'/ibex/project/c2133/vicuna'" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "markdown", + "id": "bf1c4e1c", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Load Checkpoint" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a2a7f2bd", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "ckpt_path = '/ibex/project/c2133/vicuna_ckpt_test/Vicuna_prompt_stage2_laion/20230410145/checkpoint_4.pth'\n", + "ckpt = torch.load(ckpt_path, map_location=\"cpu\")\n", + "msg = model.load_state_dict(ckpt['model'], strict=False)\n", + "model = model.to(device)" + ] + }, + { + "cell_type": "markdown", + "id": "035a495f", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Example of Tokenizer" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "3426ae10", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "texts = [\"A chat\", \"The assistant gives helpful\"]\n", + "\n", + "llama_tokens = model.llama_tokenizer(\n", + " texts, \n", + " return_tensors=\"pt\", \n", + " padding=\"longest\",\n", + " truncation=True,\n", + " max_length=10).to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "376400a4", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "texts = \"The assistant gives helpful\"\n", + "\n", + "llama_tokens = model.llama_tokenizer(\n", + " texts, \n", + " return_tensors=\"pt\", \n", + " padding=\"longest\",\n", + " truncation=True,\n", + " max_length=10).to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "6988ee66", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 5])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "llama_tokens.attention_mask.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "dc9e376d", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "targets = llama_tokens.input_ids.masked_fill(\n", + " llama_tokens.input_ids == model.llama_tokenizer.pad_token_id, -100\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e458fa52", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([2, 3])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.ones([targets.shape[0], targets.shape[0]+1]).shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "24607f7a", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "text = \\\n", + "\"### Human: What's your name?\" \\\n", + "\"### Assistant: \"\n", + "\n", + "\n", + "llama_tokens = model.llama_tokenizer(\n", + " text, \n", + " return_tensors=\"pt\", \n", + " ).to(device)" + ] + }, + { + "cell_type": "markdown", + "id": "5e69d3e1", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Example of Emb Input" + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "id": "205b092f", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "​\n", + "\n", + "I'm sorry, I am an AI language model and do not have a physical form or a name. My purpose is to assist you with any questions or tasks you may have to the best of my ability. Is there anything specific you would like help with?\n", + "###\n" + ] + } + ], + "source": [ + "inputs_embeds = model.llama_model.model.embed_tokens(llama_tokens.input_ids)\n", + "outputs = model.llama_model.generate(\n", + " inputs_embeds=inputs_embeds,\n", + " query_embeds=None,\n", + " attention_mask=llama_tokens.attention_mask,\n", + " max_new_tokens=500,\n", + " stopping_criteria=stopping_criteria,\n", + " )\n", + "output_text = model.llama_tokenizer.decode(outputs[0])\n", + "print(output_text)" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "id": "561b42f5", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 16, 5120])" + ] + }, + "execution_count": 189, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inputs_embeds.shape" + ] + }, + { + "cell_type": "markdown", + "id": "a1694ad6", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Example of ID Input" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1dc7841", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "outputs = model.llama_model.generate(\n", + " input_ids=llama_tokens.input_ids,\n", + " query_embeds=None,\n", + " attention_mask=llama_tokens.attention_mask,\n", + " max_new_tokens=500,\n", + " stopping_criteria=stopping_criteria,\n", + " )\n", + "output_text = model.llama_tokenizer.decode(outputs[0])\n", + "print(output_text)" + ] + }, + { + "cell_type": "markdown", + "id": "19dd1f9d", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [] + }, + { + "cell_type": "markdown", + "id": "468ac97e", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Example of Mixed Input" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "4af3a9bf", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "ckpt_path = '/home/zhud/project/blip2/lavis/output/BLIP2/Vicuna_pretrain_stage2_cc/20230408015/checkpoint_2.pth'\n", + "ckpt = torch.load(ckpt_path, map_location=\"cpu\")\n", + "msg = model.load_state_dict(ckpt['model'], strict=False)\n", + "model = model.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "c3148611", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# Load the image using PIL\n", + "image = Image.open('test_img5.jpg').convert('RGB')\n", + "image = vis_processor(image).unsqueeze(0).to(device)\n", + "inputs_llama, atts_llama = model.encode_img(image)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "07b82707", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "text = \\\n", + "\"A chat between a curious human and an artificial intelligence assistant. \" \\\n", + "\"The assistant gives helpful, detailed, and polite answers to the human's questions. \"\\\n", + "\"Human may ask questions related to a given image. \" \\\n", + "\"The image will be wrapped as IMAGE_CONTENT \" \\\n", + "\"### Human: To_Split \" \\\n", + "\"### Assistant: Received the image. \" \\\n", + "\"### Human: Describe the image in detail. Say everthing you see. Describe all the things.\" \\\n", + "\"### Assistant: \"\n", + "\n", + "\n", + "text = \\\n", + "\"A chat between a curious human and an artificial intelligence assistant. \" \\\n", + "\"The assistant gives helpful, detailed, and polite answers to the human's questions. \"\\\n", + "\"Human may ask questions related to a given image. \" \\\n", + "\"The image will be wrapped as IMAGE_CONTENT \" \\\n", + "\"### Human: Describe the image in detail. Say everthing you see. To_Split \" \\\n", + "\"### Assistant: \"\n", + "\n", + "text = \\\n", + "\"### Human: Describe the image in detail. Say everthing you see. To_Split \" \\\n", + "\"### Assistant: \"\n", + "\n", + "\n", + "\n", + "# text = \\\n", + "# \"A chat between a curious human and an artificial intelligence assistant. \" \\\n", + "# \"The assistant gives helpful, detailed, and polite answers to the human's questions. \"\\\n", + "# \"Human may ask questions related to a given image. \" \\\n", + "# \"The image will be wrapped as IMAGE_CONTENT \" \\\n", + "# \"### Human: To_Split \" \\\n", + "# \"### Assistant: Received the image. \" \\\n", + "# \"### Human: This is a draft of a website. Give me the html code to write this website. \" \\\n", + "# \"Btw, you need to come up with some jokes in the website to fill the placeholders. \" \\\n", + "# \"Also, make the website colorful and vivid. \" \\\n", + "# \"### Assistant: \"\n", + "\n", + "\n", + "# text = \\\n", + "# \"Return what the human says. \" \\\n", + "# \"### Human: There is a big elephant in the sky. \" \\\n", + "# \"### Assistant: There is a big elephant in the sky. \" \\\n", + "# \"### Human: fdjlks klcznv_l1 \" \\\n", + "# \"### Assistant: fdjlks klcznv_l1 \" \\\n", + "# \"### Human: To_Split \" \\\n", + "# \"### Assistant: \"\n", + "\n", + "\n", + "text_1, text_2 = text.split('To_Split')\n", + "\n", + "text_1_tokens = model.llama_tokenizer(text_1, return_tensors=\"pt\").to(device)\n", + "text_2_tokens = model.llama_tokenizer(text_2, return_tensors=\"pt\", add_special_tokens=False).to(device)\n", + "text_1_emb = model.llama_model.model.embed_tokens(text_1_tokens.input_ids)\n", + "text_2_emb = model.llama_model.model.embed_tokens(text_2_tokens.input_ids)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "136b9e97", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "The image shows a small bird perched on a tree stump, with a camera lens in the background\n", + "\n", + "The bird is a small bird, with a bright yellow beak and black feathers. It is perched on a tree stump, with its wings spread out and its beak open. The bird is looking to the left, as if it is about to take off.\n", + "\n", + "The camera lens in the background is a large, black lens with a silver ring around the front. The lens is attached to a camera, which is not visible in the image. The lens is pointed at the bird, with the camera's viewfinder showing the bird in the center of the frame.\n", + "\n", + "The background of the image is a forest, with trees and foliage visible in the distance. The trees are covered in leaves, and there is a thick layer of mist or fog in the air, which gives the image a dreamy, ethereal quality.\n", + "\n", + "The lighting in the image is soft and diffused, with the sun shining through the trees and casting a warm, golden light on the bird and the tree stump. The lighting creates deep shadows in the forest, which add to the sense of mystery and wonder in the image.\n", + "\n", + "The overall effect of the image is one of peacefulness and tranquility, with the bird and the forest creating a sense of calm and serenity. The image is beautifully composed, with the bird and the camera lens creating a visual balance that draws the viewer's eye to the center of the frame.\n", + "###\n" + ] + } + ], + "source": [ + "outputs = model.llama_model.generate(\n", + " inputs_embeds=torch.concat([text_1_emb, inputs_llama, text_2_emb], dim=1),\n", + " query_embeds=None,\n", + " attention_mask=torch.concat([text_1_tokens.attention_mask, atts_llama, text_2_tokens.attention_mask], dim=1),\n", + " max_new_tokens=600,\n", + " stopping_criteria=stopping_criteria,\n", + " )\n", + "output_text = model.llama_tokenizer.decode(outputs[0])\n", + "print(output_text)" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "54cc3d4a", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "with open('lavis/prompts/image_caption.txt', 'r') as f:\n", + " prompts = f.read().splitlines()" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "f52cd85c", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "prompt_token = model.llama_tokenizer(prompts, return_tensors=\"pt\", padding=\"longest\",)" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "4b0cf1d0", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(15, 6), (16, 11), (17, 17), (18, 17), (19, 27), (20, 18), (21, 21), (22, 4), (23, 6), (24, 2)]\n" + ] + } + ], + "source": [ + "\n", + "\n", + "my_list = prompt_token.attention_mask.sum(1).numpy()\n", + "counts = {}\n", + "\n", + "for element in my_list:\n", + " if element in counts:\n", + " counts[element] += 1\n", + " else:\n", + " counts[element] = 1\n", + "\n", + "print(sorted(counts.items(), key=lambda item: item[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "f7919e93", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 1, 2, 1, 2]\n" + ] + } + ], + "source": [ + "a,b = [1,1,1], [2,2,2]\n", + "c = [i for pair in zip(a,b) for i in pair]\n", + "print(c)" + ] + }, + { + "cell_type": "markdown", + "id": "3c64a037", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Example of Image Input" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "87164578", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a bird eating from a bird feeder\n", + "\n", + "bird feeder, bird feeder, bird feeder, bird feeder, bird feeder, bird feeder, bird\n", + "bird feeder, bird feeder, bird feeder, bird feeder, bird feeder, bird feeder, bird\n", + "bird feeder, bird feeder, bird feeder, bird feeder, bird feeder, bird feeder, bird\n", + "bird feeder, bird feeder, bird feeder\n" + ] + } + ], + "source": [ + "inputs_embeds = model.llama_model.model.embed_tokens(llama_tokens.input_ids)\n", + "bos_embeds = model.llama_model.model.embed_tokens(torch.tensor(model.llama_tokenizer.bos_token_id, device=device))[None, None]\n", + "outputs = model.llama_model.generate(\n", + " inputs_embeds=torch.concat([bos_embeds, inputs_llama], dim=1),\n", + " query_embeds=None,\n", + " attention_mask=torch.concat([atts_llama[:, :1], atts_llama], dim=1),\n", + " max_new_tokens=100,\n", + " stopping_criteria=stopping_criteria,\n", + " )\n", + "output_text = model.llama_tokenizer.decode(outputs[0])\n", + "print(output_text)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "eye", + "language": "python", + "name": "eye" + }, + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/environment.yml b/environment.yml new file mode 100644 index 0000000000000000000000000000000000000000..bd7d73e43166b529932197a683047e32cc9b33f4 --- /dev/null +++ b/environment.yml @@ -0,0 +1,56 @@ +name: minigpt4 +channels: + - pytorch + - defaults +dependencies: + - python=3.9 + - pip + - pytorch=1.12.1 + - pytorch-mutex=1.0=cuda + - torchaudio=0.12.1 + - torchvision=0.13.1 + - pip: + - accelerate==0.16.0 + - aiohttp==3.8.4 + - aiosignal==1.3.1 + - async-timeout==4.0.2 + - attrs==22.2.0 + - bitsandbytes==0.37.0 + - cchardet==2.1.7 + - chardet==5.1.0 + - contourpy==1.0.7 + - cycler==0.11.0 + - filelock==3.9.0 + - fonttools==4.38.0 + - frozenlist==1.3.3 + - huggingface-hub==0.12.1 + - importlib-resources==5.12.0 + - kiwisolver==1.4.4 + - matplotlib==3.7.0 + - multidict==6.0.4 + - openai==0.27.0 + - packaging==23.0 + - psutil==5.9.4 + - pycocotools==2.0.6 + - pyparsing==3.0.9 + - python-dateutil==2.8.2 + - pyyaml==6.0 + - regex==2022.10.31 + - tokenizers==0.13.2 + - tqdm==4.64.1 + - transformers==4.28.0 + - timm==0.6.13 + - spacy==3.5.1 + - webdataset==0.2.48 + - scikit-learn==1.2.2 + - scipy==1.10.1 + - yarl==1.8.2 + - zipp==3.14.0 + - tenacity==8.2.2 + - peft + - pycocoevalcap + - sentence-transformers + - umap-learn + - notebook + - gradio + - wandb diff --git a/eval_configs/minigpt4.yaml b/eval_configs/minigpt4.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2cf7e84d15541548a4c72079814703c5c0174660 --- /dev/null +++ b/eval_configs/minigpt4.yaml @@ -0,0 +1,30 @@ + # Copyright (c) 2022, salesforce.com, inc. + # All rights reserved. + # SPDX-License-Identifier: BSD-3-Clause + # For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause + +model: + arch: mini_gpt4 + model_type: pretrain_vicuna + freeze_vit: True + freeze_qformer: True + max_txt_len: 160 + end_sym: "###" + prompt_path: "prompts/alignment.txt" + prompt_template: '###Human: {} ###Assistant: ' + ckpt: '/ibex/project/c2133/vicuna_ckpt_test/Vicuna_stage3_align/20230412191_laion_ckpt3/checkpoint_1.pth' + + +datasets: + cc_align: + vis_processor: + train: + name: "blip2_image_eval" + image_size: 224 + text_processor: + train: + name: "blip_caption" + +run: + task: image_text_pretrain + diff --git a/examples/ad_1.png b/examples/ad_1.png new file mode 100644 index 0000000000000000000000000000000000000000..d0378e43e9a0e797b2ab32f4d8f6261fa2224408 Binary files /dev/null and b/examples/ad_1.png differ diff --git a/examples/ad_2.png b/examples/ad_2.png new file mode 100644 index 0000000000000000000000000000000000000000..674248b723bee885c43a55d85d83ea1c0fa41477 Binary files /dev/null and b/examples/ad_2.png differ diff --git a/examples/cook_1.png b/examples/cook_1.png new file mode 100644 index 0000000000000000000000000000000000000000..d8cdb45c98492afd4f975b8626bb590b580616a5 Binary files /dev/null and b/examples/cook_1.png differ diff --git a/examples/cook_2.png b/examples/cook_2.png new file mode 100644 index 0000000000000000000000000000000000000000..d08272b3733dda976bfa78733d9ca4eb544fee52 Binary files /dev/null and b/examples/cook_2.png differ diff --git a/examples/describe_1.png b/examples/describe_1.png new file mode 100644 index 0000000000000000000000000000000000000000..02f3c92f54749fa354a5f8c617f24301728555b2 Binary files /dev/null and b/examples/describe_1.png differ diff --git a/examples/describe_2.png b/examples/describe_2.png new file mode 100644 index 0000000000000000000000000000000000000000..20bf8c7cd86c03f9ed77f95d912057438997277d Binary files /dev/null and b/examples/describe_2.png differ diff --git a/examples/fact_1.png b/examples/fact_1.png new file mode 100644 index 0000000000000000000000000000000000000000..1f7522871916c3d1bd113cfb88c45386d8abda7a Binary files /dev/null and b/examples/fact_1.png differ diff --git a/examples/fact_2.png b/examples/fact_2.png new file mode 100644 index 0000000000000000000000000000000000000000..de6ef53ef7afd72894711a3a5288a24d62c39182 Binary files /dev/null and b/examples/fact_2.png differ diff --git a/examples/fix_1.png b/examples/fix_1.png new file mode 100644 index 0000000000000000000000000000000000000000..023cfe6610747868805c70001e14f2b408f3cebb Binary files /dev/null and b/examples/fix_1.png differ diff --git a/examples/fix_2.png b/examples/fix_2.png new file mode 100644 index 0000000000000000000000000000000000000000..f60da5ff9bdef7018e98a92b19c0e59d31acd059 Binary files /dev/null and b/examples/fix_2.png differ diff --git a/examples/fun_1.png b/examples/fun_1.png new file mode 100644 index 0000000000000000000000000000000000000000..f720ea603f88019e24dbcb569328c3083c832baf Binary files /dev/null and b/examples/fun_1.png differ diff --git a/examples/fun_2.png b/examples/fun_2.png new file mode 100644 index 0000000000000000000000000000000000000000..1d37a8068feda3f7ecc2d0b22893d26071e68b64 Binary files /dev/null and b/examples/fun_2.png differ diff --git a/examples/logo_1.png b/examples/logo_1.png new file mode 100644 index 0000000000000000000000000000000000000000..8bbe438bdc05ce023251045575c6b7e7b04f210f Binary files /dev/null and b/examples/logo_1.png differ diff --git a/examples/op_1.png b/examples/op_1.png new file mode 100644 index 0000000000000000000000000000000000000000..3dbb2ff51ca08f62171f48167bbb97ad604cc4d0 Binary files /dev/null and b/examples/op_1.png differ diff --git a/examples/op_2.png b/examples/op_2.png new file mode 100644 index 0000000000000000000000000000000000000000..2cd3e1f8b0326dea14d45bf866b244deb38ef409 Binary files /dev/null and b/examples/op_2.png differ diff --git a/examples/people_1.png b/examples/people_1.png new file mode 100644 index 0000000000000000000000000000000000000000..7e95c42c710aef5efe94a52da280fd7451f185d7 Binary files /dev/null and b/examples/people_1.png differ diff --git a/examples/people_2.png b/examples/people_2.png new file mode 100644 index 0000000000000000000000000000000000000000..aec6c83b217c96af91668dbc566e05a14238b2a8 Binary files /dev/null and b/examples/people_2.png differ diff --git a/examples/rhyme_1.png b/examples/rhyme_1.png new file mode 100644 index 0000000000000000000000000000000000000000..7d133878d8b534867253c7be7b2805faffbd6ad7 Binary files /dev/null and b/examples/rhyme_1.png differ diff --git a/examples/rhyme_2.png b/examples/rhyme_2.png new file mode 100644 index 0000000000000000000000000000000000000000..6cf9bf8958302e461dec8b58dd7cbbe2224a8e5c Binary files /dev/null and b/examples/rhyme_2.png differ diff --git a/examples/story_1.png b/examples/story_1.png new file mode 100644 index 0000000000000000000000000000000000000000..3eb6ccb93fb5c866eeb758ba962904e5c3d57875 Binary files /dev/null and b/examples/story_1.png differ diff --git a/examples/story_2.png b/examples/story_2.png new file mode 100644 index 0000000000000000000000000000000000000000..9d37142a9ae32f20d47ebd10cf1c395f10b363f7 Binary files /dev/null and b/examples/story_2.png differ diff --git a/examples/web_1.png b/examples/web_1.png new file mode 100644 index 0000000000000000000000000000000000000000..8943842c08609713b78d95ab3b5c418995569505 Binary files /dev/null and b/examples/web_1.png differ diff --git a/examples/wop_1.png b/examples/wop_1.png new file mode 100644 index 0000000000000000000000000000000000000000..88f37d672bb2dd3dac34caced2ed4bebcfe15412 Binary files /dev/null and b/examples/wop_1.png differ diff --git a/examples/wop_2.png b/examples/wop_2.png new file mode 100644 index 0000000000000000000000000000000000000000..8255974176014db0b388617821630bdb438b5e6b Binary files /dev/null and b/examples/wop_2.png differ diff --git a/minigpt4/__init__.py b/minigpt4/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ec06cef0e2e4e39e450746b0f3136776f6bcf143 --- /dev/null +++ b/minigpt4/__init__.py @@ -0,0 +1,31 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import os +import sys + +from omegaconf import OmegaConf + +from minigpt4.common.registry import registry + +from minigpt4.datasets.builders import * +from minigpt4.models import * +from minigpt4.processors import * +from minigpt4.tasks import * + + +root_dir = os.path.dirname(os.path.abspath(__file__)) +default_cfg = OmegaConf.load(os.path.join(root_dir, "configs/default.yaml")) + +registry.register_path("library_root", root_dir) +repo_root = os.path.join(root_dir, "..") +registry.register_path("repo_root", repo_root) +cache_root = os.path.join(repo_root, default_cfg.env.cache_root) +registry.register_path("cache_root", cache_root) + +registry.register("MAX_INT", sys.maxsize) +registry.register("SPLIT_NAMES", ["train", "val", "test"]) diff --git a/minigpt4/common/__init__.py b/minigpt4/common/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/minigpt4/common/config.py b/minigpt4/common/config.py new file mode 100644 index 0000000000000000000000000000000000000000..32f58a6ba471fb448d71302f746ea82593a0b52a --- /dev/null +++ b/minigpt4/common/config.py @@ -0,0 +1,468 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import logging +import json +from typing import Dict + +from omegaconf import OmegaConf +from minigpt4.common.registry import registry + + +class Config: + def __init__(self, args): + self.config = {} + + self.args = args + + # Register the config and configuration for setup + registry.register("configuration", self) + + user_config = self._build_opt_list(self.args.options) + + config = OmegaConf.load(self.args.cfg_path) + + runner_config = self.build_runner_config(config) + model_config = self.build_model_config(config, **user_config) + dataset_config = self.build_dataset_config(config) + + # Validate the user-provided runner configuration + # model and dataset configuration are supposed to be validated by the respective classes + # [TODO] validate the model/dataset configuration + # self._validate_runner_config(runner_config) + + # Override the default configuration with user options. + self.config = OmegaConf.merge( + runner_config, model_config, dataset_config, user_config + ) + + def _validate_runner_config(self, runner_config): + """ + This method validates the configuration, such that + 1) all the user specified options are valid; + 2) no type mismatches between the user specified options and the config. + """ + runner_config_validator = create_runner_config_validator() + runner_config_validator.validate(runner_config) + + def _build_opt_list(self, opts): + opts_dot_list = self._convert_to_dot_list(opts) + return OmegaConf.from_dotlist(opts_dot_list) + + @staticmethod + def build_model_config(config, **kwargs): + model = config.get("model", None) + assert model is not None, "Missing model configuration file." + + model_cls = registry.get_model_class(model.arch) + assert model_cls is not None, f"Model '{model.arch}' has not been registered." + + model_type = kwargs.get("model.model_type", None) + if not model_type: + model_type = model.get("model_type", None) + # else use the model type selected by user. + + assert model_type is not None, "Missing model_type." + + model_config_path = model_cls.default_config_path(model_type=model_type) + + model_config = OmegaConf.create() + # hiararchy override, customized config > default config + model_config = OmegaConf.merge( + model_config, + OmegaConf.load(model_config_path), + {"model": config["model"]}, + ) + + return model_config + + @staticmethod + def build_runner_config(config): + return {"run": config.run} + + @staticmethod + def build_dataset_config(config): + datasets = config.get("datasets", None) + if datasets is None: + raise KeyError( + "Expecting 'datasets' as the root key for dataset configuration." + ) + + dataset_config = OmegaConf.create() + + for dataset_name in datasets: + builder_cls = registry.get_builder_class(dataset_name) + + dataset_config_type = datasets[dataset_name].get("type", "default") + dataset_config_path = builder_cls.default_config_path( + type=dataset_config_type + ) + + # hiararchy override, customized config > default config + dataset_config = OmegaConf.merge( + dataset_config, + OmegaConf.load(dataset_config_path), + {"datasets": {dataset_name: config["datasets"][dataset_name]}}, + ) + + return dataset_config + + def _convert_to_dot_list(self, opts): + if opts is None: + opts = [] + + if len(opts) == 0: + return opts + + has_equal = opts[0].find("=") != -1 + + if has_equal: + return opts + + return [(opt + "=" + value) for opt, value in zip(opts[0::2], opts[1::2])] + + def get_config(self): + return self.config + + @property + def run_cfg(self): + return self.config.run + + @property + def datasets_cfg(self): + return self.config.datasets + + @property + def model_cfg(self): + return self.config.model + + def pretty_print(self): + logging.info("\n===== Running Parameters =====") + logging.info(self._convert_node_to_json(self.config.run)) + + logging.info("\n====== Dataset Attributes ======") + datasets = self.config.datasets + + for dataset in datasets: + if dataset in self.config.datasets: + logging.info(f"\n======== {dataset} =======") + dataset_config = self.config.datasets[dataset] + logging.info(self._convert_node_to_json(dataset_config)) + else: + logging.warning(f"No dataset named '{dataset}' in config. Skipping") + + logging.info(f"\n====== Model Attributes ======") + logging.info(self._convert_node_to_json(self.config.model)) + + def _convert_node_to_json(self, node): + container = OmegaConf.to_container(node, resolve=True) + return json.dumps(container, indent=4, sort_keys=True) + + def to_dict(self): + return OmegaConf.to_container(self.config) + + +def node_to_dict(node): + return OmegaConf.to_container(node) + + +class ConfigValidator: + """ + This is a preliminary implementation to centralize and validate the configuration. + May be altered in the future. + + A helper class to validate configurations from yaml file. + + This serves the following purposes: + 1. Ensure all the options in the yaml are defined, raise error if not. + 2. when type mismatches are found, the validator will raise an error. + 3. a central place to store and display helpful messages for supported configurations. + + """ + + class _Argument: + def __init__(self, name, choices=None, type=None, help=None): + self.name = name + self.val = None + self.choices = choices + self.type = type + self.help = help + + def __str__(self): + s = f"{self.name}={self.val}" + if self.type is not None: + s += f", ({self.type})" + if self.choices is not None: + s += f", choices: {self.choices}" + if self.help is not None: + s += f", ({self.help})" + return s + + def __init__(self, description): + self.description = description + + self.arguments = dict() + + self.parsed_args = None + + def __getitem__(self, key): + assert self.parsed_args is not None, "No arguments parsed yet." + + return self.parsed_args[key] + + def __str__(self) -> str: + return self.format_help() + + def add_argument(self, *args, **kwargs): + """ + Assume the first argument is the name of the argument. + """ + self.arguments[args[0]] = self._Argument(*args, **kwargs) + + def validate(self, config=None): + """ + Convert yaml config (dict-like) to list, required by argparse. + """ + for k, v in config.items(): + assert ( + k in self.arguments + ), f"""{k} is not a valid argument. Support arguments are {self.format_arguments()}.""" + + if self.arguments[k].type is not None: + try: + self.arguments[k].val = self.arguments[k].type(v) + except ValueError: + raise ValueError(f"{k} is not a valid {self.arguments[k].type}.") + + if self.arguments[k].choices is not None: + assert ( + v in self.arguments[k].choices + ), f"""{k} must be one of {self.arguments[k].choices}.""" + + return config + + def format_arguments(self): + return str([f"{k}" for k in sorted(self.arguments.keys())]) + + def format_help(self): + # description + key-value pair string for each argument + help_msg = str(self.description) + return help_msg + ", available arguments: " + self.format_arguments() + + def print_help(self): + # display help message + print(self.format_help()) + + +def create_runner_config_validator(): + validator = ConfigValidator(description="Runner configurations") + + validator.add_argument( + "runner", + type=str, + choices=["runner_base", "runner_iter"], + help="""Runner to use. The "runner_base" uses epoch-based training while iter-based + runner runs based on iters. Default: runner_base""", + ) + # add argumetns for training dataset ratios + validator.add_argument( + "train_dataset_ratios", + type=Dict[str, float], + help="""Ratios of training dataset. This is used in iteration-based runner. + Do not support for epoch-based runner because how to define an epoch becomes tricky. + Default: None""", + ) + validator.add_argument( + "max_iters", + type=float, + help="Maximum number of iterations to run.", + ) + validator.add_argument( + "max_epoch", + type=int, + help="Maximum number of epochs to run.", + ) + # add arguments for iters_per_inner_epoch + validator.add_argument( + "iters_per_inner_epoch", + type=float, + help="Number of iterations per inner epoch. This is required when runner is runner_iter.", + ) + lr_scheds_choices = registry.list_lr_schedulers() + validator.add_argument( + "lr_sched", + type=str, + choices=lr_scheds_choices, + help="Learning rate scheduler to use, from {}".format(lr_scheds_choices), + ) + task_choices = registry.list_tasks() + validator.add_argument( + "task", + type=str, + choices=task_choices, + help="Task to use, from {}".format(task_choices), + ) + # add arguments for init_lr + validator.add_argument( + "init_lr", + type=float, + help="Initial learning rate. This will be the learning rate after warmup and before decay.", + ) + # add arguments for min_lr + validator.add_argument( + "min_lr", + type=float, + help="Minimum learning rate (after decay).", + ) + # add arguments for warmup_lr + validator.add_argument( + "warmup_lr", + type=float, + help="Starting learning rate for warmup.", + ) + # add arguments for learning rate decay rate + validator.add_argument( + "lr_decay_rate", + type=float, + help="Learning rate decay rate. Required if using a decaying learning rate scheduler.", + ) + # add arguments for weight decay + validator.add_argument( + "weight_decay", + type=float, + help="Weight decay rate.", + ) + # add arguments for training batch size + validator.add_argument( + "batch_size_train", + type=int, + help="Training batch size.", + ) + # add arguments for evaluation batch size + validator.add_argument( + "batch_size_eval", + type=int, + help="Evaluation batch size, including validation and testing.", + ) + # add arguments for number of workers for data loading + validator.add_argument( + "num_workers", + help="Number of workers for data loading.", + ) + # add arguments for warm up steps + validator.add_argument( + "warmup_steps", + type=int, + help="Number of warmup steps. Required if a warmup schedule is used.", + ) + # add arguments for random seed + validator.add_argument( + "seed", + type=int, + help="Random seed.", + ) + # add arguments for output directory + validator.add_argument( + "output_dir", + type=str, + help="Output directory to save checkpoints and logs.", + ) + # add arguments for whether only use evaluation + validator.add_argument( + "evaluate", + help="Whether to only evaluate the model. If true, training will not be performed.", + ) + # add arguments for splits used for training, e.g. ["train", "val"] + validator.add_argument( + "train_splits", + type=list, + help="Splits to use for training.", + ) + # add arguments for splits used for validation, e.g. ["val"] + validator.add_argument( + "valid_splits", + type=list, + help="Splits to use for validation. If not provided, will skip the validation.", + ) + # add arguments for splits used for testing, e.g. ["test"] + validator.add_argument( + "test_splits", + type=list, + help="Splits to use for testing. If not provided, will skip the testing.", + ) + # add arguments for accumulating gradient for iterations + validator.add_argument( + "accum_grad_iters", + type=int, + help="Number of iterations to accumulate gradient for.", + ) + + # ====== distributed training ====== + validator.add_argument( + "device", + type=str, + choices=["cpu", "cuda"], + help="Device to use. Support 'cuda' or 'cpu' as for now.", + ) + validator.add_argument( + "world_size", + type=int, + help="Number of processes participating in the job.", + ) + validator.add_argument("dist_url", type=str) + validator.add_argument("distributed", type=bool) + # add arguments to opt using distributed sampler during evaluation or not + validator.add_argument( + "use_dist_eval_sampler", + type=bool, + help="Whether to use distributed sampler during evaluation or not.", + ) + + # ====== task specific ====== + # generation task specific arguments + # add arguments for maximal length of text output + validator.add_argument( + "max_len", + type=int, + help="Maximal length of text output.", + ) + # add arguments for minimal length of text output + validator.add_argument( + "min_len", + type=int, + help="Minimal length of text output.", + ) + # add arguments number of beams + validator.add_argument( + "num_beams", + type=int, + help="Number of beams used for beam search.", + ) + + # vqa task specific arguments + # add arguments for number of answer candidates + validator.add_argument( + "num_ans_candidates", + type=int, + help="""For ALBEF and BLIP, these models first rank answers according to likelihood to select answer candidates.""", + ) + # add arguments for inference method + validator.add_argument( + "inference_method", + type=str, + choices=["genearte", "rank"], + help="""Inference method to use for question answering. If rank, requires a answer list.""", + ) + + # ====== model specific ====== + validator.add_argument( + "k_test", + type=int, + help="Number of top k most similar samples from ITC/VTC selection to be tested.", + ) + + return validator diff --git a/minigpt4/common/dist_utils.py b/minigpt4/common/dist_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..296a3c86f29c6e82fa8f1108c7dd9fa7d3e9ce45 --- /dev/null +++ b/minigpt4/common/dist_utils.py @@ -0,0 +1,137 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import datetime +import functools +import os + +import torch +import torch.distributed as dist +import timm.models.hub as timm_hub + + +def setup_for_distributed(is_master): + """ + This function disables printing when not in master process + """ + import builtins as __builtin__ + + builtin_print = __builtin__.print + + def print(*args, **kwargs): + force = kwargs.pop("force", False) + if is_master or force: + builtin_print(*args, **kwargs) + + __builtin__.print = print + + +def is_dist_avail_and_initialized(): + if not dist.is_available(): + return False + if not dist.is_initialized(): + return False + return True + + +def get_world_size(): + if not is_dist_avail_and_initialized(): + return 1 + return dist.get_world_size() + + +def get_rank(): + if not is_dist_avail_and_initialized(): + return 0 + return dist.get_rank() + + +def is_main_process(): + return get_rank() == 0 + + +def init_distributed_mode(args): + if "RANK" in os.environ and "WORLD_SIZE" in os.environ: + args.rank = int(os.environ["RANK"]) + args.world_size = int(os.environ["WORLD_SIZE"]) + args.gpu = int(os.environ["LOCAL_RANK"]) + elif "SLURM_PROCID" in os.environ: + args.rank = int(os.environ["SLURM_PROCID"]) + args.gpu = args.rank % torch.cuda.device_count() + else: + print("Not using distributed mode") + args.distributed = False + return + + args.distributed = True + + torch.cuda.set_device(args.gpu) + args.dist_backend = "nccl" + print( + "| distributed init (rank {}, world {}): {}".format( + args.rank, args.world_size, args.dist_url + ), + flush=True, + ) + torch.distributed.init_process_group( + backend=args.dist_backend, + init_method=args.dist_url, + world_size=args.world_size, + rank=args.rank, + timeout=datetime.timedelta( + days=365 + ), # allow auto-downloading and de-compressing + ) + torch.distributed.barrier() + setup_for_distributed(args.rank == 0) + + +def get_dist_info(): + if torch.__version__ < "1.0": + initialized = dist._initialized + else: + initialized = dist.is_initialized() + if initialized: + rank = dist.get_rank() + world_size = dist.get_world_size() + else: # non-distributed training + rank = 0 + world_size = 1 + return rank, world_size + + +def main_process(func): + @functools.wraps(func) + def wrapper(*args, **kwargs): + rank, _ = get_dist_info() + if rank == 0: + return func(*args, **kwargs) + + return wrapper + + +def download_cached_file(url, check_hash=True, progress=False): + """ + Download a file from a URL and cache it locally. If the file already exists, it is not downloaded again. + If distributed, only the main process downloads the file, and the other processes wait for the file to be downloaded. + """ + + def get_cached_file_path(): + # a hack to sync the file path across processes + parts = torch.hub.urlparse(url) + filename = os.path.basename(parts.path) + cached_file = os.path.join(timm_hub.get_cache_dir(), filename) + + return cached_file + + if is_main_process(): + timm_hub.download_cached_file(url, check_hash, progress) + + if is_dist_avail_and_initialized(): + dist.barrier() + + return get_cached_file_path() diff --git a/minigpt4/common/gradcam.py b/minigpt4/common/gradcam.py new file mode 100644 index 0000000000000000000000000000000000000000..d53a5254d4b319eaf2cbfbd081b0ca8e38c5c7a0 --- /dev/null +++ b/minigpt4/common/gradcam.py @@ -0,0 +1,24 @@ +import numpy as np +from matplotlib import pyplot as plt +from scipy.ndimage import filters +from skimage import transform as skimage_transform + + +def getAttMap(img, attMap, blur=True, overlap=True): + attMap -= attMap.min() + if attMap.max() > 0: + attMap /= attMap.max() + attMap = skimage_transform.resize(attMap, (img.shape[:2]), order=3, mode="constant") + if blur: + attMap = filters.gaussian_filter(attMap, 0.02 * max(img.shape[:2])) + attMap -= attMap.min() + attMap /= attMap.max() + cmap = plt.get_cmap("jet") + attMapV = cmap(attMap) + attMapV = np.delete(attMapV, 3, 2) + if overlap: + attMap = ( + 1 * (1 - attMap**0.7).reshape(attMap.shape + (1,)) * img + + (attMap**0.7).reshape(attMap.shape + (1,)) * attMapV + ) + return attMap diff --git a/minigpt4/common/logger.py b/minigpt4/common/logger.py new file mode 100644 index 0000000000000000000000000000000000000000..6ccc100be114951acb6b97296244b939265400cf --- /dev/null +++ b/minigpt4/common/logger.py @@ -0,0 +1,195 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import datetime +import logging +import time +from collections import defaultdict, deque + +import torch +import torch.distributed as dist + +from minigpt4.common import dist_utils + + +class SmoothedValue(object): + """Track a series of values and provide access to smoothed values over a + window or the global series average. + """ + + def __init__(self, window_size=20, fmt=None): + if fmt is None: + fmt = "{median:.4f} ({global_avg:.4f})" + self.deque = deque(maxlen=window_size) + self.total = 0.0 + self.count = 0 + self.fmt = fmt + + def update(self, value, n=1): + self.deque.append(value) + self.count += n + self.total += value * n + + def synchronize_between_processes(self): + """ + Warning: does not synchronize the deque! + """ + if not dist_utils.is_dist_avail_and_initialized(): + return + t = torch.tensor([self.count, self.total], dtype=torch.float64, device="cuda") + dist.barrier() + dist.all_reduce(t) + t = t.tolist() + self.count = int(t[0]) + self.total = t[1] + + @property + def median(self): + d = torch.tensor(list(self.deque)) + return d.median().item() + + @property + def avg(self): + d = torch.tensor(list(self.deque), dtype=torch.float32) + return d.mean().item() + + @property + def global_avg(self): + return self.total / self.count + + @property + def max(self): + return max(self.deque) + + @property + def value(self): + return self.deque[-1] + + def __str__(self): + return self.fmt.format( + median=self.median, + avg=self.avg, + global_avg=self.global_avg, + max=self.max, + value=self.value, + ) + + +class MetricLogger(object): + def __init__(self, delimiter="\t"): + self.meters = defaultdict(SmoothedValue) + self.delimiter = delimiter + + def update(self, **kwargs): + for k, v in kwargs.items(): + if isinstance(v, torch.Tensor): + v = v.item() + assert isinstance(v, (float, int)) + self.meters[k].update(v) + + def __getattr__(self, attr): + if attr in self.meters: + return self.meters[attr] + if attr in self.__dict__: + return self.__dict__[attr] + raise AttributeError( + "'{}' object has no attribute '{}'".format(type(self).__name__, attr) + ) + + def __str__(self): + loss_str = [] + for name, meter in self.meters.items(): + loss_str.append("{}: {}".format(name, str(meter))) + return self.delimiter.join(loss_str) + + def global_avg(self): + loss_str = [] + for name, meter in self.meters.items(): + loss_str.append("{}: {:.4f}".format(name, meter.global_avg)) + return self.delimiter.join(loss_str) + + def synchronize_between_processes(self): + for meter in self.meters.values(): + meter.synchronize_between_processes() + + def add_meter(self, name, meter): + self.meters[name] = meter + + def log_every(self, iterable, print_freq, header=None): + i = 0 + if not header: + header = "" + start_time = time.time() + end = time.time() + iter_time = SmoothedValue(fmt="{avg:.4f}") + data_time = SmoothedValue(fmt="{avg:.4f}") + space_fmt = ":" + str(len(str(len(iterable)))) + "d" + log_msg = [ + header, + "[{0" + space_fmt + "}/{1}]", + "eta: {eta}", + "{meters}", + "time: {time}", + "data: {data}", + ] + if torch.cuda.is_available(): + log_msg.append("max mem: {memory:.0f}") + log_msg = self.delimiter.join(log_msg) + MB = 1024.0 * 1024.0 + for obj in iterable: + data_time.update(time.time() - end) + yield obj + iter_time.update(time.time() - end) + if i % print_freq == 0 or i == len(iterable) - 1: + eta_seconds = iter_time.global_avg * (len(iterable) - i) + eta_string = str(datetime.timedelta(seconds=int(eta_seconds))) + if torch.cuda.is_available(): + print( + log_msg.format( + i, + len(iterable), + eta=eta_string, + meters=str(self), + time=str(iter_time), + data=str(data_time), + memory=torch.cuda.max_memory_allocated() / MB, + ) + ) + else: + print( + log_msg.format( + i, + len(iterable), + eta=eta_string, + meters=str(self), + time=str(iter_time), + data=str(data_time), + ) + ) + i += 1 + end = time.time() + total_time = time.time() - start_time + total_time_str = str(datetime.timedelta(seconds=int(total_time))) + print( + "{} Total time: {} ({:.4f} s / it)".format( + header, total_time_str, total_time / len(iterable) + ) + ) + + +class AttrDict(dict): + def __init__(self, *args, **kwargs): + super(AttrDict, self).__init__(*args, **kwargs) + self.__dict__ = self + + +def setup_logger(): + logging.basicConfig( + level=logging.INFO if dist_utils.is_main_process() else logging.WARN, + format="%(asctime)s [%(levelname)s] %(message)s", + handlers=[logging.StreamHandler()], + ) diff --git a/minigpt4/common/optims.py b/minigpt4/common/optims.py new file mode 100644 index 0000000000000000000000000000000000000000..fd10715172cec4bc9980690ab3ec07cfe9117b38 --- /dev/null +++ b/minigpt4/common/optims.py @@ -0,0 +1,119 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import math + +from minigpt4.common.registry import registry + + +@registry.register_lr_scheduler("linear_warmup_step_lr") +class LinearWarmupStepLRScheduler: + def __init__( + self, + optimizer, + max_epoch, + min_lr, + init_lr, + decay_rate=1, + warmup_start_lr=-1, + warmup_steps=0, + **kwargs + ): + self.optimizer = optimizer + + self.max_epoch = max_epoch + self.min_lr = min_lr + + self.decay_rate = decay_rate + + self.init_lr = init_lr + self.warmup_steps = warmup_steps + self.warmup_start_lr = warmup_start_lr if warmup_start_lr >= 0 else init_lr + + def step(self, cur_epoch, cur_step): + if cur_epoch == 0: + warmup_lr_schedule( + step=cur_step, + optimizer=self.optimizer, + max_step=self.warmup_steps, + init_lr=self.warmup_start_lr, + max_lr=self.init_lr, + ) + else: + step_lr_schedule( + epoch=cur_epoch, + optimizer=self.optimizer, + init_lr=self.init_lr, + min_lr=self.min_lr, + decay_rate=self.decay_rate, + ) + + +@registry.register_lr_scheduler("linear_warmup_cosine_lr") +class LinearWarmupCosineLRScheduler: + def __init__( + self, + optimizer, + max_epoch, + iters_per_epoch, + min_lr, + init_lr, + warmup_steps=0, + warmup_start_lr=-1, + **kwargs + ): + self.optimizer = optimizer + + self.max_epoch = max_epoch + self.iters_per_epoch = iters_per_epoch + self.min_lr = min_lr + + self.init_lr = init_lr + self.warmup_steps = warmup_steps + self.warmup_start_lr = warmup_start_lr if warmup_start_lr >= 0 else init_lr + + def step(self, cur_epoch, cur_step): + total_cur_step = cur_epoch * self.iters_per_epoch + cur_step + if total_cur_step < self.warmup_steps: + warmup_lr_schedule( + step=cur_step, + optimizer=self.optimizer, + max_step=self.warmup_steps, + init_lr=self.warmup_start_lr, + max_lr=self.init_lr, + ) + else: + cosine_lr_schedule( + epoch=total_cur_step, + optimizer=self.optimizer, + max_epoch=self.max_epoch * self.iters_per_epoch, + init_lr=self.init_lr, + min_lr=self.min_lr, + ) + + +def cosine_lr_schedule(optimizer, epoch, max_epoch, init_lr, min_lr): + """Decay the learning rate""" + lr = (init_lr - min_lr) * 0.5 * ( + 1.0 + math.cos(math.pi * epoch / max_epoch) + ) + min_lr + for param_group in optimizer.param_groups: + param_group["lr"] = lr + + +def warmup_lr_schedule(optimizer, step, max_step, init_lr, max_lr): + """Warmup the learning rate""" + lr = min(max_lr, init_lr + (max_lr - init_lr) * step / max(max_step, 1)) + for param_group in optimizer.param_groups: + param_group["lr"] = lr + + +def step_lr_schedule(optimizer, epoch, init_lr, min_lr, decay_rate): + """Decay the learning rate""" + lr = max(min_lr, init_lr * (decay_rate**epoch)) + for param_group in optimizer.param_groups: + param_group["lr"] = lr diff --git a/minigpt4/common/registry.py b/minigpt4/common/registry.py new file mode 100644 index 0000000000000000000000000000000000000000..33dfe7692e401d1b2cb3c3d221a5787dca419b86 --- /dev/null +++ b/minigpt4/common/registry.py @@ -0,0 +1,329 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + + +class Registry: + mapping = { + "builder_name_mapping": {}, + "task_name_mapping": {}, + "processor_name_mapping": {}, + "model_name_mapping": {}, + "lr_scheduler_name_mapping": {}, + "runner_name_mapping": {}, + "state": {}, + "paths": {}, + } + + @classmethod + def register_builder(cls, name): + r"""Register a dataset builder to registry with key 'name' + + Args: + name: Key with which the builder will be registered. + + Usage: + + from minigpt4.common.registry import registry + from minigpt4.datasets.base_dataset_builder import BaseDatasetBuilder + """ + + def wrap(builder_cls): + from minigpt4.datasets.builders.base_dataset_builder import BaseDatasetBuilder + + assert issubclass( + builder_cls, BaseDatasetBuilder + ), "All builders must inherit BaseDatasetBuilder class, found {}".format( + builder_cls + ) + if name in cls.mapping["builder_name_mapping"]: + raise KeyError( + "Name '{}' already registered for {}.".format( + name, cls.mapping["builder_name_mapping"][name] + ) + ) + cls.mapping["builder_name_mapping"][name] = builder_cls + return builder_cls + + return wrap + + @classmethod + def register_task(cls, name): + r"""Register a task to registry with key 'name' + + Args: + name: Key with which the task will be registered. + + Usage: + + from minigpt4.common.registry import registry + """ + + def wrap(task_cls): + from minigpt4.tasks.base_task import BaseTask + + assert issubclass( + task_cls, BaseTask + ), "All tasks must inherit BaseTask class" + if name in cls.mapping["task_name_mapping"]: + raise KeyError( + "Name '{}' already registered for {}.".format( + name, cls.mapping["task_name_mapping"][name] + ) + ) + cls.mapping["task_name_mapping"][name] = task_cls + return task_cls + + return wrap + + @classmethod + def register_model(cls, name): + r"""Register a task to registry with key 'name' + + Args: + name: Key with which the task will be registered. + + Usage: + + from minigpt4.common.registry import registry + """ + + def wrap(model_cls): + from minigpt4.models import BaseModel + + assert issubclass( + model_cls, BaseModel + ), "All models must inherit BaseModel class" + if name in cls.mapping["model_name_mapping"]: + raise KeyError( + "Name '{}' already registered for {}.".format( + name, cls.mapping["model_name_mapping"][name] + ) + ) + cls.mapping["model_name_mapping"][name] = model_cls + return model_cls + + return wrap + + @classmethod + def register_processor(cls, name): + r"""Register a processor to registry with key 'name' + + Args: + name: Key with which the task will be registered. + + Usage: + + from minigpt4.common.registry import registry + """ + + def wrap(processor_cls): + from minigpt4.processors import BaseProcessor + + assert issubclass( + processor_cls, BaseProcessor + ), "All processors must inherit BaseProcessor class" + if name in cls.mapping["processor_name_mapping"]: + raise KeyError( + "Name '{}' already registered for {}.".format( + name, cls.mapping["processor_name_mapping"][name] + ) + ) + cls.mapping["processor_name_mapping"][name] = processor_cls + return processor_cls + + return wrap + + @classmethod + def register_lr_scheduler(cls, name): + r"""Register a model to registry with key 'name' + + Args: + name: Key with which the task will be registered. + + Usage: + + from minigpt4.common.registry import registry + """ + + def wrap(lr_sched_cls): + if name in cls.mapping["lr_scheduler_name_mapping"]: + raise KeyError( + "Name '{}' already registered for {}.".format( + name, cls.mapping["lr_scheduler_name_mapping"][name] + ) + ) + cls.mapping["lr_scheduler_name_mapping"][name] = lr_sched_cls + return lr_sched_cls + + return wrap + + @classmethod + def register_runner(cls, name): + r"""Register a model to registry with key 'name' + + Args: + name: Key with which the task will be registered. + + Usage: + + from minigpt4.common.registry import registry + """ + + def wrap(runner_cls): + if name in cls.mapping["runner_name_mapping"]: + raise KeyError( + "Name '{}' already registered for {}.".format( + name, cls.mapping["runner_name_mapping"][name] + ) + ) + cls.mapping["runner_name_mapping"][name] = runner_cls + return runner_cls + + return wrap + + @classmethod + def register_path(cls, name, path): + r"""Register a path to registry with key 'name' + + Args: + name: Key with which the path will be registered. + + Usage: + + from minigpt4.common.registry import registry + """ + assert isinstance(path, str), "All path must be str." + if name in cls.mapping["paths"]: + raise KeyError("Name '{}' already registered.".format(name)) + cls.mapping["paths"][name] = path + + @classmethod + def register(cls, name, obj): + r"""Register an item to registry with key 'name' + + Args: + name: Key with which the item will be registered. + + Usage:: + + from minigpt4.common.registry import registry + + registry.register("config", {}) + """ + path = name.split(".") + current = cls.mapping["state"] + + for part in path[:-1]: + if part not in current: + current[part] = {} + current = current[part] + + current[path[-1]] = obj + + # @classmethod + # def get_trainer_class(cls, name): + # return cls.mapping["trainer_name_mapping"].get(name, None) + + @classmethod + def get_builder_class(cls, name): + return cls.mapping["builder_name_mapping"].get(name, None) + + @classmethod + def get_model_class(cls, name): + return cls.mapping["model_name_mapping"].get(name, None) + + @classmethod + def get_task_class(cls, name): + return cls.mapping["task_name_mapping"].get(name, None) + + @classmethod + def get_processor_class(cls, name): + return cls.mapping["processor_name_mapping"].get(name, None) + + @classmethod + def get_lr_scheduler_class(cls, name): + return cls.mapping["lr_scheduler_name_mapping"].get(name, None) + + @classmethod + def get_runner_class(cls, name): + return cls.mapping["runner_name_mapping"].get(name, None) + + @classmethod + def list_runners(cls): + return sorted(cls.mapping["runner_name_mapping"].keys()) + + @classmethod + def list_models(cls): + return sorted(cls.mapping["model_name_mapping"].keys()) + + @classmethod + def list_tasks(cls): + return sorted(cls.mapping["task_name_mapping"].keys()) + + @classmethod + def list_processors(cls): + return sorted(cls.mapping["processor_name_mapping"].keys()) + + @classmethod + def list_lr_schedulers(cls): + return sorted(cls.mapping["lr_scheduler_name_mapping"].keys()) + + @classmethod + def list_datasets(cls): + return sorted(cls.mapping["builder_name_mapping"].keys()) + + @classmethod + def get_path(cls, name): + return cls.mapping["paths"].get(name, None) + + @classmethod + def get(cls, name, default=None, no_warning=False): + r"""Get an item from registry with key 'name' + + Args: + name (string): Key whose value needs to be retrieved. + default: If passed and key is not in registry, default value will + be returned with a warning. Default: None + no_warning (bool): If passed as True, warning when key doesn't exist + will not be generated. Useful for MMF's + internal operations. Default: False + """ + original_name = name + name = name.split(".") + value = cls.mapping["state"] + for subname in name: + value = value.get(subname, default) + if value is default: + break + + if ( + "writer" in cls.mapping["state"] + and value == default + and no_warning is False + ): + cls.mapping["state"]["writer"].warning( + "Key {} is not present in registry, returning default value " + "of {}".format(original_name, default) + ) + return value + + @classmethod + def unregister(cls, name): + r"""Remove an item from registry with key 'name' + + Args: + name: Key which needs to be removed. + Usage:: + + from mmf.common.registry import registry + + config = registry.unregister("config") + """ + return cls.mapping["state"].pop(name, None) + + +registry = Registry() diff --git a/minigpt4/common/utils.py b/minigpt4/common/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..d536eac1d32b35ad9e97abb29895120d850aacaf --- /dev/null +++ b/minigpt4/common/utils.py @@ -0,0 +1,424 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import io +import json +import logging +import os +import pickle +import re +import shutil +import urllib +import urllib.error +import urllib.request +from typing import Optional +from urllib.parse import urlparse + +import numpy as np +import pandas as pd +import yaml +from iopath.common.download import download +from iopath.common.file_io import file_lock, g_pathmgr +from minigpt4.common.registry import registry +from torch.utils.model_zoo import tqdm +from torchvision.datasets.utils import ( + check_integrity, + download_file_from_google_drive, + extract_archive, +) + + +def now(): + from datetime import datetime + + return datetime.now().strftime("%Y%m%d%H%M")[:-1] + + +def is_url(url_or_filename): + parsed = urlparse(url_or_filename) + return parsed.scheme in ("http", "https") + + +def get_cache_path(rel_path): + return os.path.expanduser(os.path.join(registry.get_path("cache_root"), rel_path)) + + +def get_abs_path(rel_path): + return os.path.join(registry.get_path("library_root"), rel_path) + + +def load_json(filename): + with open(filename, "r") as f: + return json.load(f) + + +# The following are adapted from torchvision and vissl +# torchvision: https://github.com/pytorch/vision +# vissl: https://github.com/facebookresearch/vissl/blob/main/vissl/utils/download.py + + +def makedir(dir_path): + """ + Create the directory if it does not exist. + """ + is_success = False + try: + if not g_pathmgr.exists(dir_path): + g_pathmgr.mkdirs(dir_path) + is_success = True + except BaseException: + print(f"Error creating directory: {dir_path}") + return is_success + + +def get_redirected_url(url: str): + """ + Given a URL, returns the URL it redirects to or the + original URL in case of no indirection + """ + import requests + + with requests.Session() as session: + with session.get(url, stream=True, allow_redirects=True) as response: + if response.history: + return response.url + else: + return url + + +def to_google_drive_download_url(view_url: str) -> str: + """ + Utility function to transform a view URL of google drive + to a download URL for google drive + Example input: + https://drive.google.com/file/d/137RyRjvTBkBiIfeYBNZBtViDHQ6_Ewsp/view + Example output: + https://drive.google.com/uc?export=download&id=137RyRjvTBkBiIfeYBNZBtViDHQ6_Ewsp + """ + splits = view_url.split("/") + assert splits[-1] == "view" + file_id = splits[-2] + return f"https://drive.google.com/uc?export=download&id={file_id}" + + +def download_google_drive_url(url: str, output_path: str, output_file_name: str): + """ + Download a file from google drive + Downloading an URL from google drive requires confirmation when + the file of the size is too big (google drive notifies that + anti-viral checks cannot be performed on such files) + """ + import requests + + with requests.Session() as session: + + # First get the confirmation token and append it to the URL + with session.get(url, stream=True, allow_redirects=True) as response: + for k, v in response.cookies.items(): + if k.startswith("download_warning"): + url = url + "&confirm=" + v + + # Then download the content of the file + with session.get(url, stream=True, verify=True) as response: + makedir(output_path) + path = os.path.join(output_path, output_file_name) + total_size = int(response.headers.get("Content-length", 0)) + with open(path, "wb") as file: + from tqdm import tqdm + + with tqdm(total=total_size) as progress_bar: + for block in response.iter_content( + chunk_size=io.DEFAULT_BUFFER_SIZE + ): + file.write(block) + progress_bar.update(len(block)) + + +def _get_google_drive_file_id(url: str) -> Optional[str]: + parts = urlparse(url) + + if re.match(r"(drive|docs)[.]google[.]com", parts.netloc) is None: + return None + + match = re.match(r"/file/d/(?P[^/]*)", parts.path) + if match is None: + return None + + return match.group("id") + + +def _urlretrieve(url: str, filename: str, chunk_size: int = 1024) -> None: + with open(filename, "wb") as fh: + with urllib.request.urlopen( + urllib.request.Request(url, headers={"User-Agent": "vissl"}) + ) as response: + with tqdm(total=response.length) as pbar: + for chunk in iter(lambda: response.read(chunk_size), ""): + if not chunk: + break + pbar.update(chunk_size) + fh.write(chunk) + + +def download_url( + url: str, + root: str, + filename: Optional[str] = None, + md5: Optional[str] = None, +) -> None: + """Download a file from a url and place it in root. + Args: + url (str): URL to download file from + root (str): Directory to place downloaded file in + filename (str, optional): Name to save the file under. + If None, use the basename of the URL. + md5 (str, optional): MD5 checksum of the download. If None, do not check + """ + root = os.path.expanduser(root) + if not filename: + filename = os.path.basename(url) + fpath = os.path.join(root, filename) + + makedir(root) + + # check if file is already present locally + if check_integrity(fpath, md5): + print("Using downloaded and verified file: " + fpath) + return + + # expand redirect chain if needed + url = get_redirected_url(url) + + # check if file is located on Google Drive + file_id = _get_google_drive_file_id(url) + if file_id is not None: + return download_file_from_google_drive(file_id, root, filename, md5) + + # download the file + try: + print("Downloading " + url + " to " + fpath) + _urlretrieve(url, fpath) + except (urllib.error.URLError, IOError) as e: # type: ignore[attr-defined] + if url[:5] == "https": + url = url.replace("https:", "http:") + print( + "Failed download. Trying https -> http instead." + " Downloading " + url + " to " + fpath + ) + _urlretrieve(url, fpath) + else: + raise e + + # check integrity of downloaded file + if not check_integrity(fpath, md5): + raise RuntimeError("File not found or corrupted.") + + +def download_and_extract_archive( + url: str, + download_root: str, + extract_root: Optional[str] = None, + filename: Optional[str] = None, + md5: Optional[str] = None, + remove_finished: bool = False, +) -> None: + download_root = os.path.expanduser(download_root) + if extract_root is None: + extract_root = download_root + if not filename: + filename = os.path.basename(url) + + download_url(url, download_root, filename, md5) + + archive = os.path.join(download_root, filename) + print("Extracting {} to {}".format(archive, extract_root)) + extract_archive(archive, extract_root, remove_finished) + + +def cache_url(url: str, cache_dir: str) -> str: + """ + This implementation downloads the remote resource and caches it locally. + The resource will only be downloaded if not previously requested. + """ + parsed_url = urlparse(url) + dirname = os.path.join(cache_dir, os.path.dirname(parsed_url.path.lstrip("/"))) + makedir(dirname) + filename = url.split("/")[-1] + cached = os.path.join(dirname, filename) + with file_lock(cached): + if not os.path.isfile(cached): + logging.info(f"Downloading {url} to {cached} ...") + cached = download(url, dirname, filename=filename) + logging.info(f"URL {url} cached in {cached}") + return cached + + +# TODO (prigoyal): convert this into RAII-style API +def create_file_symlink(file1, file2): + """ + Simply create the symlinks for a given file1 to file2. + Useful during model checkpointing to symlinks to the + latest successful checkpoint. + """ + try: + if g_pathmgr.exists(file2): + g_pathmgr.rm(file2) + g_pathmgr.symlink(file1, file2) + except Exception as e: + logging.info(f"Could NOT create symlink. Error: {e}") + + +def save_file(data, filename, append_to_json=True, verbose=True): + """ + Common i/o utility to handle saving data to various file formats. + Supported: + .pkl, .pickle, .npy, .json + Specifically for .json, users have the option to either append (default) + or rewrite by passing in Boolean value to append_to_json. + """ + if verbose: + logging.info(f"Saving data to file: {filename}") + file_ext = os.path.splitext(filename)[1] + if file_ext in [".pkl", ".pickle"]: + with g_pathmgr.open(filename, "wb") as fopen: + pickle.dump(data, fopen, pickle.HIGHEST_PROTOCOL) + elif file_ext == ".npy": + with g_pathmgr.open(filename, "wb") as fopen: + np.save(fopen, data) + elif file_ext == ".json": + if append_to_json: + with g_pathmgr.open(filename, "a") as fopen: + fopen.write(json.dumps(data, sort_keys=True) + "\n") + fopen.flush() + else: + with g_pathmgr.open(filename, "w") as fopen: + fopen.write(json.dumps(data, sort_keys=True) + "\n") + fopen.flush() + elif file_ext == ".yaml": + with g_pathmgr.open(filename, "w") as fopen: + dump = yaml.dump(data) + fopen.write(dump) + fopen.flush() + else: + raise Exception(f"Saving {file_ext} is not supported yet") + + if verbose: + logging.info(f"Saved data to file: {filename}") + + +def load_file(filename, mmap_mode=None, verbose=True, allow_pickle=False): + """ + Common i/o utility to handle loading data from various file formats. + Supported: + .pkl, .pickle, .npy, .json + For the npy files, we support reading the files in mmap_mode. + If the mmap_mode of reading is not successful, we load data without the + mmap_mode. + """ + if verbose: + logging.info(f"Loading data from file: {filename}") + + file_ext = os.path.splitext(filename)[1] + if file_ext == ".txt": + with g_pathmgr.open(filename, "r") as fopen: + data = fopen.readlines() + elif file_ext in [".pkl", ".pickle"]: + with g_pathmgr.open(filename, "rb") as fopen: + data = pickle.load(fopen, encoding="latin1") + elif file_ext == ".npy": + if mmap_mode: + try: + with g_pathmgr.open(filename, "rb") as fopen: + data = np.load( + fopen, + allow_pickle=allow_pickle, + encoding="latin1", + mmap_mode=mmap_mode, + ) + except ValueError as e: + logging.info( + f"Could not mmap {filename}: {e}. Trying without g_pathmgr" + ) + data = np.load( + filename, + allow_pickle=allow_pickle, + encoding="latin1", + mmap_mode=mmap_mode, + ) + logging.info("Successfully loaded without g_pathmgr") + except Exception: + logging.info("Could not mmap without g_pathmgr. Trying without mmap") + with g_pathmgr.open(filename, "rb") as fopen: + data = np.load(fopen, allow_pickle=allow_pickle, encoding="latin1") + else: + with g_pathmgr.open(filename, "rb") as fopen: + data = np.load(fopen, allow_pickle=allow_pickle, encoding="latin1") + elif file_ext == ".json": + with g_pathmgr.open(filename, "r") as fopen: + data = json.load(fopen) + elif file_ext == ".yaml": + with g_pathmgr.open(filename, "r") as fopen: + data = yaml.load(fopen, Loader=yaml.FullLoader) + elif file_ext == ".csv": + with g_pathmgr.open(filename, "r") as fopen: + data = pd.read_csv(fopen) + else: + raise Exception(f"Reading from {file_ext} is not supported yet") + return data + + +def abspath(resource_path: str): + """ + Make a path absolute, but take into account prefixes like + "http://" or "manifold://" + """ + regex = re.compile(r"^\w+://") + if regex.match(resource_path) is None: + return os.path.abspath(resource_path) + else: + return resource_path + + +def makedir(dir_path): + """ + Create the directory if it does not exist. + """ + is_success = False + try: + if not g_pathmgr.exists(dir_path): + g_pathmgr.mkdirs(dir_path) + is_success = True + except BaseException: + logging.info(f"Error creating directory: {dir_path}") + return is_success + + +def is_url(input_url): + """ + Check if an input string is a url. look for http(s):// and ignoring the case + """ + is_url = re.match(r"^(?:http)s?://", input_url, re.IGNORECASE) is not None + return is_url + + +def cleanup_dir(dir): + """ + Utility for deleting a directory. Useful for cleaning the storage space + that contains various training artifacts like checkpoints, data etc. + """ + if os.path.exists(dir): + logging.info(f"Deleting directory: {dir}") + shutil.rmtree(dir) + logging.info(f"Deleted contents of directory: {dir}") + + +def get_file_size(filename): + """ + Given a file, get the size of file in MB + """ + size_in_mb = os.path.getsize(filename) / float(1024**2) + return size_in_mb diff --git a/minigpt4/configs/datasets/cc_combine/align.yaml b/minigpt4/configs/datasets/cc_combine/align.yaml new file mode 100644 index 0000000000000000000000000000000000000000..fbfa24f9c21236fc2822dc2cefb8718948b57ebd --- /dev/null +++ b/minigpt4/configs/datasets/cc_combine/align.yaml @@ -0,0 +1,16 @@ + # Copyright (c) 2022, salesforce.com, inc. + # All rights reserved. + # SPDX-License-Identifier: BSD-3-Clause + # For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause + +datasets: + cc_align: + data_type: images + build_info: + # Be careful not to append minus sign (-) before split to avoid itemizing + annotations: + train: + url: placeholder + storage: /ibex/project/c2133/blip_dataset/image_alignment_cc/filter_cap.json + images: + storage: /ibex/project/c2133/blip_dataset/image_alignment_cc/ diff --git a/minigpt4/configs/datasets/cc_combine/defaults.yaml b/minigpt4/configs/datasets/cc_combine/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..53956604d11459a3f2b39c614d6754fae210b1f5 --- /dev/null +++ b/minigpt4/configs/datasets/cc_combine/defaults.yaml @@ -0,0 +1,11 @@ + # Copyright (c) 2022, salesforce.com, inc. + # All rights reserved. + # SPDX-License-Identifier: BSD-3-Clause + # For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause + +datasets: + cc_combine: + data_type: images + build_info: + # Be careful not to append minus sign (-) before split to avoid itemizing + storage: /ibex/project/c2133/blip_dataset/cc3m/cc3m_cc12m_sbu/{00000..01255}.tar diff --git a/minigpt4/configs/datasets/laion/defaults.yaml b/minigpt4/configs/datasets/laion/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..bbd37dfb6b080ccc7ef70ca7858c6b029ec0020e --- /dev/null +++ b/minigpt4/configs/datasets/laion/defaults.yaml @@ -0,0 +1,13 @@ + # Copyright (c) 2022, salesforce.com, inc. + # All rights reserved. + # SPDX-License-Identifier: BSD-3-Clause + # For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause + +datasets: + laion: + + data_type: images + + build_info: + # Be careful not to append minus sign (-) before split to avoid itemizing + storage: /ibex/project/c2133/blip_dataset/laion_1b/laion_gpu/{00000..10488}.tar diff --git a/minigpt4/configs/default.yaml b/minigpt4/configs/default.yaml new file mode 100644 index 0000000000000000000000000000000000000000..644bf96b66603d6dfd3baf237a9096c1f130103a --- /dev/null +++ b/minigpt4/configs/default.yaml @@ -0,0 +1,10 @@ + # Copyright (c) 2022, salesforce.com, inc. + # All rights reserved. + # SPDX-License-Identifier: BSD-3-Clause + # For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause + +env: + # For default users + # cache_root: "cache" + # For internal use with persistent storage + cache_root: "/export/home/.cache/minigpt4" diff --git a/minigpt4/configs/models/minigpt4.yaml b/minigpt4/configs/models/minigpt4.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2e04f3751e10bf355f49e542e5d5c5610382b236 --- /dev/null +++ b/minigpt4/configs/models/minigpt4.yaml @@ -0,0 +1,39 @@ + # Copyright (c) 2022, salesforce.com, inc. + # All rights reserved. + # SPDX-License-Identifier: BSD-3-Clause + # For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause + +model: + arch: mini_gpt4 + + # vit encoder + image_size: 224 + drop_path_rate: 0 + use_grad_checkpoint: False + vit_precision: "fp16" + freeze_vit: True + freeze_qformer: True + + # Q-Former + num_query_token: 32 + + # Vicuna + llama_model: "/path/to/vicuna/weights/" + + # generation configs + prompt: "" + + +preprocess: + vis_processor: + train: + name: "blip2_image_train" + image_size: 224 + eval: + name: "blip2_image_eval" + image_size: 224 + text_processor: + train: + name: "blip_caption" + eval: + name: "blip_caption" diff --git a/minigpt4/conversation/__init__.py b/minigpt4/conversation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/minigpt4/conversation/conversation.py b/minigpt4/conversation/conversation.py new file mode 100644 index 0000000000000000000000000000000000000000..b0c27115bdf58c5a13d497a6bc447998f1f44213 --- /dev/null +++ b/minigpt4/conversation/conversation.py @@ -0,0 +1,195 @@ +import argparse +import time +from PIL import Image + +import torch +from transformers import AutoTokenizer, AutoModelForCausalLM, LlamaTokenizer +from transformers import StoppingCriteria, StoppingCriteriaList + +import dataclasses +from enum import auto, Enum +from typing import List, Tuple, Any + +from minigpt4.common.registry import registry + + +class SeparatorStyle(Enum): + """Different separator style.""" + SINGLE = auto() + TWO = auto() + + +@dataclasses.dataclass +class Conversation: + """A class that keeps all conversation history.""" + system: str + roles: List[str] + messages: List[List[str]] + offset: int + # system_img: List[Image.Image] = [] + sep_style: SeparatorStyle = SeparatorStyle.SINGLE + sep: str = "###" + sep2: str = None + + skip_next: bool = False + conv_id: Any = None + + def get_prompt(self): + if self.sep_style == SeparatorStyle.SINGLE: + ret = self.system + self.sep + for role, message in self.messages: + if message: + ret += role + ": " + message + self.sep + else: + ret += role + ":" + return ret + elif self.sep_style == SeparatorStyle.TWO: + seps = [self.sep, self.sep2] + ret = self.system + seps[0] + for i, (role, message) in enumerate(self.messages): + if message: + ret += role + ": " + message + seps[i % 2] + else: + ret += role + ":" + return ret + else: + raise ValueError(f"Invalid style: {self.sep_style}") + + def append_message(self, role, message): + self.messages.append([role, message]) + + def to_gradio_chatbot(self): + ret = [] + for i, (role, msg) in enumerate(self.messages[self.offset:]): + if i % 2 == 0: + ret.append([msg, None]) + else: + ret[-1][-1] = msg + return ret + + def copy(self): + return Conversation( + system=self.system, + # system_img=self.system_img, + roles=self.roles, + messages=[[x, y] for x, y in self.messages], + offset=self.offset, + sep_style=self.sep_style, + sep=self.sep, + sep2=self.sep2, + conv_id=self.conv_id) + + def dict(self): + return { + "system": self.system, + # "system_img": self.system_img, + "roles": self.roles, + "messages": self.messages, + "offset": self.offset, + "sep": self.sep, + "sep2": self.sep2, + "conv_id": self.conv_id, + } + + +class StoppingCriteriaSub(StoppingCriteria): + + def __init__(self, stops=[], encounters=1): + super().__init__() + self.stops = stops + + def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor): + for stop in self.stops: + if torch.all((stop == input_ids[0][-len(stop):])).item(): + return True + + return False + + +CONV_VISION = Conversation( + system="Give the following image: ImageContent. " + "You will be able to see the image once I provide it to you. Please answer my questions.", + roles=("Human", "Assistant"), + messages=[], + offset=2, + sep_style=SeparatorStyle.SINGLE, + sep="###", +) + + + +class Chat: + def __init__(self, model, vis_processor, device='cuda:0'): + self.device = device + self.model = model + self.vis_processor = vis_processor + stop_words_ids = [torch.tensor([835]).to(self.device), + torch.tensor([2277, 29937]).to(self.device)] # '###' can be encoded in two different ways. + self.stopping_criteria = StoppingCriteriaList([StoppingCriteriaSub(stops=stop_words_ids)]) + + def ask(self, text, conv): + if len(conv.messages) > 0 and conv.messages[-1][0] == conv.roles[0] \ + and conv.messages[-1][1][-6:] == '': # last message is image. + conv.messages[-1][1] = ' '.join([conv.messages[-1][1], text]) + else: + conv.append_message(conv.roles[0], text) + + def answer(self, conv, img_list, max_new_tokens=200, num_beams=5, min_length=1, top_p=0.9, + repetition_penalty=1.0, length_penalty=1, temperature=1): + conv.append_message(conv.roles[1], None) + embs = self.get_context_emb(conv, img_list) + outputs = self.model.llama_model.generate( + inputs_embeds=embs, + max_new_tokens=max_new_tokens, + stopping_criteria=self.stopping_criteria, + num_beams=num_beams, + min_length=min_length, + top_p=top_p, + repetition_penalty=repetition_penalty, + length_penalty=length_penalty, + temperature=temperature, + ) + output_token = outputs[0] + if output_token[0] == 0: + output_token = output_token[1:] + output_text = self.model.llama_tokenizer.decode(output_token, add_special_tokens=False) + output_text = output_text.split('###')[0] # remove the stop sign '###' + output_text = output_text.split('Assistant:')[-1].strip() + conv.messages[-1][1] = output_text + return output_text, output_token.cpu().numpy() + + def upload_img(self, image, conv, img_list): + if isinstance(image, str): # is a image path + raw_image = Image.open(image).convert('RGB') + image = self.vis_processor(raw_image).unsqueeze(0).to(self.device) + elif isinstance(image, Image.Image): + raw_image = image + image = self.vis_processor(raw_image).unsqueeze(0).to(self.device) + elif isinstance(image, torch.Tensor): + if len(image.shape) == 3: + image = image.unsqueeze(0) + image = image.to(self.device) + + image_emb, _ = self.model.encode_img(image) + img_list.append(image_emb) + conv.append_message(conv.roles[0], "") + msg = "Received." + # self.conv.append_message(self.conv.roles[1], msg) + return msg + + def get_context_emb(self, conv, img_list): + prompt = conv.get_prompt() + prompt_segs = prompt.split('') + assert len(prompt_segs) == len(img_list) + 1, "Unmatched numbers of image placeholders and images." + seg_tokens = [ + self.model.llama_tokenizer( + seg, return_tensors="pt", add_special_tokens=i == 0).to(self.device).input_ids + # only add bos to the first seg + for i, seg in enumerate(prompt_segs) + ] + seg_embs = [self.model.llama_model.model.embed_tokens(seg_t) for seg_t in seg_tokens] + mixed_embs = [emb for pair in zip(seg_embs[:-1], img_list) for emb in pair] + [seg_embs[-1]] + mixed_embs = torch.cat(mixed_embs, dim=1) + return mixed_embs + + diff --git a/minigpt4/datasets/__init__.py b/minigpt4/datasets/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/minigpt4/datasets/builders/__init__.py b/minigpt4/datasets/builders/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a1f19e672f951204dc80067f30db368818fa4e00 --- /dev/null +++ b/minigpt4/datasets/builders/__init__.py @@ -0,0 +1,72 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +from minigpt4.datasets.builders.base_dataset_builder import load_dataset_config +from minigpt4.datasets.builders.image_text_pair_builder import ( + CCCombineBuilder, + LaionBuilder, + CCAlignBuilder +) +from minigpt4.common.registry import registry + +__all__ = [ + "CCCombineBuilder", + "LaionBuilder", + "CCAlignBuilder" +] + + +def load_dataset(name, cfg_path=None, vis_path=None, data_type=None): + """ + Example + + >>> dataset = load_dataset("coco_caption", cfg=None) + >>> splits = dataset.keys() + >>> print([len(dataset[split]) for split in splits]) + + """ + if cfg_path is None: + cfg = None + else: + cfg = load_dataset_config(cfg_path) + + try: + builder = registry.get_builder_class(name)(cfg) + except TypeError: + print( + f"Dataset {name} not found. Available datasets:\n" + + ", ".join([str(k) for k in dataset_zoo.get_names()]) + ) + exit(1) + + if vis_path is not None: + if data_type is None: + # use default data type in the config + data_type = builder.config.data_type + + assert ( + data_type in builder.config.build_info + ), f"Invalid data_type {data_type} for {name}." + + builder.config.build_info.get(data_type).storage = vis_path + + dataset = builder.build_datasets() + return dataset + + +class DatasetZoo: + def __init__(self) -> None: + self.dataset_zoo = { + k: list(v.DATASET_CONFIG_DICT.keys()) + for k, v in sorted(registry.mapping["builder_name_mapping"].items()) + } + + def get_names(self): + return list(self.dataset_zoo.keys()) + + +dataset_zoo = DatasetZoo() diff --git a/minigpt4/datasets/builders/base_dataset_builder.py b/minigpt4/datasets/builders/base_dataset_builder.py new file mode 100644 index 0000000000000000000000000000000000000000..8885b2c2de676b717081a512230ed6f90a0064ce --- /dev/null +++ b/minigpt4/datasets/builders/base_dataset_builder.py @@ -0,0 +1,235 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import logging +import os +import shutil +import warnings + +from omegaconf import OmegaConf +import torch.distributed as dist +from torchvision.datasets.utils import download_url + +import minigpt4.common.utils as utils +from minigpt4.common.dist_utils import is_dist_avail_and_initialized, is_main_process +from minigpt4.common.registry import registry +from minigpt4.processors.base_processor import BaseProcessor + + + +class BaseDatasetBuilder: + train_dataset_cls, eval_dataset_cls = None, None + + def __init__(self, cfg=None): + super().__init__() + + if cfg is None: + # help to create datasets from default config. + self.config = load_dataset_config(self.default_config_path()) + elif isinstance(cfg, str): + self.config = load_dataset_config(cfg) + else: + # when called from task.build_dataset() + self.config = cfg + + self.data_type = self.config.data_type + + self.vis_processors = {"train": BaseProcessor(), "eval": BaseProcessor()} + self.text_processors = {"train": BaseProcessor(), "eval": BaseProcessor()} + + def build_datasets(self): + # download, split, etc... + # only called on 1 GPU/TPU in distributed + + if is_main_process(): + self._download_data() + + if is_dist_avail_and_initialized(): + dist.barrier() + + # at this point, all the annotations and image/videos should be all downloaded to the specified locations. + logging.info("Building datasets...") + datasets = self.build() # dataset['train'/'val'/'test'] + + return datasets + + def build_processors(self): + vis_proc_cfg = self.config.get("vis_processor") + txt_proc_cfg = self.config.get("text_processor") + + if vis_proc_cfg is not None: + vis_train_cfg = vis_proc_cfg.get("train") + vis_eval_cfg = vis_proc_cfg.get("eval") + + self.vis_processors["train"] = self._build_proc_from_cfg(vis_train_cfg) + self.vis_processors["eval"] = self._build_proc_from_cfg(vis_eval_cfg) + + if txt_proc_cfg is not None: + txt_train_cfg = txt_proc_cfg.get("train") + txt_eval_cfg = txt_proc_cfg.get("eval") + + self.text_processors["train"] = self._build_proc_from_cfg(txt_train_cfg) + self.text_processors["eval"] = self._build_proc_from_cfg(txt_eval_cfg) + + @staticmethod + def _build_proc_from_cfg(cfg): + return ( + registry.get_processor_class(cfg.name).from_config(cfg) + if cfg is not None + else None + ) + + @classmethod + def default_config_path(cls, type="default"): + return utils.get_abs_path(cls.DATASET_CONFIG_DICT[type]) + + def _download_data(self): + self._download_ann() + self._download_vis() + + def _download_ann(self): + """ + Download annotation files if necessary. + All the vision-language datasets should have annotations of unified format. + + storage_path can be: + (1) relative/absolute: will be prefixed with env.cache_root to make full path if relative. + (2) basename/dirname: will be suffixed with base name of URL if dirname is provided. + + Local annotation paths should be relative. + """ + anns = self.config.build_info.annotations + + splits = anns.keys() + + cache_root = registry.get_path("cache_root") + + for split in splits: + info = anns[split] + + urls, storage_paths = info.get("url", None), info.storage + + if isinstance(urls, str): + urls = [urls] + if isinstance(storage_paths, str): + storage_paths = [storage_paths] + + assert len(urls) == len(storage_paths) + + for url_or_filename, storage_path in zip(urls, storage_paths): + # if storage_path is relative, make it full by prefixing with cache_root. + if not os.path.isabs(storage_path): + storage_path = os.path.join(cache_root, storage_path) + + dirname = os.path.dirname(storage_path) + if not os.path.exists(dirname): + os.makedirs(dirname) + + if os.path.isfile(url_or_filename): + src, dst = url_or_filename, storage_path + if not os.path.exists(dst): + shutil.copyfile(src=src, dst=dst) + else: + logging.info("Using existing file {}.".format(dst)) + else: + if os.path.isdir(storage_path): + # if only dirname is provided, suffix with basename of URL. + raise ValueError( + "Expecting storage_path to be a file path, got directory {}".format( + storage_path + ) + ) + else: + filename = os.path.basename(storage_path) + + download_url(url=url_or_filename, root=dirname, filename=filename) + + def _download_vis(self): + + storage_path = self.config.build_info.get(self.data_type).storage + storage_path = utils.get_cache_path(storage_path) + + if not os.path.exists(storage_path): + warnings.warn( + f""" + The specified path {storage_path} for visual inputs does not exist. + Please provide a correct path to the visual inputs or + refer to datasets/download_scripts/README.md for downloading instructions. + """ + ) + + def build(self): + """ + Create by split datasets inheriting torch.utils.data.Datasets. + + # build() can be dataset-specific. Overwrite to customize. + """ + self.build_processors() + + build_info = self.config.build_info + + ann_info = build_info.annotations + vis_info = build_info.get(self.data_type) + + datasets = dict() + for split in ann_info.keys(): + if split not in ["train", "val", "test"]: + continue + + is_train = split == "train" + + # processors + vis_processor = ( + self.vis_processors["train"] + if is_train + else self.vis_processors["eval"] + ) + text_processor = ( + self.text_processors["train"] + if is_train + else self.text_processors["eval"] + ) + + # annotation path + ann_paths = ann_info.get(split).storage + if isinstance(ann_paths, str): + ann_paths = [ann_paths] + + abs_ann_paths = [] + for ann_path in ann_paths: + if not os.path.isabs(ann_path): + ann_path = utils.get_cache_path(ann_path) + abs_ann_paths.append(ann_path) + ann_paths = abs_ann_paths + + # visual data storage path + vis_path = os.path.join(vis_info.storage, split) + + if not os.path.isabs(vis_path): + # vis_path = os.path.join(utils.get_cache_path(), vis_path) + vis_path = utils.get_cache_path(vis_path) + + if not os.path.exists(vis_path): + warnings.warn("storage path {} does not exist.".format(vis_path)) + + # create datasets + dataset_cls = self.train_dataset_cls if is_train else self.eval_dataset_cls + datasets[split] = dataset_cls( + vis_processor=vis_processor, + text_processor=text_processor, + ann_paths=ann_paths, + vis_root=vis_path, + ) + + return datasets + + +def load_dataset_config(cfg_path): + cfg = OmegaConf.load(cfg_path).datasets + cfg = cfg[list(cfg.keys())[0]] + + return cfg diff --git a/minigpt4/datasets/builders/image_text_pair_builder.py b/minigpt4/datasets/builders/image_text_pair_builder.py new file mode 100644 index 0000000000000000000000000000000000000000..3752be547778b7460c4cf3739723e723f9cb50d3 --- /dev/null +++ b/minigpt4/datasets/builders/image_text_pair_builder.py @@ -0,0 +1,86 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import os + +from minigpt4.common.registry import registry +from minigpt4.datasets.builders.base_dataset_builder import BaseDatasetBuilder +from minigpt4.datasets.datasets.laion_dataset import LaionDataset +from minigpt4.datasets.datasets.cc_combine_dataset import CCCombineDataset, CCAlignDataset + + +@registry.register_builder("cc_combine") +class CCCombineBuilder(BaseDatasetBuilder): + train_dataset_cls = CCCombineDataset + + DATASET_CONFIG_DICT = {"default": "configs/datasets/cc_combine/defaults.yaml"} + + def _download_ann(self): + pass + + def _download_vis(self): + pass + + def build(self): + self.build_processors() + + build_info = self.config.build_info + + datasets = dict() + split = "train" + + # create datasets + # [NOTE] return inner_datasets (wds.DataPipeline) + dataset_cls = self.train_dataset_cls + datasets[split] = dataset_cls( + vis_processor=self.vis_processors[split], + text_processor=self.text_processors[split], + location=build_info.storage, + ).inner_dataset + + return datasets + + +@registry.register_builder("laion") +class LaionBuilder(BaseDatasetBuilder): + train_dataset_cls = LaionDataset + + DATASET_CONFIG_DICT = {"default": "configs/datasets/laion/defaults.yaml"} + + def _download_ann(self): + pass + + def _download_vis(self): + pass + + def build(self): + self.build_processors() + + build_info = self.config.build_info + + datasets = dict() + split = "train" + + # create datasets + # [NOTE] return inner_datasets (wds.DataPipeline) + dataset_cls = self.train_dataset_cls + datasets[split] = dataset_cls( + vis_processor=self.vis_processors[split], + text_processor=self.text_processors[split], + location=build_info.storage, + ).inner_dataset + + return datasets + + +@registry.register_builder("cc_align") +class CCAlignBuilder(BaseDatasetBuilder): + train_dataset_cls = CCAlignDataset + + DATASET_CONFIG_DICT = { + "default": "configs/datasets/cc_combine/align.yaml", + } \ No newline at end of file diff --git a/minigpt4/datasets/data_utils.py b/minigpt4/datasets/data_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..cddc4d68a8fa5a4e39bea0055d131c96ee81e7b7 --- /dev/null +++ b/minigpt4/datasets/data_utils.py @@ -0,0 +1,196 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import gzip +import logging +import os +import random as rnd +import tarfile +import zipfile +import random +from typing import List +from tqdm import tqdm + +import decord +from decord import VideoReader +import webdataset as wds +import numpy as np +import torch +from torch.utils.data.dataset import IterableDataset + +from minigpt4.common.registry import registry +from minigpt4.datasets.datasets.base_dataset import ConcatDataset + + +decord.bridge.set_bridge("torch") +MAX_INT = registry.get("MAX_INT") + + +class ChainDataset(wds.DataPipeline): + r"""Dataset for chaining multiple :class:`DataPipeline` s. + + This class is useful to assemble different existing dataset streams. The + chaining operation is done on-the-fly, so concatenating large-scale + datasets with this class will be efficient. + + Args: + datasets (iterable of IterableDataset): datasets to be chained together + """ + def __init__(self, datasets: List[wds.DataPipeline]) -> None: + super().__init__() + self.datasets = datasets + self.prob = [] + self.names = [] + for dataset in self.datasets: + if hasattr(dataset, 'name'): + self.names.append(dataset.name) + else: + self.names.append('Unknown') + if hasattr(dataset, 'sample_ratio'): + self.prob.append(dataset.sample_ratio) + else: + self.prob.append(1) + logging.info("One of the datapipeline doesn't define ratio and set to 1 automatically.") + + def __iter__(self): + datastreams = [iter(dataset) for dataset in self.datasets] + while True: + select_datastream = random.choices(datastreams, weights=self.prob, k=1)[0] + yield next(select_datastream) + + +def apply_to_sample(f, sample): + if len(sample) == 0: + return {} + + def _apply(x): + if torch.is_tensor(x): + return f(x) + elif isinstance(x, dict): + return {key: _apply(value) for key, value in x.items()} + elif isinstance(x, list): + return [_apply(x) for x in x] + else: + return x + + return _apply(sample) + + +def move_to_cuda(sample): + def _move_to_cuda(tensor): + return tensor.cuda() + + return apply_to_sample(_move_to_cuda, sample) + + +def prepare_sample(samples, cuda_enabled=True): + if cuda_enabled: + samples = move_to_cuda(samples) + + # TODO fp16 support + + return samples + + +def reorg_datasets_by_split(datasets): + """ + Organizes datasets by split. + + Args: + datasets: dict of torch.utils.data.Dataset objects by name. + + Returns: + Dict of datasets by split {split_name: List[Datasets]}. + """ + # if len(datasets) == 1: + # return datasets[list(datasets.keys())[0]] + # else: + reorg_datasets = dict() + + # reorganize by split + for _, dataset in datasets.items(): + for split_name, dataset_split in dataset.items(): + if split_name not in reorg_datasets: + reorg_datasets[split_name] = [dataset_split] + else: + reorg_datasets[split_name].append(dataset_split) + + return reorg_datasets + + +def concat_datasets(datasets): + """ + Concatenates multiple datasets into a single dataset. + + It supports may-style datasets and DataPipeline from WebDataset. Currently, does not support + generic IterableDataset because it requires creating separate samplers. + + Now only supports conctenating training datasets and assuming validation and testing + have only a single dataset. This is because metrics should not be computed on the concatenated + datasets. + + Args: + datasets: dict of torch.utils.data.Dataset objects by split. + + Returns: + Dict of concatenated datasets by split, "train" is the concatenation of multiple datasets, + "val" and "test" remain the same. + + If the input training datasets contain both map-style and DataPipeline datasets, returns + a tuple, where the first element is a concatenated map-style dataset and the second + element is a chained DataPipeline dataset. + + """ + # concatenate datasets in the same split + for split_name in datasets: + if split_name != "train": + assert ( + len(datasets[split_name]) == 1 + ), "Do not support multiple {} datasets.".format(split_name) + datasets[split_name] = datasets[split_name][0] + else: + iterable_datasets, map_datasets = [], [] + for dataset in datasets[split_name]: + if isinstance(dataset, wds.DataPipeline): + logging.info( + "Dataset {} is IterableDataset, can't be concatenated.".format( + dataset + ) + ) + iterable_datasets.append(dataset) + elif isinstance(dataset, IterableDataset): + raise NotImplementedError( + "Do not support concatenation of generic IterableDataset." + ) + else: + map_datasets.append(dataset) + + # if len(iterable_datasets) > 0: + # concatenate map-style datasets and iterable-style datasets separately + if len(iterable_datasets) > 1: + chained_datasets = ( + ChainDataset(iterable_datasets) + ) + elif len(iterable_datasets) == 1: + chained_datasets = iterable_datasets[0] + else: + chained_datasets = None + + concat_datasets = ( + ConcatDataset(map_datasets) if len(map_datasets) > 0 else None + ) + + train_datasets = concat_datasets, chained_datasets + train_datasets = tuple([x for x in train_datasets if x is not None]) + train_datasets = ( + train_datasets[0] if len(train_datasets) == 1 else train_datasets + ) + + datasets[split_name] = train_datasets + + return datasets + diff --git a/minigpt4/datasets/datasets/__init__.py b/minigpt4/datasets/datasets/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/minigpt4/datasets/datasets/base_dataset.py b/minigpt4/datasets/datasets/base_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..e9e1c6f26f09adc3500ab7253cb555d54daf76ae --- /dev/null +++ b/minigpt4/datasets/datasets/base_dataset.py @@ -0,0 +1,68 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import json +from typing import Iterable + +from torch.utils.data import Dataset, ConcatDataset +from torch.utils.data.dataloader import default_collate + + +class BaseDataset(Dataset): + def __init__( + self, vis_processor=None, text_processor=None, vis_root=None, ann_paths=[] + ): + """ + vis_root (string): Root directory of images (e.g. coco/images/) + ann_root (string): directory to store the annotation file + """ + self.vis_root = vis_root + + self.annotation = [] + for ann_path in ann_paths: + self.annotation.extend(json.load(open(ann_path, "r"))['annotations']) + + self.vis_processor = vis_processor + self.text_processor = text_processor + + self._add_instance_ids() + + def __len__(self): + return len(self.annotation) + + def collater(self, samples): + return default_collate(samples) + + def set_processors(self, vis_processor, text_processor): + self.vis_processor = vis_processor + self.text_processor = text_processor + + def _add_instance_ids(self, key="instance_id"): + for idx, ann in enumerate(self.annotation): + ann[key] = str(idx) + + +class ConcatDataset(ConcatDataset): + def __init__(self, datasets: Iterable[Dataset]) -> None: + super().__init__(datasets) + + def collater(self, samples): + # TODO For now only supports datasets with same underlying collater implementations + + all_keys = set() + for s in samples: + all_keys.update(s) + + shared_keys = all_keys + for s in samples: + shared_keys = shared_keys & set(s.keys()) + + samples_shared_keys = [] + for s in samples: + samples_shared_keys.append({k: s[k] for k in s.keys() if k in shared_keys}) + + return self.datasets[0].collater(samples_shared_keys) diff --git a/minigpt4/datasets/datasets/caption_datasets.py b/minigpt4/datasets/datasets/caption_datasets.py new file mode 100644 index 0000000000000000000000000000000000000000..8c8fb2014794a2800e5bea480ba3ecd353512915 --- /dev/null +++ b/minigpt4/datasets/datasets/caption_datasets.py @@ -0,0 +1,85 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import os +from collections import OrderedDict + +from minigpt4.datasets.datasets.base_dataset import BaseDataset +from PIL import Image + + +class __DisplMixin: + def displ_item(self, index): + sample, ann = self.__getitem__(index), self.annotation[index] + + return OrderedDict( + { + "file": ann["image"], + "caption": ann["caption"], + "image": sample["image"], + } + ) + + +class CaptionDataset(BaseDataset, __DisplMixin): + def __init__(self, vis_processor, text_processor, vis_root, ann_paths): + """ + vis_root (string): Root directory of images (e.g. coco/images/) + ann_root (string): directory to store the annotation file + """ + super().__init__(vis_processor, text_processor, vis_root, ann_paths) + + self.img_ids = {} + n = 0 + for ann in self.annotation: + img_id = ann["image_id"] + if img_id not in self.img_ids.keys(): + self.img_ids[img_id] = n + n += 1 + + def __getitem__(self, index): + + # TODO this assumes image input, not general enough + ann = self.annotation[index] + + img_file = '{:0>12}.jpg'.format(ann["image_id"]) + image_path = os.path.join(self.vis_root, img_file) + image = Image.open(image_path).convert("RGB") + + image = self.vis_processor(image) + caption = self.text_processor(ann["caption"]) + + return { + "image": image, + "text_input": caption, + "image_id": self.img_ids[ann["image_id"]], + } + + +class CaptionEvalDataset(BaseDataset, __DisplMixin): + def __init__(self, vis_processor, text_processor, vis_root, ann_paths): + """ + vis_root (string): Root directory of images (e.g. coco/images/) + ann_root (string): directory to store the annotation file + split (string): val or test + """ + super().__init__(vis_processor, text_processor, vis_root, ann_paths) + + def __getitem__(self, index): + + ann = self.annotation[index] + + image_path = os.path.join(self.vis_root, ann["image"]) + image = Image.open(image_path).convert("RGB") + + image = self.vis_processor(image) + + return { + "image": image, + "image_id": ann["image_id"], + "instance_id": ann["instance_id"], + } diff --git a/minigpt4/datasets/datasets/cc_combine_dataset.py b/minigpt4/datasets/datasets/cc_combine_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..def863d405a4bbe34b8a46c7d9a3220efec2aaf6 --- /dev/null +++ b/minigpt4/datasets/datasets/cc_combine_dataset.py @@ -0,0 +1,53 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" +import os +from PIL import Image +import webdataset as wds +from minigpt4.datasets.datasets.base_dataset import BaseDataset +from minigpt4.datasets.datasets.caption_datasets import CaptionDataset + + +class CCCombineDataset(BaseDataset): + def __init__(self, vis_processor, text_processor, location): + super().__init__(vis_processor=vis_processor, text_processor=text_processor) + + self.inner_dataset = wds.DataPipeline( + wds.ResampledShards(location), + wds.tarfile_to_samples(handler=wds.warn_and_continue), + wds.shuffle(1000, handler=wds.warn_and_continue), + wds.decode("pilrgb", handler=wds.warn_and_continue), + wds.to_tuple("jpg", "json", handler=wds.warn_and_continue), + wds.map_tuple(self.vis_processor, handler=wds.warn_and_continue), + wds.map(self.to_dict, handler=wds.warn_and_continue), + ) + + def to_dict(self, sample): + return { + "image": sample[0], + "text_input": self.text_processor(sample[1]["caption"]), + } + + +class CCAlignDataset(CaptionDataset): + + def __getitem__(self, index): + + # TODO this assumes image input, not general enough + ann = self.annotation[index] + + img_file = '{}.jpg'.format(ann["image_id"]) + image_path = os.path.join(self.vis_root, img_file) + image = Image.open(image_path).convert("RGB") + + image = self.vis_processor(image) + caption = ann["caption"] + + return { + "image": image, + "text_input": caption, + "image_id": self.img_ids[ann["image_id"]], + } \ No newline at end of file diff --git a/minigpt4/datasets/datasets/dataloader_utils.py b/minigpt4/datasets/datasets/dataloader_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..3459972e5bda3e4a40788acf97ebe3c114fe7c3e --- /dev/null +++ b/minigpt4/datasets/datasets/dataloader_utils.py @@ -0,0 +1,162 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import time +import random +import torch +from minigpt4.datasets.data_utils import move_to_cuda +from torch.utils.data import DataLoader + + +class MultiIterLoader: + """ + A simple wrapper for iterating over multiple iterators. + + Args: + loaders (List[Loader]): List of Iterator loaders. + ratios (List[float]): List of ratios to sample from each loader. If None, all loaders are sampled uniformly. + """ + + def __init__(self, loaders, ratios=None): + # assert all loaders has __next__ method + for loader in loaders: + assert hasattr( + loader, "__next__" + ), "Loader {} has no __next__ method.".format(loader) + + if ratios is None: + ratios = [1.0] * len(loaders) + else: + assert len(ratios) == len(loaders) + ratios = [float(ratio) / sum(ratios) for ratio in ratios] + + self.loaders = loaders + self.ratios = ratios + + def __next__(self): + # random sample from each loader by ratio + loader_idx = random.choices(range(len(self.loaders)), self.ratios, k=1)[0] + return next(self.loaders[loader_idx]) + + +class PrefetchLoader(object): + """ + Modified from https://github.com/ChenRocks/UNITER. + + overlap compute and cuda data transfer + (copied and then modified from nvidia apex) + """ + + def __init__(self, loader): + self.loader = loader + self.stream = torch.cuda.Stream() + + def __iter__(self): + loader_it = iter(self.loader) + self.preload(loader_it) + batch = self.next(loader_it) + while batch is not None: + is_tuple = isinstance(batch, tuple) + if is_tuple: + task, batch = batch + + if is_tuple: + yield task, batch + else: + yield batch + batch = self.next(loader_it) + + def __len__(self): + return len(self.loader) + + def preload(self, it): + try: + self.batch = next(it) + except StopIteration: + self.batch = None + return + # if record_stream() doesn't work, another option is to make sure + # device inputs are created on the main stream. + # self.next_input_gpu = torch.empty_like(self.next_input, + # device='cuda') + # self.next_target_gpu = torch.empty_like(self.next_target, + # device='cuda') + # Need to make sure the memory allocated for next_* is not still in use + # by the main stream at the time we start copying to next_*: + # self.stream.wait_stream(torch.cuda.current_stream()) + with torch.cuda.stream(self.stream): + self.batch = move_to_cuda(self.batch) + # more code for the alternative if record_stream() doesn't work: + # copy_ will record the use of the pinned source tensor in this + # side stream. + # self.next_input_gpu.copy_(self.next_input, non_blocking=True) + # self.next_target_gpu.copy_(self.next_target, non_blocking=True) + # self.next_input = self.next_input_gpu + # self.next_target = self.next_target_gpu + + def next(self, it): + torch.cuda.current_stream().wait_stream(self.stream) + batch = self.batch + if batch is not None: + record_cuda_stream(batch) + self.preload(it) + return batch + + def __getattr__(self, name): + method = self.loader.__getattribute__(name) + return method + + +def record_cuda_stream(batch): + if isinstance(batch, torch.Tensor): + batch.record_stream(torch.cuda.current_stream()) + elif isinstance(batch, list) or isinstance(batch, tuple): + for t in batch: + record_cuda_stream(t) + elif isinstance(batch, dict): + for t in batch.values(): + record_cuda_stream(t) + else: + pass + + +class IterLoader: + """ + A wrapper to convert DataLoader as an infinite iterator. + + Modified from: + https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/iter_based_runner.py + """ + + def __init__(self, dataloader: DataLoader, use_distributed: bool = False): + self._dataloader = dataloader + self.iter_loader = iter(self._dataloader) + self._use_distributed = use_distributed + self._epoch = 0 + + @property + def epoch(self) -> int: + return self._epoch + + def __next__(self): + try: + data = next(self.iter_loader) + except StopIteration: + self._epoch += 1 + if hasattr(self._dataloader.sampler, "set_epoch") and self._use_distributed: + self._dataloader.sampler.set_epoch(self._epoch) + time.sleep(2) # Prevent possible deadlock during epoch transition + self.iter_loader = iter(self._dataloader) + data = next(self.iter_loader) + + return data + + def __iter__(self): + return self + + def __len__(self): + return len(self._dataloader) diff --git a/minigpt4/datasets/datasets/laion_dataset.py b/minigpt4/datasets/datasets/laion_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..78568fc7df9cc8213899e564babc00658c8575ac --- /dev/null +++ b/minigpt4/datasets/datasets/laion_dataset.py @@ -0,0 +1,31 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import webdataset as wds +from minigpt4.datasets.datasets.base_dataset import BaseDataset + + +class LaionDataset(BaseDataset): + def __init__(self, vis_processor, text_processor, location): + super().__init__(vis_processor=vis_processor, text_processor=text_processor) + + self.inner_dataset = wds.DataPipeline( + wds.ResampledShards(location), + wds.tarfile_to_samples(handler=wds.warn_and_continue), + wds.shuffle(1000, handler=wds.warn_and_continue), + wds.decode("pilrgb", handler=wds.warn_and_continue), + wds.to_tuple("jpg", "json", handler=wds.warn_and_continue), + wds.map_tuple(self.vis_processor, handler=wds.warn_and_continue), + wds.map(self.to_dict, handler=wds.warn_and_continue), + ) + + def to_dict(self, sample): + return { + "image": sample[0], + "text_input": self.text_processor(sample[1]["caption"]), + } + diff --git a/minigpt4/models/Qformer.py b/minigpt4/models/Qformer.py new file mode 100644 index 0000000000000000000000000000000000000000..e71b12375e10511858a9c505dc795181e6ce5603 --- /dev/null +++ b/minigpt4/models/Qformer.py @@ -0,0 +1,1216 @@ +""" + * Copyright (c) 2023, salesforce.com, inc. + * All rights reserved. + * SPDX-License-Identifier: BSD-3-Clause + * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause + * By Junnan Li + * Based on huggingface code base + * https://github.com/huggingface/transformers/blob/v4.15.0/src/transformers/models/bert +""" + +import math +import os +import warnings +from dataclasses import dataclass +from typing import Optional, Tuple, Dict, Any + +import torch +from torch import Tensor, device, dtype, nn +import torch.utils.checkpoint +from torch import nn +from torch.nn import CrossEntropyLoss +import torch.nn.functional as F + +from transformers.activations import ACT2FN +from transformers.file_utils import ( + ModelOutput, +) +from transformers.modeling_outputs import ( + BaseModelOutputWithPastAndCrossAttentions, + BaseModelOutputWithPoolingAndCrossAttentions, + CausalLMOutputWithCrossAttentions, + MaskedLMOutput, + MultipleChoiceModelOutput, + NextSentencePredictorOutput, + QuestionAnsweringModelOutput, + SequenceClassifierOutput, + TokenClassifierOutput, +) +from transformers.modeling_utils import ( + PreTrainedModel, + apply_chunking_to_forward, + find_pruneable_heads_and_indices, + prune_linear_layer, +) +from transformers.utils import logging +from transformers.models.bert.configuration_bert import BertConfig + +logger = logging.get_logger(__name__) + + +class BertEmbeddings(nn.Module): + """Construct the embeddings from word and position embeddings.""" + + def __init__(self, config): + super().__init__() + self.word_embeddings = nn.Embedding( + config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id + ) + self.position_embeddings = nn.Embedding( + config.max_position_embeddings, config.hidden_size + ) + + # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load + # any TensorFlow checkpoint file + self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = nn.Dropout(config.hidden_dropout_prob) + + # position_ids (1, len position emb) is contiguous in memory and exported when serialized + self.register_buffer( + "position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)) + ) + self.position_embedding_type = getattr( + config, "position_embedding_type", "absolute" + ) + + self.config = config + + def forward( + self, + input_ids=None, + position_ids=None, + query_embeds=None, + past_key_values_length=0, + ): + if input_ids is not None: + seq_length = input_ids.size()[1] + else: + seq_length = 0 + + if position_ids is None: + position_ids = self.position_ids[ + :, past_key_values_length : seq_length + past_key_values_length + ].clone() + + if input_ids is not None: + embeddings = self.word_embeddings(input_ids) + if self.position_embedding_type == "absolute": + position_embeddings = self.position_embeddings(position_ids) + embeddings = embeddings + position_embeddings + + if query_embeds is not None: + embeddings = torch.cat((query_embeds, embeddings), dim=1) + else: + embeddings = query_embeds + + embeddings = self.LayerNorm(embeddings) + embeddings = self.dropout(embeddings) + return embeddings + + +class BertSelfAttention(nn.Module): + def __init__(self, config, is_cross_attention): + super().__init__() + self.config = config + if config.hidden_size % config.num_attention_heads != 0 and not hasattr( + config, "embedding_size" + ): + raise ValueError( + "The hidden size (%d) is not a multiple of the number of attention " + "heads (%d)" % (config.hidden_size, config.num_attention_heads) + ) + + self.num_attention_heads = config.num_attention_heads + self.attention_head_size = int(config.hidden_size / config.num_attention_heads) + self.all_head_size = self.num_attention_heads * self.attention_head_size + + self.query = nn.Linear(config.hidden_size, self.all_head_size) + if is_cross_attention: + self.key = nn.Linear(config.encoder_width, self.all_head_size) + self.value = nn.Linear(config.encoder_width, self.all_head_size) + else: + self.key = nn.Linear(config.hidden_size, self.all_head_size) + self.value = nn.Linear(config.hidden_size, self.all_head_size) + + self.dropout = nn.Dropout(config.attention_probs_dropout_prob) + self.position_embedding_type = getattr( + config, "position_embedding_type", "absolute" + ) + if ( + self.position_embedding_type == "relative_key" + or self.position_embedding_type == "relative_key_query" + ): + self.max_position_embeddings = config.max_position_embeddings + self.distance_embedding = nn.Embedding( + 2 * config.max_position_embeddings - 1, self.attention_head_size + ) + self.save_attention = False + + def save_attn_gradients(self, attn_gradients): + self.attn_gradients = attn_gradients + + def get_attn_gradients(self): + return self.attn_gradients + + def save_attention_map(self, attention_map): + self.attention_map = attention_map + + def get_attention_map(self): + return self.attention_map + + def transpose_for_scores(self, x): + new_x_shape = x.size()[:-1] + ( + self.num_attention_heads, + self.attention_head_size, + ) + x = x.view(*new_x_shape) + return x.permute(0, 2, 1, 3) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_value=None, + output_attentions=False, + ): + + # If this is instantiated as a cross-attention module, the keys + # and values come from an encoder; the attention mask needs to be + # such that the encoder's padding tokens are not attended to. + is_cross_attention = encoder_hidden_states is not None + + if is_cross_attention: + key_layer = self.transpose_for_scores(self.key(encoder_hidden_states)) + value_layer = self.transpose_for_scores(self.value(encoder_hidden_states)) + attention_mask = encoder_attention_mask + elif past_key_value is not None: + key_layer = self.transpose_for_scores(self.key(hidden_states)) + value_layer = self.transpose_for_scores(self.value(hidden_states)) + key_layer = torch.cat([past_key_value[0], key_layer], dim=2) + value_layer = torch.cat([past_key_value[1], value_layer], dim=2) + else: + key_layer = self.transpose_for_scores(self.key(hidden_states)) + value_layer = self.transpose_for_scores(self.value(hidden_states)) + + mixed_query_layer = self.query(hidden_states) + + query_layer = self.transpose_for_scores(mixed_query_layer) + + past_key_value = (key_layer, value_layer) + + # Take the dot product between "query" and "key" to get the raw attention scores. + attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2)) + + if ( + self.position_embedding_type == "relative_key" + or self.position_embedding_type == "relative_key_query" + ): + seq_length = hidden_states.size()[1] + position_ids_l = torch.arange( + seq_length, dtype=torch.long, device=hidden_states.device + ).view(-1, 1) + position_ids_r = torch.arange( + seq_length, dtype=torch.long, device=hidden_states.device + ).view(1, -1) + distance = position_ids_l - position_ids_r + positional_embedding = self.distance_embedding( + distance + self.max_position_embeddings - 1 + ) + positional_embedding = positional_embedding.to( + dtype=query_layer.dtype + ) # fp16 compatibility + + if self.position_embedding_type == "relative_key": + relative_position_scores = torch.einsum( + "bhld,lrd->bhlr", query_layer, positional_embedding + ) + attention_scores = attention_scores + relative_position_scores + elif self.position_embedding_type == "relative_key_query": + relative_position_scores_query = torch.einsum( + "bhld,lrd->bhlr", query_layer, positional_embedding + ) + relative_position_scores_key = torch.einsum( + "bhrd,lrd->bhlr", key_layer, positional_embedding + ) + attention_scores = ( + attention_scores + + relative_position_scores_query + + relative_position_scores_key + ) + + attention_scores = attention_scores / math.sqrt(self.attention_head_size) + if attention_mask is not None: + # Apply the attention mask is (precomputed for all layers in BertModel forward() function) + attention_scores = attention_scores + attention_mask + + # Normalize the attention scores to probabilities. + attention_probs = nn.Softmax(dim=-1)(attention_scores) + + if is_cross_attention and self.save_attention: + self.save_attention_map(attention_probs) + attention_probs.register_hook(self.save_attn_gradients) + + # This is actually dropping out entire tokens to attend to, which might + # seem a bit unusual, but is taken from the original Transformer paper. + attention_probs_dropped = self.dropout(attention_probs) + + # Mask heads if we want to + if head_mask is not None: + attention_probs_dropped = attention_probs_dropped * head_mask + + context_layer = torch.matmul(attention_probs_dropped, value_layer) + + context_layer = context_layer.permute(0, 2, 1, 3).contiguous() + new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,) + context_layer = context_layer.view(*new_context_layer_shape) + + outputs = ( + (context_layer, attention_probs) if output_attentions else (context_layer,) + ) + + outputs = outputs + (past_key_value,) + return outputs + + +class BertSelfOutput(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.hidden_size) + self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = nn.Dropout(config.hidden_dropout_prob) + + def forward(self, hidden_states, input_tensor): + hidden_states = self.dense(hidden_states) + hidden_states = self.dropout(hidden_states) + hidden_states = self.LayerNorm(hidden_states + input_tensor) + return hidden_states + + +class BertAttention(nn.Module): + def __init__(self, config, is_cross_attention=False): + super().__init__() + self.self = BertSelfAttention(config, is_cross_attention) + self.output = BertSelfOutput(config) + self.pruned_heads = set() + + def prune_heads(self, heads): + if len(heads) == 0: + return + heads, index = find_pruneable_heads_and_indices( + heads, + self.self.num_attention_heads, + self.self.attention_head_size, + self.pruned_heads, + ) + + # Prune linear layers + self.self.query = prune_linear_layer(self.self.query, index) + self.self.key = prune_linear_layer(self.self.key, index) + self.self.value = prune_linear_layer(self.self.value, index) + self.output.dense = prune_linear_layer(self.output.dense, index, dim=1) + + # Update hyper params and store pruned heads + self.self.num_attention_heads = self.self.num_attention_heads - len(heads) + self.self.all_head_size = ( + self.self.attention_head_size * self.self.num_attention_heads + ) + self.pruned_heads = self.pruned_heads.union(heads) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_value=None, + output_attentions=False, + ): + self_outputs = self.self( + hidden_states, + attention_mask, + head_mask, + encoder_hidden_states, + encoder_attention_mask, + past_key_value, + output_attentions, + ) + attention_output = self.output(self_outputs[0], hidden_states) + + outputs = (attention_output,) + self_outputs[ + 1: + ] # add attentions if we output them + return outputs + + +class BertIntermediate(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.intermediate_size) + if isinstance(config.hidden_act, str): + self.intermediate_act_fn = ACT2FN[config.hidden_act] + else: + self.intermediate_act_fn = config.hidden_act + + def forward(self, hidden_states): + hidden_states = self.dense(hidden_states) + hidden_states = self.intermediate_act_fn(hidden_states) + return hidden_states + + +class BertOutput(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.intermediate_size, config.hidden_size) + self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = nn.Dropout(config.hidden_dropout_prob) + + def forward(self, hidden_states, input_tensor): + hidden_states = self.dense(hidden_states) + hidden_states = self.dropout(hidden_states) + hidden_states = self.LayerNorm(hidden_states + input_tensor) + return hidden_states + + +class BertLayer(nn.Module): + def __init__(self, config, layer_num): + super().__init__() + self.config = config + self.chunk_size_feed_forward = config.chunk_size_feed_forward + self.seq_len_dim = 1 + self.attention = BertAttention(config) + self.layer_num = layer_num + if ( + self.config.add_cross_attention + and layer_num % self.config.cross_attention_freq == 0 + ): + self.crossattention = BertAttention( + config, is_cross_attention=self.config.add_cross_attention + ) + self.has_cross_attention = True + else: + self.has_cross_attention = False + self.intermediate = BertIntermediate(config) + self.output = BertOutput(config) + + self.intermediate_query = BertIntermediate(config) + self.output_query = BertOutput(config) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_value=None, + output_attentions=False, + query_length=0, + ): + # decoder uni-directional self-attention cached key/values tuple is at positions 1,2 + self_attn_past_key_value = ( + past_key_value[:2] if past_key_value is not None else None + ) + self_attention_outputs = self.attention( + hidden_states, + attention_mask, + head_mask, + output_attentions=output_attentions, + past_key_value=self_attn_past_key_value, + ) + attention_output = self_attention_outputs[0] + outputs = self_attention_outputs[1:-1] + + present_key_value = self_attention_outputs[-1] + + if query_length > 0: + query_attention_output = attention_output[:, :query_length, :] + + if self.has_cross_attention: + assert ( + encoder_hidden_states is not None + ), "encoder_hidden_states must be given for cross-attention layers" + cross_attention_outputs = self.crossattention( + query_attention_output, + attention_mask, + head_mask, + encoder_hidden_states, + encoder_attention_mask, + output_attentions=output_attentions, + ) + query_attention_output = cross_attention_outputs[0] + outputs = ( + outputs + cross_attention_outputs[1:-1] + ) # add cross attentions if we output attention weights + + layer_output = apply_chunking_to_forward( + self.feed_forward_chunk_query, + self.chunk_size_feed_forward, + self.seq_len_dim, + query_attention_output, + ) + if attention_output.shape[1] > query_length: + layer_output_text = apply_chunking_to_forward( + self.feed_forward_chunk, + self.chunk_size_feed_forward, + self.seq_len_dim, + attention_output[:, query_length:, :], + ) + layer_output = torch.cat([layer_output, layer_output_text], dim=1) + else: + layer_output = apply_chunking_to_forward( + self.feed_forward_chunk, + self.chunk_size_feed_forward, + self.seq_len_dim, + attention_output, + ) + outputs = (layer_output,) + outputs + + outputs = outputs + (present_key_value,) + + return outputs + + def feed_forward_chunk(self, attention_output): + intermediate_output = self.intermediate(attention_output) + layer_output = self.output(intermediate_output, attention_output) + return layer_output + + def feed_forward_chunk_query(self, attention_output): + intermediate_output = self.intermediate_query(attention_output) + layer_output = self.output_query(intermediate_output, attention_output) + return layer_output + + +class BertEncoder(nn.Module): + def __init__(self, config): + super().__init__() + self.config = config + self.layer = nn.ModuleList( + [BertLayer(config, i) for i in range(config.num_hidden_layers)] + ) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_values=None, + use_cache=None, + output_attentions=False, + output_hidden_states=False, + return_dict=True, + query_length=0, + ): + all_hidden_states = () if output_hidden_states else None + all_self_attentions = () if output_attentions else None + all_cross_attentions = ( + () if output_attentions and self.config.add_cross_attention else None + ) + + next_decoder_cache = () if use_cache else None + + for i in range(self.config.num_hidden_layers): + layer_module = self.layer[i] + if output_hidden_states: + all_hidden_states = all_hidden_states + (hidden_states,) + + layer_head_mask = head_mask[i] if head_mask is not None else None + past_key_value = past_key_values[i] if past_key_values is not None else None + + if getattr(self.config, "gradient_checkpointing", False) and self.training: + + if use_cache: + logger.warn( + "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..." + ) + use_cache = False + + def create_custom_forward(module): + def custom_forward(*inputs): + return module( + *inputs, past_key_value, output_attentions, query_length + ) + + return custom_forward + + layer_outputs = torch.utils.checkpoint.checkpoint( + create_custom_forward(layer_module), + hidden_states, + attention_mask, + layer_head_mask, + encoder_hidden_states, + encoder_attention_mask, + ) + else: + layer_outputs = layer_module( + hidden_states, + attention_mask, + layer_head_mask, + encoder_hidden_states, + encoder_attention_mask, + past_key_value, + output_attentions, + query_length, + ) + + hidden_states = layer_outputs[0] + if use_cache: + next_decoder_cache += (layer_outputs[-1],) + if output_attentions: + all_self_attentions = all_self_attentions + (layer_outputs[1],) + all_cross_attentions = all_cross_attentions + (layer_outputs[2],) + + if output_hidden_states: + all_hidden_states = all_hidden_states + (hidden_states,) + + if not return_dict: + return tuple( + v + for v in [ + hidden_states, + next_decoder_cache, + all_hidden_states, + all_self_attentions, + all_cross_attentions, + ] + if v is not None + ) + return BaseModelOutputWithPastAndCrossAttentions( + last_hidden_state=hidden_states, + past_key_values=next_decoder_cache, + hidden_states=all_hidden_states, + attentions=all_self_attentions, + cross_attentions=all_cross_attentions, + ) + + +class BertPooler(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.hidden_size) + self.activation = nn.Tanh() + + def forward(self, hidden_states): + # We "pool" the model by simply taking the hidden state corresponding + # to the first token. + first_token_tensor = hidden_states[:, 0] + pooled_output = self.dense(first_token_tensor) + pooled_output = self.activation(pooled_output) + return pooled_output + + +class BertPredictionHeadTransform(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.hidden_size) + if isinstance(config.hidden_act, str): + self.transform_act_fn = ACT2FN[config.hidden_act] + else: + self.transform_act_fn = config.hidden_act + self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + + def forward(self, hidden_states): + hidden_states = self.dense(hidden_states) + hidden_states = self.transform_act_fn(hidden_states) + hidden_states = self.LayerNorm(hidden_states) + return hidden_states + + +class BertLMPredictionHead(nn.Module): + def __init__(self, config): + super().__init__() + self.transform = BertPredictionHeadTransform(config) + + # The output weights are the same as the input embeddings, but there is + # an output-only bias for each token. + self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False) + + self.bias = nn.Parameter(torch.zeros(config.vocab_size)) + + # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings` + self.decoder.bias = self.bias + + def forward(self, hidden_states): + hidden_states = self.transform(hidden_states) + hidden_states = self.decoder(hidden_states) + return hidden_states + + +class BertOnlyMLMHead(nn.Module): + def __init__(self, config): + super().__init__() + self.predictions = BertLMPredictionHead(config) + + def forward(self, sequence_output): + prediction_scores = self.predictions(sequence_output) + return prediction_scores + + +class BertPreTrainedModel(PreTrainedModel): + """ + An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained + models. + """ + + config_class = BertConfig + base_model_prefix = "bert" + _keys_to_ignore_on_load_missing = [r"position_ids"] + + def _init_weights(self, module): + """Initialize the weights""" + if isinstance(module, (nn.Linear, nn.Embedding)): + # Slightly different from the TF version which uses truncated_normal for initialization + # cf https://github.com/pytorch/pytorch/pull/5617 + module.weight.data.normal_(mean=0.0, std=self.config.initializer_range) + elif isinstance(module, nn.LayerNorm): + module.bias.data.zero_() + module.weight.data.fill_(1.0) + if isinstance(module, nn.Linear) and module.bias is not None: + module.bias.data.zero_() + + +class BertModel(BertPreTrainedModel): + """ + The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of + cross-attention is added between the self-attention layers, following the architecture described in `Attention is + all you need `__ by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, + Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin. + argument and :obj:`add_cross_attention` set to :obj:`True`; an :obj:`encoder_hidden_states` is then expected as an + input to the forward pass. + """ + + def __init__(self, config, add_pooling_layer=False): + super().__init__(config) + self.config = config + + self.embeddings = BertEmbeddings(config) + + self.encoder = BertEncoder(config) + + self.pooler = BertPooler(config) if add_pooling_layer else None + + self.init_weights() + + def get_input_embeddings(self): + return self.embeddings.word_embeddings + + def set_input_embeddings(self, value): + self.embeddings.word_embeddings = value + + def _prune_heads(self, heads_to_prune): + """ + Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base + class PreTrainedModel + """ + for layer, heads in heads_to_prune.items(): + self.encoder.layer[layer].attention.prune_heads(heads) + + def get_extended_attention_mask( + self, + attention_mask: Tensor, + input_shape: Tuple[int], + device: device, + is_decoder: bool, + has_query: bool = False, + ) -> Tensor: + """ + Makes broadcastable attention and causal masks so that future and masked tokens are ignored. + + Arguments: + attention_mask (:obj:`torch.Tensor`): + Mask with ones indicating tokens to attend to, zeros for tokens to ignore. + input_shape (:obj:`Tuple[int]`): + The shape of the input to the model. + device: (:obj:`torch.device`): + The device of the input to the model. + + Returns: + :obj:`torch.Tensor` The extended attention mask, with a the same dtype as :obj:`attention_mask.dtype`. + """ + # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length] + # ourselves in which case we just need to make it broadcastable to all heads. + if attention_mask.dim() == 3: + extended_attention_mask = attention_mask[:, None, :, :] + elif attention_mask.dim() == 2: + # Provided a padding mask of dimensions [batch_size, seq_length] + # - if the model is a decoder, apply a causal mask in addition to the padding mask + # - if the model is an encoder, make the mask broadcastable to [batch_size, num_heads, seq_length, seq_length] + if is_decoder: + batch_size, seq_length = input_shape + + seq_ids = torch.arange(seq_length, device=device) + causal_mask = ( + seq_ids[None, None, :].repeat(batch_size, seq_length, 1) + <= seq_ids[None, :, None] + ) + + # add a prefix ones mask to the causal mask + # causal and attention masks must have same type with pytorch version < 1.3 + causal_mask = causal_mask.to(attention_mask.dtype) + + if causal_mask.shape[1] < attention_mask.shape[1]: + prefix_seq_len = attention_mask.shape[1] - causal_mask.shape[1] + if has_query: # UniLM style attention mask + causal_mask = torch.cat( + [ + torch.zeros( + (batch_size, prefix_seq_len, seq_length), + device=device, + dtype=causal_mask.dtype, + ), + causal_mask, + ], + axis=1, + ) + causal_mask = torch.cat( + [ + torch.ones( + (batch_size, causal_mask.shape[1], prefix_seq_len), + device=device, + dtype=causal_mask.dtype, + ), + causal_mask, + ], + axis=-1, + ) + extended_attention_mask = ( + causal_mask[:, None, :, :] * attention_mask[:, None, None, :] + ) + else: + extended_attention_mask = attention_mask[:, None, None, :] + else: + raise ValueError( + "Wrong shape for input_ids (shape {}) or attention_mask (shape {})".format( + input_shape, attention_mask.shape + ) + ) + + # Since attention_mask is 1.0 for positions we want to attend and 0.0 for + # masked positions, this operation will create a tensor which is 0.0 for + # positions we want to attend and -10000.0 for masked positions. + # Since we are adding it to the raw scores before the softmax, this is + # effectively the same as removing these entirely. + extended_attention_mask = extended_attention_mask.to( + dtype=self.dtype + ) # fp16 compatibility + extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0 + return extended_attention_mask + + def forward( + self, + input_ids=None, + attention_mask=None, + position_ids=None, + head_mask=None, + query_embeds=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_values=None, + use_cache=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + is_decoder=False, + ): + r""" + encoder_hidden_states (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`): + Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if + the model is configured as a decoder. + encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in + the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``: + - 1 for tokens that are **not masked**, + - 0 for tokens that are **masked**. + past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`): + Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding. + If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids` + (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)` + instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`. + use_cache (:obj:`bool`, `optional`): + If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up + decoding (see :obj:`past_key_values`). + """ + output_attentions = ( + output_attentions + if output_attentions is not None + else self.config.output_attentions + ) + output_hidden_states = ( + output_hidden_states + if output_hidden_states is not None + else self.config.output_hidden_states + ) + return_dict = ( + return_dict if return_dict is not None else self.config.use_return_dict + ) + + # use_cache = use_cache if use_cache is not None else self.config.use_cache + + if input_ids is None: + assert ( + query_embeds is not None + ), "You have to specify query_embeds when input_ids is None" + + # past_key_values_length + past_key_values_length = ( + past_key_values[0][0].shape[2] - self.config.query_length + if past_key_values is not None + else 0 + ) + + query_length = query_embeds.shape[1] if query_embeds is not None else 0 + + embedding_output = self.embeddings( + input_ids=input_ids, + position_ids=position_ids, + query_embeds=query_embeds, + past_key_values_length=past_key_values_length, + ) + + input_shape = embedding_output.size()[:-1] + batch_size, seq_length = input_shape + device = embedding_output.device + + if attention_mask is None: + attention_mask = torch.ones( + ((batch_size, seq_length + past_key_values_length)), device=device + ) + + # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length] + # ourselves in which case we just need to make it broadcastable to all heads. + if is_decoder: + extended_attention_mask = self.get_extended_attention_mask( + attention_mask, + input_ids.shape, + device, + is_decoder, + has_query=(query_embeds is not None), + ) + else: + extended_attention_mask = self.get_extended_attention_mask( + attention_mask, input_shape, device, is_decoder + ) + + # If a 2D or 3D attention mask is provided for the cross-attention + # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length] + if encoder_hidden_states is not None: + if type(encoder_hidden_states) == list: + encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states[ + 0 + ].size() + else: + ( + encoder_batch_size, + encoder_sequence_length, + _, + ) = encoder_hidden_states.size() + encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length) + + if type(encoder_attention_mask) == list: + encoder_extended_attention_mask = [ + self.invert_attention_mask(mask) for mask in encoder_attention_mask + ] + elif encoder_attention_mask is None: + encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device) + encoder_extended_attention_mask = self.invert_attention_mask( + encoder_attention_mask + ) + else: + encoder_extended_attention_mask = self.invert_attention_mask( + encoder_attention_mask + ) + else: + encoder_extended_attention_mask = None + + # Prepare head mask if needed + # 1.0 in head_mask indicate we keep the head + # attention_probs has shape bsz x n_heads x N x N + # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads] + # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length] + head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers) + + encoder_outputs = self.encoder( + embedding_output, + attention_mask=extended_attention_mask, + head_mask=head_mask, + encoder_hidden_states=encoder_hidden_states, + encoder_attention_mask=encoder_extended_attention_mask, + past_key_values=past_key_values, + use_cache=use_cache, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + query_length=query_length, + ) + sequence_output = encoder_outputs[0] + pooled_output = ( + self.pooler(sequence_output) if self.pooler is not None else None + ) + + if not return_dict: + return (sequence_output, pooled_output) + encoder_outputs[1:] + + return BaseModelOutputWithPoolingAndCrossAttentions( + last_hidden_state=sequence_output, + pooler_output=pooled_output, + past_key_values=encoder_outputs.past_key_values, + hidden_states=encoder_outputs.hidden_states, + attentions=encoder_outputs.attentions, + cross_attentions=encoder_outputs.cross_attentions, + ) + + +class BertLMHeadModel(BertPreTrainedModel): + + _keys_to_ignore_on_load_unexpected = [r"pooler"] + _keys_to_ignore_on_load_missing = [r"position_ids", r"predictions.decoder.bias"] + + def __init__(self, config): + super().__init__(config) + + self.bert = BertModel(config, add_pooling_layer=False) + self.cls = BertOnlyMLMHead(config) + + self.init_weights() + + def get_output_embeddings(self): + return self.cls.predictions.decoder + + def set_output_embeddings(self, new_embeddings): + self.cls.predictions.decoder = new_embeddings + + def forward( + self, + input_ids=None, + attention_mask=None, + position_ids=None, + head_mask=None, + query_embeds=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + labels=None, + past_key_values=None, + use_cache=True, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + return_logits=False, + is_decoder=True, + reduction="mean", + ): + r""" + encoder_hidden_states (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`): + Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if + the model is configured as a decoder. + encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in + the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``: + - 1 for tokens that are **not masked**, + - 0 for tokens that are **masked**. + labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Labels for computing the left-to-right language modeling loss (next word prediction). Indices should be in + ``[-100, 0, ..., config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are + ignored (masked), the loss is only computed for the tokens with labels n ``[0, ..., config.vocab_size]`` + past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`): + Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding. + If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids` + (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)` + instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`. + use_cache (:obj:`bool`, `optional`): + If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up + decoding (see :obj:`past_key_values`). + Returns: + Example:: + >>> from transformers import BertTokenizer, BertLMHeadModel, BertConfig + >>> import torch + >>> tokenizer = BertTokenizer.from_pretrained('bert-base-cased') + >>> config = BertConfig.from_pretrained("bert-base-cased") + >>> model = BertLMHeadModel.from_pretrained('bert-base-cased', config=config) + >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") + >>> outputs = model(**inputs) + >>> prediction_logits = outputs.logits + """ + return_dict = ( + return_dict if return_dict is not None else self.config.use_return_dict + ) + if labels is not None: + use_cache = False + if past_key_values is not None: + query_embeds = None + + outputs = self.bert( + input_ids, + attention_mask=attention_mask, + position_ids=position_ids, + head_mask=head_mask, + query_embeds=query_embeds, + encoder_hidden_states=encoder_hidden_states, + encoder_attention_mask=encoder_attention_mask, + past_key_values=past_key_values, + use_cache=use_cache, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + is_decoder=is_decoder, + ) + + sequence_output = outputs[0] + if query_embeds is not None: + sequence_output = outputs[0][:, query_embeds.shape[1] :, :] + + prediction_scores = self.cls(sequence_output) + + if return_logits: + return prediction_scores[:, :-1, :].contiguous() + + lm_loss = None + if labels is not None: + # we are doing next-token prediction; shift prediction scores and input ids by one + shifted_prediction_scores = prediction_scores[:, :-1, :].contiguous() + labels = labels[:, 1:].contiguous() + loss_fct = CrossEntropyLoss(reduction=reduction, label_smoothing=0.1) + lm_loss = loss_fct( + shifted_prediction_scores.view(-1, self.config.vocab_size), + labels.view(-1), + ) + if reduction == "none": + lm_loss = lm_loss.view(prediction_scores.size(0), -1).sum(1) + + if not return_dict: + output = (prediction_scores,) + outputs[2:] + return ((lm_loss,) + output) if lm_loss is not None else output + + return CausalLMOutputWithCrossAttentions( + loss=lm_loss, + logits=prediction_scores, + past_key_values=outputs.past_key_values, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + cross_attentions=outputs.cross_attentions, + ) + + def prepare_inputs_for_generation( + self, input_ids, query_embeds, past=None, attention_mask=None, **model_kwargs + ): + # if model is used as a decoder in encoder-decoder model, the decoder attention mask is created on the fly + if attention_mask is None: + attention_mask = input_ids.new_ones(input_ids.shape) + query_mask = input_ids.new_ones(query_embeds.shape[:-1]) + attention_mask = torch.cat([query_mask, attention_mask], dim=-1) + + # cut decoder_input_ids if past is used + if past is not None: + input_ids = input_ids[:, -1:] + + return { + "input_ids": input_ids, + "query_embeds": query_embeds, + "attention_mask": attention_mask, + "past_key_values": past, + "encoder_hidden_states": model_kwargs.get("encoder_hidden_states", None), + "encoder_attention_mask": model_kwargs.get("encoder_attention_mask", None), + "is_decoder": True, + } + + def _reorder_cache(self, past, beam_idx): + reordered_past = () + for layer_past in past: + reordered_past += ( + tuple( + past_state.index_select(0, beam_idx) for past_state in layer_past + ), + ) + return reordered_past + + +class BertForMaskedLM(BertPreTrainedModel): + + _keys_to_ignore_on_load_unexpected = [r"pooler"] + _keys_to_ignore_on_load_missing = [r"position_ids", r"predictions.decoder.bias"] + + def __init__(self, config): + super().__init__(config) + + self.bert = BertModel(config, add_pooling_layer=False) + self.cls = BertOnlyMLMHead(config) + + self.init_weights() + + def get_output_embeddings(self): + return self.cls.predictions.decoder + + def set_output_embeddings(self, new_embeddings): + self.cls.predictions.decoder = new_embeddings + + def forward( + self, + input_ids=None, + attention_mask=None, + position_ids=None, + head_mask=None, + query_embeds=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + labels=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + return_logits=False, + is_decoder=False, + ): + r""" + labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Labels for computing the masked language modeling loss. Indices should be in ``[-100, 0, ..., + config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are ignored + (masked), the loss is only computed for the tokens with labels in ``[0, ..., config.vocab_size]`` + """ + + return_dict = ( + return_dict if return_dict is not None else self.config.use_return_dict + ) + + outputs = self.bert( + input_ids, + attention_mask=attention_mask, + position_ids=position_ids, + head_mask=head_mask, + query_embeds=query_embeds, + encoder_hidden_states=encoder_hidden_states, + encoder_attention_mask=encoder_attention_mask, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + is_decoder=is_decoder, + ) + + if query_embeds is not None: + sequence_output = outputs[0][:, query_embeds.shape[1] :, :] + prediction_scores = self.cls(sequence_output) + + if return_logits: + return prediction_scores + + masked_lm_loss = None + if labels is not None: + loss_fct = CrossEntropyLoss() # -100 index = padding token + masked_lm_loss = loss_fct( + prediction_scores.view(-1, self.config.vocab_size), labels.view(-1) + ) + + if not return_dict: + output = (prediction_scores,) + outputs[2:] + return ( + ((masked_lm_loss,) + output) if masked_lm_loss is not None else output + ) + + return MaskedLMOutput( + loss=masked_lm_loss, + logits=prediction_scores, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + ) diff --git a/minigpt4/models/__init__.py b/minigpt4/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5096a04317a51def52386b728124962b72a2574c --- /dev/null +++ b/minigpt4/models/__init__.py @@ -0,0 +1,200 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import logging +import torch +from omegaconf import OmegaConf + +from minigpt4.common.registry import registry +from minigpt4.models.base_model import BaseModel +from minigpt4.models.blip2 import Blip2Base +from minigpt4.models.mini_gpt4 import MiniGPT4 +from minigpt4.processors.base_processor import BaseProcessor + + +__all__ = [ + "load_model", + "BaseModel", + "Blip2Base", + "MiniGPT4", +] + + +def load_model(name, model_type, is_eval=False, device="cpu", checkpoint=None): + """ + Load supported models. + + To list all available models and types in registry: + >>> from minigpt4.models import model_zoo + >>> print(model_zoo) + + Args: + name (str): name of the model. + model_type (str): type of the model. + is_eval (bool): whether the model is in eval mode. Default: False. + device (str): device to use. Default: "cpu". + checkpoint (str): path or to checkpoint. Default: None. + Note that expecting the checkpoint to have the same keys in state_dict as the model. + + Returns: + model (torch.nn.Module): model. + """ + + model = registry.get_model_class(name).from_pretrained(model_type=model_type) + + if checkpoint is not None: + model.load_checkpoint(checkpoint) + + if is_eval: + model.eval() + + if device == "cpu": + model = model.float() + + return model.to(device) + + +def load_preprocess(config): + """ + Load preprocessor configs and construct preprocessors. + + If no preprocessor is specified, return BaseProcessor, which does not do any preprocessing. + + Args: + config (dict): preprocessor configs. + + Returns: + vis_processors (dict): preprocessors for visual inputs. + txt_processors (dict): preprocessors for text inputs. + + Key is "train" or "eval" for processors used in training and evaluation respectively. + """ + + def _build_proc_from_cfg(cfg): + return ( + registry.get_processor_class(cfg.name).from_config(cfg) + if cfg is not None + else BaseProcessor() + ) + + vis_processors = dict() + txt_processors = dict() + + vis_proc_cfg = config.get("vis_processor") + txt_proc_cfg = config.get("text_processor") + + if vis_proc_cfg is not None: + vis_train_cfg = vis_proc_cfg.get("train") + vis_eval_cfg = vis_proc_cfg.get("eval") + else: + vis_train_cfg = None + vis_eval_cfg = None + + vis_processors["train"] = _build_proc_from_cfg(vis_train_cfg) + vis_processors["eval"] = _build_proc_from_cfg(vis_eval_cfg) + + if txt_proc_cfg is not None: + txt_train_cfg = txt_proc_cfg.get("train") + txt_eval_cfg = txt_proc_cfg.get("eval") + else: + txt_train_cfg = None + txt_eval_cfg = None + + txt_processors["train"] = _build_proc_from_cfg(txt_train_cfg) + txt_processors["eval"] = _build_proc_from_cfg(txt_eval_cfg) + + return vis_processors, txt_processors + + +def load_model_and_preprocess(name, model_type, is_eval=False, device="cpu"): + """ + Load model and its related preprocessors. + + List all available models and types in registry: + >>> from minigpt4.models import model_zoo + >>> print(model_zoo) + + Args: + name (str): name of the model. + model_type (str): type of the model. + is_eval (bool): whether the model is in eval mode. Default: False. + device (str): device to use. Default: "cpu". + + Returns: + model (torch.nn.Module): model. + vis_processors (dict): preprocessors for visual inputs. + txt_processors (dict): preprocessors for text inputs. + """ + model_cls = registry.get_model_class(name) + + # load model + model = model_cls.from_pretrained(model_type=model_type) + + if is_eval: + model.eval() + + # load preprocess + cfg = OmegaConf.load(model_cls.default_config_path(model_type)) + if cfg is not None: + preprocess_cfg = cfg.preprocess + + vis_processors, txt_processors = load_preprocess(preprocess_cfg) + else: + vis_processors, txt_processors = None, None + logging.info( + f"""No default preprocess for model {name} ({model_type}). + This can happen if the model is not finetuned on downstream datasets, + or it is not intended for direct use without finetuning. + """ + ) + + if device == "cpu" or device == torch.device("cpu"): + model = model.float() + + return model.to(device), vis_processors, txt_processors + + +class ModelZoo: + """ + A utility class to create string representation of available model architectures and types. + + >>> from minigpt4.models import model_zoo + >>> # list all available models + >>> print(model_zoo) + >>> # show total number of models + >>> print(len(model_zoo)) + """ + + def __init__(self) -> None: + self.model_zoo = { + k: list(v.PRETRAINED_MODEL_CONFIG_DICT.keys()) + for k, v in registry.mapping["model_name_mapping"].items() + } + + def __str__(self) -> str: + return ( + "=" * 50 + + "\n" + + f"{'Architectures':<30} {'Types'}\n" + + "=" * 50 + + "\n" + + "\n".join( + [ + f"{name:<30} {', '.join(types)}" + for name, types in self.model_zoo.items() + ] + ) + ) + + def __iter__(self): + return iter(self.model_zoo.items()) + + def __len__(self): + return sum([len(v) for v in self.model_zoo.values()]) + + +model_zoo = ModelZoo() diff --git a/minigpt4/models/base_model.py b/minigpt4/models/base_model.py new file mode 100644 index 0000000000000000000000000000000000000000..dbfaf8e989d509bef7c4f06ac6d3de2b085e5d38 --- /dev/null +++ b/minigpt4/models/base_model.py @@ -0,0 +1,247 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import logging +import os + +import numpy as np +import torch +import torch.nn as nn +from minigpt4.common.dist_utils import download_cached_file, is_dist_avail_and_initialized +from minigpt4.common.utils import get_abs_path, is_url +from omegaconf import OmegaConf + + +class BaseModel(nn.Module): + """Base class for models.""" + + def __init__(self): + super().__init__() + + @property + def device(self): + return list(self.parameters())[0].device + + def load_checkpoint(self, url_or_filename): + """ + Load from a finetuned checkpoint. + + This should expect no mismatch in the model keys and the checkpoint keys. + """ + + if is_url(url_or_filename): + cached_file = download_cached_file( + url_or_filename, check_hash=False, progress=True + ) + checkpoint = torch.load(cached_file, map_location="cpu") + elif os.path.isfile(url_or_filename): + checkpoint = torch.load(url_or_filename, map_location="cpu") + else: + raise RuntimeError("checkpoint url or path is invalid") + + if "model" in checkpoint.keys(): + state_dict = checkpoint["model"] + else: + state_dict = checkpoint + + msg = self.load_state_dict(state_dict, strict=False) + + logging.info("Missing keys {}".format(msg.missing_keys)) + logging.info("load checkpoint from %s" % url_or_filename) + + return msg + + @classmethod + def from_pretrained(cls, model_type): + """ + Build a pretrained model from default configuration file, specified by model_type. + + Args: + - model_type (str): model type, specifying architecture and checkpoints. + + Returns: + - model (nn.Module): pretrained or finetuned model, depending on the configuration. + """ + model_cfg = OmegaConf.load(cls.default_config_path(model_type)).model + model = cls.from_config(model_cfg) + + return model + + @classmethod + def default_config_path(cls, model_type): + assert ( + model_type in cls.PRETRAINED_MODEL_CONFIG_DICT + ), "Unknown model type {}".format(model_type) + return get_abs_path(cls.PRETRAINED_MODEL_CONFIG_DICT[model_type]) + + def load_checkpoint_from_config(self, cfg, **kwargs): + """ + Load checkpoint as specified in the config file. + + If load_finetuned is True, load the finetuned model; otherwise, load the pretrained model. + When loading the pretrained model, each task-specific architecture may define their + own load_from_pretrained() method. + """ + load_finetuned = cfg.get("load_finetuned", True) + if load_finetuned: + finetune_path = cfg.get("finetuned", None) + assert ( + finetune_path is not None + ), "Found load_finetuned is True, but finetune_path is None." + self.load_checkpoint(url_or_filename=finetune_path) + else: + # load pre-trained weights + pretrain_path = cfg.get("pretrained", None) + assert "Found load_finetuned is False, but pretrain_path is None." + self.load_from_pretrained(url_or_filename=pretrain_path, **kwargs) + + def before_evaluation(self, **kwargs): + pass + + def show_n_params(self, return_str=True): + tot = 0 + for p in self.parameters(): + w = 1 + for x in p.shape: + w *= x + tot += w + if return_str: + if tot >= 1e6: + return "{:.1f}M".format(tot / 1e6) + else: + return "{:.1f}K".format(tot / 1e3) + else: + return tot + + +class BaseEncoder(nn.Module): + """ + Base class for primitive encoders, such as ViT, TimeSformer, etc. + """ + + def __init__(self): + super().__init__() + + def forward_features(self, samples, **kwargs): + raise NotImplementedError + + @property + def device(self): + return list(self.parameters())[0].device + + +class SharedQueueMixin: + @torch.no_grad() + def _dequeue_and_enqueue(self, image_feat, text_feat, idxs=None): + # gather keys before updating queue + image_feats = concat_all_gather(image_feat) + text_feats = concat_all_gather(text_feat) + + batch_size = image_feats.shape[0] + + ptr = int(self.queue_ptr) + assert self.queue_size % batch_size == 0 # for simplicity + + # replace the keys at ptr (dequeue and enqueue) + self.image_queue[:, ptr : ptr + batch_size] = image_feats.T + self.text_queue[:, ptr : ptr + batch_size] = text_feats.T + + if idxs is not None: + idxs = concat_all_gather(idxs) + self.idx_queue[:, ptr : ptr + batch_size] = idxs.T + + ptr = (ptr + batch_size) % self.queue_size # move pointer + self.queue_ptr[0] = ptr + + +class MomentumDistilationMixin: + @torch.no_grad() + def copy_params(self): + for model_pair in self.model_pairs: + for param, param_m in zip( + model_pair[0].parameters(), model_pair[1].parameters() + ): + param_m.data.copy_(param.data) # initialize + param_m.requires_grad = False # not update by gradient + + @torch.no_grad() + def _momentum_update(self): + for model_pair in self.model_pairs: + for param, param_m in zip( + model_pair[0].parameters(), model_pair[1].parameters() + ): + param_m.data = param_m.data * self.momentum + param.data * ( + 1.0 - self.momentum + ) + + +class GatherLayer(torch.autograd.Function): + """ + Gather tensors from all workers with support for backward propagation: + This implementation does not cut the gradients as torch.distributed.all_gather does. + """ + + @staticmethod + def forward(ctx, x): + output = [ + torch.zeros_like(x) for _ in range(torch.distributed.get_world_size()) + ] + torch.distributed.all_gather(output, x) + return tuple(output) + + @staticmethod + def backward(ctx, *grads): + all_gradients = torch.stack(grads) + torch.distributed.all_reduce(all_gradients) + return all_gradients[torch.distributed.get_rank()] + + +def all_gather_with_grad(tensors): + """ + Performs all_gather operation on the provided tensors. + Graph remains connected for backward grad computation. + """ + # Queue the gathered tensors + world_size = torch.distributed.get_world_size() + # There is no need for reduction in the single-proc case + if world_size == 1: + return tensors + + # tensor_all = GatherLayer.apply(tensors) + tensor_all = GatherLayer.apply(tensors) + + return torch.cat(tensor_all, dim=0) + + +@torch.no_grad() +def concat_all_gather(tensor): + """ + Performs all_gather operation on the provided tensors. + *** Warning ***: torch.distributed.all_gather has no gradient. + """ + # if use distributed training + if not is_dist_avail_and_initialized(): + return tensor + + tensors_gather = [ + torch.ones_like(tensor) for _ in range(torch.distributed.get_world_size()) + ] + torch.distributed.all_gather(tensors_gather, tensor, async_op=False) + + output = torch.cat(tensors_gather, dim=0) + return output + + +def tile(x, dim, n_tile): + init_dim = x.size(dim) + repeat_idx = [1] * x.dim() + repeat_idx[dim] = n_tile + x = x.repeat(*(repeat_idx)) + order_index = torch.LongTensor( + np.concatenate([init_dim * np.arange(n_tile) + i for i in range(init_dim)]) + ) + return torch.index_select(x, dim, order_index.to(x.device)) diff --git a/minigpt4/models/blip2.py b/minigpt4/models/blip2.py new file mode 100644 index 0000000000000000000000000000000000000000..bb04c4d95f102266d9f97ddd98050d65f5be7ff2 --- /dev/null +++ b/minigpt4/models/blip2.py @@ -0,0 +1,221 @@ +""" + Copyright (c) 2023, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" +import contextlib +import logging +import os +import time +import datetime + +import torch +import torch.nn as nn +import torch.distributed as dist +import torch.nn.functional as F + +import minigpt4.common.dist_utils as dist_utils +from minigpt4.common.dist_utils import download_cached_file +from minigpt4.common.utils import is_url +from minigpt4.common.logger import MetricLogger +from minigpt4.models.base_model import BaseModel +from minigpt4.models.Qformer import BertConfig, BertLMHeadModel +from minigpt4.models.eva_vit import create_eva_vit_g +from transformers import BertTokenizer + + +class Blip2Base(BaseModel): + @classmethod + def init_tokenizer(cls): + tokenizer = BertTokenizer.from_pretrained("bert-base-uncased") + tokenizer.add_special_tokens({"bos_token": "[DEC]"}) + return tokenizer + + def maybe_autocast(self, dtype=torch.float16): + # if on cpu, don't use autocast + # if on gpu, use autocast with dtype if provided, otherwise use torch.float16 + enable_autocast = self.device != torch.device("cpu") + + if enable_autocast: + return torch.cuda.amp.autocast(dtype=dtype) + else: + return contextlib.nullcontext() + + @classmethod + def init_Qformer(cls, num_query_token, vision_width, cross_attention_freq=2): + encoder_config = BertConfig.from_pretrained("bert-base-uncased") + encoder_config.encoder_width = vision_width + # insert cross-attention layer every other block + encoder_config.add_cross_attention = True + encoder_config.cross_attention_freq = cross_attention_freq + encoder_config.query_length = num_query_token + Qformer = BertLMHeadModel(config=encoder_config) + query_tokens = nn.Parameter( + torch.zeros(1, num_query_token, encoder_config.hidden_size) + ) + query_tokens.data.normal_(mean=0.0, std=encoder_config.initializer_range) + return Qformer, query_tokens + + @classmethod + def init_vision_encoder( + cls, model_name, img_size, drop_path_rate, use_grad_checkpoint, precision + ): + assert model_name == "eva_clip_g", "vit model must be eva_clip_g for current version of MiniGPT-4" + visual_encoder = create_eva_vit_g( + img_size, drop_path_rate, use_grad_checkpoint, precision + ) + + ln_vision = LayerNorm(visual_encoder.num_features) + return visual_encoder, ln_vision + + def load_from_pretrained(self, url_or_filename): + if is_url(url_or_filename): + cached_file = download_cached_file( + url_or_filename, check_hash=False, progress=True + ) + checkpoint = torch.load(cached_file, map_location="cpu") + elif os.path.isfile(url_or_filename): + checkpoint = torch.load(url_or_filename, map_location="cpu") + else: + raise RuntimeError("checkpoint url or path is invalid") + + state_dict = checkpoint["model"] + + msg = self.load_state_dict(state_dict, strict=False) + + # logging.info("Missing keys {}".format(msg.missing_keys)) + logging.info("load checkpoint from %s" % url_or_filename) + + return msg + + +def disabled_train(self, mode=True): + """Overwrite model.train with this function to make sure train/eval mode + does not change anymore.""" + return self + + +class LayerNorm(nn.LayerNorm): + """Subclass torch's LayerNorm to handle fp16.""" + + def forward(self, x: torch.Tensor): + orig_type = x.dtype + ret = super().forward(x.type(torch.float32)) + return ret.type(orig_type) + + +def compute_sim_matrix(model, data_loader, **kwargs): + k_test = kwargs.pop("k_test") + + metric_logger = MetricLogger(delimiter=" ") + header = "Evaluation:" + + logging.info("Computing features for evaluation...") + start_time = time.time() + + texts = data_loader.dataset.text + num_text = len(texts) + text_bs = 256 + text_ids = [] + text_embeds = [] + text_atts = [] + for i in range(0, num_text, text_bs): + text = texts[i : min(num_text, i + text_bs)] + text_input = model.tokenizer( + text, + padding="max_length", + truncation=True, + max_length=35, + return_tensors="pt", + ).to(model.device) + text_feat = model.forward_text(text_input) + text_embed = F.normalize(model.text_proj(text_feat)) + text_embeds.append(text_embed) + text_ids.append(text_input.input_ids) + text_atts.append(text_input.attention_mask) + + text_embeds = torch.cat(text_embeds, dim=0) + text_ids = torch.cat(text_ids, dim=0) + text_atts = torch.cat(text_atts, dim=0) + + vit_feats = [] + image_embeds = [] + for samples in data_loader: + image = samples["image"] + + image = image.to(model.device) + image_feat, vit_feat = model.forward_image(image) + image_embed = model.vision_proj(image_feat) + image_embed = F.normalize(image_embed, dim=-1) + + vit_feats.append(vit_feat.cpu()) + image_embeds.append(image_embed) + + vit_feats = torch.cat(vit_feats, dim=0) + image_embeds = torch.cat(image_embeds, dim=0) + + sims_matrix = [] + for image_embed in image_embeds: + sim_q2t = image_embed @ text_embeds.t() + sim_i2t, _ = sim_q2t.max(0) + sims_matrix.append(sim_i2t) + sims_matrix = torch.stack(sims_matrix, dim=0) + + score_matrix_i2t = torch.full( + (len(data_loader.dataset.image), len(texts)), -100.0 + ).to(model.device) + + num_tasks = dist_utils.get_world_size() + rank = dist_utils.get_rank() + step = sims_matrix.size(0) // num_tasks + 1 + start = rank * step + end = min(sims_matrix.size(0), start + step) + + for i, sims in enumerate( + metric_logger.log_every(sims_matrix[start:end], 50, header) + ): + topk_sim, topk_idx = sims.topk(k=k_test, dim=0) + image_inputs = vit_feats[start + i].repeat(k_test, 1, 1).to(model.device) + score = model.compute_itm( + image_inputs=image_inputs, + text_ids=text_ids[topk_idx], + text_atts=text_atts[topk_idx], + ).float() + score_matrix_i2t[start + i, topk_idx] = score + topk_sim + + sims_matrix = sims_matrix.t() + score_matrix_t2i = torch.full( + (len(texts), len(data_loader.dataset.image)), -100.0 + ).to(model.device) + + step = sims_matrix.size(0) // num_tasks + 1 + start = rank * step + end = min(sims_matrix.size(0), start + step) + + for i, sims in enumerate( + metric_logger.log_every(sims_matrix[start:end], 50, header) + ): + topk_sim, topk_idx = sims.topk(k=k_test, dim=0) + image_inputs = vit_feats[topk_idx.cpu()].to(model.device) + score = model.compute_itm( + image_inputs=image_inputs, + text_ids=text_ids[start + i].repeat(k_test, 1), + text_atts=text_atts[start + i].repeat(k_test, 1), + ).float() + score_matrix_t2i[start + i, topk_idx] = score + topk_sim + + if dist_utils.is_dist_avail_and_initialized(): + dist.barrier() + torch.distributed.all_reduce( + score_matrix_i2t, op=torch.distributed.ReduceOp.SUM + ) + torch.distributed.all_reduce( + score_matrix_t2i, op=torch.distributed.ReduceOp.SUM + ) + + total_time = time.time() - start_time + total_time_str = str(datetime.timedelta(seconds=int(total_time))) + logging.info("Evaluation time {}".format(total_time_str)) + + return score_matrix_i2t.cpu().numpy(), score_matrix_t2i.cpu().numpy() diff --git a/minigpt4/models/blip2_outputs.py b/minigpt4/models/blip2_outputs.py new file mode 100644 index 0000000000000000000000000000000000000000..1135e8b51b8a92e0ea5bf67725fb989236e7a703 --- /dev/null +++ b/minigpt4/models/blip2_outputs.py @@ -0,0 +1,110 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +from dataclasses import dataclass +from typing import Optional + +import torch +from transformers.modeling_outputs import ( + ModelOutput, + BaseModelOutputWithPoolingAndCrossAttentions, + CausalLMOutputWithCrossAttentions, +) + + +@dataclass +class BlipSimilarity(ModelOutput): + sim_i2t: torch.FloatTensor = None + sim_t2i: torch.FloatTensor = None + + sim_i2t_m: Optional[torch.FloatTensor] = None + sim_t2i_m: Optional[torch.FloatTensor] = None + + sim_i2t_targets: Optional[torch.FloatTensor] = None + sim_t2i_targets: Optional[torch.FloatTensor] = None + + +@dataclass +class BlipIntermediateOutput(ModelOutput): + """ + Data class for intermediate outputs of BLIP models. + + image_embeds (torch.FloatTensor): Image embeddings, shape (batch_size, num_patches, embed_dim). + text_embeds (torch.FloatTensor): Text embeddings, shape (batch_size, seq_len, embed_dim). + + image_embeds_m (torch.FloatTensor): Image embeddings from momentum visual encoder, shape (batch_size, num_patches, embed_dim). + text_embeds_m (torch.FloatTensor): Text embeddings from momentum text encoder, shape (batch_size, seq_len, embed_dim). + + encoder_output (BaseModelOutputWithPoolingAndCrossAttentions): output from the image-grounded text encoder. + encoder_output_neg (BaseModelOutputWithPoolingAndCrossAttentions): output from the image-grounded text encoder for negative pairs. + + decoder_output (CausalLMOutputWithCrossAttentions): output from the image-grounded text decoder. + decoder_labels (torch.LongTensor): labels for the captioning loss. + + itm_logits (torch.FloatTensor): logits for the image-text matching loss, shape (batch_size * 3, 2). + itm_labels (torch.LongTensor): labels for the image-text matching loss, shape (batch_size * 3,) + + """ + + # uni-modal features + image_embeds: torch.FloatTensor = None + text_embeds: Optional[torch.FloatTensor] = None + + image_embeds_m: Optional[torch.FloatTensor] = None + text_embeds_m: Optional[torch.FloatTensor] = None + + # intermediate outputs of multimodal encoder + encoder_output: Optional[BaseModelOutputWithPoolingAndCrossAttentions] = None + encoder_output_neg: Optional[BaseModelOutputWithPoolingAndCrossAttentions] = None + + itm_logits: Optional[torch.FloatTensor] = None + itm_labels: Optional[torch.LongTensor] = None + + # intermediate outputs of multimodal decoder + decoder_output: Optional[CausalLMOutputWithCrossAttentions] = None + decoder_labels: Optional[torch.LongTensor] = None + + +@dataclass +class BlipOutput(ModelOutput): + # some finetuned models (e.g. BlipVQA) do not compute similarity, thus optional. + sims: Optional[BlipSimilarity] = None + + intermediate_output: BlipIntermediateOutput = None + + loss: Optional[torch.FloatTensor] = None + + loss_itc: Optional[torch.FloatTensor] = None + + loss_itm: Optional[torch.FloatTensor] = None + + loss_lm: Optional[torch.FloatTensor] = None + + +@dataclass +class BlipOutputFeatures(ModelOutput): + """ + Data class of features from BlipFeatureExtractor. + + Args: + image_embeds: (torch.FloatTensor) of shape (batch_size, num_patches+1, embed_dim), optional + image_features: (torch.FloatTensor) of shape (batch_size, num_patches+1, feature_dim), optional + text_embeds: (torch.FloatTensor) of shape (batch_size, sequence_length+1, embed_dim), optional + text_features: (torch.FloatTensor) of shape (batch_size, sequence_length+1, feature_dim), optional + + The first embedding or feature is for the [CLS] token. + + Features are obtained by projecting the corresponding embedding into a normalized low-dimensional space. + """ + + image_embeds: Optional[torch.FloatTensor] = None + image_embeds_proj: Optional[torch.FloatTensor] = None + + text_embeds: Optional[torch.FloatTensor] = None + text_embeds_proj: Optional[torch.FloatTensor] = None + + multimodal_embeds: Optional[torch.FloatTensor] = None diff --git a/minigpt4/models/eva_vit.py b/minigpt4/models/eva_vit.py new file mode 100644 index 0000000000000000000000000000000000000000..7fcc63a74049f1faf65c99943ef94f72383ca3f5 --- /dev/null +++ b/minigpt4/models/eva_vit.py @@ -0,0 +1,442 @@ +# Based on EVA, BEIT, timm and DeiT code bases +# https://github.com/baaivision/EVA +# https://github.com/rwightman/pytorch-image-models/tree/master/timm +# https://github.com/microsoft/unilm/tree/master/beit +# https://github.com/facebookresearch/deit/ +# https://github.com/facebookresearch/dino +# --------------------------------------------------------' +import math +from functools import partial + +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.utils.checkpoint as checkpoint +from timm.models.layers import drop_path, to_2tuple, trunc_normal_ +from timm.models.registry import register_model + +from minigpt4.common.dist_utils import download_cached_file + +def _cfg(url='', **kwargs): + return { + 'url': url, + 'num_classes': 1000, 'input_size': (3, 224, 224), 'pool_size': None, + 'crop_pct': .9, 'interpolation': 'bicubic', + 'mean': (0.5, 0.5, 0.5), 'std': (0.5, 0.5, 0.5), + **kwargs + } + + +class DropPath(nn.Module): + """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks). + """ + def __init__(self, drop_prob=None): + super(DropPath, self).__init__() + self.drop_prob = drop_prob + + def forward(self, x): + return drop_path(x, self.drop_prob, self.training) + + def extra_repr(self) -> str: + return 'p={}'.format(self.drop_prob) + + +class Mlp(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features) + self.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features) + self.drop = nn.Dropout(drop) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + # x = self.drop(x) + # commit this for the orignal BERT implement + x = self.fc2(x) + x = self.drop(x) + return x + + +class Attention(nn.Module): + def __init__( + self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., + proj_drop=0., window_size=None, attn_head_dim=None): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + if attn_head_dim is not None: + head_dim = attn_head_dim + all_head_dim = head_dim * self.num_heads + self.scale = qk_scale or head_dim ** -0.5 + + self.qkv = nn.Linear(dim, all_head_dim * 3, bias=False) + if qkv_bias: + self.q_bias = nn.Parameter(torch.zeros(all_head_dim)) + self.v_bias = nn.Parameter(torch.zeros(all_head_dim)) + else: + self.q_bias = None + self.v_bias = None + + if window_size: + self.window_size = window_size + self.num_relative_distance = (2 * window_size[0] - 1) * (2 * window_size[1] - 1) + 3 + self.relative_position_bias_table = nn.Parameter( + torch.zeros(self.num_relative_distance, num_heads)) # 2*Wh-1 * 2*Ww-1, nH + # cls to token & token 2 cls & cls to cls + + # get pair-wise relative position index for each token inside the window + coords_h = torch.arange(window_size[0]) + coords_w = torch.arange(window_size[1]) + coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # 2, Wh, Ww + coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww + relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww + relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2 + relative_coords[:, :, 0] += window_size[0] - 1 # shift to start from 0 + relative_coords[:, :, 1] += window_size[1] - 1 + relative_coords[:, :, 0] *= 2 * window_size[1] - 1 + relative_position_index = \ + torch.zeros(size=(window_size[0] * window_size[1] + 1, ) * 2, dtype=relative_coords.dtype) + relative_position_index[1:, 1:] = relative_coords.sum(-1) # Wh*Ww, Wh*Ww + relative_position_index[0, 0:] = self.num_relative_distance - 3 + relative_position_index[0:, 0] = self.num_relative_distance - 2 + relative_position_index[0, 0] = self.num_relative_distance - 1 + + self.register_buffer("relative_position_index", relative_position_index) + else: + self.window_size = None + self.relative_position_bias_table = None + self.relative_position_index = None + + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(all_head_dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + + def forward(self, x, rel_pos_bias=None): + B, N, C = x.shape + qkv_bias = None + if self.q_bias is not None: + qkv_bias = torch.cat((self.q_bias, torch.zeros_like(self.v_bias, requires_grad=False), self.v_bias)) + # qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4) + qkv = F.linear(input=x, weight=self.qkv.weight, bias=qkv_bias) + qkv = qkv.reshape(B, N, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4) + q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple) + + q = q * self.scale + attn = (q @ k.transpose(-2, -1)) + + if self.relative_position_bias_table is not None: + relative_position_bias = \ + self.relative_position_bias_table[self.relative_position_index.view(-1)].view( + self.window_size[0] * self.window_size[1] + 1, + self.window_size[0] * self.window_size[1] + 1, -1) # Wh*Ww,Wh*Ww,nH + relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww + attn = attn + relative_position_bias.unsqueeze(0) + + if rel_pos_bias is not None: + attn = attn + rel_pos_bias + + attn = attn.softmax(dim=-1) + attn = self.attn_drop(attn) + + x = (attn @ v).transpose(1, 2).reshape(B, N, -1) + x = self.proj(x) + x = self.proj_drop(x) + return x + + +class Block(nn.Module): + + def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0., + drop_path=0., init_values=None, act_layer=nn.GELU, norm_layer=nn.LayerNorm, + window_size=None, attn_head_dim=None): + super().__init__() + self.norm1 = norm_layer(dim) + self.attn = Attention( + dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, + attn_drop=attn_drop, proj_drop=drop, window_size=window_size, attn_head_dim=attn_head_dim) + # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here + self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity() + self.norm2 = norm_layer(dim) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop) + + if init_values is not None and init_values > 0: + self.gamma_1 = nn.Parameter(init_values * torch.ones((dim)),requires_grad=True) + self.gamma_2 = nn.Parameter(init_values * torch.ones((dim)),requires_grad=True) + else: + self.gamma_1, self.gamma_2 = None, None + + def forward(self, x, rel_pos_bias=None): + if self.gamma_1 is None: + x = x + self.drop_path(self.attn(self.norm1(x), rel_pos_bias=rel_pos_bias)) + x = x + self.drop_path(self.mlp(self.norm2(x))) + else: + x = x + self.drop_path(self.gamma_1 * self.attn(self.norm1(x), rel_pos_bias=rel_pos_bias)) + x = x + self.drop_path(self.gamma_2 * self.mlp(self.norm2(x))) + return x + + +class PatchEmbed(nn.Module): + """ Image to Patch Embedding + """ + def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0]) + self.patch_shape = (img_size[0] // patch_size[0], img_size[1] // patch_size[1]) + self.img_size = img_size + self.patch_size = patch_size + self.num_patches = num_patches + + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size) + + def forward(self, x, **kwargs): + B, C, H, W = x.shape + # FIXME look at relaxing size constraints + assert H == self.img_size[0] and W == self.img_size[1], \ + f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})." + x = self.proj(x).flatten(2).transpose(1, 2) + return x + + +class RelativePositionBias(nn.Module): + + def __init__(self, window_size, num_heads): + super().__init__() + self.window_size = window_size + self.num_relative_distance = (2 * window_size[0] - 1) * (2 * window_size[1] - 1) + 3 + self.relative_position_bias_table = nn.Parameter( + torch.zeros(self.num_relative_distance, num_heads)) # 2*Wh-1 * 2*Ww-1, nH + # cls to token & token 2 cls & cls to cls + + # get pair-wise relative position index for each token inside the window + coords_h = torch.arange(window_size[0]) + coords_w = torch.arange(window_size[1]) + coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # 2, Wh, Ww + coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww + relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww + relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2 + relative_coords[:, :, 0] += window_size[0] - 1 # shift to start from 0 + relative_coords[:, :, 1] += window_size[1] - 1 + relative_coords[:, :, 0] *= 2 * window_size[1] - 1 + relative_position_index = \ + torch.zeros(size=(window_size[0] * window_size[1] + 1,) * 2, dtype=relative_coords.dtype) + relative_position_index[1:, 1:] = relative_coords.sum(-1) # Wh*Ww, Wh*Ww + relative_position_index[0, 0:] = self.num_relative_distance - 3 + relative_position_index[0:, 0] = self.num_relative_distance - 2 + relative_position_index[0, 0] = self.num_relative_distance - 1 + + self.register_buffer("relative_position_index", relative_position_index) + + # trunc_normal_(self.relative_position_bias_table, std=.02) + + def forward(self): + relative_position_bias = \ + self.relative_position_bias_table[self.relative_position_index.view(-1)].view( + self.window_size[0] * self.window_size[1] + 1, + self.window_size[0] * self.window_size[1] + 1, -1) # Wh*Ww,Wh*Ww,nH + return relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww + + +class VisionTransformer(nn.Module): + """ Vision Transformer with support for patch or hybrid CNN input stage + """ + def __init__(self, img_size=224, patch_size=16, in_chans=3, num_classes=1000, embed_dim=768, depth=12, + num_heads=12, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop_rate=0., attn_drop_rate=0., + drop_path_rate=0., norm_layer=nn.LayerNorm, init_values=None, + use_abs_pos_emb=True, use_rel_pos_bias=False, use_shared_rel_pos_bias=False, + use_mean_pooling=True, init_scale=0.001, use_checkpoint=False): + super().__init__() + self.image_size = img_size + self.num_classes = num_classes + self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models + + self.patch_embed = PatchEmbed( + img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim) + num_patches = self.patch_embed.num_patches + + self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + if use_abs_pos_emb: + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim)) + else: + self.pos_embed = None + self.pos_drop = nn.Dropout(p=drop_rate) + + if use_shared_rel_pos_bias: + self.rel_pos_bias = RelativePositionBias(window_size=self.patch_embed.patch_shape, num_heads=num_heads) + else: + self.rel_pos_bias = None + self.use_checkpoint = use_checkpoint + + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)] # stochastic depth decay rule + self.use_rel_pos_bias = use_rel_pos_bias + self.blocks = nn.ModuleList([ + Block( + dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer, + init_values=init_values, window_size=self.patch_embed.patch_shape if use_rel_pos_bias else None) + for i in range(depth)]) +# self.norm = nn.Identity() if use_mean_pooling else norm_layer(embed_dim) +# self.fc_norm = norm_layer(embed_dim) if use_mean_pooling else None +# self.head = nn.Linear(embed_dim, num_classes) if num_classes > 0 else nn.Identity() + + if self.pos_embed is not None: + trunc_normal_(self.pos_embed, std=.02) + trunc_normal_(self.cls_token, std=.02) + # trunc_normal_(self.mask_token, std=.02) +# if isinstance(self.head, nn.Linear): +# trunc_normal_(self.head.weight, std=.02) + self.apply(self._init_weights) + self.fix_init_weight() +# if isinstance(self.head, nn.Linear): +# self.head.weight.data.mul_(init_scale) +# self.head.bias.data.mul_(init_scale) + + def fix_init_weight(self): + def rescale(param, layer_id): + param.div_(math.sqrt(2.0 * layer_id)) + + for layer_id, layer in enumerate(self.blocks): + rescale(layer.attn.proj.weight.data, layer_id + 1) + rescale(layer.mlp.fc2.weight.data, layer_id + 1) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + + def get_classifier(self): + return self.head + + def reset_classifier(self, num_classes, global_pool=''): + self.num_classes = num_classes + self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity() + + def forward_features(self, x): + x = self.patch_embed(x) + batch_size, seq_len, _ = x.size() + + cls_tokens = self.cls_token.expand(batch_size, -1, -1) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_tokens, x), dim=1) + if self.pos_embed is not None: + x = x + self.pos_embed + x = self.pos_drop(x) + + rel_pos_bias = self.rel_pos_bias() if self.rel_pos_bias is not None else None + for blk in self.blocks: + if self.use_checkpoint: + x = checkpoint.checkpoint(blk, x, rel_pos_bias) + else: + x = blk(x, rel_pos_bias) + return x +# x = self.norm(x) + +# if self.fc_norm is not None: +# t = x[:, 1:, :] +# return self.fc_norm(t.mean(1)) +# else: +# return x[:, 0] + + def forward(self, x): + x = self.forward_features(x) +# x = self.head(x) + return x + + def get_intermediate_layers(self, x): + x = self.patch_embed(x) + batch_size, seq_len, _ = x.size() + + cls_tokens = self.cls_token.expand(batch_size, -1, -1) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_tokens, x), dim=1) + if self.pos_embed is not None: + x = x + self.pos_embed + x = self.pos_drop(x) + + features = [] + rel_pos_bias = self.rel_pos_bias() if self.rel_pos_bias is not None else None + for blk in self.blocks: + x = blk(x, rel_pos_bias) + features.append(x) + + return features + + +def interpolate_pos_embed(model, checkpoint_model): + if 'pos_embed' in checkpoint_model: + pos_embed_checkpoint = checkpoint_model['pos_embed'].float() + embedding_size = pos_embed_checkpoint.shape[-1] + num_patches = model.patch_embed.num_patches + num_extra_tokens = model.pos_embed.shape[-2] - num_patches + # height (== width) for the checkpoint position embedding + orig_size = int((pos_embed_checkpoint.shape[-2] - num_extra_tokens) ** 0.5) + # height (== width) for the new position embedding + new_size = int(num_patches ** 0.5) + # class_token and dist_token are kept unchanged + if orig_size != new_size: + print("Position interpolate from %dx%d to %dx%d" % (orig_size, orig_size, new_size, new_size)) + extra_tokens = pos_embed_checkpoint[:, :num_extra_tokens] + # only the position tokens are interpolated + pos_tokens = pos_embed_checkpoint[:, num_extra_tokens:] + pos_tokens = pos_tokens.reshape(-1, orig_size, orig_size, embedding_size).permute(0, 3, 1, 2) + pos_tokens = torch.nn.functional.interpolate( + pos_tokens, size=(new_size, new_size), mode='bicubic', align_corners=False) + pos_tokens = pos_tokens.permute(0, 2, 3, 1).flatten(1, 2) + new_pos_embed = torch.cat((extra_tokens, pos_tokens), dim=1) + checkpoint_model['pos_embed'] = new_pos_embed + + +def convert_weights_to_fp16(model: nn.Module): + """Convert applicable model parameters to fp16""" + + def _convert_weights_to_fp16(l): + if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)): + l.weight.data = l.weight.data.half() + if l.bias is not None: + l.bias.data = l.bias.data.half() + +# if isinstance(l, (nn.MultiheadAttention, Attention)): +# for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]: +# tensor = getattr(l, attr) +# if tensor is not None: +# tensor.data = tensor.data.half() + + model.apply(_convert_weights_to_fp16) + + +def create_eva_vit_g(img_size=224,drop_path_rate=0.4,use_checkpoint=False,precision="fp16"): + model = VisionTransformer( + img_size=img_size, + patch_size=14, + use_mean_pooling=False, + embed_dim=1408, + depth=39, + num_heads=1408//88, + mlp_ratio=4.3637, + qkv_bias=True, + drop_path_rate=drop_path_rate, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + use_checkpoint=use_checkpoint, + ) + url = "https://storage.googleapis.com/sfr-vision-language-research/LAVIS/models/BLIP2/eva_vit_g.pth" + cached_file = download_cached_file( + url, check_hash=False, progress=True + ) + state_dict = torch.load(cached_file, map_location="cpu") + interpolate_pos_embed(model,state_dict) + + incompatible_keys = model.load_state_dict(state_dict, strict=False) +# print(incompatible_keys) + + if precision == "fp16": +# model.to("cuda") + convert_weights_to_fp16(model) + return model \ No newline at end of file diff --git a/minigpt4/models/mini_gpt4.py b/minigpt4/models/mini_gpt4.py new file mode 100644 index 0000000000000000000000000000000000000000..a1c3a44d76d4554c26abb4d0700ff46d3c4c8a19 --- /dev/null +++ b/minigpt4/models/mini_gpt4.py @@ -0,0 +1,256 @@ +""" + Copyright (c) 2023, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" +import logging +import random + +import torch +from torch.cuda.amp import autocast as autocast +import torch.nn as nn + +from minigpt4.common.registry import registry +from minigpt4.models.blip2 import Blip2Base, disabled_train +from minigpt4.models.modeling_llama import LlamaForCausalLM +from transformers import LlamaTokenizer + + +@registry.register_model("mini_gpt4") +class MiniGPT4(Blip2Base): + """ + BLIP2 GPT-LLAMA model. + """ + + PRETRAINED_MODEL_CONFIG_DICT = { + "pretrain_vicuna": "configs/models/minigpt4.yaml", + } + + def __init__( + self, + vit_model="eva_clip_g", + q_former_model="https://storage.googleapis.com/sfr-vision-language-research/LAVIS/models/BLIP2/blip2_pretrained_flant5xxl.pth", + img_size=224, + drop_path_rate=0, + use_grad_checkpoint=False, + vit_precision="fp16", + freeze_vit=True, + freeze_qformer=True, + num_query_token=32, + llama_model="", + llama_cache_dir='', + prompt_path="", + prompt_template="", + max_txt_len=32, + end_sym='\n', + ): + super().__init__() + + self.tokenizer = self.init_tokenizer() + + print('Loading VIT') + self.visual_encoder, self.ln_vision = self.init_vision_encoder( + vit_model, img_size, drop_path_rate, use_grad_checkpoint, vit_precision + ) + if freeze_vit: + for name, param in self.visual_encoder.named_parameters(): + param.requires_grad = False + self.visual_encoder = self.visual_encoder.eval() + self.visual_encoder.train = disabled_train + for name, param in self.ln_vision.named_parameters(): + param.requires_grad = False + self.ln_vision = self.ln_vision.eval() + self.ln_vision.train = disabled_train + logging.info("freeze vision encoder") + print('Loading VIT Done') + + print('Loading Q-Former') + self.Qformer, self.query_tokens = self.init_Qformer( + num_query_token, self.visual_encoder.num_features + ) + self.Qformer.cls = None + self.Qformer.bert.embeddings.word_embeddings = None + self.Qformer.bert.embeddings.position_embeddings = None + for layer in self.Qformer.bert.encoder.layer: + layer.output = None + layer.intermediate = None + self.load_from_pretrained(url_or_filename=q_former_model) + + if freeze_qformer: + for name, param in self.Qformer.named_parameters(): + param.requires_grad = False + self.Qformer = self.Qformer.eval() + self.Qformer.train = disabled_train + self.query_tokens.requires_grad = False + logging.info("freeze Qformer") + print('Loading Q-Former Done') + + print('Loading LLAMA') + self.llama_tokenizer = LlamaTokenizer.from_pretrained(llama_model, use_fast=False) + self.llama_tokenizer.pad_token = self.llama_tokenizer.eos_token + + if llama_cache_dir: + self.llama_model = LlamaForCausalLM.from_pretrained( + llama_model, load_in_8bit=True, torch_dtype=torch.float16, device_map={'': 0}, cache_dir=llama_cache_dir + ) + else: + self.llama_model = LlamaForCausalLM.from_pretrained( + llama_model, load_in_8bit=True, torch_dtype=torch.float16, device_map={'': 0} + ) + for name, param in self.llama_model.named_parameters(): + param.requires_grad = False + print('Loading LLAMA Done') + + self.llama_proj = nn.Linear( + self.Qformer.config.hidden_size, self.llama_model.config.hidden_size + ) + self.max_txt_len = max_txt_len + self.end_sym = end_sym + + if prompt_path: + with open(prompt_path, 'r') as f: + raw_prompts = f.read().splitlines() + filted_prompts = [raw_prompt for raw_prompt in raw_prompts if "" in raw_prompt] + self.prompt_list = [prompt_template.format(p) for p in filted_prompts] + print('Load {} training prompts'.format(len(self.prompt_list))) + print('Prompt Example \n{}'.format(random.choice(self.prompt_list))) + else: + self.prompt_list = [] + + def encode_img(self, image): + with self.maybe_autocast(): + image_embeds = self.ln_vision(self.visual_encoder(image)) + image_atts = torch.ones(image_embeds.size()[:-1], dtype=torch.long).to( + image.device + ) + + query_tokens = self.query_tokens.expand(image_embeds.shape[0], -1, -1) + query_output = self.Qformer.bert( + query_embeds=query_tokens, + encoder_hidden_states=image_embeds, + encoder_attention_mask=image_atts, + return_dict=True, + ) + + inputs_llama = self.llama_proj(query_output.last_hidden_state) + atts_llama = torch.ones(inputs_llama.size()[:-1], dtype=torch.long).to(image.device) + return inputs_llama, atts_llama + + def prompt_wrap(self, img_embeds, atts_img, prompt): + if prompt: + batch_size = img_embeds.shape[0] + p_before, p_after = prompt.split('') + p_before_tokens = self.llama_tokenizer( + p_before, return_tensors="pt", add_special_tokens=False).to(img_embeds.device) + p_after_tokens = self.llama_tokenizer( + p_after, return_tensors="pt", add_special_tokens=False).to(img_embeds.device) + p_before_embeds = self.llama_model.model.embed_tokens(p_before_tokens.input_ids).expand(batch_size, -1, -1) + p_after_embeds = self.llama_model.model.embed_tokens(p_after_tokens.input_ids).expand(batch_size, -1, -1) + wrapped_img_embeds = torch.cat([p_before_embeds, img_embeds, p_after_embeds], dim=1) + wrapped_atts_img = atts_img[:, :1].expand(-1, wrapped_img_embeds.shape[1]) + return wrapped_img_embeds, wrapped_atts_img + else: + return img_embeds, atts_img + + def forward(self, samples): + image = samples["image"] + img_embeds, atts_img = self.encode_img(image) + if hasattr(samples, 'question_split'): # VQA dataset + print('VQA Batch') + vqa_prompt = '###Human: ' + img_embeds, atts_img = self.prompt_wrap(img_embeds, atts_img, vqa_prompt) + elif self.prompt_list: + prompt = random.choice(self.prompt_list) + img_embeds, atts_img = self.prompt_wrap(img_embeds, atts_img, prompt) + + self.llama_tokenizer.padding_side = "right" + + text = [t + self.end_sym for t in samples["text_input"]] + + to_regress_tokens = self.llama_tokenizer( + text, + return_tensors="pt", + padding="longest", + truncation=True, + max_length=self.max_txt_len, + add_special_tokens=False + ).to(image.device) + + targets = to_regress_tokens.input_ids.masked_fill( + to_regress_tokens.input_ids == self.llama_tokenizer.pad_token_id, -100 + ) + + empty_targets = ( + torch.ones([atts_img.shape[0], atts_img.shape[1]+1], + dtype=torch.long).to(image.device).fill_(-100) # plus one for bos + ) + targets = torch.cat([empty_targets, targets], dim=1) + + batch_size = img_embeds.shape[0] + bos = torch.ones([batch_size, 1], + dtype=to_regress_tokens.input_ids.dtype, + device=to_regress_tokens.input_ids.device) * self.llama_tokenizer.bos_token_id + bos_embeds = self.llama_model.model.embed_tokens(bos) + atts_bos = atts_img[:, :1] + + to_regress_embeds = self.llama_model.model.embed_tokens(to_regress_tokens.input_ids) + inputs_embeds = torch.cat([bos_embeds, img_embeds, to_regress_embeds], dim=1) + attention_mask = torch.cat([atts_bos, atts_img, to_regress_tokens.attention_mask], dim=1) + + with self.maybe_autocast(): + outputs = self.llama_model( + inputs_embeds=inputs_embeds, + attention_mask=attention_mask, + return_dict=True, + labels=targets, + ) + loss = outputs.loss + + return {"loss": loss} + + @classmethod + def from_config(cls, cfg): + vit_model = cfg.get("vit_model", "eva_clip_g") + q_former_model = cfg.get("q_former_model", "https://storage.googleapis.com/sfr-vision-language-research/LAVIS/models/BLIP2/blip2_pretrained_flant5xxl.pth") + img_size = cfg.get("image_size") + num_query_token = cfg.get("num_query_token") + llama_model = cfg.get("llama_model") + + drop_path_rate = cfg.get("drop_path_rate", 0) + use_grad_checkpoint = cfg.get("use_grad_checkpoint", False) + vit_precision = cfg.get("vit_precision", "fp16") + freeze_vit = cfg.get("freeze_vit", True) + freeze_qformer = cfg.get("freeze_qformer", True) + llama_cache_dir = cfg.get("llama_cache_dir", "") + + prompt_path = cfg.get("prompt_path", "") + prompt_template = cfg.get("prompt_template", "") + max_txt_len = cfg.get("max_txt_len", 32) + end_sym = cfg.get("end_sym", '\n') + + model = cls( + vit_model=vit_model, + q_former_model=q_former_model, + img_size=img_size, + drop_path_rate=drop_path_rate, + use_grad_checkpoint=use_grad_checkpoint, + vit_precision=vit_precision, + freeze_vit=freeze_vit, + freeze_qformer=freeze_qformer, + llama_cache_dir=llama_cache_dir, + num_query_token=num_query_token, + llama_model=llama_model, + prompt_path=prompt_path, + prompt_template=prompt_template, + max_txt_len=max_txt_len, + end_sym=end_sym + ) + + ckpt_path = cfg.get("ckpt", "") # load weights of MiniGPT-4 + if ckpt_path: + print("Load BLIP2-LLM Checkpoint: {}".format(ckpt_path)) + ckpt = torch.load(ckpt_path, map_location="cpu") + msg = model.load_state_dict(ckpt['model'], strict=False) + + return model diff --git a/minigpt4/models/modeling_llama.py b/minigpt4/models/modeling_llama.py new file mode 100644 index 0000000000000000000000000000000000000000..2cebacf454dd9cf82823fc372d7673142b2082c7 --- /dev/null +++ b/minigpt4/models/modeling_llama.py @@ -0,0 +1,772 @@ +# coding=utf-8 +# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved. +# +# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX +# and OPT implementations in this library. It has been modified from its +# original forms to accommodate minor architectural differences compared +# to GPT-NeoX and OPT used by the Meta AI team that trained the model. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" PyTorch LLaMA model.""" +import math +from typing import List, Optional, Tuple, Union + +import torch +import torch.utils.checkpoint +from torch import nn +from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss + +from transformers.activations import ACT2FN +from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast, SequenceClassifierOutputWithPast +from transformers.modeling_utils import PreTrainedModel +from transformers.utils import add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings +from transformers.models.llama.configuration_llama import LlamaConfig + + +logger = logging.get_logger(__name__) + +_CONFIG_FOR_DOC = "LlamaConfig" + + +# Copied from transformers.models.bart.modeling_bart._make_causal_mask +def _make_causal_mask( + input_ids_shape: torch.Size, dtype: torch.dtype, device: torch.device, past_key_values_length: int = 0 +): + """ + Make causal mask used for bi-directional self-attention. + """ + bsz, tgt_len = input_ids_shape + mask = torch.full((tgt_len, tgt_len), torch.tensor(torch.finfo(dtype).min, device=device), device=device) + mask_cond = torch.arange(mask.size(-1), device=device) + mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0) + mask = mask.to(dtype) + + if past_key_values_length > 0: + mask = torch.cat([torch.zeros(tgt_len, past_key_values_length, dtype=dtype, device=device), mask], dim=-1) + return mask[None, None, :, :].expand(bsz, 1, tgt_len, tgt_len + past_key_values_length) + + +# Copied from transformers.models.bart.modeling_bart._expand_mask +def _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None): + """ + Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`. + """ + bsz, src_len = mask.size() + tgt_len = tgt_len if tgt_len is not None else src_len + + expanded_mask = mask[:, None, None, :].expand(bsz, 1, tgt_len, src_len).to(dtype) + + inverted_mask = 1.0 - expanded_mask + + return inverted_mask.masked_fill(inverted_mask.to(torch.bool), torch.finfo(dtype).min) + + +class LlamaRMSNorm(nn.Module): + def __init__(self, hidden_size, eps=1e-6): + """ + LlamaRMSNorm is equivalent to T5LayerNorm + """ + super().__init__() + self.weight = nn.Parameter(torch.ones(hidden_size)) + self.variance_epsilon = eps + + def forward(self, hidden_states): + variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True) + hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon) + + # convert into half-precision if necessary + if self.weight.dtype in [torch.float16, torch.bfloat16]: + hidden_states = hidden_states.to(self.weight.dtype) + + return self.weight * hidden_states + + +class LlamaRotaryEmbedding(torch.nn.Module): + def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None): + super().__init__() + inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2).float().to(device) / dim)) + self.register_buffer("inv_freq", inv_freq) + + # Build here to make `torch.jit.trace` work. + self.max_seq_len_cached = max_position_embeddings + t = torch.arange(self.max_seq_len_cached, device=self.inv_freq.device, dtype=self.inv_freq.dtype) + freqs = torch.einsum("i,j->ij", t, self.inv_freq) + # Different from paper, but it uses a different permutation in order to obtain the same calculation + emb = torch.cat((freqs, freqs), dim=-1) + self.register_buffer("cos_cached", emb.cos()[None, None, :, :], persistent=False) + self.register_buffer("sin_cached", emb.sin()[None, None, :, :], persistent=False) + + def forward(self, x, seq_len=None): + # x: [bs, num_attention_heads, seq_len, head_size] + # This `if` block is unlikely to be run after we build sin/cos in `__init__`. Keep the logic here just in case. + if seq_len > self.max_seq_len_cached: + self.max_seq_len_cached = seq_len + t = torch.arange(self.max_seq_len_cached, device=x.device, dtype=self.inv_freq.dtype) + freqs = torch.einsum("i,j->ij", t, self.inv_freq) + # Different from paper, but it uses a different permutation in order to obtain the same calculation + emb = torch.cat((freqs, freqs), dim=-1).to(x.device) + self.register_buffer("cos_cached", emb.cos()[None, None, :, :], persistent=False) + self.register_buffer("sin_cached", emb.sin()[None, None, :, :], persistent=False) + return ( + self.cos_cached[:, :, :seq_len, ...].to(dtype=x.dtype), + self.sin_cached[:, :, :seq_len, ...].to(dtype=x.dtype), + ) + + +def rotate_half(x): + """Rotates half the hidden dims of the input.""" + x1 = x[..., : x.shape[-1] // 2] + x2 = x[..., x.shape[-1] // 2 :] + return torch.cat((-x2, x1), dim=-1) + + +def apply_rotary_pos_emb(q, k, cos, sin, position_ids): + gather_indices = position_ids[:, None, :, None] # [bs, 1, seq_len, 1] + gather_indices = gather_indices.repeat(1, cos.shape[1], 1, cos.shape[3]) + cos = torch.gather(cos.repeat(gather_indices.shape[0], 1, 1, 1), 2, gather_indices) + sin = torch.gather(sin.repeat(gather_indices.shape[0], 1, 1, 1), 2, gather_indices) + q_embed = (q * cos) + (rotate_half(q) * sin) + k_embed = (k * cos) + (rotate_half(k) * sin) + return q_embed, k_embed + + +class LlamaMLP(nn.Module): + def __init__( + self, + hidden_size: int, + intermediate_size: int, + hidden_act: str, + ): + super().__init__() + self.gate_proj = nn.Linear(hidden_size, intermediate_size, bias=False) + self.down_proj = nn.Linear(intermediate_size, hidden_size, bias=False) + self.up_proj = nn.Linear(hidden_size, intermediate_size, bias=False) + self.act_fn = ACT2FN[hidden_act] + + def forward(self, x): + return self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x)) + + +class LlamaAttention(nn.Module): + """Multi-headed attention from 'Attention Is All You Need' paper""" + + def __init__(self, config: LlamaConfig): + super().__init__() + self.config = config + self.hidden_size = config.hidden_size + self.num_heads = config.num_attention_heads + self.head_dim = self.hidden_size // self.num_heads + self.max_position_embeddings = config.max_position_embeddings + + if (self.head_dim * self.num_heads) != self.hidden_size: + raise ValueError( + f"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}" + f" and `num_heads`: {self.num_heads})." + ) + self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False) + self.k_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False) + self.v_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False) + self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=False) + self.rotary_emb = LlamaRotaryEmbedding(self.head_dim, max_position_embeddings=self.max_position_embeddings) + + def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int): + return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous() + + def forward( + self, + hidden_states: torch.Tensor, + attention_mask: Optional[torch.Tensor] = None, + position_ids: Optional[torch.LongTensor] = None, + past_key_value: Optional[Tuple[torch.Tensor]] = None, + output_attentions: bool = False, + use_cache: bool = False, + ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]: + bsz, q_len, _ = hidden_states.size() + + query_states = self.q_proj(hidden_states).view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2) + key_states = self.k_proj(hidden_states).view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2) + value_states = self.v_proj(hidden_states).view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2) + + kv_seq_len = key_states.shape[-2] + if past_key_value is not None: + kv_seq_len += past_key_value[0].shape[-2] + cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len) + query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids) + # [bsz, nh, t, hd] + + if past_key_value is not None: + # reuse k, v, self_attention + key_states = torch.cat([past_key_value[0], key_states], dim=2) + value_states = torch.cat([past_key_value[1], value_states], dim=2) + + past_key_value = (key_states, value_states) if use_cache else None + + attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim) + + if attn_weights.size() != (bsz, self.num_heads, q_len, kv_seq_len): + raise ValueError( + f"Attention weights should be of size {(bsz * self.num_heads, q_len, kv_seq_len)}, but is" + f" {attn_weights.size()}" + ) + + if attention_mask is not None: + if attention_mask.size() != (bsz, 1, q_len, kv_seq_len): + raise ValueError( + f"Attention mask should be of size {(bsz, 1, q_len, kv_seq_len)}, but is {attention_mask.size()}" + ) + attn_weights = attn_weights + attention_mask + attn_weights = torch.max(attn_weights, torch.tensor(torch.finfo(attn_weights.dtype).min)) + + # upcast attention to fp32 + attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype) + attn_output = torch.matmul(attn_weights, value_states) + + if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim): + raise ValueError( + f"`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is" + f" {attn_output.size()}" + ) + + attn_output = attn_output.transpose(1, 2) + attn_output = attn_output.reshape(bsz, q_len, self.hidden_size) + + attn_output = self.o_proj(attn_output) + + if not output_attentions: + attn_weights = None + + return attn_output, attn_weights, past_key_value + + +class LlamaDecoderLayer(nn.Module): + def __init__(self, config: LlamaConfig): + super().__init__() + self.hidden_size = config.hidden_size + self.self_attn = LlamaAttention(config=config) + self.mlp = LlamaMLP( + hidden_size=self.hidden_size, + intermediate_size=config.intermediate_size, + hidden_act=config.hidden_act, + ) + self.input_layernorm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps) + self.post_attention_layernorm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps) + + def forward( + self, + hidden_states: torch.Tensor, + attention_mask: Optional[torch.Tensor] = None, + position_ids: Optional[torch.LongTensor] = None, + past_key_value: Optional[Tuple[torch.Tensor]] = None, + output_attentions: Optional[bool] = False, + use_cache: Optional[bool] = False, + ) -> Tuple[torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]]: + """ + Args: + hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)` + attention_mask (`torch.FloatTensor`, *optional*): attention mask of size + `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values. + output_attentions (`bool`, *optional*): + Whether or not to return the attentions tensors of all attention layers. See `attentions` under + returned tensors for more detail. + use_cache (`bool`, *optional*): + If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding + (see `past_key_values`). + past_key_value (`Tuple(torch.FloatTensor)`, *optional*): cached past key and value projection states + """ + + residual = hidden_states + + hidden_states = self.input_layernorm(hidden_states) + + # Self Attention + hidden_states, self_attn_weights, present_key_value = self.self_attn( + hidden_states=hidden_states, + attention_mask=attention_mask, + position_ids=position_ids, + past_key_value=past_key_value, + output_attentions=output_attentions, + use_cache=use_cache, + ) + hidden_states = residual + hidden_states + + # Fully Connected + residual = hidden_states + hidden_states = self.post_attention_layernorm(hidden_states) + hidden_states = self.mlp(hidden_states) + hidden_states = residual + hidden_states + + outputs = (hidden_states,) + + if output_attentions: + outputs += (self_attn_weights,) + + if use_cache: + outputs += (present_key_value,) + + return outputs + + +LLAMA_START_DOCSTRING = r""" + This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the + library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads + etc.) + + This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. + Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage + and behavior. + + Parameters: + config ([`LlamaConfig`]): + Model configuration class with all the parameters of the model. Initializing with a config file does not + load the weights associated with the model, only the configuration. Check out the + [`~PreTrainedModel.from_pretrained`] method to load the model weights. +""" + + +@add_start_docstrings( + "The bare LLaMA Model outputting raw hidden-states without any specific head on top.", + LLAMA_START_DOCSTRING, +) +class LlamaPreTrainedModel(PreTrainedModel): + config_class = LlamaConfig + base_model_prefix = "model" + supports_gradient_checkpointing = True + _no_split_modules = ["LlamaDecoderLayer"] + _keys_to_ignore_on_load_unexpected = [r"decoder\.version"] + + def _init_weights(self, module): + std = self.config.initializer_range + if isinstance(module, nn.Linear): + module.weight.data.normal_(mean=0.0, std=std) + if module.bias is not None: + module.bias.data.zero_() + elif isinstance(module, nn.Embedding): + module.weight.data.normal_(mean=0.0, std=std) + if module.padding_idx is not None: + module.weight.data[module.padding_idx].zero_() + + def _set_gradient_checkpointing(self, module, value=False): + if isinstance(module, LlamaModel): + module.gradient_checkpointing = value + + +LLAMA_INPUTS_DOCSTRING = r""" + Args: + input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): + Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide + it. + + Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and + [`PreTrainedTokenizer.__call__`] for details. + + [What are input IDs?](../glossary#input-ids) + attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*): + Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`: + + - 1 for tokens that are **not masked**, + - 0 for tokens that are **masked**. + + [What are attention masks?](../glossary#attention-mask) + + Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and + [`PreTrainedTokenizer.__call__`] for details. + + If `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see + `past_key_values`). + + If you want to change padding behavior, you should read [`modeling_opt._prepare_decoder_attention_mask`] + and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more + information on the default strategy. + + - 1 indicates the head is **not masked**, + - 0 indicates the head is **masked**. + position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*): + Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0, + config.n_positions - 1]`. + + [What are position IDs?](../glossary#position-ids) + past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`): + Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape + `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape + `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`. + + Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention + blocks) that can be used (see `past_key_values` input) to speed up sequential decoding. + + If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that + don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all + `decoder_input_ids` of shape `(batch_size, sequence_length)`. + inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*): + Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This + is useful if you want more control over how to convert `input_ids` indices into associated vectors than the + model's internal embedding lookup matrix. + use_cache (`bool`, *optional*): + If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see + `past_key_values`). + output_attentions (`bool`, *optional*): + Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned + tensors for more detail. + output_hidden_states (`bool`, *optional*): + Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for + more detail. + return_dict (`bool`, *optional*): + Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. +""" + + +@add_start_docstrings( + "The bare LLaMA Model outputting raw hidden-states without any specific head on top.", + LLAMA_START_DOCSTRING, +) +class LlamaModel(LlamaPreTrainedModel): + """ + Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`LlamaDecoderLayer`] + + Args: + config: LlamaConfig + """ + + def __init__(self, config: LlamaConfig): + super().__init__(config) + self.padding_idx = config.pad_token_id + self.vocab_size = config.vocab_size + + self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx) + self.layers = nn.ModuleList([LlamaDecoderLayer(config) for _ in range(config.num_hidden_layers)]) + self.norm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps) + + self.gradient_checkpointing = False + # Initialize weights and apply final processing + self.post_init() + + def get_input_embeddings(self): + return self.embed_tokens + + def set_input_embeddings(self, value): + self.embed_tokens = value + + # Copied from transformers.models.bart.modeling_bart.BartDecoder._prepare_decoder_attention_mask + def _prepare_decoder_attention_mask(self, attention_mask, input_shape, inputs_embeds, past_key_values_length): + # create causal mask + # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len] + combined_attention_mask = None + if input_shape[-1] > 1: + combined_attention_mask = _make_causal_mask( + input_shape, + inputs_embeds.dtype, + device=inputs_embeds.device, + past_key_values_length=past_key_values_length, + ) + + if attention_mask is not None: + # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len] + expanded_attn_mask = _expand_mask(attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]).to( + inputs_embeds.device + ) + combined_attention_mask = ( + expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask + combined_attention_mask + ) + + return combined_attention_mask + + @add_start_docstrings_to_model_forward(LLAMA_INPUTS_DOCSTRING) + def forward( + self, + input_ids: torch.LongTensor = None, + attention_mask: Optional[torch.Tensor] = None, + position_ids: Optional[torch.LongTensor] = None, + past_key_values: Optional[List[torch.FloatTensor]] = None, + inputs_embeds: Optional[torch.FloatTensor] = None, + query_embeds: Optional[torch.FloatTensor] = None, + use_cache: Optional[bool] = None, + output_attentions: Optional[bool] = None, + output_hidden_states: Optional[bool] = None, + return_dict: Optional[bool] = None, + ) -> Union[Tuple, BaseModelOutputWithPast]: + output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions + output_hidden_states = ( + output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states + ) + use_cache = use_cache if use_cache is not None else self.config.use_cache + + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + # retrieve input_ids and inputs_embeds + if input_ids is not None and inputs_embeds is not None: + raise ValueError("You cannot specify both decoder_input_ids and decoder_inputs_embeds at the same time") + elif input_ids is not None: + batch_size, seq_length = input_ids.shape + elif inputs_embeds is not None: + batch_size, seq_length, _ = inputs_embeds.shape + else: + raise ValueError("You have to specify either decoder_input_ids or decoder_inputs_embeds") + + if inputs_embeds is None: + inputs_embeds = self.embed_tokens(input_ids) + if query_embeds is not None: + inputs_embeds = torch.cat([query_embeds, inputs_embeds], dim=1) + batch_size, seq_length, _ = inputs_embeds.shape + + seq_length_with_past = seq_length + past_key_values_length = 0 + + if past_key_values is not None: + past_key_values_length = past_key_values[0][0].shape[2] + seq_length_with_past = seq_length_with_past + past_key_values_length + + if position_ids is None: + device = input_ids.device if input_ids is not None else inputs_embeds.device + position_ids = torch.arange( + past_key_values_length, seq_length + past_key_values_length, dtype=torch.long, device=device + ) + position_ids = position_ids.unsqueeze(0).view(-1, seq_length) + else: + position_ids = position_ids.view(-1, seq_length).long() + + # embed positions + if attention_mask is None: + attention_mask = torch.ones( + (batch_size, seq_length_with_past), dtype=torch.bool, device=inputs_embeds.device + ) + attention_mask = self._prepare_decoder_attention_mask( + attention_mask, (batch_size, seq_length), inputs_embeds, past_key_values_length + ) + + hidden_states = inputs_embeds + + if self.gradient_checkpointing and self.training: + if use_cache: + logger.warning_once( + "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..." + ) + use_cache = False + + # decoder layers + all_hidden_states = () if output_hidden_states else None + all_self_attns = () if output_attentions else None + next_decoder_cache = () if use_cache else None + + for idx, decoder_layer in enumerate(self.layers): + if output_hidden_states: + all_hidden_states += (hidden_states,) + + past_key_value = past_key_values[idx] if past_key_values is not None else None + + if self.gradient_checkpointing and self.training: + + def create_custom_forward(module): + def custom_forward(*inputs): + # None for past_key_value + return module(*inputs, output_attentions, None) + + return custom_forward + + layer_outputs = torch.utils.checkpoint.checkpoint( + create_custom_forward(decoder_layer), + hidden_states, + attention_mask, + position_ids, + None, + ) + else: + layer_outputs = decoder_layer( + hidden_states, + attention_mask=attention_mask, + position_ids=position_ids, + past_key_value=past_key_value, + output_attentions=output_attentions, + use_cache=use_cache, + ) + + hidden_states = layer_outputs[0] + + if use_cache: + next_decoder_cache += (layer_outputs[2 if output_attentions else 1],) + + if output_attentions: + all_self_attns += (layer_outputs[1],) + + hidden_states = self.norm(hidden_states) + + # add hidden states from the last decoder layer + if output_hidden_states: + all_hidden_states += (hidden_states,) + + next_cache = next_decoder_cache if use_cache else None + if not return_dict: + return tuple(v for v in [hidden_states, next_cache, all_hidden_states, all_self_attns] if v is not None) + return BaseModelOutputWithPast( + last_hidden_state=hidden_states, + past_key_values=next_cache, + hidden_states=all_hidden_states, + attentions=all_self_attns, + ) + + +class LlamaForCausalLM(LlamaPreTrainedModel): + def __init__(self, config): + super().__init__(config) + self.model = LlamaModel(config) + + self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False) + + # Initialize weights and apply final processing + self.post_init() + + def get_input_embeddings(self): + return self.model.embed_tokens + + def set_input_embeddings(self, value): + self.model.embed_tokens = value + + def get_output_embeddings(self): + return self.lm_head + + def set_output_embeddings(self, new_embeddings): + self.lm_head = new_embeddings + + def set_decoder(self, decoder): + self.model = decoder + + def get_decoder(self): + return self.model + + @add_start_docstrings_to_model_forward(LLAMA_INPUTS_DOCSTRING) + @replace_return_docstrings(output_type=CausalLMOutputWithPast, config_class=_CONFIG_FOR_DOC) + def forward( + self, + input_ids: torch.LongTensor = None, + attention_mask: Optional[torch.Tensor] = None, + position_ids: Optional[torch.LongTensor] = None, + past_key_values: Optional[List[torch.FloatTensor]] = None, + inputs_embeds: Optional[torch.FloatTensor] = None, + query_embeds: Optional[torch.FloatTensor] = None, + labels: Optional[torch.LongTensor] = None, + use_cache: Optional[bool] = None, + output_attentions: Optional[bool] = None, + output_hidden_states: Optional[bool] = None, + return_dict: Optional[bool] = None, + ) -> Union[Tuple, CausalLMOutputWithPast]: + r""" + Args: + labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*): + Labels for computing the masked language modeling loss. Indices should either be in `[0, ..., + config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored + (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`. + + Returns: + + Example: + + ```python + >>> from transformers import AutoTokenizer, LlamaForCausalLM + + >>> model = LlamaForCausalLM.from_pretrained(PATH_TO_CONVERTED_WEIGHTS) + >>> tokenizer = AutoTokenizer.from_pretrained(PATH_TO_CONVERTED_TOKENIZER) + + >>> prompt = "Hey, are you consciours? Can you talk to me?" + >>> inputs = tokenizer(prompt, return_tensors="pt") + + >>> # Generate + >>> generate_ids = model.generate(inputs.input_ids, max_length=30) + >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] + "Hey, are you consciours? Can you talk to me?\nI'm not consciours, but I can talk to you." + ```""" + + output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions + output_hidden_states = ( + output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states + ) + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn) + outputs = self.model( + input_ids=input_ids, + attention_mask=attention_mask, + position_ids=position_ids, + past_key_values=past_key_values, + inputs_embeds=inputs_embeds, + query_embeds=query_embeds, + use_cache=use_cache, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + ) + + hidden_states = outputs[0] + logits = self.lm_head(hidden_states) + + loss = None + if labels is not None: + # Shift so that tokens < n predict n + shift_logits = logits[..., :-1, :].contiguous() + shift_labels = labels[..., 1:].contiguous() + # Flatten the tokens + loss_fct = CrossEntropyLoss() + shift_logits = shift_logits.view(-1, self.config.vocab_size) + shift_labels = shift_labels.view(-1) + # Enable model parallelism + shift_labels = shift_labels.to(shift_logits.device) + loss = loss_fct(shift_logits, shift_labels) + + if not return_dict: + output = (logits,) + outputs[1:] + return (loss,) + output if loss is not None else output + + return CausalLMOutputWithPast( + loss=loss, + logits=logits, + past_key_values=outputs.past_key_values, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + ) + + def prepare_inputs_for_generation( + self, input_ids, query_embeds=None, past_key_values=None, attention_mask=None, inputs_embeds=None, **kwargs + ): + if past_key_values: + input_ids = input_ids[:, -1:] + + position_ids = kwargs.get("position_ids", None) + if attention_mask is not None and position_ids is None: + # create position_ids on the fly for batch generation + position_ids = attention_mask.long().cumsum(-1) - 1 + position_ids.masked_fill_(attention_mask == 0, 1) + if past_key_values: + position_ids = position_ids[:, -1].unsqueeze(-1) + query_embeds = None + + # if `inputs_embeds` are passed, we only want to use them in the 1st generation step + if inputs_embeds is not None and past_key_values is None: + model_inputs = {"inputs_embeds": inputs_embeds} + else: + model_inputs = {"input_ids": input_ids} + + model_inputs.update( + { + "position_ids": position_ids, + "query_embeds": query_embeds, + "past_key_values": past_key_values, + "use_cache": kwargs.get("use_cache"), + "attention_mask": attention_mask, + } + ) + return model_inputs + + @staticmethod + def _reorder_cache(past_key_values, beam_idx): + reordered_past = () + for layer_past in past_key_values: + reordered_past += (tuple(past_state.index_select(0, beam_idx) for past_state in layer_past),) + return reordered_past + diff --git a/minigpt4/processors/__init__.py b/minigpt4/processors/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cfb0908e7603881b41be0228d7f8346f0d00840e --- /dev/null +++ b/minigpt4/processors/__init__.py @@ -0,0 +1,33 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +from minigpt4.processors.base_processor import BaseProcessor +from minigpt4.processors.blip_processors import ( + Blip2ImageTrainProcessor, + Blip2ImageEvalProcessor, + BlipCaptionProcessor, +) + +from minigpt4.common.registry import registry + +__all__ = [ + "BaseProcessor", + "Blip2ImageTrainProcessor", + "Blip2ImageEvalProcessor", + "BlipCaptionProcessor", +] + + +def load_processor(name, cfg=None): + """ + Example + + >>> processor = load_processor("alpro_video_train", cfg=None) + """ + processor = registry.get_processor_class(name).from_config(cfg) + + return processor diff --git a/minigpt4/processors/base_processor.py b/minigpt4/processors/base_processor.py new file mode 100644 index 0000000000000000000000000000000000000000..b4c9d86859270a046623661a632587f2b3136b46 --- /dev/null +++ b/minigpt4/processors/base_processor.py @@ -0,0 +1,26 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +from omegaconf import OmegaConf + + +class BaseProcessor: + def __init__(self): + self.transform = lambda x: x + return + + def __call__(self, item): + return self.transform(item) + + @classmethod + def from_config(cls, cfg=None): + return cls() + + def build(self, **kwargs): + cfg = OmegaConf.create(kwargs) + + return self.from_config(cfg) diff --git a/minigpt4/processors/blip_processors.py b/minigpt4/processors/blip_processors.py new file mode 100644 index 0000000000000000000000000000000000000000..9853aedc2d51c546b9b34ff4c6ec587aded93dbf --- /dev/null +++ b/minigpt4/processors/blip_processors.py @@ -0,0 +1,141 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import re + +from minigpt4.common.registry import registry +from minigpt4.processors.base_processor import BaseProcessor +from minigpt4.processors.randaugment import RandomAugment +from omegaconf import OmegaConf +from torchvision import transforms +from torchvision.transforms.functional import InterpolationMode + + +class BlipImageBaseProcessor(BaseProcessor): + def __init__(self, mean=None, std=None): + if mean is None: + mean = (0.48145466, 0.4578275, 0.40821073) + if std is None: + std = (0.26862954, 0.26130258, 0.27577711) + + self.normalize = transforms.Normalize(mean, std) + + +@registry.register_processor("blip_caption") +class BlipCaptionProcessor(BaseProcessor): + def __init__(self, prompt="", max_words=50): + self.prompt = prompt + self.max_words = max_words + + def __call__(self, caption): + caption = self.prompt + self.pre_caption(caption) + + return caption + + @classmethod + def from_config(cls, cfg=None): + if cfg is None: + cfg = OmegaConf.create() + + prompt = cfg.get("prompt", "") + max_words = cfg.get("max_words", 50) + + return cls(prompt=prompt, max_words=max_words) + + def pre_caption(self, caption): + caption = re.sub( + r"([.!\"()*#:;~])", + " ", + caption.lower(), + ) + caption = re.sub( + r"\s{2,}", + " ", + caption, + ) + caption = caption.rstrip("\n") + caption = caption.strip(" ") + + # truncate caption + caption_words = caption.split(" ") + if len(caption_words) > self.max_words: + caption = " ".join(caption_words[: self.max_words]) + + return caption + + +@registry.register_processor("blip2_image_train") +class Blip2ImageTrainProcessor(BlipImageBaseProcessor): + def __init__(self, image_size=224, mean=None, std=None, min_scale=0.5, max_scale=1.0): + super().__init__(mean=mean, std=std) + + self.transform = transforms.Compose( + [ + transforms.RandomResizedCrop( + image_size, + scale=(min_scale, max_scale), + interpolation=InterpolationMode.BICUBIC, + ), + transforms.ToTensor(), + self.normalize, + ] + ) + + def __call__(self, item): + return self.transform(item) + + @classmethod + def from_config(cls, cfg=None): + if cfg is None: + cfg = OmegaConf.create() + + image_size = cfg.get("image_size", 224) + + mean = cfg.get("mean", None) + std = cfg.get("std", None) + + min_scale = cfg.get("min_scale", 0.5) + max_scale = cfg.get("max_scale", 1.0) + + return cls( + image_size=image_size, + mean=mean, + std=std, + min_scale=min_scale, + max_scale=max_scale, + ) + + +@registry.register_processor("blip2_image_eval") +class Blip2ImageEvalProcessor(BlipImageBaseProcessor): + def __init__(self, image_size=224, mean=None, std=None): + super().__init__(mean=mean, std=std) + + self.transform = transforms.Compose( + [ + transforms.Resize( + (image_size, image_size), interpolation=InterpolationMode.BICUBIC + ), + transforms.ToTensor(), + self.normalize, + ] + ) + + def __call__(self, item): + return self.transform(item) + + @classmethod + def from_config(cls, cfg=None): + if cfg is None: + cfg = OmegaConf.create() + + image_size = cfg.get("image_size", 224) + + mean = cfg.get("mean", None) + std = cfg.get("std", None) + + return cls(image_size=image_size, mean=mean, std=std) \ No newline at end of file diff --git a/minigpt4/processors/randaugment.py b/minigpt4/processors/randaugment.py new file mode 100644 index 0000000000000000000000000000000000000000..5c6a9e6d62f74358f490d19546c9829b3ac6aaef --- /dev/null +++ b/minigpt4/processors/randaugment.py @@ -0,0 +1,398 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import cv2 +import numpy as np + +import torch + + +## aug functions +def identity_func(img): + return img + + +def autocontrast_func(img, cutoff=0): + """ + same output as PIL.ImageOps.autocontrast + """ + n_bins = 256 + + def tune_channel(ch): + n = ch.size + cut = cutoff * n // 100 + if cut == 0: + high, low = ch.max(), ch.min() + else: + hist = cv2.calcHist([ch], [0], None, [n_bins], [0, n_bins]) + low = np.argwhere(np.cumsum(hist) > cut) + low = 0 if low.shape[0] == 0 else low[0] + high = np.argwhere(np.cumsum(hist[::-1]) > cut) + high = n_bins - 1 if high.shape[0] == 0 else n_bins - 1 - high[0] + if high <= low: + table = np.arange(n_bins) + else: + scale = (n_bins - 1) / (high - low) + offset = -low * scale + table = np.arange(n_bins) * scale + offset + table[table < 0] = 0 + table[table > n_bins - 1] = n_bins - 1 + table = table.clip(0, 255).astype(np.uint8) + return table[ch] + + channels = [tune_channel(ch) for ch in cv2.split(img)] + out = cv2.merge(channels) + return out + + +def equalize_func(img): + """ + same output as PIL.ImageOps.equalize + PIL's implementation is different from cv2.equalize + """ + n_bins = 256 + + def tune_channel(ch): + hist = cv2.calcHist([ch], [0], None, [n_bins], [0, n_bins]) + non_zero_hist = hist[hist != 0].reshape(-1) + step = np.sum(non_zero_hist[:-1]) // (n_bins - 1) + if step == 0: + return ch + n = np.empty_like(hist) + n[0] = step // 2 + n[1:] = hist[:-1] + table = (np.cumsum(n) // step).clip(0, 255).astype(np.uint8) + return table[ch] + + channels = [tune_channel(ch) for ch in cv2.split(img)] + out = cv2.merge(channels) + return out + + +def rotate_func(img, degree, fill=(0, 0, 0)): + """ + like PIL, rotate by degree, not radians + """ + H, W = img.shape[0], img.shape[1] + center = W / 2, H / 2 + M = cv2.getRotationMatrix2D(center, degree, 1) + out = cv2.warpAffine(img, M, (W, H), borderValue=fill) + return out + + +def solarize_func(img, thresh=128): + """ + same output as PIL.ImageOps.posterize + """ + table = np.array([el if el < thresh else 255 - el for el in range(256)]) + table = table.clip(0, 255).astype(np.uint8) + out = table[img] + return out + + +def color_func(img, factor): + """ + same output as PIL.ImageEnhance.Color + """ + ## implementation according to PIL definition, quite slow + # degenerate = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)[:, :, np.newaxis] + # out = blend(degenerate, img, factor) + # M = ( + # np.eye(3) * factor + # + np.float32([0.114, 0.587, 0.299]).reshape(3, 1) * (1. - factor) + # )[np.newaxis, np.newaxis, :] + M = np.float32( + [[0.886, -0.114, -0.114], [-0.587, 0.413, -0.587], [-0.299, -0.299, 0.701]] + ) * factor + np.float32([[0.114], [0.587], [0.299]]) + out = np.matmul(img, M).clip(0, 255).astype(np.uint8) + return out + + +def contrast_func(img, factor): + """ + same output as PIL.ImageEnhance.Contrast + """ + mean = np.sum(np.mean(img, axis=(0, 1)) * np.array([0.114, 0.587, 0.299])) + table = ( + np.array([(el - mean) * factor + mean for el in range(256)]) + .clip(0, 255) + .astype(np.uint8) + ) + out = table[img] + return out + + +def brightness_func(img, factor): + """ + same output as PIL.ImageEnhance.Contrast + """ + table = (np.arange(256, dtype=np.float32) * factor).clip(0, 255).astype(np.uint8) + out = table[img] + return out + + +def sharpness_func(img, factor): + """ + The differences the this result and PIL are all on the 4 boundaries, the center + areas are same + """ + kernel = np.ones((3, 3), dtype=np.float32) + kernel[1][1] = 5 + kernel /= 13 + degenerate = cv2.filter2D(img, -1, kernel) + if factor == 0.0: + out = degenerate + elif factor == 1.0: + out = img + else: + out = img.astype(np.float32) + degenerate = degenerate.astype(np.float32)[1:-1, 1:-1, :] + out[1:-1, 1:-1, :] = degenerate + factor * (out[1:-1, 1:-1, :] - degenerate) + out = out.astype(np.uint8) + return out + + +def shear_x_func(img, factor, fill=(0, 0, 0)): + H, W = img.shape[0], img.shape[1] + M = np.float32([[1, factor, 0], [0, 1, 0]]) + out = cv2.warpAffine( + img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR + ).astype(np.uint8) + return out + + +def translate_x_func(img, offset, fill=(0, 0, 0)): + """ + same output as PIL.Image.transform + """ + H, W = img.shape[0], img.shape[1] + M = np.float32([[1, 0, -offset], [0, 1, 0]]) + out = cv2.warpAffine( + img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR + ).astype(np.uint8) + return out + + +def translate_y_func(img, offset, fill=(0, 0, 0)): + """ + same output as PIL.Image.transform + """ + H, W = img.shape[0], img.shape[1] + M = np.float32([[1, 0, 0], [0, 1, -offset]]) + out = cv2.warpAffine( + img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR + ).astype(np.uint8) + return out + + +def posterize_func(img, bits): + """ + same output as PIL.ImageOps.posterize + """ + out = np.bitwise_and(img, np.uint8(255 << (8 - bits))) + return out + + +def shear_y_func(img, factor, fill=(0, 0, 0)): + H, W = img.shape[0], img.shape[1] + M = np.float32([[1, 0, 0], [factor, 1, 0]]) + out = cv2.warpAffine( + img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR + ).astype(np.uint8) + return out + + +def cutout_func(img, pad_size, replace=(0, 0, 0)): + replace = np.array(replace, dtype=np.uint8) + H, W = img.shape[0], img.shape[1] + rh, rw = np.random.random(2) + pad_size = pad_size // 2 + ch, cw = int(rh * H), int(rw * W) + x1, x2 = max(ch - pad_size, 0), min(ch + pad_size, H) + y1, y2 = max(cw - pad_size, 0), min(cw + pad_size, W) + out = img.copy() + out[x1:x2, y1:y2, :] = replace + return out + + +### level to args +def enhance_level_to_args(MAX_LEVEL): + def level_to_args(level): + return ((level / MAX_LEVEL) * 1.8 + 0.1,) + + return level_to_args + + +def shear_level_to_args(MAX_LEVEL, replace_value): + def level_to_args(level): + level = (level / MAX_LEVEL) * 0.3 + if np.random.random() > 0.5: + level = -level + return (level, replace_value) + + return level_to_args + + +def translate_level_to_args(translate_const, MAX_LEVEL, replace_value): + def level_to_args(level): + level = (level / MAX_LEVEL) * float(translate_const) + if np.random.random() > 0.5: + level = -level + return (level, replace_value) + + return level_to_args + + +def cutout_level_to_args(cutout_const, MAX_LEVEL, replace_value): + def level_to_args(level): + level = int((level / MAX_LEVEL) * cutout_const) + return (level, replace_value) + + return level_to_args + + +def solarize_level_to_args(MAX_LEVEL): + def level_to_args(level): + level = int((level / MAX_LEVEL) * 256) + return (level,) + + return level_to_args + + +def none_level_to_args(level): + return () + + +def posterize_level_to_args(MAX_LEVEL): + def level_to_args(level): + level = int((level / MAX_LEVEL) * 4) + return (level,) + + return level_to_args + + +def rotate_level_to_args(MAX_LEVEL, replace_value): + def level_to_args(level): + level = (level / MAX_LEVEL) * 30 + if np.random.random() < 0.5: + level = -level + return (level, replace_value) + + return level_to_args + + +func_dict = { + "Identity": identity_func, + "AutoContrast": autocontrast_func, + "Equalize": equalize_func, + "Rotate": rotate_func, + "Solarize": solarize_func, + "Color": color_func, + "Contrast": contrast_func, + "Brightness": brightness_func, + "Sharpness": sharpness_func, + "ShearX": shear_x_func, + "TranslateX": translate_x_func, + "TranslateY": translate_y_func, + "Posterize": posterize_func, + "ShearY": shear_y_func, +} + +translate_const = 10 +MAX_LEVEL = 10 +replace_value = (128, 128, 128) +arg_dict = { + "Identity": none_level_to_args, + "AutoContrast": none_level_to_args, + "Equalize": none_level_to_args, + "Rotate": rotate_level_to_args(MAX_LEVEL, replace_value), + "Solarize": solarize_level_to_args(MAX_LEVEL), + "Color": enhance_level_to_args(MAX_LEVEL), + "Contrast": enhance_level_to_args(MAX_LEVEL), + "Brightness": enhance_level_to_args(MAX_LEVEL), + "Sharpness": enhance_level_to_args(MAX_LEVEL), + "ShearX": shear_level_to_args(MAX_LEVEL, replace_value), + "TranslateX": translate_level_to_args(translate_const, MAX_LEVEL, replace_value), + "TranslateY": translate_level_to_args(translate_const, MAX_LEVEL, replace_value), + "Posterize": posterize_level_to_args(MAX_LEVEL), + "ShearY": shear_level_to_args(MAX_LEVEL, replace_value), +} + + +class RandomAugment(object): + def __init__(self, N=2, M=10, isPIL=False, augs=[]): + self.N = N + self.M = M + self.isPIL = isPIL + if augs: + self.augs = augs + else: + self.augs = list(arg_dict.keys()) + + def get_random_ops(self): + sampled_ops = np.random.choice(self.augs, self.N) + return [(op, 0.5, self.M) for op in sampled_ops] + + def __call__(self, img): + if self.isPIL: + img = np.array(img) + ops = self.get_random_ops() + for name, prob, level in ops: + if np.random.random() > prob: + continue + args = arg_dict[name](level) + img = func_dict[name](img, *args) + return img + + +class VideoRandomAugment(object): + def __init__(self, N=2, M=10, p=0.0, tensor_in_tensor_out=True, augs=[]): + self.N = N + self.M = M + self.p = p + self.tensor_in_tensor_out = tensor_in_tensor_out + if augs: + self.augs = augs + else: + self.augs = list(arg_dict.keys()) + + def get_random_ops(self): + sampled_ops = np.random.choice(self.augs, self.N, replace=False) + return [(op, self.M) for op in sampled_ops] + + def __call__(self, frames): + assert ( + frames.shape[-1] == 3 + ), "Expecting last dimension for 3-channels RGB (b, h, w, c)." + + if self.tensor_in_tensor_out: + frames = frames.numpy().astype(np.uint8) + + num_frames = frames.shape[0] + + ops = num_frames * [self.get_random_ops()] + apply_or_not = num_frames * [np.random.random(size=self.N) > self.p] + + frames = torch.stack( + list(map(self._aug, frames, ops, apply_or_not)), dim=0 + ).float() + + return frames + + def _aug(self, img, ops, apply_or_not): + for i, (name, level) in enumerate(ops): + if not apply_or_not[i]: + continue + args = arg_dict[name](level) + img = func_dict[name](img, *args) + return torch.from_numpy(img) + + +if __name__ == "__main__": + a = RandomAugment() + img = np.random.randn(32, 32, 3) + a(img) diff --git a/minigpt4/runners/__init__.py b/minigpt4/runners/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5d1dae7693eabffc2400d29642f56aa5115d43ca --- /dev/null +++ b/minigpt4/runners/__init__.py @@ -0,0 +1,10 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +from minigpt4.runners.runner_base import RunnerBase + +__all__ = ["RunnerBase"] diff --git a/minigpt4/runners/runner_base.py b/minigpt4/runners/runner_base.py new file mode 100644 index 0000000000000000000000000000000000000000..5f667f213d3874e3b616080df22de9ff91a9844b --- /dev/null +++ b/minigpt4/runners/runner_base.py @@ -0,0 +1,658 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import datetime +import json +import logging +import os +import time +from pathlib import Path + +import torch +import torch.distributed as dist +import webdataset as wds +from minigpt4.common.dist_utils import ( + download_cached_file, + get_rank, + get_world_size, + is_main_process, + main_process, +) +from minigpt4.common.registry import registry +from minigpt4.common.utils import is_url +from minigpt4.datasets.data_utils import concat_datasets, reorg_datasets_by_split, ChainDataset +from minigpt4.datasets.datasets.dataloader_utils import ( + IterLoader, + MultiIterLoader, + PrefetchLoader, +) +from torch.nn.parallel import DistributedDataParallel as DDP +from torch.utils.data import DataLoader, DistributedSampler + + +@registry.register_runner("runner_base") +class RunnerBase: + """ + A runner class to train and evaluate a model given a task and datasets. + + The runner uses pytorch distributed data parallel by default. Future release + will support other distributed frameworks. + """ + + def __init__(self, cfg, task, model, datasets, job_id): + self.config = cfg + self.job_id = job_id + + self.task = task + self.datasets = datasets + + self._model = model + + self._wrapped_model = None + self._device = None + self._optimizer = None + self._scaler = None + self._dataloaders = None + self._lr_sched = None + + self.start_epoch = 0 + + # self.setup_seeds() + self.setup_output_dir() + + @property + def device(self): + if self._device is None: + self._device = torch.device(self.config.run_cfg.device) + + return self._device + + @property + def use_distributed(self): + return self.config.run_cfg.distributed + + @property + def model(self): + """ + A property to get the DDP-wrapped model on the device. + """ + # move model to device + if self._model.device != self.device: + self._model = self._model.to(self.device) + + # distributed training wrapper + if self.use_distributed: + if self._wrapped_model is None: + self._wrapped_model = DDP( + self._model, device_ids=[self.config.run_cfg.gpu] + ) + else: + self._wrapped_model = self._model + + return self._wrapped_model + + @property + def optimizer(self): + # TODO make optimizer class and configurations + if self._optimizer is None: + num_parameters = 0 + p_wd, p_non_wd = [], [] + for n, p in self.model.named_parameters(): + if not p.requires_grad: + continue # frozen weights + print(n) + if p.ndim < 2 or "bias" in n or "ln" in n or "bn" in n: + p_non_wd.append(p) + else: + p_wd.append(p) + num_parameters += p.data.nelement() + logging.info("number of trainable parameters: %d" % num_parameters) + optim_params = [ + { + "params": p_wd, + "weight_decay": float(self.config.run_cfg.weight_decay), + }, + {"params": p_non_wd, "weight_decay": 0}, + ] + beta2 = self.config.run_cfg.get("beta2", 0.999) + self._optimizer = torch.optim.AdamW( + optim_params, + lr=float(self.config.run_cfg.init_lr), + weight_decay=float(self.config.run_cfg.weight_decay), + betas=(0.9, beta2), + ) + + return self._optimizer + + @property + def scaler(self): + amp = self.config.run_cfg.get("amp", False) + + if amp: + if self._scaler is None: + self._scaler = torch.cuda.amp.GradScaler() + + return self._scaler + + @property + def lr_scheduler(self): + """ + A property to get and create learning rate scheduler by split just in need. + """ + if self._lr_sched is None: + lr_sched_cls = registry.get_lr_scheduler_class(self.config.run_cfg.lr_sched) + + # max_epoch = self.config.run_cfg.max_epoch + max_epoch = self.max_epoch + # min_lr = self.config.run_cfg.min_lr + min_lr = self.min_lr + # init_lr = self.config.run_cfg.init_lr + init_lr = self.init_lr + + # optional parameters + decay_rate = self.config.run_cfg.get("lr_decay_rate", None) + warmup_start_lr = self.config.run_cfg.get("warmup_lr", -1) + warmup_steps = self.config.run_cfg.get("warmup_steps", 0) + iters_per_epoch = self.config.run_cfg.get("iters_per_epoch", None) + + if iters_per_epoch is None: + try: + iters_per_epoch = len(self.dataloaders['train']) + except (AttributeError, TypeError): + iters_per_epoch = 10000 + + self._lr_sched = lr_sched_cls( + optimizer=self.optimizer, + max_epoch=max_epoch, + iters_per_epoch=iters_per_epoch, + min_lr=min_lr, + init_lr=init_lr, + decay_rate=decay_rate, + warmup_start_lr=warmup_start_lr, + warmup_steps=warmup_steps, + ) + + return self._lr_sched + + @property + def dataloaders(self) -> dict: + """ + A property to get and create dataloaders by split just in need. + + If no train_dataset_ratio is provided, concatenate map-style datasets and + chain wds.DataPipe datasets separately. Training set becomes a tuple + (ConcatDataset, ChainDataset), both are optional but at least one of them is + required. The resultant ConcatDataset and ChainDataset will be sampled evenly. + + If train_dataset_ratio is provided, create a MultiIterLoader to sample + each dataset by ratios during training. + + Currently do not support multiple datasets for validation and test. + + Returns: + dict: {split_name: (tuples of) dataloader} + """ + if self._dataloaders is None: + + # concatenate map-style datasets and chain wds.DataPipe datasets separately + # training set becomes a tuple (ConcatDataset, ChainDataset), both are + # optional but at least one of them is required. The resultant ConcatDataset + # and ChainDataset will be sampled evenly. + logging.info( + "dataset_ratios not specified, datasets will be concatenated (map-style datasets) or chained (webdataset.DataPipeline)." + ) + + datasets = reorg_datasets_by_split(self.datasets) + self.datasets = datasets + # self.datasets = concat_datasets(datasets) + + # print dataset statistics after concatenation/chaining + for split_name in self.datasets: + if isinstance(self.datasets[split_name], tuple) or isinstance( + self.datasets[split_name], list + ): + # mixed wds.DataPipeline and torch.utils.data.Dataset + num_records = sum( + [ + len(d) + if not type(d) in [wds.DataPipeline, ChainDataset] + else 0 + for d in self.datasets[split_name] + ] + ) + + else: + if hasattr(self.datasets[split_name], "__len__"): + # a single map-style dataset + num_records = len(self.datasets[split_name]) + else: + # a single wds.DataPipeline + num_records = -1 + logging.info( + "Only a single wds.DataPipeline dataset, no __len__ attribute." + ) + + if num_records >= 0: + logging.info( + "Loaded {} records for {} split from the dataset.".format( + num_records, split_name + ) + ) + + # create dataloaders + split_names = sorted(self.datasets.keys()) + + datasets = [self.datasets[split] for split in split_names] + is_trains = [split in self.train_splits for split in split_names] + + batch_sizes = [ + self.config.run_cfg.batch_size_train + if split == "train" + else self.config.run_cfg.batch_size_eval + for split in split_names + ] + + collate_fns = [] + for dataset in datasets: + if isinstance(dataset, tuple) or isinstance(dataset, list): + collate_fns.append([getattr(d, "collater", None) for d in dataset]) + else: + collate_fns.append(getattr(dataset, "collater", None)) + + dataloaders = self.create_loaders( + datasets=datasets, + num_workers=self.config.run_cfg.num_workers, + batch_sizes=batch_sizes, + is_trains=is_trains, + collate_fns=collate_fns, + ) + + self._dataloaders = {k: v for k, v in zip(split_names, dataloaders)} + + return self._dataloaders + + @property + def cuda_enabled(self): + return self.device.type == "cuda" + + @property + def max_epoch(self): + return int(self.config.run_cfg.max_epoch) + + @property + def log_freq(self): + log_freq = self.config.run_cfg.get("log_freq", 50) + return int(log_freq) + + @property + def init_lr(self): + return float(self.config.run_cfg.init_lr) + + @property + def min_lr(self): + return float(self.config.run_cfg.min_lr) + + @property + def accum_grad_iters(self): + return int(self.config.run_cfg.get("accum_grad_iters", 1)) + + @property + def valid_splits(self): + valid_splits = self.config.run_cfg.get("valid_splits", []) + + if len(valid_splits) == 0: + logging.info("No validation splits found.") + + return valid_splits + + @property + def test_splits(self): + test_splits = self.config.run_cfg.get("test_splits", []) + + return test_splits + + @property + def train_splits(self): + train_splits = self.config.run_cfg.get("train_splits", []) + + if len(train_splits) == 0: + logging.info("Empty train splits.") + + return train_splits + + @property + def evaluate_only(self): + """ + Set to True to skip training. + """ + return self.config.run_cfg.evaluate + + @property + def use_dist_eval_sampler(self): + return self.config.run_cfg.get("use_dist_eval_sampler", True) + + @property + def resume_ckpt_path(self): + return self.config.run_cfg.get("resume_ckpt_path", None) + + @property + def train_loader(self): + train_dataloader = self.dataloaders["train"] + + return train_dataloader + + def setup_output_dir(self): + lib_root = Path(registry.get_path("library_root")) + + output_dir = lib_root / self.config.run_cfg.output_dir / self.job_id + result_dir = output_dir / "result" + + output_dir.mkdir(parents=True, exist_ok=True) + result_dir.mkdir(parents=True, exist_ok=True) + + registry.register_path("result_dir", str(result_dir)) + registry.register_path("output_dir", str(output_dir)) + + self.result_dir = result_dir + self.output_dir = output_dir + + def train(self): + start_time = time.time() + best_agg_metric = 0 + best_epoch = 0 + + self.log_config() + + # resume from checkpoint if specified + if not self.evaluate_only and self.resume_ckpt_path is not None: + self._load_checkpoint(self.resume_ckpt_path) + + for cur_epoch in range(self.start_epoch, self.max_epoch): + # training phase + if not self.evaluate_only: + logging.info("Start training") + train_stats = self.train_epoch(cur_epoch) + self.log_stats(split_name="train", stats=train_stats) + + # evaluation phase + if len(self.valid_splits) > 0: + for split_name in self.valid_splits: + logging.info("Evaluating on {}.".format(split_name)) + + val_log = self.eval_epoch( + split_name=split_name, cur_epoch=cur_epoch + ) + if val_log is not None: + if is_main_process(): + assert ( + "agg_metrics" in val_log + ), "No agg_metrics found in validation log." + + agg_metrics = val_log["agg_metrics"] + if agg_metrics > best_agg_metric and split_name == "val": + best_epoch, best_agg_metric = cur_epoch, agg_metrics + + self._save_checkpoint(cur_epoch, is_best=True) + + val_log.update({"best_epoch": best_epoch}) + self.log_stats(val_log, split_name) + + else: + # if no validation split is provided, we just save the checkpoint at the end of each epoch. + if not self.evaluate_only: + self._save_checkpoint(cur_epoch, is_best=False) + + if self.evaluate_only: + break + + if self.config.run_cfg.distributed: + dist.barrier() + + # testing phase + test_epoch = "best" if len(self.valid_splits) > 0 else cur_epoch + self.evaluate(cur_epoch=test_epoch, skip_reload=self.evaluate_only) + + total_time = time.time() - start_time + total_time_str = str(datetime.timedelta(seconds=int(total_time))) + logging.info("Training time {}".format(total_time_str)) + + def evaluate(self, cur_epoch="best", skip_reload=False): + test_logs = dict() + + if len(self.test_splits) > 0: + for split_name in self.test_splits: + test_logs[split_name] = self.eval_epoch( + split_name=split_name, cur_epoch=cur_epoch, skip_reload=skip_reload + ) + + return test_logs + + def train_epoch(self, epoch): + # train + self.model.train() + + return self.task.train_epoch( + epoch=epoch, + model=self.model, + data_loader=self.train_loader, + optimizer=self.optimizer, + scaler=self.scaler, + lr_scheduler=self.lr_scheduler, + cuda_enabled=self.cuda_enabled, + log_freq=self.log_freq, + accum_grad_iters=self.accum_grad_iters, + ) + + @torch.no_grad() + def eval_epoch(self, split_name, cur_epoch, skip_reload=False): + """ + Evaluate the model on a given split. + + Args: + split_name (str): name of the split to evaluate on. + cur_epoch (int): current epoch. + skip_reload_best (bool): whether to skip reloading the best checkpoint. + During training, we will reload the best checkpoint for validation. + During testing, we will use provided weights and skip reloading the best checkpoint . + """ + data_loader = self.dataloaders.get(split_name, None) + assert data_loader, "data_loader for split {} is None.".format(split_name) + + # TODO In validation, you need to compute loss as well as metrics + # TODO consider moving to model.before_evaluation() + model = self.unwrap_dist_model(self.model) + if not skip_reload and cur_epoch == "best": + model = self._reload_best_model(model) + model.eval() + + self.task.before_evaluation( + model=model, + dataset=self.datasets[split_name], + ) + results = self.task.evaluation(model, data_loader) + + if results is not None: + return self.task.after_evaluation( + val_result=results, + split_name=split_name, + epoch=cur_epoch, + ) + + def unwrap_dist_model(self, model): + if self.use_distributed: + return model.module + else: + return model + + def create_loaders( + self, + datasets, + num_workers, + batch_sizes, + is_trains, + collate_fns, + dataset_ratios=None, + ): + """ + Create dataloaders for training and validation. + """ + + def _create_loader(dataset, num_workers, bsz, is_train, collate_fn): + # create a single dataloader for each split + if isinstance(dataset, ChainDataset) or isinstance( + dataset, wds.DataPipeline + ): + # wds.WebdDataset instance are chained together + # webdataset.DataPipeline has its own sampler and collate_fn + loader = iter( + DataLoader( + dataset, + batch_size=bsz, + num_workers=num_workers, + pin_memory=True, + ) + ) + else: + # map-style dataset are concatenated together + # setup distributed sampler + if self.use_distributed: + sampler = DistributedSampler( + dataset, + shuffle=is_train, + num_replicas=get_world_size(), + rank=get_rank(), + ) + if not self.use_dist_eval_sampler: + # e.g. retrieval evaluation + sampler = sampler if is_train else None + else: + sampler = None + + loader = DataLoader( + dataset, + batch_size=bsz, + num_workers=num_workers, + pin_memory=True, + sampler=sampler, + shuffle=sampler is None and is_train, + collate_fn=collate_fn, + drop_last=True if is_train else False, + ) + loader = PrefetchLoader(loader) + + if is_train: + loader = IterLoader(loader, use_distributed=self.use_distributed) + + return loader + + loaders = [] + + for dataset, bsz, is_train, collate_fn in zip( + datasets, batch_sizes, is_trains, collate_fns + ): + if isinstance(dataset, list) or isinstance(dataset, tuple): + if hasattr(dataset[0], 'sample_ratio') and dataset_ratios is None: + dataset_ratios = [d.sample_ratio for d in dataset] + loader = MultiIterLoader( + loaders=[ + _create_loader(d, num_workers, bsz, is_train, collate_fn[i]) + for i, d in enumerate(dataset) + ], + ratios=dataset_ratios, + ) + else: + loader = _create_loader(dataset, num_workers, bsz, is_train, collate_fn) + + loaders.append(loader) + + return loaders + + @main_process + def _save_checkpoint(self, cur_epoch, is_best=False): + """ + Save the checkpoint at the current epoch. + """ + model_no_ddp = self.unwrap_dist_model(self.model) + param_grad_dic = { + k: v.requires_grad for (k, v) in model_no_ddp.named_parameters() + } + state_dict = model_no_ddp.state_dict() + for k in list(state_dict.keys()): + if k in param_grad_dic.keys() and not param_grad_dic[k]: + # delete parameters that do not require gradient + del state_dict[k] + save_obj = { + "model": state_dict, + "optimizer": self.optimizer.state_dict(), + "config": self.config.to_dict(), + "scaler": self.scaler.state_dict() if self.scaler else None, + "epoch": cur_epoch, + } + save_to = os.path.join( + self.output_dir, + "checkpoint_{}.pth".format("best" if is_best else cur_epoch), + ) + logging.info("Saving checkpoint at epoch {} to {}.".format(cur_epoch, save_to)) + torch.save(save_obj, save_to) + + def _reload_best_model(self, model): + """ + Load the best checkpoint for evaluation. + """ + checkpoint_path = os.path.join(self.output_dir, "checkpoint_best.pth") + + logging.info("Loading checkpoint from {}.".format(checkpoint_path)) + checkpoint = torch.load(checkpoint_path, map_location="cpu") + try: + model.load_state_dict(checkpoint["model"]) + except RuntimeError as e: + logging.warning( + """ + Key mismatch when loading checkpoint. This is expected if only part of the model is saved. + Trying to load the model with strict=False. + """ + ) + model.load_state_dict(checkpoint["model"], strict=False) + return model + + def _load_checkpoint(self, url_or_filename): + """ + Resume from a checkpoint. + """ + if is_url(url_or_filename): + cached_file = download_cached_file( + url_or_filename, check_hash=False, progress=True + ) + checkpoint = torch.load(cached_file, map_location=self.device, strict=False) + elif os.path.isfile(url_or_filename): + checkpoint = torch.load(url_or_filename, map_location=self.device, strict=False) + else: + raise RuntimeError("checkpoint url or path is invalid") + + state_dict = checkpoint["model"] + self.unwrap_dist_model(self.model).load_state_dict(state_dict) + + self.optimizer.load_state_dict(checkpoint["optimizer"]) + if self.scaler and "scaler" in checkpoint: + self.scaler.load_state_dict(checkpoint["scaler"]) + + self.start_epoch = checkpoint["epoch"] + 1 + logging.info("Resume checkpoint from {}".format(url_or_filename)) + + @main_process + def log_stats(self, stats, split_name): + if isinstance(stats, dict): + log_stats = {**{f"{split_name}_{k}": v for k, v in stats.items()}} + with open(os.path.join(self.output_dir, "log.txt"), "a") as f: + f.write(json.dumps(log_stats) + "\n") + elif isinstance(stats, list): + pass + + @main_process + def log_config(self): + with open(os.path.join(self.output_dir, "log.txt"), "a") as f: + f.write(json.dumps(self.config.to_dict(), indent=4) + "\n") diff --git a/minigpt4/tasks/__init__.py b/minigpt4/tasks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..82913e9c1eefeb852eb58d9e4bcaedb8f832ae3b --- /dev/null +++ b/minigpt4/tasks/__init__.py @@ -0,0 +1,26 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +from minigpt4.common.registry import registry +from minigpt4.tasks.base_task import BaseTask +from minigpt4.tasks.image_text_pretrain import ImageTextPretrainTask + + +def setup_task(cfg): + assert "task" in cfg.run_cfg, "Task name must be provided." + + task_name = cfg.run_cfg.task + task = registry.get_task_class(task_name).setup_task(cfg=cfg) + assert task is not None, "Task {} not properly registered.".format(task_name) + + return task + + +__all__ = [ + "BaseTask", + "ImageTextPretrainTask", +] diff --git a/minigpt4/tasks/base_task.py b/minigpt4/tasks/base_task.py new file mode 100644 index 0000000000000000000000000000000000000000..9f82a2a52779a782e5a40dfb6a6d9a57e991e345 --- /dev/null +++ b/minigpt4/tasks/base_task.py @@ -0,0 +1,286 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import logging +import os + +import torch +import torch.distributed as dist +from minigpt4.common.dist_utils import get_rank, get_world_size, is_main_process, is_dist_avail_and_initialized +from minigpt4.common.logger import MetricLogger, SmoothedValue +from minigpt4.common.registry import registry +from minigpt4.datasets.data_utils import prepare_sample + + +class BaseTask: + def __init__(self, **kwargs): + super().__init__() + + self.inst_id_key = "instance_id" + + @classmethod + def setup_task(cls, **kwargs): + return cls() + + def build_model(self, cfg): + model_config = cfg.model_cfg + + model_cls = registry.get_model_class(model_config.arch) + return model_cls.from_config(model_config) + + def build_datasets(self, cfg): + """ + Build a dictionary of datasets, keyed by split 'train', 'valid', 'test'. + Download dataset and annotations automatically if not exist. + + Args: + cfg (common.config.Config): _description_ + + Returns: + dict: Dictionary of torch.utils.data.Dataset objects by split. + """ + + datasets = dict() + + datasets_config = cfg.datasets_cfg + + assert len(datasets_config) > 0, "At least one dataset has to be specified." + + for name in datasets_config: + dataset_config = datasets_config[name] + + builder = registry.get_builder_class(name)(dataset_config) + dataset = builder.build_datasets() + + dataset['train'].name = name + if 'sample_ratio' in dataset_config: + dataset['train'].sample_ratio = dataset_config.sample_ratio + + datasets[name] = dataset + + return datasets + + def train_step(self, model, samples): + loss = model(samples)["loss"] + return loss + + def valid_step(self, model, samples): + raise NotImplementedError + + def before_evaluation(self, model, dataset, **kwargs): + model.before_evaluation(dataset=dataset, task_type=type(self)) + + def after_evaluation(self, **kwargs): + pass + + def inference_step(self): + raise NotImplementedError + + def evaluation(self, model, data_loader, cuda_enabled=True): + metric_logger = MetricLogger(delimiter=" ") + header = "Evaluation" + # TODO make it configurable + print_freq = 10 + + results = [] + + for samples in metric_logger.log_every(data_loader, print_freq, header): + samples = prepare_sample(samples, cuda_enabled=cuda_enabled) + + eval_output = self.valid_step(model=model, samples=samples) + results.extend(eval_output) + + if is_dist_avail_and_initialized(): + dist.barrier() + + return results + + def train_epoch( + self, + epoch, + model, + data_loader, + optimizer, + lr_scheduler, + scaler=None, + cuda_enabled=False, + log_freq=50, + accum_grad_iters=1, + ): + return self._train_inner_loop( + epoch=epoch, + iters_per_epoch=lr_scheduler.iters_per_epoch, + model=model, + data_loader=data_loader, + optimizer=optimizer, + scaler=scaler, + lr_scheduler=lr_scheduler, + log_freq=log_freq, + cuda_enabled=cuda_enabled, + accum_grad_iters=accum_grad_iters, + ) + + def train_iters( + self, + epoch, + start_iters, + iters_per_inner_epoch, + model, + data_loader, + optimizer, + lr_scheduler, + scaler=None, + cuda_enabled=False, + log_freq=50, + accum_grad_iters=1, + ): + return self._train_inner_loop( + epoch=epoch, + start_iters=start_iters, + iters_per_epoch=iters_per_inner_epoch, + model=model, + data_loader=data_loader, + optimizer=optimizer, + scaler=scaler, + lr_scheduler=lr_scheduler, + log_freq=log_freq, + cuda_enabled=cuda_enabled, + accum_grad_iters=accum_grad_iters, + ) + + def _train_inner_loop( + self, + epoch, + iters_per_epoch, + model, + data_loader, + optimizer, + lr_scheduler, + scaler=None, + start_iters=None, + log_freq=50, + cuda_enabled=False, + accum_grad_iters=1, + ): + """ + An inner training loop compatible with both epoch-based and iter-based training. + + When using epoch-based, training stops after one epoch; when using iter-based, + training stops after #iters_per_epoch iterations. + """ + use_amp = scaler is not None + + if not hasattr(data_loader, "__next__"): + # convert to iterator if not already + data_loader = iter(data_loader) + + metric_logger = MetricLogger(delimiter=" ") + metric_logger.add_meter("lr", SmoothedValue(window_size=1, fmt="{value:.6f}")) + metric_logger.add_meter("loss", SmoothedValue(window_size=1, fmt="{value:.4f}")) + + # if iter-based runner, schedule lr based on inner epoch. + logging.info( + "Start training epoch {}, {} iters per inner epoch.".format( + epoch, iters_per_epoch + ) + ) + header = "Train: data epoch: [{}]".format(epoch) + if start_iters is None: + # epoch-based runner + inner_epoch = epoch + else: + # In iter-based runner, we schedule the learning rate based on iterations. + inner_epoch = start_iters // iters_per_epoch + header = header + "; inner epoch [{}]".format(inner_epoch) + + for i in metric_logger.log_every(range(iters_per_epoch), log_freq, header): + # if using iter-based runner, we stop after iters_per_epoch iterations. + if i >= iters_per_epoch: + break + + samples = next(data_loader) + + samples = prepare_sample(samples, cuda_enabled=cuda_enabled) + samples.update( + { + "epoch": inner_epoch, + "num_iters_per_epoch": iters_per_epoch, + "iters": i, + } + ) + + lr_scheduler.step(cur_epoch=inner_epoch, cur_step=i) + + with torch.cuda.amp.autocast(enabled=use_amp): + loss = self.train_step(model=model, samples=samples) + + # after_train_step() + if use_amp: + scaler.scale(loss).backward() + else: + loss.backward() + + # update gradients every accum_grad_iters iterations + if (i + 1) % accum_grad_iters == 0: + if use_amp: + scaler.step(optimizer) + scaler.update() + else: + optimizer.step() + optimizer.zero_grad() + + metric_logger.update(loss=loss.item()) + metric_logger.update(lr=optimizer.param_groups[0]["lr"]) + + # after train_epoch() + # gather the stats from all processes + metric_logger.synchronize_between_processes() + logging.info("Averaged stats: " + str(metric_logger.global_avg())) + return { + k: "{:.3f}".format(meter.global_avg) + for k, meter in metric_logger.meters.items() + } + + @staticmethod + def save_result(result, result_dir, filename, remove_duplicate=""): + import json + + result_file = os.path.join( + result_dir, "%s_rank%d.json" % (filename, get_rank()) + ) + final_result_file = os.path.join(result_dir, "%s.json" % filename) + + json.dump(result, open(result_file, "w")) + + if is_dist_avail_and_initialized(): + dist.barrier() + + if is_main_process(): + logging.warning("rank %d starts merging results." % get_rank()) + # combine results from all processes + result = [] + + for rank in range(get_world_size()): + result_file = os.path.join( + result_dir, "%s_rank%d.json" % (filename, rank) + ) + res = json.load(open(result_file, "r")) + result += res + + if remove_duplicate: + result_new = [] + id_list = [] + for res in result: + if res[remove_duplicate] not in id_list: + id_list.append(res[remove_duplicate]) + result_new.append(res) + result = result_new + + json.dump(result, open(final_result_file, "w")) + print("result file saved to %s" % final_result_file) + + return final_result_file diff --git a/minigpt4/tasks/image_text_pretrain.py b/minigpt4/tasks/image_text_pretrain.py new file mode 100644 index 0000000000000000000000000000000000000000..a2214a2e887799fa5236f165ac7329b60bc81d8f --- /dev/null +++ b/minigpt4/tasks/image_text_pretrain.py @@ -0,0 +1,18 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +from minigpt4.common.registry import registry +from minigpt4.tasks.base_task import BaseTask + + +@registry.register_task("image_text_pretrain") +class ImageTextPretrainTask(BaseTask): + def __init__(self): + super().__init__() + + def evaluation(self, model, data_loader, cuda_enabled=True): + pass diff --git a/prompts/alignment.txt b/prompts/alignment.txt new file mode 100644 index 0000000000000000000000000000000000000000..38ae75a9cee293861f06544cbff6fdc4aa941d85 --- /dev/null +++ b/prompts/alignment.txt @@ -0,0 +1,4 @@ + Describe this image in detail. + Take a look at this image and describe what you notice. + Please provide a detailed description of the picture. + Could you describe the contents of this image for me? \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..bbc3244d2e2c0684f678dba0ccd7c4f87f10b179 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,28 @@ +contexttimer +decord +einops>=0.4.1 +fairscale==0.4.4 +ftfy +iopath +ipython +omegaconf +opencv-python-headless==4.5.5.64 +opendatasets +packaging +pandas +plotly +pre-commit +pycocoevalcap +pycocotools +python-magic +scikit-image +sentencepiece +spacy +streamlit +timm==0.4.12 +torch>=1.10.0 +torchvision +tqdm +transformers>=4.25.0,<4.27 +webdataset +wheel diff --git a/train.py b/train.py new file mode 100644 index 0000000000000000000000000000000000000000..a2dd8946e95b70b5d8cc485e8d303c052c5506a6 --- /dev/null +++ b/train.py @@ -0,0 +1,103 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import argparse +import os +import random + +import numpy as np +import torch +import torch.backends.cudnn as cudnn + +import minigpt4.tasks as tasks +from minigpt4.common.config import Config +from minigpt4.common.dist_utils import get_rank, init_distributed_mode +from minigpt4.common.logger import setup_logger +from minigpt4.common.optims import ( + LinearWarmupCosineLRScheduler, + LinearWarmupStepLRScheduler, +) +from minigpt4.common.registry import registry +from minigpt4.common.utils import now + +# imports modules for registration +from minigpt4.datasets.builders import * +from minigpt4.models import * +from minigpt4.processors import * +from minigpt4.runners import * +from minigpt4.tasks import * + + +def parse_args(): + parser = argparse.ArgumentParser(description="Training") + + parser.add_argument("--cfg-path", required=True, help="path to configuration file.") + parser.add_argument( + "--options", + nargs="+", + help="override some settings in the used config, the key-value pair " + "in xxx=yyy format will be merged into config file (deprecate), " + "change to --cfg-options instead.", + ) + + args = parser.parse_args() + # if 'LOCAL_RANK' not in os.environ: + # os.environ['LOCAL_RANK'] = str(args.local_rank) + + return args + + +def setup_seeds(config): + seed = config.run_cfg.seed + get_rank() + + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + + cudnn.benchmark = False + cudnn.deterministic = True + + +def get_runner_class(cfg): + """ + Get runner class from config. Default to epoch-based runner. + """ + runner_cls = registry.get_runner_class(cfg.run_cfg.get("runner", "runner_base")) + + return runner_cls + + +def main(): + # allow auto-dl completes on main process without timeout when using NCCL backend. + # os.environ["NCCL_BLOCKING_WAIT"] = "1" + + # set before init_distributed_mode() to ensure the same job_id shared across all ranks. + job_id = now() + + cfg = Config(parse_args()) + + init_distributed_mode(cfg.run_cfg) + + setup_seeds(cfg) + + # set after init_distributed_mode() to only log on master. + setup_logger() + + cfg.pretty_print() + + task = tasks.setup_task(cfg) + datasets = task.build_datasets(cfg) + model = task.build_model(cfg) + + runner = get_runner_class(cfg)( + cfg=cfg, job_id=job_id, task=task, model=model, datasets=datasets + ) + runner.train() + + +if __name__ == "__main__": + main() diff --git a/train_configs/minigpt4_stage1_laion.yaml b/train_configs/minigpt4_stage1_laion.yaml new file mode 100644 index 0000000000000000000000000000000000000000..10d3bd4df77e7465f875651f8a8348d1595b2558 --- /dev/null +++ b/train_configs/minigpt4_stage1_laion.yaml @@ -0,0 +1,62 @@ + # Copyright (c) 2022, salesforce.com, inc. + # All rights reserved. + # SPDX-License-Identifier: BSD-3-Clause + # For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause + +model: + arch: mini_gpt4 + model_type: pretrain_vicuna + freeze_vit: True + freeze_qformer: True + + +datasets: + laion: + vis_processor: + train: + name: "blip2_image_train" + image_size: 224 + text_processor: + train: + name: "blip_caption" + sample_ratio: 115 + cc_combine: + vis_processor: + train: + name: "blip2_image_train" + image_size: 224 + text_processor: + train: + name: "blip_caption" + sample_ratio: 14 + + +run: + task: image_text_pretrain + # optimizer + lr_sched: "linear_warmup_cosine_lr" + init_lr: 1e-4 + min_lr: 3e-5 + warmup_lr: 1e-6 + + weight_decay: 0.05 + max_epoch: 4 + batch_size_train: 64 + batch_size_eval: 64 + num_workers: 4 + warmup_steps: 5000 + iters_per_epoch: 5000 + + seed: 42 + output_dir: "/path/to/save/your/model/" + + amp: True + resume_ckpt_path: null + + evaluate: False + train_splits: ["train"] + + device: "cuda" + world_size: 1 + dist_url: "env://" + distributed: True \ No newline at end of file diff --git a/train_configs/minigpt4_stage2_align.yaml b/train_configs/minigpt4_stage2_align.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f2fbf5c815d3114ceeaa621a266c49c3f56f91e7 --- /dev/null +++ b/train_configs/minigpt4_stage2_align.yaml @@ -0,0 +1,56 @@ + # Copyright (c) 2022, salesforce.com, inc. + # All rights reserved. + # SPDX-License-Identifier: BSD-3-Clause + # For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause + +model: + arch: mini_gpt4 + model_type: pretrain_vicuna + freeze_vit: True + freeze_qformer: True + max_txt_len: 160 + end_sym: "###" + prompt_path: "prompts/alignment.txt" + prompt_template: '###Human: {} ###Assistant: ' + ckpt: '/ibex/project/c2133/vicuna_jun_checkpoint_wihtout_prompt/20230412162/checkpoint_3.pth' + + +datasets: + cc_align: + vis_processor: + train: + name: "blip2_image_train" + image_size: 224 + text_processor: + train: + name: "blip_caption" + +run: + task: image_text_pretrain + # optimizer + lr_sched: "linear_warmup_cosine_lr" + init_lr: 3e-5 + min_lr: 1e-5 + warmup_lr: 1e-6 + + weight_decay: 0.05 + max_epoch: 5 + iters_per_epoch: 200 + batch_size_train: 12 + batch_size_eval: 12 + num_workers: 4 + warmup_steps: 200 + + seed: 42 + output_dir: "/ibex/project/c2133/vicuna_ckpt_test/minigpt4_stage2_align" + + amp: True + resume_ckpt_path: null + + evaluate: False + train_splits: ["train"] + + device: "cuda" + world_size: 1 + dist_url: "env://" + distributed: True \ No newline at end of file