Upload 2 files

Spectrograms.py

@@ -0,0 +1,384 @@
+import numpy as np
+import torch
+import torchaudio
+import librosa
+import librosa.display
+import matplotlib.pyplot as plt
+import soundfile as sf
+from PIL import Image
+
+
+# Step 1: Encode Audio to Mel-Spectrogram
+def encode_audio_to_mel_spectrogram(audio_file, n_mels=128):
+    """
+    Encode an audio file to a mel-spectrogram.
+    
+    Parameters:
+    - audio_file: Path to the audio file.
+    - n_mels: Number of mel bands (default: 128).
+    
+    Returns:
+    - mel_spectrogram_db: Mel-spectrogram in dB scale.
+    - sample_rate: Sample rate of the audio file.
+    """
+    y, sample_rate = librosa.load(audio_file, sr=None)  # Load audio
+    mel_spectrogram = librosa.feature.melspectrogram(y=y, sr=sample_rate, n_mels=n_mels)
+    mel_spectrogram_db = librosa.power_to_db(mel_spectrogram, ref=np.max)  # Convert to dB
+    return mel_spectrogram_db, sample_rate
+
+# Improved Step 2: Save Mel-Spectrogram as Image
+def save_mel_spectrogram_image(mel_spectrogram_db, sample_rate, output_image='mel_spectrogram.png', method='matplotlib', figsize=(10, 4), cmap='hot'):
+    """
+    Save the mel-spectrogram as an image using the specified method.
+    
+    Parameters:
+    - mel_spectrogram_db: Mel-spectrogram in dB scale.
+    - sample_rate: Sample rate of the audio file.
+    - output_image: Path to save the image.
+    - method: Method for saving ('matplotlib' or 'custom').
+    - figsize: Size of the figure for matplotlib (default: (10, 4)).
+    - cmap: Colormap for the spectrogram (default: 'hot').
+    """
+    if method == 'matplotlib':
+        plt.figure(figsize=figsize)
+        librosa.display.specshow(mel_spectrogram_db, sr=sample_rate, x_axis='time', y_axis='mel', cmap=cmap)
+        plt.colorbar(format='%+2.0f dB')
+        plt.title('Mel-Spectrogram')
+        plt.savefig(output_image)
+        plt.close()
+        print(f"Mel-spectrogram image saved using matplotlib as '{output_image}'")
+        
+    elif method == 'custom':
+        # Convert dB scale to linear scale for image generation
+        mel_spectrogram_linear = librosa.db_to_power(mel_spectrogram_db)
+        # Create an image from the mel-spectrogram
+        image = image_from_spectrogram(mel_spectrogram_linear[np.newaxis, ...])  # Add channel dimension
+        # Save the image
+        image.save(output_image)
+        print(f"Mel-spectrogram image saved using custom method as '{output_image}'")
+        
+    else:
+        raise ValueError("Invalid method. Choose 'matplotlib' or 'custom'.")
+
+
+# Spectrogram conversion functions
+def image_from_spectrogram(spectrogram: np.ndarray, power: float = 0.25) -> Image.Image:
+    """
+    Compute a spectrogram image from a spectrogram magnitude array.
+
+    Args:
+        spectrogram: (channels, frequency, time)
+        power: A power curve to apply to the spectrogram to preserve contrast
+
+    Returns:
+        image: (frequency, time, channels)
+    """
+    # Rescale to 0-1
+    max_value = np.max(spectrogram)
+    data = spectrogram / max_value
+
+    # Apply the power curve
+    data = np.power(data, power)
+
+    # Rescale to 0-255 and invert
+    data = 255 - (data * 255).astype(np.uint8)
+
+    # Convert to a PIL image
+    if data.shape[0] == 1:
+        image = Image.fromarray(data[0], mode="L").convert("RGB")
+    elif data.shape[0] == 2:
+        data = np.array([np.zeros_like(data[0]), data[0], data[1]]).transpose(1, 2, 0)
+        image = Image.fromarray(data, mode="RGB")
+    else:
+        raise NotImplementedError(f"Unsupported number of channels: {data.shape[0]}")
+
+    # Flip Y
+    image = image.transpose(Image.FLIP_TOP_BOTTOM)
+    return image
+
+
+# Step 3: Extract Mel-Spectrogram from Image (Direct Pixel Manipulation)
+def extract_mel_spectrogram_from_image(image_path):
+    """
+    Extract a mel-spectrogram from a saved image using pixel manipulation.
+    
+    Parameters:
+    - image_path: Path to the spectrogram image file.
+    
+    Returns:
+    - mel_spectrogram_db: The extracted mel-spectrogram in dB scale.
+    """
+    img = Image.open(image_path).convert('L')  # Open image and convert to grayscale
+    img_array = np.array(img)  # Convert to NumPy array
+    mel_spectrogram_db = img_array / 255.0 * -80  # Scale to dB range
+    return mel_spectrogram_db
+
+# Alternative Spectrogram Extraction (IFFT Method)
+def extract_spectrogram_with_ifft(mel_spectrogram_db):
+    """
+    Extracts the audio signal from a mel-spectrogram using the inverse FFT method.
+    
+    Parameters:
+    - mel_spectrogram_db: The mel-spectrogram in dB scale.
+    
+    Returns:
+    - audio: The reconstructed audio signal.
+    """
+    # Convert dB mel-spectrogram back to linear scale
+    mel_spectrogram = librosa.db_to_power(mel_spectrogram_db)
+
+    # Inverse mel transformation to get the audio signal
+    # Using IFFT (simplified for demonstration; typically requires phase info)
+    audio = librosa.feature.inverse.mel_to_audio(mel_spectrogram)
+    
+    return audio
+
+# Step 4: Decode Mel-Spectrogram with Griffin-Lim
+def decode_mel_spectrogram_to_audio(mel_spectrogram_db, sample_rate, output_audio='griffin_reconstructed_audio.wav'):
+    """
+    Decode a mel-spectrogram into audio using Griffin-Lim algorithm.
+    
+    Parameters:
+    - mel_spectrogram_db: The mel-spectrogram in dB scale.
+    - sample_rate: The sample rate for the audio file.
+    - output_audio: Path to save the reconstructed audio file.
+    """
+    # Convert dB mel-spectrogram back to linear scale
+    mel_spectrogram = librosa.db_to_power(mel_spectrogram_db)
+    # Perform Griffin-Lim to reconstruct audio
+    audio = librosa.griffinlim(mel_spectrogram)
+    # Save the generated audio
+    sf.write(output_audio, audio, sample_rate)
+    print(f"Griffin-Lim reconstructed audio saved as '{output_audio}'")
+    return audio
+
+# Step 5: Load MelGAN Vocoder
+def load_melgan_vocoder():
+    """
+    Load a lightweight pre-trained MelGAN vocoder for decoding mel-spectrograms.
+    Returns a torch MelGAN vocoder model.
+    """
+    model = torchaudio.models.MelGAN()  # Load MelGAN model
+    model.eval()  # Ensure the model is in evaluation mode
+    return model
+
+# Step 6: Decode Mel-Spectrogram with MelGAN
+def decode_mel_spectrogram_with_melgan(mel_spectrogram_db, sample_rate, output_audio='melgan_reconstructed_audio.wav'):
+    """
+    Decode a mel-spectrogram into audio using MelGAN vocoder.
+    
+    Parameters:
+    - mel_spectrogram_db: The mel-spectrogram in dB scale.
+    - sample_rate: The sample rate for the audio file.
+    - output_audio: Path to save the reconstructed audio file.
+    
+    Returns:
+    - audio: The reconstructed audio signal.
+    """
+    # Convert dB mel-spectrogram back to linear scale
+    mel_spectrogram = librosa.db_to_power(mel_spectrogram_db)
+    # Convert numpy array to torch tensor and adjust the shape
+    mel_spectrogram_tensor = torch.tensor(mel_spectrogram).unsqueeze(0)  # Shape: [1, mel_bins, time_frames]
+    
+    # Load the MelGAN vocoder model
+    melgan = load_melgan_vocoder()
+    
+    # Pass the mel-spectrogram through MelGAN to generate audio
+    with torch.no_grad():
+        audio = melgan(mel_spectrogram_tensor).squeeze().numpy()  # Squeeze to remove batch dimension
+    
+    # Save the generated audio
+    sf.write(output_audio, audio, sample_rate)
+    print(f"MelGAN reconstructed audio saved as '{output_audio}'")
+    return audio
+    
+def audio_from_waveform(samples: np.ndarray, sample_rate: int, normalize: bool = False) -> pydub.AudioSegment:
+    """
+    Convert a numpy array of samples of a waveform to an audio segment.
+
+    Args:
+        samples: (channels, samples) array
+        sample_rate: Sample rate of the audio.
+        normalize: Flag to normalize volume.
+
+    Returns:
+        pydub.AudioSegment
+    """
+    # Normalize volume to fit in int16
+    if normalize:
+        samples *= np.iinfo(np.int16).max / np.max(np.abs(samples))
+
+    # Transpose and convert to int16
+    samples = samples.transpose(1, 0).astype(np.int16)
+
+    # Write to the bytes of a WAV file
+    wav_bytes = io.BytesIO()
+    wavfile.write(wav_bytes, sample_rate, samples)
+    wav_bytes.seek(0)
+
+    # Read into pydub
+    return pydub.AudioSegment.from_wav(wav_bytes)
+
+
+def apply_filters(segment: pydub.AudioSegment, compression: bool = False) -> pydub.AudioSegment:
+    """
+    Apply post-processing filters to the audio segment to compress it and keep at a -10 dBFS level.
+
+    Args:
+        segment: The audio segment to filter.
+        compression: Flag to apply dynamic range compression.
+
+    Returns:
+        pydub.AudioSegment
+    """
+    if compression:
+        segment = pydub.effects.normalize(segment, headroom=0.1)
+        segment = segment.apply_gain(-10 - segment.dBFS)
+        segment = pydub.effects.compress_dynamic_range(
+            segment,
+            threshold=-20.0,
+            ratio=4.0,
+            attack=5.0,
+            release=50.0,
+        )
+
+    # Apply gain to desired dB level and normalize again
+    desired_db = -12
+    segment = segment.apply_gain(desired_db - segment.dBFS)
+    return pydub.effects.normalize(segment, headroom=0.1)
+
+
+def stitch_segments(segments: Sequence[pydub.AudioSegment], crossfade_s: float) -> pydub.AudioSegment:
+    """
+    Stitch together a sequence of audio segments with a crossfade between each segment.
+
+    Args:
+        segments: Sequence of audio segments to stitch.
+        crossfade_s: Duration of crossfade in seconds.
+
+    Returns:
+        pydub.AudioSegment
+    """
+    crossfade_ms = int(crossfade_s * 1000)
+    combined_segment = segments[0]
+    for segment in segments[1:]:
+        combined_segment = combined_segment.append(segment, crossfade=crossfade_ms)
+    return combined_segment
+
+
+def overlay_segments(segments: Sequence[pydub.AudioSegment]) -> pydub.AudioSegment:
+    """
+    Overlay a sequence of audio segments on top of each other.
+
+    Args:
+        segments: Sequence of audio segments to overlay.
+
+    Returns:
+        pydub.AudioSegment
+    """
+    assert len(segments) > 0
+    output: pydub.AudioSegment = segments[0]
+    for segment in segments[1:]:
+        output = output.overlay(segment)
+    return output
+
+
+
+# Step 7: Full Pipeline for Audio Processing with Customization
+def mel_spectrogram_pipeline(audio_file, output_image='mel_spectrogram.png', 
+                             output_audio_griffin='griffin_reconstructed_audio.wav', 
+                             output_audio_melgan='melgan_reconstructed_audio.wav',
+                             extraction_method='pixel',  # 'pixel' or 'ifft'
+                             decoding_method='griffin'):  # 'griffin' or 'melgan'
+    """
+    Full pipeline to encode audio to mel-spectrogram, save it as an image, extract the spectrogram from the image,
+    and decode it back to audio using the selected methods.
+    
+    Parameters:
+    - audio_file: Path to the audio file to be processed.
+    - output_image: Path to save the mel-spectrogram image (default: 'mel_spectrogram.png').
+    - output_audio_griffin: Path to save the Griffin-Lim reconstructed audio.
+    - output_audio_melgan: Path to save the MelGAN reconstructed audio.
+    - extraction_method: Method for extraction ('pixel' or 'ifft').
+    - decoding_method: Method for decoding ('griffin' or 'melgan').
+    """
+    # Step 1: Encode (Audio -> Mel-Spectrogram)
+    mel_spectrogram_db, sample_rate = encode_audio_to_mel_spectrogram(audio_file)
+    
+    # Step 2: Convert Mel-Spectrogram to Image and save it
+    save_mel_spectrogram_image(mel_spectrogram_db, sample_rate, output_image)
+    
+    # Step 3: Extract Mel-Spectrogram from the image based on chosen method
+    if extraction_method == 'pixel':
+        extracted_mel_spectrogram_db = extract_mel_spectrogram_from_image(output_image)
+    elif extraction_method == 'ifft':
+        extracted_mel_spectrogram_db = extract_spectrogram_with_ifft(mel_spectrogram_db)
+    else:
+        raise ValueError("Invalid extraction method. Choose 'pixel' or 'ifft'.")
+    
+    # Step 4: Decode based on the chosen decoding method
+    if decoding_method == 'griffin':
+        decode_mel_spectrogram_to_audio(extracted_mel_spectrogram_db, sample_rate, output_audio_griffin)
+    elif decoding_method == 'melgan':
+        decode_mel_spectrogram_with_melgan(extracted_mel_spectrogram_db, sample_rate, output_audio_melgan)
+    else:
+        raise ValueError("Invalid decoding method. Choose 'griffin' or 'melgan'.")
+
+
+def process_audio(audio_file, extraction_method, decoding_method):
+    # Create temporary files for outputs
+    with tempfile.NamedTemporaryFile(suffix=".png") as temp_image, \
+         tempfile.NamedTemporaryFile(suffix=".wav") as temp_audio_griffin, \
+         tempfile.NamedTemporaryFile(suffix=".wav") as temp_audio_melgan:
+        
+        # Step 1: Encode (Audio -> Mel-Spectrogram)
+        mel_spectrogram_db, sample_rate = encode_audio_to_mel_spectrogram(audio_file)
+        
+        # Step 2: Convert Mel-Spectrogram to Image and save it
+        save_mel_spectrogram_image(mel_spectrogram_db, sample_rate, temp_image.name)
+        
+        # Step 3: Extract Mel-Spectrogram from the image based on chosen method
+        if extraction_method == 'pixel':
+            extracted_mel_spectrogram_db = extract_mel_spectrogram_from_image(temp_image.name)
+        elif extraction_method == 'ifft':
+            extracted_mel_spectrogram_db = extract_spectrogram_with_ifft(mel_spectrogram_db)
+        
+        # Step 4: Decode using both methods
+        decode_mel_spectrogram_to_audio(extracted_mel_spectrogram_db, sample_rate, temp_audio_griffin.name)
+        decode_mel_spectrogram_with_melgan(extracted_mel_spectrogram_db, sample_rate, temp_audio_melgan.name)
+        
+        # Return results
+        return (temp_image.name, 
+                temp_audio_griffin.name if decoding_method == 'griffin' else temp_audio_melgan.name)
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=process_audio,
+    inputs=[
+        gr.Audio(type="filepath", label="Upload Audio"),
+        gr.Radio(["pixel", "ifft"], label="Extraction Method", value="pixel"),
+        gr.Radio(["griffin", "melgan"], label="Decoding Method", value="griffin")
+    ],
+    outputs=[
+        gr.Image(type="filepath", label="Mel-Spectrogram"),
+        gr.Audio(type="filepath", label="Reconstructed Audio")
+    ],
+    title="Audio Encoder-Decoder",
+    description="Upload an audio file to encode it to a mel-spectrogram and then decode it back to audio."
+)
+
+# Launch the app
+iface.launch()
+
+
+# Example usage(TEST)
+if __name__ == "__main__":
+    audio_file_path = 'your_audio_file.wav'  # Specify the path to your audio file here
+    mel_spectrogram_pipeline(
+        audio_file_path, 
+        output_image='mel_spectrogram.png',
+        output_audio_griffin='griffin_reconstructed_audio.wav',
+        output_audio_melgan='melgan_reconstructed_audio.wav',
+        extraction_method='pixel',  # Choose 'pixel' or 'ifft'
+        decoding_method='griffin'  # Choose 'griffin' or 'melgan'
+    )

