Skip to main content

JSON

runn::network::network_io

Struct JSON 

Source 
pub struct JSON {
    pub file_name: String,
    pub directory: String,
}
Expand description

A builder for configuring and creating a JSON network I/O exporter.

This struct provides a fluent interface to customize the file name and output directory for a JSON-encoded network representation. Use the build method to validate the configuration and return a concrete implementation of NetworkIO.

Fields§

§file_name: String§directory: String

Implementations§

Source§

impl JSON

Source

pub fn file_name(self, filename: &str) -> Self

Sets the base name for the output JSON file.

Examples found in repository?
examples/energy_efficiency/energy_efficiency.rs (line 70)
55fn train_and_validate(
56    training_inputs: &DMat, training_targets: &DMat, validation_inputs: &DMat, validation_targets: &DMat,
57) {
58    let network_file = format!("{}_network", EXP_NAME);
59
60    let mut network = energy_efficiency_network(training_inputs.cols(), training_targets.cols());
61
62    let training_result = network.train(training_inputs, training_targets);
63    match training_result {
64        Ok(_) => {
65            info!("Training successfully completed");
66            network
67                .save(
68                    JSON::default()
69                        .directory(EXP_NAME)
70                        .file_name(&network_file)
71                        .build()
72                        .unwrap(),
73                )
74                .unwrap();
75            let net_results = network.predict(training_inputs, training_targets).unwrap();
76            info!(
77                "{}",
78                helper::pretty_compare_matrices(
79                    training_inputs,
80                    training_targets,
81                    &net_results.predictions,
82                    helper::CompareMode::Regression
83                )
84            );
85            info!("Training: {}", net_results.display_metrics());
86        }
87        Err(e) => {
88            error!("Training failed: {}", e);
89        }
90    }
91
92    network = Network::load(
93        JSON::default()
94            .directory(EXP_NAME)
95            .file_name(&network_file)
96            .build()
97            .unwrap(),
98    )
99    .unwrap();
100    let net_results = network.predict(validation_inputs, validation_targets).unwrap();
101    log::info!(
102        "{}",
103        helper::pretty_compare_matrices(
104            validation_inputs,
105            validation_targets,
106            &net_results.predictions,
107            helper::CompareMode::Regression
108        )
109    );
110    info!("Validation: {}", net_results.display_metrics());
111}
More examples
Hide additional examples
examples/wine/wine.rs (line 72)
57fn train_and_validate(
58    training_inputs: &DMat, training_targets: &DMat, validation_inputs: &DMat, validation_targets: &DMat,
59) {
60    let network_file = format!("{}_network", EXP_NAME);
61
62    let mut network = one_hot_encode_network(training_inputs.cols(), training_targets.cols());
63
64    let training_result = network.train(training_inputs, training_targets);
65    match training_result {
66        Ok(_) => {
67            info!("Training successfully completed");
68            network
69                .save(
70                    JSON::default()
71                        .directory(EXP_NAME)
72                        .file_name(&network_file)
73                        .build()
74                        .unwrap(),
75                )
76                .unwrap();
77            let net_results = network.predict(training_inputs, training_targets).unwrap();
78            info!(
79                "{}",
80                helper::pretty_compare_matrices(
81                    training_inputs,
82                    training_targets,
83                    &net_results.predictions,
84                    helper::CompareMode::Classification
85                )
86            );
87            info!("Training: {}", net_results.display_metrics());
88        }
89        Err(e) => {
90            eprintln!("Training failed: {}", e);
91        }
92    }
93
94    network = Network::load(
95        JSON::default()
96            .directory(EXP_NAME)
97            .file_name(&network_file)
98            .build()
99            .unwrap(),
100    )
101    .unwrap();
102    let net_results = network.predict(validation_inputs, validation_targets).unwrap();
103    info!(
104        "{}",
105        helper::pretty_compare_matrices(
106            validation_inputs,
107            validation_targets,
108            &net_results.predictions,
109            helper::CompareMode::Classification
110        )
111    );
112    info!("Validation: {}", net_results.display_metrics());
113}
examples/iris/iris.rs (line 64)
50fn train_and_validate() {
51    let network_file = format!("{}_network", EXP_NAME);
52
53    let (training_inputs, training_targets) = iris_inputs_outputs("train", 7, 4).unwrap();
54    let mut network = iris_network(training_inputs.cols(), training_targets.cols());
55
56    let training_result = network.train(&training_inputs, &training_targets);
57    match training_result {
58        Ok(_) => {
59            info!("Training successfully completed");
60            network
61                .save(
62                    JSON::default()
63                        .directory(EXP_NAME)
64                        .file_name(&network_file)
65                        .build()
66                        .unwrap(),
67                )
68                .unwrap();
69            let net_results = network.predict(&training_inputs, &training_targets).unwrap();
70            info!(
71                "{}",
72                helper::pretty_compare_matrices(
73                    &training_inputs,
74                    &training_targets,
75                    &net_results.predictions,
76                    helper::CompareMode::Classification
77                )
78            );
79            info!("Training: {}", net_results.display_metrics());
80        }
81        Err(e) => {
82            eprintln!("Training failed: {}", e);
83        }
84    }
85
86    network = Network::load(
87        JSON::default()
88            .directory(EXP_NAME)
89            .file_name(&network_file)
90            .build()
91            .unwrap(),
92    )
93    .unwrap();
94    let (validation_inputs, validation_targets) = iris_inputs_outputs("test", 7, 4).unwrap();
95    let net_results = network.predict(&validation_inputs, &validation_targets).unwrap();
96    log::info!(
97        "{}",
98        helper::pretty_compare_matrices(
99            &validation_inputs,
100            &validation_targets,
101            &net_results.predictions,
102            helper::CompareMode::Classification
103        )
104    );
105    info!("Validation: {}", net_results.display_metrics());
106}
examples/triplets/triplets.rs (line 77)
63fn train_and_validate() {
64    let network_file = format!("{}_network", EXP_NAME);
65    let training_inputs = data::training_inputs();
66    let training_targets = data::training_targets();
67    let mut network = triplets_network(training_inputs.cols(), training_targets.cols());
68
69    let train_result = network.train(&training_inputs, &training_targets);
70    match train_result {
71        Ok(_) => {
72            info!("Training successfully completed");
73            network
74                .save(
75                    JSON::default()
76                        .directory(EXP_NAME)
77                        .file_name(&network_file)
78                        .build()
79                        .unwrap(),
80                )
81                .unwrap();
82            let net_results = network.predict(&training_inputs, &training_targets).unwrap();
83            info!(
84                "{}",
85                helper::pretty_compare_matrices(
86                    &training_inputs,
87                    &training_targets,
88                    &net_results.predictions,
89                    helper::CompareMode::Classification
90                )
91            );
92            info!("Training: {}", net_results.display_metrics());
93        }
94        Err(e) => {
95            eprintln!("Training failed: {}", e);
96        }
97    }
98
99    network = Network::load(
100        JSON::default()
101            .directory(EXP_NAME)
102            .file_name(&network_file)
103            .build()
104            .unwrap(),
105    )
106    .unwrap();
107    let validation_inputs = data::validation_inputs();
108    let validation_targets = data::validation_targets();
109    let net_results = network.predict(&validation_inputs, &validation_targets).unwrap();
110    log::info!(
111        "{}",
112        helper::pretty_compare_matrices(
113            &validation_inputs,
114            &validation_targets,
115            &net_results.predictions,
116            helper::CompareMode::Classification
117        )
118    );
119    info!("Validation: {}", net_results.display_metrics());
120}
Source

