appiq-solution 1.2.0 → 1.3.0

package/#Tools/SkyReels-V2/skycaptioner_v1/examples/test_result.csv

@@ -0,0 +1,5 @@
+path,structural_caption
+./examples/data/1.mp4,"{""subjects"": [{""TYPES"": {""type"": ""Sport"", ""sub_type"": ""Other""}, ""appearance"": ""Wearing winter sports gear, including a helmet and goggles."", ""action"": ""The video shows a snowy mountain landscape with a ski slope surrounded by dense trees and distant mountains. A skier is seen descending the slope, moving from the top left to the bottom right of the frame. The skier maintains a steady pace, navigating the curves of the slope. The background includes a ski lift with chairs moving along the cables, and the slope is marked with red and white lines indicating the path for skiers. The skier continues to descend, gradually getting closer to the bottom of the slope."", ""expression"": """", ""position"": ""Centered in the frame, moving downwards on the slope."", ""is_main_subject"": true}, {""TYPES"": {""type"": ""Scenery"", ""sub_type"": ""Mountain""}, ""appearance"": ""White, covering the ground and trees."", ""action"": """", ""expression"": """", ""position"": ""Surrounding the skier, covering the entire visible area."", ""is_main_subject"": false}, {""TYPES"": {""type"": ""Plant"", ""sub_type"": ""Tree""}, ""appearance"": ""Tall, evergreen, covered in snow."", ""action"": """", ""expression"": """", ""position"": ""Scattered throughout the scene, both in the foreground and background."", ""is_main_subject"": false}, {""TYPES"": {""type"": ""Scenery"", ""sub_type"": ""Mountain""}, ""appearance"": ""Snow-covered, with ski lifts and structures."", ""action"": """", ""expression"": """", ""position"": ""In the background, providing context to the location."", ""is_main_subject"": false}], ""shot_type"": ""long_shot"", ""shot_angle"": ""high_angle"", ""shot_position"": ""overlooking_view"", ""camera_motion"": ""the camera moves toward zooms in"", ""environment"": ""A snowy mountain landscape with a ski slope, trees, and a ski resort in the background."", ""lighting"": ""Bright daylight, casting shadows and highlighting the snow's texture.""}"
+./examples/data/2.mp4,"{""subjects"": [{""TYPES"": {""type"": ""Human"", ""sub_type"": ""Woman""}, ""appearance"": ""Long, straight black hair, wearing a sparkling choker necklace with a diamond-like texture, light-colored top, subtle makeup with pink lipstick, stud earrings."", ""action"": ""A woman wearing a sparkling choker necklace and earrings is sitting in a car, looking to her left and speaking. A man, dressed in a suit, is sitting next to her, attentively watching her. The background outside the car is green, indicating a possible outdoor setting."", ""expression"": ""The individual in the video exhibits a neutral facial expression, characterized by slightly open lips and a gentle, soft-focus gaze. There are no noticeable signs of sadness or distress evident in their demeanor."", ""position"": ""Seated in the foreground of the car, facing slightly to the right."", ""is_main_subject"": true}, {""TYPES"": {""type"": ""Human"", ""sub_type"": ""Man""}, ""appearance"": ""Short hair, wearing a dark-colored suit with a white shirt."", ""action"": """", ""expression"": """", ""position"": ""Seated in the background of the car, facing the woman."", ""is_main_subject"": false}], ""shot_type"": ""close_up"", ""shot_angle"": ""eye_level"", ""shot_position"": ""side_view"", ""camera_motion"": """", ""environment"": ""Interior of a car with dark upholstery."", ""lighting"": ""Soft and natural lighting, suggesting daytime.""}"
+./examples/data/3.mp4,"{""subjects"": [{""TYPES"": {""type"": ""Animal"", ""sub_type"": ""Insect""}, ""appearance"": ""The spider has a spherical, yellowish-green body with darker green stripes and spots. It has eight slender legs with visible joints and segments."", ""action"": ""A spider with a yellow and green body and black and white striped legs is hanging from its web in a natural setting with a blurred background of green and brown hues. The spider remains mostly still, with slight movements in its legs and body, indicating a gentle swaying motion."", ""expression"": """", ""position"": ""The spider is centrally positioned in the frame, hanging from a web."", ""is_main_subject"": true}], ""shot_type"": ""extreme_close_up"", ""shot_angle"": ""eye_level"", ""shot_position"": ""front_view"", ""camera_motion"": """", ""environment"": ""The background consists of vertical, out-of-focus lines in shades of green and brown, suggesting a natural environment with vegetation."", ""lighting"": ""The lighting is soft and diffused, with no harsh shadows, indicating an overcast sky or a shaded area.""}"
+./examples/data/4.mp4,"{""subjects"": [{""TYPES"": {""type"": ""Sport"", ""sub_type"": ""Football""}, ""appearance"": ""Wearing a dark-colored jersey, black shorts, and bright blue soccer shoes with white soles."", ""action"": ""A man is on a grassy field with orange cones placed in a line. He is wearing a gray shirt, black shorts, and black socks with blue shoes. The man starts by standing still with his feet apart, then begins to move forward while keeping his eyes on the cones. He continues to run forward, maintaining his focus on the cones, and his feet move in a coordinated manner to navigate around them. The background shows a clear sky, some trees, and a few buildings in the distance."", ""expression"": """", ""position"": ""Centered in the frame, with the soccer ball positioned between the cones."", ""is_main_subject"": true}, {""TYPES"": {""type"": ""Sport"", ""sub_type"": ""Other""}, ""appearance"": ""Bright orange, conical shape."", ""action"": """", ""expression"": """", ""position"": ""Placed on the grass, creating a path for the soccer player."", ""is_main_subject"": false}], ""shot_type"": ""full_shot"", ""shot_angle"": ""low_angle"", ""shot_position"": ""front_view"", ""camera_motion"": ""use a tracking shot, the camera moves toward zooms in"", ""environment"": ""Outdoor sports field with well-maintained grass, trees, and a clear blue sky."", ""lighting"": ""Bright and natural, suggesting a sunny day.""}"

package/#Tools/SkyReels-V2/skycaptioner_v1/infer_fusion_caption.sh

@@ -0,0 +1,9 @@
+expor LLM_MODEL_PATH="/path/to/your_local_model_path2"
+
+python scripts/vllm_fusion_caption.py \
+    --model_path ${LLM_MODEL_PATH} \
+    --input_csv "./examples/test_result.csv" \
+    --out_csv "./examples/test_result_caption.csv" \
+    --bs 4 \
+    --tp 1 \
+    --task t2v

package/#Tools/SkyReels-V2/skycaptioner_v1/infer_struct_caption.sh

@@ -0,0 +1,8 @@
+expor SkyCaptioner_V1_Model_PATH="/path/to/your_local_model_path"
+
+python scripts/vllm_struct_caption.py \
+    --model_path ${SkyCaptioner_V1_Model_PATH} \
+    --input_csv "./examples/test.csv" \
+    --out_csv "./examepls/test_result.csv" \
+    --tp 1 \
+    --bs 32

package/#Tools/SkyReels-V2/skycaptioner_v1/requirements.txt

@@ -0,0 +1,3 @@
+decord==0.6.0
+transformers>=4.49.0
+vllm==0.8.4

package/#Tools/SkyReels-V2/skycaptioner_v1/scripts/gradio_fusion_caption.py

@@ -0,0 +1,146 @@
+import json
+import argparse
+import pandas as pd
+import gradio as gr
+
+from vllm import LLM, SamplingParams
+
+from vllm_fusion_caption import StructuralCaptionDataset
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--fusioncaptioner_model_path", default=None, type=str)
+parser.add_argument("--tensor_parallel_size", type=int, default=2)
+args = parser.parse_args()
+
+example_input = """
+{
+    "subjects": [
+        {
+            "TYPES": {
+                "type": "Human",
+                "sub_type": "Woman"
+            },
+            "appearance": "Long, straight black hair with bangs, wearing a sparkling choker necklace and a dark-colored top or dress with a visible strap over her shoulder.",
+            "action": "A woman wearing a sparkling choker necklace and earrings is sitting in a car, looking to her left and speaking. A man, dressed in a suit, is sitting next to her, attentively watching her.",
+            "expression": "The individual in the video exhibits a neutral facial expression, characterized by slightly open lips and a gentle, soft-focus gaze. There are no noticeable signs of sadness or distress evident in their demeanor.",
+            "position": "Seated in the foreground of the car, facing slightly to the right.",
+            "is_main_subject": true
+        },
+        {
+            "TYPES": {
+                "type": "Human",
+                "sub_type": "Man"
+            },
+            "appearance": "Short hair, wearing a dark-colored suit with a white shirt.",
+            "action": "",
+            "expression": "",
+            "position": "Seated in the background of the car, facing the woman.",
+            "is_main_subject": false
+        }
+    ],
+    "shot_type": "close_up",
+    "shot_angle": "eye_level",
+    "shot_position": "side_view",
+    "camera_motion": "",
+    "environment": "Interior of a car with a dark color scheme.",
+    "lighting": "Soft and natural lighting, suggesting daytime."
+}
+"""
+
+class FusionCaptioner:
+    def __init__(self, model_path, tensor_parallel_size):
+        self.model = LLM(model=model_path,
+            gpu_memory_utilization=0.9, 
+            max_model_len=4096,
+            tensor_parallel_size=tensor_parallel_size)    
+        self.sampling_params = SamplingParams(
+            temperature=0.1,
+            max_tokens=512,
+            stop=['\n\n']
+        )    
+        self.model_path = model_path
+
+    def __call__(self, structural_caption, task='t2v'):
+        if isinstance(structural_caption, dict):
+            structural_caption = json.dumps(structural_caption, ensure_ascii=False)
+        else:
+            structural_caption = json.dumps(json.loads(structural_caption), ensure_ascii=False)
+        meta = pd.DataFrame([structural_caption], columns=['structural_caption'])
+        print(f'structural_caption: {structural_caption}')
+        print(f'task: {task}')
+        dataset = StructuralCaptionDataset(meta, self.model_path, task)
+        _, fusion_by_llm, text, original_text, camera_movement = dataset[0]
+        llm_original_texts = []     
+        if not fusion_by_llm:     
+            caption = original_text + " " + camera_movement
+            return caption
+        try:
+            outputs = self.model.generate([text], self.sampling_params, use_tqdm=False)
+            result = outputs[0].outputs[0].text
+        except Exception as e:
+            result = llm_original_texts
+        
+        llm_caption = result + " " + camera_movement
+        return llm_caption
+
+def main():
+    fusion_captioner = FusionCaptioner(args.fusioncaptioner_model_path, args.tensor_parallel_size)
+
+    def fusion_caption(structural_caption, task):
+        caption = fusion_captioner(structural_caption, task)
+        return caption
+        
+    with gr.Blocks() as demo:
+        gr.Markdown(
+            """
+            <h1 style="text-align: center; font-size: 2em;">SkyCaptioner</h1>
+            """,
+            elem_id="header"
+        )
+        
+        with gr.Row():
+            with gr.Column(visible=True):
+                with gr.Row():
+                    json_input = gr.Code(
+                        label="Structural Caption",
+                        language="json",
+                        lines=25,
+                        interactive=True
+                    )
+                with gr.Row():
+                    task_input = gr.Radio(
+                        label="Task",
+                        choices=["t2v", "i2v"],
+                        value="t2v",
+                        interactive=True
+                    )                                  
+
+            with gr.Column(visible=True):
+                text_output = gr.Textbox(
+                    label="Fusion Caption",
+                    lines=25,
+                    interactive=False,
+                    autoscroll=True
+                )
+
+        gr.Button("Generate").click(
+            fn=fusion_caption,
+            inputs=[json_input, task_input],
+            outputs=text_output
+        )
+        with gr.Row():
+            gr.Examples(
+                examples=[
+                    [example_input, "t2v"],
+                ],
+                inputs=[json_input, task_input],
+                label="Example Input"
+            )
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7863,
+            share=False
+        )    
+
+if __name__ == '__main__': 
+    main()

package/#Tools/SkyReels-V2/skycaptioner_v1/scripts/gradio_struct_caption.py

@@ -0,0 +1,92 @@
+import json
+import argparse
+import pandas as pd
+import gradio as gr
+from vllm import LLM, SamplingParams
+from vllm_struct_caption import VideoTextDataset
+
+
+class StructCaptioner:
+    def __init__(self, model_path, tensor_parallel_size):
+        self.model = LLM(model=model_path,
+            gpu_memory_utilization=0.6, 
+            max_model_len=31920,
+            tensor_parallel_size=tensor_parallel_size)    
+
+        self.model_path = model_path
+        self.sampling_params = SamplingParams(temperature=0.05, max_tokens=2048)
+
+    def __call__(self, video_path):
+        meta = pd.DataFrame([video_path], columns=['path'])
+        dataset = VideoTextDataset(meta, self.model_path)
+        item = dataset[0]['input']
+        batch_user_inputs = [{
+            'prompt': item['prompt'],
+            'multi_modal_data':{'video': item['multi_modal_data']['video'][0]},
+        }]
+        outputs = self.model.generate(batch_user_inputs, self.sampling_params, use_tqdm=False)
+        caption = outputs[0].outputs[0].text
+        caption = json.loads(caption)
+        caption = json.dumps(caption, indent=4, ensure_ascii=False)
+        return caption
+
+    
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--skycaptioner_model_path", required=True, type=str)
+    parser.add_argument("--tensor_parallel_size", type=int, default=2)
+    args = parser.parse_args()
+
+    struct_captioner = StructCaptioner(args.skycaptioner_model_path, args.tensor_parallel_size)
+    def generate_caption(video_path):
+        caption = struct_captioner(video_path)
+        return caption
+    
+    with gr.Blocks() as demo:
+        gr.Markdown(
+            """
+            <h1 style="text-align: center; font-size: 2em;">SkyCaptioner</h1>
+            """,
+            elem_id="header"
+        )
+        
+        with gr.Row():
+            with gr.Column(visible=True, scale=0.5):
+                with gr.Row():
+                    video_input = gr.Video(
+                        label="Upload Video",
+                        interactive=True,
+                        format="mp4", 
+                    )                                
+
+            with gr.Column(visible=True):
+                json_output = gr.Code(
+                    label="Caption",
+                    language="json",
+                    lines=25,
+                    interactive=False
+                )
+
+        gr.Button("Generate").click(
+            fn=generate_caption,
+            inputs=video_input,
+            outputs=json_output
+        )   
+
+        gr.Examples(
+            examples=[
+                ["./examples/data/1.mp4"],
+                ["./examples/data/2.mp4"],
+            ],
+            inputs=video_input,
+            label="Example Videos"
+        )    
+
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7862,
+            share=False
+        )
+
+if __name__ == '__main__': 
+    main()

package/#Tools/SkyReels-V2/skycaptioner_v1/scripts/utils.py

@@ -0,0 +1,19 @@
+import numpy as np
+import pandas as pd
+
+def result_writer(indices_list: list, result_list: list, meta: pd.DataFrame, column):
+    flat_indices = []
+    for x in zip(indices_list):
+        flat_indices.extend(x)
+    flat_results = []
+    for x in zip(result_list):
+        flat_results.extend(x)
+    
+    flat_indices = np.array(flat_indices)
+    flat_results = np.array(flat_results)
+
+    unique_indices, unique_indices_idx = np.unique(flat_indices, return_index=True)
+    meta.loc[unique_indices, column[0]] = flat_results[unique_indices_idx]
+
+    meta = meta.loc[unique_indices]
+    return meta

package/#Tools/SkyReels-V2/skycaptioner_v1/scripts/vllm_fusion_caption.py

@@ -0,0 +1,256 @@
+import os
+from pathlib import Path
+import argparse
+import glob
+import time
+import gc
+from tqdm import tqdm
+import torch
+from transformers import AutoTokenizer
+import pandas as pd
+from vllm import LLM, SamplingParams
+from torch.utils.data import DataLoader
+import json
+import random
+from utils import result_writer
+
+SYSTEM_PROMPT_I2V = """
+You are an expert in video captioning. You are given a structured video caption and you need to compose it to be more natural and fluent in English.
+
+## Structured Input
+{structured_input}
+
+## Notes
+1. If there has an empty field, just ignore it and do not mention it in the output.
+2. Do not make any semantic changes to the original fields. Please be sure to follow the original meaning.
+3. If the action field is not empty, eliminate the irrelevant information in the action field that is not related to the timing action(such as wearings, background and environment information) to make a pure action field.
+
+## Output Principles and Orders
+1. First, eliminate the static information in the action field that is not related to the timing action, such as background or environment information.
+2. Second, describe each subject with its pure action and expression if these fields exist.
+
+## Output
+Please directly output the final composed caption without any additional information.
+"""
+
+SYSTEM_PROMPT_T2V = """
+You are an expert in video captioning. You are given a structured video caption and you need to compose it to be more natural and fluent in English.
+
+## Structured Input
+{structured_input}
+
+## Notes
+1. According to the action field information, change its name field to the subject pronoun in the action.
+2. If there has an empty field, just ignore it and do not mention it in the output.
+3. Do not make any semantic changes to the original fields. Please be sure to follow the original meaning.
+
+## Output Principles and Orders
+1. First, declare the shot_type, then declare the shot_angle and the shot_position fields.
+2. Second, eliminate information in the action field that is not related to the timing action, such as background or environment information if action is not empty.
+3. Third, describe each subject with its pure action, appearance, expression, position if these fields exist.
+4. Finally, declare the environment and lighting if the environment and lighting fields are not empty.
+
+## Output
+Please directly output the final composed caption without any additional information.
+"""
+
+SHOT_TYPE_LIST = [
+    'close-up shot',
+    'extreme close-up shot',
+    'medium shot',
+    'long shot',
+    'full shot',
+]
+
+
+class StructuralCaptionDataset(torch.utils.data.Dataset):
+    def __init__(self, input_csv, model_path, task=None):
+        if isinstance(input_csv, pd.DataFrame):
+            self.meta = input_csv
+        else:
+            self.meta = pd.read_csv(input_csv)
+        if task is None:
+            self.task = args.task
+        else:
+            self.task = task
+        self.system_prompt = SYSTEM_PROMPT_T2V if self.task == 't2v' else SYSTEM_PROMPT_I2V
+        self.tokenizer = AutoTokenizer.from_pretrained(model_path)
+        
+    
+    def __len__(self):
+        return len(self.meta)
+    
+    def __getitem__(self, index):
+        row = self.meta.iloc[index]
+        real_index = self.meta.index[index]
+
+        struct_caption = json.loads(row["structural_caption"])
+
+        camera_movement = struct_caption.get('camera_motion', '')
+        if camera_movement != '':
+            camera_movement += '.'
+        camera_movement = camera_movement.capitalize()
+        
+        fusion_by_llm = False
+        cleaned_struct_caption = self.clean_struct_caption(struct_caption, self.task)
+        if cleaned_struct_caption.get('num_subjects', 0) > 0:
+            new_struct_caption = json.dumps(cleaned_struct_caption, indent=4, ensure_ascii=False)
+            conversation = [
+                {
+                    "role": "system",
+                    "content": self.system_prompt.format(structured_input=new_struct_caption),
+                },
+            ]
+            text = self.tokenizer.apply_chat_template(
+                conversation,
+                tokenize=False,
+                add_generation_prompt=True
+            )
+            fusion_by_llm = True
+        else:
+            text = '-'
+        return real_index, fusion_by_llm, text, '-', camera_movement
+    
+    def clean_struct_caption(self, struct_caption, task):
+        raw_subjects = struct_caption.get('subjects', [])
+        subjects = []
+        for subject in raw_subjects:
+            subject_type = subject.get("TYPES", {}).get('type', '')
+            subject_sub_type = subject.get("TYPES", {}).get('sub_type', '')
+            if subject_type not in ["Human", "Animal"]:
+                subject['expression'] = ''
+            if subject_type == 'Human' and subject_sub_type == 'Accessory':
+                subject['expression'] = ''
+            if subject_sub_type != '':
+                subject['name'] = subject_sub_type
+            if 'TYPES' in subject:
+                del subject['TYPES']
+            if 'is_main_subject' in subject:
+                del subject['is_main_subject']
+            subjects.append(subject)
+
+        to_del_subject_ids = []
+        for idx, subject in enumerate(subjects):
+            action = subject.get('action', '').strip()
+            subject['action'] = action
+            if random.random() > 0.9 and 'appearance' in subject:
+                del subject['appearance']
+            if random.random() > 0.9 and 'position' in subject:
+                del subject['position']
+            if task == 'i2v':
+                # just keep name and action, expression in subjects
+                dropped_keys = ['appearance', 'position']
+                for key in dropped_keys:
+                    if key in subject:
+                        del subject[key]
+                if subject['action'] == '' and ('expression' not in subject or subject['expression'] == ''):
+                    to_del_subject_ids.append(idx)
+        
+        # delete the subjects according to the to_del_subject_ids
+        for idx in sorted(to_del_subject_ids, reverse=True):
+            del subjects[idx]
+
+
+        shot_type = struct_caption.get('shot_type', '').replace('_', ' ')
+        # if shot_type not in SHOT_TYPE_LIST:
+        #     struct_caption['shot_type'] = ''
+        
+        new_struct_caption = {
+            'num_subjects': len(subjects),
+            'subjects': subjects,
+            'shot_type': struct_caption.get('shot_type', ''),
+            'shot_angle': struct_caption.get('shot_angle', ''),
+            'shot_position': struct_caption.get('shot_position', ''),
+            'environment': struct_caption.get('environment', ''),
+            'lighting': struct_caption.get('lighting', ''),
+        }
+
+        if task == 't2v' and random.random() > 0.9:
+            del new_struct_caption['lighting']
+
+        if task == 'i2v':
+            drop_keys = ['environment', 'lighting', 'shot_type', 'shot_angle', 'shot_position']
+            for drop_key in drop_keys:
+                del new_struct_caption[drop_key]
+        return new_struct_caption
+
+def custom_collate_fn(batch):
+    real_indices, fusion_by_llm, texts, original_texts, camera_movements = zip(*batch)
+    return list(real_indices), list(fusion_by_llm), list(texts), list(original_texts), list(camera_movements)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Caption Fusion by LLM")
+    parser.add_argument("--input_csv", default="./examples/test_result.csv")
+    parser.add_argument("--out_csv", default="./examples/test_result_caption.csv")
+    parser.add_argument("--bs", type=int, default=4)
+    parser.add_argument("--tp", type=int, default=1)
+    parser.add_argument("--model_path", required=True, type=str, help="LLM model path")
+    parser.add_argument("--task", default='t2v', help="t2v or i2v")
+    
+    args = parser.parse_args()
+
+    sampling_params = SamplingParams(
+        temperature=0.1,
+        max_tokens=512,
+        stop=['\n\n']
+    )
+    # model_path = "/maindata/data/shared/public/Common-Models/Qwen2.5-32B-Instruct/"
+
+   
+    llm = LLM(
+        model=args.model_path,
+        gpu_memory_utilization=0.9,
+        max_model_len=4096,
+        tensor_parallel_size = args.tp
+    )
+    
+
+    dataset = StructuralCaptionDataset(input_csv=args.input_csv, model_path=args.model_path)
+    
+    dataloader = DataLoader(
+        dataset,
+        batch_size=args.bs,
+        num_workers=8,
+        collate_fn=custom_collate_fn,
+        shuffle=False,
+        drop_last=False,
+    )
+
+    indices_list = []
+    result_list = []
+    for indices, fusion_by_llms, texts, original_texts, camera_movements in tqdm(dataloader):
+        llm_indices, llm_texts, llm_original_texts, llm_camera_movements = [], [], [], []
+        for idx, fusion_by_llm, text, original_text, camera_movement in zip(indices, fusion_by_llms, texts, original_texts, camera_movements):
+            if fusion_by_llm:
+                llm_indices.append(idx)
+                llm_texts.append(text)
+                llm_original_texts.append(original_text)
+                llm_camera_movements.append(camera_movement)    
+            else:
+                indices_list.append(idx)
+                caption = original_text + " " + camera_movement
+                result_list.append(caption)
+        if len(llm_texts) > 0:
+            try:
+                outputs = llm.generate(llm_texts, sampling_params, use_tqdm=False)
+                results = []
+                for output in outputs:
+                    result = output.outputs[0].text.strip()
+                    results.append(result)
+                indices_list.extend(llm_indices)
+            except Exception as e:
+                print(f"Error at {llm_indices}: {str(e)}")
+                indices_list.extend(llm_indices)
+                results = llm_original_texts
+            
+            for result, camera_movement in zip(results, llm_camera_movements):
+                # concat camera movement to fusion_caption
+                llm_caption = result + " " + camera_movement
+                result_list.append(llm_caption)
+    torch.cuda.empty_cache()
+    gc.collect()
+    gathered_list = [indices_list, result_list]
+    meta_new = result_writer(indices_list, result_list, dataset.meta, column=[f"{args.task}_fusion_caption"])
+    meta_new.to_csv(args.out_csv, index=False)
+