Zum Inhalt

Batch-Operationen

Maximieren Sie die Effizienz durch parallele Verarbeitung mehrerer Responses und Bewertungen mit Batch-Operationen

Batch-Operationen ermöglichen es Ihnen, mehrere Elemente in einem einzigen API-Aufruf zu verarbeiten, anstatt separate Aufrufe für jedes Element durchzuführen. In elluminate bedeutet dies, dass Sie mehrere Responses parallel generieren oder mehrere Ratings durchführen können, was die Effizienz deutlich verbessert und den Overhead reduziert.

Anstatt beispielsweise 10 separate API-Aufrufe zu tätigen, um Responses für 10 verschiedene Sets von Template-Variablen zu generieren, können Sie alle 10 Sets in einer einzigen Batch-Anfrage senden. Der Server verarbeitet diese Anfragen parallel und liefert alle Ergebnisse gemeinsam zurück.

Batch-Operationen sind besonders nützlich, wenn Sie:

  • Responses in Masse verarbeiten - Effizient Responses für mehrere Prompts generieren
  • Batch-Ratings - Parallel mehrere Responses anhand von Kriterien bewerten
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
"""v1.0 API version of example_sdk_usage_batch.py

Key changes from v0.x:
- Uses collection.add_many() for batch variable addition (single call)
- Uses client.run_experiment() which handles batch generation and rating
- No need for manual generate_many() + rate_many() calls

The v1.0 API simplifies batch operations significantly because:
1. collection.add_many() replaces the loop with add_to_collection()
2. run_experiment() handles all responses and ratings automatically
"""

from dotenv import load_dotenv
from elluminate import Client

load_dotenv(override=True)

client = Client()

# v1.0: get_or_create_prompt_template - messages is part of lookup
template, _ = client.get_or_create_prompt_template(
    name="Programming Quirks",
    messages="Explain why {{language}}'s {{quirk}} is considered surprising or counterintuitive, "
    "and demonstrate it with a short code example that might trip up even experienced developers.",
)

# v1.0: Rich model method - auto-generate criteria from template if none exist
template.get_or_generate_criteria()

# v1.0: get_or_create_collection
collection, _ = client.get_or_create_collection(
    name="Programming Quirks Variables", defaults={"description": "Decide on defaults dict vs regular params"}
)

# v1.0: Batch add with collection.add_many()
# OLD: Loop with client.template_variables.add_to_collection() for each item
# NEW: Single call with list of variable dicts
values = [
    {"language": "Python", "quirk": "mutable default arguments"},
    {"language": "JavaScript", "quirk": "type coercion"},
]
collection.add_many(variables=values)

# v1.0: run_experiment() handles ALL batch operations internally:
# - Creates the experiment
# - Generates responses for ALL collection items (batch)
# - Rates ALL responses (batch)
# OLD: Required separate generate_many() + rate_many() calls
experiment = client.run_experiment(
    name="Programming Quirks Analysis",
    prompt_template=template,
    collection=collection,
    description="Evaluating explanations of programming language quirks",
)

# Results are already populated - no additional API calls needed
for response in experiment.responses():
    print(f"\n\nResponse: {response.response_str[:200]}...")
    for rating in response.ratings:
        print(f"  Criteria: {rating.criterion.criterion_str}")
        print(f"  Rating: {rating.rating}")

  1. Erstellen Sie ein Experiment zur Verfolgung der Batch-Responses und Ratings. Dieses Experiment wird verwendet, um alle generierten Responses mit diesem Evaluationslauf zu verknüpfen.

  2. Generiert effizient mehrere Responses aus einem einzelnen Prompt-Template mit verschiedenen Template-Variablen. Der Experiment-Parameter verknüpft alle generierten Responses mit dem Experiment.

  3. Bewertet effizient mehrere Responses anhand ihrer jeweiligen Kriterien. Die Ratings werden automatisch mit dem Experiment verknüpft, da die Responses während der Generierung mit ihm verknüpft wurden. Der Rating-Modus bestimmt die Art der zu verwendenden Bewertungsstrategie.

Performance-Überlegungen

Batch-Operationen bieten mehrere Leistungsvorteile:

  • Reduzierter Netzwerk-Overhead
  • Parallele Verarbeitung auf dem Server
  • Geringere Gesamtlatenz für mehrere Operationen
  • Effizientere Ressourcennutzung

Beachten Sie jedoch:

  • Speicherverbrauch bei großen Batches
  • Timeout-Grenzen bei lang laufenden Operationen
  • API-Ratenlimits und Kontingente
  • Komplexität der Fehlerbehandlung