import { ClassifierBase } from '../base';
import { Params } from '../base/estimator';
import { ClassificationLossName, SGDLearningRate, SGDPenalty } from './sgdBase';
export interface SGDClassifierProps {
    loss?: ClassificationLossName;
    penalty?: SGDPenalty;
    alpha?: number;
    l1Ratio?: number;
    fitIntercept?: boolean;
    maxIter?: number;
    tol?: number | null;
    shuffle?: boolean;
    randomState?: number;
    learningRate?: SGDLearningRate;
    eta0?: number;
    powerT?: number;
    nIterNoChange?: number;
}
/**
 * Linear classifier trained with plain (non-averaged) stochastic gradient
 * descent, mirroring scikit-learn's `SGDClassifier`.
 *
 * Binary problems fit a single weight vector; multiclass problems are handled
 * one-vs-rest (one binary SGD per class, prediction by argmax of the decision
 * values). `predictProba` is available only for `loss='logLoss'` and
 * `loss='modifiedHuber'` (the sklearn rule); other losses throw.
 */
export declare class SGDClassifier extends ClassifierBase {
    protected loss: ClassificationLossName;
    protected penalty: SGDPenalty;
    protected alpha: number;
    protected l1Ratio: number;
    protected fitIntercept: boolean;
    protected maxIter: number;
    protected tol: number | null;
    protected shuffle: boolean;
    protected randomState?: number;
    protected learningRate: SGDLearningRate;
    protected eta0: number;
    protected powerT: number;
    protected nIterNoChange: number;
    protected classes: number[];
    /** One weight row per class (a single row for binary problems). */
    protected coefState: number[][];
    /** One intercept per weight row. */
    protected intercept: number[];
    /** Epochs run by the slowest-converging binary problem. */
    protected nIter: number;
    constructor(props?: SGDClassifierProps);
    getParams(): Params;
    fit(trainX: number[][], trainY: number[]): void;
    private assertFitted;
    private scoreRow;
    /**
     * Signed distances to the decision boundary. Returns a 1-D array for
     * binary problems, an [nSamples][nClasses] array for multiclass.
     */
    decisionFunction(testX: number[][]): number[] | number[][];
    predict(testX: number[][]): number[];
    /**
     * Class-membership probabilities, columns ordered by sorted `classes`.
     * Only supported for `loss='logLoss'` (sigmoid of the decision value,
     * one-vs-rest normalized for multiclass) and `loss='modifiedHuber'`
     * ((clip(d, -1, 1) + 1) / 2, normalized; uniform when every class gives
     * zero) — the same rule scikit-learn applies.
     */
    predictProba(testX: number[][]): number[][];
    getClasses(): number[];
    /** Fitted weights, one row per class (a single row for binary problems). */
    getCoef(): number[][];
    get coef(): number[][];
    getIntercept(): number[];
    /** Epochs run by the slowest-converging one-vs-rest problem. */
    getNIter(): number;
}