1
import data_designer.config as dd
2
from data_designer.interface import DataDesigner
3
 

1
data_designer = DataDesigner()
2
 

1
# This name is set in the model provider configuration.
2
MODEL_PROVIDER = "nvidia"
3
 
4
# The model ID is from build.nvidia.com.
5
MODEL_ID = "nvidia/nemotron-3-nano-30b-a3b"
6
 
7
# We choose this alias to be descriptive for our use case.
8
MODEL_ALIAS = "nemotron-nano-v3"
9
 
10
model_configs = [
11
    dd.ModelConfig(
12
        alias=MODEL_ALIAS,
13
        model=MODEL_ID,
14
        provider=MODEL_PROVIDER,
15
        inference_parameters=dd.ChatCompletionInferenceParams(
16
            temperature=1.0,
17
            top_p=1.0,
18
            max_tokens=2048,
19
            extra_body={"chat_template_kwargs": {"enable_thinking": False}},
20
        ),
21
    )
22
]
23
 

1
config_builder = dd.DataDesignerConfigBuilder(model_configs=model_configs)
2
 

1
from decimal import Decimal
2
from typing import Literal
3
 
4
from pydantic import BaseModel, Field
5
 
6
 
7
# We define a Product schema so that the name, description, and price are generated
8
# in one go, with the types and constraints specified.
9
class Product(BaseModel):
10
    name: str = Field(description="The name of the product")
11
    description: str = Field(description="A description of the product")
12
    price: Decimal = Field(description="The price of the product", ge=10, le=1000, decimal_places=2)
13
 
14
 
15
class ProductReview(BaseModel):
16
    rating: int = Field(description="The rating of the product", ge=1, le=5)
17
    customer_mood: Literal["irritated", "mad", "happy", "neutral", "excited"] = Field(
18
        description="The mood of the customer"
19
    )
20
    review: str = Field(description="A review of the product")
21
 

1
# Since we often only want a few attributes from Person objects, we can
2
# set drop=True in the column config to drop the column from the final dataset.
3
config_builder.add_column(
4
    dd.SamplerColumnConfig(
5
        name="customer",
6
        sampler_type=dd.SamplerType.PERSON_FROM_FAKER,
7
        params=dd.PersonFromFakerSamplerParams(),
8
        drop=True,
9
    )
10
)
11
 
12
config_builder.add_column(
13
    dd.SamplerColumnConfig(
14
        name="product_category",
15
        sampler_type=dd.SamplerType.CATEGORY,
16
        params=dd.CategorySamplerParams(
17
            values=[
18
                "Electronics",
19
                "Clothing",
20
                "Home & Kitchen",
21
                "Books",
22
                "Home Office",
23
            ],
24
        ),
25
    )
26
)
27
 
28
config_builder.add_column(
29
    dd.SamplerColumnConfig(
30
        name="product_subcategory",
31
        sampler_type=dd.SamplerType.SUBCATEGORY,
32
        params=dd.SubcategorySamplerParams(
33
            category="product_category",
34
            values={
35
                "Electronics": [
36
                    "Smartphones",
37
                    "Laptops",
38
                    "Headphones",
39
                    "Cameras",
40
                    "Accessories",
41
                ],
42
                "Clothing": [
43
                    "Men's Clothing",
44
                    "Women's Clothing",
45
                    "Winter Coats",
46
                    "Activewear",
47
                    "Accessories",
48
                ],
49
                "Home & Kitchen": [
50
                    "Appliances",
51
                    "Cookware",
52
                    "Furniture",
53
                    "Decor",
54
                    "Organization",
55
                ],
56
                "Books": [
57
                    "Fiction",
58
                    "Non-Fiction",
59
                    "Self-Help",
60
                    "Textbooks",
61
                    "Classics",
62
                ],
63
                "Home Office": [
64
                    "Desks",
65
                    "Chairs",
66
                    "Storage",
67
                    "Office Supplies",
68
                    "Lighting",
69
                ],
70
            },
71
        ),
72
    )
73
)
74
 
75
config_builder.add_column(
76
    dd.SamplerColumnConfig(
77
        name="target_age_range",
78
        sampler_type=dd.SamplerType.CATEGORY,
79
        params=dd.CategorySamplerParams(values=["18-25", "25-35", "35-50", "50-65", "65+"]),
80
    )
81
)
82
 
83
# Sampler columns support conditional params, which are used if the condition is met.
84
# In this example, we set the review style to rambling if the target age range is 18-25.
85
# Note conditional parameters are only supported for Sampler column types.
86
config_builder.add_column(
87
    dd.SamplerColumnConfig(
88
        name="review_style",
89
        sampler_type=dd.SamplerType.CATEGORY,
90
        params=dd.CategorySamplerParams(
91
            values=["rambling", "brief", "detailed", "structured with bullet points"],
92
            weights=[1, 2, 2, 1],
93
        ),
94
        conditional_params={
95
            "target_age_range == '18-25'": dd.CategorySamplerParams(values=["rambling"]),
96
        },
97
    )
98
)
99
 
