model

type AdaptiveLearning interface {
	// GetLearningRate returns the current learning rate
	GetLearningRate() float64

	// SetLearningRate sets the learning rate
	SetLearningRate(lr float64)

	// GetLearningRateSchedule returns the learning rate schedule
	// e.g., "constant", "optimal", "invscaling", "adaptive"
	GetLearningRateSchedule() string

	// SetLearningRateSchedule sets the learning rate schedule
	SetLearningRateSchedule(schedule string)
}

type BaseEstimator struct {
	// State holds the model's learning state. Public for gob encoding.
	State EstimatorState

	// ModelType identifies the type of model
	ModelType string

	// Version is the model version
	Version string
	// contains filtered or unexported fields
}

type Batch struct {
	X mat.Matrix // Feature matrix
	Y mat.Matrix // Target matrix
}

type BufferedStreaming interface {
	// SetBufferSize sets the size of streaming buffer
	SetBufferSize(size int)

	// GetBufferSize returns current buffer size
	GetBufferSize() int

	// FlushBuffer forces buffer flush
	FlushBuffer() error
}

type Classifier interface {
	Estimator
	Predictor
	Scorer

	// PredictProba returns probability estimates for each class.
	PredictProba(X mat.Matrix) (mat.Matrix, error)

	// Classes returns the unique classes seen during fitting.
	Classes() []int
}

type ClassifierMixin interface {
	Estimator

	// PredictProba は各クラスの確率を予測
	PredictProba(X mat.Matrix) (mat.Matrix, error)

	// PredictLogProba は各クラスの対数確率を予測
	PredictLogProba(X mat.Matrix) (mat.Matrix, error)

	// DecisionFunction は決定関数の値を計算
	DecisionFunction(X mat.Matrix) (mat.Matrix, error)

	// Classes は学習されたクラスラベルを返す
	Classes() []interface{}

	// NClasses は学習されたクラス数を返す
	NClasses() int
}

type ClassifierWithPartialFit interface {
	Classifier
	IncrementalLearner
}

type ClusterMixin interface {
	Fitter

	// FitPredict は学習と予測を同時に実行
	FitPredict(X mat.Matrix) ([]int, error)

	// PredictCluster は新しいデータのクラスタを予測
	PredictCluster(X mat.Matrix) ([]int, error)

	// NClusters はクラスタ数を返す
	NClusters() int
}

type CrossValidatable interface {
	// GetCVSplits はクロスバリデーションの分割数を返す
	GetCVSplits() int

	// SetCVSplits はクロスバリデーションの分割数を設定
	SetCVSplits(n int)

	// GetCVScores はクロスバリデーションのスコアを返す
	GetCVScores() []float64
}

type Estimator interface {
	Fitter
	Predictor
}

type EstimatorState int

type Fitter interface {
	// Fit trains the model with training data
	Fit(X, y mat.Matrix) error
}

type IncrementalEstimator interface {
	Estimator

	// PartialFit trains the model incrementally with mini-batches
	// classes specifies all class labels for classification problems (required only on first call)
	// Pass nil for regression problems
	PartialFit(X, y mat.Matrix, classes []int) error

	// NIterations returns the number of training iterations executed
	NIterations() int

	// IsWarmStart returns whether warm start is enabled
	// If true, continues learning from existing parameters when Fit is called
	IsWarmStart() bool

	// SetWarmStart enables/disables warm start
	SetWarmStart(warmStart bool)
}

type IncrementalLearner interface {
	// PartialFit performs one epoch of stochastic gradient descent on given samples.
	PartialFit(X mat.Matrix, y mat.Matrix, classes []int) error
}

type InverseTransformerMixin interface {
	TransformerMixin

	// InverseTransform は変換を逆方向に適用
	InverseTransform(X mat.Matrix) (mat.Matrix, error)
}

type LinearModel interface {
	// Weights returns the learned weights (coefficients)
	Weights() []float64
	// Intercept returns the learned intercept
	Intercept() float64
	// Score calculates the model's coefficient of determination (R²)
	Score(X, y mat.Matrix) (float64, error)
}

type ModelState struct {
	Fitted    bool                   `json:"fitted"`
	NFeatures int                    `json:"n_features,omitempty"`
	NSamples  int                    `json:"n_samples,omitempty"`
	Params    map[string]interface{} `json:"params,omitempty"`
}

type ModelValidation struct {
	// ValidateInput は入力データの検証
	ValidateInput func(X mat.Matrix) error

	// ValidateOutput は出力データの検証
	ValidateOutput func(y mat.Matrix) error

	// ValidateWeights は重みの検証
	ValidateWeights func(weights *ModelWeights) error
}

type ModelWeights struct {
	// ModelType はモデルの種類（LinearRegression, SGDRegressor等）
	ModelType string `json:"model_type"`

	// Version はモデルのバージョン（互換性チェック用）
	Version string `json:"version"`

	// Coefficients は重み係数
	Coefficients []float64 `json:"coefficients"`

	// Intercept は切片
	Intercept float64 `json:"intercept"`

	// Features は特徴量の名前（オプション）
	Features []string `json:"features,omitempty"`

	// Hyperparameters はモデルのハイパーパラメータ
	Hyperparameters map[string]interface{} `json:"hyperparameters"`

	// Metadata は追加のメタデータ（学習時の統計等）
	Metadata map[string]interface{} `json:"metadata,omitempty"`

	// IsFitted はモデルが学習済みかどうか
	IsFitted bool `json:"is_fitted"`
}

