weave-typescript 0.8.0 → 0.10.0

package/dist/weaveapi/llmx/v1/architecture.pb.d.ts

@@ -258,97 +258,385 @@ export declare enum LicenseType {
 }
 export declare function licenseTypeFromJSON(object: any): LicenseType;
 export declare function licenseTypeToJSON(object: LicenseType): string;
-/** Architecture describes model architecture details */
+/** Architecture describes the technical architecture of an AI model. */
 export interface Architecture {
+    /**
+     * Fundamental architecture type (Transformer, Mamba, etc.).
+     * Example: BASE_ARCHITECTURE_TRANSFORMER for GPT models
+     */
     baseArchitecture: BaseArchitecture;
+    /**
+     * Specific model family/variant.
+     * Example: MODEL_ARCHITECTURE_GPT for GPT-4, MODEL_ARCHITECTURE_LLAMA for LLaMA
+     */
     modelArchitecture: ModelArchitecture;
+    /**
+     * Total learnable parameters in billions.
+     * Example: 175 for GPT-3 (175B parameters)
+     */
     parameterCount: number;
+    /**
+     * Parameters activated per forward pass (for MoE models).
+     * Example: 8B active out of 141B total for Mixtral-8x7B
+     */
     activeParameters: number;
+    /**
+     * Total parameters including non-trainable (embeddings, etc.).
+     * May be slightly higher than parameter_count
+     */
     totalParameters: number;
+    /**
+     * Number of transformer/attention layers.
+     * Example: 96 for GPT-3, 32 for 7B models
+     */
     layerCount: number;
+    /**
+     * Hidden dimension size of the model.
+     * Example: 12288 for GPT-3, 4096 for smaller models
+     */
     hiddenSize: number;
+    /**
+     * Number of attention heads in multi-head attention.
+     * Example: 96 for GPT-3, 32 for 7B models
+     */
     attentionHeads: number;
+    /**
+     * Size of the token vocabulary.
+     * Example: 50257 for GPT-2/3, 32000 for LLaMA
+     */
     vocabularySize: number;
+    /**
+     * Type of position encoding used.
+     * Example: POSITION_EMBEDDING_ROTARY for modern models (RoPE)
+     */
     positionEmbedding: PositionEmbedding;
+    /**
+     * Activation function in feed-forward layers.
+     * Example: ACTIVATION_FUNCTION_SWIGLU for LLaMA models
+     */
     activationFunction: ActivationFunction;
+    /**
+     * Whether this is a Mixture of Experts model.
+     * Example: true for Mixtral, GPT-4 (rumored), false for dense models
+     */
     isMixtureOfExperts: boolean;
+    /**
+     * Total number of expert networks (for MoE).
+     * Example: 8 for Mixtral-8x7B
+     */
     expertCount: number;
+    /**
+     * Number of experts activated per token (for MoE).
+     * Example: 2 for Mixtral (2 experts per token out of 8)
+     */
     expertsPerToken: number;
 }
-/** Training contains training information */
+/** Training contains information about how the model was trained. */
 export interface Training {
-    /** "1T tokens" */
+    /**
+     * Size of training dataset.
+     * Examples: "1T tokens", "45TB text", "100B tokens"
+     */
     trainingDataSize: string;
+    /**
+     * List of data sources used for training.
+     * Examples: ["Common Crawl", "Wikipedia", "Books", "GitHub", "ArXiv"]
+     */
     trainingDataSources: string[];
+    /**
+     * Description of data mixture/proportions.
+     * Example: "60% web, 20% books, 10% code, 10% reference"
+     */
     dataMixture: string;
-    /** "3 months" */
+    /**
+     * Total training time.
+     * Examples: "3 months", "6 weeks", "90 days"
+     */
     trainingDuration: string;
-    /** "10000 H100 GPUs" */
+    /**
+     * Hardware used for training.
+     * Examples: "10000 H100 GPUs", "512 A100 80GB", "TPU v4 pods"
+     */
     trainingHardware: string;
-    /** "$100M" */
+    /**
+     * Estimated training cost.
+     * Examples: "$100M", "$4.6M", "Not disclosed"
+     */
     trainingCost: string;
+    /**
+     * Primary training technique used.
+     * Example: TRAINING_TECHNIQUE_REINFORCEMENT_LEARNING_FROM_HUMAN_FEEDBACK
+     */
     trainingTechnique: TrainingTechnique;
+    /**
+     * Training batch size per step.
+     * Example: 2048, 4096
+     */
     batchSize: number;
+    /**
+     * Peak learning rate used.
+     * Example: 0.0001, 3e-4
+     */
     learningRate: number;
+    /**
+     * Total number of training steps/iterations.
+     * Example: 1000000
+     */
     trainingSteps: number;
+    /**
+     * Number of warmup steps for learning rate schedule.
+     * Example: 2000
+     */
     warmupSteps: number;
+    /**
+     * Whether model supports fine-tuning via API.
+     * Example: true for GPT-3.5, false for GPT-4
+     */
     fineTuningAvailable: boolean;
+    /**
+     * Minimum training examples required for fine-tuning.
+     * Example: 10 for OpenAI models
+     */
     minFineTuneExamples: number;
+    /**
+     * Maximum training examples allowed for fine-tuning.
+     * Example: 100000 for GPT-3.5
+     */
     maxFineTuneExamples: number;
+    /**
+     * Supported data formats for fine-tuning.
+     * Example: [DATA_FORMAT_JSONL, DATA_FORMAT_CSV]
+     */
     fineTuneFormats: DataFormat[];
 }
