anchor.diff:  import 'package:ml_linalg/matrix.dart';
   import 'package:ml_linalg/vector.dart';
   
  -/// A factory for all the linear regressors.
  +/// A class that performs linear regression
   ///
   /// A typical linear regressor uses the equation of a line for multidimensional
   /// space to make a prediction. Each `x` in the equation has its own coefficient
   /// (weight) and the combination of these `x`-es and its coefficients gives the
  -/// `y` term. The latter is a thing, that the regressor should predict, and
  -/// as one knows all the `x` values (since it is the input for the algorithm),
  +/// `y` term. The latter is a value, that the regressor should predict, and
  +/// as all the `x` values are known (since it is the input for the algorithm),
   /// the regressor should find the best coefficients (weights) (they are unknown)
   /// to make a best prediction of `y` term.
   abstract class LinearRegressor implements Assessable {
  -  /// Creates a gradient linear regressor. Uses gradient descent solver to
  -  /// find the optimal weights
  -  ///
     /// Parameters:
     ///
     /// [fittingData] A [DataFrame] with observations, that will be used by the
  -  /// regressor to learn coefficients of the predicting line
  +  /// regressor to learn coefficients of the predicting hyperplane. Must contain
  +  /// [targetName] column.
     ///
  -  /// [targetName] A string, that serves as a name of the target column (a
  -  /// column, that contains outcomes for the associated features)
  +  /// [targetName] A string, that serves as a name of the target column, that
  +  /// contains labels or outcomes.
  +  ///
  +  /// [optimizerType] Defines an algorithm of optimization, that will be used
  +  /// to find the best coefficients of a cost function. Also defines, which
  +  /// regularization type (L1 or L2) one may use to learn a linear regressor.
     ///
     /// [iterationsLimit] A number of fitting iterations. Uses as a condition of
  -  /// convergence in the solver. Default
  -  /// value is `100`
  +  /// convergence in the optimization algorithm. Default value is `100`.
     ///
     /// [initialLearningRate] A value, defining velocity of the convergence of the
  -  /// gradient descent solver.
  +  /// gradient descent optimizer. Default value is `1e-3`.
     ///
  -  /// [minCoefficientsUpdate] A minimum distance between weights vectors in two
  -  /// subsequent iterations. Uses as a condition of convergence in the solver.
  -  /// In other words, if difference is small, there is no reason to continue
  -  /// fitting. Default value is `1e-12`
  +  /// [minCoefficientsUpdate] A minimum distance between coefficient vectors in
  +  /// two contiguous iterations. Uses as a condition of convergence in the
  +  /// optimization algorithm. If difference between the two vectors is small
  +  /// enough, there is no reason to continue fitting. Default value is `1e-12`
     ///
  -  /// [lambda] A coefficient for regularization. For this particular regressor
  -  /// there is only L2 regularization type.
  +  /// [lambda] A coefficient of regularization. Uses to prevent the regressor's
  +  /// overfitting. The more the value of [lambda], the more regular the
  +  /// coefficients of the predicting hyperplane are. Extremely large [lambda]
  +  /// may decrease the coefficients to nothing, otherwise too small [lambda] may
  +  /// be a cause of too large absolute values of the coefficients.
     ///
  -  /// [randomSeed] A seed, that will be passed to a random value generator, used
  -  /// by stochastic optimizers. Will be ignored, if the solver is not
  -  /// stochastic. Remember, each time you run the regressor with the same
  -  /// parameters, you will receive a different result. To avoid it, define
  -  /// [randomSeed]
  +  /// [randomSeed] A seed, that will be passed to a random value generator,
  +  /// used by stochastic optimizers. Will be ignored, if the solver cannot be
  +  /// stochastic. Remember, each time you run the stochastic regressor with the
  +  /// same parameters but with unspecified [randomSeed], you will receive
  +  /// different results. To avoid it, define [randomSeed]
     ///
     /// [batchSize] A size of data (in rows), that will be used for fitting per
  -  /// one iteration.
  +  /// one iteration. Applicable not for all optimizers. If gradient-based
  +  /// optimizer is used and If [batchSize] == `1`, stochastic mode will be
  +  /// activated; if `1` < [batchSize] < `total number of rows`, mini-batch mode
  +  /// will be activated; if [batchSize] == `total number of rows`, full-batch
  +  /// mode will be activated.
     ///
     /// [fitIntercept] Whether or not to fit intercept term. Default value is
  -  /// `false`.
  +  /// `false`. Intercept in 2-dimensional space is a bias of the line (relative
  +  /// to X-axis) to be learned by the regressor
     ///
  -  /// [interceptScale] A value, defining a size of the intercept term
  +  /// [interceptScale] A value, defining a size of the intercept.
  +  ///
  +  /// [isFittingDataNormalized] Defines, whether the [fittingData] normalized
  +  /// or not. Normalization should be performed column-wise. Normalized data
  +  /// may be needed for some optimizers (e.g., for
  +  /// [LinearOptimizerType.vanillaCD])
     ///
     /// [learningRateType] A value, defining a strategy for the learning rate
  -  /// behaviour throughout the whole fitting process
  +  /// behaviour throughout the whole fitting process.
     ///
  -  /// [dtype] A data type for all the numeric values, used by the algorithm.
  -  /// Can affect performance or accuracy of the computations. Default value is
  -  /// [Float32x4]
  +  /// [initialCoefficientsType] Defines the coefficients, that will be
  +  /// autogenerated before the first iteration of optimization. By default,
  +  /// all the autogenerated coefficients are equal to zeroes at the start.
  +  /// If [initialCoefficients] are provided, the parameter will be ignored
  +  ///
  +  /// [initialCoefficients] Coefficients to be used in the first iteration of
  +  /// optimization algorithm. [initialCoefficients] is a vector, length of which
  +  /// must be equal to the number of features in [fittingData]: the number of
  +  /// features is equal to the number of columns in [fittingData] minus 1
  +  /// (target column).
  +  ///
  +  /// [dtype] A data type for all the numeric values, used by the algorithm. Can
  +  /// affect performance or accuracy of the computations. Default value is
  +  /// [DType.float32]
     factory LinearRegressor(DataFrame fittingData, String targetName, {
       LinearOptimizerType optimizerType,
       int iterationsLimit = 100,
  
positive.code:       initialCoefficientsType: initialCoefficientsType,
        fitIntercept: fitIntercept,
        interceptScale: interceptScale,
        isFittingDataNormalized: isTrainDataNormalized,
        dtype: dtype,
      );
  
  
negative.code:     int randomSeed,
      int batchSize = 1,
      Matrix initialCoefficients,
      bool isFittingDataNormalized = false,
      DType dtype = DType.float32,
    }) {
      final optimizer = createSquaredCostOptimizer(
  