pub fn directory(self, directory: &str) -> Self

Sets the output directory for the JSON file.

Examples found in repository?
examples/energy_efficiency/energy_efficiency.rs (line 69)
55fn train_and_validate(
56    training_inputs: &DMat, training_targets: &DMat, validation_inputs: &DMat, validation_targets: &DMat,
57) {
58    let network_file = format!("{}_network", EXP_NAME);
59
60    let mut network = energy_efficiency_network(training_inputs.cols(), training_targets.cols());
61
62    let training_result = network.train(training_inputs, training_targets);
63    match training_result {
64        Ok(_) => {
65            info!("Training successfully completed");
66            network
67                .save(
68                    JSON::default()
69                        .directory(EXP_NAME)
70                        .file_name(&network_file)
71                        .build()
72                        .unwrap(),
73                )
74                .unwrap();
75            let net_results = network.predict(training_inputs, training_targets).unwrap();
76            info!(
77                "{}",
78                helper::pretty_compare_matrices(
79                    training_inputs,
80                    training_targets,
81                    &net_results.predictions,
82                    helper::CompareMode::Regression
83                )
84            );
85            info!("Training: {}", net_results.display_metrics());
86        }
87        Err(e) => {
88            error!("Training failed: {}", e);
89        }
90    }
91
92    network = Network::load(
93        JSON::default()
94            .directory(EXP_NAME)
95            .file_name(&network_file)
96            .build()
97            .unwrap(),
98    )
99    .unwrap();
100    let net_results = network.predict(validation_inputs, validation_targets).unwrap();
101    log::info!(
102        "{}",
103        helper::pretty_compare_matrices(
104            validation_inputs,
105            validation_targets,
106            &net_results.predictions,
107            helper::CompareMode::Regression
108        )
109    );
110    info!("Validation: {}", net_results.display_metrics());
111}
More examples
Hide additional examples
examples/wine/wine.rs (line 71)
57fn train_and_validate(
58    training_inputs: &DMat, training_targets: &DMat, validation_inputs: &DMat, validation_targets: &DMat,
59) {
60    let network_file = format!("{}_network", EXP_NAME);
61
62    let mut network = one_hot_encode_network(training_inputs.cols(), training_targets.cols());
63
64    let training_result = network.train(training_inputs, training_targets);
65    match training_result {
66        Ok(_) => {
67            info!("Training successfully completed");
68            network
69                .save(
70                    JSON::default()
71                        .directory(EXP_NAME)
72                        .file_name(&network_file)
73                        .build()
74                        .unwrap(),
75                )
76                .unwrap();
77            let net_results = network.predict(training_inputs, training_targets).unwrap();
78            info!(
79                "{}",
80                helper::pretty_compare_matrices(
81                    training_inputs,
82                    training_targets,
83                    &net_results.predictions,
84                    helper::CompareMode::Classification
85                )
86            );
87            info!("Training: {}", net_results.display_metrics());
88        }
89        Err(e) => {
90            eprintln!("Training failed: {}", e);
91        }
92    }
93
94    network = Network::load(
95        JSON::default()
96            .directory(EXP_NAME)
97            .file_name(&network_file)
98            .build()
99            .unwrap(),
100    )
101    .unwrap();
102    let net_results = network.predict(validation_inputs, validation_targets).unwrap();
103    info!(
104        "{}",
105        helper::pretty_compare_matrices(
106            validation_inputs,
107            validation_targets,
108            &net_results.predictions,
109            helper::CompareMode::Classification
110        )
111    );
112    info!("Validation: {}", net_results.display_metrics());
113}
examples/iris/iris.rs (line 63)
50fn train_and_validate() {
51    let network_file = format!("{}_network", EXP_NAME);
52
53    let (training_inputs, training_targets) = iris_inputs_outputs("train", 7, 4).unwrap();
54    let mut network = iris_network(training_inputs.cols(), training_targets.cols());
55
56    let training_result = network.train(&training_inputs, &training_targets);
57    match training_result {
58        Ok(_) => {
59            info!("Training successfully completed");
60            network
61                .save(
62                    JSON::default()
63                        .directory(EXP_NAME)
64                        .file_name(&network_file)
65                        .build()
66                        .unwrap(),
67                )
68                .unwrap();
69            let net_results = network.predict(&training_inputs, &training_targets).unwrap();
70            info!(
71                "{}",
72                helper::pretty_compare_matrices(
73                    &training_inputs,
74                    &training_targets,
75                    &net_results.predictions,
76                    helper::CompareMode::Classification
77                )
78            );
79            info!("Training: {}", net_results.display_metrics());
80        }
81        Err(e) => {
82            eprintln!("Training failed: {}", e);
83        }
84    }
85
86    network = Network::load(
87        JSON::default()
88            .directory(EXP_NAME)
89            .file_name(&network_file)
90            .build()
91            .unwrap(),
92    )
93    .unwrap();
94    let (validation_inputs, validation_targets) = iris_inputs_outputs("test", 7, 4).unwrap();
95    let net_results = network.predict(&validation_inputs, &validation_targets).unwrap();
96    log::info!(
97        "{}",
98        helper::pretty_compare_matrices(
99            &validation_inputs,
100            &validation_targets,
101            &net_results.predictions,
102            helper::CompareMode::Classification
103        )
104    );
105    info!("Validation: {}", net_results.display_metrics());
106}
examples/triplets/triplets.rs (line 76)
63fn train_and_validate() {
64    let network_file = format!("{}_network", EXP_NAME);
65    let training_inputs = data::training_inputs();
66    let training_targets = data::training_targets();
67    let mut network = triplets_network(training_inputs.cols(), training_targets.cols());
68
69    let train_result = network.train(&training_inputs, &training_targets);
70    match train_result {
71        Ok(_) => {
72            info!("Training successfully completed");
73            network
74                .save(
75                    JSON::default()
76                        .directory(EXP_NAME)
77                        .file_name(&network_file)
78                        .build()
79                        .unwrap(),
80                )
81                .unwrap();
82            let net_results = network.predict(&training_inputs, &training_targets).unwrap();
83            info!(
84                "{}",
85                helper::pretty_compare_matrices(
86                    &training_inputs,
87                    &training_targets,
88                    &net_results.predictions,
89                    helper::CompareMode::Classification
90                )
91            );
92            info!("Training: {}", net_results.display_metrics());
93        }
94        Err(e) => {
95            eprintln!("Training failed: {}", e);
96        }
97    }
98
99    network = Network::load(
100        JSON::default()
101            .directory(EXP_NAME)
102            .file_name(&network_file)
103            .build()
104            .unwrap(),
105    )
106    .unwrap();
107    let validation_inputs = data::validation_inputs();
108    let validation_targets = data::validation_targets();
109    let net_results = network.predict(&validation_inputs, &validation_targets).unwrap();
110    log::info!(
111        "{}",
112        helper::pretty_compare_matrices(
113            &validation_inputs,
114            &validation_targets,
115            &net_results.predictions,
116            helper::CompareMode::Classification
117        )
118    );
119    info!("Validation: {}", net_results.display_metrics());
120}
Source

