ttv 0.4.0

Create train, test and validation sets from text files
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use std::ops::Deref;
use std::str::FromStr;

use crate::error::{Error, Result};

/// Represents a single 'split' of data
pub trait Split {
    /// Get the name of the split.
    fn name(&self) -> &str;
}

/// A split based on a proportion.
#[derive(Clone, Debug)]
pub struct ProportionSplit {
    /// The split name. Will be used as the filename for the split.
    name: String,
    /// The proportion of data that should be directed to this split.
    pub proportion: f64,
}

impl Split for ProportionSplit {
    fn name(&self) -> &str {
        &self.name
    }
}

impl FromStr for ProportionSplit {
    type Err = Error;

    /// Create a ProportionSplit from a string specification, such as
    /// "train=0.8".
    fn from_str(spec: &str) -> Result<Self> {
        let split: Vec<&str> = spec.split('=').collect();
        if split.len() != 2 {
            return Err(Error::InvalidSplitSpecification(spec.to_string()));
        }
        let proportion = split[1]
            .parse::<f64>()
            .map_err(|_| Error::InvalidSplitSpecification(spec.to_string()))?;
        if proportion <= 0.0 {
            return Err(Error::ProportionTooLow(spec.to_string()));
        } else if proportion > 1.0 {
            return Err(Error::ProportionTooHigh(spec.to_string()));
        }
        Ok(ProportionSplit {
            name: split[0].to_string(),
            proportion,
        })
    }
}

/// A split based on a number of rows
#[derive(Clone, Debug)]
pub struct RowSplit {
    /// The split name. Will be used as the filename for the split.
    name: String,
    /// The total number of rows to send to this split.
    /// Stored as an f64 for optimization reasons.
    pub total: f64,
    /// The number of rows sent to this split so far.
    pub done: f64,
}

impl Split for RowSplit {
    fn name(&self) -> &str {
        &self.name
    }
}

impl FromStr for RowSplit {
    type Err = Error;

    /// Create a ProportionSplit from a string specification, such as
    /// "train=0.8".
    fn from_str(spec: &str) -> Result<Self> {
        let split: Vec<&str> = spec.split('=').collect();
        if split.len() != 2 {
            return Err(Error::InvalidSplitSpecification(spec.to_string()));
        }
        let total = split[1]
            .parse::<u64>()
            .map(|total| total as f64)
            .map_err(|_| Error::InvalidSplitSpecification(spec.to_string()))?;
        Ok(RowSplit {
            name: split[0].to_string(),
            total,
            done: 0.0,
        })
    }
}

pub enum SplitEnum {
    Rows(RowSplit),
    Proportion(ProportionSplit),
}

impl Deref for SplitEnum {
    type Target = dyn Split;
    fn deref(&self) -> &Self::Target {
        match self {
            SplitEnum::Rows(r) => r,
            SplitEnum::Proportion(p) => p,
        }
    }
}