type OnlineEstimator interface {
	Estimator
	IncrementalLearner
}

type OnlineMetrics interface {
	// GetLoss returns the current loss value
	GetLoss() float64

	// GetLossHistory returns the history of loss values
	GetLossHistory() []float64

	// GetConverged returns whether the model has converged
	GetConverged() bool
}

type ParallelStreaming interface {
	// SetWorkers sets the number of workers
	SetWorkers(n int)

	// GetWorkers returns current number of workers
	GetWorkers() int

	// SetBatchParallelism enables/disables intra-batch parallelism
	SetBatchParallelism(enabled bool)
}

type ParameterGetter interface {
	// GetParams returns the model's hyperparameters.
	GetParams() map[string]interface{}
}

type ParameterSetter interface {
	// SetParams sets the model's hyperparameters.
	SetParams(params map[string]interface{}) error
}

type PartialFitMixin interface {
	// PartialFit はミニバッチで逐次学習
	PartialFit(X, y mat.Matrix, classes []int) error

	// NIterations は学習イテレーション数を返す
	NIterations() int

	// IsWarmStart はウォームスタートが有効かどうか
	IsWarmStart() bool

	// SetWarmStart はウォームスタートの有効/無効を設定
	SetWarmStart(warmStart bool)
}

type Persistable interface {
	// Save saves the model to a file.
	Save(path string) error

	// Load loads the model from a file.
	Load(path string) error
}

type PipelineCompatible interface {
	SKLearnCompatible

	// GetInputDim は入力次元数を返す
	GetInputDim() int

	// GetOutputDim は出力次元数を返す
	GetOutputDim() int

	// RequiresFit は学習が必要かどうか
	RequiresFit() bool
}

type Predictor interface {
	// Predict performs predictions on input data
	Predict(X mat.Matrix) (mat.Matrix, error)
}

type Regressor interface {
	Estimator
	Predictor
	Scorer
}

type RegressorMixin interface {
	Estimator

	// Score は決定係数R²を計算
	Score(X, y mat.Matrix) (float64, error)
}

type RegressorWithPartialFit interface {
	Regressor
	IncrementalLearner
}

type SKLearnCompatible interface {
	// GetParams はモデルのハイパーパラメータを取得
	GetParams(deep bool) map[string]interface{}

	// SetParams はモデルのハイパーパラメータを設定
	SetParams(params map[string]interface{}) error

	// Clone はモデルの新しいインスタンスを同じパラメータで作成
	Clone() SKLearnCompatible
}

type SKLearnLinearRegressionParams struct {
	Coefficients []float64 `json:"coefficients"` // 係数（重み）
	Intercept    float64   `json:"intercept"`    // 切片
	NFeatures    int       `json:"n_features"`   // 特徴量の数
}

type SKLearnModel struct {
	ModelSpec SKLearnModelSpec `json:"model_spec"`
	Params    json.RawMessage  `json:"params"`
}

type SKLearnModelSpec struct {
	Name           string `json:"name"`                      // モデル名 (e.g., "LinearRegression")
	FormatVersion  string `json:"format_version"`            // フォーマットバージョン
	SKLearnVersion string `json:"sklearn_version,omitempty"` // scikit-learnのバージョン
}

type Scorer interface {
	// Score returns the coefficient of determination R^2 of the prediction.
	Score(X mat.Matrix, y mat.Matrix) (float64, error)
}

type StateManager struct {
	Fitted bool // Public for gob encoding

	// Optional metadata - Public for gob encoding
	NFeatures int
	NSamples  int
	// contains filtered or unexported fields
}

type StreamingEstimator interface {
	IncrementalEstimator

	// FitStream trains the model from a data stream
	// Continues learning until the context is canceled or the channel is closed
	FitStream(ctx context.Context, dataChan <-chan *Batch) error

	// PredictStream performs real-time predictions on input stream
	// Output channel is closed when input channel is closed
	PredictStream(ctx context.Context, inputChan <-chan mat.Matrix) <-chan mat.Matrix

	// FitPredictStream performs learning and prediction simultaneously
	// Returns predictions while training on new data (test-then-train approach)
	FitPredictStream(ctx context.Context, dataChan <-chan *Batch) <-chan mat.Matrix
}

type StreamingMetrics interface {
	OnlineMetrics

	// GetThroughput returns current throughput (samples/second)
	GetThroughput() float64

	// GetProcessedSamples returns total number of processed samples
	GetProcessedSamples() int64

	// GetAverageLatency returns average latency in milliseconds
	GetAverageLatency() float64

	// GetMemoryUsage returns current memory usage in bytes
	GetMemoryUsage() int64
}

type Transformer interface {
	// Fit learns parameters necessary for transformation
	Fit(X mat.Matrix) error

	// Transform transforms data
	Transform(X mat.Matrix) (mat.Matrix, error)

	// FitTransform executes Fit and Transform simultaneously
	FitTransform(X mat.Matrix) (mat.Matrix, error)
}

type TransformerMixin interface {
	// Transform はデータを変換
	Transform(X mat.Matrix) (mat.Matrix, error)

	// FitTransform は学習と変換を同時に実行
	FitTransform(X mat.Matrix) (mat.Matrix, error)
}

type WeightExporter interface {
	// ExportWeights はモデルの重みをエクスポート
	ExportWeights() (*ModelWeights, error)

	// ImportWeights はモデルの重みをインポート
	ImportWeights(weights *ModelWeights) error

	// GetWeightHash は重みのハッシュ値を計算（検証用）
	GetWeightHash() string
}