pub fn build(self) -> Result<impl NetworkIO, NetworkError>

Finalizes the builder and constructs a JSONNetworkIO if the configuration is valid.

Examples found in repository?
examples/energy_efficiency/energy_efficiency.rs (line 71)
55fn train_and_validate(
56    training_inputs: &DMat, training_targets: &DMat, validation_inputs: &DMat, validation_targets: &DMat,
57) {
58    let network_file = format!("{}_network", EXP_NAME);
59
60    let mut network = energy_efficiency_network(training_inputs.cols(), training_targets.cols());
61
62    let training_result = network.train(training_inputs, training_targets);
63    match training_result {
64        Ok(_) => {
65            info!("Training successfully completed");
66            network
67                .save(
68                    JSON::default()
69                        .directory(EXP_NAME)
70                        .file_name(&network_file)
71                        .build()
72                        .unwrap(),
73                )
74                .unwrap();
75            let net_results = network.predict(training_inputs, training_targets).unwrap();
76            info!(
77                "{}",
78                helper::pretty_compare_matrices(
79                    training_inputs,
80                    training_targets,
81                    &net_results.predictions,
82                    helper::CompareMode::Regression
83                )
84            );
85            info!("Training: {}", net_results.display_metrics());
86        }
87        Err(e) => {
88            error!("Training failed: {}", e);
89        }
90    }
91
92    network = Network::load(
93        JSON::default()
94            .directory(EXP_NAME)
95            .file_name(&network_file)
96            .build()
97            .unwrap(),
98    )
99    .unwrap();
100    let net_results = network.predict(validation_inputs, validation_targets).unwrap();
101    log::info!(
102        "{}",
103        helper::pretty_compare_matrices(
104            validation_inputs,
105            validation_targets,
106            &net_results.predictions,
107            helper::CompareMode::Regression
108        )
109    );
110    info!("Validation: {}", net_results.display_metrics());
111}
More examples
Hide additional examples
examples/wine/wine.rs (line 73)
57fn train_and_validate(
58    training_inputs: &DMat, training_targets: &DMat, validation_inputs: &DMat, validation_targets: &DMat,
59) {
60    let network_file = format!("{}_network", EXP_NAME);
61
62    let mut network = one_hot_encode_network(training_inputs.cols(), training_targets.cols());
63
64    let training_result = network.train(training_inputs, training_targets);
65    match training_result {
66        Ok(_) => {
67            info!("Training successfully completed");
68            network
69                .save(
70                    JSON::default()
71                        .directory(EXP_NAME)
72                        .file_name(&network_file)
73                        .build()
74                        .unwrap(),
75                )
76                .unwrap();
77            let net_results = network.predict(training_inputs, training_targets).unwrap();
78            info!(
79                "{}",
80                helper::pretty_compare_matrices(
81                    training_inputs,
82                    training_targets,
83                    &net_results.predictions,
84                    helper::CompareMode::Classification
85                )
86            );
87            info!("Training: {}", net_results.display_metrics());
88        }
89        Err(e) => {
90            eprintln!("Training failed: {}", e);
91        }
92    }
93
94    network = Network::load(
95        JSON::default()
96            .directory(EXP_NAME)
97            .file_name(&network_file)
98            .build()
99            .unwrap(),
100    )
101    .unwrap();
102    let net_results = network.predict(validation_inputs, validation_targets).unwrap();
103    info!(
104        "{}",
105        helper::pretty_compare_matrices(
106            validation_inputs,
107            validation_targets,
108            &net_results.predictions,
109            helper::CompareMode::Classification
110        )
111    );
112    info!("Validation: {}", net_results.display_metrics());
113}
examples/iris/iris.rs (line 65)
50fn train_and_validate() {
51    let network_file = format!("{}_network", EXP_NAME);
52
53    let (training_inputs, training_targets) = iris_inputs_outputs("train", 7, 4).unwrap();
54    let mut network = iris_network(training_inputs.cols(), training_targets.cols());
55
56    let training_result = network.train(&training_inputs, &training_targets);
57    match training_result {
58        Ok(_) => {
59            info!("Training successfully completed");
60            network
61                .save(
62                    JSON::default()
63                        .directory(EXP_NAME)
64                        .file_name(&network_file)
65                        .build()
66                        .unwrap(),
67                )
68                .unwrap();
69            let net_results = network.predict(&training_inputs, &training_targets).unwrap();
70            info!(
71                "{}",
72                helper::pretty_compare_matrices(
73                    &training_inputs,
74                    &training_targets,
75                    &net_results.predictions,
76                    helper::CompareMode::Classification
77                )
78            );
79            info!("Training: {}", net_results.display_metrics());
80        }
81        Err(e) => {
82            eprintln!("Training failed: {}", e);
83        }
84    }
85
86    network = Network::load(
87        JSON::default()
88            .directory(EXP_NAME)
89            .file_name(&network_file)
90            .build()
91            .unwrap(),
92    )
93    .unwrap();
94    let (validation_inputs, validation_targets) = iris_inputs_outputs("test", 7, 4).unwrap();
95    let net_results = network.predict(&validation_inputs, &validation_targets).unwrap();
96    log::info!(
97        "{}",
98        helper::pretty_compare_matrices(
99            &validation_inputs,
100            &validation_targets,
101            &net_results.predictions,
102            helper::CompareMode::Classification
103        )
104    );
105    info!("Validation: {}", net_results.display_metrics());
106}
examples/triplets/triplets.rs (line 78)
63fn train_and_validate() {
64    let network_file = format!("{}_network", EXP_NAME);
65    let training_inputs = data::training_inputs();
66    let training_targets = data::training_targets();
67    let mut network = triplets_network(training_inputs.cols(), training_targets.cols());
68
69    let train_result = network.train(&training_inputs, &training_targets);
70    match train_result {
71        Ok(_) => {
72            info!("Training successfully completed");
73            network
74                .save(
75                    JSON::default()
76                        .directory(EXP_NAME)
77                        .file_name(&network_file)
78                        .build()
79                        .unwrap(),
80                )
81                .unwrap();
82            let net_results = network.predict(&training_inputs, &training_targets).unwrap();
83            info!(
84                "{}",
85                helper::pretty_compare_matrices(
86                    &training_inputs,
87                    &training_targets,
88                    &net_results.predictions,
89                    helper::CompareMode::Classification
90                )
91            );
92            info!("Training: {}", net_results.display_metrics());
93        }
94        Err(e) => {
95            eprintln!("Training failed: {}", e);
96        }
97    }
98
99    network = Network::load(
100        JSON::default()
101            .directory(EXP_NAME)
102            .file_name(&network_file)
103            .build()
104            .unwrap(),
105    )
106    .unwrap();
107    let validation_inputs = data::validation_inputs();
108    let validation_targets = data::validation_targets();
109    let net_results = network.predict(&validation_inputs, &validation_targets).unwrap();
110    log::info!(
111        "{}",
112        helper::pretty_compare_matrices(
113            &validation_inputs,
114            &validation_targets,
115            &net_results.predictions,
116            helper::CompareMode::Classification
117        )
118    );
119    info!("Validation: {}", net_results.display_metrics());
120}

Trait Implementations§

Source§

impl Default for JSON

Source§

fn default() -> Self

Creates a new JSON builder with default values. Default values:

  • File name: "network"
  • Directory: "." (current directory)

Auto Trait Implementations§

§

impl Freeze for JSON

§

impl RefUnwindSafe for JSON

§

impl Send for JSON

§

impl Sync for JSON

§

impl Unpin for JSON

§

impl UnsafeUnpin for JSON

§

impl UnwindSafe for JSON

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

Source§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more
Source§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
Source§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
Source§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V