-/** TechnicalSpecs contains detailed technical specifications */
+/** TechnicalSpecs contains hardware and software requirements for running the model. */
 export interface TechnicalSpecs {
+    /**
+     * Minimum system RAM required in GB.
+     * Example: 32 for 7B models, 64 for 13B models
+     */
     minMemoryGb: number;
+    /**
+     * Recommended system RAM for optimal performance in GB.
+     * Example: 64 for 7B models, 128 for 13B models
+     */
     recommendedMemoryGb: number;
+    /**
+     * Minimum GPU VRAM required in GB.
+     * Example: 24 for 7B fp16, 48 for 13B fp16
+     */
     minGpuMemoryGb: number;
+    /**
+     * Disk storage required for model files in GB.
+     * Example: 15 for 7B models, 30 for 13B models
+     */
     storageGb: number;
+    /**
+     * Quantization method if applicable.
+     * Example: QUANTIZATION_INT8 for 8-bit quantized models
+     */
     quantization: Quantization;
+    /**
+     * Numerical precision used.
+     * Example: PRECISION_FP16 for half-precision inference
+     */
     precision: Precision;
+    /**
+     * Optimization level/profile.
+     * Examples: "O3", "fast", "balanced", "memory-optimized"
+     */
     optimizationLevel: string;
+    /**
+     * List of compatible GPU types.
+     * Example: [GPU_TYPE_A100, GPU_TYPE_H100, GPU_TYPE_RTX_4090]
+     */
     supportedGpus: GPUType[];
+    /**
+     * Whether CUDA is required for GPU inference.
+     * Example: true for NVIDIA GPUs, false for CPU-only
+     */
     requiresCuda: boolean;
+    /**
+     * Minimum CUDA version required.
+     * Examples: "11.8", "12.0"
+     */
     cudaVersion: string;
+    /**
+     * Recommended inference framework.
+     * Example: INFERENCE_FRAMEWORK_VLLM for high-throughput serving
+     */
     inferenceFramework: InferenceFramework;
+    /**
+     * Format of distributed model files.
+     * Example: MODEL_FORMAT_SAFETENSORS for HuggingFace models
+     */
     modelFormat: ModelFormat;
+    /**
+     * Total size of model files in GB.
+     * Example: 13.5 for 7B model in fp16
+     */
     modelSizeGb: number;
+    /**
+     * Format of model checkpoint files.
+     * Example: CHECKPOINT_FORMAT_PYTORCH for .pt files
+     */
     checkpointFormat: CheckpointFormat;
+    /**
+     * Number of model shard files.
+     * Example: 2 for models split across multiple files
+     */
     numberOfFiles: number;
+    /**
+     * List of compatible CPU architectures.
+     * Example: [CPU_TYPE_X86_64, CPU_TYPE_ARM64]
+     */
     supportedCpus: CPUType[];
+    /**
+     * Serving framework/stack.
+     * Examples: "TGI", "vLLM", "llama.cpp"
+     */
     servingFramework: string;
+    /**
+     * Pre-built container image if available.
+     * Example: "nvcr.io/nvidia/pytorch:23.10-py3"
+     */
     containerImage: string;
-    /** Minimum requirements for reasonable performance */
+    /**
+     * Minimum GPU for reasonable performance.
+     * Example: GPU_TYPE_RTX_3090 for 7B models
+     */
     minimumGpu: GPUType;
+    /**
+     * Minimum GPU memory for basic inference in GB.
+     * Example: 16 for 7B int8 models
+     */
     minimumGpuMemoryGb: number;
+    /**
+     * Whether model can run on CPU (even if slowly).
+     * Example: true for smaller quantized models
+     */
     cpuCompatible: boolean;
+    /**
+     * Recommended GPU memory for good performance in GB.
+     * Example: 24 for 7B fp16 with reasonable batch size
+     */
     recommendedGpuMemoryGb: number;
 }
-/** Safety contains safety and moderation features */
+/** Safety contains safety, moderation, and compliance features. */
 export interface Safety {
+    /**
+     * Built-in content moderation strictness.
+     * Example: MODERATION_LEVEL_HIGH for family-friendly models
+     */
     moderationLevel: ModerationLevel;
+    /**
+     * Whether automatic content filtering is enabled.
+     * Example: true for models that block harmful content
+     */
     contentFiltering: boolean;
+    /**
+     * List of active safety filters.
+     * Examples: ["violence", "sexual", "hate", "self-harm", "illegal"]
+     */
     safetyFilters: string[];
+    /**
+     * Bias assessment rating.
+     * Examples: "Low", "Medium", "High", "Evaluated"
+     */
     biasRating: string;
+    /**
+     * Toxicity score from evaluations (0-1).
+     * Example: 0.02 for well-aligned models (lower is better)
+     */
     toxicityScore: number;
+    /**
+     * GDPR (General Data Protection Regulation) compliance.
+     * Example: true for models that don't retain user data
+     */
     gdprCompliant: boolean;
+    /**
+     * HIPAA (Health Insurance Portability and Accountability Act) compliance.
+     * Example: true for medical-safe models
+     */
     hipaaCompliant: boolean;
+    /**
+     * SOC 2 (Service Organization Control 2) compliance.
+     * Example: true for enterprise-grade security
+     */
     soc2Compliant: boolean;
+    /**
+     * ISO certification status.
+     * Example: true for ISO 27001 certified services
+     */
     isoCertified: boolean;
+    /**
+     * Can refuse harmful or inappropriate requests.
+     * Example: true for models trained to decline harmful tasks
+     */
     refusalCapability: boolean;
+    /**
+     * Whether outputs include watermarking.
+     * Example: true for models with detectible AI signatures
+     */
     watermarkOutput: boolean;
+    /**
+     * Built-in safety guardrails.
+     * Examples: ["constitutional-ai", "harmlessness", "helpfulness"]
+     */
     builtInGuardrails: string[];
+    /**
+     * Supports custom safety guardrails.
+     * Example: true if users can add their own safety rules
+     */
     customGuardrails: boolean;
 }
-/** Licensing contains license and usage terms */
+/** Licensing contains license and usage terms for the model. */
 export interface Licensing {
+    /**
+     * Type of license governing model use.
+     * Example: LICENSE_TYPE_APACHE_2_0, LICENSE_TYPE_PROPRIETARY
+     */
     licenseType: LicenseType;
+    /**
+     * URL to full license text.
+     * Example: "https://github.com/meta-llama/llama/blob/main/LICENSE"
+     */
     licenseUrl: string;
+    /**
+     * Whether source code is openly available.
+     * Example: true for research papers with code
+     */
     isOpenSource: boolean;
+    /**
+     * Whether model weights are publicly downloadable.
+     * Example: true for LLaMA, Mistral; false for GPT-4
+     */
     isOpenWeights: boolean;
+    /**
+     * Allowed for commercial/business use.
+     * Example: true for Apache/MIT licensed models
+     */
     commercialUse: boolean;
+    /**
+     * Allowed for research purposes.
+     * Example: true for most models, even proprietary ones
+     */
     researchUse: boolean;
+    /**
+     * Must attribute/cite when using.
+     * Example: true for CC-BY licenses
+     */
     attributionRequired: boolean;
+    /**
+     * Derivatives must use same license.
+     * Example: true for GPL, CC-BY-SA licenses
+     */
     shareAlikeRequired: boolean;
+    /**
+     * Specific usage restrictions or conditions.
+     * Examples: ["No use for surveillance", "Monthly active user limits",
+     *           "No competitive use against provider"]
+     */
     usageRestrictions: string[];
 }
 export declare const Architecture: MessageFns<Architecture>;