Struct LogisticRegression 

pub struct LogisticRegression {
    pub learning_rate: f32,
    pub bias: f32,
    pub weights: Vec<f32>,
    pub l1: f32,
    pub l2: f32,
    pub features: HashMap<Bytes, usize>,
    pub trained: bool,
    pub original_ngrams: u32,
    pub file_type: FileType,
    pub train_performance: PerformanceStats,
    pub test_performance: Option<PerformanceStats>,
    /* private fields */
}

Machine learning model using logistic regression

Fields

learning_rate: f32

Learning rate

bias: f32

Bias term

weights: Vec<f32>

Model’s weights

l1: f32

L1 LASSO regularization

l2: f32

L2 Ridge regularization

features: HashMap<Bytes, usize>

N-grams used to train the model

trained: bool

If the model has been trained

original_ngrams: u32

Amount of n-grams originally used

file_type: FileType

The type of file this model is trained on

train_performance: PerformanceStats

How well the model performed on the training dataset

test_performance: Option<PerformanceStats>

How well the model performed on the testing dataset

Implementations

impl LogisticRegression

pub fn new(input_size: usize, learning_rate: f32, l1: f32, l2: f32) -> Self

New logistic regression model with random initial weights from given parameters.

pub fn new_from_dataset_and_train( dataset: &mut Dataset, test: Option<&Dataset>, epochs: u32, learning_rate: f32, l1: f32, l2: f32, ) -> (Self, f32)

Returns a trained logistic regression model from given parameters and dataset. Returns the model and the error value from the last epoch.

Panics

This code won’t panic, but LogisticRegression::train would panic if the data sizes were different, but that can’t happen in this case since the same object is used in both places.

pub fn predict(&self, input: &[f32]) -> f32

Predicts the output for a given input vector. This will fail if the input vector isn’t the same length as the weights vector.

pub fn train( &mut self, epochs: u32, dataset: &mut Dataset, ) -> Result<f32, &'static str>

Trains the classifier once with the given inputs and outputs.

A mutable reference is required because the dataset is shuffled in place each epoch.

Errors

Returns an error if the data isn’t the correct size or if labels are missing.

pub fn evaluate_dataset<'a>( &self, dataset: &'a Dataset, ) -> Result<ConfusionMatrix<'a>>

Evaluate a dataset

Errors

If the dataset doesn’t match the model weight length or doesn’t have labels

pub fn evaluate_file<P: AsRef<Path>>( &self, path: P, ) -> Result<(&'static str, f32, u32)>

Evaluate a file

Errors

Errors will result if the model doesn’t have features or if the sample file can’t be read

pub fn reduce(&mut self, dataset: &Dataset) -> Result<usize>

Remove small weights (from regularization), returns the number of weights removed

Errors

There’s an error if the model is not trained

pub fn set_features(&mut self, features: Vec<Bytes>) -> Result<()>

Set the features by adding to the struct

Errors

Returns an error if the number of weights and features doesn’t match

pub fn set_features_and_reduce(&mut self, dataset: &Dataset) -> Result<usize>

Convenience function to get the features from the dataset then reduce based on the dataset.

Errors

An error occurs if the conditions below aren’t met:

• Ensures the number of model weights matches the dataset features
• Ensures the file types match

pub fn with_features(self, features: Vec<Bytes>) -> Result<Self>

Set the features by creating a new struct which has the features

Errors

Returns an error if the number of weights and features doesn’t match

Trait Implementations

impl Clone for LogisticRegression

fn clone(&self) -> LogisticRegression

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LogisticRegression

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LogisticRegression

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LogisticRegression

fn eq(&self, other: &LogisticRegression) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for LogisticRegression

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LogisticRegression