Skip to content

armgit / dspy

Public Imported from GitHub
0

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.py
new file mode 100644
index 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__.py
index 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_generation
diff --git a/dspy/utils/synthetic_data_generation.py b/dspy/utils/synthetic_data_generation.py
deleted file mode 100644
index 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)