@astermind/astermind-synth
Advanced tools
OmegaSynth - Label-Conditioned Synthetic Data Generator for AsterMind ELM/KELM Pipelines
Label-conditioned synthetic data generation engine for ELM/KELM pipelines with advanced pattern matching and realism improvements.
retrieval: Simple deterministic retrieval from stored samples (fully realistic formats from curated synthetic examples)elm: ELM-based generation with label conditioning (75-85% realistic)hybrid: Blends retrieval with ELM jitter for realism + variation (80-90% realistic)exact: High-fidelity retrieval with pattern-based variations (typically 95–100% format realism on our internal benchmarks)premium: Best-of-all-worlds mode combining exact, hybrid, and improved ELM (85-100% realistic)npm install @astermind/astermind-synth
git clone https://github.com/astermindai/astermind-synth.git
cd astermind-synth
npm install
npm run build
OmegaSynth requires a valid license token for production use. Set the ASTERMIND_LICENSE_TOKEN environment variable:
export ASTERMIND_LICENSE_TOKEN="your-license-token-here"
A valid license token is required for all use (including evaluation and testing).
For evaluation: Obtain a free 30-day trial key from the license server (see below). Trial keys work exactly like production keys but expire after 30 days.
For testing: Use a trial key, or mock the license runtime in your test setup (see test examples).
Create a free 30-day trial token using the self-service API:
Step 1: Request Trial
curl -X POST "https://c0lgp437u3.execute-api.us-east-1.amazonaws.com/v1/trial/create" \
-H "Content-Type: application/json" \
-d '{"email": "your-email@example.com", "product": "astermind-synth"}'
Response:
{
"message": "Verification email sent",
"email": "your-email@example.com",
"product": "astermind-synth"
}
Step 2: Verify Your Email
Check your email inbox for a verification message from AsterMind. Click the verification link in the email to activate your trial.
Step 3: Get Your License Token
After clicking the verification link, you'll receive:
Step 4: Use Your Token
Set the token as an environment variable:
export ASTERMIND_LICENSE_TOKEN="your-token-here"
Or use it programmatically in your code (see examples in src/omegasynth/examples/).
Trial Details:
Troubleshooting:
For production licenses or extended trials, contact AsterMind at support@astermind.ai
How it works:
"astermind-elm") that include the "astermind-synth" feature will be accepted, allowing multi-product license keys to work across AsterMind productsASTERMIND_LICENSE_TOKEN: Your license token (JWT format) - Required for all useNote: This follows industry licensing patterns with server-validated keys. Free 30-day trial keys are available via the self-service API.
import { loadPretrained } from '@astermind/astermind-synth';
// Load a pretrained retrieval/hybrid model and immediately generate values
const synth = loadPretrained('hybrid');
const firstName = await synth.generate('first_name');
const email = await synth.generate('email');
console.log(`${firstName} - ${email}`);
import { OmegaSynth } from '@astermind/astermind-synth';
const synth = new OmegaSynth({
mode: 'hybrid',
maxLength: 32,
seed: 42
});
const dataset = [
{ label: 'product_name', value: 'Widget A' },
{ label: 'product_name', value: 'Widget B' },
];
await synth.train(dataset);
const product = await synth.generate('product_name');
You can load a pretrained model and fine-tune it with your own data:
import { loadPretrained } from '@astermind/astermind-synth';
// Load pretrained model
const synth = loadPretrained('retrieval');
// Wait for initial training to complete
await new Promise(resolve => setTimeout(resolve, 100));
// Add your custom data
const customData = [
{ label: 'product_name', value: 'MyProduct A' },
{ label: 'product_name', value: 'MyProduct B' },
{ label: 'custom_label', value: 'Custom Value' },
];
// Fine-tune with additional data
await synth.train(customData);
// Now you can generate from both pretrained and custom labels
const product = await synth.generate('product_name');
const custom = await synth.generate('custom_label');
const email = await synth.generate('email'); // Still works from pretrained data
Fine-Tuning Behavior by Mode:
train() adds new samples to existing data (true fine-tuning)train() retrains on the new data only (replaces previous training). For true fine-tuning, combine old and new data before calling train().After training with your own data, you can save the model for later use:
import { OmegaSynth, saveTrainedModel, loadPretrainedFromVersion } from '@astermind/astermind-synth';
import * as path from 'path';
// Train your model
const synth = new OmegaSynth({ mode: 'hybrid' });
const trainingData = [
{ label: 'product_name', value: 'Widget A' },
{ label: 'product_name', value: 'Widget B' },
// ... more training data
];
await synth.train(trainingData);
// Save the trained model
const outputDir = path.join(process.cwd(), 'my-models');
const modelPath = await saveTrainedModel(
synth,
trainingData, // Training data is required for saving
outputDir,
'1.0.0' // Optional version string
);
// Later, load the saved model
const loadedSynth = loadPretrainedFromVersion(modelPath);
const result = await loadedSynth.generate('product_name');
Note: The training data you used must be provided when saving, as it's needed to reconstruct the model when loading.
// Premium mode - combines all improvements
const synth = new OmegaSynth({
mode: 'premium',
maxLength: 50,
seed: 42,
usePatternCorrection: true, // Enable pattern correction
useOneHot: false, // Set to true if memory allows
});
await synth.train(dataset);
const result = await synth.generate('first_name');
// High-fidelity realistic (0% jitter)
const synth = new OmegaSynth({
mode: 'hybrid',
exactMode: true, // 0% jitter = high-fidelity realistic
usePatternCorrection: true,
});
Main class for synthetic data generation.
const synth = new OmegaSynth({
mode: 'retrieval' | 'elm' | 'hybrid' | 'exact' | 'premium',
maxLength?: number, // Maximum string length (default: 32)
seed?: number, // Random seed for deterministic generation
exactMode?: boolean, // For hybrid: use 0% jitter (default: false)
useOneHot?: boolean, // Use one-hot encoding (default: false)
useClassification?: boolean, // Use classification (default: false)
usePatternCorrection?: boolean, // Enable pattern correction (default: true)
});
// Train the generator
await synth.train(dataset: LabeledSample[]);
// Generate a single sample
const result = await synth.generate(label: string, seed?: number);
// Generate multiple samples
const batch = await synth.generateBatch(label: string, count: number);
// Get all available labels
const labels = synth.getLabels();
// Check if trained
const isReady = synth.isTrained();
// Save trained model (requires training data)
await saveTrainedModel(synth, trainingData, './my-models', '1.0.0');
interface LabeledSample {
label: string;
value: string;
}
The pretrained model supports the following labels:
first_name, last_namephone_number, emailstreet_address, city, state, countrycompany_name, job_title, product_namecolor, uuid, date, credit_card_type (card network names, e.g., Visa®, Mastercard®), device_typeAfter implementing all improvements, internal evaluation on the bundled datasets shows:
phone_number: 82.5%email: 82.4%uuid: 83.3%date: 82.0%street_address: 64.3%first_name: 59.6%city: 53.0%product_name: 50.5%company_name: 49.3%credit_card_type: 47.0%device_type: 46.7%last_name: 42.7%state: 42.7%color: 42.4%country: 37.4%job_title: 35.2%All 10 architectural improvements have been implemented:
All improvements are integrated into the current codebase.
false to prevent memory issues (can be enabled if memory allows)import { OmegaSynth } from '@astermind/astermind-synth';
const synth = new OmegaSynth({
mode: 'hybrid',
maxLength: 32,
});
await synth.train([
{ label: 'first_name', value: 'John' },
{ label: 'first_name', value: 'Jane' },
]);
const name = await synth.generate('first_name');
console.log(name); // "John" or "Jane" or variation
const names = await synth.generateBatch('first_name', 10);
console.log(names); // Array of 10 unique names
// Run evaluation script
npm run evaluate-generated
The evaluation script will generate samples, score quality/realism/uniqueness, and write reports.
npm run build
npm test
# Train a new model
npm run train
# Test a model
npm run test-elm
src/omegasynth/
├── core/
│ ├── PatternCorrector.ts # Pattern matching and correction
│ ├── SequenceContext.ts # N-gram pattern learning
│ ├── CharacterEmbeddings.ts # Character embeddings
│ ├── validation.ts # Label-specific validation
│ └── elm_utils.ts # ELM utilities
├── generators/
│ ├── RetrievalGenerator.ts # Simple retrieval
│ ├── ELMGenerator.ts # ELM-based generation
│ ├── HybridGenerator.ts # Hybrid retrieval + jitter
│ ├── ExactGenerator.ts # High-fidelity retrieval
│ └── PremiumGenerator.ts # Best-of-all-worlds
├── encoders/
│ ├── StringEncoder.ts # String encoding/decoding
│ ├── CharVocab.ts # Character vocabulary
│ └── ...
├── examples/
│ ├── quickstart.ts # Quick start examples
│ ├── trainELMFromSynth.ts # ELM training example
│ └── evaluateGeneratedData.ts # Evaluation script
└── OmegaSynth.ts # Main class
All tests are located in src/omegasynth/tests/ and src/omegasynth/**/__tests__/.
Test coverage includes:
Run tests with:
npm test
npm install @astermind/astermind-elm
npm install @astermind/astermind-synth
import { loadPretrained } from '@astermind/astermind-synth';
const synth = loadPretrained('retrieval'); // Fully realistic formats from curated synthetic examples
const samples = await Promise.all([
synth.generate('first_name'),
synth.generate('last_name'),
synth.generate('email'),
synth.generate('phone_number'),
]);
console.log(samples);
import { ELM } from '@astermind/astermind-elm';
const categories = ['first_name','last_name','email','phone_number'];
const texts: string[] = []; // your synthesized texts
const labels: string[] = []; // the corresponding labels
const elm = new ELM({
useTokenizer: true,
hiddenUnits: 256,
categories,
maxLen: 50,
});
(elm as any).setCategories?.(categories);
// Train
const labelIndices = labels.map(l => categories.indexOf(l));
(elm as any).trainFromData(
(elm as any).encoder.batchEncode(texts).map((v: number[]) => (elm as any).encoder.normalize(v)),
labelIndices
);
// Predict
const preds = (elm as any).predict('John Doe', 3);
console.log(preds);
npm run build
Artifacts are saved under dist/models/vX.Y.Z/.
OmegaSynth relies on curated and/or synthesized data to bootstrap and validate AsterMind pipelines. The following principles govern training and evaluation datasets:
src/omegasynth/models/*.json.retrieval and exact modes reproduce only the samples present in the curated sets; elm, hybrid, and premium may produce variations guided by learned patterns.validation.ts) and pattern correction to enforce format and policy constraints.dist/models/vX.Y.Z/ containing training_data.json, elm_model.json, and a manifest for traceability.These guidelines reflect the content previously documented in the training data statement and are now maintained here to keep a single source of truth.
IMPORTANT: PLEASE READ THIS END USER LICENSE AGREEMENT (“EULA”) CAREFULLY BEFORE USING ASTERMIND SYNTH (“SOFTWARE”). BY INSTALLING, ACCESSING, OR USING THE SOFTWARE, YOU AGREE TO BE BOUND BY THIS EULA. IF YOU DO NOT AGREE, DO NOT INSTALL OR USE THE SOFTWARE.
@astermind/astermind-elm remains subject to its published license.Contact: legal@astermind.ai
NOTE ON MIT REFERENCES: Prior references to "MIT" in this repository applied to earlier open-source portions or third-party components only. AsterMind Synth, as a paid/licensed product, is subject to this EULA. Open-source dependencies remain under their respective licenses.
The following documents are included with this package and govern your use of AsterMind Synth:
These documents are located in the package root directory after installation. For questions or concerns, contact:
AsterMind Synth generates synthetic data designed to match typical formatting and structure. All outputs are fictional and should not be used to represent real individuals. AsterMind Synth does not guarantee perfect realism and should be validated for fitness within your workflows.
Trademark Notice: Visa® and Mastercard® are registered trademarks of their respective owners. AsterMind Synth is not affiliated with or endorsed by any card networks.
npm testnpm run buildFixed: ReferenceError: __dirname is not defined in ESM modules.
Solution: Removed __dirname usage entirely and replaced with process.cwd() + findPackageRoot() pattern. This is the proper approach since we're locating files relative to the package root, not the current file location.
Changes:
import.meta.url from source (causes Jest parse errors)process.cwd() and findPackageRoot() to locate model filesImpact: The ESM build (dist/astermind-synth.esm.js) no longer uses __dirname, fixing the error when used in ESM projects.
setLicenseToken() hasn't completed yetASTERMIND_LICENSE_TOKEN environment variable when state is "missing"state.payload is null but token existsstate.payload.features and decoded JWT payload, allowing tokens with different audiences (e.g., "astermind-elm") that include the "astermind-synth" featurehasFeature() which fails when license state is invalidstate.payload?.features?.includes("astermind-synth") directly, allowing tokens with different audiences (e.g., "astermind-elm") that include the "astermind-synth" featureexact and premium generation modesFAQs
OmegaSynth - Label-Conditioned Synthetic Data Generator for AsterMind ELM/KELM Pipelines
The npm package @astermind/astermind-synth receives a total of 3 weekly downloads. As such, @astermind/astermind-synth popularity was classified as not popular.
We found that @astermind/astermind-synth demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Product
Socket now scans VS Code extensions, giving teams early detection of risky behaviors, hidden capabilities, and supply chain threats in developer tools.
Research
/Security News
Socket uncovered two malicious VS Code themes in a GlassWorm-linked cluster with thousands of installs across VS Code Marketplace and Open VSX.
Security News
/Company News
Capital One is partnering with Socket to proactively secure its open source supply chain.