703 lines
21 KiB
ObjectPascal
703 lines
21 KiB
ObjectPascal
// Copyright (c) Ivan Bondarev, Stanislav Mikhalkovich (for details please see \doc\copyright.txt)
|
||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
||
// PreprocessorABC v.1.0
|
||
|
||
{
|
||
DataFrameABC
|
||
↓
|
||
PreprocessorABC
|
||
├─ IPreprocessor
|
||
├─ Scalers / Encoders / Imputer
|
||
└─ Pipeline
|
||
↓
|
||
MLCore
|
||
}
|
||
|
||
/// PreprocessorABC — модуль подготовки табличных данных для анализа данных и машинного обучения.
|
||
/// Содержит типовые преобразования признаков с семантикой Fit / Transform.
|
||
/// Работает совместно с DataFrameABC и не содержит моделей машинного обучения.
|
||
unit PreprocessorABC;
|
||
|
||
interface
|
||
|
||
uses DataFrameABC;
|
||
uses System;
|
||
uses MLCoreABC;
|
||
|
||
type
|
||
/// Базовый интерфейс шагов подготовки данных.
|
||
/// Определяет семантику операций Fit и Transform
|
||
IPreprocessor = interface(IDataStep)
|
||
/// Анализирует DataFrame и и сохраняет параметры шага
|
||
function Fit(df: DataFrame): IPreprocessor;
|
||
/// Применяет сохранённые параметры к DataFrame.
|
||
/// Возвращает новый DataFrame
|
||
function Transform(df: DataFrame): DataFrame;
|
||
/// Выполняет Fit и Transform последовательно
|
||
function FitTransform(df: DataFrame): DataFrame;
|
||
|
||
function Clone: IPreprocessor;
|
||
end;
|
||
|
||
/// Кодирует строковый категориальный столбец в целочисленные индексы (0,1,2,...).
|
||
/// Соответствие значений и индексов фиксируется при вызове Fit
|
||
/// в порядке первого появления категорий.
|
||
/// Работает только со строковыми столбцами и предназначен для признаков.
|
||
/// Не должен применяться к целевому столбцу (target).
|
||
LabelEncoder = class(IPreprocessor, IColumnBoundStep)
|
||
private
|
||
col: string;
|
||
mapping: Dictionary<string, integer>;
|
||
fitted: boolean;
|
||
public
|
||
/// Создаёт LabelEncoder для указанного столбца
|
||
constructor Create(column: string);
|
||
|
||
/// Определяет множество категорий и сохраняет их коды
|
||
function Fit(df: DataFrame): IPreprocessor;
|
||
/// Заменяет категории их числовыми кодами
|
||
/// Возвращает новый DataFrame
|
||
function Transform(df: DataFrame): DataFrame;
|
||
/// Выполняет Fit и Transform последовательно
|
||
function FitTransform(df: DataFrame): DataFrame;
|
||
|
||
function ToString: string; override;
|
||
|
||
property ColumnName: string read col;
|
||
|
||
function Clone: IPreprocessor;
|
||
end;
|
||
|
||
/// Кодирует строковый категориальный столбец в набор бинарных (one-hot) столбцов
|
||
/// Категории фиксируются при Fit
|
||
/// Неизвестные категории кодируются нулями
|
||
/// Пропущенные значения (NA) кодируются нулями
|
||
OneHotEncoder = class(IPreprocessor, IColumnBoundStep)
|
||
private
|
||
col: string;
|
||
categories: array of string;
|
||
indexByValue: Dictionary<string, integer>;
|
||
fitted: boolean;
|
||
public
|
||
/// Создаёт OneHotEncoder для указанного столбца
|
||
constructor Create(column: string);
|
||
|
||
/// Определяет множество категорий столбца
|
||
function Fit(df: DataFrame): IPreprocessor;
|
||
/// Заменяет столбец набором бинарных столбцов
|
||
/// Возвращает новый DataFrame
|
||
function Transform(df: DataFrame): DataFrame;
|
||
/// Выполняет Fit и Transform последовательно
|
||
function FitTransform(df: DataFrame): DataFrame;
|
||
|
||
function ToString: string; override;
|
||
|
||
property ColumnName: string read col;
|
||
|
||
function Clone: IPreprocessor;
|
||
end;
|
||
|
||
ImputeStrategy = (isMean, isConstant, isMedian);
|
||
|
||
/// Заполняет пропущенные значения (NA) в числовых столбцах
|
||
/// Поддерживает стратегии isMean и isConstant
|
||
/// Работает только с Int и Float столбцами
|
||
Imputer = class(IPreprocessor, IColumnsBoundStep)
|
||
private
|
||
cols: array of string;
|
||
strategy: ImputeStrategy;
|
||
constants: array of object;
|
||
means: array of real;
|
||
medians: array of real;
|
||
fitted: boolean;
|
||
public
|
||
/// Создаёт Imputer с заполнением средним значением
|
||
constructor Create(params columns: array of string);
|
||
/// Создаёт Imputer с заданной стратегией заполнения
|
||
constructor Create(strategy: ImputeStrategy; params columns: array of string);
|
||
/// Создаёт Imputer с константной стратегией заполнения
|
||
constructor Create(value: object; params columns: array of string);
|
||
|
||
/// Вычисляет значения для заполнения пропусков
|
||
function Fit(df: DataFrame): IPreprocessor;
|
||
/// Заполняет пропущенные значения в DataFrame
|
||
/// Возвращает новый DataFrame
|
||
function Transform(df: DataFrame): DataFrame;
|
||
/// Выполняет Fit и Transform последовательно
|
||
function FitTransform(df: DataFrame): DataFrame;
|
||
|
||
function ToString: string; override;
|
||
|
||
property Columns: array of string read cols;
|
||
|
||
function Clone: IPreprocessor;
|
||
end;
|
||
|
||
|
||
implementation
|
||
|
||
uses MLExceptions;
|
||
|
||
const
|
||
ER_SCALER_NO_COLUMNS =
|
||
'StandardScaler: столбцы не указаны!!StandardScaler: columns not specified';
|
||
ER_SCALER_COLUMN_NOT_NUMERIC =
|
||
'StandardScaler: столбец "{0}" не является числовым!!StandardScaler: column "{0}" is not numeric';
|
||
ER_SCALER_NO_VALID_VALUES =
|
||
'StandardScaler: столбец "{0}" не содержит допустимых значений!!' +
|
||
'StandardScaler: column "{0}" has no valid values';
|
||
ER_SCALER_ZERO_VARIANCE =
|
||
'StandardScaler: нулевая дисперсия в столбце "{0}"!!' +
|
||
'StandardScaler: zero variance in column "{0}"';
|
||
ER_MINMAX_NO_COLUMNS =
|
||
'MinMaxScaler: столбцы не указаны!!MinMaxScaler: columns not specified';
|
||
ER_MINMAX_COLUMN_NOT_NUMERIC =
|
||
'MinMaxScaler: столбец "{0}" не является числовым!!MinMaxScaler: column "{0}" is not numeric';
|
||
ER_MINMAX_NO_VALID_VALUES =
|
||
'MinMaxScaler: столбец "{0}" не содержит допустимых значений!!' +
|
||
'MinMaxScaler: column "{0}" has no valid values';
|
||
ER_MINMAX_CONSTANT_COLUMN =
|
||
'MinMaxScaler: постоянный столбец "{0}"!!MinMaxScaler: constant column "{0}"';
|
||
ER_LABELENCODER_NO_COLUMN =
|
||
'LabelEncoder: столбец не указан!!LabelEncoder: column not specified';
|
||
ER_LABELENCODER_NOT_STRING =
|
||
'LabelEncoder: столбец "{0}" не является строковым!!' +
|
||
'LabelEncoder: column "{0}" is not string';
|
||
ER_LABELENCODER_NA =
|
||
'LabelEncoder: NA значение не допускается!!LabelEncoder: NA value not allowed';
|
||
ER_LABELENCODER_UNSEEN_CATEGORY =
|
||
'LabelEncoder: неизвестная категория "{0}"!!' +
|
||
'LabelEncoder: unseen category "{0}"';
|
||
ER_ONEHOT_NO_COLUMN =
|
||
'OneHotEncoder: столбец не указан!!OneHotEncoder: column not specified';
|
||
ER_ONEHOT_NOT_STRING =
|
||
'OneHotEncoder: столбец "{0}" не является строковым или не содержит допустимых значений!!' +
|
||
'OneHotEncoder: column "{0}" is not string or has no valid values';
|
||
ER_ONEHOT_UNSEEN_CATEGORY =
|
||
'OneHotEncoder: неизвестная категория "{0}"!!' +
|
||
'OneHotEncoder: unseen category "{0}"';
|
||
ER_IMPUTER_INVALID_STRATEGY_MEAN =
|
||
'Imputer: данный конструктор предназначен для стратегии isMean!!' +
|
||
'Imputer: this constructor is for isMean';
|
||
ER_IMPUTER_INVALID_STRATEGY_CONSTANT =
|
||
'Imputer: данный конструктор предназначен для стратегии isConstant!!' +
|
||
'Imputer: this constructor is for isConstant';
|
||
ER_IMPUTER_NO_COLUMNS =
|
||
'Imputer: столбцы не указаны!!Imputer: columns not specified';
|
||
ER_IMPUTER_COLUMN_NOT_NUMERIC =
|
||
'Imputer: столбец "{0}" не является числовым!!' +
|
||
'Imputer: column "{0}" is not numeric';
|
||
ER_IMPUTER_NO_VALID_VALUES =
|
||
'Imputer(mean): столбец "{0}" не содержит допустимых значений!!' +
|
||
'Imputer(mean): column "{0}" has no valid values';
|
||
ER_IMPUTER_CONSTANT_VALUE_NULL =
|
||
'Imputer(constant): значение nil для столбца "{0}"!!' +
|
||
'Imputer(constant): value is nil for column "{0}"';
|
||
ER_IMPUTER_CONSTANT_TYPE_MISMATCH =
|
||
'Imputer(constant): несоответствие типа значения для столбца "{0}"!!' +
|
||
'Imputer(constant): value type mismatch for column "{0}"';
|
||
ER_ONEHOT_EMPTY_COLUMN =
|
||
'Столбец "{0}" не содержит категориальных значений!!Column "{0}" contains no categorical values';
|
||
ER_IMPUTER_CONSTANTS_INVALID =
|
||
'Массив констант не задан или имеет неверный размер!!Constants array is null or has invalid length';
|
||
ER_IMPUTER_STRATEGY_NOT_SUPPORTED =
|
||
'Стратегия импутации {0} не поддерживается!!Imputation strategy {0} is not supported';
|
||
ER_UNSUPPORTED_IMPUTE_STRATEGY =
|
||
'Неподдерживаемая стратегия заполнения: {0}!!Unsupported impute strategy: {0}';
|
||
|
||
|
||
//-----------------------------
|
||
// LabelEncoder
|
||
//-----------------------------
|
||
|
||
constructor LabelEncoder.Create(column: string);
|
||
begin
|
||
if column = '' then
|
||
ArgumentError(ER_LABELENCODER_NO_COLUMN);
|
||
|
||
col := column;
|
||
fitted := false;
|
||
end;
|
||
|
||
function LabelEncoder.Fit(df: DataFrame): IPreprocessor;
|
||
begin
|
||
if df = nil then
|
||
ArgumentNullError(ER_ARG_NULL, 'df');
|
||
|
||
if not df.HasColumn(col) then
|
||
ArgumentError(ER_COLUMN_NOT_FOUND, col);
|
||
|
||
var idx := df.Schema.IndexOf(col);
|
||
|
||
if df.Schema.ColumnTypeAt(idx) <> ColumnType.ctStr then
|
||
Error(ER_LABELENCODER_NOT_STRING, col);
|
||
|
||
mapping := new Dictionary<string, integer>;
|
||
|
||
var cur := df.GetCursor;
|
||
var nextId := 0;
|
||
|
||
while cur.MoveNext do
|
||
begin
|
||
if not cur.IsValid(idx) then continue;
|
||
|
||
var s := cur.Str(idx);
|
||
if not mapping.ContainsKey(s) then
|
||
begin
|
||
mapping[s] := nextId;
|
||
nextId += 1;
|
||
end;
|
||
end;
|
||
|
||
fitted := true;
|
||
Result := Self;
|
||
end;
|
||
|
||
function LabelEncoder.Transform(df: DataFrame): DataFrame;
|
||
begin
|
||
if not fitted then
|
||
NotFittedError(ER_FIT_NOT_CALLED);
|
||
|
||
var idx := df.Schema.IndexOf(col);
|
||
var n := df.RowCount;
|
||
|
||
var data := new integer[n];
|
||
var valid: array of boolean := nil;
|
||
|
||
var cur := df.GetCursor;
|
||
var row := 0;
|
||
while cur.MoveNext do
|
||
begin
|
||
if not cur.IsValid(idx) then
|
||
begin
|
||
if valid = nil then
|
||
begin
|
||
valid := new boolean[n];
|
||
for var j := 0 to row - 1 do
|
||
valid[j] := true;
|
||
end;
|
||
valid[row] := false;
|
||
data[row] := 0;
|
||
end
|
||
else
|
||
begin
|
||
var s := cur.Str(idx);
|
||
|
||
if not mapping.ContainsKey(s) then
|
||
Error(ER_LABELENCODER_UNSEEN_CATEGORY, s);
|
||
|
||
data[row] := mapping[s];
|
||
if valid <> nil then
|
||
valid[row] := true;
|
||
end;
|
||
|
||
row += 1;
|
||
end;
|
||
|
||
var res := new DataFrame;
|
||
|
||
foreach var src in df.GetColumns do
|
||
if src.Info.Name <> col then
|
||
res.AddColumnAlias(src)
|
||
else
|
||
res.AddIntColumn(col, data, valid);
|
||
|
||
Result := res.SetCategorical([col]);
|
||
end;
|
||
|
||
function LabelEncoder.FitTransform(df: DataFrame): DataFrame;
|
||
begin
|
||
Fit(df);
|
||
Result := Transform(df);
|
||
end;
|
||
|
||
function LabelEncoder.ToString: string;
|
||
begin
|
||
Result := 'LabelEncoder(' + col + ')';
|
||
end;
|
||
|
||
function LabelEncoder.Clone: IPreprocessor;
|
||
begin
|
||
Result := new LabelEncoder(col);
|
||
end;
|
||
//-----------------------------
|
||
// OneHotEncoder
|
||
//-----------------------------
|
||
|
||
constructor OneHotEncoder.Create(column: string);
|
||
begin
|
||
if column = '' then
|
||
ArgumentError(ER_ONEHOT_NO_COLUMN);
|
||
col := column;
|
||
fitted := false;
|
||
end;
|
||
|
||
function OneHotEncoder.Fit(df: DataFrame): IPreprocessor;
|
||
begin
|
||
if df = nil then
|
||
ArgumentNullError(ER_ARG_NULL, 'df');
|
||
|
||
var idx := df.Schema.IndexOf(col);
|
||
if idx < 0 then
|
||
Error(ER_COLUMN_NOT_FOUND, col);
|
||
|
||
if df.Schema.ColumnTypeAt(idx) <> ColumnType.ctStr then
|
||
Error(ER_ONEHOT_NOT_STRING, col);
|
||
|
||
indexByValue := new Dictionary<string, integer>;
|
||
var values := new List<string>;
|
||
|
||
var cur := df.GetCursor;
|
||
while cur.MoveNext do
|
||
begin
|
||
if not cur.IsValid(idx) then continue;
|
||
|
||
var s := cur.Str(idx);
|
||
|
||
var dummy: integer;
|
||
if not indexByValue.TryGetValue(s, dummy) then
|
||
begin
|
||
indexByValue[s] := values.Count;
|
||
values.Add(s);
|
||
end;
|
||
end;
|
||
|
||
if values.Count = 0 then
|
||
Error(ER_ONEHOT_EMPTY_COLUMN, col);
|
||
|
||
categories := values.ToArray;
|
||
fitted := true;
|
||
Result := Self;
|
||
end;
|
||
|
||
function OneHotEncoder.Transform(df: DataFrame): DataFrame;
|
||
begin
|
||
if not fitted then
|
||
NotFittedError(ER_FIT_NOT_CALLED);
|
||
|
||
var srcIdx := df.Schema.IndexOf(col);
|
||
if srcIdx < 0 then
|
||
ArgumentError(ER_COLUMN_NOT_FOUND, col);
|
||
|
||
var catCount := categories.Length;
|
||
|
||
var res := df;
|
||
|
||
// === Генерация one-hot столбцов ===
|
||
for var j := 0 to catCount - 1 do
|
||
begin
|
||
var catIdx := j;
|
||
var newName := col + '_' + categories[j];
|
||
|
||
var Encode: DataFrameCursor -> integer := c ->
|
||
begin
|
||
if not c.IsValid(col) then
|
||
begin
|
||
Result := 0;
|
||
exit;
|
||
end;
|
||
|
||
var s := c.Str(col);
|
||
|
||
var idx: integer;
|
||
if not indexByValue.TryGetValue(s, idx) then
|
||
begin
|
||
Result := 0;
|
||
exit;
|
||
end;
|
||
|
||
Result := Ord(idx = catIdx);
|
||
end;
|
||
|
||
res := res.AddDerivedIntColumn(newName, Encode);
|
||
end;
|
||
|
||
// === удаление исходного столбца ===
|
||
res := res.Drop([srcIdx]);
|
||
|
||
Result := res;
|
||
end;
|
||
|
||
function OneHotEncoder.FitTransform(df: DataFrame): DataFrame;
|
||
begin
|
||
Fit(df);
|
||
Result := Transform(df);
|
||
end;
|
||
|
||
function OneHotEncoder.ToString: string;
|
||
begin
|
||
Result := 'OneHotEncoder(column=' + col + ')';
|
||
end;
|
||
|
||
function OneHotEncoder.Clone: IPreprocessor;
|
||
begin
|
||
Result := new OneHotEncoder(col);
|
||
end;
|
||
|
||
//-----------------------------
|
||
// Imputer
|
||
//-----------------------------
|
||
|
||
constructor Imputer.Create(strategy: ImputeStrategy; params columns: array of string);
|
||
begin
|
||
if (columns = nil) or (columns.Length = 0) then
|
||
ArgumentError(ER_IMPUTER_NO_COLUMNS);
|
||
|
||
self.strategy := strategy;
|
||
self.cols := columns;
|
||
self.constants := nil;
|
||
fitted := false;
|
||
end;
|
||
|
||
constructor Imputer.Create(params columns: array of string);
|
||
begin
|
||
Create(ImputeStrategy.isMean, columns);
|
||
end;
|
||
|
||
constructor Imputer.Create(value: object; params columns: array of string);
|
||
begin
|
||
if (columns = nil) or (columns.Length = 0) then
|
||
ArgumentError(ER_IMPUTER_NO_COLUMNS);
|
||
|
||
self.strategy := ImputeStrategy.isConstant;
|
||
self.cols := columns;
|
||
|
||
// одна и та же константа для всех столбцов
|
||
self.constants := new object[columns.Length];
|
||
for var i := 0 to columns.Length - 1 do
|
||
self.constants[i] := value;
|
||
|
||
fitted := false;
|
||
end;
|
||
|
||
function Imputer.Fit(df: DataFrame): IPreprocessor;
|
||
begin
|
||
case strategy of
|
||
isMean:
|
||
begin
|
||
SetLength(means, cols.Length);
|
||
|
||
for var i := 0 to cols.Length - 1 do
|
||
begin
|
||
var name := cols[i];
|
||
var idx := df.Schema.IndexOf(name);
|
||
var ct := df.Schema.ColumnTypeAt(idx);
|
||
|
||
if not (ct in [ColumnType.ctInt, ColumnType.ctFloat]) then
|
||
Error(ER_IMPUTER_COLUMN_NOT_NUMERIC, name);
|
||
|
||
var sum := 0.0;
|
||
var cnt := 0;
|
||
|
||
var cur := df.GetCursor;
|
||
while cur.MoveNext do
|
||
if cur.IsValid(idx) then
|
||
begin
|
||
sum += cur.Float(idx);
|
||
cnt += 1;
|
||
end;
|
||
|
||
if cnt = 0 then
|
||
Error(ER_IMPUTER_NO_VALID_VALUES, name);
|
||
|
||
means[i] := sum / cnt;
|
||
end;
|
||
end;
|
||
|
||
isConstant:
|
||
begin
|
||
// ничего делать не нужно
|
||
end;
|
||
|
||
isMedian:
|
||
begin
|
||
SetLength(medians, cols.Length);
|
||
|
||
for var i := 0 to cols.Length - 1 do
|
||
begin
|
||
var name := cols[i];
|
||
var idx := df.Schema.IndexOf(name);
|
||
var ct := df.Schema.ColumnTypeAt(idx);
|
||
|
||
if not (ct in [ColumnType.ctInt, ColumnType.ctFloat]) then
|
||
Error(ER_IMPUTER_COLUMN_NOT_NUMERIC, name);
|
||
|
||
// --- собираем значения
|
||
var values := new List<real>;
|
||
|
||
var cur := df.GetCursor;
|
||
while cur.MoveNext do
|
||
if cur.IsValid(idx) then
|
||
values.Add(cur.Float(idx));
|
||
|
||
if values.Count = 0 then
|
||
Error(ER_IMPUTER_NO_VALID_VALUES, name);
|
||
|
||
// --- сортируем
|
||
values.Sort;
|
||
|
||
// --- медиана
|
||
var n := values.Count;
|
||
if n mod 2 = 1 then
|
||
medians[i] := values[n div 2]
|
||
else
|
||
medians[i] := (values[n div 2 - 1] + values[n div 2]) / 2.0;
|
||
end;
|
||
end;
|
||
|
||
end;
|
||
|
||
fitted := true;
|
||
Result := Self;
|
||
end;
|
||
|
||
function Imputer.Transform(df: DataFrame): DataFrame;
|
||
begin
|
||
if not fitted then
|
||
NotFittedError(ER_FIT_NOT_CALLED);
|
||
|
||
// --- проверка constants
|
||
if (strategy = isConstant) and
|
||
((constants = nil) or (constants.Length <> cols.Length)) then
|
||
Error(ER_IMPUTER_CONSTANTS_INVALID);
|
||
|
||
var res := df;
|
||
|
||
for var i := 0 to cols.Length - 1 do
|
||
begin
|
||
var name := cols[i];
|
||
|
||
// --- ВАЖНО: используем актуальную схему
|
||
var idx := res.Schema.IndexOf(name);
|
||
var ct := res.Schema.ColumnTypeAt(idx);
|
||
|
||
if not (ct in [ColumnType.ctInt, ColumnType.ctFloat]) then
|
||
Error(ER_IMPUTER_COLUMN_NOT_NUMERIC, name);
|
||
|
||
case strategy of
|
||
isMean:
|
||
begin
|
||
var m := means[i];
|
||
res := res.ReplaceColumnFloat(
|
||
name,
|
||
c -> (if c.IsValid(idx) then c.Float(idx) else m)
|
||
);
|
||
end;
|
||
|
||
isConstant:
|
||
begin
|
||
var v := constants[i];
|
||
if v = nil then
|
||
Error(ER_IMPUTER_CONSTANT_VALUE_NULL, name);
|
||
|
||
if ct = ColumnType.ctInt then
|
||
begin
|
||
var k: integer;
|
||
|
||
if v is integer then
|
||
k := integer(v)
|
||
else if v is real then
|
||
begin
|
||
var r := real(v);
|
||
var ir := Round(r);
|
||
if Abs(r - ir) > 1e-9 then
|
||
Error(ER_IMPUTER_CONSTANT_TYPE_MISMATCH, name);
|
||
k := ir;
|
||
end
|
||
else
|
||
Error(ER_IMPUTER_CONSTANT_TYPE_MISMATCH, name);
|
||
|
||
res := res.ReplaceColumnInt(
|
||
name,
|
||
c -> (if c.IsValid(idx) then c.Int(idx) else k)
|
||
);
|
||
end
|
||
else // ctFloat
|
||
begin
|
||
var r: real;
|
||
try
|
||
r := real(v);
|
||
except
|
||
on e: Exception do
|
||
Error(ER_IMPUTER_CONSTANT_TYPE_MISMATCH, name);
|
||
end;
|
||
|
||
res := res.ReplaceColumnFloat(
|
||
name,
|
||
c -> (if c.IsValid(idx) then c.Float(idx) else r)
|
||
);
|
||
end;
|
||
end;
|
||
|
||
isMedian:
|
||
begin
|
||
var m := medians[i];
|
||
res := res.ReplaceColumnFloat(
|
||
name,
|
||
c -> (if c.IsValid(idx) then c.Float(idx) else m)
|
||
);
|
||
end;
|
||
|
||
else
|
||
Error(ER_IMPUTER_STRATEGY_NOT_SUPPORTED, strategy);
|
||
end;
|
||
end;
|
||
|
||
Result := res;
|
||
end;
|
||
|
||
function Imputer.FitTransform(df: DataFrame): DataFrame;
|
||
begin
|
||
Fit(df);
|
||
Result := Transform(df);
|
||
end;
|
||
|
||
function Imputer.ToString: string;
|
||
begin
|
||
var colsStr := '[' + cols.JoinToString(', ') + ']';
|
||
|
||
case strategy of
|
||
isMean:
|
||
Result := 'Imputer(strategy=mean, columns=' + colsStr + ')';
|
||
|
||
isMedian:
|
||
Result := 'Imputer(strategy=median, columns=' + colsStr + ')';
|
||
|
||
isConstant:
|
||
begin
|
||
var valStr :=
|
||
if (constants <> nil) and (constants.Length > 0) and (constants[0] <> nil) then
|
||
constants[0].ToString
|
||
else
|
||
'null';
|
||
|
||
Result := 'Imputer(strategy=constant, value=' +
|
||
valStr + ', columns=' + colsStr + ')';
|
||
end;
|
||
|
||
else
|
||
Result := 'Imputer(strategy=unknown, columns=' + colsStr + ')';
|
||
end;
|
||
end;
|
||
|
||
function Imputer.Clone: IPreprocessor;
|
||
begin
|
||
case strategy of
|
||
ImputeStrategy.isMean:
|
||
Result := new Imputer(cols);
|
||
|
||
ImputeStrategy.isMedian:
|
||
Result := new Imputer(ImputeStrategy.isMedian, cols);
|
||
|
||
ImputeStrategy.isConstant:
|
||
begin
|
||
var val := if (constants <> nil) and (constants.Length > 0) then constants[0] else nil;
|
||
Result := new Imputer(val, cols);
|
||
end;
|
||
|
||
else
|
||
Error(ER_UNSUPPORTED_IMPUTE_STRATEGY, strategy);
|
||
end;
|
||
end;
|
||
|
||
end. |