text-embedding

Efficient Batch Processing of Text Data with Cognitive Actions

25 Apr 2025
Efficient Batch Processing of Text Data with Cognitive Actions

In the world of machine learning and natural language processing, the ability to efficiently handle and analyze large volumes of text data is crucial. The "Bge Large En Batched" service provides a powerful Cognitive Action that allows developers to perform batch processing of text data, generating normalized embeddings from a JSONL file. This capability not only simplifies the process of embedding creation but also optimizes performance and memory usage, making it ideal for a variety of applications.

Imagine scenarios where you need to analyze customer feedback, process large datasets for sentiment analysis, or build recommendation systems. With batch processing, developers can seamlessly handle multiple text entries at once, significantly reducing the time it takes to generate embeddings for large datasets. The flexibility to customize the batch size allows for fine-tuning based on specific resource constraints, ensuring that applications run smoothly without overwhelming system memory.

Batch Predict Text Embeddings

The Batch Predict Text Embeddings action is designed to convert text data into embeddings—numerical representations of text that can be used for various machine learning tasks. This action addresses the challenge of processing large text datasets efficiently, enabling applications to harness the power of embeddings for deeper insights and improved performance.

Input Requirements

To utilize this action, you need to provide a JSONL file containing your text data. Each line in the file must represent a JSON object with a 'text' field. The input schema requires the following parameters:

  • Path: A URL pointing to the JSONL file (e.g., https://replicate.delivery/pbxt/JdHX0Er26JMM85ryJIH71JG5WVTeehTTipBqsmV2f5XdaS4V/samsum.txt).
  • Batch Size: An integer indicating how many entries to process at once (default is 32, but can be adjusted as needed).
  • Normalize Embeddings: A boolean value to indicate whether the embeddings should be normalized (default is true).

Expected Output

Upon successful invocation, the action returns a URL to a file containing the generated embeddings, which can be used for subsequent analysis or machine learning tasks (e.g., https://assets.cognitiveactions.com/invocations/74823e4b-7aae-4f63-a5ec-94d29ea6363a/52c6be97-8f72-4fd9-9edf-08785cdcc46b.npy).

Use Cases for this Specific Action

  • Sentiment Analysis: Process large volumes of customer feedback or social media posts to derive sentiment insights.
  • Recommendation Systems: Generate embeddings for product descriptions or user reviews to improve recommendation accuracy.
  • Text Classification: Prepare text data for classification tasks by generating embeddings that can be fed into machine learning models.

```python
import requests
import json

# Replace with your actual Cognitive Actions API key and endpoint
# Ensure your environment securely handles the API key
COGNITIVE_ACTIONS_API_KEY = "YOUR_COGNITIVE_ACTIONS_API_KEY"
# This endpoint URL is hypothetical and should be documented for users
COGNITIVE_ACTIONS_EXECUTE_URL = "https://api.cognitiveactions.com/actions/execute"

action_id = "7fcfd483-456f-4aab-b9ff-340fd19dc0ae" # Action ID for: Batch Predict Text Embeddings

# Construct the exact input payload based on the action's requirements
# This example uses the predefined example_input for this action:
payload = {
  "path": "https://replicate.delivery/pbxt/JdHX0Er26JMM85ryJIH71JG5WVTeehTTipBqsmV2f5XdaS4V/samsum.txt",
  "batchSize": 128,
  "normalizeEmbeddings": true
}

headers = {
    "Authorization": f"Bearer {COGNITIVE_ACTIONS_API_KEY}",
    "Content-Type": "application/json",
    # Add any other required headers for the Cognitive Actions API
}

# Prepare the request body for the hypothetical execution endpoint
request_body = {
    "action_id": action_id,
    "inputs": payload
}

print(f"--- Calling Cognitive Action: {action.name or action_id} ---")
print(f"Endpoint: {COGNITIVE_ACTIONS_EXECUTE_URL}")
print(f"Action ID: {action_id}")
print("Payload being sent:")
print(json.dumps(request_body, indent=2))
print("------------------------------------------------")

try:
    response = requests.post(
        COGNITIVE_ACTIONS_EXECUTE_URL,
        headers=headers,
        json=request_body
    )
    response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)

    result = response.json()
    print("Action executed successfully. Result:")
    print(json.dumps(result, indent=2))

except requests.exceptions.RequestException as e:
    print(f"Error executing action {action_id}: {e}")
    if e.response is not None:
        print(f"Response status: {e.response.status_code}")
        try:
            print(f"Response body: {e.response.json()}")
        except json.JSONDecodeError:
            print(f"Response body (non-JSON): {e.response.text}")
    print("------------------------------------------------")



## Conclusion

The Batch Predict Text Embeddings action under the "Bge Large En Batched" service empowers developers to efficiently generate text embeddings from large datasets. Its ability to customize batch sizes and normalize embeddings enhances performance, making it an invaluable tool for tasks such as sentiment analysis, recommendation systems, and text classification. To get started, ensure you have your Cognitive Actions API key ready and explore the possibilities of integrating this powerful action into your applications for improved data insights and performance.
← Back to All Articles