Struct NetworkSearch

Source

pub struct NetworkSearch { /* private fields */ }

Implementations§

Source §

impl NetworkSearch

Source

pub fn search( &mut self, training_inputs: &DMat, training_targets: &DMat, validation_inputs: &DMat, validation_targets: &DMat, ) -> Result<Vec<SearchResult>, NetworkError>

Perform the hyperparameter search.

Examples found in repository ?

examples/triplets/triplets.rs (line 173)

122fn search() {
123    let training_inputs = data::training_inputs();
124    let training_targets = data::training_targets();
125
126    let validation_inputs = data::validation_inputs();
127    let validation_targets = data::validation_targets();
128
129    let network = triplets_network(training_inputs.cols(), training_targets.cols());
130
131    let network_search = NetworkSearchBuilder::new()
132        .network(network)
133        .parallelize(4)
134        .learning_rates(
135            SequentialNumbers::new()
136                .lower_limit(0.0025)
137                .upper_limit(0.0035)
138                .increment(0.0005)
139                .floats(),
140        )
141        .batch_sizes(
142            SequentialNumbers::new()
143                .lower_limit(5.0)
144                .upper_limit(10.0)
145                .increment(1.0)
146                .ints(),
147        )
148        .hidden_layer(
149            SequentialNumbers::new()
150                .lower_limit(12.0)
151                .upper_limit(24.0)
152                .increment(4.0)
153                .ints(),
154            ReLU::build(),
155        )
156        .export(
157            CSV::default()
158                .directory(EXP_NAME)
159                .file_name(&format!("{}_search", EXP_NAME))
160                .build(),
161        )
162        .build();
163
164    let mut network_search = match network_search {
165        Ok(ns) => ns,
166        Err(e) => {
167            error!("Failed to build network_search: {}", e);
168            std::process::exit(1);
169        }
170    };
171
172    let search_res = network_search
173        .search(&training_inputs, &training_targets, &validation_inputs, &validation_targets)
174        .unwrap();
175
176    info!("Num Results: {}", search_res.len());
177}

More examples

Hide additional examples

examples/wine/wine.rs (line 191)

137fn search(training_inputs: &DMat, training_targets: &DMat, validation_inputs: &DMat, validation_targets: &DMat) {
138    let network = one_hot_encode_network(training_inputs.cols(), training_targets.cols());
139
140    let network_search = NetworkSearchBuilder::new()
141        .network(network)
142        .parallelize(4)
143        .normalize_input(MinMax::default())
144        .learning_rates(
145            SequentialNumbers::new()
146                .lower_limit(0.0015)
147                .upper_limit(0.0035)
148                .increment(0.0005)
149                .floats(),
150        )
151        .batch_sizes(
152            SequentialNumbers::new()
153                .lower_limit(4.0)
154                .upper_limit(9.0)
155                .increment(1.0)
156                .ints(),
157        )
158        .hidden_layer(
159            SequentialNumbers::new()
160                .lower_limit(4.0)
161                .upper_limit(10.0)
162                .increment(1.0)
163                .ints(),
164            ReLU::build(),
165        )
166        .hidden_layer(
167            SequentialNumbers::new()
168                .lower_limit(4.0)
169                .upper_limit(10.0)
170                .increment(1.0)
171                .ints(),
172            ReLU::build(),
173        )
174        .export(
175            CSV::default()
176                .directory(EXP_NAME)
177                .file_name(&format!("{}_search", EXP_NAME))
178                .build(),
179        )
180        .build();
181
182    let mut network_search = match network_search {
183        Ok(ns) => ns,
184        Err(e) => {
185            error!("Failed to build network_search: {}", e);
186            std::process::exit(1);
187        }
188    };
189
190    let search_res = network_search
191        .search(training_inputs, training_targets, validation_inputs, validation_targets)
192        .unwrap();
193
194    info!("Search Result Count: {}", search_res.len());
195}