imageTotext-gradio.py

@@ -0,0 +1,288 @@
+import json
+import re
+import uuid
+import os
+import requests
+from PIL import Image
+from PIL import ImageOps
+from io import BytesIO
+from urllib.parse import urlparse
+from pathlib import Path
+from tqdm import tqdm
+import gradio as gr
+from gradio.components import Textbox, Radio, Dataframe
+import torch
+from llava.constants import DEFAULT_IMAGE_TOKEN, IMAGE_TOKEN_INDEX
+from llava.conversation import SeparatorStyle, conv_templates
+from llava.mm_utils import (
+    KeywordsStoppingCriteria,
+    get_model_name_from_path,
+    process_images,
+    tokenizer_image_token,
+)
+from llava.model.builder import load_pretrained_model
+from llava.utils import disable_torch_init
+
+# Set CUDA device
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+
+disable_torch_init()
+torch.manual_seed(1234)
+
+# Load model and other necessary components
+MODEL = "LeroyDyer/Mixtral_AI_Vision-Instruct_X"
+model_name = get_model_name_from_path(MODEL)
+tokenizer, model, image_processor, context_len = load_pretrained_model(
+    model_path=MODEL, model_base=None, model_name=model_name, device="cuda"
+)
+
+def get_extension_from_url(url):
+    """
+    Extract the file extension from the given URL.
+    """
+    parsed_url = urlparse(url)
+    path = Path(parsed_url.path)
+    return path.suffix
+
+def remove_transparency(image):
+    if image.mode in ('RGBA', 'LA') or (image.mode == 'P' and 'transparency' in image.info):
+        alpha = image.convert('RGBA').split()[-1]
+        bg = Image.new("RGB", image.size, (255, 255, 255))
+        bg.paste(image, mask=alpha)
+        return bg
+    else:
+        return image
+
+def load_image(image_file):
+    if image_file.startswith("http://") or image_file.startswith("https://"):
+        response = requests.get(image_file)
+        image = Image.open(BytesIO(response.content)).convert("RGB")
+    else:
+        image = Image.open(image_file).convert("RGB")
+    image = remove_transparency(image)
+    return image
+
+def process_image(image):
+    args = {"image_aspect_ratio": "pad"}
+    image_tensor = process_images([image], image_processor, args)
+    return image_tensor.to(model.device, dtype=torch.float16)
+
+def create_prompt(prompt: str):
+    conv = conv_templates["llava_v0"].copy()
+    roles = conv.roles
+    prompt = DEFAULT_IMAGE_TOKEN + "\n" + prompt
+    conv.append_message(roles[0], prompt)
+    conv.append_message(roles[1], None)
+    return conv.get_prompt(), conv
+
+def remove_duplicates(string):
+    words = string.split()
+    unique_words = []
+
+    for word in words:
+        if word not in unique_words:
+            unique_words.append(word)
+
+    return ' '.join(unique_words)
+
+def ask_image(image: Image, prompt: str):
+    image_tensor = process_image(image)
+    prompt, conv = create_prompt(prompt)
+    input_ids = (
+        tokenizer_image_token(
+            prompt,
+            tokenizer,
+            IMAGE_TOKEN_INDEX,
+            return_tensors="pt",
+        )
+        .unsqueeze(0)
+        .to(model.device)
+    )
+
+    stop_str = conv.sep if conv.sep_style != SeparatorStyle.TWO else conv.sep2
+    stopping_criteria = KeywordsStoppingCriteria(keywords=[stop_str], tokenizer=tokenizer, input_ids=input_ids)
+
+    with torch.inference_mode():
+        output_ids = model.generate(
+            input_ids,
+            images=image_tensor,
+            do_sample=True,
+            temperature=0.2,
+            max_new_tokens=2048,
+            use_cache=True,
+            stopping_criteria=[stopping_criteria],
+        )
+    generated_caption = tokenizer.decode(output_ids[0, input_ids.shape[1] :], skip_special_tokens=True).strip()
+
+    # Remove unnecessary phrases from the generated caption
+    unnecessary_phrases = [
+        "The person is a",
+        "The image is",
+        "looking directly at the camera",
+        "in the image",
+        "taking a selfie",
+        "posing for a picture",
+        "holding a cellphone",
+        "is wearing a pair of sunglasses",
+        "pulled back in a ponytail",
+        "with a large window in the cent",
+        "and there are no other people or objects in the scene.",
+        " and.",
+        "..",
+        " is.",
+    ]
+
+    for phrase in unnecessary_phrases:
+        generated_caption = generated_caption.replace(phrase, "")
+
+    # Split the caption into sentences
+    sentences = generated_caption.split('. ')
+
+    # Check if the last sentence is a fragment and remove it if necessary
+    min_sentence_length = 3
+    if len(sentences) > 1:
+        last_sentence = sentences[-1]
+        if len(last_sentence.split()) <= min_sentence_length:
+            sentences = sentences[:-1]
+
+    # Keep only the first three sentences and append periods
+    sentences = [s.strip() + '.' for s in sentences[:3]]
+
+    generated_caption = ' '.join(sentences)
+
+    generated_caption = remove_duplicates(generated_caption)  # Remove duplicate words
+
+    return generated_caption
+
+
+def fix_generated_caption(generated_caption):
+    # Remove unnecessary phrases from the generated caption
+    unnecessary_phrases = [
+        "The person is",
+        "The image is",
+        "looking directly at the camera",
+        "in the image",
+        "taking a selfie",
+        "posing for a picture",
+        "holding a cellphone",
+        "is wearing a pair of sunglasses",
+        "pulled back in a ponytail",
+        "with a large window in the cent",
+        "and there are no other people or objects in the scene.",
+        " and.",
+        "..",
+        " is.",
+    ]
+
+    for phrase in unnecessary_phrases:
+        generated_caption = generated_caption.replace(phrase, "")
+
+    # Split the caption into sentences
+    sentences = generated_caption.split('. ')
+
+    # Check if the last sentence is a fragment and remove it if necessary
+    min_sentence_length = 3
+    if len(sentences) > 1:
+        last_sentence = sentences[-1]
+        if len(last_sentence.split()) <= min_sentence_length:
+            sentences = sentences[:-1]
+
+    # Capitalize the first letter of the caption and add "a" at the beginning
+    sentences[0] = sentences[0].strip().capitalize()
+    sentences[0] = "a " + sentences[0] if not sentences[0].startswith("A ") else sentences[0]
+
+    generated_caption = '. '.join(sentences)
+
+    generated_caption = remove_duplicates(generated_caption)  # Remove duplicate words
+
+    return generated_caption
+
+def find_image_urls(data, url_pattern=re.compile(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+\.(?:jpg|jpeg|png|webp)')):
+    """
+    Recursively search for image URLs in a JSON object.
+    """
+    if isinstance(data, list):
+        for item in data:
+            for url in find_image_urls(item, url_pattern):
+                yield url
+    elif isinstance(data, dict):
+        for value in data.values():
+            for url in find_image_urls(value, url_pattern):
+                yield url
+    elif isinstance(data, str) and url_pattern.match(data):
+        yield data
+
+def gradio_interface(directory_path, prompt, exist):
+    image_paths = [os.path.join(directory_path, f) for f in os.listdir(directory_path) if f.endswith(('.png', '.jpg', '.jpeg', '.webp'))]
+    captions = []
+    
+    # Check for images.json and process it
+    json_path = os.path.join(directory_path, 'images.json')
+    if os.path.exists(json_path):
+        with open(json_path, 'r') as json_file:
+            data = json.load(json_file)
+            image_urls = list(find_image_urls(data))
+            for url in image_urls:
+                try:
+                    # Generate a unique filename for each image with the correct extension
+                    extension = get_extension_from_url(url) or '.jpg'  # Default to .jpg if no extension is found
+                    unique_filename = str(uuid.uuid4()) + extension
+                    unique_filepath = os.path.join(directory_path, unique_filename)
+                    response = requests.get(url)
+                    with open(unique_filepath, 'wb') as img_file:
+                        img_file.write(response.content)
+                    image_paths.append(unique_filepath)
+                except Exception as e:
+                    captions.append((url, f"Error downloading {url}: {e}"))
+
+    # Process each image path with tqdm progress tracker
+    for im_path in tqdm(image_paths, desc="Captioning Images", unit="image"):
+        base_name = os.path.splitext(os.path.basename(im_path))[0]
+        caption_path = os.path.join(directory_path, base_name + '.caption')
+
+        # Handling existing files
+        if os.path.exists(caption_path) and exist == 'skip':
+            captions.append((base_name, "Skipped existing caption"))
+            continue
+        elif os.path.exists(caption_path) and exist == 'add':
+            mode = 'a'
+        else:
+            mode = 'w'
+
+        # Image captioning
+        try:
+            im = load_image(im_path)
+            result = ask_image(im, prompt)
+
+            # Fix the generated caption
+            fixed_result = fix_generated_caption(result)
+
+            # Writing to a text file
+            with open(caption_path, mode) as file:
+                if mode == 'a':
+                    file.write("\n")
+                file.write(fixed_result)  # Write the fixed caption
+
+            captions.append((base_name, fixed_result))
+        except Exception as e:
+            captions.append((base_name, f"Error processing {im_path}: {e}"))
+
+    return captions
+
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        Textbox(label="Directory Path"),
+        Textbox(default="Describe the persons, The person is appearance like eyes color, hair color, skin color, and the clothes, object position the scene and the situation. Please describe it detailed. Don't explain the artstyle of the image", label="Captioning Prompt"),
+        Radio(["skip", "replace", "add"], label="Existing Caption Action", default="skip")
+    ],
+    outputs=[
+        Dataframe(type="pandas", headers=["Image", "Caption"], label="Captions")
+    ],
+    title="Image Captioning",
+    description="Generate captions for images in a specified directory."
+)
+
+# Run the Gradio app
+if __name__ == "__main__":
+    iface.launch()