models.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (C) 2026 Artificial Intelligence Techniques, S.L. and Roberto López González
 
#pragma once
 
#include "opennn/network/network.h"
#include "opennn/network/layers/pooling_layer.h"
#include "opennn/network/detection_head.h"
 
namespace opennn
{
 
class ApproximationNetwork : public Network
{
 
public:
 
    ApproximationNetwork(const Shape&,
                         const Shape&,
                         const Shape&,
                         const string& hidden_activation = "Tanh");
};
 
class ClassificationNetwork : public Network
{
 
public:
 
    ClassificationNetwork(const Shape&,
                          const Shape&,
                          const Shape&,
                          const string& hidden_activation = "Tanh");
};
 
class ForecastingNetwork : public Network
{
 
public:
 
    ForecastingNetwork(const Shape&,
                       const Shape&,
                       const Shape&);
};
 
class ForecastingLstmNetwork : public Network
{
 
public:
 
    ForecastingLstmNetwork(const Shape&,
                           const Shape&,
                           const Shape&);
};
 
class Autoencoder : public Network
{
 
public:
 
    Autoencoder(const Shape&,
                           const Shape&,
                           const string&,
                           const string&);
};
 
#ifndef OPENNN_NO_VISION
 
class ImageClassificationNetwork : public Network
{
 
public:
 
    ImageClassificationNetwork(const Shape&,
                               const Shape&,
                               const Shape&);
};
 
class ResNet : public Network
{
 
public:
 
    static unique_ptr<ResNet> from_pretrained(const filesystem::path&);
 
    ResNet(const Shape&,
           const vector<Index>&,
           const Shape&,
           const Shape&,
           bool use_bottleneck = false);
};
 
class Yolo : public Network
{
public:
 
    enum class Backbone { Vgg, DarknetTiny, DarknetTinyV3, Darknet53, CSPDarknet53, CSPDarknet53v11 };
 
    using ClassActivation = DetectionClassActivation;
 
    enum class HeadStyle { Single, FPN, PANet, FPNv8 };
 
    enum class BodyActivation { ReLU, LeakyReLU, SiLU };
 
    enum class ModelSize { n, s, m, l, x };
 
    Yolo(const Shape&,
                Index,
                const vector<array<float, 2>>&,
                Index grid_size = 13,
                Backbone backbone = Backbone::Vgg,
                ClassActivation class_activation = ClassActivation::Softmax,
                HeadStyle head_style = HeadStyle::Single,
                BodyActivation body_activation = BodyActivation::ReLU,
                bool use_sppf = false,
                Index reg_max = 1,
                ModelSize model_size = ModelSize::l);
 
    Index load_pretrained_backbone(const filesystem::path&);
 
private:
 
    Backbone backbone;
};
 
class TextClassificationNetwork : public Network
{
 
public:
 
    struct Prediction
    {
        string category;
        float confidence = 0.0f;
    };
 
    static constexpr Index default_embedding_dimension = 64;
    static constexpr Index default_heads_number = 4;
    static constexpr Index default_hidden_neurons = 64;
 
    TextClassificationNetwork(const Shape&,
                              const Shape&,
                              const Shape&,
                              PoolingMethod pooling_method = PoolingMethod::AveragePooling);
 
    Prediction classify(string_view);
    MatrixR calculate_text_outputs(const Tensor<string, 1>&);
 
    void set_tokenizer(unique_ptr<TokenizerOperator>);
    const TokenizerOperator* get_tokenizer() const;
};
 
class Transformer final : public Network
{
public:
 
    Transformer();
 
    Transformer(Index,
                Index,
                Index,
                Index,
                Index,
                Index,
                Index,
                Index);
 
    explicit Transformer(const filesystem::path&);
 
    Index get_input_sequence_length() const { return get_layer("encoder_embedding")->get_input_shape()[0]; }
    Index get_decoder_sequence_length() const { return get_layer("decoder_embedding")->get_input_shape()[0]; }
 
