428 lines
12 KiB
Common Lisp
428 lines
12 KiB
Common Lisp
#pragma OPENCL EXTENSION cl_khr_fp64 : enable //Tiene que soportar double
|
|
|
|
|
|
#ifdef cl_khr_int64
|
|
#define entero_signed long
|
|
#define entero_unsigned ulong
|
|
#pragma OPENCL EXTENSION cl_khr_int64 : enable
|
|
#else
|
|
#define entero_signed int
|
|
#define entero_unsigned uint
|
|
#endif
|
|
|
|
#define min_value 1e-9
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
__kernel void fit_standard_scaler_init(
|
|
__global double* mean, // Output: [cols]
|
|
__global double* std, // Output: [cols]
|
|
__global const double* matrix, // Input: [rows * cols]
|
|
const entero_unsigned cols,
|
|
const entero_unsigned rows
|
|
)
|
|
{
|
|
uint col = get_global_id(0); // Solo una dimensión
|
|
|
|
if(col >= cols)
|
|
return;
|
|
|
|
//--- media
|
|
double total_sum = 0.0;
|
|
for(entero_unsigned row = 0; row < rows; row++)
|
|
{
|
|
entero_unsigned idx = row * cols + col;
|
|
total_sum += matrix[idx];
|
|
}
|
|
|
|
double mean_col = total_sum / rows; //media
|
|
mean[col] = mean_col;
|
|
|
|
double variance_sum = 0.0; //valor inicial
|
|
|
|
for(entero_unsigned row = 0; row < rows; row++)
|
|
{
|
|
entero_unsigned idx = row * cols + col;
|
|
double diff = matrix[idx] - mean_col;
|
|
variance_sum += diff * diff; //obtenemos la variacion Suma
|
|
}
|
|
|
|
double variance = variance_sum / (rows); // ddof=0
|
|
double std_val = sqrt(variance); //valor del std
|
|
|
|
// Evitar división por cero
|
|
std[col] = (std_val < min_value) ? 1.0 : std_val;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
__kernel void standar_scaler_fit_transform_vector(
|
|
const double mean,
|
|
const double std,
|
|
__global double* X_to_scale
|
|
)
|
|
{
|
|
uint idx = get_global_id(0);
|
|
X_to_scale[idx] = (X_to_scale[idx] - mean) / std;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
__kernel void standard_scaler_tranform_matrix(
|
|
__global const double* mean,
|
|
__global const double* std,
|
|
__global double* matrix,
|
|
const entero_unsigned cols
|
|
)
|
|
{
|
|
//2 dimensiones
|
|
const uint row = get_global_id(0);
|
|
const uint col = get_global_id(1);
|
|
|
|
entero_unsigned idx = row * cols + col;
|
|
|
|
// La compprobacion ya se hace en init
|
|
matrix[idx] = (matrix[idx] - mean[col]) / std[col];
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
__kernel void standard_scaler_tranform_vector(
|
|
__global const double* mean,
|
|
__global const double* std,
|
|
__global double* vector
|
|
)
|
|
{
|
|
const uint idx = get_global_id(0);
|
|
// esta funcion ya esta cargada por lo que std ya esta corregido (si es que era muy pequeño)
|
|
vector[idx] = (vector[idx] - mean[idx]) / std[idx];
|
|
}
|
|
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
__kernel void standard_scaler_inverse_tranform_matrix(
|
|
__global const double* mean,
|
|
__global const double* std,
|
|
__global double* matrix,
|
|
const entero_unsigned cols
|
|
)
|
|
{
|
|
//2 dimensiones
|
|
uint row = get_global_id(0);
|
|
uint col = get_global_id(1);
|
|
|
|
entero_unsigned idx = row * cols + col;
|
|
matrix[idx] = matrix[idx] * std[col] + mean[col];
|
|
} //X_unscaled[row][col] = X_to_unscale[row][col] * this.std[col] + this.mean[col];
|
|
|
|
//+------------------------------------------------------------------+
|
|
__kernel void standard_scaler_inverse_tranform_vector(
|
|
__global const double* mean,
|
|
__global const double* std,
|
|
__global double* vector
|
|
)
|
|
{
|
|
uint idx = get_global_id(0);
|
|
vector[idx] = vector[idx] * std[idx] + mean[idx] ;
|
|
} //X_unscaled[i] = X_to_unscale[i] * this.std[i] + this.mean[i];
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
__kernel void fit_scaler_max_min_init(
|
|
__global double* min_values, // Output: [cols]
|
|
__global double* max_values, // Output: [cols]
|
|
__global const double* matrix, // Input: [rows * cols]
|
|
const entero_unsigned cols,
|
|
const entero_unsigned rows
|
|
)
|
|
{
|
|
const uint col = get_global_id(0); // Solo una dimensión
|
|
|
|
// variables inicales
|
|
double max_col = DBL_MIN;
|
|
double min_col = DBL_MAX;
|
|
|
|
// Macro incial
|
|
#define value(prow , pcol) matrix[prow * cols + pcol]
|
|
|
|
|
|
// Encontramos el miaxmo y minimo
|
|
for(int i = 0; i < rows; i++)
|
|
{
|
|
const double val = value(i, col);
|
|
if(val > max_col)
|
|
max_col = val;
|
|
|
|
if(val < min_col)
|
|
min_col = val;
|
|
}
|
|
|
|
// Correcion de valores pequeños
|
|
if(max_col - min_col < min_value)
|
|
max_col = min_col + 1.0;
|
|
|
|
// Escritura
|
|
max_values[col] = max_col;
|
|
min_values[col] = min_col;
|
|
#undef value
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
__kernel void max_min_scaler_fit_transform_vector(
|
|
const double min_data,
|
|
const double max_data,
|
|
__global double* vector
|
|
)
|
|
{
|
|
const uint idx = get_global_id(0); // Indice en la primera dimension
|
|
vector[idx] = (vector[idx] - min_data) / (max_data - min_data); // la comprobacion de division se hace en mql
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
__kernel void max_min_scaler_tranform_matrix(
|
|
__global const double* min_values, //vector
|
|
__global const double* max_values, // vector
|
|
__global double* matrix, // matriz
|
|
const entero_unsigned cols
|
|
)
|
|
{
|
|
//2 dimensiones
|
|
const uint row = get_global_id(0);
|
|
const uint col = get_global_id(1);
|
|
|
|
entero_unsigned idx = row * cols + col;
|
|
// la comprobacion de rango se ha hecho en init (los valores ya estan corregidos)
|
|
matrix[idx] = (matrix[idx] - min_values[col]) / (max_values[col] - min_values[col]);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
__kernel void max_min_scaler_tranform_vector(
|
|
__global const double* min_values,
|
|
__global const double* max_values,
|
|
__global double* vector
|
|
)
|
|
{
|
|
const uint idx = get_global_id(0);
|
|
// esta funcion ya esta cargada por lo que range ya esta corregido (si es que era muy pequeño)
|
|
vector[idx] = (vector[idx] - min_values[idx]) / (max_values[idx] - min_values[idx]);
|
|
}
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
__kernel void min_max_inverse_tranform_matrix(
|
|
__global const double* min_values,
|
|
__global const double* max_values,
|
|
__global double* matrix,
|
|
const entero_unsigned cols
|
|
)
|
|
{
|
|
//2 dimensiones
|
|
const uint row = get_global_id(0);
|
|
const uint col = get_global_id(1);
|
|
|
|
entero_unsigned idx = row * cols + col;
|
|
matrix[idx] = matrix[idx] * (max_values[col] - min_values[col]) + min_values[col];
|
|
}
|
|
// X_unscaled[row][col] = X_to_unscale[row][col] * (this.max_vals[col] - this.min_vals[col]) + this.min_vals[col];
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
__kernel void max_min_scaler_inverse_tranform_vector(
|
|
__global const double* min_values,
|
|
__global const double* max_values,
|
|
__global double* vector
|
|
)
|
|
{
|
|
const uint idx = get_global_id(0);
|
|
vector[idx] = vector[idx] * (max_values[idx] - min_values[idx]) + min_values[idx];
|
|
} // X_unscaled[i] = X_to_unscale[i] * (this.max_vals[i] - this.min_vals[i]) + this.min_vals[i];
|
|
|
|
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
__kernel void ExtractMatrixToScaler(
|
|
__global const double* data, //solo lectura
|
|
__global double* result, //Escritura y lectura
|
|
const entero_unsigned rows_data,
|
|
const entero_unsigned cols_data,
|
|
const entero_unsigned rows_res,
|
|
const entero_unsigned cols_res,
|
|
const entero_unsigned cols_to_escale, //numero de columnas a extraer desde el inicio
|
|
const entero_unsigned start_col
|
|
)
|
|
{
|
|
uint row = get_global_id(0);
|
|
uint col = get_global_id(1);
|
|
|
|
entero_unsigned idx_data = row * cols_data + (col + start_col);
|
|
entero_unsigned idx_res = row * cols_res + col; // Asumiendo mismas dimensiones
|
|
result[idx_res] = data[idx_data];
|
|
}
|
|
|
|
/*
|
|
//+------------------------------------------------------------------+
|
|
matrix ScalerBase::ExtractMatrixToScale(const matrix &X) const
|
|
{
|
|
matrix result;
|
|
|
|
if(use_custom)
|
|
{
|
|
result.Init(X.Rows(), count_cols);
|
|
|
|
for(entero_unsigned row = 0; row < X.Rows(); row++)
|
|
for(entero_unsigned col = 0; col < count_cols; col++)
|
|
result[row][col] = X[row][start_col + col];
|
|
}
|
|
else
|
|
{
|
|
entero_unsigned cols_to_scale = X.Cols() - excluyed_cols;
|
|
result.Init(X.Rows(), cols_to_scale);
|
|
|
|
for(entero_unsigned row = 0; row < X.Rows(); row++)
|
|
for(entero_unsigned col = 0; col < cols_to_scale; col++)
|
|
result[row][col] = X[row][col];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
*/
|
|
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
__kernel void ExtractVectorToScale(
|
|
__global const double* data,
|
|
__global double* result,
|
|
const entero_unsigned start_col,
|
|
const entero_unsigned count_cols
|
|
)
|
|
{
|
|
uint idx = get_global_id(0);
|
|
result[idx] = data[start_col + idx];
|
|
}
|
|
/*
|
|
//+------------------------------------------------------------------+
|
|
vector ScalerBaseCL::ExtractVectorToScale(const vector &X) const
|
|
{
|
|
vector result;
|
|
|
|
if(use_custom)
|
|
{
|
|
// Extraer rango específico
|
|
result.Resize(count_cols);
|
|
for(entero_unsigned i = 0; i < count_cols; i++)
|
|
result[i] = X[start_col + i];
|
|
}
|
|
else
|
|
{
|
|
// Extraer todas excepto las últimas N
|
|
entero_unsigned size_to_scale = X.Size() - excluyed_cols;
|
|
result.Resize(size_to_scale);
|
|
for(entero_unsigned i = 0; i < size_to_scale; i++)
|
|
result[i] = X[i];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
*/
|
|
//+------------------------------------------------------------------+
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
__kernel void ReconstructVector(
|
|
__global const double* data, //data
|
|
__global double* result, //resultado
|
|
const entero_unsigned start_col,
|
|
const entero_unsigned count_cols
|
|
)
|
|
{
|
|
uint idx = get_global_id(0);
|
|
result[idx + start_col] = data[idx]; //No es necesario comprobar ya se da eltamaño
|
|
}
|
|
/*
|
|
//+------------------------------------------------------------------+
|
|
vector ScalerBaseCL::ReconstructVector(const vector &X_original, const vector &X_scaled) const
|
|
{
|
|
vector result = X_original;
|
|
|
|
if(use_custom)
|
|
{
|
|
// Reemplazar rango específico
|
|
for(entero_unsigned i = 0; i < count_cols; i++)
|
|
result[start_col + i] = X_scaled[i];
|
|
}
|
|
else
|
|
{
|
|
// Reemplazar todas excepto las últimas N
|
|
for(entero_unsigned i = 0; i < X_scaled.Size(); i++)
|
|
result[i] = X_scaled[i];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
*/
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
__kernel void ReconstructMatrix(
|
|
__global const double* scaled_data, // X_scaled
|
|
__global double* original_result, // X_original
|
|
const entero_unsigned rows_data,
|
|
const entero_unsigned cols_data,
|
|
const entero_unsigned rows_res,
|
|
const entero_unsigned cols_res,
|
|
const entero_unsigned cols_to_insert, // Columnas a insertar
|
|
const entero_unsigned start_col // Posición donde insertar
|
|
)
|
|
{
|
|
uint row = get_global_id(0);
|
|
uint col = get_global_id(1);
|
|
|
|
// Leer desde X_scaled
|
|
entero_unsigned idx_scaled = row * cols_to_insert + col;
|
|
|
|
// Escribir en X_original en posición específica
|
|
entero_unsigned target_col = start_col + col;
|
|
|
|
|
|
entero_unsigned idx_result = row * cols_res + target_col;
|
|
|
|
original_result[idx_result] = scaled_data[idx_scaled];
|
|
}
|
|
/*
|
|
//+------------------------------------------------------------------+
|
|
matrix ScalerBaseCL::ReconstructMatrix(const matrix &X_original, const matrix &X_scaled) const
|
|
{
|
|
matrix result = X_original; // Copia completa
|
|
|
|
if(use_custom)
|
|
{
|
|
for(entero_unsigned row = 0; row < X_original.Rows(); row++)
|
|
for(entero_unsigned col = 0; col < count_cols; col++)
|
|
result[row][start_col + col] = X_scaled[row][col];
|
|
}
|
|
else
|
|
{
|
|
for(entero_unsigned row = 0; row < X_original.Rows(); row++)
|
|
for(entero_unsigned col = 0; col < X_scaled.Cols(); col++)
|
|
result[row][col] = X_scaled[row][col];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
*/
|
|
//+------------------------------------------------------------------+
|