ml

type AdaptiveThresholds struct {
	// contains filtered or unexported fields
}

type Alert struct {
	ID           string     `json:"id"`
	Timestamp    time.Time  `json:"timestamp"`
	VMId         string     `json:"vm_id"`
	Severity     string     `json:"severity"`
	Type         string     `json:"type"`
	Message      string     `json:"message"`
	Score        float64    `json:"score"`
	Acknowledged bool       `json:"acknowledged"`
	ResolvedAt   *time.Time `json:"resolved_at,omitempty"`
	Actions      []string   `json:"actions"`
}

type AlertManager struct {
	// contains filtered or unexported fields
}

type AlertSubscriber interface {
	OnAlert(alert Alert)
}

type AnomalyConfig struct {
	NumTrees          int           `json:"num_trees"`          // Number of trees in forest
	SampleSize        int           `json:"sample_size"`        // Subsample size
	ContaminationRate float64       `json:"contamination_rate"` // Expected anomaly rate
	AlertThreshold    float64       `json:"alert_threshold"`    // Score threshold for alerts
	LearningRate      float64       `json:"learning_rate"`      // Threshold adaptation rate
	WindowSize        time.Duration `json:"window_size"`        // Detection window
	UpdateInterval    time.Duration `json:"update_interval"`    // Model update frequency
	EnableAutoLearn   bool          `json:"enable_auto_learn"`  // Auto-adjust thresholds
	EnableClustering  bool          `json:"enable_clustering"`  // Group similar anomalies
}

type AnomalyDetector struct {
	// contains filtered or unexported fields
}

type AnomalyScore struct {
	Timestamp      time.Time              `json:"timestamp"`
	VMId           string                 `json:"vm_id"`
	Score          float64                `json:"score"` // 0-1, higher = more anomalous
	IsAnomaly      bool                   `json:"is_anomaly"`
	Severity       string                 `json:"severity"`     // low, medium, high, critical
	AnomalyType    string                 `json:"anomaly_type"` // cpu_spike, memory_leak, etc.
	Features       map[string]float64     `json:"features"`
	Deviations     map[string]float64     `json:"deviations"` // Feature deviations from normal
	ContextualInfo map[string]interface{} `json:"contextual_info"`
	Confidence     float64                `json:"confidence"`
	FalsePositive  bool                   `json:"false_positive"` // Marked by operator feedback
}

type Bottleneck struct {
	Type        string    `json:"type"`        // cpu, memory, io, network
	Severity    string    `json:"severity"`    // low, medium, high, critical
	Impact      float64   `json:"impact"`      // Performance impact percentage
	TimeWindow  time.Time `json:"time_window"` // When bottleneck occurs
	Description string    `json:"description"`
}

type CapacityChange struct {
	Type          string    `json:"type"`      // add_node, upgrade_cpu, add_memory
	Magnitude     float64   `json:"magnitude"` // Amount of change
	Timing        time.Time `json:"timing"`    // When to implement
	Priority      string    `json:"priority"`
	Justification string    `json:"justification"`
}

type CapacityConstraint struct {
	Type        string  `json:"type"` // budget, hardware, policy
	Limit       float64 `json:"limit"`
	Flexible    bool    `json:"flexible"`
	Description string  `json:"description"`
}

type CapacityPlan struct {
	ID              string           `json:"id"`
	CreatedAt       time.Time        `json:"created_at"`
	TimeHorizon     time.Duration    `json:"time_horizon"`
	RequiredChanges []CapacityChange `json:"required_changes"`
	EstimatedCost   float64          `json:"estimated_cost"`
	RiskLevel       string           `json:"risk_level"`
	Benefits        []string         `json:"benefits"`
}

type CapacityPlanner struct {
	// contains filtered or unexported fields
}

