Struct BCECriterion 

pub struct BCECriterion { /* private fields */ }

The binary cross entropy criterion.

Uses the Sigmoid activation function and the cross entropy error.

Implementations

impl BCECriterion

pub fn new(regularization: Regularization<f64>) -> Self

Constructs a new BCECriterion with the given regularization.

Examples

use rusty_machine::learning::nnet::BCECriterion;
use rusty_machine::learning::toolkit::regularization::Regularization;

// Create a new BCE criterion with L2 regularization of 0.3.
let criterion = BCECriterion::new(Regularization::L2(0.3f64));

Examples found in repository

examples/nnet-and_gate.rs (line 43)

fn main() {
    println!("AND gate learner sample:");

    const THRESHOLD: f64 = 0.7;

    const SAMPLES: usize = 10000;
    println!("Generating {} training data and labels...", SAMPLES as u32);

    let mut input_data = Vec::with_capacity(SAMPLES * 2);
    let mut label_data = Vec::with_capacity(SAMPLES);

    for _ in 0..SAMPLES {
        // The two inputs are "signals" between 0 and 1
        let Closed01(left) = random::<Closed01<f64>>();
        let Closed01(right) = random::<Closed01<f64>>();
        input_data.push(left);
        input_data.push(right);
        if left > THRESHOLD && right > THRESHOLD {
            label_data.push(1.0);
        } else {
            label_data.push(0.0)
        }
    }

    let inputs = Matrix::new(SAMPLES, 2, input_data);
    let targets = Matrix::new(SAMPLES, 1, label_data);

    let layers = &[2, 1];
    let criterion = BCECriterion::new(Regularization::L2(0.));
    let mut model = NeuralNet::new(layers, criterion, StochasticGD::default());

    println!("Training...");
    // Our train function returns a Result<(), E>
    model.train(&inputs, &targets).unwrap();

    let test_cases = vec![
        0.0, 0.0,
        0.0, 1.0,
        1.0, 1.0,
        1.0, 0.0,
        ];
    let expected = vec![
        0.0,
        0.0,
        1.0,
        0.0,
        ];
    let test_inputs = Matrix::new(test_cases.len() / 2, 2, test_cases);
    let res = model.predict(&test_inputs).unwrap();

    println!("Evaluation...");
    let mut hits = 0;
    let mut misses = 0;
    // Evaluation
    println!("Got\tExpected");
    for (idx, prediction) in res.into_vec().iter().enumerate() {
        println!("{:.2}\t{}", prediction, expected[idx]);
        if (prediction - 0.5) * (expected[idx] - 0.5) > 0. {
            hits += 1;
        } else {
            misses += 1;
        }
    }

    println!("Hits: {}, Misses: {}", hits, misses);
    let hits_f = hits as f64;
    let total = (hits + misses) as f64;
    println!("Accuracy: {}%", (hits_f / total) * 100.);
}

Trait Implementations

impl Clone for BCECriterion

fn clone(&self) -> BCECriterion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Criterion for BCECriterion

type ActFunc = Sigmoid

The activation function for the criterion.

type Cost = CrossEntropyError

The cost function for the criterion.

fn regularization(&self) -> Regularization<f64>

Returns the regularization for this criterion.

fn activate(&self, mat: Matrix<f64>) -> Matrix<f64>

The activation function applied to a matrix.

fn grad_activ(&self, mat: Matrix<f64>) -> Matrix<f64>

The gradient of the activation function applied to a matrix.

fn cost(&self, outputs: &Matrix<f64>, targets: &Matrix<f64>) -> f64

The cost function.

fn cost_grad(&self, outputs: &Matrix<f64>, targets: &Matrix<f64>) -> Matrix<f64>

The gradient of the cost function.

fn is_regularized(&self) -> bool

Checks if the current criterion includes regularization.

fn reg_cost(&self, reg_weights: MatrixSlice<'_, f64>) -> f64

Returns the regularization cost for the criterion.

fn reg_cost_grad(&self, reg_weights: MatrixSlice<'_, f64>) -> Matrix<f64>

Returns the regularization gradient for the criterion.

impl Debug for BCECriterion

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

Formats the value using the given formatter.

impl Default for BCECriterion

Creates an MSE Criterion without any regularization.

fn default() -> Self

Returns the “default value” for a type.

impl Copy for BCECriterion