examples/iris/iris.rs (line 187)

131fn search() {
132    let (training_inputs, training_targets) = iris_inputs_outputs("train", 7, 4).unwrap();
133    let (validation_inputs, validation_targets) = iris_inputs_outputs("test", 7, 4).unwrap();
134
135    let network = iris_network(training_inputs.cols(), training_targets.cols());
136
137    let network_search = NetworkSearchBuilder::new()
138        .network(network)
139        .parallelize(4)
140        .learning_rates(
141            SequentialNumbers::new()
142                .lower_limit(0.0025)
143                .upper_limit(0.0035)
144                .increment(0.0005)
145                .floats(),
146        )
147        .batch_sizes(
148            SequentialNumbers::new()
149                .lower_limit(7.0)
150                .upper_limit(10.0)
151                .increment(1.0)
152                .ints(),
153        )
154        .hidden_layer(
155            SequentialNumbers::new()
156                .lower_limit(12.0)
157                .upper_limit(20.0)
158                .increment(4.0)
159                .ints(),
160            ReLU::build(),
161        )
162        .hidden_layer(
163            SequentialNumbers::new()
164                .lower_limit(12.0)
165                .upper_limit(20.0)
166                .increment(4.0)
167                .ints(),
168            ReLU::build(),
169        )
170        .export(
171            CSV::default()
172                .directory(EXP_NAME)
173                .file_name(&format!("{}_search", EXP_NAME))
174                .build(),
175        )
176        .build();
177
178    let mut network_search = match network_search {
179        Ok(ns) => ns,
180        Err(e) => {
181            error!("Failed to build network_search: {}", e);
182            std::process::exit(1);
183        }
184    };
185
186    let search_res = network_search
187        .search(&training_inputs, &training_targets, &validation_inputs, &validation_targets)
188        .unwrap();
189
190    info!("Num Results: {}", search_res.len());
191}

examples/energy_efficiency/energy_efficiency.rs (line 200)

145fn search(training_inputs: &DMat, training_targets: &DMat, validation_inputs: &DMat, validation_targets: &DMat) {
146    let start_time = std::time::Instant::now();
147    info!("Energy Efficieny network search started");
148    let network = energy_efficiency_network(training_inputs.cols(), training_targets.cols());
149
150    let network_search = NetworkSearchBuilder::new()
151        .network(network)
152        .parallelize(4)
153        .normalize_input(MinMax::default())
154        .learning_rates(
155            SequentialNumbers::new()
156                .lower_limit(0.0025)
157                .upper_limit(0.0035)
158                .increment(0.0005)
159                .floats(),
160        )
161        .batch_sizes(
162            SequentialNumbers::new()
163                .lower_limit(6.0)
164                .upper_limit(9.0)
165                .increment(1.0)
166                .ints(),
167        )
168        .hidden_layer(
169            SequentialNumbers::new()
170                .lower_limit(14.0)
171                .upper_limit(18.0)
172                .increment(2.0)
173                .ints(),
174            ReLU::build(),
175        )
176        .hidden_layer(
177            SequentialNumbers::new()
178                .lower_limit(14.0)
179                .upper_limit(18.0)
180                .increment(2.0)
181                .ints(),
182            ReLU::build(),
183        )
184        .export(
185            CSV::default()
186                .directory(EXP_NAME)
187                .file_name(&format!("{}_search", EXP_NAME))
188                .build(),
189        )
190        .build();
191    let mut network_search = match network_search {
192        Ok(ns) => ns,
193        Err(e) => {
194            error!("Failed to build network_search: {}", e);
195            std::process::exit(1);
196        }
197    };
198
199    let search_res = network_search
200        .search(training_inputs, training_targets, validation_inputs, validation_targets)
201        .unwrap();
202
203    info!("Energy Efficieny network search finished in {} seconds", start_time.elapsed().as_secs());
204    info!("Num Results: {}", search_res.len());
205}