type CollectorConfig struct {
	InfluxURL       string        `json:"influx_url"`
	InfluxToken     string        `json:"influx_token"`
	InfluxOrg       string        `json:"influx_org"`
	InfluxBucket    string        `json:"influx_bucket"`
	CollectionRate  time.Duration `json:"collection_rate"`
	BufferSize      int           `json:"buffer_size"`
	WindowSize      int           `json:"window_size"`
	StepSize        int           `json:"step_size"`
	AggregationFunc string        `json:"aggregation_func"`
	FeatureConfig   FeatureConfig `json:"feature_config"`
}

type CompressedGradient struct {
	// OriginalTensor reference to original tensor metadata
	OriginalTensor *GradientTensor `json:"original_tensor"`

	// CompressedData contains the compressed gradient data
	CompressedData []byte `json:"compressed_data"`

	// Algorithm used for compression
	Algorithm GradientCompressionAlgorithm `json:"algorithm"`

	// CompressionRatio achieved
	CompressionRatio float64 `json:"compression_ratio"`

	// SparsityLevel achieved (for sparse algorithms)
	SparsityLevel float64 `json:"sparsity_level"`

	// QuantizationLevel used (for quantization algorithms)
	QuantizationLevel QuantizationBits `json:"quantization_level"`

	// Indices for sparse gradients
	Indices []int32 `json:"indices,omitempty"`

	// Values for sparse gradients
	Values []float32 `json:"values,omitempty"`

	// QuantizationScale for dequantization
	QuantizationScale float64 `json:"quantization_scale,omitempty"`

	// QuantizationZeroPoint for asymmetric quantization
	QuantizationZeroPoint int32 `json:"quantization_zero_point,omitempty"`

	// ErrorMetrics contains compression error statistics
	ErrorMetrics *CompressionErrorMetrics `json:"error_metrics,omitempty"`
}

type CompressedTensor struct {
	// OriginalTensor reference to original tensor metadata
	OriginalTensor *ModelTensor `json:"original_tensor"`

	// CompressedData contains the compressed tensor data
	CompressedData []byte `json:"compressed_data"`

	// Algorithm used for compression
	Algorithm TensorCompressionAlgorithm `json:"algorithm"`

	// CompressionRatio achieved
	CompressionRatio float64 `json:"compression_ratio"`

	// CompressionMetrics contains detailed compression statistics
	CompressionMetrics *TensorCompressionMetrics `json:"compression_metrics"`

	// ReconstructionData additional data needed for reconstruction
	ReconstructionData map[string]interface{} `json:"reconstruction_data,omitempty"`

	// PrunedIndices for pruning-based compression
	PrunedIndices []int32 `json:"pruned_indices,omitempty"`

	// QuantizationClusters for k-means quantization
	QuantizationClusters []float32 `json:"quantization_clusters,omitempty"`

	// SVDComponents for SVD compression
	SVDComponents *SVDComponents `json:"svd_components,omitempty"`
}

type CompressionErrorMetrics struct {
	// L1Error absolute error
	L1Error float64 `json:"l1_error"`

	// L2Error mean squared error
	L2Error float64 `json:"l2_error"`

	// RelativeError relative error
	RelativeError float64 `json:"relative_error"`

	// MaxError maximum absolute error
	MaxError float64 `json:"max_error"`

	// SNR signal-to-noise ratio
	SNR float64 `json:"snr"`
}

type CompressionPipeline struct {
	// contains filtered or unexported fields
}

