How can I use init_with in a for loop?

[zemelLeong]

for head in Self::get_heads() {
    let output_channels = head.1;
    match head.0.as_str() {
        "reg" => {
            let reg_record = &record.reg.layers;
            reg = SequentialConv2d::from(vec![
                Conv2dConfig::new([input_channels, head_conv], [3, 3])
                    .with_padding(PaddingConfig2d::Explicit(1, 1))
                    .init_with(reg_record[0]),
                Conv2dConfig::new([head_conv, output_channels], [3, 3])
                    .with_padding(PaddingConfig2d::Explicit(1, 1))
                    .init_with(reg_record[1]),
            ]);
        }
        other => {
            let seq = |r: &SequentialConv2dRecord<B>| {
                let layers = &r.layers;
                SequentialConv2d::from(vec![
                    Conv2dConfig::new([input_channels, head_conv], [3, 3])
                        .with_padding(PaddingConfig2d::Explicit(1, 1))
                        .init_with(layers[0]),
                    Conv2dConfig::new([head_conv, head_conv], [3, 3])
                        .with_padding(PaddingConfig2d::Explicit(1, 1))
                        .init_with(layers[1]),
                    Conv2dConfig::new([head_conv, head_conv], [3, 3])
                        .with_padding(PaddingConfig2d::Explicit(1, 1))
                        .init_with(layers[2]),
                    Conv2dConfig::new([head_conv, head_conv], [3, 3])
                        .with_padding(PaddingConfig2d::Explicit(1, 1))
                        .init_with(layers[3]),
                    Conv2dConfig::new([head_conv, output_channels], [1, 1])
                        .with_stride([1, 1])
                        .init_with(layers[4]),
                ])
            };
            match other {
                "ax" => ax = seq(&record.ax),
                "cr" => cr = seq(&record.cr),
                "hm" => hm = seq(&record.hm),
                "st" => st = seq(&record.st),
                "wh" => wh = seq(&record.wh),
                _ => panic!("Invalid head"),
            }
        }
    }
}

error[E0507]: cannot move out of index of `std::vec::Vec<Conv2dRecord<B>>`
   --> src\lore_detector.rs:334:44
    |
334 | ...                   .init_with(layers[0]),
    |                                  ^^^^^^^^^ move occurs because value has type `Conv2dRecord<B>`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `std::vec::Vec<Conv2dRecord<B>>`
   --> src\lore_detector.rs:337:44
    |
337 | ...                   .init_with(layers[1]),
    |                                  ^^^^^^^^^ move occurs because value has type `Conv2dRecord<B>`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `std::vec::Vec<Conv2dRecord<B>>`
   --> src\lore_detector.rs:340:44
    |
340 | ...                   .init_with(layers[2]),
    |                                  ^^^^^^^^^ move occurs because value has type `Conv2dRecord<B>`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `std::vec::Vec<Conv2dRecord<B>>`
   --> src\lore_detector.rs:343:44
    |
343 | ...                   .init_with(layers[3]),
    |                                  ^^^^^^^^^ move occurs because value has type `Conv2dRecord<B>`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `std::vec::Vec<Conv2dRecord<B>>`
   --> src\lore_detector.rs:346:44
    |
346 | ...                   .init_with(layers[4]),
    |                                  ^^^^^^^^^ move occurs because value has type `Conv2dRecord<B>`, which does not implement the `Copy` trait

warning: variable does not need to be mutable
   --> src\lore_detector.rs:361:13
    |
361 |         let mut lore_dector = Self {
    |             ----^^^^^^^^^^^
    |             |
    |             help: remove this `mut`
    |
    = note: `#[warn(unused_mut)]` on by default

error[E0507]: cannot move out of index of `std::vec::Vec<Conv2dRecord<B>>`
   --> src\lore_detector.rs:322:40
    |
322 | ...                   .init_with(reg_record[0]),
    |                                  ^^^^^^^^^^^^^ move occurs because value has type `Conv2dRecord<B>`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `std::vec::Vec<Conv2dRecord<B>>`
   --> src\lore_detector.rs:325:40
    |
325 | ...                   .init_with(reg_record[1]),
    |                                  ^^^^^^^^^^^^^ move occurs because value has type `Conv2dRecord<B>`, which does not implement the `Copy` trait

Also, my model state weight key is not continuous. Can I access it using the above indexing way?

  "model.ax.0.weight",
  "model.ax.0.bias",
  "model.ax.2.weight",
  "model.ax.2.bias",
  "model.ax.4.weight",
  "model.ax.4.bias",
  "model.ax.6.weight",
  "model.ax.6.bias",
  "model.ax.8.weight",
  "model.ax.8.bias",
  "model.cr.0.weight",
  "model.cr.0.bias",
  "model.cr.2.weight",
  "model.cr.2.bias",
  "model.cr.4.weight",
  "model.cr.4.bias",
  "model.cr.6.weight",
  "model.cr.6.bias",
  "model.cr.8.weight",
  "model.cr.8.bias",

[antimora]

I had the same issue and currently you cannot close records because we encourage to own the item.

You can use .into_iter() to own items from a vector. Here is a working example from my recent work. You can modify to use .into_iter() iterator with next() if you wish to use outside loop.

        let mut blocks = vec![];
        for record_block in record.blocks.into_iter() {
            blocks.push(ResidualAttentionBlock::init_with(
                config.n_audio_head,
                config.n_audio_state,
                record_block,
            ));
        }

Regarding, your question "state weight key is not continuous". I believe the deserializer should just add items to a vector resetting the indexes (0 => 0, 2 => 1, 4=> 2, etc). The order should be preserved. I haven't tested but I implemented the deserializer myself and uses iterator to pull the items. Just make sure your struct uses Vec.