use crate::api::ModelError;
use crate::artifact::{
ArtifactCursor, ArtifactError, ArtifactPayloadWriter, MODEL_ARTIFACT_VERSION, SchemaRole,
artifact_version, decode_component, decode_v2_envelope, encode_component, encode_v2_envelope,
};
use crate::data::{DenseMatrix, MatrixView};
const STACK_PREFLIGHT_FEATURES: usize = 256;
const MAX_ARTIFACT_FEATURES: usize = 1_000_000;
pub(super) const BASE_PAYLOAD_VERSION: u16 = 1;
const STATE_COMPONENT_KIND: u16 = 1;
const STATE_COMPONENT_VERSION: u16 = 1;
pub(super) fn substituted_divisor(spread: f64) -> f64 {
if spread == 0.0 { 1.0 } else { spread }
}
pub(super) fn validate_inverse_request(
n_features_in: usize,
data: &MatrixView<'_>,
output: &[f32],
) -> Result<usize, ModelError> {
validate_transform_request(n_features_in, data, output)
}
pub(super) fn inverse_transform_allocating(
n_features_in: usize,
data: &MatrixView<'_>,
inverse: impl FnOnce(&MatrixView<'_>, &mut [f32]) -> Result<(), ModelError>,
) -> Result<DenseMatrix, ModelError> {
let len = data
.rows()
.checked_mul(n_features_in)
.ok_or(ModelError::OutputShapeOverflow {
rows: data.rows(),
columns: n_features_in,
})?;
let mut output = vec![0.0; len];
inverse(data, &mut output)?;
Ok(DenseMatrix::from_validated_parts(
output,
data.rows(),
n_features_in,
))
}
pub(super) fn transform_preflighted<'output, F>(
data: &MatrixView<'_>,
output: &'output mut [f32],
transform: F,
) -> Result<MatrixView<'output>, ModelError>
where
F: Fn(f32, usize) -> f32 + Copy,
{
if !extrema_are_safe(data, transform) {
for (row_index, row) in data.iter_rows().enumerate() {
for (column, &value) in row.iter().enumerate() {
if !transform(value, column).is_finite() {
return Err(ModelError::NonFiniteTransform {
row: row_index,
column,
});
}
}
}
}
for (row, output_row) in data
.iter_rows()
.zip(output.chunks_exact_mut(data.columns()))
{
for (column, (&value, slot)) in row.iter().zip(output_row).enumerate() {
*slot = transform(value, column);
}
}
Ok(MatrixView::from_validated_parts(
output,
data.rows(),
data.columns(),
))
}
fn extrema_are_safe<F>(data: &MatrixView<'_>, transform: F) -> bool
where
F: Fn(f32, usize) -> f32,
{
if data.columns() > STACK_PREFLIGHT_FEATURES {
return false;
}
let mut minima = [f32::INFINITY; STACK_PREFLIGHT_FEATURES];
let mut maxima = [f32::NEG_INFINITY; STACK_PREFLIGHT_FEATURES];
for row in data.iter_rows() {
for (column, &value) in row.iter().enumerate() {
minima[column] = minima[column].min(value);
maxima[column] = maxima[column].max(value);
}
}
(0..data.columns()).all(|column| {
transform(minima[column], column).is_finite()
&& transform(maxima[column], column).is_finite()
})
}
pub(super) fn encode_scaler_artifact(
kind: u16,
input_schema: [u8; 32],
transformed_schema: [u8; 32],
n_features_in: usize,
parameters: ScalerParameters<'_>,
fields_per_feature: usize,
mut write_feature: impl FnMut(usize, &mut ArtifactPayloadWriter),
) -> Result<Vec<u8>, ArtifactError> {
let ScalerParameters {
version,
flags,
reals,
} = parameters;
if n_features_in > MAX_ARTIFACT_FEATURES {
return Err(ArtifactError::InvalidPayload);
}
let count = u32::try_from(n_features_in).map_err(|_| ArtifactError::InvalidPayload)?;
let capacity = 8 + flags.len() * 4 + reals.len() * 8 + n_features_in * fields_per_feature * 8;
let mut state = ArtifactPayloadWriter::with_capacity(capacity);
state.u32(count);
for &flag in flags {
state.u32(flag);
}
for &real in reals {
state.f64(real);
}
state.u32(count);
for feature in 0..n_features_in {
write_feature(feature, &mut state);
}
let component = encode_component(
STATE_COMPONENT_KIND,
STATE_COMPONENT_VERSION,
&state.finish(),
)?;
encode_v2_envelope(
kind,
version,
&[
(SchemaRole::Input, input_schema),
(SchemaRole::Transformed, transformed_schema),
],
&component,
)
}
pub(super) struct ScalerParameters<'a> {
pub version: u16,
pub flags: &'a [u32],
pub reals: &'a [f64],
}
pub(super) struct ScalerHeader<'a> {
pub n_features_in: usize,
pub flags: Vec<u32>,
pub parameters: Vec<f64>,
pub state: ArtifactCursor<'a>,
}
pub(super) fn decode_scaler_artifact<'a>(
bytes: &'a [u8],
kind: u16,
input_schema: [u8; 32],
transformed_schema: [u8; 32],
payload_version: u16,
flag_count: usize,
parameter_count: usize,
) -> Result<ScalerHeader<'a>, ArtifactError> {
let version = artifact_version(bytes)?;
if version != MODEL_ARTIFACT_VERSION {
return Err(ArtifactError::UnsupportedVersion { found: version });
}
let mut envelope = decode_v2_envelope(
bytes,
kind,
payload_version,
&[
(SchemaRole::Input, input_schema),
(SchemaRole::Transformed, transformed_schema),
],
)?;
let mut state = decode_component(&mut envelope, STATE_COMPONENT_KIND, STATE_COMPONENT_VERSION)?;
if !envelope.is_empty() {
return Err(ArtifactError::TrailingBytes);
}
let n_features_in = state.u32()? as usize;
let mut flags = Vec::with_capacity(flag_count);
for _ in 0..flag_count {
flags.push(state.u32()?);
}
let mut parameters = Vec::with_capacity(parameter_count);
for _ in 0..parameter_count {
parameters.push(state.f64()?);
}
let count = state.u32()? as usize;
if n_features_in == 0 || n_features_in > MAX_ARTIFACT_FEATURES || count != n_features_in {
return Err(ArtifactError::InvalidPayload);
}
Ok(ScalerHeader {
n_features_in,
flags,
parameters,
state,
})
}
pub(super) fn decode_flag(value: u32) -> Result<bool, ArtifactError> {
match value {
0 => Ok(false),
1 => Ok(true),
_ => Err(ArtifactError::InvalidPayload),
}
}
pub(super) fn validate_transform_request(
n_features_in: usize,
data: &MatrixView<'_>,
output: &[f32],
) -> Result<usize, ModelError> {
if data.columns() != n_features_in {
return Err(ModelError::FeatureDimension {
expected: n_features_in,
actual: data.columns(),
});
}
let expected =
data.rows()
.checked_mul(n_features_in)
.ok_or(ModelError::OutputShapeOverflow {
rows: data.rows(),
columns: n_features_in,
})?;
if output.len() != expected {
return Err(ModelError::OutputLength {
expected,
actual: output.len(),
});
}
Ok(expected)
}