How to infer from saved model using custom image dataset?

[silicology1]

What is the code for inference for custom image dataset example.

Here is my code, don't know what to do next.

pub fn infer<B: Backend>(artifact_dir: &str, device: B::Device) { 
    let record = CompactRecorder::new()
        .load(format!("{artifact_dir}/model").into(), &device)
        .expect("Trained model should exist");
    let dataset = ImageFolderDataset::cifar10_test();

    let value = dataset.get(0).unwrap();
}

It also gives error:

error[E0283]: type annotations needed
   --> src/training.rs:125:10
    |
125 |         .load(format!("{artifact_dir}/model").into(), &device)
    |          ^^^^
    |

How can I convert dataset to tensor, and run model.forward

If I type annotate with

    let record: Cnn<B>= CompactRecorder::new()
    .load(format!("{artifact_dir}/model").into(), &device)
    .expect("Trained model should exist");

It gives error:

rror[E0277]: the trait bound `Cnn<B>: Record<_>` is not satisfied
   --> src/training.rs:123:6
    |
123 |     .load(format!("{artifact_dir}/model").into(), &device)
    |      ^^^^ the trait `Record<_>` is not implemented for `Cnn<B>`
    |
    = help: the following other types implement trait `Record<B>`:
              bool
              i8
              i16
              i32
              i64
              usize
              u8
              u16
            and 72 others
note: required by a bound in `burn::record::Recorder::load`
   --> /home/amiya/.cargo/git/checkouts/burn-178c6829f420dae1/6522276/crates/burn-core/src/record/recorder.rs:60:12
    |
58  |     fn load<R>(&self, args: Self::LoadArgs, device: &B::Device) -> Result<R, RecorderError>
    |        ---- required by a bound in this associated function
59  |     where
60  |         R: Record<B>,
    |            ^^^^^^^^^ required by this bound in `Recorder::load`

For more information about this error, try `rustc --explain E0277`.
warning: `burn-image-training` (lib) generated 2 warnings
error: could not compile `burn-image-training` (lib) due to previous error; 2 warnings emitted

[silicology1]

Finally without error, but not tested by running the code:

pub fn infer<B: Backend>(artifact_dir: &str, device: B::Device) {
    let record = CompactRecorder::new()
        .load(format!("{artifact_dir}/model").into(), &device)
        .expect("Trained model should exist");
    let model: Cnn<B> = Cnn::new(NUM_CLASSES.into(), &device).load_record(record);
    let dataset = ImageFolderDataset::cifar10_test();

    let item = dataset.get(0).unwrap();
    let annotation = item.clone().annotation;
    let batcher = ClassificationBatcher::new(device);
    let batch = batcher.batch(vec![item]);
    let output = model.forward(batch.images);
    let predicted = output.argmax(1).flatten::<1>(0, 1).into_scalar();
    println!("Predicted {} Expected {:?}", predicted, annotation);

}

[laggui]

Sorry I didn't see your question in time!

Your code looks good. I'll provide a snippet with all modules required for future reference.

use burn::{
    data::{
        dataloader::batcher::Batcher,
        dataset::vision::{Annotation, ImageDatasetItem},
    },
    module::Module,
    record::{CompactRecorder, Recorder},
    tensor::backend::Backend,
};

use crate::{data::ClassificationBatcher, model::Cnn};

// NUM_CLASSES const in training.rs is private right now
const NUM_CLASSES: u8 = 10;

pub fn infer<B: Backend>(artifact_dir: &str, device: B::Device, item: ImageDatasetItem) {
    let record = CompactRecorder::new()
        .load(format!("{artifact_dir}/model").into(), &device)
        .expect("Trained model should exist");

    let model: Cnn<B> = Cnn::new(NUM_CLASSES.into(), &device).load_record(record);

    let mut label = 0;
    if let Annotation::Label(category) = item.annotation {
        label = category;
    };
    let batcher = ClassificationBatcher::new(device);
    let batch = batcher.batch(vec![item]);
    let output = model.forward(batch.images);
    let predicted = output.argmax(1).flatten::<1>(0, 1).into_scalar();
    println!("Predicted {} Expected {:?}", predicted, label);
}

And you can call the function with an item from the dataset, for example:

infer::<MyBackend>(
    artifact_dir,
    device,
    ImageFolderDataset::cifar10_test().get(0).unwrap()
);