reductionml-core 0.1.0

Reduction based machine learning toolkit core library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

use crate::{hash::hash_bytes, sparse_namespaced_features::Namespace};

#[derive(Serialize, Deserialize, Clone, JsonSchema, Debug)]
pub enum NamespaceDef {
    Name(String),
    Default,
}

pub type Interaction = Vec<NamespaceDef>;
pub type HashedInteraction = Vec<Namespace>;

pub fn hash_interaction(interaction: &Interaction, hash_seed: u32) -> HashedInteraction {
    if interaction.is_empty() || interaction.len() > 3 {
        panic!("Interaction must be between 1 and 3 namespaces")
    }
    interaction
        .iter()
        .map(|ns| match ns {
            NamespaceDef::Name(name) => {
                let namespace_hash = hash_bytes(name.as_bytes(), hash_seed);
                Namespace::Named(namespace_hash.into())
            }
            NamespaceDef::Default => Namespace::Default,
        })
        .collect()
}

type InteractionPair = (Namespace, Namespace);
type InteractionTriple = (Namespace, Namespace, Namespace);

pub fn compile_interactions(
    interactions: &[Interaction],
    hash_seed: u32,
) -> (Vec<InteractionPair>, Vec<InteractionTriple>) {
    let pairs: Vec<(Namespace, Namespace)> = interactions
        .iter()
        .filter(|interaction| interaction.len() == 2)
        .map(|interaction| {
            let hashed_interaction = hash_interaction(interaction, hash_seed);
            (hashed_interaction[0], hashed_interaction[1])
        })
        .collect();

    let triples: Vec<(Namespace, Namespace, Namespace)> = interactions
        .iter()
        .filter(|interaction| interaction.len() == 3)
        .map(|interaction| {
            let hashed_interaction = hash_interaction(interaction, hash_seed);
            (
                hashed_interaction[0],
                hashed_interaction[1],
                hashed_interaction[2],
            )
        })
        .collect();

    if pairs.len() + triples.len() != interactions.len() {
        panic!("Invalid interaction. Only pairs and triples are supported")
    }

    (pairs, triples)
}