AI-CY25Q3- Model Customization with Red Hat AI

Model Customization with Red Hat AI

Your Data. Your Models. Your AI.

AI Account Advisor

jharmison-redhat/parasol-financial-data

parasol-financial-data/flexible_core_checking at main · jharmison-redhat/parasol-financial-data

Red Hat OpenShift AI

createpvc
createpvc-2
createpvc-3
data-p...ng-op
deletepvc
deletepvc-2
deletepvc-3
genera...rt-op
importer
importer-2
knowle...ct-op
model-to-pvc-op
prereq...ck-op
6
pvc-to...ch-op
pytorc...er-op
pytorc...-op-2
run-final-eval-op
run-mt-bench-op
sdg-op
sdg-to...ct-op
skills...ct-op
taxono...ct-op

Zoom In
Zoom Out
Fit to Screen
Reset View
Expand All
Collapse All

createpvc-3
deletepvc-2
deletepvc-3
genera...rt-op
pvc-to...ch-op
pvc-to...ch-op
pvc-to...ch-op
pytorc...-op-2
run-final-eval-op
run-mt-bench-op
upload-model-op

Skip to content
Navigation Menu
Red-Hat-AI-Innovation-Team
/
sdg_hub
Type / to search
Code
Issues
5
Pull requests
5
Discussions
Actions
Projects
Security
Insights
sdg_hub
Public
Watch13
Fork 15
 Star 22
Red-Hat-AI-Innovation-Team/sdg_hub
 main
9 Branches
4 Tags
t
Add file
Add file
Code
Folders and files
Name	Last commit message	Last commit date

Latest commit
dependabot[bot]
chore(deps): bump DavidAnson/markdownlint-cli2-action (#100)
1ee9335
 · 
History
50 Commits


.github
	
chore(deps): bump DavidAnson/markdownlint-cli2-action (#100)
	


assets/imgs
	
Reasoning Model Customization Update 1 (#62)
	


examples
	
removing the cell outputs (#99)
	


scripts
	
Remove unused scripts and utility files (#68)
	


src/sdg_hub
	
Reasoning Model Customization Update 1 (#62)
	


tests
	
Fix incomplete tag-handling logic in LLMBlock match extraction (#87)
	


.gitignore
	
instructlab/sdg -> sdg_hub + pipy (#52)
	


.isort.cfg
	
Initial public release
	


.markdownlint-cli2.yaml
	
fix: ignore markdown lint errors in 'examples' dir (#70)
	


.pre-commit-config.yaml
	
Initial public release
	


.pylintrc
	
Initial public release
	


CONTRIBUTING.md
	
docs: add CONTRIBUTING.md (#71)
	


LICENSE
	
Initial public release
	


MANIFEST.in
	
instructlab/sdg -> sdg_hub + pipy (#52)
	


Makefile
	
Remove spellcheck linting (#55)
	


README.md
	
chore: README badges (#93)
	


pyproject.toml
	
Update to enable PyPI publishing for sdg_hub (#58)
	


requirements-dev.txt
	
instructlab/sdg -> sdg_hub + pipy (#52)
	


requirements.txt
	
Update datasets requirement from <3.0.0,>=2.18.0 to >=2.18.0,<4.0.0 (#50
	


tox.ini
	
Remove spellcheck linting (#55)
	
Repository files navigation
README
Apache-2.0 license
sdg_hub: Synthetic Data Generation Toolkit for LLMs

    

sdg_hub is a modular, scalable, and efficient solution for creating synthetic data generation workflows in a "no-code" manner. At its core, this framework is designed to simplify data creation for LLMs, allowing users to chain computational units and build powerful pipelines for generating data and processing tasks.

Installation

Latest release from PyPI

pip install sdg-hub

Latest main branch

pip install git+https://github.com/Red-Hat-AI-Innovation-Team/sdg_hub.git
Core Design Principles

The framework is built around the following principles:

Modular Design: Highly composable blocks form the building units of the framework, allowing users to build workflows effortlessly.
No-Code Workflow Creation: Specify workflows using simple YAML configuration files.
Scalability and Performance: Optimized for handling large-scale workflows with millions of records.
Framework Architecture

Blocks: The Fundamental Unit

At the heart of the framework is the Block. Each block is a self-contained computational unit that performs specific tasks, such as:

Making LLM calls
Performing data transformations
Applying filters

Blocks are designed to be:

Modular: Reusable across multiple pipelines.
Composable: Easily chained together to create workflows.

These blocks are implemented in the src/sdg_hub/blocks directory.

Prompts

Prompts are at the core of how LLMs are instructed within SDG Hub. Each LLMBlock is associated with a prompt configuration file written in YAML, allowing users to define the exact behavior of the language model — including system instructions, generation principles, and output formatting.

Prompt YAML Structure

A typical prompt YAML file looks like this:

system: You are a helpful assistant that can summarize text.
introduction: Give me a short summary of the text.
principles:
  - Do not add any new information.
  - Do not miss any key points from the provided text.
examples:
  - input: Red Hat announced the acquisition of Neural Magic...
    output: Red Hat acquired Neural Magic to enhance its AI optimization capabilities.
generation: Here is the document to summarize: {{document}}
Key Fields
system: A high-level instruction that sets the persona or behavior of the model.
introduction: Optional introduction to set context for the user.
principles: A list of guiding constraints or rules the model should follow during generation.
examples: Few-shot examples (optional) to guide output format or tone.
generation: The actual template used to generate the model input. This supports variable injection using {{variable_name}}.
YAML-Based Workflow: The Flow

The YAML configuration file, known as the Flow, is central to defining data generation workflows in the SDG Framework. A Flow describes how blocks and pipelines are orchestrated to process and generate data efficiently. By leveraging YAML, users can create highly customizable and modular workflows without writing any code.

Key Features of a Flow

Modular Design:

Flows are composed of blocks, which can be chained together into pipelines.
Each block performs a specific task, such as generating, filtering, or transforming data.

Reusability:

Blocks and configurations defined in a Flow can be reused across different workflows.
YAML makes it easy to tweak or extend workflows without significant changes.

Ease of Configuration:

Users can specify block types, configurations, and data processing details in a simple and intuitive manner.
Hello World Example

Let’s say you have a document and want to generate a concise summary using an LLM. Here’s how simple that is in sdg_hub:

- block_type: LLMBlock
  block_config:
    block_name: gen_summary
    config_path: prompts/summarization.yaml
    model_id: meta-llama/Llama-3.3-70B-Instruct
    output_cols:
      - summary
  gen_kwargs:
    max_tokens: 512

Want to go further? Add another block to extract keywords from the summary:

- block_type: LLMBlock
  block_config:
    block_name: gen_keywords
    config_path: prompts/keywords.yaml
    model_id: meta-llama/Llama-3.3-70B-Instruct
    output_cols:
      - keywords
  gen_kwargs:
    max_tokens: 64

Just like that, you’ve built a multi-step LLM workflow using nothing but YAML.

Available Blocks

The SDG Framework provides a rich set of blocks for different data processing needs. Here's a comprehensive overview of the available blocks and when to use them:

Base Block Class

The framework is built around the abstract Block class, which serves as the foundation for all other blocks:

Purpose: Provides core functionality and interface for all blocks
Key Features:
Template validation for input data
Configuration loading from YAML files
Standardized block initialization
Common interface for all blocks
Core Methods:
_validate: Validates input data against templates
_load_config: Loads configuration from YAML files
generate: Abstract method for block execution

All blocks inherit from this base class, ensuring consistent behavior and interface across the framework.

LLM Blocks

LLMBlock

Purpose: Generate text using language models
Use Cases:
Generating questions, responses, or any text content
Single-prompt generation with structured outputs
Features:
Supports batched processing
Configurable output parsing
Template-based prompt generation

ConditionalLLMBlock

Purpose: Generate text based on conditional logic
Use Cases:
Different prompt templates based on input conditions
Multi-path text generation workflows
Features:
Multiple config paths for different conditions
Dynamic prompt selection

LLMLogProbBlock

Purpose: Generate text with log probabilities
Use Cases:
Analyzing model confidence
Quality scoring of generations
Features:
Returns top-k log probabilities
JSON-formatted output

LLMMessagesBlock

Purpose: Chat-based text generation
Use Cases:
Multi-turn conversations
Chat-based interactions
Features:
Supports message history
Chat completion API
Filtering and Processing Blocks

FilterByValueBlock

Purpose: Filter datasets based on column values
Use Cases:
Removing unwanted samples
Data cleaning
Quality filtering
Features:
Multiple filter operations
Type conversion support
Parallel processing

IterBlock

Purpose: Iterative processing of data
Use Cases:
Multiple generation attempts
Iterative refinement
Features:
Configurable number of iterations
Nested block execution
Utility Blocks

SamplePopulatorBlock

Purpose: Populate samples with configuration data
Use Cases:
Adding metadata
Configuration injection

SelectorBlock

Purpose: Select data based on mapping
Use Cases:
Conditional data selection
Data routing

CombineColumnsBlock

Purpose: Merge multiple columns
Use Cases:
Text concatenation
Feature combination

FlattenColumnsBlock

Purpose: Convert wide to long format
Use Cases:
Data reshaping
Variable-value pairs

DuplicateColumns

Purpose: Create column copies
Use Cases:
Data preservation
Multiple processing paths

RenameColumns

Purpose: Rename dataset columns
Use Cases:
Standardizing column names
Data reorganization

SetToMajorityValue

Purpose: Replace values with majority
Use Cases:
Data normalization
Outlier handling
Dataflow and Storage

Data Representation: Dataflow between blocks and pipelines is handled using Hugging Face Datasets, which are based on Arrow tables. This provides:

Native parallelization capabilities (e.g., maps, filters).
Support for efficient data transformations.

Data Checkpoints: Intermediate caches of generated data. Checkpoints allow users to:

Resume workflows from the last successful state if interrupted.
Improve reliability for long-running workflows.
Examples

For sample use cases and implementation examples, please refer to the examples directory. This directory contains various examples demonstrating different workflows and use cases of the SDG Framework.

About

Synthetic Data Generation Toolkit for LLMs

Resources
 Readme
License
 Apache-2.0 license
 Activity
 Custom properties
Stars
 22 stars
Watchers
 13 watching
Forks
 15 forks
Report repository


Releases 4
v0.1.0a4 - Important bug fix with LLM Response Parsing
Latest
+ 3 releases


Packages
No packages published



Contributors
12


Languages
Python
97.4%
 
Makefile
1.7%
 
Shell
0.9%
Footer
© 2025 GitHub, Inc.
Footer navigation
Terms
Privacy
Security
Status
Docs
Contact
Manage cookies
Do not share my personal information
Red-Hat-AI-Innovation-Team/sdg_hub: Synthetic Data Generation Toolkit for LLMs

Red-Hat-AI-Innovation-Team/sdg_hub: Synthetic Data Generation Toolkit for LLMs

JupyterLab

Preparing Document for Data generation
This notebook will show you how to do document parsing
Document Chunking
And finally mixing it with user QNA to create seed examples
Install SDG
pip install sdg-hub==0.1.0a2
pip install rich datasets tabulate transformers
Using docling v1
[ ]:
data_dir = 'document_collection/ibm-annual-report'
!OMP_NUM_THREADS=32 mamba run -n docling python ../scripts/docparser.py --input-dir {data_dir} --output-dir {data_dir}
Using docling v2
[ ]:
data_dir = 'document_collection/ibm-annual-report'
!OMP_NUM_THREADS=32 mamba run -n docling python ../scripts/docparser_v2.py --input-dir {data_dir} --output-dir {data_dir} --c docling_v2_config.yaml
Create Seed Examples
[ ]:
from sdg_hub.utils.docprocessor import DocProcessor


output_dir = f"sdg_demo_output/"
# This is where your PDFs are stored
data_dir = '../document_collection/ibm-annual-report' 
# It also have your QNA yaml file
dp = DocProcessor(data_dir, user_config_path=f'{data_dir}/qna.yaml')


### Using docling v1 json
seed_data = dp.get_processed_dataset()


### Using markdown file
seed_data = dp.get_processed_markdown_dataset([f"{data_dir}/ibm-annual-report-2024.md"])


# Note: For now v2 json is not supported


seed_data.to_json(f'{output_dir}/seed_data.jsonl', orient='records', lines=True)
Click to add a cell.

document_pre… - JupyterLab

[1]:
%load_ext autoreload
%autoreload 2
Install SDG
pip install sdg-hub==0.1.0a2
pip install rich datasets tabulate transformers
If you haven't already, run the document pre-processing notebook to create the seed data
[ ]:
# Third Party
from datasets import load_dataset
from openai import OpenAI


# First Party
from sdg_hub.flow import Flow
from sdg_hub.pipeline import Pipeline
from sdg_hub.sdg import SDG
from sdg_hub.utils.docprocessor import DocProcessor
import sys
Setup OpenAI Client for interacting with the model
[ ]:
endpoint = f"http://localhost:8000/v1"
openai_api_key = "EMPTY"
openai_api_base = endpoint


client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)
teacher_model = client.models.list().data[0].id
print(teacher_model)
Run SDG
This will create knowledge flow from provided yaml file
We will run this on small dataset for demo purposes
For large scale generation, please use the python command provided in the next cell
You can analyze the generated data to ensure the quality is similar to proivded QnA pairs
[13]:
knowledge_agentic_pipeline = "../../../src/instructlab/sdg/flows/generation/knowledge/synth_knowledge1.5.yaml"
flow_cfg = Flow(client).get_flow_from_file(knowledge_agentic_pipeline)
sdg = SDG(
    [Pipeline(flow_cfg)],
    num_workers=1,
    batch_size=1,
    save_freq=1000,
)
[5]:
number_of_samples = 5
seed_data_dir = f"sdg_demo_output/"
ds = load_dataset('json', data_files=f'{seed_data_dir}/seed_data.jsonl', split='train')
ds = ds.shuffle(seed=42).select(range(number_of_samples))
Click to add a cell.