Struct ModelSoup 

pub struct ModelSoup { /* private fields */ }

Model Soup - Weight-space averaging for improved generalization.

From “Model soups: averaging weights of multiple fine-tuned models improves accuracy without increasing inference time” (Wortsman et al., 2022).

Model soups average the weights of multiple models (not predictions), which can:

• Improve accuracy compared to individual models
• No inference cost (single model at test time)
• Work across different hyperparameters and random seeds
• Particularly effective for models fine-tuned from same initialization

Two main recipes:

• Uniform Soup: Simple average of all model weights
• Greedy Soup: Iteratively add models that improve validation performance

Example

use tensorlogic_train::{ModelSoup, SoupRecipe};
use std::collections::HashMap;
use scirs2_core::ndarray::Array2;

// Collect weights from multiple fine-tuned models
// let model_weights = vec![weights1, weights2, weights3];
// let soup = ModelSoup::uniform_soup(model_weights);
// let averaged_weights = soup.weights();

Implementations

impl ModelSoup

pub fn uniform_soup( model_weights: Vec<HashMap<String, Array2<f64>>>, ) -> TrainResult<Self>

Create a uniform soup by averaging all model weights equally.

Arguments

• model_weights - Weights from multiple fine-tuned models

Returns

Model soup with uniformly averaged weights

Example

use tensorlogic_train::ModelSoup;
use std::collections::HashMap;
use scirs2_core::ndarray::array;

let mut weights1 = HashMap::new();
weights1.insert("w".to_string(), array![[1.0, 2.0]]);

let mut weights2 = HashMap::new();
weights2.insert("w".to_string(), array![[3.0, 4.0]]);

let soup = ModelSoup::uniform_soup(vec![weights1, weights2]).unwrap();
// Averaged weights: [[2.0, 3.0]]

pub fn greedy_soup( model_weights: Vec<HashMap<String, Array2<f64>>>, val_accuracies: Vec<f64>, ) -> TrainResult<Self>

Create a greedy soup by iteratively adding models that improve validation performance.

Arguments

• model_weights - Weights from multiple fine-tuned models
• val_accuracies - Validation accuracy for each model

Returns

Model soup with greedily selected and averaged weights

Algorithm

1. Start with best single model
2. Try adding each remaining model to soup
3. Keep additions that improve validation performance
4. Repeat until no improvement

pub fn weighted_soup( model_weights: Vec<HashMap<String, Array2<f64>>>, weights: Vec<f64>, ) -> TrainResult<Self>

Create a weighted soup with custom weights for each model.

Arguments

• model_weights - Weights from multiple fine-tuned models
• weights - Weight for each model (will be normalized to sum to 1)

Returns

Model soup with weighted averaged parameters

pub fn weights(&self) -> &HashMap<String, Array2<f64>>

Get the averaged weights from the soup.

pub fn num_models(&self) -> usize

Get the number of models in the soup.

pub fn recipe(&self) -> SoupRecipe

Get the recipe used to create the soup.

pub fn get_parameter(&self, name: &str) -> Option<&Array2<f64>>

Get a specific parameter by name.

pub fn into_weights(self) -> HashMap<String, Array2<f64>>

Load weights into a model (consumes the soup).

This is a convenience method that returns the weights for loading into a model.

Trait Implementations

impl Clone for ModelSoup

fn clone(&self) -> ModelSoup

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModelSoup

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

Formats the value using the given formatter.