docs: add comprehensive documentation and examples for LLM augmentation
Introduced `llm-augmentation.md`, detailing the creation, training, testing, exporting, and deployment of language models using Brainy's graph database. Added examples showcasing practical usage and pipeline integration. Included class implementations in `llmAugmentations.ts`.
This commit is contained in:
parent
dbea051572
commit
7f95844434
9 changed files with 3447 additions and 44 deletions
1690
src/augmentations/llmAugmentations.ts
Normal file
1690
src/augmentations/llmAugmentations.ts
Normal file
File diff suppressed because it is too large
Load diff
636
src/augmentations/llmTrainingAugmentations.ts
Normal file
636
src/augmentations/llmTrainingAugmentations.ts
Normal file
|
|
@ -0,0 +1,636 @@
|
|||
import {
|
||||
AugmentationType,
|
||||
IActivationAugmentation,
|
||||
AugmentationResponse
|
||||
} from '../types/augmentations.js'
|
||||
import { BrainyData } from '../brainyData.js'
|
||||
import { GraphNoun, GraphVerb, NounType, VerbType } from '../types/graphTypes.js'
|
||||
|
||||
/**
|
||||
* LLMTrainingActivationAugmentation
|
||||
*
|
||||
* An activation augmentation that provides actions for exporting Brainy graph data
|
||||
* to train and export a Language Learning Model (LLM).
|
||||
*/
|
||||
export class LLMTrainingActivationAugmentation implements IActivationAugmentation {
|
||||
readonly name: string
|
||||
readonly description: string
|
||||
enabled: boolean = true
|
||||
private isInitialized = false
|
||||
private brainyData: BrainyData | null = null
|
||||
|
||||
constructor(name: string = 'llm-training-activation') {
|
||||
this.name = name
|
||||
this.description = 'Activation augmentation for training and exporting LLMs using Brainy graph data'
|
||||
}
|
||||
|
||||
getType(): AugmentationType {
|
||||
return AugmentationType.ACTIVATION
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize the augmentation
|
||||
*/
|
||||
async initialize(): Promise<void> {
|
||||
if (this.isInitialized) {
|
||||
return
|
||||
}
|
||||
|
||||
this.isInitialized = true
|
||||
}
|
||||
|
||||
/**
|
||||
* Shut down the augmentation
|
||||
*/
|
||||
async shutDown(): Promise<void> {
|
||||
this.isInitialized = false
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the status of the augmentation
|
||||
*/
|
||||
async getStatus(): Promise<'active' | 'inactive' | 'error'> {
|
||||
return this.isInitialized ? 'active' : 'inactive'
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the Brainy data instance to use for accessing graph data
|
||||
* @param data The BrainyData instance
|
||||
*/
|
||||
setBrainyData(data: BrainyData): void {
|
||||
this.brainyData = data
|
||||
}
|
||||
|
||||
/**
|
||||
* Trigger an action based on a processed command or internal state
|
||||
* @param actionName The name of the action to trigger
|
||||
* @param parameters Optional parameters for the action
|
||||
*/
|
||||
// This is the interface method that returns a synchronous response
|
||||
triggerAction(
|
||||
actionName: string,
|
||||
parameters?: Record<string, unknown>
|
||||
): AugmentationResponse<unknown> {
|
||||
if (!this.brainyData) {
|
||||
return {
|
||||
success: false,
|
||||
data: null,
|
||||
error: 'BrainyData instance not set'
|
||||
}
|
||||
}
|
||||
|
||||
// Start the async operation
|
||||
this.triggerActionAsync(actionName, parameters);
|
||||
|
||||
// Return a placeholder response
|
||||
return {
|
||||
success: true,
|
||||
data: { status: 'processing', actionName, parameters },
|
||||
};
|
||||
}
|
||||
|
||||
// This is the actual implementation that handles the async operations
|
||||
private async triggerActionAsync(
|
||||
actionName: string,
|
||||
parameters?: Record<string, unknown>
|
||||
): Promise<void> {
|
||||
try {
|
||||
let result: AugmentationResponse<unknown>;
|
||||
|
||||
switch (actionName) {
|
||||
case 'exportGraphData':
|
||||
result = await this.handleExportGraphData(parameters || {});
|
||||
break;
|
||||
case 'generateTrainingData':
|
||||
result = await this.handleGenerateTrainingData(parameters || {});
|
||||
break;
|
||||
case 'trainModel':
|
||||
result = await this.handleTrainModel(parameters || {});
|
||||
break;
|
||||
case 'exportModel':
|
||||
result = await this.handleExportModel(parameters || {});
|
||||
break;
|
||||
default:
|
||||
result = {
|
||||
success: false,
|
||||
data: null,
|
||||
error: `Unknown action: ${actionName}`
|
||||
};
|
||||
}
|
||||
|
||||
// Here you would typically emit an event or update a status property
|
||||
// with the result of the async operation
|
||||
console.log(`Action ${actionName} completed:`, result);
|
||||
} catch (error) {
|
||||
console.error(`Error executing action ${actionName}:`, error);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle the exportGraphData action
|
||||
* @param parameters Action parameters
|
||||
*/
|
||||
private async handleExportGraphData(
|
||||
parameters: Record<string, unknown>
|
||||
): Promise<AugmentationResponse<unknown>> {
|
||||
const format = parameters.format as string || 'json'
|
||||
const includeNouns = parameters.includeNouns as boolean || true
|
||||
const includeVerbs = parameters.includeVerbs as boolean || true
|
||||
const nounTypes = parameters.nounTypes as NounType[] || Object.values(NounType)
|
||||
const verbTypes = parameters.verbTypes as VerbType[] || Object.values(VerbType)
|
||||
|
||||
try {
|
||||
const exportData: Record<string, unknown> = {}
|
||||
|
||||
// Export nouns if requested
|
||||
if (includeNouns) {
|
||||
const nouns: GraphNoun[] = []
|
||||
// Get all nouns from BrainyData
|
||||
// Use search to get all nouns of the specified types
|
||||
for (const nounType of nounTypes) {
|
||||
try {
|
||||
// Search for nouns of this type with a high limit to get all
|
||||
const searchResults = await this.brainyData!.searchByNounTypes(
|
||||
'', // Empty query to match all
|
||||
1000, // High limit to get as many as possible
|
||||
[nounType as string]
|
||||
);
|
||||
|
||||
// Add the results to our nouns array
|
||||
if (searchResults && Array.isArray(searchResults)) {
|
||||
for (const result of searchResults) {
|
||||
// SearchResult might not have data directly, use metadata instead
|
||||
if (result.metadata) {
|
||||
nouns.push(result.metadata as unknown as GraphNoun);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
console.warn(`Failed to get nouns of type ${nounType}:`, error);
|
||||
}
|
||||
}
|
||||
|
||||
exportData.nouns = nouns
|
||||
}
|
||||
|
||||
// Export verbs if requested
|
||||
if (includeVerbs) {
|
||||
try {
|
||||
const verbs = await this.brainyData!.getAllVerbs() || []
|
||||
exportData.verbs = verbs.filter(verb => {
|
||||
// Check for verb type in either verb.verb or verb.type
|
||||
const verbType = (verb as any).verb || (verb as any).type;
|
||||
return typeof verbType === 'string' && verbTypes.includes(verbType as VerbType);
|
||||
})
|
||||
} catch (error) {
|
||||
console.warn('Failed to get all verbs:', error);
|
||||
exportData.verbs = [];
|
||||
}
|
||||
}
|
||||
|
||||
// Format the export data
|
||||
if (format === 'json') {
|
||||
return {
|
||||
success: true,
|
||||
data: exportData
|
||||
}
|
||||
} else if (format === 'csv') {
|
||||
// Convert to CSV format (simplified)
|
||||
const csvData = this.convertToCSV(exportData)
|
||||
return {
|
||||
success: true,
|
||||
data: csvData
|
||||
}
|
||||
} else {
|
||||
return {
|
||||
success: false,
|
||||
data: null,
|
||||
error: `Unsupported format: ${format}`
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
return {
|
||||
success: false,
|
||||
data: null,
|
||||
error: `Failed to export graph data: ${error}`
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle the generateTrainingData action
|
||||
* @param parameters Action parameters
|
||||
*/
|
||||
private async handleGenerateTrainingData(
|
||||
parameters: Record<string, unknown>
|
||||
): Promise<AugmentationResponse<unknown>> {
|
||||
const format = parameters.format as string || 'jsonl'
|
||||
const includeEmbeddings = parameters.includeEmbeddings as boolean || true
|
||||
const maxSamples = parameters.maxSamples as number || 1000
|
||||
|
||||
try {
|
||||
// First, export the graph data
|
||||
const exportResult = await this.handleExportGraphData({
|
||||
format: 'json',
|
||||
includeNouns: true,
|
||||
includeVerbs: true
|
||||
})
|
||||
|
||||
if (!exportResult.success) {
|
||||
return exportResult
|
||||
}
|
||||
|
||||
const graphData = exportResult.data as Record<string, unknown>
|
||||
const nouns = graphData.nouns as GraphNoun[] || []
|
||||
const verbs = graphData.verbs as GraphVerb[] || []
|
||||
|
||||
// Generate training samples
|
||||
const trainingSamples = this.generateTrainingSamples(nouns, verbs, maxSamples, includeEmbeddings)
|
||||
|
||||
// Format the training data
|
||||
if (format === 'jsonl') {
|
||||
const jsonlData = trainingSamples.map(sample => JSON.stringify(sample)).join('\n')
|
||||
return {
|
||||
success: true,
|
||||
data: jsonlData
|
||||
}
|
||||
} else if (format === 'json') {
|
||||
return {
|
||||
success: true,
|
||||
data: trainingSamples
|
||||
}
|
||||
} else {
|
||||
return {
|
||||
success: false,
|
||||
data: null,
|
||||
error: `Unsupported format: ${format}`
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
return {
|
||||
success: false,
|
||||
data: null,
|
||||
error: `Failed to generate training data: ${error}`
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle the trainModel action
|
||||
* @param parameters Action parameters
|
||||
*/
|
||||
private async handleTrainModel(
|
||||
parameters: Record<string, unknown>
|
||||
): Promise<AugmentationResponse<unknown>> {
|
||||
const modelType = parameters.modelType as string || 'default'
|
||||
const epochs = parameters.epochs as number || 10
|
||||
const batchSize = parameters.batchSize as number || 32
|
||||
const learningRate = parameters.learningRate as number || 0.001
|
||||
|
||||
try {
|
||||
// First, generate the training data
|
||||
const trainingDataResult = await this.handleGenerateTrainingData({
|
||||
format: 'json'
|
||||
})
|
||||
|
||||
if (!trainingDataResult.success) {
|
||||
return trainingDataResult
|
||||
}
|
||||
|
||||
const trainingSamples = trainingDataResult.data as any[]
|
||||
|
||||
// In a real implementation, this would call an actual LLM training library
|
||||
// For now, we'll just simulate the training process
|
||||
const trainingResult = this.simulateTraining(
|
||||
trainingSamples,
|
||||
modelType,
|
||||
epochs,
|
||||
batchSize,
|
||||
learningRate
|
||||
)
|
||||
|
||||
return {
|
||||
success: true,
|
||||
data: trainingResult
|
||||
}
|
||||
} catch (error) {
|
||||
return {
|
||||
success: false,
|
||||
data: null,
|
||||
error: `Failed to train model: ${error}`
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle the exportModel action
|
||||
* @param parameters Action parameters
|
||||
*/
|
||||
private async handleExportModel(
|
||||
parameters: Record<string, unknown>
|
||||
): Promise<AugmentationResponse<unknown>> {
|
||||
const format = parameters.format as string || 'onnx'
|
||||
const modelId = parameters.modelId as string
|
||||
|
||||
try {
|
||||
// In a real implementation, this would export the trained model
|
||||
// For now, we'll just return a simulated export result
|
||||
const exportResult = {
|
||||
modelId: modelId || 'default-model',
|
||||
format,
|
||||
timestamp: new Date().toISOString(),
|
||||
size: '125MB',
|
||||
parameters: '7B',
|
||||
url: `https://example.com/models/${modelId || 'default-model'}.${format}`
|
||||
}
|
||||
|
||||
return {
|
||||
success: true,
|
||||
data: exportResult
|
||||
}
|
||||
} catch (error) {
|
||||
return {
|
||||
success: false,
|
||||
data: null,
|
||||
error: `Failed to export model: ${error}`
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates an expressive output or response from Brainy
|
||||
* @param knowledgeId The identifier of the knowledge to express
|
||||
* @param format The desired output format (e.g., 'text', 'json')
|
||||
*/
|
||||
generateOutput(
|
||||
knowledgeId: string,
|
||||
format: string
|
||||
): AugmentationResponse<string | Record<string, unknown>> {
|
||||
if (!this.brainyData) {
|
||||
return {
|
||||
success: false,
|
||||
data: '',
|
||||
error: 'BrainyData instance not set'
|
||||
}
|
||||
}
|
||||
|
||||
// Start the async operation
|
||||
this.generateOutputAsync(knowledgeId, format);
|
||||
|
||||
// Return a placeholder response
|
||||
return {
|
||||
success: true,
|
||||
data: { status: 'processing', knowledgeId, format },
|
||||
};
|
||||
}
|
||||
|
||||
// This is the actual implementation that handles the async operations
|
||||
private async generateOutputAsync(
|
||||
knowledgeId: string,
|
||||
format: string
|
||||
): Promise<void> {
|
||||
try {
|
||||
// Get the knowledge from BrainyData
|
||||
const knowledge = await this.brainyData!.get(knowledgeId);
|
||||
let result: AugmentationResponse<string | Record<string, unknown>>;
|
||||
|
||||
if (!knowledge) {
|
||||
result = {
|
||||
success: false,
|
||||
data: '',
|
||||
error: `Knowledge not found: ${knowledgeId}`
|
||||
};
|
||||
} else {
|
||||
// Format the output
|
||||
if (format === 'text') {
|
||||
// Generate a text representation of the knowledge
|
||||
const text = this.generateTextFromKnowledge(knowledge);
|
||||
result = {
|
||||
success: true,
|
||||
data: text
|
||||
};
|
||||
} else if (format === 'json') {
|
||||
// Return the knowledge as JSON
|
||||
// Convert VectorDocument to a plain object to avoid type issues
|
||||
const knowledgeObj = { ...knowledge };
|
||||
result = {
|
||||
success: true,
|
||||
data: knowledgeObj
|
||||
};
|
||||
} else {
|
||||
result = {
|
||||
success: false,
|
||||
data: '',
|
||||
error: `Unsupported format: ${format}`
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Here you would typically emit an event or update a status property
|
||||
// with the result of the async operation
|
||||
console.log(`Generate output for ${knowledgeId} completed:`, result);
|
||||
} catch (error) {
|
||||
console.error(`Failed to generate output for ${knowledgeId}:`, error);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Interacts with an external system or API
|
||||
* @param systemId The identifier of the external system
|
||||
* @param payload The data to send to the external system
|
||||
*/
|
||||
interactExternal(
|
||||
systemId: string,
|
||||
payload: Record<string, unknown>
|
||||
): AugmentationResponse<unknown> {
|
||||
// This method would interact with external LLM training systems or APIs
|
||||
// For now, we'll just return a simulated response
|
||||
return {
|
||||
success: true,
|
||||
data: {
|
||||
systemId,
|
||||
status: 'processing',
|
||||
message: 'Interaction with external system initiated',
|
||||
timestamp: new Date().toISOString(),
|
||||
payload
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method to convert data to CSV format
|
||||
* @param data The data to convert
|
||||
* @returns CSV formatted string
|
||||
*/
|
||||
private convertToCSV(data: Record<string, unknown>): string {
|
||||
// Simplified CSV conversion - in a real implementation, this would be more robust
|
||||
let csv = ''
|
||||
|
||||
// Handle nouns
|
||||
if (data.nouns && Array.isArray(data.nouns) && data.nouns.length > 0) {
|
||||
const nouns = data.nouns as GraphNoun[]
|
||||
// Add header
|
||||
csv += 'id,noun,label,createdAt\n'
|
||||
|
||||
// Add rows
|
||||
for (const noun of nouns) {
|
||||
csv += `${noun.id},${noun.noun},${noun.label || ''},${noun.createdAt.seconds}\n`
|
||||
}
|
||||
|
||||
csv += '\n'
|
||||
}
|
||||
|
||||
// Handle verbs
|
||||
if (data.verbs && Array.isArray(data.verbs) && data.verbs.length > 0) {
|
||||
const verbs = data.verbs as GraphVerb[]
|
||||
// Add header
|
||||
csv += 'id,source,target,verb,label,createdAt\n'
|
||||
|
||||
// Add rows
|
||||
for (const verb of verbs) {
|
||||
csv += `${verb.id},${verb.source},${verb.target},${verb.verb},${verb.label || ''},${verb.createdAt.seconds}\n`
|
||||
}
|
||||
}
|
||||
|
||||
return csv
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method to generate training samples from graph data
|
||||
* @param nouns The graph nouns
|
||||
* @param verbs The graph verbs
|
||||
* @param maxSamples Maximum number of samples to generate
|
||||
* @param includeEmbeddings Whether to include embeddings in the samples
|
||||
* @returns Array of training samples
|
||||
*/
|
||||
private generateTrainingSamples(
|
||||
nouns: GraphNoun[],
|
||||
verbs: GraphVerb[],
|
||||
maxSamples: number,
|
||||
includeEmbeddings: boolean
|
||||
): any[] {
|
||||
const samples = []
|
||||
|
||||
// Create a map of noun IDs to nouns for quick lookup
|
||||
const nounMap = new Map<string, GraphNoun>()
|
||||
for (const noun of nouns) {
|
||||
nounMap.set(noun.id, noun)
|
||||
}
|
||||
|
||||
// Generate samples from verbs (relationships)
|
||||
for (const verb of verbs) {
|
||||
if (samples.length >= maxSamples) break
|
||||
|
||||
const sourceNoun = nounMap.get(verb.source)
|
||||
const targetNoun = nounMap.get(verb.target)
|
||||
|
||||
if (sourceNoun && targetNoun) {
|
||||
// Create a training sample
|
||||
const sample: Record<string, unknown> = {
|
||||
input: `What is the relationship between ${sourceNoun.label || sourceNoun.id} and ${targetNoun.label || targetNoun.id}?`,
|
||||
output: `${sourceNoun.label || sourceNoun.id} ${verb.verb} ${targetNoun.label || targetNoun.id}`
|
||||
}
|
||||
|
||||
// Add embeddings if requested
|
||||
if (includeEmbeddings) {
|
||||
sample.sourceEmbedding = sourceNoun.embedding
|
||||
sample.targetEmbedding = targetNoun.embedding
|
||||
sample.verbEmbedding = verb.embedding
|
||||
}
|
||||
|
||||
samples.push(sample)
|
||||
}
|
||||
}
|
||||
|
||||
// Generate samples from nouns (entities)
|
||||
for (const noun of nouns) {
|
||||
if (samples.length >= maxSamples) break
|
||||
|
||||
// Create a training sample
|
||||
const sample: Record<string, unknown> = {
|
||||
input: `What type of entity is ${noun.label || noun.id}?`,
|
||||
output: `${noun.label || noun.id} is a ${noun.noun}`
|
||||
}
|
||||
|
||||
// Add embeddings if requested
|
||||
if (includeEmbeddings) {
|
||||
sample.embedding = noun.embedding
|
||||
}
|
||||
|
||||
samples.push(sample)
|
||||
}
|
||||
|
||||
return samples
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method to simulate training an LLM
|
||||
* @param trainingSamples The training samples
|
||||
* @param modelType The type of model to train
|
||||
* @param epochs Number of training epochs
|
||||
* @param batchSize Batch size for training
|
||||
* @param learningRate Learning rate for training
|
||||
* @returns Simulated training result
|
||||
*/
|
||||
private simulateTraining(
|
||||
trainingSamples: any[],
|
||||
modelType: string,
|
||||
epochs: number,
|
||||
batchSize: number,
|
||||
learningRate: number
|
||||
): Record<string, unknown> {
|
||||
// In a real implementation, this would use an actual LLM training library
|
||||
// For now, we'll just simulate the training process
|
||||
return {
|
||||
modelId: `${modelType}-${new Date().getTime()}`,
|
||||
trainingSamples: trainingSamples.length,
|
||||
epochs,
|
||||
batchSize,
|
||||
learningRate,
|
||||
trainingTime: `${Math.floor(Math.random() * 100) + 50}s`,
|
||||
loss: Math.random() * 0.5,
|
||||
accuracy: 0.5 + Math.random() * 0.5,
|
||||
timestamp: new Date().toISOString()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method to generate text from knowledge
|
||||
* @param knowledge The knowledge to generate text from
|
||||
* @returns Generated text
|
||||
*/
|
||||
private generateTextFromKnowledge(knowledge: any): string {
|
||||
// In a real implementation, this would generate natural language text
|
||||
// For now, we'll just return a simple string
|
||||
if (knowledge.noun) {
|
||||
return `This is a ${knowledge.noun} called "${knowledge.label || knowledge.id}".`
|
||||
} else if (knowledge.verb) {
|
||||
return `This is a ${knowledge.verb} relationship from "${knowledge.source}" to "${knowledge.target}".`
|
||||
} else {
|
||||
return `This is an entity with ID "${knowledge.id}".`
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Factory function to create an LLM training augmentation
|
||||
* @param options Additional options
|
||||
* @returns The created augmentation
|
||||
*/
|
||||
export async function createLLMTrainingAugmentation(
|
||||
options: {
|
||||
name?: string,
|
||||
brainyData?: BrainyData
|
||||
} = {}
|
||||
): Promise<LLMTrainingActivationAugmentation> {
|
||||
// Create the activation augmentation
|
||||
const activation = new LLMTrainingActivationAugmentation(options.name)
|
||||
await activation.initialize()
|
||||
|
||||
// Set the BrainyData instance if provided
|
||||
if (options.brainyData) {
|
||||
activation.setBrainyData(options.brainyData)
|
||||
}
|
||||
|
||||
return activation
|
||||
}
|
||||
545
src/cli.ts
545
src/cli.ts
|
|
@ -15,6 +15,7 @@ import { VERSION } from './utils/version.js'
|
|||
import { sequentialPipeline } from './sequentialPipeline.js'
|
||||
import { augmentationPipeline, ExecutionMode } from './augmentationPipeline.js'
|
||||
import { AugmentationType } from './types/augmentations.js'
|
||||
import { createLLMAugmentations } from './augmentations/llmAugmentations.js'
|
||||
|
||||
// Get the directory of the current module
|
||||
const __filename = fileURLToPath(import.meta.url)
|
||||
|
|
@ -605,6 +606,20 @@ Examples:
|
|||
$ brainy generate-random-graph --noun-types Person,Thing --verb-types RelatedTo,Owns
|
||||
$ brainy visualize --type Thing --limit 10
|
||||
$ brainy visualize --root id1 --depth 3
|
||||
|
||||
# Augmentation commands
|
||||
$ brainy augment list
|
||||
$ brainy augment info cognition
|
||||
$ brainy augment test-pipeline "Test data" --data-type text --mode sequential
|
||||
$ brainy augment stream-test --count 3 --interval 500
|
||||
|
||||
# LLM commands
|
||||
$ brainy llm create --name my-model --type simple
|
||||
$ brainy llm train model-id --epochs 20 --batch-size 64
|
||||
$ brainy llm test model-id --generate-samples
|
||||
$ brainy llm export model-id --format json --include-metadata
|
||||
$ brainy llm deploy model-id --target browser
|
||||
$ brainy llm generate model-id "Once upon a time" --temperature 0.8
|
||||
`)
|
||||
|
||||
// Setup autocomplete
|
||||
|
|
@ -633,10 +648,8 @@ completion.tree({
|
|||
'completion-setup',
|
||||
'init',
|
||||
'help',
|
||||
'list-augmentations',
|
||||
'augmentation-info',
|
||||
'test-pipeline',
|
||||
'stream-test'
|
||||
'augment',
|
||||
'llm'
|
||||
],
|
||||
// Command-specific completions
|
||||
add: {
|
||||
|
|
@ -679,40 +692,116 @@ completion.tree({
|
|||
`--verb-types ${getVerbTypes().join(',')}`
|
||||
]
|
||||
},
|
||||
'list-augmentations': {},
|
||||
'augmentation-info': {
|
||||
augment: {
|
||||
_: () => [
|
||||
'sense',
|
||||
'memory',
|
||||
'cognition',
|
||||
'conduit',
|
||||
'activation',
|
||||
'perception',
|
||||
'dialog',
|
||||
'websocket'
|
||||
]
|
||||
},
|
||||
'test-pipeline': {
|
||||
_: () => [
|
||||
'--data-type text',
|
||||
'--mode sequential',
|
||||
'--mode parallel',
|
||||
'--mode threaded',
|
||||
'--stop-on-error',
|
||||
'--verbose'
|
||||
]
|
||||
},
|
||||
'stream-test': {
|
||||
_: () => [
|
||||
'--count 5',
|
||||
'--interval 1000',
|
||||
'--data-type text',
|
||||
'--verbose'
|
||||
]
|
||||
'list',
|
||||
'info',
|
||||
'test-pipeline',
|
||||
'stream-test'
|
||||
],
|
||||
info: {
|
||||
_: () => [
|
||||
'sense',
|
||||
'memory',
|
||||
'cognition',
|
||||
'conduit',
|
||||
'activation',
|
||||
'perception',
|
||||
'dialog',
|
||||
'websocket'
|
||||
]
|
||||
},
|
||||
'test-pipeline': {
|
||||
_: () => [
|
||||
'--data-type text',
|
||||
'--mode sequential',
|
||||
'--mode parallel',
|
||||
'--mode threaded',
|
||||
'--stop-on-error',
|
||||
'--verbose'
|
||||
]
|
||||
},
|
||||
'stream-test': {
|
||||
_: () => [
|
||||
'--count 5',
|
||||
'--interval 1000',
|
||||
'--data-type text',
|
||||
'--verbose'
|
||||
]
|
||||
}
|
||||
},
|
||||
'completion-setup': {},
|
||||
init: {},
|
||||
help: {}
|
||||
help: {},
|
||||
llm: {
|
||||
_: () => [
|
||||
'create',
|
||||
'train',
|
||||
'test',
|
||||
'export',
|
||||
'deploy',
|
||||
'generate'
|
||||
],
|
||||
create: {
|
||||
_: () => [
|
||||
'--name my-model',
|
||||
'--description "My custom LLM model"',
|
||||
'--type simple',
|
||||
'--type transformer',
|
||||
'--vocab-size 5000',
|
||||
'--embedding-dim 64',
|
||||
'--hidden-dim 128',
|
||||
'--layers 2',
|
||||
'--heads 4',
|
||||
'--dropout 0.1',
|
||||
'--max-seq-length 100'
|
||||
]
|
||||
},
|
||||
train: {
|
||||
_: () => [
|
||||
'--max-samples 1000',
|
||||
'--validation-split 0.2',
|
||||
'--epochs 10',
|
||||
'--batch-size 32',
|
||||
'--patience 3'
|
||||
]
|
||||
},
|
||||
test: {
|
||||
_: () => [
|
||||
'--test-size 100',
|
||||
'--generate-samples',
|
||||
'--sample-count 5'
|
||||
]
|
||||
},
|
||||
export: {
|
||||
_: () => [
|
||||
'--format json',
|
||||
'--format tfjs',
|
||||
'--output ./models',
|
||||
'--include-metadata',
|
||||
'--include-vocab'
|
||||
]
|
||||
},
|
||||
deploy: {
|
||||
_: () => [
|
||||
'--target browser',
|
||||
'--target node',
|
||||
'--target cloud',
|
||||
'--provider aws',
|
||||
'--provider gcp',
|
||||
'--provider azure',
|
||||
'--endpoint https://example.com/api',
|
||||
'--region us-east-1'
|
||||
]
|
||||
},
|
||||
generate: {
|
||||
_: () => [
|
||||
'--temperature 0.7',
|
||||
'--top-k 5',
|
||||
'--max-length 100'
|
||||
]
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
// Initialize autocomplete
|
||||
|
|
@ -726,8 +815,11 @@ if (process.argv.includes('--completion-setup')) {
|
|||
}
|
||||
|
||||
// Pipeline and Augmentation Commands
|
||||
program
|
||||
.command('list-augmentations')
|
||||
const augmentCommand = new Command('augment')
|
||||
.description('Augmentation pipeline operations')
|
||||
|
||||
augmentCommand
|
||||
.command('list')
|
||||
.description('List all available augmentation types and registered augmentations')
|
||||
.action(async () => {
|
||||
try {
|
||||
|
|
@ -773,7 +865,7 @@ program
|
|||
}
|
||||
})
|
||||
|
||||
program
|
||||
augmentCommand
|
||||
.command('test-pipeline')
|
||||
.description('Test the sequential pipeline with sample data')
|
||||
.argument('[text]', 'Sample text to process through the pipeline', 'This is a test of the Brainy pipeline')
|
||||
|
|
@ -855,7 +947,7 @@ program
|
|||
}
|
||||
})
|
||||
|
||||
program
|
||||
augmentCommand
|
||||
.command('stream-test')
|
||||
.description('Test streaming data through the pipeline (simulated)')
|
||||
.option('-c, --count <number>', 'Number of data items to stream', '5')
|
||||
|
|
@ -949,8 +1041,8 @@ program
|
|||
}
|
||||
})
|
||||
|
||||
program
|
||||
.command('augmentation-info')
|
||||
augmentCommand
|
||||
.command('info')
|
||||
.description('Get detailed information about a specific augmentation type')
|
||||
.argument('<type>', 'Augmentation type (sense, memory, cognition, conduit, activation, perception, dialog, websocket)')
|
||||
.action(async (typeArg) => {
|
||||
|
|
@ -1045,6 +1137,9 @@ program
|
|||
}
|
||||
})
|
||||
|
||||
// Add the augment command to the program
|
||||
program.addCommand(augmentCommand)
|
||||
|
||||
// Add a command for setting up autocomplete
|
||||
program
|
||||
.command('completion-setup')
|
||||
|
|
@ -1055,4 +1150,374 @@ program
|
|||
})
|
||||
|
||||
// Parse command line arguments
|
||||
// LLM Commands
|
||||
const llmCommand = new Command('llm')
|
||||
.description('LLM (Language Learning Model) operations')
|
||||
|
||||
llmCommand
|
||||
.command('create')
|
||||
.description('Create a new LLM model from Brainy data')
|
||||
.option('-n, --name <name>', 'Name of the model')
|
||||
.option('-d, --description <description>', 'Description of the model')
|
||||
.option('-t, --type <type>', 'Type of model (simple, transformer, custom)', 'simple')
|
||||
.option('-v, --vocab-size <size>', 'Vocabulary size', '5000')
|
||||
.option('-e, --embedding-dim <dim>', 'Embedding dimension', '64')
|
||||
.option('-h, --hidden-dim <dim>', 'Hidden dimension', '128')
|
||||
.option('-l, --layers <count>', 'Number of layers', '2')
|
||||
.option('--heads <count>', 'Number of attention heads (for transformer models)', '4')
|
||||
.option('--dropout <rate>', 'Dropout rate', '0.1')
|
||||
.option('--max-seq-length <length>', 'Maximum sequence length', '100')
|
||||
.action(async (options) => {
|
||||
try {
|
||||
const db = createDb()
|
||||
await db.init()
|
||||
|
||||
console.log('Creating LLM model...')
|
||||
|
||||
// Initialize LLM augmentations
|
||||
const { cognition, activation } = await createLLMAugmentations()
|
||||
|
||||
// Set the database for the cognition augmentation
|
||||
cognition.setBrainyDb(db)
|
||||
|
||||
// Parse options
|
||||
const config = {
|
||||
name: options.name || 'model-' + Date.now(),
|
||||
description: options.description || 'Created via CLI',
|
||||
modelType: options.type,
|
||||
vocabSize: parseInt(options.vocabSize, 10),
|
||||
embeddingDim: parseInt(options.embeddingDim, 10),
|
||||
hiddenDim: parseInt(options.hiddenDim, 10),
|
||||
layers: parseInt(options.layers, 10),
|
||||
heads: parseInt(options.heads, 10),
|
||||
dropout: parseFloat(options.dropout),
|
||||
maxSeqLength: parseInt(options.maxSeqLength, 10)
|
||||
}
|
||||
|
||||
// Create the model
|
||||
const result = await cognition.createModel(config)
|
||||
|
||||
if (result.success) {
|
||||
console.log(`Model created successfully with ID: ${result.data.modelId}`)
|
||||
console.log(`Model type: ${config.modelType}`)
|
||||
console.log(`Vocabulary size: ${config.vocabSize}`)
|
||||
} else {
|
||||
console.error(`Failed to create model: ${result.error}`)
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error('Error:', (error as Error).message)
|
||||
process.exit(1)
|
||||
}
|
||||
})
|
||||
|
||||
llmCommand
|
||||
.command('train')
|
||||
.description('Train an LLM model on Brainy data')
|
||||
.argument('<modelId>', 'ID of the model to train')
|
||||
.option('-s, --max-samples <count>', 'Maximum number of training samples')
|
||||
.option('-v, --validation-split <ratio>', 'Validation split ratio', '0.2')
|
||||
.option('-e, --epochs <count>', 'Number of training epochs', '10')
|
||||
.option('-b, --batch-size <size>', 'Batch size', '32')
|
||||
.option('-p, --patience <count>', 'Early stopping patience', '3')
|
||||
.action(async (modelId, options) => {
|
||||
try {
|
||||
const db = createDb()
|
||||
await db.init()
|
||||
|
||||
console.log(`Training LLM model ${modelId}...`)
|
||||
|
||||
// Initialize LLM augmentations
|
||||
const { cognition, activation } = await createLLMAugmentations()
|
||||
|
||||
// Set the database for the cognition augmentation
|
||||
cognition.setBrainyDb(db)
|
||||
|
||||
// Parse options
|
||||
const trainingOptions = {
|
||||
maxSamples: options.maxSamples ? parseInt(options.maxSamples, 10) : undefined,
|
||||
validationSplit: parseFloat(options.validationSplit),
|
||||
epochs: parseInt(options.epochs, 10),
|
||||
batchSize: parseInt(options.batchSize, 10),
|
||||
patience: parseInt(options.patience, 10)
|
||||
}
|
||||
|
||||
console.log('Training with options:')
|
||||
console.log(` Max samples: ${trainingOptions.maxSamples || 'All available'}`)
|
||||
console.log(` Validation split: ${trainingOptions.validationSplit}`)
|
||||
console.log(` Epochs: ${trainingOptions.epochs}`)
|
||||
console.log(` Batch size: ${trainingOptions.batchSize}`)
|
||||
console.log(` Early stopping patience: ${trainingOptions.patience}`)
|
||||
|
||||
// Train the model
|
||||
const result = await cognition.trainModel(modelId, trainingOptions)
|
||||
|
||||
if (result.success) {
|
||||
console.log(`\nModel ${modelId} trained successfully!`)
|
||||
console.log(`Training metrics:`)
|
||||
if (result.data.metrics) {
|
||||
console.log(` Final loss: ${result.data.metrics.loss.toFixed(4)}`)
|
||||
console.log(` Final accuracy: ${result.data.metrics.accuracy.toFixed(4)}`)
|
||||
console.log(` Epochs completed: ${result.data.metrics.epochs}`)
|
||||
}
|
||||
} else {
|
||||
console.error(`\nFailed to train model: ${result.error}`)
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error('Error:', (error as Error).message)
|
||||
process.exit(1)
|
||||
}
|
||||
})
|
||||
|
||||
llmCommand
|
||||
.command('test')
|
||||
.description('Test an LLM model on Brainy data')
|
||||
.argument('<modelId>', 'ID of the model to test')
|
||||
.option('-s, --test-size <count>', 'Number of test samples', '100')
|
||||
.option('-g, --generate-samples', 'Generate sample predictions')
|
||||
.option('-c, --sample-count <count>', 'Number of samples to generate', '5')
|
||||
.action(async (modelId, options) => {
|
||||
try {
|
||||
const db = createDb()
|
||||
await db.init()
|
||||
|
||||
console.log(`Testing LLM model ${modelId}...`)
|
||||
|
||||
// Initialize LLM augmentations
|
||||
const { cognition, activation } = await createLLMAugmentations()
|
||||
|
||||
// Set the database for the cognition augmentation
|
||||
cognition.setBrainyDb(db)
|
||||
|
||||
// Parse options
|
||||
const testingOptions = {
|
||||
testSize: parseInt(options.testSize, 10),
|
||||
generateSamples: options.generateSamples,
|
||||
sampleCount: parseInt(options.sampleCount, 10)
|
||||
}
|
||||
|
||||
console.log('Testing with options:')
|
||||
console.log(` Test size: ${testingOptions.testSize}`)
|
||||
console.log(` Generate samples: ${testingOptions.generateSamples ? 'Yes' : 'No'}`)
|
||||
if (testingOptions.generateSamples) {
|
||||
console.log(` Sample count: ${testingOptions.sampleCount}`)
|
||||
}
|
||||
|
||||
// Test the model
|
||||
const result = await cognition.testModel(modelId, testingOptions)
|
||||
|
||||
if (result.success) {
|
||||
console.log(`\nModel ${modelId} tested successfully!`)
|
||||
console.log(`Test metrics:`)
|
||||
if (result.data.metrics) {
|
||||
console.log(` Test loss: ${result.data.metrics.loss.toFixed(4)}`)
|
||||
console.log(` Test accuracy: ${result.data.metrics.accuracy.toFixed(4)}`)
|
||||
console.log(` Test samples: ${result.data.metrics.samples}`)
|
||||
}
|
||||
|
||||
// Display generated samples if available
|
||||
if (result.data.samples && result.data.samples.length > 0) {
|
||||
console.log(`\nGenerated samples:`)
|
||||
result.data.samples.forEach((sample: { input: string; expected: string; generated: string }, index: number) => {
|
||||
console.log(`\nSample ${index + 1}:`)
|
||||
console.log(` Input: ${sample.input}`)
|
||||
console.log(` Predicted: ${sample.generated}`)
|
||||
if (sample.expected) {
|
||||
console.log(` Actual: ${sample.expected}`)
|
||||
}
|
||||
})
|
||||
}
|
||||
} else {
|
||||
console.error(`\nFailed to test model: ${result.error}`)
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error('Error:', (error as Error).message)
|
||||
process.exit(1)
|
||||
}
|
||||
})
|
||||
|
||||
llmCommand
|
||||
.command('export')
|
||||
.description('Export an LLM model for deployment')
|
||||
.argument('<modelId>', 'ID of the model to export')
|
||||
.option('-f, --format <format>', 'Export format (tfjs, json)', 'json')
|
||||
.option('-o, --output <path>', 'Output path')
|
||||
.option('-m, --include-metadata', 'Include metadata')
|
||||
.option('-v, --include-vocab', 'Include vocabulary')
|
||||
.action(async (modelId, options) => {
|
||||
try {
|
||||
const db = createDb()
|
||||
await db.init()
|
||||
|
||||
console.log(`Exporting LLM model ${modelId}...`)
|
||||
|
||||
// Initialize LLM augmentations
|
||||
const { cognition, activation } = await createLLMAugmentations()
|
||||
|
||||
// Set the database for the cognition augmentation
|
||||
cognition.setBrainyDb(db)
|
||||
|
||||
// Parse options
|
||||
const exportOptions = {
|
||||
format: options.format,
|
||||
outputPath: options.output,
|
||||
includeMetadata: options.includeMetadata,
|
||||
includeVocab: options.includeVocab
|
||||
}
|
||||
|
||||
console.log('Exporting with options:')
|
||||
console.log(` Format: ${exportOptions.format}`)
|
||||
if (exportOptions.outputPath) {
|
||||
console.log(` Output path: ${exportOptions.outputPath}`)
|
||||
}
|
||||
console.log(` Include metadata: ${exportOptions.includeMetadata ? 'Yes' : 'No'}`)
|
||||
console.log(` Include vocabulary: ${exportOptions.includeVocab ? 'Yes' : 'No'}`)
|
||||
|
||||
// Export the model
|
||||
const result = await cognition.exportModel(modelId, exportOptions)
|
||||
|
||||
if (result.success) {
|
||||
console.log(`\nModel ${modelId} exported successfully!`)
|
||||
if (result.data.path) {
|
||||
console.log(`Exported to: ${result.data.path}`)
|
||||
}
|
||||
if (result.data.size) {
|
||||
console.log(`Export size: ${(result.data.size / 1024).toFixed(2)} KB`)
|
||||
}
|
||||
} else {
|
||||
console.error(`\nFailed to export model: ${result.error}`)
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error('Error:', (error as Error).message)
|
||||
process.exit(1)
|
||||
}
|
||||
})
|
||||
|
||||
llmCommand
|
||||
.command('deploy')
|
||||
.description('Deploy an LLM model to the specified target')
|
||||
.argument('<modelId>', 'ID of the model to deploy')
|
||||
.option('-t, --target <target>', 'Deployment target (browser, node, cloud)', 'browser')
|
||||
.option('-p, --provider <provider>', 'Cloud provider (aws, gcp, azure)')
|
||||
.option('-e, --endpoint <url>', 'Endpoint URL for cloud deployment')
|
||||
.option('-r, --region <region>', 'Region for cloud deployment')
|
||||
.action(async (modelId, options) => {
|
||||
try {
|
||||
const db = createDb()
|
||||
await db.init()
|
||||
|
||||
console.log(`Deploying LLM model ${modelId} to ${options.target}...`)
|
||||
|
||||
// Initialize LLM augmentations
|
||||
const { cognition, activation } = await createLLMAugmentations()
|
||||
|
||||
// Set the database for the cognition augmentation
|
||||
cognition.setBrainyDb(db)
|
||||
|
||||
// Parse options
|
||||
const deploymentOptions = {
|
||||
target: options.target,
|
||||
provider: options.provider,
|
||||
endpoint: options.endpoint,
|
||||
region: options.region
|
||||
}
|
||||
|
||||
console.log('Deploying with options:')
|
||||
console.log(` Target: ${deploymentOptions.target}`)
|
||||
if (deploymentOptions.provider) {
|
||||
console.log(` Provider: ${deploymentOptions.provider}`)
|
||||
}
|
||||
if (deploymentOptions.endpoint) {
|
||||
console.log(` Endpoint: ${deploymentOptions.endpoint}`)
|
||||
}
|
||||
if (deploymentOptions.region) {
|
||||
console.log(` Region: ${deploymentOptions.region}`)
|
||||
}
|
||||
|
||||
// Deploy the model
|
||||
const result = await cognition.deployModel(modelId, deploymentOptions)
|
||||
|
||||
if (result.success) {
|
||||
console.log(`\nModel ${modelId} deployed successfully!`)
|
||||
if (result.data.url) {
|
||||
console.log(`Deployment URL: ${result.data.url}`)
|
||||
}
|
||||
if (result.data.deploymentId) {
|
||||
console.log(`Deployment ID: ${result.data.deploymentId}`)
|
||||
}
|
||||
} else {
|
||||
console.error(`\nFailed to deploy model: ${result.error}`)
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error('Error:', (error as Error).message)
|
||||
process.exit(1)
|
||||
}
|
||||
})
|
||||
|
||||
llmCommand
|
||||
.command('generate')
|
||||
.description('Generate text using an LLM model')
|
||||
.argument('<modelId>', 'ID of the model to use')
|
||||
.argument('<prompt>', 'Input prompt for text generation')
|
||||
.option('-t, --temperature <temp>', 'Temperature for sampling', '0.7')
|
||||
.option('-k, --top-k <count>', 'Number of top tokens to consider', '5')
|
||||
.option('-l, --max-length <length>', 'Maximum length of generated text', '100')
|
||||
.action(async (modelId, prompt, options) => {
|
||||
try {
|
||||
const db = createDb()
|
||||
await db.init()
|
||||
|
||||
console.log(`Generating text using LLM model ${modelId}...`)
|
||||
console.log(`Prompt: "${prompt}"`)
|
||||
|
||||
// Initialize LLM augmentations
|
||||
const { cognition, activation } = await createLLMAugmentations()
|
||||
|
||||
// Set the database for the cognition augmentation
|
||||
cognition.setBrainyDb(db)
|
||||
|
||||
// Parse options
|
||||
const generateOptions = {
|
||||
temperature: parseFloat(options.temperature),
|
||||
topK: parseInt(options.topK, 10),
|
||||
maxLength: parseInt(options.maxLength, 10)
|
||||
}
|
||||
|
||||
console.log('Generation options:')
|
||||
console.log(` Temperature: ${generateOptions.temperature}`)
|
||||
console.log(` Top-K: ${generateOptions.topK}`)
|
||||
console.log(` Max length: ${generateOptions.maxLength}`)
|
||||
|
||||
// Generate text
|
||||
const result = await cognition.generateText(modelId, prompt, generateOptions)
|
||||
|
||||
if (result.success) {
|
||||
console.log(`\nGenerated text:`)
|
||||
console.log(`--------------`)
|
||||
console.log(result.data.text)
|
||||
console.log(`--------------`)
|
||||
|
||||
if (result.data.tokens) {
|
||||
console.log(`\nTokens generated: ${result.data.tokens}`)
|
||||
}
|
||||
if (result.data.timeMs) {
|
||||
console.log(`Generation time: ${result.data.timeMs}ms`)
|
||||
}
|
||||
} else {
|
||||
console.error(`\nFailed to generate text: ${result.error}`)
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error('Error:', (error as Error).message)
|
||||
process.exit(1)
|
||||
}
|
||||
})
|
||||
|
||||
// Add the LLM command to the program
|
||||
program.addCommand(llmCommand)
|
||||
|
||||
program.parse()
|
||||
|
|
|
|||
10
src/index.ts
10
src/index.ts
|
|
@ -141,6 +141,11 @@ import {
|
|||
ServerSearchActivationAugmentation,
|
||||
createServerSearchAugmentations
|
||||
} from './augmentations/serverSearchAugmentations.js'
|
||||
import {
|
||||
LLMCognitionAugmentation,
|
||||
LLMActivationAugmentation,
|
||||
createLLMAugmentations
|
||||
} from './augmentations/llmAugmentations.js'
|
||||
|
||||
export {
|
||||
MemoryStorageAugmentation,
|
||||
|
|
@ -152,7 +157,10 @@ export {
|
|||
createConduitAugmentation,
|
||||
ServerSearchConduitAugmentation,
|
||||
ServerSearchActivationAugmentation,
|
||||
createServerSearchAugmentations
|
||||
createServerSearchAugmentations,
|
||||
LLMCognitionAugmentation,
|
||||
LLMActivationAugmentation,
|
||||
createLLMAugmentations
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -3,4 +3,4 @@
|
|||
* Do not modify this file directly.
|
||||
*/
|
||||
|
||||
export const VERSION = '0.7.6';
|
||||
export const VERSION = '0.7.7';
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue