Function build_lstm_sequence

src/framework/modules/recurrent_modules.cpp:154–200

}

LSTMSequenceOutputs build_lstm_sequence(
    core::ModuleBuildContext & ctx,
    const LSTMSequenceConfig & config,
    const core::TensorValue & input,
    const core::TensorValue & initial_hidden,
    const core::TensorValue & initial_cell,
    const LSTMCellWeights & weights) {
    if (ctx.ggml == nullptr) {
        throw std::runtime_error("ModuleBuildContext.ggml is null");
    }
    core::validate_shape(input, core::TensorShape::from_dims({input.shape.dims[0], config.input_size}), "input");
    core::validate_shape(initial_hidden, core::TensorShape::from_dims({1, config.hidden_size}), "initial_hidden");
    core::validate_shape(initial_cell, core::TensorShape::from_dims({1, config.hidden_size}), "initial_cell");
    validate_weight_shapes({config.input_size, config.hidden_size}, weights);

    const int64_t frames = input.shape.dims[0];
    const int64_t gates = 4 * config.hidden_size;
    const auto projected_inputs = LinearModule({config.input_size, gates, true}).build(
        ctx,
        input,
        {weights.weight_ih, weights.bias_ih});
    std::vector<core::TensorValue> steps(static_cast<size_t>(frames));
    auto hidden = initial_hidden;
    auto cell = initial_cell;
    const ConcatModule concat_rows({0});

    for (int64_t step = 0; step < frames; ++step) {
        const int64_t t = config.reverse ? (frames - 1 - step) : step;
        const auto projected_x_t = SliceModule({0, t, 1}).build(ctx, projected_inputs);
        const auto outputs = build_lstm_cell_from_projected_input(
            ctx,
            {config.input_size, config.hidden_size},
            projected_x_t,
            hidden,
            cell,
            weights);
        hidden = outputs.hidden;
        cell = outputs.cell;
        steps[static_cast<size_t>(t)] = hidden;
    }

    auto sequence = steps[0];
    for (int64_t t = 1; t < frames; ++t) {
        sequence = concat_rows.build(ctx, sequence, steps[static_cast<size_t>(t)]);
    }
    return LSTMSequenceOutputs{sequence, hidden, cell};
}

}  // namespace