    void set_dropout_rate(const float);
    void set_attention_sdpa_min_sequence_length(Index);
 
    void set_input_vocabulary(const vector<string>&);
    void set_target_vocabulary(const vector<string>&);
    const TokenizerOperator* get_input_tokenizer() const;
    const TokenizerOperator* get_target_tokenizer() const;
    const vector<string>& get_input_vocabulary() const;
    const vector<string>& get_target_vocabulary() const;
 
};
 
class TextGenerationNetwork final : public Network
{
public:
 
    TextGenerationNetwork();
 
    TextGenerationNetwork(Index,
                          Index,
                          Index,
                          Index,
                          Index,
                          Index,
                          bool pre_normalization = false,
                          bool scale_embedding = true,
                          bool learned_positional = false,
                          const string& feed_forward_activation = "ReLU");
 
    explicit TextGenerationNetwork(const filesystem::path&);
 
    void load_pretrained(const filesystem::path& data_directory);
 
    Index get_sequence_length() const { return get_layer("embedding")->get_input_shape()[0]; }
 
    void set_dropout_rate(const float);
    void set_attention_sdpa_auto(bool new_sdpa_auto);
 
    void set_tokenizer(unique_ptr<TokenizerOperator>);
    void set_vocabulary(const vector<string>&);
    const TokenizerOperator* get_tokenizer() const;
 
};
 
class Qwen3 final : public Network
{
public:
 
    enum class Variant { B0_6, B4 };
 
    static unique_ptr<Qwen3> from_pretrained(
        Variant,
        const filesystem::path&,
        Index sequence_length = 32768);
 
    // Builds the network and loads a BF16 inference binary without ever
    // allocating or initialising the fp32 parameter master.
    static unique_ptr<Qwen3> from_binary(
        const filesystem::path& weights_path,
        Index sequence_length,
        Index vocabulary_size,
        Index hidden_size,
        Index layers_number,
        Index query_heads,
        Index key_value_heads,
        Index head_dimension,
        Index intermediate_size,
        float rope_theta = 1000000.0f,
        float rms_epsilon = 1.0e-6f);
 
    Qwen3();
 
    Qwen3(Index sequence_length,
          Index vocabulary_size,
          Index hidden_size,
          Index layers_number,
          Index query_heads,
          Index key_value_heads,
          Index head_dimension,
          Index intermediate_size,
          float rope_theta = 1000000.0f,
          float rms_epsilon = 1.0e-6f);
 
private:
 
    void build(Index sequence_length,
               Index vocabulary_size,
               Index hidden_size,
               Index layers_number,
               Index query_heads,
               Index key_value_heads,
               Index head_dimension,
               Index intermediate_size,
               float rope_theta,
               float rms_epsilon);
};
 
class Bert final : public Network
{
public:
 
    Bert();
 
    Bert(Index sequence_length,
         Index vocabulary_size,
         Index hidden_size,
         Index heads_number,
         Index intermediate_size,
         Index layers_number,
         Index type_vocabulary_size = 2);
};
 
class BertForSequenceClassification final : public Network
{
public:
 
    struct Pretrained
    {
        unique_ptr<BertForSequenceClassification> model;
        filesystem::path vocabulary_path;
        Index sequence_length;
    };
 
    static Pretrained from_pretrained(const filesystem::path&);
 
    BertForSequenceClassification();
 
    BertForSequenceClassification(Index sequence_length,
                                  Index vocabulary_size,
                                  Index hidden_size,
                                  Index heads_number,
                                  Index intermediate_size,
                                  Index layers_number,
                                  Index labels_number,
                                  Index type_vocabulary_size = 2);
 
    void set_dropout_rate(const float);
};
 
#endif
 
#ifndef OPENNN_NO_VISION
Index load_darknet_backbone(Network&, const filesystem::path&, Index);
Index load_darknet_backbone_v11(Network&, const filesystem::path&);
Index load_yolov8s_onnx(Network&, const filesystem::path& onnx_path, Index n_classes);
#endif
 
}