type CompressionPipelineConfig struct {
	// EnableGradientCompression enables gradient compression
	EnableGradientCompression bool `json:"enable_gradient_compression"`

	// EnableTensorCompression enables model tensor compression
	EnableTensorCompression bool `json:"enable_tensor_compression"`

	// EnableSparsification enables sparsification algorithms
	EnableSparsification bool `json:"enable_sparsification"`

	// EnableStorageCompression enables storage-level compression
	EnableStorageCompression bool `json:"enable_storage_compression"`

	// GradientConfig configuration for gradient compression
	GradientConfig GradientCompressionConfig `json:"gradient_config"`

	// TensorConfig configuration for tensor compression
	TensorConfig TensorCompressionConfig `json:"tensor_config"`

	// SparsificationConfig configuration for sparsification
	SparsificationConfig SparsificationConfig `json:"sparsification_config"`

	// StorageConfig configuration for storage compression
	StorageConfig compression.CompressionConfig `json:"storage_config"`

	// CompressionThresholds size thresholds for applying compression
	CompressionThresholds CompressionThresholds `json:"compression_thresholds"`

	// QualitySettings quality vs compression trade-offs
	QualitySettings QualitySettings `json:"quality_settings"`

	// ParallelProcessing enables parallel compression processing
	ParallelProcessing bool `json:"parallel_processing"`

	// MaxConcurrency maximum concurrent compression operations
	MaxConcurrency int `json:"max_concurrency"`
}

