Unlock Efficiency: Categorize Movies & Caption Images with OpenAI Batch API

Struggling with large-scale data processing? The OpenAI Batch API offers a cost-effective and efficient solution for tasks like content tagging, sentiment analysis, and more. Forget slow, manual processing – the Batch API lets you analyze massive datasets with higher rate limits and asynchronous job completion, typically within 24 hours.

What is the OpenAI Batch API and Why Should You Use It?

The OpenAI Batch API is a powerful tool that allows you to submit multiple requests as a single job. This is ideal for:

• Bulk Content Enrichment: Tagging, captioning, or enriching content on marketplaces or blogs.
• Automated Support Ticket Management: Categorizing support tickets and suggesting relevant answers.
• Large-Scale Sentiment Analysis: Analyzing customer feedback to understand overall sentiment.
• Document Processing: Generating summaries or translations for extensive document collections.

The primary keyword is "OpenAI Batch API". It helps streamline workflows while reducing costs, making it perfect for businesses needing to parse a lot of data without the hefty price tag.

Getting Started with the Batch API: A Quick Setup

Before diving into practical examples, ensure you have the latest OpenAI Python library installed:

% pip install openai --upgrade

Next, initialize the OpenAI client with your API key:

import json
from openai import OpenAI
import pandas as pd
from IPython.display import Image, display

client = OpenAI()

Now you are ready to use the OpenAI Batch API for efficient data processing.

Example 1: Movie Category Extraction and Summarization

Let’s explore a hands-on example: categorizing movies using the gpt-4o-mini model. We’ll extract movie categories and create a concise one-sentence summary from movie descriptions, outputting the data in JSON format.

1. Loading Movie Data: We will use the IMDB top 1000 movies dataset for this example.
2. Crafting the Perfect Prompt: A well-defined system prompt is crucial for accurate results.

categorize_system_prompt = '''
Your goal is to extract movie categories from movie descriptions, as well as a 1-sentence summary for these movies.
You will be provided with a movie description, and you will output a json object containing the following information:

{
categories: string[] // Array of categories based on the movie description,
summary: string // 1-sentence summary of the movie based on the movie description
}

Categories refer to the genre or type of the movie, like "action", "romance", "comedy", etc. Keep category names simple and use only lower case letters.
Movies can have several categories, but try to keep it under 3-4. Only mention the categories that are the most obvious based on the description.
'''

3. Preparing Batch Requests: For each movie, we create a request formatted as a JSON object. This object includes a unique custom_id, the API endpoint (/v1/chat/completions), and the request body with the model details and messages.
4. Creating and Uploading the Batch File (JSONL): Combine each JSON request into a single .jsonl file, where each line represents a separate request.

tasks = []

for index, row in df.iterrows():
    description = row['Overview']

    task = {
        "custom_id": f"task-{index}",
        "method": "POST",
        "url": "/v1/chat/completions",
        "body": {
            "model": "gpt-4o-mini",
            "temperature": 0.1,
            "response_format": {
                "type": "json_object"
            },
            "messages": [
                {
                    "role": "system",
                    "content": categorize_system_prompt
                },
                {
                    "role": "user",
                    "content": description
                }
            ],
        }
    }

    tasks.append(task)

file_name = "data/batch_tasks_movies.jsonl"

with open(file_name, 'w') as file:
    for obj in tasks:
        file.write(json.dumps(obj) + ' \n ')

5. Submitting and Monitoring the Batch Job: Upload the .jsonl file to OpenAI and create a batch job. Monitor the batch job status using the batch ID until it is completed.

batch_file = client.files.create(
    file=open(file_name, "rb"),
    purpose="batch"
)

batch_job = client.batches.create(
    input_file_id=batch_file.id,
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

batch_job = client.batches.retrieve(batch_job.id)
print(batch_job)

6. Retrieving and Reading Results: Once completed, download the results file. Remember that the results might not be in the same order as your input file, so use the custom_id to match the responses accurately.

Example 2: Image Captioning with Vision Capabilities

The power of the Batch API extends to multimodal tasks. You can implement OpenAI image captioning in bulk. Let's use the gpt-4-turbo model to create captions for furniture images, leveraging its vision capabilities.

1. Prepare Your Data: Load a dataset containing image URLs.
2. Modify the Request Body: Construct the request body to include the image URL and instructions for captioning.
3. Process and Monitor: Like the movie example, create a .jsonl file, upload it, and monitor the batch job until completion.

This example showcases the use cases for the OpenAI Batch API along with efficient image captioning.

Key Benefits of Using the OpenAI Batch API:

• Cost Savings: Benefit from lower pricing compared to individual API calls.
• Higher Rate Limits: Process more data faster without hitting rate limits.
• Asynchronous Processing: Submit jobs and retrieve results later, allowing for efficient workflow management.
• Versatile Applications: Suitable for a wide range of tasks, including text processing, image analysis, and more.

Actionable Takeaways:

• Experiment with different models: The Batch API supports various OpenAI models; find the one that best suits your needs.
• Optimize your prompts: Clear and concise prompts are essential for accurate results.
• Leverage custom_id: Ensure accurate matching of inputs and outputs using the custom_id field.

By implementing the OpenAI Batch API, you can streamline large-scale data processing tasks, reduce costs, and improve efficiency. Embrace the power of batch processing and unlock new possibilities for your projects! The future of scalable AI data processing is here.