755 lines
23 KiB
ObjectPascal
755 lines
23 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
|
||
/// в порядке первого появления категорий.
|
||
/// Пропущенные значения (NA) игнорируются при обучении
|
||
/// и сохраняются как пропуски при преобразовании.
|
||
/// Работает только со строковыми столбцами и предназначен для признаков.
|
||
/// Не должен применяться к целевому столбцу (target).
|
||
LabelEncoder = class(IPreprocessor, IColumnBoundStep)
|
||
private
|
||
col: string;
|
||
mapping: Dictionary<string, integer>;
|
||
fitted: boolean;
|
||
public
|
||
/// Создаёт LabelEncoder для указанного столбца
|
||
constructor Create(column: string);
|
||
|
||
/// Определяет множество категорий столбца и сохраняет их числовое кодирование.
|
||
/// df — таблица данных.
|
||
/// Сохраняет отображение категорий в числовые коды для последующего применения.
|
||
///
|
||
/// Примечание:
|
||
/// • отображение категорий НЕ копируется методом Clone
|
||
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, IColumnExpander)
|
||
private
|
||
col: string;
|
||
categories: array of string;
|
||
indexByValue: Dictionary<string, integer>;
|
||
fitted: boolean;
|
||
public
|
||
/// Создаёт OneHotEncoder для указанного столбца
|
||
constructor Create(column: string);
|
||
|
||
/// Определяет множество категорий столбца.
|
||
/// df — таблица данных.
|
||
/// Сохраняет категории для последующего преобразования в one-hot представление.
|
||
///
|
||
/// Примечание:
|
||
/// • категории НЕ копируются методом Clone
|
||
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 GetExpandedColumns(sourceColumn: string): array of string;
|
||
|
||
/// Копирует только конфигурацию препроцессора (без обученного состояния).
|
||
/// Используется для создания независимых экземпляров препроцессора.
|
||
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);
|
||
|
||
/// Вычисляет значения для заполнения пропусков.
|
||
/// df — таблица данных.
|
||
/// В зависимости от стратегии вычисляет параметры заполнения
|
||
/// (например, среднее, медиану или константу) для каждого столбца.
|
||
///
|
||
/// Примечание:
|
||
/// • вычисленные параметры НЕ копируются методом Clone
|
||
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_LABELENCODER_NO_COLUMN =
|
||
'LabelEncoder: столбец не указан!!LabelEncoder: column not specified';
|
||
ER_LABELENCODER_NOT_STRING =
|
||
'LabelEncoder: столбец "{0}" не является строковым!!' +
|
||
'LabelEncoder: column "{0}" is not string';
|
||
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}';
|
||
ER_ONEHOT_NAME_EQUALS_SOURCE =
|
||
'Сгенерированная колонка совпадает с исходной: {0}!!Generated column equals source column: {0}';
|
||
ER_ONEHOT_COLUMN_COLLISION =
|
||
'Конфликт имён колонок: {0}!!Column name collision: {0}';
|
||
ER_ONEHOT_DUPLICATE_COLUMN =
|
||
'Дублирующаяся сгенерированная колонка: {0}!!Duplicate generated column: {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 := new boolean[n];
|
||
|
||
var cur := df.GetCursor;
|
||
var row := 0;
|
||
while cur.MoveNext do
|
||
begin
|
||
if not cur.IsValid(idx) then
|
||
begin
|
||
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];
|
||
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;
|
||
|
||
// --- проверка коллизий имён колонок
|
||
var used := new HashSet<string>;
|
||
|
||
for var i := 0 to categories.Length - 1 do
|
||
begin
|
||
var newName := col + '_' + categories[i];
|
||
|
||
// 1. совпадение с исходным именем
|
||
if newName = col then
|
||
Error(ER_ONEHOT_NAME_EQUALS_SOURCE, newName);
|
||
|
||
// 2. коллизия с существующими колонками DataFrame
|
||
if df.HasColumn(newName) then
|
||
Error(ER_ONEHOT_COLUMN_COLLISION, newName);
|
||
|
||
// 3. дубликаты среди сгенерированных колонок
|
||
if used.Contains(newName) then
|
||
Error(ER_ONEHOT_DUPLICATE_COLUMN, newName);
|
||
|
||
used.Add(newName);
|
||
end;
|
||
|
||
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.GetExpandedColumns(sourceColumn: string): array of string;
|
||
begin
|
||
if not fitted then
|
||
NotFittedError(ER_FIT_NOT_CALLED);
|
||
|
||
if sourceColumn <> col then
|
||
exit(nil);
|
||
|
||
var res := new string[categories.Length];
|
||
for var i := 0 to categories.Length - 1 do
|
||
res[i] := col + '_' + categories[i];
|
||
|
||
Result := res;
|
||
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);
|
||
|
||
var capturedIdx := idx;
|
||
|
||
case strategy of
|
||
isMean:
|
||
begin
|
||
var m := means[i];
|
||
res := res.ReplaceColumnFloat(
|
||
name,
|
||
c -> (if c.IsValid(capturedIdx) then c.Float(capturedIdx) 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(capturedIdx) then c.Int(capturedIdx) 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(capturedIdx) then c.Float(capturedIdx) else r)
|
||
);
|
||
end;
|
||
end;
|
||
|
||
isMedian:
|
||
begin
|
||
var m := medians[i];
|
||
res := res.ReplaceColumnFloat(
|
||
name,
|
||
c -> (if c.IsValid(capturedIdx) then c.Float(capturedIdx) 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.
|