DSPy: The framework for programming—not prompting—language models
Python
feat(data-generation): Implement dynamic synthetic data generation from pydantic model or via initial sample data
Franck Stephane Ndzomga94a3cd33106b
diff --git a/dspy/experimental/synthetic_data.py b/dspy/experimental/synthetic_data.pynew file mode 100644index 000000000..a8258c864--- /dev/null+++ b/dspy/experimental/synthetic_data.py@@ -0,0 +1,68 @@+from pydantic import BaseModel+import dspy+import random+from typing import List, Optional++class descriptionSignature(dspy.Signature):+ field_name = dspy.InputField(desc="name of a field")+ example = dspy.InputField(desc="an example value for the field")+ description = dspy.OutputField(desc="a short text only description of what the field contains")++class SyntheticDataGenerator:+ def __init__(self, schema_class: Optional[BaseModel] = None, examples: Optional[List[dspy.Example]] = None):+ self.schema_class = schema_class+ self.examples = examples++ def generate(self, sample_size: int) -> List[dspy.Example]:+ if not self.schema_class and not self.examples:+ raise ValueError("Either a schema_class or examples must be provided.")+ if self.examples and len(self.examples) >= sample_size:+ print("No additional data generation needed.")+ return self.examples[:sample_size]++ additional_samples_needed = sample_size - (len(self.examples) if self.examples else 0)+ generated_examples = self._generate_additional_examples(additional_samples_needed)++ return self.examples + generated_examples if self.examples else generated_examples++ def _define_or_infer_fields(self):+ if self.schema_class:+ data_schema = self.schema_class.model_json_schema()+ properties = data_schema['properties']+ elif self.examples:+ inferred_schema = self.examples[0].__dict__['_store']+ descriptor = dspy.Predict(descriptionSignature)+ properties = {field: {'description': str((descriptor(field_name=field, example=str(inferred_schema[field]))).description)}+ for field in inferred_schema.keys()}+ else:+ properties = {}+ return properties++ def _generate_additional_examples(self, additional_samples_needed: int) -> List[dspy.Example]:+ properties = self._define_or_infer_fields()+ class_name = f"{self.schema_class.__name__ if self.schema_class else 'Inferred'}Signature"+ fields = self._prepare_fields(properties, class_name)++ signature_class = type(class_name, (dspy.Signature,), fields)+ generator = dspy.Predict(signature_class, n=additional_samples_needed)+ response = generator(sindex=str(random.randint(1, additional_samples_needed)))++ return [dspy.Example({field_name: getattr(completion, field_name) for field_name in properties.keys()})+ for completion in response.completions]++ def _prepare_fields(self, properties, class_name) -> dict:+ return {+ '__doc__': f"Generates the following outputs: {{{', '.join(properties.keys())}}}.",+ 'sindex': dspy.InputField(desc="a random string"),+ **{field_name: dspy.OutputField(desc=properties[field_name].get('description', 'No description'))+ for field_name in properties.keys()}+ }++# # Usage example+# # Generating synthetic data via a pydantic model+# generator = SyntheticDataGenerator(schema_class=SyntheticFacts)+# examples = generator.generate(sample_size=6)++# # Generating synthetic data via existing examples+# generator = SyntheticDataGenerator(examples=existing_examples)+# examples = generator.generate(sample_size=5)diff --git a/dspy/utils/__init__.py b/dspy/utils/__init__.pyindex 812fe7914..9f8b201f6 100644--- a/dspy/utils/__init__.py+++ b/dspy/utils/__init__.py@@ -1,2 +1 @@from .dummies import *-from .synthetic_data_generation import synthetic_data_generationdiff --git a/dspy/utils/synthetic_data_generation.py b/dspy/utils/synthetic_data_generation.pydeleted file mode 100644index 1d081f5a4..000000000--- a/dspy/utils/synthetic_data_generation.py+++ /dev/null@@ -1,43 +0,0 @@-from pydantic import BaseModel-import dspy-import random--def synthetic_data_generation(schema_class: BaseModel, sample_size: int):- class_name = f"{schema_class.__name__}Signature"-- # Fetch schema information- data_schema = schema_class.model_json_schema()- properties = data_schema['properties']-- fields = {- '__doc__': f"Generates the following outputs: {{{', '.join(properties.keys())}}}.",- 'sindex': dspy.InputField(desc="a random string")- }-- for field_name, field_info in properties.items():- fields[field_name] = dspy.OutputField(desc=field_info.get('description', 'No description'))-- signature_class = type(class_name, (dspy.Signature,), fields)-- generator = dspy.Predict(signature_class, n=sample_size)- response = generator(sindex=str(random.randint(1, sample_size)))--- # Creation of few_shot_examples using dspy.Example- few_shot_examples = [- dspy.Example({- field_name: completion[field_name] for field_name in properties.keys()- }) for completion in response.completions- ]-- return few_shot_examples--# Example usage:--# class SyntheticFacts(BaseModel):-# fact: str = Field(..., description="a statement")-# veracity: bool = Field(..., description="an assessment of the veracity of the statement")--# synthetic_examples = synthetic_data_generation(SyntheticFacts, sample_size=10)--# print(synthetic_examples)