type CompressionResult struct {
	// Success whether compression was successful
	Success bool `json:"success"`

	// CompressedData the compressed data (could be gradient, tensor, or sparse)
	CompressedData interface{} `json:"compressed_data"`

	// CompressionRatio achieved compression ratio
	CompressionRatio float64 `json:"compression_ratio"`

	// Method compression method used
	Method string `json:"method"`

	// ProcessingTimeMs time taken for compression
	ProcessingTimeMs int64 `json:"processing_time_ms"`

	// ErrorMessage error message if compression failed
	ErrorMessage string `json:"error_message,omitempty"`

	// Metadata additional metadata about compression
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type CompressionThresholds struct {
	// MinGradientSize minimum size in bytes to apply gradient compression
	MinGradientSize int64 `json:"min_gradient_size"`

	// MinTensorSize minimum size in bytes to apply tensor compression
	MinTensorSize int64 `json:"min_tensor_size"`

	// MinSparsificationSize minimum size to apply sparsification
	MinSparsificationSize int64 `json:"min_sparsification_size"`

	// MinStorageSize minimum size to apply storage compression
	MinStorageSize int64 `json:"min_storage_size"`
}

type DemandProjection struct {
	Timestamp       time.Time `json:"timestamp"`
	ProjectedCPU    int       `json:"projected_cpu"`
	ProjectedMemory int64     `json:"projected_memory"`
	ProjectedIOPS   int64     `json:"projected_iops"`
	Confidence      float64   `json:"confidence"`
	Scenario        string    `json:"scenario"` // best, likely, worst
}

type ErrorToleranceMode string

type Feature struct {
	Name        string    `json:"name"`
	Value       float64   `json:"value"`
	Type        string    `json:"type"` // numeric, categorical, temporal
	Description string    `json:"description"`
	Timestamp   time.Time `json:"timestamp"`
}

type FeatureConfig struct {
	EnableTemporalFeatures    bool      `json:"enable_temporal_features"`
	EnableStatisticalFeatures bool      `json:"enable_statistical_features"`
	EnableFrequencyFeatures   bool      `json:"enable_frequency_features"`
	EnableLaggedFeatures      bool      `json:"enable_lagged_features"`
	LagPeriods                []int     `json:"lag_periods"`
	RollingWindowSizes        []int     `json:"rolling_window_sizes"`
	QuantileThresholds        []float64 `json:"quantile_thresholds"`
}

type FeatureEngine interface {
	ExtractFeatures(data []TimeSeriesPoint) []Feature
	GetFeatureName() string
}

type GradientCompressionAlgorithm string

type GradientCompressionConfig struct {
	// Algorithm specifies the compression algorithm to use
	Algorithm GradientCompressionAlgorithm `json:"algorithm"`

	// CompressionRatio target compression ratio (0.0-1.0)
	CompressionRatio float64 `json:"compression_ratio"`

	// TopKRatio for top-k sparsification (percentage of top gradients to keep)
	TopKRatio float64 `json:"topk_ratio"`

	// SparsityThreshold for threshold-based sparsification
	SparsityThreshold float64 `json:"sparsity_threshold"`

	// QuantizationBits for gradient quantization
	QuantizationBits QuantizationBits `json:"quantization_bits"`

	// EnableAdaptive enables adaptive compression based on gradient distribution
	EnableAdaptive bool `json:"enable_adaptive"`

	// MinCompressionRatio minimum compression ratio for adaptive mode
	MinCompressionRatio float64 `json:"min_compression_ratio"`

	// MaxCompressionRatio maximum compression ratio for adaptive mode
	MaxCompressionRatio float64 `json:"max_compression_ratio"`

	// ErrorBoundCompression enable error-bounded compression
	ErrorBoundCompression bool `json:"error_bound_compression"`

	// MaxRelativeError maximum relative error for error-bounded compression
	MaxRelativeError float64 `json:"max_relative_error"`
}

type GradientCompressor struct {
	// contains filtered or unexported fields
}

type GradientTensor struct {
	// Shape of the tensor (dimensions)
	Shape []int `json:"shape"`

	// Data contains the gradient values as float32
	Data []float32 `json:"data"`

	// LayerName identifies the layer this gradient belongs to
	LayerName string `json:"layer_name"`

	// Timestamp when the gradient was computed
	Timestamp int64 `json:"timestamp"`
}

type ImpactPredictor struct {
	// contains filtered or unexported fields
}

type ImportanceMetric string

type IsolationForest struct {
	// contains filtered or unexported fields
}

type IsolationNode struct {
	// contains filtered or unexported fields
}

type IsolationTree struct {
	// contains filtered or unexported fields
}

type LSTMModel struct {
	// contains filtered or unexported fields
}

type Layer struct {
	// contains filtered or unexported fields
}

type MLDataset struct {
	ID         string            `json:"id"`
	Created    time.Time         `json:"created"`
	Features   [][]Feature       `json:"features"`
	Labels     []float64         `json:"labels"`
	Metadata   map[string]string `json:"metadata"`
	WindowSize int               `json:"window_size"`
	StepSize   int               `json:"step_size"`
}

type MetricCollector interface {
	Collect() (PerformanceRecord, error)
}

type MetricType string

type MetricsCollector struct {
	// contains filtered or unexported fields
}

type MetricsRingBuffer struct {
	// contains filtered or unexported fields
}

type MigrationCostModel struct {
	// contains filtered or unexported fields
}

type MigrationImpact struct {
	Timestamp         time.Time     `json:"timestamp"`
	VMSize            int64         `json:"vm_size"`
	MigrationTime     time.Duration `json:"migration_time"`
	Downtime          time.Duration `json:"downtime"`
	PerformanceImpact float64       `json:"performance_impact"`
	Success           bool          `json:"success"`
}

type MigrationOptimizer struct {
	// contains filtered or unexported fields
}

type MigrationSuggestion struct {
	VMId            string          `json:"vm_id"`
	SourceNode      string          `json:"source_node"`
	TargetNode      string          `json:"target_node"`
	OptimalWindow   MigrationWindow `json:"optimal_window"`
	Reason          string          `json:"reason"`
	ExpectedBenefit float64         `json:"expected_benefit"`
	EstimatedTime   time.Duration   `json:"estimated_time"`
	Prerequisites   []string        `json:"prerequisites"`
}

type MigrationWindow struct {
	Start             time.Time `json:"start"`
	End               time.Time `json:"end"`
	Score             float64   `json:"score"`
	ExpectedImpact    float64   `json:"expected_impact"`
	ResourceAvailable bool      `json:"resource_available"`
	RiskLevel         string    `json:"risk_level"`
}

type ModelTensor struct {
	// Name of the tensor (layer name + parameter type)
	Name string `json:"name"`

	// Shape of the tensor
	Shape []int `json:"shape"`

	// Data contains the tensor values
	Data []float32 `json:"data"`

	// Type of tensor (weight, bias, etc.)
	Type TensorType `json:"type"`

	// LayerType the layer this tensor belongs to (conv, linear, etc.)
	LayerType string `json:"layer_type"`

	// Metadata additional information about the tensor
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type NeuralNetwork struct {
	// contains filtered or unexported fields
}

type PatternOccurrence struct {
	PatternID  string        `json:"pattern_id"`
	Timestamp  time.Time     `json:"timestamp"`
	VMId       string        `json:"vm_id"`
	Confidence float64       `json:"confidence"`
	Duration   time.Duration `json:"duration"`
}

type PatternRecognizer struct {
	// contains filtered or unexported fields
}

type PerformanceConfig struct {
	ModelLayers        []int         `json:"model_layers"`         // Neural network architecture
	LearningRate       float64       `json:"learning_rate"`        // Training learning rate
	PredictionWindow   time.Duration `json:"prediction_window"`    // How far ahead to predict
	UpdateFrequency    time.Duration `json:"update_frequency"`     // Model update frequency
	AccuracyTarget     float64       `json:"accuracy_target"`      // Target accuracy (85%)
	LatencyTarget      time.Duration `json:"latency_target"`       // Target latency (250ms)
	EnableCapacityPlan bool          `json:"enable_capacity_plan"` // Enable capacity planning
	EnableMigrationOpt bool          `json:"enable_migration_opt"` // Enable migration optimization
}

type PerformanceHistory struct {
	// contains filtered or unexported fields
}

type PerformancePrediction struct {
	Timestamp           time.Time                   `json:"timestamp"`
	VMId                string                      `json:"vm_id"`
	WorkloadType        string                      `json:"workload_type"`
	PredictedThroughput float64                     `json:"predicted_throughput"`
	PredictedLatency    time.Duration               `json:"predicted_latency"`
	PredictedIOPS       float64                     `json:"predicted_iops"`
	PredictedBandwidth  float64                     `json:"predicted_bandwidth"`
	PerformanceScore    float64                     `json:"performance_score"`
	Bottlenecks         []Bottleneck                `json:"bottlenecks"`
	Recommendations     []PerformanceRecommendation `json:"recommendations"`
	CapacityPlan        *CapacityPlan               `json:"capacity_plan,omitempty"`
	MigrationSuggestion *MigrationSuggestion        `json:"migration_suggestion,omitempty"`
	Confidence          float64                     `json:"confidence"`
	ModelAccuracy       float64                     `json:"model_accuracy"`
}

type PerformancePredictor struct {
	// contains filtered or unexported fields
}

type PerformanceRecommendation struct {
	Action              string        `json:"action"`
	Priority            string        `json:"priority"`
	ExpectedImprovement float64       `json:"expected_improvement"`
	Implementation      string        `json:"implementation"`
	Cost                float64       `json:"cost"`
	TimeToImplement     time.Duration `json:"time_to_implement"`
}

type PerformanceRecord struct {
	Timestamp   time.Time `json:"timestamp"`
	VMId        string    `json:"vm_id"`
	Throughput  float64   `json:"throughput"`
	Latency     float64   `json:"latency"`
	IOPS        float64   `json:"iops"`
	Bandwidth   float64   `json:"bandwidth"`
	CPUUsage    float64   `json:"cpu_usage"`
	MemoryUsage float64   `json:"memory_usage"`
}

type PipelineStatistics struct {
	// TotalOperations total compression operations
	TotalOperations int64 `json:"total_operations"`

	// GradientOperations gradient compression operations
	GradientOperations int64 `json:"gradient_operations"`

	// TensorOperations tensor compression operations
	TensorOperations int64 `json:"tensor_operations"`

	// SparsificationOperations sparsification operations
	SparsificationOperations int64 `json:"sparsification_operations"`

	// TotalBytesProcessed total bytes processed
	TotalBytesProcessed int64 `json:"total_bytes_processed"`

	// TotalBytesCompressed total bytes after compression
	TotalBytesCompressed int64 `json:"total_bytes_compressed"`

	// AverageCompressionRatio average compression ratio achieved
	AverageCompressionRatio float64 `json:"average_compression_ratio"`

	// TotalCompressionTime total time spent on compression
	TotalCompressionTimeMs int64 `json:"total_compression_time_ms"`

	// LastUpdated timestamp of last update
	LastUpdated time.Time `json:"last_updated"`
}

type PredictiveAllocator struct {
	// contains filtered or unexported fields
}

type PredictorConfig struct {
	PredictionHorizon time.Duration `json:"prediction_horizon"` // 15 minutes ahead
	UpdateInterval    time.Duration `json:"update_interval"`    // Model update frequency
	BufferSize        int           `json:"buffer_size"`        // Historical data points
	AccuracyTarget    float64       `json:"accuracy_target"`    // 85% accuracy target
	LatencyTarget     time.Duration `json:"latency_target"`     // 250ms latency target
	EnableAutoScaling bool          `json:"enable_auto_scaling"`
	EnablePreemptive  bool          `json:"enable_preemptive"`
	ModelVersion      string        `json:"model_version"`
}

type ProductionDataCollector struct {
	// contains filtered or unexported fields
}

type PruningSchedule struct {
	// InitialSparsity starting sparsity ratio
	InitialSparsity float64 `json:"initial_sparsity"`

	// FinalSparsity target final sparsity ratio
	FinalSparsity float64 `json:"final_sparsity"`

	// PruningFrequency how often to apply pruning (in epochs)
	PruningFrequency int `json:"pruning_frequency"`

	// Schedule type (linear, polynomial, exponential)
	Schedule string `json:"schedule"`

	// PolynomialPower for polynomial schedule
	PolynomialPower float64 `json:"polynomial_power,omitempty"`
}

type QualitySettings struct {
	// QualityLevel overall quality level (0.0-1.0)
	QualityLevel float64 `json:"quality_level"`

	// PreserveAccuracy prioritize accuracy over compression ratio
	PreserveAccuracy bool `json:"preserve_accuracy"`

	// MaxAccuracyLoss maximum acceptable accuracy loss
	MaxAccuracyLoss float64 `json:"max_accuracy_loss"`

	// AdaptiveCompression adjust compression based on importance
	AdaptiveCompression bool `json:"adaptive_compression"`

	// ErrorToleranceMode error tolerance for compression
	ErrorToleranceMode ErrorToleranceMode `json:"error_tolerance_mode"`
}

type QuantizationBits uint8

type ResourceMetrics struct {
	Timestamp    time.Time `json:"timestamp"`
	VMId         string    `json:"vm_id"`
	CPUUsage     float64   `json:"cpu_usage"`
	MemoryUsage  float64   `json:"memory_usage"`
	IOUsage      float64   `json:"io_usage"`
	NetworkUsage float64   `json:"network_usage"`
}

type ResourcePrediction struct {
	Timestamp         time.Time               `json:"timestamp"`
	VMId              string                  `json:"vm_id"`
	PredictedCPU      float64                 `json:"predicted_cpu"`
	PredictedMemory   float64                 `json:"predicted_memory"`
	PredictedIO       float64                 `json:"predicted_io"`
	PredictedNetwork  float64                 `json:"predicted_network"`
	Confidence        float64                 `json:"confidence"`
	Recommendations   []ScalingRecommendation `json:"recommendations"`
	PredictionLatency time.Duration           `json:"prediction_latency"`
	Accuracy          float64                 `json:"accuracy"`
}

type ResourceProfile struct {
	CPUPattern     []float64 `json:"cpu_pattern"`
	MemoryPattern  []float64 `json:"memory_pattern"`
	IOPattern      []float64 `json:"io_pattern"`
	NetworkPattern []float64 `json:"network_pattern"`
}

type SVDComponents struct {
	// U matrix (left singular vectors)
	U []float32 `json:"u"`
	// S vector (singular values)
	S []float32 `json:"s"`
	// VT matrix (right singular vectors transposed)
	VT []float32 `json:"vt"`
	// UShape shape of U matrix
	UShape []int `json:"u_shape"`
	// VTShape shape of VT matrix
	VTShape []int `json:"vt_shape"`
	// Rank preserved rank
	Rank int `json:"rank"`
}

type ScalingRecommendation struct {
	Action          string        `json:"action"`    // scale_up, scale_down, migrate
	Target          string        `json:"target"`    // resource or VM ID
	Magnitude       float64       `json:"magnitude"` // scaling factor
	Urgency         string        `json:"urgency"`   // immediate, scheduled, optional
	Reason          string        `json:"reason"`
	EstimatedImpact float64       `json:"estimated_impact"`
	TimeWindow      time.Duration `json:"time_window"`
}

type SparseData struct {
	// Indices of non-zero elements
	Indices []int32 `json:"indices"`

	// Values of non-zero elements
	Values []float32 `json:"values"`

	// Shape of the original dense tensor
	Shape []int `json:"shape"`

	// SparsityLevel achieved sparsity level
	SparsityLevel float64 `json:"sparsity_level"`

	// Algorithm used for sparsification
	Algorithm SparsificationAlgorithm `json:"algorithm"`

	// Metadata additional information
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type SparsificationAlgorithm string

type SparsificationConfig struct {
	// Algorithm specifies the sparsification algorithm
	Algorithm SparsificationAlgorithm `json:"algorithm"`

	// SparsityRatio target sparsity ratio (0.0-1.0)
	SparsityRatio float64 `json:"sparsity_ratio"`

	// Granularity of sparsification
	Granularity SparsificationGranularity `json:"granularity"`

	// BlockSize for block-wise sparsification
	BlockSize []int `json:"block_size,omitempty"`

	// PruningSchedule for iterative pruning
	PruningSchedule *PruningSchedule `json:"pruning_schedule,omitempty"`

	// GradientAccumulation steps for gradient-based pruning
	GradientAccumulation int `json:"gradient_accumulation"`

	// ImportanceMetric for importance-based pruning
	ImportanceMetric ImportanceMetric `json:"importance_metric"`

	// AdaptiveThreshold enables adaptive threshold adjustment
	AdaptiveThreshold bool `json:"adaptive_threshold"`

	// MinSparsity minimum sparsity level
	MinSparsity float64 `json:"min_sparsity"`

	// MaxSparsity maximum sparsity level
	MaxSparsity float64 `json:"max_sparsity"`

	// RecoveryEpochs epochs to recover after aggressive pruning
	RecoveryEpochs int `json:"recovery_epochs"`

	// PreserveStructure whether to maintain structured sparsity
	PreserveStructure bool `json:"preserve_structure"`
}

type SparsificationGranularity string

type SparsificationMetrics struct {
	// OriginalSize number of parameters before sparsification
	OriginalSize int `json:"original_size"`

	// NonZeroCount number of non-zero parameters after sparsification
	NonZeroCount int `json:"non_zero_count"`

	// SparsityLevel achieved sparsity level
	SparsityLevel float64 `json:"sparsity_level"`

	// CompressionRatio memory compression achieved
	CompressionRatio float64 `json:"compression_ratio"`

	// FlopsReduction computational reduction
	FlopsReduction float64 `json:"flops_reduction"`

	// AccuracyDrop estimated accuracy drop
	AccuracyDrop float64 `json:"accuracy_drop,omitempty"`

	// SparsificationTime time taken to sparsify
	SparsificationTimeMs int64 `json:"sparsification_time_ms"`
}

type Sparsifier struct {
	// contains filtered or unexported fields
}

type SystemCapacity struct {
	TotalCPU     int   `json:"total_cpu"`
	TotalMemory  int64 `json:"total_memory"`
	TotalStorage int64 `json:"total_storage"`
	TotalNetwork int64 `json:"total_network"`
	UsedCPU      int   `json:"used_cpu"`
	UsedMemory   int64 `json:"used_memory"`
	UsedStorage  int64 `json:"used_storage"`
	UsedNetwork  int64 `json:"used_network"`
	VMCount      int   `json:"vm_count"`
	NodeCount    int   `json:"node_count"`
}

type TensorCompressionAlgorithm string

type TensorCompressionConfig struct {
	Algorithm        TensorCompressionAlgorithm `json:"algorithm"`
	CompressionRatio float64                    `json:"compression_ratio"`
	QuantizationBits QuantizationBits           `json:"quantization_bits"`
}

type TensorCompressionMetrics struct {
	// OriginalSize in bytes
	OriginalSize int `json:"original_size"`

	// CompressedSize in bytes
	CompressedSize int `json:"compressed_size"`

	// CompressionRatio actual achieved ratio
	CompressionRatio float64 `json:"compression_ratio"`

	// ParameterReduction percentage of parameters reduced
	ParameterReduction float64 `json:"parameter_reduction"`

	// AccuracyLoss estimated accuracy loss from compression
	AccuracyLoss float64 `json:"accuracy_loss,omitempty"`

	// CompressionTime time taken to compress
	CompressionTimeMs int64 `json:"compression_time_ms"`

	// DecompressionTime time taken to decompress
	DecompressionTimeMs int64 `json:"decompression_time_ms"`

	// ErrorMetrics compression error statistics
	ErrorMetrics *CompressionErrorMetrics `json:"error_metrics,omitempty"`
}

type TensorCompressor struct {
	// contains filtered or unexported fields
}

type TensorType string

type ThresholdInfo struct {
	Current        float64   `json:"current"`
	Historical     []float64 `json:"historical"`
	LastUpdated    time.Time `json:"last_updated"`
	Confidence     float64   `json:"confidence"`
	TruePositives  int       `json:"true_positives"`
	FalsePositives int       `json:"false_positives"`
}

type TimeSeriesBuffer struct {
	// contains filtered or unexported fields
}

type TimeSeriesPoint struct {
	Timestamp time.Time              `json:"timestamp"`
	Value     float64                `json:"value"`
	Tags      map[string]string      `json:"tags"`
	Fields    map[string]interface{} `json:"fields"`
}

type VMMetrics struct {
	Timestamp     time.Time          `json:"timestamp"`
	VMId          string             `json:"vm_id"`
	CPU           float64            `json:"cpu"`
	Memory        float64            `json:"memory"`
	DiskIO        float64            `json:"disk_io"`
	NetworkIO     float64            `json:"network_io"`
	Latency       float64            `json:"latency"`
	ErrorRate     float64            `json:"error_rate"`
	CustomMetrics map[string]float64 `json:"custom_metrics"`
}

type WorkloadPattern struct {
	ID              string             `json:"id"`
	Name            string             `json:"name"`
	Type            string             `json:"type"` // periodic, burst, steady, growing
	Characteristics map[string]float64 `json:"characteristics"`
	Frequency       time.Duration      `json:"frequency"`
	Duration        time.Duration      `json:"duration"`
	ResourceProfile ResourceProfile    `json:"resource_profile"`
	LastSeen        time.Time          `json:"last_seen"`
	Occurrences     int                `json:"occurrences"`
}

type WorkloadProfile struct {
	ModelType         string  `json:"model_type"`         // transformer, cnn, mlp, etc.
	ModelSize         int64   `json:"model_size"`         // Model size in parameters
	BatchSize         int     `json:"batch_size"`         // Training batch size
	MemoryConstrained bool    `json:"memory_constrained"` // Whether memory is limited
	SpeedCritical     bool    `json:"speed_critical"`     // Whether speed is critical
	AccuracyTarget    float64 `json:"accuracy_target"`    // Target accuracy to maintain
}