use crate::api::{Capabilities, Estimator, HasCapabilities, HasParams, ModelError, Transformer};
use crate::artifact::{ArtifactError, POLYNOMIAL_FEATURES_ARTIFACT_KIND, StageArtifact};
use crate::data::MatrixView;
use super::expansion::{
MAX_EXPANDED_FEATURES, binomial, column_magnitude_bounds, expand_allocating,
expand_preflighted, validate_expansion_request,
};
use super::scaling::{
BASE_PAYLOAD_VERSION, ScalerHeader, ScalerParameters, decode_flag, decode_scaler_artifact,
encode_scaler_artifact,
};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct PolynomialFeaturesParams {
degree: u32,
interaction_only: bool,
include_bias: bool,
}
impl Default for PolynomialFeaturesParams {
fn default() -> Self {
Self {
degree: 2,
interaction_only: false,
include_bias: true,
}
}
}
impl PolynomialFeaturesParams {
#[must_use]
pub const fn with_degree(mut self, degree: u32) -> Self {
self.degree = degree;
self
}
#[must_use]
pub const fn with_interaction_only(mut self, interaction_only: bool) -> Self {
self.interaction_only = interaction_only;
self
}
#[must_use]
pub const fn with_include_bias(mut self, include_bias: bool) -> Self {
self.include_bias = include_bias;
self
}
#[must_use]
pub const fn degree(&self) -> u32 {
self.degree
}
#[must_use]
pub const fn interaction_only(&self) -> bool {
self.interaction_only
}
#[must_use]
pub const fn include_bias(&self) -> bool {
self.include_bias
}
const fn validate(&self) -> Result<(), ModelError> {
if self.degree == 0 && !self.include_bias {
return Err(ModelError::EmptyFeatureExpansion);
}
Ok(())
}
fn expanded_width(&self, n_features: usize) -> Option<usize> {
let mut total = usize::from(self.include_bias);
for degree in 1..=self.degree as usize {
let block = if self.interaction_only {
binomial(n_features, degree)?
} else if n_features == 0 {
0
} else {
binomial(n_features + degree - 1, degree)?
};
total = total.checked_add(block)?;
if total > MAX_EXPANDED_FEATURES {
return None;
}
}
Some(total)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PolynomialFeatures {
n_features_in: usize,
params: PolynomialFeaturesParams,
n_features_out: usize,
term_features: Vec<u32>,
term_offsets: Vec<u32>,
}
impl PolynomialFeatures {
pub fn fit(
data: &MatrixView<'_>,
params: PolynomialFeaturesParams,
) -> Result<Self, ModelError> {
Self::describe(data.columns(), params)
}
fn describe(
n_features_in: usize,
params: PolynomialFeaturesParams,
) -> Result<Self, ModelError> {
params.validate()?;
let n_features_out =
params
.expanded_width(n_features_in)
.ok_or(ModelError::FeatureExpansionOverflow {
n_features: n_features_in,
degree: params.degree,
})?;
let mut term_features = Vec::new();
let mut term_offsets = Vec::with_capacity(n_features_out + 1);
term_offsets.push(0);
if params.include_bias {
term_offsets.push(0);
}
for degree in 1..=params.degree as usize {
push_terms(
n_features_in,
degree,
params.interaction_only,
&mut term_features,
&mut term_offsets,
);
}
debug_assert_eq!(
term_offsets.len() - 1,
n_features_out,
"the generated term count left the width formula"
);
Ok(Self {
n_features_in,
params,
n_features_out,
term_features,
term_offsets,
})
}
#[must_use]
pub const fn n_features_in(&self) -> usize {
self.n_features_in
}
#[must_use]
pub const fn n_features_out(&self) -> usize {
self.n_features_out
}
#[must_use]
pub const fn get_params(&self) -> &PolynomialFeaturesParams {
&self.params
}
pub fn transform_into<'output>(
&self,
data: &MatrixView<'_>,
output: &'output mut [f32],
) -> Result<MatrixView<'output>, ModelError> {
<Self as Transformer>::transform_into(self, data, output)
}
pub fn transform(&self, data: &MatrixView<'_>) -> Result<crate::data::DenseMatrix, ModelError> {
expand_allocating(self.n_features_out, data, |batch, output| {
self.transform_into(batch, output).map(|_| ())
})
}
fn monomial(&self, row: &[f32], column: usize) -> f32 {
let start = self.term_offsets[column] as usize;
let end = self.term_offsets[column + 1] as usize;
let mut product = 1.0_f64;
for &feature in &self.term_features[start..end] {
product *= f64::from(row[feature as usize]);
}
product as f32
}
fn batch_is_proven_finite(&self, data: &MatrixView<'_>) -> bool {
let Some(bounds) = column_magnitude_bounds(data) else {
return false;
};
(0..self.n_features_out).all(|column| {
let start = self.term_offsets[column] as usize;
let end = self.term_offsets[column + 1] as usize;
let mut product = 1.0_f64;
for &feature in &self.term_features[start..end] {
product *= bounds[feature as usize];
}
(product as f32).is_finite()
})
}
}
fn push_terms(
n_features: usize,
degree: usize,
interaction_only: bool,
term_features: &mut Vec<u32>,
term_offsets: &mut Vec<u32>,
) {
if n_features == 0 || (interaction_only && degree > n_features) {
return;
}
let mut tuple: Vec<usize> = if interaction_only {
(0..degree).collect()
} else {
vec![0; degree]
};
loop {
for &feature in &tuple {
term_features.push(feature as u32);
}
term_offsets.push(term_features.len() as u32);
let mut position = degree;
let advanced = loop {
if position == 0 {
break false;
}
position -= 1;
let ceiling = if interaction_only {
n_features - degree + position
} else {
n_features - 1
};
if tuple[position] < ceiling {
tuple[position] += 1;
for later in position + 1..degree {
tuple[later] = if interaction_only {
tuple[later - 1] + 1
} else {
tuple[position]
};
}
break true;
}
};
if !advanced {
return;
}
}
}
impl StageArtifact for PolynomialFeatures {
const ARTIFACT_KIND: u16 = POLYNOMIAL_FEATURES_ARTIFACT_KIND;
fn to_artifact(
&self,
input_schema: [u8; 32],
transformed_schema: [u8; 32],
) -> Result<Vec<u8>, ArtifactError> {
encode_scaler_artifact(
Self::ARTIFACT_KIND,
input_schema,
transformed_schema,
self.n_features_in,
ScalerParameters {
version: BASE_PAYLOAD_VERSION,
flags: &[
u32::from(self.params.interaction_only),
u32::from(self.params.include_bias),
self.params.degree,
],
reals: &[],
},
0,
|_, _| {},
)
}
fn from_artifact(
bytes: &[u8],
input_schema: [u8; 32],
transformed_schema: [u8; 32],
) -> Result<Self, ArtifactError> {
let ScalerHeader {
n_features_in,
flags,
state,
..
} = decode_scaler_artifact(
bytes,
Self::ARTIFACT_KIND,
input_schema,
transformed_schema,
BASE_PAYLOAD_VERSION,
3,
0,
)?;
if !state.is_empty() {
return Err(ArtifactError::TrailingBytes);
}
let params = PolynomialFeaturesParams {
interaction_only: decode_flag(flags[0])?,
include_bias: decode_flag(flags[1])?,
degree: flags[2],
};
Self::describe(n_features_in, params).map_err(|_| ArtifactError::InvalidPayload)
}
}
impl Estimator for PolynomialFeatures {
fn n_features_in(&self) -> usize {
self.n_features_in
}
}
impl HasCapabilities for PolynomialFeatures {
const CAPABILITIES: Capabilities = Capabilities::NONE.with_artifact(true);
}
impl HasParams for PolynomialFeatures {
type Params = PolynomialFeaturesParams;
fn get_params(&self) -> &Self::Params {
&self.params
}
}
impl Transformer for PolynomialFeatures {
fn n_features_out(&self) -> usize {
self.n_features_out
}
fn transform_into<'output>(
&self,
data: &MatrixView<'_>,
output: &'output mut [f32],
) -> Result<MatrixView<'output>, ModelError> {
validate_expansion_request(self.n_features_in, self.n_features_out, data, output)?;
expand_preflighted(
data,
output,
self.n_features_out,
self.batch_is_proven_finite(data),
|row, column| self.monomial(row, column),
)
}
}
#[cfg(test)]
mod tests;