100
# Optionally validate that the columns are configured correctly.
101
data_designer.validate(config_builder)
102
 

1
# We can create new columns using Jinja expressions that reference
2
# existing columns, including attributes of nested objects.
3
config_builder.add_column(
4
    dd.ExpressionColumnConfig(name="customer_name", expr="{{ customer.first_name }} {{ customer.last_name }}")
5
)
6
 
7
config_builder.add_column(dd.ExpressionColumnConfig(name="customer_age", expr="{{ customer.age }}"))
8
 
9
config_builder.add_column(
10
    dd.LLMStructuredColumnConfig(
11
        name="product",
12
        prompt=(
13
            "Create a product in the '{{ product_category }}' category, focusing on products  "
14
            "related to '{{ product_subcategory }}'. The target age range of the ideal customer is "
15
            "{{ target_age_range }} years old. The product should be priced between $10 and $1000."
16
        ),
17
        output_format=Product,
18
        model_alias=MODEL_ALIAS,
19
    )
20
)
21
 
22
# We can even use if/else logic in our Jinja expressions to create more complex prompt patterns.
23
config_builder.add_column(
24
    dd.LLMStructuredColumnConfig(
25
        name="customer_review",
26
        prompt=(
27
            "Your task is to write a review for the following product:\n\n"
28
            "Product Name: {{ product.name }}\n"
29
            "Product Description: {{ product.description }}\n"
30
            "Price: {{ product.price }}\n\n"
31
            "Imagine your name is {{ customer_name }} and you are from {{ customer.city }}, {{ customer.state }}. "
32
            "Write the review in a style that is '{{ review_style }}'."
33
            "{% if target_age_range == '18-25' %}"
34
            "Make sure the review is more informal and conversational.\n"
35
            "{% else %}"
36
            "Make sure the review is more formal and structured.\n"
37
            "{% endif %}"
38
            "The review field should contain only the review, no other text."
39
        ),
40
        output_format=ProductReview,
41
        model_alias=MODEL_ALIAS,
42
    )
43
)
44
 
45
data_designer.validate(config_builder)
46
 

1
config_builder.add_column(
2
    dd.LLMTextColumnConfig(
3
        name="complaint_analysis",
4
        model_alias=MODEL_ALIAS,
5
        prompt=(
6
            "A customer reviewed '{{ product.name }}' ({{ product_category }} / {{ product_subcategory }}).\n\n"
7
            "Review: {{ customer_review.review }}\n"
8
            "Rating: {{ customer_review.rating }}/5\n"
9
            "Mood: {{ customer_review.customer_mood }}\n\n"
10
            "Write a short root-cause analysis of why this customer is unhappy "
11
            "and suggest one concrete improvement the product team could make."
12
        ),
13
        skip=dd.SkipConfig(when="{{ customer_review.rating > 2 }}"),
14
    )
15
)
16
 

1
config_builder.add_column(
2
    dd.LLMTextColumnConfig(
3
        name="action_items",
4
        model_alias=MODEL_ALIAS,
5
        prompt=(
6
            "Based on this complaint analysis:\n"
7
            "{{ complaint_analysis }}\n\n"
8
            "List 2-3 concrete action items for the product team."
9
        ),
10
    )
11
)
12
 

1
config_builder.add_column(
2
    dd.LLMTextColumnConfig(
3
        name="review_summary",
4
        model_alias=MODEL_ALIAS,
5
        propagate_skip=False,
6
        prompt=(
7
            "Summarize this product review in one sentence:\n"
8
            "Product: {{ product.name }}\n"
9
            "Rating: {{ customer_review.rating }}/5\n"
10
            "Review: {{ customer_review.review }}\n"
11
            "{% if complaint_analysis %}"
12
            "Complaint analysis: {{ complaint_analysis }}\n"
13
            "{% endif %}"
14
        ),
15
    )
16
)
17
 
18
data_designer.validate(config_builder)
19
 

1
preview = data_designer.preview(config_builder, num_records=2)
2
 

1
# Run this cell multiple times to cycle through the 2 preview records.
2
# Look for rows where complaint_analysis and action_items are None (skipped)
3
# vs rows where they were generated (low-rated reviews).
4
preview.display_sample_record()
5
 

1
# The preview dataset is available as a pandas DataFrame.
2
# Notice that complaint_analysis, action_items, and review_summary columns
3
# reflect the skip behavior: None for skipped rows, generated text otherwise.
4
preview.dataset
5
 

1
# Print the analysis as a table.
2
preview.analysis.to_report()
3
 

1
results = data_designer.create(config_builder, num_records=10, dataset_name="tutorial-2")
2
 

1
# Load the generated dataset as a pandas DataFrame.
2
dataset = results.load_dataset()
3
 
4
dataset.head()
5
 

1
# Load the analysis results into memory.
2
analysis = results.load_analysis()
3
 
4
analysis.to_report()
5