diff --git "a/chess-gpt-eval-contrastive/lc0/build/release/encoder_test.p/proto/net.pb.h" "b/chess-gpt-eval-contrastive/lc0/build/release/encoder_test.p/proto/net.pb.h" new file mode 100644--- /dev/null +++ "b/chess-gpt-eval-contrastive/lc0/build/release/encoder_test.p/proto/net.pb.h" @@ -0,0 +1,2819 @@ +// This file is AUTOGENERATED, do not edit. +#pragma once +#include "utils/protomessage.h" +namespace pblczero { + +// Forward declarations. +class EngineVersion; +class Weights; +class Weights_Layer; +class Weights_ConvBlock; +class Weights_SEunit; +class Weights_Residual; +class Weights_Smolgen; +class Weights_MHA; +class Weights_FFN; +class Weights_EncoderLayer; +class TrainingParams; +class NetworkFormat; +class Format; +class OnnxModel; +class Net; +enum NetworkFormat_InputFormat : int { + NetworkFormat_InputFormat_INPUT_UNKNOWN = 0, + NetworkFormat_InputFormat_INPUT_CLASSICAL_112_PLANE = 1, + NetworkFormat_InputFormat_INPUT_112_WITH_CASTLING_PLANE = 2, + NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION = 3, + NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION_HECTOPLIES = 4, + NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION_HECTOPLIES_ARMAGEDDON = 132, + NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION_V2 = 5, + NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION_V2_ARMAGEDDON = 133, +}; +inline std::string NetworkFormat_InputFormat_Name(NetworkFormat_InputFormat val) { + switch (val) { + case NetworkFormat_InputFormat_INPUT_UNKNOWN: + return "INPUT_UNKNOWN"; + case NetworkFormat_InputFormat_INPUT_CLASSICAL_112_PLANE: + return "INPUT_CLASSICAL_112_PLANE"; + case NetworkFormat_InputFormat_INPUT_112_WITH_CASTLING_PLANE: + return "INPUT_112_WITH_CASTLING_PLANE"; + case NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION: + return "INPUT_112_WITH_CANONICALIZATION"; + case NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION_HECTOPLIES: + return "INPUT_112_WITH_CANONICALIZATION_HECTOPLIES"; + case NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION_HECTOPLIES_ARMAGEDDON: + return "INPUT_112_WITH_CANONICALIZATION_HECTOPLIES_ARMAGEDDON"; + case NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION_V2: + return "INPUT_112_WITH_CANONICALIZATION_V2"; + case NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION_V2_ARMAGEDDON: + return "INPUT_112_WITH_CANONICALIZATION_V2_ARMAGEDDON"; + }; + return "InputFormat(" + std::to_string(val) + ")"; +} +enum NetworkFormat_OutputFormat : int { + NetworkFormat_OutputFormat_OUTPUT_UNKNOWN = 0, + NetworkFormat_OutputFormat_OUTPUT_CLASSICAL = 1, + NetworkFormat_OutputFormat_OUTPUT_WDL = 2, +}; +inline std::string NetworkFormat_OutputFormat_Name(NetworkFormat_OutputFormat val) { + switch (val) { + case NetworkFormat_OutputFormat_OUTPUT_UNKNOWN: + return "OUTPUT_UNKNOWN"; + case NetworkFormat_OutputFormat_OUTPUT_CLASSICAL: + return "OUTPUT_CLASSICAL"; + case NetworkFormat_OutputFormat_OUTPUT_WDL: + return "OUTPUT_WDL"; + }; + return "OutputFormat(" + std::to_string(val) + ")"; +} +enum NetworkFormat_NetworkStructure : int { + NetworkFormat_NetworkStructure_NETWORK_UNKNOWN = 0, + NetworkFormat_NetworkStructure_NETWORK_CLASSICAL = 1, + NetworkFormat_NetworkStructure_NETWORK_SE = 2, + NetworkFormat_NetworkStructure_NETWORK_CLASSICAL_WITH_HEADFORMAT = 3, + NetworkFormat_NetworkStructure_NETWORK_SE_WITH_HEADFORMAT = 4, + NetworkFormat_NetworkStructure_NETWORK_ONNX = 5, + NetworkFormat_NetworkStructure_NETWORK_ATTENTIONBODY_WITH_HEADFORMAT = 6, +}; +inline std::string NetworkFormat_NetworkStructure_Name(NetworkFormat_NetworkStructure val) { + switch (val) { + case NetworkFormat_NetworkStructure_NETWORK_UNKNOWN: + return "NETWORK_UNKNOWN"; + case NetworkFormat_NetworkStructure_NETWORK_CLASSICAL: + return "NETWORK_CLASSICAL"; + case NetworkFormat_NetworkStructure_NETWORK_SE: + return "NETWORK_SE"; + case NetworkFormat_NetworkStructure_NETWORK_CLASSICAL_WITH_HEADFORMAT: + return "NETWORK_CLASSICAL_WITH_HEADFORMAT"; + case NetworkFormat_NetworkStructure_NETWORK_SE_WITH_HEADFORMAT: + return "NETWORK_SE_WITH_HEADFORMAT"; + case NetworkFormat_NetworkStructure_NETWORK_ONNX: + return "NETWORK_ONNX"; + case NetworkFormat_NetworkStructure_NETWORK_ATTENTIONBODY_WITH_HEADFORMAT: + return "NETWORK_ATTENTIONBODY_WITH_HEADFORMAT"; + }; + return "NetworkStructure(" + std::to_string(val) + ")"; +} +enum NetworkFormat_PolicyFormat : int { + NetworkFormat_PolicyFormat_POLICY_UNKNOWN = 0, + NetworkFormat_PolicyFormat_POLICY_CLASSICAL = 1, + NetworkFormat_PolicyFormat_POLICY_CONVOLUTION = 2, + NetworkFormat_PolicyFormat_POLICY_ATTENTION = 3, +}; +inline std::string NetworkFormat_PolicyFormat_Name(NetworkFormat_PolicyFormat val) { + switch (val) { + case NetworkFormat_PolicyFormat_POLICY_UNKNOWN: + return "POLICY_UNKNOWN"; + case NetworkFormat_PolicyFormat_POLICY_CLASSICAL: + return "POLICY_CLASSICAL"; + case NetworkFormat_PolicyFormat_POLICY_CONVOLUTION: + return "POLICY_CONVOLUTION"; + case NetworkFormat_PolicyFormat_POLICY_ATTENTION: + return "POLICY_ATTENTION"; + }; + return "PolicyFormat(" + std::to_string(val) + ")"; +} +enum NetworkFormat_ValueFormat : int { + NetworkFormat_ValueFormat_VALUE_UNKNOWN = 0, + NetworkFormat_ValueFormat_VALUE_CLASSICAL = 1, + NetworkFormat_ValueFormat_VALUE_WDL = 2, + NetworkFormat_ValueFormat_VALUE_PARAM = 3, +}; +inline std::string NetworkFormat_ValueFormat_Name(NetworkFormat_ValueFormat val) { + switch (val) { + case NetworkFormat_ValueFormat_VALUE_UNKNOWN: + return "VALUE_UNKNOWN"; + case NetworkFormat_ValueFormat_VALUE_CLASSICAL: + return "VALUE_CLASSICAL"; + case NetworkFormat_ValueFormat_VALUE_WDL: + return "VALUE_WDL"; + case NetworkFormat_ValueFormat_VALUE_PARAM: + return "VALUE_PARAM"; + }; + return "ValueFormat(" + std::to_string(val) + ")"; +} +enum NetworkFormat_MovesLeftFormat : int { + NetworkFormat_MovesLeftFormat_MOVES_LEFT_NONE = 0, + NetworkFormat_MovesLeftFormat_MOVES_LEFT_V1 = 1, +}; +inline std::string NetworkFormat_MovesLeftFormat_Name(NetworkFormat_MovesLeftFormat val) { + switch (val) { + case NetworkFormat_MovesLeftFormat_MOVES_LEFT_NONE: + return "MOVES_LEFT_NONE"; + case NetworkFormat_MovesLeftFormat_MOVES_LEFT_V1: + return "MOVES_LEFT_V1"; + }; + return "MovesLeftFormat(" + std::to_string(val) + ")"; +} +enum NetworkFormat_ActivationFunction : int { + NetworkFormat_ActivationFunction_ACTIVATION_DEFAULT = 0, + NetworkFormat_ActivationFunction_ACTIVATION_MISH = 1, + NetworkFormat_ActivationFunction_ACTIVATION_RELU = 2, + NetworkFormat_ActivationFunction_ACTIVATION_NONE = 3, + NetworkFormat_ActivationFunction_ACTIVATION_TANH = 4, + NetworkFormat_ActivationFunction_ACTIVATION_SIGMOID = 5, + NetworkFormat_ActivationFunction_ACTIVATION_SELU = 6, + NetworkFormat_ActivationFunction_ACTIVATION_SWISH = 7, + NetworkFormat_ActivationFunction_ACTIVATION_RELU_2 = 8, + NetworkFormat_ActivationFunction_ACTIVATION_SOFTMAX = 9, +}; +inline std::string NetworkFormat_ActivationFunction_Name(NetworkFormat_ActivationFunction val) { + switch (val) { + case NetworkFormat_ActivationFunction_ACTIVATION_DEFAULT: + return "ACTIVATION_DEFAULT"; + case NetworkFormat_ActivationFunction_ACTIVATION_MISH: + return "ACTIVATION_MISH"; + case NetworkFormat_ActivationFunction_ACTIVATION_RELU: + return "ACTIVATION_RELU"; + case NetworkFormat_ActivationFunction_ACTIVATION_NONE: + return "ACTIVATION_NONE"; + case NetworkFormat_ActivationFunction_ACTIVATION_TANH: + return "ACTIVATION_TANH"; + case NetworkFormat_ActivationFunction_ACTIVATION_SIGMOID: + return "ACTIVATION_SIGMOID"; + case NetworkFormat_ActivationFunction_ACTIVATION_SELU: + return "ACTIVATION_SELU"; + case NetworkFormat_ActivationFunction_ACTIVATION_SWISH: + return "ACTIVATION_SWISH"; + case NetworkFormat_ActivationFunction_ACTIVATION_RELU_2: + return "ACTIVATION_RELU_2"; + case NetworkFormat_ActivationFunction_ACTIVATION_SOFTMAX: + return "ACTIVATION_SOFTMAX"; + }; + return "ActivationFunction(" + std::to_string(val) + ")"; +} +enum NetworkFormat_DefaultActivation : int { + NetworkFormat_DefaultActivation_DEFAULT_ACTIVATION_RELU = 0, + NetworkFormat_DefaultActivation_DEFAULT_ACTIVATION_MISH = 1, +}; +inline std::string NetworkFormat_DefaultActivation_Name(NetworkFormat_DefaultActivation val) { + switch (val) { + case NetworkFormat_DefaultActivation_DEFAULT_ACTIVATION_RELU: + return "DEFAULT_ACTIVATION_RELU"; + case NetworkFormat_DefaultActivation_DEFAULT_ACTIVATION_MISH: + return "DEFAULT_ACTIVATION_MISH"; + }; + return "DefaultActivation(" + std::to_string(val) + ")"; +} +enum Format_Encoding : int { + Format_Encoding_UNKNOWN = 0, + Format_Encoding_LINEAR16 = 1, +}; +inline std::string Format_Encoding_Name(Format_Encoding val) { + switch (val) { + case Format_Encoding_UNKNOWN: + return "UNKNOWN"; + case Format_Encoding_LINEAR16: + return "LINEAR16"; + }; + return "Encoding(" + std::to_string(val) + ")"; +} +enum OnnxModel_DataType : int { + OnnxModel_DataType_UNKNOWN_DATATYPE = 0, + OnnxModel_DataType_FLOAT = 1, + OnnxModel_DataType_FLOAT16 = 10, + OnnxModel_DataType_BFLOAT16 = 16, +}; +inline std::string OnnxModel_DataType_Name(OnnxModel_DataType val) { + switch (val) { + case OnnxModel_DataType_UNKNOWN_DATATYPE: + return "UNKNOWN_DATATYPE"; + case OnnxModel_DataType_FLOAT: + return "FLOAT"; + case OnnxModel_DataType_FLOAT16: + return "FLOAT16"; + case OnnxModel_DataType_BFLOAT16: + return "BFLOAT16"; + }; + return "DataType(" + std::to_string(val) + ")"; +} + +// Class declarations. +class EngineVersion final : public lczero::ProtoMessage { + public: + + bool has_major() const; + std::uint32_t major() const; + void set_major(std::uint32_t val); + + bool has_minor() const; + std::uint32_t minor() const; + void set_minor(std::uint32_t val); + + bool has_patch() const; + std::uint32_t patch() const; + void set_patch(std::uint32_t val); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetVarInt(int field_id, std::uint64_t val) final; + + bool has_major_{}; + std::uint32_t major_{}; + bool has_minor_{}; + std::uint32_t minor_{}; + bool has_patch_{}; + std::uint32_t patch_{}; +}; + +class Weights_Layer final : public lczero::ProtoMessage { + public: + + bool has_min_val() const; + float min_val() const; + void set_min_val(float val); + + bool has_max_val() const; + float max_val() const; + void set_max_val(float val); + + bool has_params() const; + std::string_view params() const; + void set_params(std::string_view val); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetInt32(int field_id, std::uint32_t val) final; + void SetString(int field_id, std::string_view val) final; + + bool has_min_val_{}; + float min_val_{}; + bool has_max_val_{}; + float max_val_{}; + bool has_params_{}; + std::string params_{}; +}; + +class Weights_ConvBlock final : public lczero::ProtoMessage { + public: + + bool has_weights() const; + const Weights_Layer& weights() const; + Weights_Layer* mutable_weights(); + + bool has_biases() const; + const Weights_Layer& biases() const; + Weights_Layer* mutable_biases(); + + bool has_bn_means() const; + const Weights_Layer& bn_means() const; + Weights_Layer* mutable_bn_means(); + + bool has_bn_stddivs() const; + const Weights_Layer& bn_stddivs() const; + Weights_Layer* mutable_bn_stddivs(); + + bool has_bn_gammas() const; + const Weights_Layer& bn_gammas() const; + Weights_Layer* mutable_bn_gammas(); + + bool has_bn_betas() const; + const Weights_Layer& bn_betas() const; + Weights_Layer* mutable_bn_betas(); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetString(int field_id, std::string_view val) final; + + bool has_weights_{}; + Weights_Layer weights_{}; + bool has_biases_{}; + Weights_Layer biases_{}; + bool has_bn_means_{}; + Weights_Layer bn_means_{}; + bool has_bn_stddivs_{}; + Weights_Layer bn_stddivs_{}; + bool has_bn_gammas_{}; + Weights_Layer bn_gammas_{}; + bool has_bn_betas_{}; + Weights_Layer bn_betas_{}; +}; + +class Weights_SEunit final : public lczero::ProtoMessage { + public: + + bool has_w1() const; + const Weights_Layer& w1() const; + Weights_Layer* mutable_w1(); + + bool has_b1() const; + const Weights_Layer& b1() const; + Weights_Layer* mutable_b1(); + + bool has_w2() const; + const Weights_Layer& w2() const; + Weights_Layer* mutable_w2(); + + bool has_b2() const; + const Weights_Layer& b2() const; + Weights_Layer* mutable_b2(); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetString(int field_id, std::string_view val) final; + + bool has_w1_{}; + Weights_Layer w1_{}; + bool has_b1_{}; + Weights_Layer b1_{}; + bool has_w2_{}; + Weights_Layer w2_{}; + bool has_b2_{}; + Weights_Layer b2_{}; +}; + +class Weights_Residual final : public lczero::ProtoMessage { + public: + + bool has_conv1() const; + const Weights_ConvBlock& conv1() const; + Weights_ConvBlock* mutable_conv1(); + + bool has_conv2() const; + const Weights_ConvBlock& conv2() const; + Weights_ConvBlock* mutable_conv2(); + + bool has_se() const; + const Weights_SEunit& se() const; + Weights_SEunit* mutable_se(); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetString(int field_id, std::string_view val) final; + + bool has_conv1_{}; + Weights_ConvBlock conv1_{}; + bool has_conv2_{}; + Weights_ConvBlock conv2_{}; + bool has_se_{}; + Weights_SEunit se_{}; +}; + +class Weights_Smolgen final : public lczero::ProtoMessage { + public: + + bool has_compress() const; + const Weights_Layer& compress() const; + Weights_Layer* mutable_compress(); + + bool has_dense1_w() const; + const Weights_Layer& dense1_w() const; + Weights_Layer* mutable_dense1_w(); + + bool has_dense1_b() const; + const Weights_Layer& dense1_b() const; + Weights_Layer* mutable_dense1_b(); + + bool has_ln1_gammas() const; + const Weights_Layer& ln1_gammas() const; + Weights_Layer* mutable_ln1_gammas(); + + bool has_ln1_betas() const; + const Weights_Layer& ln1_betas() const; + Weights_Layer* mutable_ln1_betas(); + + bool has_dense2_w() const; + const Weights_Layer& dense2_w() const; + Weights_Layer* mutable_dense2_w(); + + bool has_dense2_b() const; + const Weights_Layer& dense2_b() const; + Weights_Layer* mutable_dense2_b(); + + bool has_ln2_gammas() const; + const Weights_Layer& ln2_gammas() const; + Weights_Layer* mutable_ln2_gammas(); + + bool has_ln2_betas() const; + const Weights_Layer& ln2_betas() const; + Weights_Layer* mutable_ln2_betas(); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetString(int field_id, std::string_view val) final; + + bool has_compress_{}; + Weights_Layer compress_{}; + bool has_dense1_w_{}; + Weights_Layer dense1_w_{}; + bool has_dense1_b_{}; + Weights_Layer dense1_b_{}; + bool has_ln1_gammas_{}; + Weights_Layer ln1_gammas_{}; + bool has_ln1_betas_{}; + Weights_Layer ln1_betas_{}; + bool has_dense2_w_{}; + Weights_Layer dense2_w_{}; + bool has_dense2_b_{}; + Weights_Layer dense2_b_{}; + bool has_ln2_gammas_{}; + Weights_Layer ln2_gammas_{}; + bool has_ln2_betas_{}; + Weights_Layer ln2_betas_{}; +}; + +class Weights_MHA final : public lczero::ProtoMessage { + public: + + bool has_q_w() const; + const Weights_Layer& q_w() const; + Weights_Layer* mutable_q_w(); + + bool has_q_b() const; + const Weights_Layer& q_b() const; + Weights_Layer* mutable_q_b(); + + bool has_k_w() const; + const Weights_Layer& k_w() const; + Weights_Layer* mutable_k_w(); + + bool has_k_b() const; + const Weights_Layer& k_b() const; + Weights_Layer* mutable_k_b(); + + bool has_v_w() const; + const Weights_Layer& v_w() const; + Weights_Layer* mutable_v_w(); + + bool has_v_b() const; + const Weights_Layer& v_b() const; + Weights_Layer* mutable_v_b(); + + bool has_dense_w() const; + const Weights_Layer& dense_w() const; + Weights_Layer* mutable_dense_w(); + + bool has_dense_b() const; + const Weights_Layer& dense_b() const; + Weights_Layer* mutable_dense_b(); + + bool has_smolgen() const; + const Weights_Smolgen& smolgen() const; + Weights_Smolgen* mutable_smolgen(); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetString(int field_id, std::string_view val) final; + + bool has_q_w_{}; + Weights_Layer q_w_{}; + bool has_q_b_{}; + Weights_Layer q_b_{}; + bool has_k_w_{}; + Weights_Layer k_w_{}; + bool has_k_b_{}; + Weights_Layer k_b_{}; + bool has_v_w_{}; + Weights_Layer v_w_{}; + bool has_v_b_{}; + Weights_Layer v_b_{}; + bool has_dense_w_{}; + Weights_Layer dense_w_{}; + bool has_dense_b_{}; + Weights_Layer dense_b_{}; + bool has_smolgen_{}; + Weights_Smolgen smolgen_{}; +}; + +class Weights_FFN final : public lczero::ProtoMessage { + public: + + bool has_dense1_w() const; + const Weights_Layer& dense1_w() const; + Weights_Layer* mutable_dense1_w(); + + bool has_dense1_b() const; + const Weights_Layer& dense1_b() const; + Weights_Layer* mutable_dense1_b(); + + bool has_dense2_w() const; + const Weights_Layer& dense2_w() const; + Weights_Layer* mutable_dense2_w(); + + bool has_dense2_b() const; + const Weights_Layer& dense2_b() const; + Weights_Layer* mutable_dense2_b(); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetString(int field_id, std::string_view val) final; + + bool has_dense1_w_{}; + Weights_Layer dense1_w_{}; + bool has_dense1_b_{}; + Weights_Layer dense1_b_{}; + bool has_dense2_w_{}; + Weights_Layer dense2_w_{}; + bool has_dense2_b_{}; + Weights_Layer dense2_b_{}; +}; + +class Weights_EncoderLayer final : public lczero::ProtoMessage { + public: + + bool has_mha() const; + const Weights_MHA& mha() const; + Weights_MHA* mutable_mha(); + + bool has_ln1_gammas() const; + const Weights_Layer& ln1_gammas() const; + Weights_Layer* mutable_ln1_gammas(); + + bool has_ln1_betas() const; + const Weights_Layer& ln1_betas() const; + Weights_Layer* mutable_ln1_betas(); + + bool has_ffn() const; + const Weights_FFN& ffn() const; + Weights_FFN* mutable_ffn(); + + bool has_ln2_gammas() const; + const Weights_Layer& ln2_gammas() const; + Weights_Layer* mutable_ln2_gammas(); + + bool has_ln2_betas() const; + const Weights_Layer& ln2_betas() const; + Weights_Layer* mutable_ln2_betas(); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetString(int field_id, std::string_view val) final; + + bool has_mha_{}; + Weights_MHA mha_{}; + bool has_ln1_gammas_{}; + Weights_Layer ln1_gammas_{}; + bool has_ln1_betas_{}; + Weights_Layer ln1_betas_{}; + bool has_ffn_{}; + Weights_FFN ffn_{}; + bool has_ln2_gammas_{}; + Weights_Layer ln2_gammas_{}; + bool has_ln2_betas_{}; + Weights_Layer ln2_betas_{}; +}; + +class Weights final : public lczero::ProtoMessage { + public: + using Layer = Weights_Layer; + using ConvBlock = Weights_ConvBlock; + using SEunit = Weights_SEunit; + using Residual = Weights_Residual; + using Smolgen = Weights_Smolgen; + using MHA = Weights_MHA; + using FFN = Weights_FFN; + using EncoderLayer = Weights_EncoderLayer; + + bool has_input() const; + const Weights_ConvBlock& input() const; + Weights_ConvBlock* mutable_input(); + + Weights_Residual* add_residual(); + const std::vector& residual() const; + std::vector* mutable_residual(); + const Weights_Residual& residual(size_t idx) const; + Weights_Residual* mutable_residual(size_t idx); + size_t residual_size() const; + + bool has_ip_emb_w() const; + const Weights_Layer& ip_emb_w() const; + Weights_Layer* mutable_ip_emb_w(); + + bool has_ip_emb_b() const; + const Weights_Layer& ip_emb_b() const; + Weights_Layer* mutable_ip_emb_b(); + + bool has_ip_mult_gate() const; + const Weights_Layer& ip_mult_gate() const; + Weights_Layer* mutable_ip_mult_gate(); + + bool has_ip_add_gate() const; + const Weights_Layer& ip_add_gate() const; + Weights_Layer* mutable_ip_add_gate(); + + Weights_EncoderLayer* add_encoder(); + const std::vector& encoder() const; + std::vector* mutable_encoder(); + const Weights_EncoderLayer& encoder(size_t idx) const; + Weights_EncoderLayer* mutable_encoder(size_t idx); + size_t encoder_size() const; + + bool has_headcount() const; + std::uint32_t headcount() const; + void set_headcount(std::uint32_t val); + + Weights_EncoderLayer* add_pol_encoder(); + const std::vector& pol_encoder() const; + std::vector* mutable_pol_encoder(); + const Weights_EncoderLayer& pol_encoder(size_t idx) const; + Weights_EncoderLayer* mutable_pol_encoder(size_t idx); + size_t pol_encoder_size() const; + + bool has_pol_headcount() const; + std::uint32_t pol_headcount() const; + void set_pol_headcount(std::uint32_t val); + + bool has_policy1() const; + const Weights_ConvBlock& policy1() const; + Weights_ConvBlock* mutable_policy1(); + + bool has_policy() const; + const Weights_ConvBlock& policy() const; + Weights_ConvBlock* mutable_policy(); + + bool has_ip_pol_w() const; + const Weights_Layer& ip_pol_w() const; + Weights_Layer* mutable_ip_pol_w(); + + bool has_ip_pol_b() const; + const Weights_Layer& ip_pol_b() const; + Weights_Layer* mutable_ip_pol_b(); + + bool has_ip2_pol_w() const; + const Weights_Layer& ip2_pol_w() const; + Weights_Layer* mutable_ip2_pol_w(); + + bool has_ip2_pol_b() const; + const Weights_Layer& ip2_pol_b() const; + Weights_Layer* mutable_ip2_pol_b(); + + bool has_ip3_pol_w() const; + const Weights_Layer& ip3_pol_w() const; + Weights_Layer* mutable_ip3_pol_w(); + + bool has_ip3_pol_b() const; + const Weights_Layer& ip3_pol_b() const; + Weights_Layer* mutable_ip3_pol_b(); + + bool has_ip4_pol_w() const; + const Weights_Layer& ip4_pol_w() const; + Weights_Layer* mutable_ip4_pol_w(); + + bool has_value() const; + const Weights_ConvBlock& value() const; + Weights_ConvBlock* mutable_value(); + + bool has_ip_val_w() const; + const Weights_Layer& ip_val_w() const; + Weights_Layer* mutable_ip_val_w(); + + bool has_ip_val_b() const; + const Weights_Layer& ip_val_b() const; + Weights_Layer* mutable_ip_val_b(); + + bool has_ip1_val_w() const; + const Weights_Layer& ip1_val_w() const; + Weights_Layer* mutable_ip1_val_w(); + + bool has_ip1_val_b() const; + const Weights_Layer& ip1_val_b() const; + Weights_Layer* mutable_ip1_val_b(); + + bool has_ip2_val_w() const; + const Weights_Layer& ip2_val_w() const; + Weights_Layer* mutable_ip2_val_w(); + + bool has_ip2_val_b() const; + const Weights_Layer& ip2_val_b() const; + Weights_Layer* mutable_ip2_val_b(); + + bool has_moves_left() const; + const Weights_ConvBlock& moves_left() const; + Weights_ConvBlock* mutable_moves_left(); + + bool has_ip_mov_w() const; + const Weights_Layer& ip_mov_w() const; + Weights_Layer* mutable_ip_mov_w(); + + bool has_ip_mov_b() const; + const Weights_Layer& ip_mov_b() const; + Weights_Layer* mutable_ip_mov_b(); + + bool has_ip1_mov_w() const; + const Weights_Layer& ip1_mov_w() const; + Weights_Layer* mutable_ip1_mov_w(); + + bool has_ip1_mov_b() const; + const Weights_Layer& ip1_mov_b() const; + Weights_Layer* mutable_ip1_mov_b(); + + bool has_ip2_mov_w() const; + const Weights_Layer& ip2_mov_w() const; + Weights_Layer* mutable_ip2_mov_w(); + + bool has_ip2_mov_b() const; + const Weights_Layer& ip2_mov_b() const; + Weights_Layer* mutable_ip2_mov_b(); + + bool has_smolgen_w() const; + const Weights_Layer& smolgen_w() const; + Weights_Layer* mutable_smolgen_w(); + + bool has_smolgen_b() const; + const Weights_Layer& smolgen_b() const; + Weights_Layer* mutable_smolgen_b(); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetString(int field_id, std::string_view val) final; + void SetVarInt(int field_id, std::uint64_t val) final; + + bool has_input_{}; + Weights_ConvBlock input_{}; + std::vector residual_; + bool has_ip_emb_w_{}; + Weights_Layer ip_emb_w_{}; + bool has_ip_emb_b_{}; + Weights_Layer ip_emb_b_{}; + bool has_ip_mult_gate_{}; + Weights_Layer ip_mult_gate_{}; + bool has_ip_add_gate_{}; + Weights_Layer ip_add_gate_{}; + std::vector encoder_; + bool has_headcount_{}; + std::uint32_t headcount_{}; + std::vector pol_encoder_; + bool has_pol_headcount_{}; + std::uint32_t pol_headcount_{}; + bool has_policy1_{}; + Weights_ConvBlock policy1_{}; + bool has_policy_{}; + Weights_ConvBlock policy_{}; + bool has_ip_pol_w_{}; + Weights_Layer ip_pol_w_{}; + bool has_ip_pol_b_{}; + Weights_Layer ip_pol_b_{}; + bool has_ip2_pol_w_{}; + Weights_Layer ip2_pol_w_{}; + bool has_ip2_pol_b_{}; + Weights_Layer ip2_pol_b_{}; + bool has_ip3_pol_w_{}; + Weights_Layer ip3_pol_w_{}; + bool has_ip3_pol_b_{}; + Weights_Layer ip3_pol_b_{}; + bool has_ip4_pol_w_{}; + Weights_Layer ip4_pol_w_{}; + bool has_value_{}; + Weights_ConvBlock value_{}; + bool has_ip_val_w_{}; + Weights_Layer ip_val_w_{}; + bool has_ip_val_b_{}; + Weights_Layer ip_val_b_{}; + bool has_ip1_val_w_{}; + Weights_Layer ip1_val_w_{}; + bool has_ip1_val_b_{}; + Weights_Layer ip1_val_b_{}; + bool has_ip2_val_w_{}; + Weights_Layer ip2_val_w_{}; + bool has_ip2_val_b_{}; + Weights_Layer ip2_val_b_{}; + bool has_moves_left_{}; + Weights_ConvBlock moves_left_{}; + bool has_ip_mov_w_{}; + Weights_Layer ip_mov_w_{}; + bool has_ip_mov_b_{}; + Weights_Layer ip_mov_b_{}; + bool has_ip1_mov_w_{}; + Weights_Layer ip1_mov_w_{}; + bool has_ip1_mov_b_{}; + Weights_Layer ip1_mov_b_{}; + bool has_ip2_mov_w_{}; + Weights_Layer ip2_mov_w_{}; + bool has_ip2_mov_b_{}; + Weights_Layer ip2_mov_b_{}; + bool has_smolgen_w_{}; + Weights_Layer smolgen_w_{}; + bool has_smolgen_b_{}; + Weights_Layer smolgen_b_{}; +}; + +class TrainingParams final : public lczero::ProtoMessage { + public: + + bool has_training_steps() const; + std::uint32_t training_steps() const; + void set_training_steps(std::uint32_t val); + + bool has_learning_rate() const; + float learning_rate() const; + void set_learning_rate(float val); + + bool has_mse_loss() const; + float mse_loss() const; + void set_mse_loss(float val); + + bool has_policy_loss() const; + float policy_loss() const; + void set_policy_loss(float val); + + bool has_accuracy() const; + float accuracy() const; + void set_accuracy(float val); + + bool has_lc0_params() const; + std::string_view lc0_params() const; + void set_lc0_params(std::string_view val); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetVarInt(int field_id, std::uint64_t val) final; + void SetInt32(int field_id, std::uint32_t val) final; + void SetString(int field_id, std::string_view val) final; + + bool has_training_steps_{}; + std::uint32_t training_steps_{}; + bool has_learning_rate_{}; + float learning_rate_{}; + bool has_mse_loss_{}; + float mse_loss_{}; + bool has_policy_loss_{}; + float policy_loss_{}; + bool has_accuracy_{}; + float accuracy_{}; + bool has_lc0_params_{}; + std::string lc0_params_{}; +}; + +class NetworkFormat final : public lczero::ProtoMessage { + public: + using InputFormat = NetworkFormat_InputFormat; + static constexpr InputFormat INPUT_UNKNOWN = + NetworkFormat_InputFormat_INPUT_UNKNOWN; + static constexpr InputFormat INPUT_CLASSICAL_112_PLANE = + NetworkFormat_InputFormat_INPUT_CLASSICAL_112_PLANE; + static constexpr InputFormat INPUT_112_WITH_CASTLING_PLANE = + NetworkFormat_InputFormat_INPUT_112_WITH_CASTLING_PLANE; + static constexpr InputFormat INPUT_112_WITH_CANONICALIZATION = + NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION; + static constexpr InputFormat INPUT_112_WITH_CANONICALIZATION_HECTOPLIES = + NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION_HECTOPLIES; + static constexpr InputFormat INPUT_112_WITH_CANONICALIZATION_HECTOPLIES_ARMAGEDDON = + NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION_HECTOPLIES_ARMAGEDDON; + static constexpr InputFormat INPUT_112_WITH_CANONICALIZATION_V2 = + NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION_V2; + static constexpr InputFormat INPUT_112_WITH_CANONICALIZATION_V2_ARMAGEDDON = + NetworkFormat_InputFormat_INPUT_112_WITH_CANONICALIZATION_V2_ARMAGEDDON; + static constexpr std::array InputFormat_AllValues = { + INPUT_UNKNOWN, + INPUT_CLASSICAL_112_PLANE, + INPUT_112_WITH_CASTLING_PLANE, + INPUT_112_WITH_CANONICALIZATION, + INPUT_112_WITH_CANONICALIZATION_HECTOPLIES, + INPUT_112_WITH_CANONICALIZATION_HECTOPLIES_ARMAGEDDON, + INPUT_112_WITH_CANONICALIZATION_V2, + INPUT_112_WITH_CANONICALIZATION_V2_ARMAGEDDON, + }; + static std::string InputFormat_Name(InputFormat val) { + return NetworkFormat_InputFormat_Name(val); + } + using OutputFormat = NetworkFormat_OutputFormat; + static constexpr OutputFormat OUTPUT_UNKNOWN = + NetworkFormat_OutputFormat_OUTPUT_UNKNOWN; + static constexpr OutputFormat OUTPUT_CLASSICAL = + NetworkFormat_OutputFormat_OUTPUT_CLASSICAL; + static constexpr OutputFormat OUTPUT_WDL = + NetworkFormat_OutputFormat_OUTPUT_WDL; + static constexpr std::array OutputFormat_AllValues = { + OUTPUT_UNKNOWN, + OUTPUT_CLASSICAL, + OUTPUT_WDL, + }; + static std::string OutputFormat_Name(OutputFormat val) { + return NetworkFormat_OutputFormat_Name(val); + } + using NetworkStructure = NetworkFormat_NetworkStructure; + static constexpr NetworkStructure NETWORK_UNKNOWN = + NetworkFormat_NetworkStructure_NETWORK_UNKNOWN; + static constexpr NetworkStructure NETWORK_CLASSICAL = + NetworkFormat_NetworkStructure_NETWORK_CLASSICAL; + static constexpr NetworkStructure NETWORK_SE = + NetworkFormat_NetworkStructure_NETWORK_SE; + static constexpr NetworkStructure NETWORK_CLASSICAL_WITH_HEADFORMAT = + NetworkFormat_NetworkStructure_NETWORK_CLASSICAL_WITH_HEADFORMAT; + static constexpr NetworkStructure NETWORK_SE_WITH_HEADFORMAT = + NetworkFormat_NetworkStructure_NETWORK_SE_WITH_HEADFORMAT; + static constexpr NetworkStructure NETWORK_ONNX = + NetworkFormat_NetworkStructure_NETWORK_ONNX; + static constexpr NetworkStructure NETWORK_ATTENTIONBODY_WITH_HEADFORMAT = + NetworkFormat_NetworkStructure_NETWORK_ATTENTIONBODY_WITH_HEADFORMAT; + static constexpr std::array NetworkStructure_AllValues = { + NETWORK_UNKNOWN, + NETWORK_CLASSICAL, + NETWORK_SE, + NETWORK_CLASSICAL_WITH_HEADFORMAT, + NETWORK_SE_WITH_HEADFORMAT, + NETWORK_ONNX, + NETWORK_ATTENTIONBODY_WITH_HEADFORMAT, + }; + static std::string NetworkStructure_Name(NetworkStructure val) { + return NetworkFormat_NetworkStructure_Name(val); + } + using PolicyFormat = NetworkFormat_PolicyFormat; + static constexpr PolicyFormat POLICY_UNKNOWN = + NetworkFormat_PolicyFormat_POLICY_UNKNOWN; + static constexpr PolicyFormat POLICY_CLASSICAL = + NetworkFormat_PolicyFormat_POLICY_CLASSICAL; + static constexpr PolicyFormat POLICY_CONVOLUTION = + NetworkFormat_PolicyFormat_POLICY_CONVOLUTION; + static constexpr PolicyFormat POLICY_ATTENTION = + NetworkFormat_PolicyFormat_POLICY_ATTENTION; + static constexpr std::array PolicyFormat_AllValues = { + POLICY_UNKNOWN, + POLICY_CLASSICAL, + POLICY_CONVOLUTION, + POLICY_ATTENTION, + }; + static std::string PolicyFormat_Name(PolicyFormat val) { + return NetworkFormat_PolicyFormat_Name(val); + } + using ValueFormat = NetworkFormat_ValueFormat; + static constexpr ValueFormat VALUE_UNKNOWN = + NetworkFormat_ValueFormat_VALUE_UNKNOWN; + static constexpr ValueFormat VALUE_CLASSICAL = + NetworkFormat_ValueFormat_VALUE_CLASSICAL; + static constexpr ValueFormat VALUE_WDL = + NetworkFormat_ValueFormat_VALUE_WDL; + static constexpr ValueFormat VALUE_PARAM = + NetworkFormat_ValueFormat_VALUE_PARAM; + static constexpr std::array ValueFormat_AllValues = { + VALUE_UNKNOWN, + VALUE_CLASSICAL, + VALUE_WDL, + VALUE_PARAM, + }; + static std::string ValueFormat_Name(ValueFormat val) { + return NetworkFormat_ValueFormat_Name(val); + } + using MovesLeftFormat = NetworkFormat_MovesLeftFormat; + static constexpr MovesLeftFormat MOVES_LEFT_NONE = + NetworkFormat_MovesLeftFormat_MOVES_LEFT_NONE; + static constexpr MovesLeftFormat MOVES_LEFT_V1 = + NetworkFormat_MovesLeftFormat_MOVES_LEFT_V1; + static constexpr std::array MovesLeftFormat_AllValues = { + MOVES_LEFT_NONE, + MOVES_LEFT_V1, + }; + static std::string MovesLeftFormat_Name(MovesLeftFormat val) { + return NetworkFormat_MovesLeftFormat_Name(val); + } + using ActivationFunction = NetworkFormat_ActivationFunction; + static constexpr ActivationFunction ACTIVATION_DEFAULT = + NetworkFormat_ActivationFunction_ACTIVATION_DEFAULT; + static constexpr ActivationFunction ACTIVATION_MISH = + NetworkFormat_ActivationFunction_ACTIVATION_MISH; + static constexpr ActivationFunction ACTIVATION_RELU = + NetworkFormat_ActivationFunction_ACTIVATION_RELU; + static constexpr ActivationFunction ACTIVATION_NONE = + NetworkFormat_ActivationFunction_ACTIVATION_NONE; + static constexpr ActivationFunction ACTIVATION_TANH = + NetworkFormat_ActivationFunction_ACTIVATION_TANH; + static constexpr ActivationFunction ACTIVATION_SIGMOID = + NetworkFormat_ActivationFunction_ACTIVATION_SIGMOID; + static constexpr ActivationFunction ACTIVATION_SELU = + NetworkFormat_ActivationFunction_ACTIVATION_SELU; + static constexpr ActivationFunction ACTIVATION_SWISH = + NetworkFormat_ActivationFunction_ACTIVATION_SWISH; + static constexpr ActivationFunction ACTIVATION_RELU_2 = + NetworkFormat_ActivationFunction_ACTIVATION_RELU_2; + static constexpr ActivationFunction ACTIVATION_SOFTMAX = + NetworkFormat_ActivationFunction_ACTIVATION_SOFTMAX; + static constexpr std::array ActivationFunction_AllValues = { + ACTIVATION_DEFAULT, + ACTIVATION_MISH, + ACTIVATION_RELU, + ACTIVATION_NONE, + ACTIVATION_TANH, + ACTIVATION_SIGMOID, + ACTIVATION_SELU, + ACTIVATION_SWISH, + ACTIVATION_RELU_2, + ACTIVATION_SOFTMAX, + }; + static std::string ActivationFunction_Name(ActivationFunction val) { + return NetworkFormat_ActivationFunction_Name(val); + } + using DefaultActivation = NetworkFormat_DefaultActivation; + static constexpr DefaultActivation DEFAULT_ACTIVATION_RELU = + NetworkFormat_DefaultActivation_DEFAULT_ACTIVATION_RELU; + static constexpr DefaultActivation DEFAULT_ACTIVATION_MISH = + NetworkFormat_DefaultActivation_DEFAULT_ACTIVATION_MISH; + static constexpr std::array DefaultActivation_AllValues = { + DEFAULT_ACTIVATION_RELU, + DEFAULT_ACTIVATION_MISH, + }; + static std::string DefaultActivation_Name(DefaultActivation val) { + return NetworkFormat_DefaultActivation_Name(val); + } + + bool has_input() const; + NetworkFormat_InputFormat input() const; + void set_input(NetworkFormat_InputFormat val); + + bool has_output() const; + NetworkFormat_OutputFormat output() const; + void set_output(NetworkFormat_OutputFormat val); + + bool has_network() const; + NetworkFormat_NetworkStructure network() const; + void set_network(NetworkFormat_NetworkStructure val); + + bool has_policy() const; + NetworkFormat_PolicyFormat policy() const; + void set_policy(NetworkFormat_PolicyFormat val); + + bool has_value() const; + NetworkFormat_ValueFormat value() const; + void set_value(NetworkFormat_ValueFormat val); + + bool has_moves_left() const; + NetworkFormat_MovesLeftFormat moves_left() const; + void set_moves_left(NetworkFormat_MovesLeftFormat val); + + bool has_default_activation() const; + NetworkFormat_DefaultActivation default_activation() const; + void set_default_activation(NetworkFormat_DefaultActivation val); + + bool has_smolgen_activation() const; + NetworkFormat_ActivationFunction smolgen_activation() const; + void set_smolgen_activation(NetworkFormat_ActivationFunction val); + + bool has_ffn_activation() const; + NetworkFormat_ActivationFunction ffn_activation() const; + void set_ffn_activation(NetworkFormat_ActivationFunction val); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetVarInt(int field_id, std::uint64_t val) final; + + bool has_input_{}; + NetworkFormat_InputFormat input_{}; + bool has_output_{}; + NetworkFormat_OutputFormat output_{}; + bool has_network_{}; + NetworkFormat_NetworkStructure network_{}; + bool has_policy_{}; + NetworkFormat_PolicyFormat policy_{}; + bool has_value_{}; + NetworkFormat_ValueFormat value_{}; + bool has_moves_left_{}; + NetworkFormat_MovesLeftFormat moves_left_{}; + bool has_default_activation_{}; + NetworkFormat_DefaultActivation default_activation_{}; + bool has_smolgen_activation_{}; + NetworkFormat_ActivationFunction smolgen_activation_{}; + bool has_ffn_activation_{}; + NetworkFormat_ActivationFunction ffn_activation_{}; +}; + +class Format final : public lczero::ProtoMessage { + public: + using Encoding = Format_Encoding; + static constexpr Encoding UNKNOWN = + Format_Encoding_UNKNOWN; + static constexpr Encoding LINEAR16 = + Format_Encoding_LINEAR16; + static constexpr std::array Encoding_AllValues = { + UNKNOWN, + LINEAR16, + }; + static std::string Encoding_Name(Encoding val) { + return Format_Encoding_Name(val); + } + + bool has_weights_encoding() const; + Format_Encoding weights_encoding() const; + void set_weights_encoding(Format_Encoding val); + + bool has_network_format() const; + const NetworkFormat& network_format() const; + NetworkFormat* mutable_network_format(); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetVarInt(int field_id, std::uint64_t val) final; + void SetString(int field_id, std::string_view val) final; + + bool has_weights_encoding_{}; + Format_Encoding weights_encoding_{}; + bool has_network_format_{}; + NetworkFormat network_format_{}; +}; + +class OnnxModel final : public lczero::ProtoMessage { + public: + using DataType = OnnxModel_DataType; + static constexpr DataType UNKNOWN_DATATYPE = + OnnxModel_DataType_UNKNOWN_DATATYPE; + static constexpr DataType FLOAT = + OnnxModel_DataType_FLOAT; + static constexpr DataType FLOAT16 = + OnnxModel_DataType_FLOAT16; + static constexpr DataType BFLOAT16 = + OnnxModel_DataType_BFLOAT16; + static constexpr std::array DataType_AllValues = { + UNKNOWN_DATATYPE, + FLOAT, + FLOAT16, + BFLOAT16, + }; + static std::string DataType_Name(DataType val) { + return OnnxModel_DataType_Name(val); + } + + bool has_model() const; + std::string_view model() const; + void set_model(std::string_view val); + + bool has_data_type() const; + OnnxModel_DataType data_type() const; + void set_data_type(OnnxModel_DataType val); + + bool has_input_planes() const; + std::string_view input_planes() const; + void set_input_planes(std::string_view val); + + bool has_output_value() const; + std::string_view output_value() const; + void set_output_value(std::string_view val); + + bool has_output_wdl() const; + std::string_view output_wdl() const; + void set_output_wdl(std::string_view val); + + bool has_output_policy() const; + std::string_view output_policy() const; + void set_output_policy(std::string_view val); + + bool has_output_mlh() const; + std::string_view output_mlh() const; + void set_output_mlh(std::string_view val); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetString(int field_id, std::string_view val) final; + void SetVarInt(int field_id, std::uint64_t val) final; + + bool has_model_{}; + std::string model_{}; + bool has_data_type_{}; + OnnxModel_DataType data_type_{}; + bool has_input_planes_{}; + std::string input_planes_{}; + bool has_output_value_{}; + std::string output_value_{}; + bool has_output_wdl_{}; + std::string output_wdl_{}; + bool has_output_policy_{}; + std::string output_policy_{}; + bool has_output_mlh_{}; + std::string output_mlh_{}; +}; + +class Net final : public lczero::ProtoMessage { + public: + + bool has_magic() const; + std::uint32_t magic() const; + void set_magic(std::uint32_t val); + + bool has_license() const; + std::string_view license() const; + void set_license(std::string_view val); + + bool has_min_version() const; + const EngineVersion& min_version() const; + EngineVersion* mutable_min_version(); + + bool has_format() const; + const Format& format() const; + Format* mutable_format(); + + bool has_training_params() const; + const TrainingParams& training_params() const; + TrainingParams* mutable_training_params(); + + bool has_weights() const; + const Weights& weights() const; + Weights* mutable_weights(); + + bool has_onnx_model() const; + const OnnxModel& onnx_model() const; + OnnxModel* mutable_onnx_model(); + + std::string OutputAsString() const final; + std::string OutputAsJson() const final; + void Clear() final; + + private: + void SetInt32(int field_id, std::uint32_t val) final; + void SetString(int field_id, std::string_view val) final; + + bool has_magic_{}; + std::uint32_t magic_{}; + bool has_license_{}; + std::string license_{}; + bool has_min_version_{}; + EngineVersion min_version_{}; + bool has_format_{}; + Format format_{}; + bool has_training_params_{}; + TrainingParams training_params_{}; + bool has_weights_{}; + Weights weights_{}; + bool has_onnx_model_{}; + OnnxModel onnx_model_{}; +}; + + +// Function definitions. +inline std::string EngineVersion::OutputAsString() const { + std::string out; + if (has_major_) AppendVarInt(1, major_, &out); + if (has_minor_) AppendVarInt(2, minor_, &out); + if (has_patch_) AppendVarInt(3, patch_, &out); + return out; +} +inline std::string EngineVersion::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_major_) AppendJsonField("major", major_, &first, &out); + if (has_minor_) AppendJsonField("minor", minor_, &first, &out); + if (has_patch_) AppendJsonField("patch", patch_, &first, &out); + out += "}"; + return out; +} +inline void EngineVersion::Clear() { + has_major_ = false; + major_ = {}; + has_minor_ = false; + minor_ = {}; + has_patch_ = false; + patch_ = {}; +} +inline void EngineVersion::SetVarInt(int field_id, std::uint64_t val) { + switch (field_id) { + case 1: set_major(static_cast(val)); break; + case 2: set_minor(static_cast(val)); break; + case 3: set_patch(static_cast(val)); break; + } +} +inline bool EngineVersion::has_major() const { return has_major_; } +inline std::uint32_t EngineVersion::major() const { return major_; } +inline void EngineVersion::set_major(std::uint32_t val) { + has_major_ = true; + major_ = val; +} +inline bool EngineVersion::has_minor() const { return has_minor_; } +inline std::uint32_t EngineVersion::minor() const { return minor_; } +inline void EngineVersion::set_minor(std::uint32_t val) { + has_minor_ = true; + minor_ = val; +} +inline bool EngineVersion::has_patch() const { return has_patch_; } +inline std::uint32_t EngineVersion::patch() const { return patch_; } +inline void EngineVersion::set_patch(std::uint32_t val) { + has_patch_ = true; + patch_ = val; +} +inline std::string Weights_Layer::OutputAsString() const { + std::string out; + if (has_min_val_) AppendInt32(1, bit_cast(min_val_), &out); + if (has_max_val_) AppendInt32(2, bit_cast(max_val_), &out); + if (has_params_) AppendString(3, params_, &out); + return out; +} +inline std::string Weights_Layer::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_min_val_) AppendJsonField("min_val", min_val_, &first, &out); + if (has_max_val_) AppendJsonField("max_val", max_val_, &first, &out); + if (has_params_) AppendJsonField("params", params_, &first, &out); + out += "}"; + return out; +} +inline void Weights_Layer::Clear() { + has_min_val_ = false; + min_val_ = {}; + has_max_val_ = false; + max_val_ = {}; + has_params_ = false; + params_ = {}; +} +inline void Weights_Layer::SetInt32(int field_id, std::uint32_t val) { + switch (field_id) { + case 1: set_min_val(bit_cast(val)); break; + case 2: set_max_val(bit_cast(val)); break; + } +} +inline void Weights_Layer::SetString(int field_id, std::string_view val) { + switch (field_id) { + case 3: set_params(val); break; + } +} +inline bool Weights_Layer::has_min_val() const { return has_min_val_; } +inline float Weights_Layer::min_val() const { return min_val_; } +inline void Weights_Layer::set_min_val(float val) { + has_min_val_ = true; + min_val_ = val; +} +inline bool Weights_Layer::has_max_val() const { return has_max_val_; } +inline float Weights_Layer::max_val() const { return max_val_; } +inline void Weights_Layer::set_max_val(float val) { + has_max_val_ = true; + max_val_ = val; +} +inline bool Weights_Layer::has_params() const { return has_params_; } +inline std::string_view Weights_Layer::params() const { return params_; } +inline void Weights_Layer::set_params(std::string_view val) { + has_params_ = true; + params_ = val; +} +inline std::string Weights_ConvBlock::OutputAsString() const { + std::string out; + if (has_weights_) AppendString(1, weights_.OutputAsString(), &out); + if (has_biases_) AppendString(2, biases_.OutputAsString(), &out); + if (has_bn_means_) AppendString(3, bn_means_.OutputAsString(), &out); + if (has_bn_stddivs_) AppendString(4, bn_stddivs_.OutputAsString(), &out); + if (has_bn_gammas_) AppendString(5, bn_gammas_.OutputAsString(), &out); + if (has_bn_betas_) AppendString(6, bn_betas_.OutputAsString(), &out); + return out; +} +inline std::string Weights_ConvBlock::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_weights_) AppendJsonField("weights", weights_, &first, &out); + if (has_biases_) AppendJsonField("biases", biases_, &first, &out); + if (has_bn_means_) AppendJsonField("bn_means", bn_means_, &first, &out); + if (has_bn_stddivs_) AppendJsonField("bn_stddivs", bn_stddivs_, &first, &out); + if (has_bn_gammas_) AppendJsonField("bn_gammas", bn_gammas_, &first, &out); + if (has_bn_betas_) AppendJsonField("bn_betas", bn_betas_, &first, &out); + out += "}"; + return out; +} +inline void Weights_ConvBlock::Clear() { + has_weights_ = false; + weights_ = {}; + has_biases_ = false; + biases_ = {}; + has_bn_means_ = false; + bn_means_ = {}; + has_bn_stddivs_ = false; + bn_stddivs_ = {}; + has_bn_gammas_ = false; + bn_gammas_ = {}; + has_bn_betas_ = false; + bn_betas_ = {}; +} +inline void Weights_ConvBlock::SetString(int field_id, std::string_view val) { + switch (field_id) { + case 1: mutable_weights()->MergeFromString(val); break; + case 2: mutable_biases()->MergeFromString(val); break; + case 3: mutable_bn_means()->MergeFromString(val); break; + case 4: mutable_bn_stddivs()->MergeFromString(val); break; + case 5: mutable_bn_gammas()->MergeFromString(val); break; + case 6: mutable_bn_betas()->MergeFromString(val); break; + } +} +inline bool Weights_ConvBlock::has_weights() const { return has_weights_; } +inline const Weights_Layer& Weights_ConvBlock::weights() const { return weights_; } +inline Weights_Layer* Weights_ConvBlock::mutable_weights() { + has_weights_ = true; + return &weights_; +} +inline bool Weights_ConvBlock::has_biases() const { return has_biases_; } +inline const Weights_Layer& Weights_ConvBlock::biases() const { return biases_; } +inline Weights_Layer* Weights_ConvBlock::mutable_biases() { + has_biases_ = true; + return &biases_; +} +inline bool Weights_ConvBlock::has_bn_means() const { return has_bn_means_; } +inline const Weights_Layer& Weights_ConvBlock::bn_means() const { return bn_means_; } +inline Weights_Layer* Weights_ConvBlock::mutable_bn_means() { + has_bn_means_ = true; + return &bn_means_; +} +inline bool Weights_ConvBlock::has_bn_stddivs() const { return has_bn_stddivs_; } +inline const Weights_Layer& Weights_ConvBlock::bn_stddivs() const { return bn_stddivs_; } +inline Weights_Layer* Weights_ConvBlock::mutable_bn_stddivs() { + has_bn_stddivs_ = true; + return &bn_stddivs_; +} +inline bool Weights_ConvBlock::has_bn_gammas() const { return has_bn_gammas_; } +inline const Weights_Layer& Weights_ConvBlock::bn_gammas() const { return bn_gammas_; } +inline Weights_Layer* Weights_ConvBlock::mutable_bn_gammas() { + has_bn_gammas_ = true; + return &bn_gammas_; +} +inline bool Weights_ConvBlock::has_bn_betas() const { return has_bn_betas_; } +inline const Weights_Layer& Weights_ConvBlock::bn_betas() const { return bn_betas_; } +inline Weights_Layer* Weights_ConvBlock::mutable_bn_betas() { + has_bn_betas_ = true; + return &bn_betas_; +} +inline std::string Weights_SEunit::OutputAsString() const { + std::string out; + if (has_w1_) AppendString(1, w1_.OutputAsString(), &out); + if (has_b1_) AppendString(2, b1_.OutputAsString(), &out); + if (has_w2_) AppendString(3, w2_.OutputAsString(), &out); + if (has_b2_) AppendString(4, b2_.OutputAsString(), &out); + return out; +} +inline std::string Weights_SEunit::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_w1_) AppendJsonField("w1", w1_, &first, &out); + if (has_b1_) AppendJsonField("b1", b1_, &first, &out); + if (has_w2_) AppendJsonField("w2", w2_, &first, &out); + if (has_b2_) AppendJsonField("b2", b2_, &first, &out); + out += "}"; + return out; +} +inline void Weights_SEunit::Clear() { + has_w1_ = false; + w1_ = {}; + has_b1_ = false; + b1_ = {}; + has_w2_ = false; + w2_ = {}; + has_b2_ = false; + b2_ = {}; +} +inline void Weights_SEunit::SetString(int field_id, std::string_view val) { + switch (field_id) { + case 1: mutable_w1()->MergeFromString(val); break; + case 2: mutable_b1()->MergeFromString(val); break; + case 3: mutable_w2()->MergeFromString(val); break; + case 4: mutable_b2()->MergeFromString(val); break; + } +} +inline bool Weights_SEunit::has_w1() const { return has_w1_; } +inline const Weights_Layer& Weights_SEunit::w1() const { return w1_; } +inline Weights_Layer* Weights_SEunit::mutable_w1() { + has_w1_ = true; + return &w1_; +} +inline bool Weights_SEunit::has_b1() const { return has_b1_; } +inline const Weights_Layer& Weights_SEunit::b1() const { return b1_; } +inline Weights_Layer* Weights_SEunit::mutable_b1() { + has_b1_ = true; + return &b1_; +} +inline bool Weights_SEunit::has_w2() const { return has_w2_; } +inline const Weights_Layer& Weights_SEunit::w2() const { return w2_; } +inline Weights_Layer* Weights_SEunit::mutable_w2() { + has_w2_ = true; + return &w2_; +} +inline bool Weights_SEunit::has_b2() const { return has_b2_; } +inline const Weights_Layer& Weights_SEunit::b2() const { return b2_; } +inline Weights_Layer* Weights_SEunit::mutable_b2() { + has_b2_ = true; + return &b2_; +} +inline std::string Weights_Residual::OutputAsString() const { + std::string out; + if (has_conv1_) AppendString(1, conv1_.OutputAsString(), &out); + if (has_conv2_) AppendString(2, conv2_.OutputAsString(), &out); + if (has_se_) AppendString(3, se_.OutputAsString(), &out); + return out; +} +inline std::string Weights_Residual::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_conv1_) AppendJsonField("conv1", conv1_, &first, &out); + if (has_conv2_) AppendJsonField("conv2", conv2_, &first, &out); + if (has_se_) AppendJsonField("se", se_, &first, &out); + out += "}"; + return out; +} +inline void Weights_Residual::Clear() { + has_conv1_ = false; + conv1_ = {}; + has_conv2_ = false; + conv2_ = {}; + has_se_ = false; + se_ = {}; +} +inline void Weights_Residual::SetString(int field_id, std::string_view val) { + switch (field_id) { + case 1: mutable_conv1()->MergeFromString(val); break; + case 2: mutable_conv2()->MergeFromString(val); break; + case 3: mutable_se()->MergeFromString(val); break; + } +} +inline bool Weights_Residual::has_conv1() const { return has_conv1_; } +inline const Weights_ConvBlock& Weights_Residual::conv1() const { return conv1_; } +inline Weights_ConvBlock* Weights_Residual::mutable_conv1() { + has_conv1_ = true; + return &conv1_; +} +inline bool Weights_Residual::has_conv2() const { return has_conv2_; } +inline const Weights_ConvBlock& Weights_Residual::conv2() const { return conv2_; } +inline Weights_ConvBlock* Weights_Residual::mutable_conv2() { + has_conv2_ = true; + return &conv2_; +} +inline bool Weights_Residual::has_se() const { return has_se_; } +inline const Weights_SEunit& Weights_Residual::se() const { return se_; } +inline Weights_SEunit* Weights_Residual::mutable_se() { + has_se_ = true; + return &se_; +} +inline std::string Weights_Smolgen::OutputAsString() const { + std::string out; + if (has_compress_) AppendString(1, compress_.OutputAsString(), &out); + if (has_dense1_w_) AppendString(2, dense1_w_.OutputAsString(), &out); + if (has_dense1_b_) AppendString(3, dense1_b_.OutputAsString(), &out); + if (has_ln1_gammas_) AppendString(4, ln1_gammas_.OutputAsString(), &out); + if (has_ln1_betas_) AppendString(5, ln1_betas_.OutputAsString(), &out); + if (has_dense2_w_) AppendString(6, dense2_w_.OutputAsString(), &out); + if (has_dense2_b_) AppendString(7, dense2_b_.OutputAsString(), &out); + if (has_ln2_gammas_) AppendString(8, ln2_gammas_.OutputAsString(), &out); + if (has_ln2_betas_) AppendString(9, ln2_betas_.OutputAsString(), &out); + return out; +} +inline std::string Weights_Smolgen::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_compress_) AppendJsonField("compress", compress_, &first, &out); + if (has_dense1_w_) AppendJsonField("dense1_w", dense1_w_, &first, &out); + if (has_dense1_b_) AppendJsonField("dense1_b", dense1_b_, &first, &out); + if (has_ln1_gammas_) AppendJsonField("ln1_gammas", ln1_gammas_, &first, &out); + if (has_ln1_betas_) AppendJsonField("ln1_betas", ln1_betas_, &first, &out); + if (has_dense2_w_) AppendJsonField("dense2_w", dense2_w_, &first, &out); + if (has_dense2_b_) AppendJsonField("dense2_b", dense2_b_, &first, &out); + if (has_ln2_gammas_) AppendJsonField("ln2_gammas", ln2_gammas_, &first, &out); + if (has_ln2_betas_) AppendJsonField("ln2_betas", ln2_betas_, &first, &out); + out += "}"; + return out; +} +inline void Weights_Smolgen::Clear() { + has_compress_ = false; + compress_ = {}; + has_dense1_w_ = false; + dense1_w_ = {}; + has_dense1_b_ = false; + dense1_b_ = {}; + has_ln1_gammas_ = false; + ln1_gammas_ = {}; + has_ln1_betas_ = false; + ln1_betas_ = {}; + has_dense2_w_ = false; + dense2_w_ = {}; + has_dense2_b_ = false; + dense2_b_ = {}; + has_ln2_gammas_ = false; + ln2_gammas_ = {}; + has_ln2_betas_ = false; + ln2_betas_ = {}; +} +inline void Weights_Smolgen::SetString(int field_id, std::string_view val) { + switch (field_id) { + case 1: mutable_compress()->MergeFromString(val); break; + case 2: mutable_dense1_w()->MergeFromString(val); break; + case 3: mutable_dense1_b()->MergeFromString(val); break; + case 4: mutable_ln1_gammas()->MergeFromString(val); break; + case 5: mutable_ln1_betas()->MergeFromString(val); break; + case 6: mutable_dense2_w()->MergeFromString(val); break; + case 7: mutable_dense2_b()->MergeFromString(val); break; + case 8: mutable_ln2_gammas()->MergeFromString(val); break; + case 9: mutable_ln2_betas()->MergeFromString(val); break; + } +} +inline bool Weights_Smolgen::has_compress() const { return has_compress_; } +inline const Weights_Layer& Weights_Smolgen::compress() const { return compress_; } +inline Weights_Layer* Weights_Smolgen::mutable_compress() { + has_compress_ = true; + return &compress_; +} +inline bool Weights_Smolgen::has_dense1_w() const { return has_dense1_w_; } +inline const Weights_Layer& Weights_Smolgen::dense1_w() const { return dense1_w_; } +inline Weights_Layer* Weights_Smolgen::mutable_dense1_w() { + has_dense1_w_ = true; + return &dense1_w_; +} +inline bool Weights_Smolgen::has_dense1_b() const { return has_dense1_b_; } +inline const Weights_Layer& Weights_Smolgen::dense1_b() const { return dense1_b_; } +inline Weights_Layer* Weights_Smolgen::mutable_dense1_b() { + has_dense1_b_ = true; + return &dense1_b_; +} +inline bool Weights_Smolgen::has_ln1_gammas() const { return has_ln1_gammas_; } +inline const Weights_Layer& Weights_Smolgen::ln1_gammas() const { return ln1_gammas_; } +inline Weights_Layer* Weights_Smolgen::mutable_ln1_gammas() { + has_ln1_gammas_ = true; + return &ln1_gammas_; +} +inline bool Weights_Smolgen::has_ln1_betas() const { return has_ln1_betas_; } +inline const Weights_Layer& Weights_Smolgen::ln1_betas() const { return ln1_betas_; } +inline Weights_Layer* Weights_Smolgen::mutable_ln1_betas() { + has_ln1_betas_ = true; + return &ln1_betas_; +} +inline bool Weights_Smolgen::has_dense2_w() const { return has_dense2_w_; } +inline const Weights_Layer& Weights_Smolgen::dense2_w() const { return dense2_w_; } +inline Weights_Layer* Weights_Smolgen::mutable_dense2_w() { + has_dense2_w_ = true; + return &dense2_w_; +} +inline bool Weights_Smolgen::has_dense2_b() const { return has_dense2_b_; } +inline const Weights_Layer& Weights_Smolgen::dense2_b() const { return dense2_b_; } +inline Weights_Layer* Weights_Smolgen::mutable_dense2_b() { + has_dense2_b_ = true; + return &dense2_b_; +} +inline bool Weights_Smolgen::has_ln2_gammas() const { return has_ln2_gammas_; } +inline const Weights_Layer& Weights_Smolgen::ln2_gammas() const { return ln2_gammas_; } +inline Weights_Layer* Weights_Smolgen::mutable_ln2_gammas() { + has_ln2_gammas_ = true; + return &ln2_gammas_; +} +inline bool Weights_Smolgen::has_ln2_betas() const { return has_ln2_betas_; } +inline const Weights_Layer& Weights_Smolgen::ln2_betas() const { return ln2_betas_; } +inline Weights_Layer* Weights_Smolgen::mutable_ln2_betas() { + has_ln2_betas_ = true; + return &ln2_betas_; +} +inline std::string Weights_MHA::OutputAsString() const { + std::string out; + if (has_q_w_) AppendString(1, q_w_.OutputAsString(), &out); + if (has_q_b_) AppendString(2, q_b_.OutputAsString(), &out); + if (has_k_w_) AppendString(3, k_w_.OutputAsString(), &out); + if (has_k_b_) AppendString(4, k_b_.OutputAsString(), &out); + if (has_v_w_) AppendString(5, v_w_.OutputAsString(), &out); + if (has_v_b_) AppendString(6, v_b_.OutputAsString(), &out); + if (has_dense_w_) AppendString(7, dense_w_.OutputAsString(), &out); + if (has_dense_b_) AppendString(8, dense_b_.OutputAsString(), &out); + if (has_smolgen_) AppendString(9, smolgen_.OutputAsString(), &out); + return out; +} +inline std::string Weights_MHA::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_q_w_) AppendJsonField("q_w", q_w_, &first, &out); + if (has_q_b_) AppendJsonField("q_b", q_b_, &first, &out); + if (has_k_w_) AppendJsonField("k_w", k_w_, &first, &out); + if (has_k_b_) AppendJsonField("k_b", k_b_, &first, &out); + if (has_v_w_) AppendJsonField("v_w", v_w_, &first, &out); + if (has_v_b_) AppendJsonField("v_b", v_b_, &first, &out); + if (has_dense_w_) AppendJsonField("dense_w", dense_w_, &first, &out); + if (has_dense_b_) AppendJsonField("dense_b", dense_b_, &first, &out); + if (has_smolgen_) AppendJsonField("smolgen", smolgen_, &first, &out); + out += "}"; + return out; +} +inline void Weights_MHA::Clear() { + has_q_w_ = false; + q_w_ = {}; + has_q_b_ = false; + q_b_ = {}; + has_k_w_ = false; + k_w_ = {}; + has_k_b_ = false; + k_b_ = {}; + has_v_w_ = false; + v_w_ = {}; + has_v_b_ = false; + v_b_ = {}; + has_dense_w_ = false; + dense_w_ = {}; + has_dense_b_ = false; + dense_b_ = {}; + has_smolgen_ = false; + smolgen_ = {}; +} +inline void Weights_MHA::SetString(int field_id, std::string_view val) { + switch (field_id) { + case 1: mutable_q_w()->MergeFromString(val); break; + case 2: mutable_q_b()->MergeFromString(val); break; + case 3: mutable_k_w()->MergeFromString(val); break; + case 4: mutable_k_b()->MergeFromString(val); break; + case 5: mutable_v_w()->MergeFromString(val); break; + case 6: mutable_v_b()->MergeFromString(val); break; + case 7: mutable_dense_w()->MergeFromString(val); break; + case 8: mutable_dense_b()->MergeFromString(val); break; + case 9: mutable_smolgen()->MergeFromString(val); break; + } +} +inline bool Weights_MHA::has_q_w() const { return has_q_w_; } +inline const Weights_Layer& Weights_MHA::q_w() const { return q_w_; } +inline Weights_Layer* Weights_MHA::mutable_q_w() { + has_q_w_ = true; + return &q_w_; +} +inline bool Weights_MHA::has_q_b() const { return has_q_b_; } +inline const Weights_Layer& Weights_MHA::q_b() const { return q_b_; } +inline Weights_Layer* Weights_MHA::mutable_q_b() { + has_q_b_ = true; + return &q_b_; +} +inline bool Weights_MHA::has_k_w() const { return has_k_w_; } +inline const Weights_Layer& Weights_MHA::k_w() const { return k_w_; } +inline Weights_Layer* Weights_MHA::mutable_k_w() { + has_k_w_ = true; + return &k_w_; +} +inline bool Weights_MHA::has_k_b() const { return has_k_b_; } +inline const Weights_Layer& Weights_MHA::k_b() const { return k_b_; } +inline Weights_Layer* Weights_MHA::mutable_k_b() { + has_k_b_ = true; + return &k_b_; +} +inline bool Weights_MHA::has_v_w() const { return has_v_w_; } +inline const Weights_Layer& Weights_MHA::v_w() const { return v_w_; } +inline Weights_Layer* Weights_MHA::mutable_v_w() { + has_v_w_ = true; + return &v_w_; +} +inline bool Weights_MHA::has_v_b() const { return has_v_b_; } +inline const Weights_Layer& Weights_MHA::v_b() const { return v_b_; } +inline Weights_Layer* Weights_MHA::mutable_v_b() { + has_v_b_ = true; + return &v_b_; +} +inline bool Weights_MHA::has_dense_w() const { return has_dense_w_; } +inline const Weights_Layer& Weights_MHA::dense_w() const { return dense_w_; } +inline Weights_Layer* Weights_MHA::mutable_dense_w() { + has_dense_w_ = true; + return &dense_w_; +} +inline bool Weights_MHA::has_dense_b() const { return has_dense_b_; } +inline const Weights_Layer& Weights_MHA::dense_b() const { return dense_b_; } +inline Weights_Layer* Weights_MHA::mutable_dense_b() { + has_dense_b_ = true; + return &dense_b_; +} +inline bool Weights_MHA::has_smolgen() const { return has_smolgen_; } +inline const Weights_Smolgen& Weights_MHA::smolgen() const { return smolgen_; } +inline Weights_Smolgen* Weights_MHA::mutable_smolgen() { + has_smolgen_ = true; + return &smolgen_; +} +inline std::string Weights_FFN::OutputAsString() const { + std::string out; + if (has_dense1_w_) AppendString(1, dense1_w_.OutputAsString(), &out); + if (has_dense1_b_) AppendString(2, dense1_b_.OutputAsString(), &out); + if (has_dense2_w_) AppendString(3, dense2_w_.OutputAsString(), &out); + if (has_dense2_b_) AppendString(4, dense2_b_.OutputAsString(), &out); + return out; +} +inline std::string Weights_FFN::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_dense1_w_) AppendJsonField("dense1_w", dense1_w_, &first, &out); + if (has_dense1_b_) AppendJsonField("dense1_b", dense1_b_, &first, &out); + if (has_dense2_w_) AppendJsonField("dense2_w", dense2_w_, &first, &out); + if (has_dense2_b_) AppendJsonField("dense2_b", dense2_b_, &first, &out); + out += "}"; + return out; +} +inline void Weights_FFN::Clear() { + has_dense1_w_ = false; + dense1_w_ = {}; + has_dense1_b_ = false; + dense1_b_ = {}; + has_dense2_w_ = false; + dense2_w_ = {}; + has_dense2_b_ = false; + dense2_b_ = {}; +} +inline void Weights_FFN::SetString(int field_id, std::string_view val) { + switch (field_id) { + case 1: mutable_dense1_w()->MergeFromString(val); break; + case 2: mutable_dense1_b()->MergeFromString(val); break; + case 3: mutable_dense2_w()->MergeFromString(val); break; + case 4: mutable_dense2_b()->MergeFromString(val); break; + } +} +inline bool Weights_FFN::has_dense1_w() const { return has_dense1_w_; } +inline const Weights_Layer& Weights_FFN::dense1_w() const { return dense1_w_; } +inline Weights_Layer* Weights_FFN::mutable_dense1_w() { + has_dense1_w_ = true; + return &dense1_w_; +} +inline bool Weights_FFN::has_dense1_b() const { return has_dense1_b_; } +inline const Weights_Layer& Weights_FFN::dense1_b() const { return dense1_b_; } +inline Weights_Layer* Weights_FFN::mutable_dense1_b() { + has_dense1_b_ = true; + return &dense1_b_; +} +inline bool Weights_FFN::has_dense2_w() const { return has_dense2_w_; } +inline const Weights_Layer& Weights_FFN::dense2_w() const { return dense2_w_; } +inline Weights_Layer* Weights_FFN::mutable_dense2_w() { + has_dense2_w_ = true; + return &dense2_w_; +} +inline bool Weights_FFN::has_dense2_b() const { return has_dense2_b_; } +inline const Weights_Layer& Weights_FFN::dense2_b() const { return dense2_b_; } +inline Weights_Layer* Weights_FFN::mutable_dense2_b() { + has_dense2_b_ = true; + return &dense2_b_; +} +inline std::string Weights_EncoderLayer::OutputAsString() const { + std::string out; + if (has_mha_) AppendString(1, mha_.OutputAsString(), &out); + if (has_ln1_gammas_) AppendString(2, ln1_gammas_.OutputAsString(), &out); + if (has_ln1_betas_) AppendString(3, ln1_betas_.OutputAsString(), &out); + if (has_ffn_) AppendString(4, ffn_.OutputAsString(), &out); + if (has_ln2_gammas_) AppendString(5, ln2_gammas_.OutputAsString(), &out); + if (has_ln2_betas_) AppendString(6, ln2_betas_.OutputAsString(), &out); + return out; +} +inline std::string Weights_EncoderLayer::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_mha_) AppendJsonField("mha", mha_, &first, &out); + if (has_ln1_gammas_) AppendJsonField("ln1_gammas", ln1_gammas_, &first, &out); + if (has_ln1_betas_) AppendJsonField("ln1_betas", ln1_betas_, &first, &out); + if (has_ffn_) AppendJsonField("ffn", ffn_, &first, &out); + if (has_ln2_gammas_) AppendJsonField("ln2_gammas", ln2_gammas_, &first, &out); + if (has_ln2_betas_) AppendJsonField("ln2_betas", ln2_betas_, &first, &out); + out += "}"; + return out; +} +inline void Weights_EncoderLayer::Clear() { + has_mha_ = false; + mha_ = {}; + has_ln1_gammas_ = false; + ln1_gammas_ = {}; + has_ln1_betas_ = false; + ln1_betas_ = {}; + has_ffn_ = false; + ffn_ = {}; + has_ln2_gammas_ = false; + ln2_gammas_ = {}; + has_ln2_betas_ = false; + ln2_betas_ = {}; +} +inline void Weights_EncoderLayer::SetString(int field_id, std::string_view val) { + switch (field_id) { + case 1: mutable_mha()->MergeFromString(val); break; + case 2: mutable_ln1_gammas()->MergeFromString(val); break; + case 3: mutable_ln1_betas()->MergeFromString(val); break; + case 4: mutable_ffn()->MergeFromString(val); break; + case 5: mutable_ln2_gammas()->MergeFromString(val); break; + case 6: mutable_ln2_betas()->MergeFromString(val); break; + } +} +inline bool Weights_EncoderLayer::has_mha() const { return has_mha_; } +inline const Weights_MHA& Weights_EncoderLayer::mha() const { return mha_; } +inline Weights_MHA* Weights_EncoderLayer::mutable_mha() { + has_mha_ = true; + return &mha_; +} +inline bool Weights_EncoderLayer::has_ln1_gammas() const { return has_ln1_gammas_; } +inline const Weights_Layer& Weights_EncoderLayer::ln1_gammas() const { return ln1_gammas_; } +inline Weights_Layer* Weights_EncoderLayer::mutable_ln1_gammas() { + has_ln1_gammas_ = true; + return &ln1_gammas_; +} +inline bool Weights_EncoderLayer::has_ln1_betas() const { return has_ln1_betas_; } +inline const Weights_Layer& Weights_EncoderLayer::ln1_betas() const { return ln1_betas_; } +inline Weights_Layer* Weights_EncoderLayer::mutable_ln1_betas() { + has_ln1_betas_ = true; + return &ln1_betas_; +} +inline bool Weights_EncoderLayer::has_ffn() const { return has_ffn_; } +inline const Weights_FFN& Weights_EncoderLayer::ffn() const { return ffn_; } +inline Weights_FFN* Weights_EncoderLayer::mutable_ffn() { + has_ffn_ = true; + return &ffn_; +} +inline bool Weights_EncoderLayer::has_ln2_gammas() const { return has_ln2_gammas_; } +inline const Weights_Layer& Weights_EncoderLayer::ln2_gammas() const { return ln2_gammas_; } +inline Weights_Layer* Weights_EncoderLayer::mutable_ln2_gammas() { + has_ln2_gammas_ = true; + return &ln2_gammas_; +} +inline bool Weights_EncoderLayer::has_ln2_betas() const { return has_ln2_betas_; } +inline const Weights_Layer& Weights_EncoderLayer::ln2_betas() const { return ln2_betas_; } +inline Weights_Layer* Weights_EncoderLayer::mutable_ln2_betas() { + has_ln2_betas_ = true; + return &ln2_betas_; +} +inline std::string Weights::OutputAsString() const { + std::string out; + if (has_input_) AppendString(1, input_.OutputAsString(), &out); + for (const auto& x : residual_) AppendString(2, x.OutputAsString(), &out); + if (has_policy_) AppendString(3, policy_.OutputAsString(), &out); + if (has_ip_pol_w_) AppendString(4, ip_pol_w_.OutputAsString(), &out); + if (has_ip_pol_b_) AppendString(5, ip_pol_b_.OutputAsString(), &out); + if (has_value_) AppendString(6, value_.OutputAsString(), &out); + if (has_ip1_val_w_) AppendString(7, ip1_val_w_.OutputAsString(), &out); + if (has_ip1_val_b_) AppendString(8, ip1_val_b_.OutputAsString(), &out); + if (has_ip2_val_w_) AppendString(9, ip2_val_w_.OutputAsString(), &out); + if (has_ip2_val_b_) AppendString(10, ip2_val_b_.OutputAsString(), &out); + if (has_policy1_) AppendString(11, policy1_.OutputAsString(), &out); + if (has_moves_left_) AppendString(12, moves_left_.OutputAsString(), &out); + if (has_ip1_mov_w_) AppendString(13, ip1_mov_w_.OutputAsString(), &out); + if (has_ip1_mov_b_) AppendString(14, ip1_mov_b_.OutputAsString(), &out); + if (has_ip2_mov_w_) AppendString(15, ip2_mov_w_.OutputAsString(), &out); + if (has_ip2_mov_b_) AppendString(16, ip2_mov_b_.OutputAsString(), &out); + if (has_ip2_pol_w_) AppendString(17, ip2_pol_w_.OutputAsString(), &out); + if (has_ip2_pol_b_) AppendString(18, ip2_pol_b_.OutputAsString(), &out); + if (has_ip3_pol_w_) AppendString(19, ip3_pol_w_.OutputAsString(), &out); + if (has_ip3_pol_b_) AppendString(20, ip3_pol_b_.OutputAsString(), &out); + for (const auto& x : pol_encoder_) AppendString(21, x.OutputAsString(), &out); + if (has_ip4_pol_w_) AppendString(22, ip4_pol_w_.OutputAsString(), &out); + if (has_pol_headcount_) AppendVarInt(24, pol_headcount_, &out); + if (has_ip_emb_w_) AppendString(25, ip_emb_w_.OutputAsString(), &out); + if (has_ip_emb_b_) AppendString(26, ip_emb_b_.OutputAsString(), &out); + for (const auto& x : encoder_) AppendString(27, x.OutputAsString(), &out); + if (has_headcount_) AppendVarInt(28, headcount_, &out); + if (has_ip_val_w_) AppendString(29, ip_val_w_.OutputAsString(), &out); + if (has_ip_val_b_) AppendString(30, ip_val_b_.OutputAsString(), &out); + if (has_ip_mov_w_) AppendString(31, ip_mov_w_.OutputAsString(), &out); + if (has_ip_mov_b_) AppendString(32, ip_mov_b_.OutputAsString(), &out); + if (has_ip_mult_gate_) AppendString(33, ip_mult_gate_.OutputAsString(), &out); + if (has_ip_add_gate_) AppendString(34, ip_add_gate_.OutputAsString(), &out); + if (has_smolgen_w_) AppendString(35, smolgen_w_.OutputAsString(), &out); + if (has_smolgen_b_) AppendString(36, smolgen_b_.OutputAsString(), &out); + return out; +} +inline std::string Weights::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_input_) AppendJsonField("input", input_, &first, &out); + if (!residual_.empty()) AppendJsonRepeatedField("residual", residual_, &first, &out); + if (has_ip_emb_w_) AppendJsonField("ip_emb_w", ip_emb_w_, &first, &out); + if (has_ip_emb_b_) AppendJsonField("ip_emb_b", ip_emb_b_, &first, &out); + if (has_ip_mult_gate_) AppendJsonField("ip_mult_gate", ip_mult_gate_, &first, &out); + if (has_ip_add_gate_) AppendJsonField("ip_add_gate", ip_add_gate_, &first, &out); + if (!encoder_.empty()) AppendJsonRepeatedField("encoder", encoder_, &first, &out); + if (has_headcount_) AppendJsonField("headcount", headcount_, &first, &out); + if (!pol_encoder_.empty()) AppendJsonRepeatedField("pol_encoder", pol_encoder_, &first, &out); + if (has_pol_headcount_) AppendJsonField("pol_headcount", pol_headcount_, &first, &out); + if (has_policy1_) AppendJsonField("policy1", policy1_, &first, &out); + if (has_policy_) AppendJsonField("policy", policy_, &first, &out); + if (has_ip_pol_w_) AppendJsonField("ip_pol_w", ip_pol_w_, &first, &out); + if (has_ip_pol_b_) AppendJsonField("ip_pol_b", ip_pol_b_, &first, &out); + if (has_ip2_pol_w_) AppendJsonField("ip2_pol_w", ip2_pol_w_, &first, &out); + if (has_ip2_pol_b_) AppendJsonField("ip2_pol_b", ip2_pol_b_, &first, &out); + if (has_ip3_pol_w_) AppendJsonField("ip3_pol_w", ip3_pol_w_, &first, &out); + if (has_ip3_pol_b_) AppendJsonField("ip3_pol_b", ip3_pol_b_, &first, &out); + if (has_ip4_pol_w_) AppendJsonField("ip4_pol_w", ip4_pol_w_, &first, &out); + if (has_value_) AppendJsonField("value", value_, &first, &out); + if (has_ip_val_w_) AppendJsonField("ip_val_w", ip_val_w_, &first, &out); + if (has_ip_val_b_) AppendJsonField("ip_val_b", ip_val_b_, &first, &out); + if (has_ip1_val_w_) AppendJsonField("ip1_val_w", ip1_val_w_, &first, &out); + if (has_ip1_val_b_) AppendJsonField("ip1_val_b", ip1_val_b_, &first, &out); + if (has_ip2_val_w_) AppendJsonField("ip2_val_w", ip2_val_w_, &first, &out); + if (has_ip2_val_b_) AppendJsonField("ip2_val_b", ip2_val_b_, &first, &out); + if (has_moves_left_) AppendJsonField("moves_left", moves_left_, &first, &out); + if (has_ip_mov_w_) AppendJsonField("ip_mov_w", ip_mov_w_, &first, &out); + if (has_ip_mov_b_) AppendJsonField("ip_mov_b", ip_mov_b_, &first, &out); + if (has_ip1_mov_w_) AppendJsonField("ip1_mov_w", ip1_mov_w_, &first, &out); + if (has_ip1_mov_b_) AppendJsonField("ip1_mov_b", ip1_mov_b_, &first, &out); + if (has_ip2_mov_w_) AppendJsonField("ip2_mov_w", ip2_mov_w_, &first, &out); + if (has_ip2_mov_b_) AppendJsonField("ip2_mov_b", ip2_mov_b_, &first, &out); + if (has_smolgen_w_) AppendJsonField("smolgen_w", smolgen_w_, &first, &out); + if (has_smolgen_b_) AppendJsonField("smolgen_b", smolgen_b_, &first, &out); + out += "}"; + return out; +} +inline void Weights::Clear() { + has_input_ = false; + input_ = {}; + residual_.clear(); + has_ip_emb_w_ = false; + ip_emb_w_ = {}; + has_ip_emb_b_ = false; + ip_emb_b_ = {}; + has_ip_mult_gate_ = false; + ip_mult_gate_ = {}; + has_ip_add_gate_ = false; + ip_add_gate_ = {}; + encoder_.clear(); + has_headcount_ = false; + headcount_ = {}; + pol_encoder_.clear(); + has_pol_headcount_ = false; + pol_headcount_ = {}; + has_policy1_ = false; + policy1_ = {}; + has_policy_ = false; + policy_ = {}; + has_ip_pol_w_ = false; + ip_pol_w_ = {}; + has_ip_pol_b_ = false; + ip_pol_b_ = {}; + has_ip2_pol_w_ = false; + ip2_pol_w_ = {}; + has_ip2_pol_b_ = false; + ip2_pol_b_ = {}; + has_ip3_pol_w_ = false; + ip3_pol_w_ = {}; + has_ip3_pol_b_ = false; + ip3_pol_b_ = {}; + has_ip4_pol_w_ = false; + ip4_pol_w_ = {}; + has_value_ = false; + value_ = {}; + has_ip_val_w_ = false; + ip_val_w_ = {}; + has_ip_val_b_ = false; + ip_val_b_ = {}; + has_ip1_val_w_ = false; + ip1_val_w_ = {}; + has_ip1_val_b_ = false; + ip1_val_b_ = {}; + has_ip2_val_w_ = false; + ip2_val_w_ = {}; + has_ip2_val_b_ = false; + ip2_val_b_ = {}; + has_moves_left_ = false; + moves_left_ = {}; + has_ip_mov_w_ = false; + ip_mov_w_ = {}; + has_ip_mov_b_ = false; + ip_mov_b_ = {}; + has_ip1_mov_w_ = false; + ip1_mov_w_ = {}; + has_ip1_mov_b_ = false; + ip1_mov_b_ = {}; + has_ip2_mov_w_ = false; + ip2_mov_w_ = {}; + has_ip2_mov_b_ = false; + ip2_mov_b_ = {}; + has_smolgen_w_ = false; + smolgen_w_ = {}; + has_smolgen_b_ = false; + smolgen_b_ = {}; +} +inline void Weights::SetString(int field_id, std::string_view val) { + switch (field_id) { + case 1: mutable_input()->MergeFromString(val); break; + case 2: add_residual()->MergeFromString(val); break; + case 25: mutable_ip_emb_w()->MergeFromString(val); break; + case 26: mutable_ip_emb_b()->MergeFromString(val); break; + case 33: mutable_ip_mult_gate()->MergeFromString(val); break; + case 34: mutable_ip_add_gate()->MergeFromString(val); break; + case 27: add_encoder()->MergeFromString(val); break; + case 21: add_pol_encoder()->MergeFromString(val); break; + case 11: mutable_policy1()->MergeFromString(val); break; + case 3: mutable_policy()->MergeFromString(val); break; + case 4: mutable_ip_pol_w()->MergeFromString(val); break; + case 5: mutable_ip_pol_b()->MergeFromString(val); break; + case 17: mutable_ip2_pol_w()->MergeFromString(val); break; + case 18: mutable_ip2_pol_b()->MergeFromString(val); break; + case 19: mutable_ip3_pol_w()->MergeFromString(val); break; + case 20: mutable_ip3_pol_b()->MergeFromString(val); break; + case 22: mutable_ip4_pol_w()->MergeFromString(val); break; + case 6: mutable_value()->MergeFromString(val); break; + case 29: mutable_ip_val_w()->MergeFromString(val); break; + case 30: mutable_ip_val_b()->MergeFromString(val); break; + case 7: mutable_ip1_val_w()->MergeFromString(val); break; + case 8: mutable_ip1_val_b()->MergeFromString(val); break; + case 9: mutable_ip2_val_w()->MergeFromString(val); break; + case 10: mutable_ip2_val_b()->MergeFromString(val); break; + case 12: mutable_moves_left()->MergeFromString(val); break; + case 31: mutable_ip_mov_w()->MergeFromString(val); break; + case 32: mutable_ip_mov_b()->MergeFromString(val); break; + case 13: mutable_ip1_mov_w()->MergeFromString(val); break; + case 14: mutable_ip1_mov_b()->MergeFromString(val); break; + case 15: mutable_ip2_mov_w()->MergeFromString(val); break; + case 16: mutable_ip2_mov_b()->MergeFromString(val); break; + case 35: mutable_smolgen_w()->MergeFromString(val); break; + case 36: mutable_smolgen_b()->MergeFromString(val); break; + } +} +inline void Weights::SetVarInt(int field_id, std::uint64_t val) { + switch (field_id) { + case 28: set_headcount(static_cast(val)); break; + case 24: set_pol_headcount(static_cast(val)); break; + } +} +inline bool Weights::has_input() const { return has_input_; } +inline const Weights_ConvBlock& Weights::input() const { return input_; } +inline Weights_ConvBlock* Weights::mutable_input() { + has_input_ = true; + return &input_; +} +inline Weights_Residual* Weights::add_residual() { return &residual_.emplace_back(); } +inline const std::vector& Weights::residual() const { return residual_; } +inline std::vector* Weights::mutable_residual() { return &residual_; } +inline const Weights_Residual& Weights::residual(size_t idx) const { return residual_[idx]; } +inline Weights_Residual* Weights::mutable_residual(size_t idx) { return &residual_[idx]; } +inline size_t Weights::residual_size() const { return residual_.size(); } +inline bool Weights::has_ip_emb_w() const { return has_ip_emb_w_; } +inline const Weights_Layer& Weights::ip_emb_w() const { return ip_emb_w_; } +inline Weights_Layer* Weights::mutable_ip_emb_w() { + has_ip_emb_w_ = true; + return &ip_emb_w_; +} +inline bool Weights::has_ip_emb_b() const { return has_ip_emb_b_; } +inline const Weights_Layer& Weights::ip_emb_b() const { return ip_emb_b_; } +inline Weights_Layer* Weights::mutable_ip_emb_b() { + has_ip_emb_b_ = true; + return &ip_emb_b_; +} +inline bool Weights::has_ip_mult_gate() const { return has_ip_mult_gate_; } +inline const Weights_Layer& Weights::ip_mult_gate() const { return ip_mult_gate_; } +inline Weights_Layer* Weights::mutable_ip_mult_gate() { + has_ip_mult_gate_ = true; + return &ip_mult_gate_; +} +inline bool Weights::has_ip_add_gate() const { return has_ip_add_gate_; } +inline const Weights_Layer& Weights::ip_add_gate() const { return ip_add_gate_; } +inline Weights_Layer* Weights::mutable_ip_add_gate() { + has_ip_add_gate_ = true; + return &ip_add_gate_; +} +inline Weights_EncoderLayer* Weights::add_encoder() { return &encoder_.emplace_back(); } +inline const std::vector& Weights::encoder() const { return encoder_; } +inline std::vector* Weights::mutable_encoder() { return &encoder_; } +inline const Weights_EncoderLayer& Weights::encoder(size_t idx) const { return encoder_[idx]; } +inline Weights_EncoderLayer* Weights::mutable_encoder(size_t idx) { return &encoder_[idx]; } +inline size_t Weights::encoder_size() const { return encoder_.size(); } +inline bool Weights::has_headcount() const { return has_headcount_; } +inline std::uint32_t Weights::headcount() const { return headcount_; } +inline void Weights::set_headcount(std::uint32_t val) { + has_headcount_ = true; + headcount_ = val; +} +inline Weights_EncoderLayer* Weights::add_pol_encoder() { return &pol_encoder_.emplace_back(); } +inline const std::vector& Weights::pol_encoder() const { return pol_encoder_; } +inline std::vector* Weights::mutable_pol_encoder() { return &pol_encoder_; } +inline const Weights_EncoderLayer& Weights::pol_encoder(size_t idx) const { return pol_encoder_[idx]; } +inline Weights_EncoderLayer* Weights::mutable_pol_encoder(size_t idx) { return &pol_encoder_[idx]; } +inline size_t Weights::pol_encoder_size() const { return pol_encoder_.size(); } +inline bool Weights::has_pol_headcount() const { return has_pol_headcount_; } +inline std::uint32_t Weights::pol_headcount() const { return pol_headcount_; } +inline void Weights::set_pol_headcount(std::uint32_t val) { + has_pol_headcount_ = true; + pol_headcount_ = val; +} +inline bool Weights::has_policy1() const { return has_policy1_; } +inline const Weights_ConvBlock& Weights::policy1() const { return policy1_; } +inline Weights_ConvBlock* Weights::mutable_policy1() { + has_policy1_ = true; + return &policy1_; +} +inline bool Weights::has_policy() const { return has_policy_; } +inline const Weights_ConvBlock& Weights::policy() const { return policy_; } +inline Weights_ConvBlock* Weights::mutable_policy() { + has_policy_ = true; + return &policy_; +} +inline bool Weights::has_ip_pol_w() const { return has_ip_pol_w_; } +inline const Weights_Layer& Weights::ip_pol_w() const { return ip_pol_w_; } +inline Weights_Layer* Weights::mutable_ip_pol_w() { + has_ip_pol_w_ = true; + return &ip_pol_w_; +} +inline bool Weights::has_ip_pol_b() const { return has_ip_pol_b_; } +inline const Weights_Layer& Weights::ip_pol_b() const { return ip_pol_b_; } +inline Weights_Layer* Weights::mutable_ip_pol_b() { + has_ip_pol_b_ = true; + return &ip_pol_b_; +} +inline bool Weights::has_ip2_pol_w() const { return has_ip2_pol_w_; } +inline const Weights_Layer& Weights::ip2_pol_w() const { return ip2_pol_w_; } +inline Weights_Layer* Weights::mutable_ip2_pol_w() { + has_ip2_pol_w_ = true; + return &ip2_pol_w_; +} +inline bool Weights::has_ip2_pol_b() const { return has_ip2_pol_b_; } +inline const Weights_Layer& Weights::ip2_pol_b() const { return ip2_pol_b_; } +inline Weights_Layer* Weights::mutable_ip2_pol_b() { + has_ip2_pol_b_ = true; + return &ip2_pol_b_; +} +inline bool Weights::has_ip3_pol_w() const { return has_ip3_pol_w_; } +inline const Weights_Layer& Weights::ip3_pol_w() const { return ip3_pol_w_; } +inline Weights_Layer* Weights::mutable_ip3_pol_w() { + has_ip3_pol_w_ = true; + return &ip3_pol_w_; +} +inline bool Weights::has_ip3_pol_b() const { return has_ip3_pol_b_; } +inline const Weights_Layer& Weights::ip3_pol_b() const { return ip3_pol_b_; } +inline Weights_Layer* Weights::mutable_ip3_pol_b() { + has_ip3_pol_b_ = true; + return &ip3_pol_b_; +} +inline bool Weights::has_ip4_pol_w() const { return has_ip4_pol_w_; } +inline const Weights_Layer& Weights::ip4_pol_w() const { return ip4_pol_w_; } +inline Weights_Layer* Weights::mutable_ip4_pol_w() { + has_ip4_pol_w_ = true; + return &ip4_pol_w_; +} +inline bool Weights::has_value() const { return has_value_; } +inline const Weights_ConvBlock& Weights::value() const { return value_; } +inline Weights_ConvBlock* Weights::mutable_value() { + has_value_ = true; + return &value_; +} +inline bool Weights::has_ip_val_w() const { return has_ip_val_w_; } +inline const Weights_Layer& Weights::ip_val_w() const { return ip_val_w_; } +inline Weights_Layer* Weights::mutable_ip_val_w() { + has_ip_val_w_ = true; + return &ip_val_w_; +} +inline bool Weights::has_ip_val_b() const { return has_ip_val_b_; } +inline const Weights_Layer& Weights::ip_val_b() const { return ip_val_b_; } +inline Weights_Layer* Weights::mutable_ip_val_b() { + has_ip_val_b_ = true; + return &ip_val_b_; +} +inline bool Weights::has_ip1_val_w() const { return has_ip1_val_w_; } +inline const Weights_Layer& Weights::ip1_val_w() const { return ip1_val_w_; } +inline Weights_Layer* Weights::mutable_ip1_val_w() { + has_ip1_val_w_ = true; + return &ip1_val_w_; +} +inline bool Weights::has_ip1_val_b() const { return has_ip1_val_b_; } +inline const Weights_Layer& Weights::ip1_val_b() const { return ip1_val_b_; } +inline Weights_Layer* Weights::mutable_ip1_val_b() { + has_ip1_val_b_ = true; + return &ip1_val_b_; +} +inline bool Weights::has_ip2_val_w() const { return has_ip2_val_w_; } +inline const Weights_Layer& Weights::ip2_val_w() const { return ip2_val_w_; } +inline Weights_Layer* Weights::mutable_ip2_val_w() { + has_ip2_val_w_ = true; + return &ip2_val_w_; +} +inline bool Weights::has_ip2_val_b() const { return has_ip2_val_b_; } +inline const Weights_Layer& Weights::ip2_val_b() const { return ip2_val_b_; } +inline Weights_Layer* Weights::mutable_ip2_val_b() { + has_ip2_val_b_ = true; + return &ip2_val_b_; +} +inline bool Weights::has_moves_left() const { return has_moves_left_; } +inline const Weights_ConvBlock& Weights::moves_left() const { return moves_left_; } +inline Weights_ConvBlock* Weights::mutable_moves_left() { + has_moves_left_ = true; + return &moves_left_; +} +inline bool Weights::has_ip_mov_w() const { return has_ip_mov_w_; } +inline const Weights_Layer& Weights::ip_mov_w() const { return ip_mov_w_; } +inline Weights_Layer* Weights::mutable_ip_mov_w() { + has_ip_mov_w_ = true; + return &ip_mov_w_; +} +inline bool Weights::has_ip_mov_b() const { return has_ip_mov_b_; } +inline const Weights_Layer& Weights::ip_mov_b() const { return ip_mov_b_; } +inline Weights_Layer* Weights::mutable_ip_mov_b() { + has_ip_mov_b_ = true; + return &ip_mov_b_; +} +inline bool Weights::has_ip1_mov_w() const { return has_ip1_mov_w_; } +inline const Weights_Layer& Weights::ip1_mov_w() const { return ip1_mov_w_; } +inline Weights_Layer* Weights::mutable_ip1_mov_w() { + has_ip1_mov_w_ = true; + return &ip1_mov_w_; +} +inline bool Weights::has_ip1_mov_b() const { return has_ip1_mov_b_; } +inline const Weights_Layer& Weights::ip1_mov_b() const { return ip1_mov_b_; } +inline Weights_Layer* Weights::mutable_ip1_mov_b() { + has_ip1_mov_b_ = true; + return &ip1_mov_b_; +} +inline bool Weights::has_ip2_mov_w() const { return has_ip2_mov_w_; } +inline const Weights_Layer& Weights::ip2_mov_w() const { return ip2_mov_w_; } +inline Weights_Layer* Weights::mutable_ip2_mov_w() { + has_ip2_mov_w_ = true; + return &ip2_mov_w_; +} +inline bool Weights::has_ip2_mov_b() const { return has_ip2_mov_b_; } +inline const Weights_Layer& Weights::ip2_mov_b() const { return ip2_mov_b_; } +inline Weights_Layer* Weights::mutable_ip2_mov_b() { + has_ip2_mov_b_ = true; + return &ip2_mov_b_; +} +inline bool Weights::has_smolgen_w() const { return has_smolgen_w_; } +inline const Weights_Layer& Weights::smolgen_w() const { return smolgen_w_; } +inline Weights_Layer* Weights::mutable_smolgen_w() { + has_smolgen_w_ = true; + return &smolgen_w_; +} +inline bool Weights::has_smolgen_b() const { return has_smolgen_b_; } +inline const Weights_Layer& Weights::smolgen_b() const { return smolgen_b_; } +inline Weights_Layer* Weights::mutable_smolgen_b() { + has_smolgen_b_ = true; + return &smolgen_b_; +} +inline std::string TrainingParams::OutputAsString() const { + std::string out; + if (has_training_steps_) AppendVarInt(1, training_steps_, &out); + if (has_learning_rate_) AppendInt32(2, bit_cast(learning_rate_), &out); + if (has_mse_loss_) AppendInt32(3, bit_cast(mse_loss_), &out); + if (has_policy_loss_) AppendInt32(4, bit_cast(policy_loss_), &out); + if (has_accuracy_) AppendInt32(5, bit_cast(accuracy_), &out); + if (has_lc0_params_) AppendString(6, lc0_params_, &out); + return out; +} +inline std::string TrainingParams::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_training_steps_) AppendJsonField("training_steps", training_steps_, &first, &out); + if (has_learning_rate_) AppendJsonField("learning_rate", learning_rate_, &first, &out); + if (has_mse_loss_) AppendJsonField("mse_loss", mse_loss_, &first, &out); + if (has_policy_loss_) AppendJsonField("policy_loss", policy_loss_, &first, &out); + if (has_accuracy_) AppendJsonField("accuracy", accuracy_, &first, &out); + if (has_lc0_params_) AppendJsonField("lc0_params", lc0_params_, &first, &out); + out += "}"; + return out; +} +inline void TrainingParams::Clear() { + has_training_steps_ = false; + training_steps_ = {}; + has_learning_rate_ = false; + learning_rate_ = {}; + has_mse_loss_ = false; + mse_loss_ = {}; + has_policy_loss_ = false; + policy_loss_ = {}; + has_accuracy_ = false; + accuracy_ = {}; + has_lc0_params_ = false; + lc0_params_ = {}; +} +inline void TrainingParams::SetVarInt(int field_id, std::uint64_t val) { + switch (field_id) { + case 1: set_training_steps(static_cast(val)); break; + } +} +inline void TrainingParams::SetInt32(int field_id, std::uint32_t val) { + switch (field_id) { + case 2: set_learning_rate(bit_cast(val)); break; + case 3: set_mse_loss(bit_cast(val)); break; + case 4: set_policy_loss(bit_cast(val)); break; + case 5: set_accuracy(bit_cast(val)); break; + } +} +inline void TrainingParams::SetString(int field_id, std::string_view val) { + switch (field_id) { + case 6: set_lc0_params(val); break; + } +} +inline bool TrainingParams::has_training_steps() const { return has_training_steps_; } +inline std::uint32_t TrainingParams::training_steps() const { return training_steps_; } +inline void TrainingParams::set_training_steps(std::uint32_t val) { + has_training_steps_ = true; + training_steps_ = val; +} +inline bool TrainingParams::has_learning_rate() const { return has_learning_rate_; } +inline float TrainingParams::learning_rate() const { return learning_rate_; } +inline void TrainingParams::set_learning_rate(float val) { + has_learning_rate_ = true; + learning_rate_ = val; +} +inline bool TrainingParams::has_mse_loss() const { return has_mse_loss_; } +inline float TrainingParams::mse_loss() const { return mse_loss_; } +inline void TrainingParams::set_mse_loss(float val) { + has_mse_loss_ = true; + mse_loss_ = val; +} +inline bool TrainingParams::has_policy_loss() const { return has_policy_loss_; } +inline float TrainingParams::policy_loss() const { return policy_loss_; } +inline void TrainingParams::set_policy_loss(float val) { + has_policy_loss_ = true; + policy_loss_ = val; +} +inline bool TrainingParams::has_accuracy() const { return has_accuracy_; } +inline float TrainingParams::accuracy() const { return accuracy_; } +inline void TrainingParams::set_accuracy(float val) { + has_accuracy_ = true; + accuracy_ = val; +} +inline bool TrainingParams::has_lc0_params() const { return has_lc0_params_; } +inline std::string_view TrainingParams::lc0_params() const { return lc0_params_; } +inline void TrainingParams::set_lc0_params(std::string_view val) { + has_lc0_params_ = true; + lc0_params_ = val; +} +inline std::string NetworkFormat::OutputAsString() const { + std::string out; + if (has_input_) AppendVarInt(1, input_, &out); + if (has_output_) AppendVarInt(2, output_, &out); + if (has_network_) AppendVarInt(3, network_, &out); + if (has_policy_) AppendVarInt(4, policy_, &out); + if (has_value_) AppendVarInt(5, value_, &out); + if (has_moves_left_) AppendVarInt(6, moves_left_, &out); + if (has_default_activation_) AppendVarInt(7, default_activation_, &out); + if (has_smolgen_activation_) AppendVarInt(8, smolgen_activation_, &out); + if (has_ffn_activation_) AppendVarInt(9, ffn_activation_, &out); + return out; +} +inline std::string NetworkFormat::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_input_) AppendJsonField("input", NetworkFormat_InputFormat_Name(input_), &first, &out); + if (has_output_) AppendJsonField("output", NetworkFormat_OutputFormat_Name(output_), &first, &out); + if (has_network_) AppendJsonField("network", NetworkFormat_NetworkStructure_Name(network_), &first, &out); + if (has_policy_) AppendJsonField("policy", NetworkFormat_PolicyFormat_Name(policy_), &first, &out); + if (has_value_) AppendJsonField("value", NetworkFormat_ValueFormat_Name(value_), &first, &out); + if (has_moves_left_) AppendJsonField("moves_left", NetworkFormat_MovesLeftFormat_Name(moves_left_), &first, &out); + if (has_default_activation_) AppendJsonField("default_activation", NetworkFormat_DefaultActivation_Name(default_activation_), &first, &out); + if (has_smolgen_activation_) AppendJsonField("smolgen_activation", NetworkFormat_ActivationFunction_Name(smolgen_activation_), &first, &out); + if (has_ffn_activation_) AppendJsonField("ffn_activation", NetworkFormat_ActivationFunction_Name(ffn_activation_), &first, &out); + out += "}"; + return out; +} +inline void NetworkFormat::Clear() { + has_input_ = false; + input_ = {}; + has_output_ = false; + output_ = {}; + has_network_ = false; + network_ = {}; + has_policy_ = false; + policy_ = {}; + has_value_ = false; + value_ = {}; + has_moves_left_ = false; + moves_left_ = {}; + has_default_activation_ = false; + default_activation_ = {}; + has_smolgen_activation_ = false; + smolgen_activation_ = {}; + has_ffn_activation_ = false; + ffn_activation_ = {}; +} +inline void NetworkFormat::SetVarInt(int field_id, std::uint64_t val) { + switch (field_id) { + case 1: set_input(static_cast(val)); break; + case 2: set_output(static_cast(val)); break; + case 3: set_network(static_cast(val)); break; + case 4: set_policy(static_cast(val)); break; + case 5: set_value(static_cast(val)); break; + case 6: set_moves_left(static_cast(val)); break; + case 7: set_default_activation(static_cast(val)); break; + case 8: set_smolgen_activation(static_cast(val)); break; + case 9: set_ffn_activation(static_cast(val)); break; + } +} +inline bool NetworkFormat::has_input() const { return has_input_; } +inline NetworkFormat_InputFormat NetworkFormat::input() const { return input_; } +inline void NetworkFormat::set_input(NetworkFormat_InputFormat val) { + has_input_ = true; + input_ = val; +} +inline bool NetworkFormat::has_output() const { return has_output_; } +inline NetworkFormat_OutputFormat NetworkFormat::output() const { return output_; } +inline void NetworkFormat::set_output(NetworkFormat_OutputFormat val) { + has_output_ = true; + output_ = val; +} +inline bool NetworkFormat::has_network() const { return has_network_; } +inline NetworkFormat_NetworkStructure NetworkFormat::network() const { return network_; } +inline void NetworkFormat::set_network(NetworkFormat_NetworkStructure val) { + has_network_ = true; + network_ = val; +} +inline bool NetworkFormat::has_policy() const { return has_policy_; } +inline NetworkFormat_PolicyFormat NetworkFormat::policy() const { return policy_; } +inline void NetworkFormat::set_policy(NetworkFormat_PolicyFormat val) { + has_policy_ = true; + policy_ = val; +} +inline bool NetworkFormat::has_value() const { return has_value_; } +inline NetworkFormat_ValueFormat NetworkFormat::value() const { return value_; } +inline void NetworkFormat::set_value(NetworkFormat_ValueFormat val) { + has_value_ = true; + value_ = val; +} +inline bool NetworkFormat::has_moves_left() const { return has_moves_left_; } +inline NetworkFormat_MovesLeftFormat NetworkFormat::moves_left() const { return moves_left_; } +inline void NetworkFormat::set_moves_left(NetworkFormat_MovesLeftFormat val) { + has_moves_left_ = true; + moves_left_ = val; +} +inline bool NetworkFormat::has_default_activation() const { return has_default_activation_; } +inline NetworkFormat_DefaultActivation NetworkFormat::default_activation() const { return default_activation_; } +inline void NetworkFormat::set_default_activation(NetworkFormat_DefaultActivation val) { + has_default_activation_ = true; + default_activation_ = val; +} +inline bool NetworkFormat::has_smolgen_activation() const { return has_smolgen_activation_; } +inline NetworkFormat_ActivationFunction NetworkFormat::smolgen_activation() const { return smolgen_activation_; } +inline void NetworkFormat::set_smolgen_activation(NetworkFormat_ActivationFunction val) { + has_smolgen_activation_ = true; + smolgen_activation_ = val; +} +inline bool NetworkFormat::has_ffn_activation() const { return has_ffn_activation_; } +inline NetworkFormat_ActivationFunction NetworkFormat::ffn_activation() const { return ffn_activation_; } +inline void NetworkFormat::set_ffn_activation(NetworkFormat_ActivationFunction val) { + has_ffn_activation_ = true; + ffn_activation_ = val; +} +inline std::string Format::OutputAsString() const { + std::string out; + if (has_weights_encoding_) AppendVarInt(1, weights_encoding_, &out); + if (has_network_format_) AppendString(2, network_format_.OutputAsString(), &out); + return out; +} +inline std::string Format::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_weights_encoding_) AppendJsonField("weights_encoding", Format_Encoding_Name(weights_encoding_), &first, &out); + if (has_network_format_) AppendJsonField("network_format", network_format_, &first, &out); + out += "}"; + return out; +} +inline void Format::Clear() { + has_weights_encoding_ = false; + weights_encoding_ = {}; + has_network_format_ = false; + network_format_ = {}; +} +inline void Format::SetVarInt(int field_id, std::uint64_t val) { + switch (field_id) { + case 1: set_weights_encoding(static_cast(val)); break; + } +} +inline void Format::SetString(int field_id, std::string_view val) { + switch (field_id) { + case 2: mutable_network_format()->MergeFromString(val); break; + } +} +inline bool Format::has_weights_encoding() const { return has_weights_encoding_; } +inline Format_Encoding Format::weights_encoding() const { return weights_encoding_; } +inline void Format::set_weights_encoding(Format_Encoding val) { + has_weights_encoding_ = true; + weights_encoding_ = val; +} +inline bool Format::has_network_format() const { return has_network_format_; } +inline const NetworkFormat& Format::network_format() const { return network_format_; } +inline NetworkFormat* Format::mutable_network_format() { + has_network_format_ = true; + return &network_format_; +} +inline std::string OnnxModel::OutputAsString() const { + std::string out; + if (has_model_) AppendString(1, model_, &out); + if (has_data_type_) AppendVarInt(2, data_type_, &out); + if (has_input_planes_) AppendString(3, input_planes_, &out); + if (has_output_value_) AppendString(4, output_value_, &out); + if (has_output_wdl_) AppendString(5, output_wdl_, &out); + if (has_output_policy_) AppendString(6, output_policy_, &out); + if (has_output_mlh_) AppendString(7, output_mlh_, &out); + return out; +} +inline std::string OnnxModel::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_model_) AppendJsonField("model", model_, &first, &out); + if (has_data_type_) AppendJsonField("data_type", OnnxModel_DataType_Name(data_type_), &first, &out); + if (has_input_planes_) AppendJsonField("input_planes", input_planes_, &first, &out); + if (has_output_value_) AppendJsonField("output_value", output_value_, &first, &out); + if (has_output_wdl_) AppendJsonField("output_wdl", output_wdl_, &first, &out); + if (has_output_policy_) AppendJsonField("output_policy", output_policy_, &first, &out); + if (has_output_mlh_) AppendJsonField("output_mlh", output_mlh_, &first, &out); + out += "}"; + return out; +} +inline void OnnxModel::Clear() { + has_model_ = false; + model_ = {}; + has_data_type_ = false; + data_type_ = {}; + has_input_planes_ = false; + input_planes_ = {}; + has_output_value_ = false; + output_value_ = {}; + has_output_wdl_ = false; + output_wdl_ = {}; + has_output_policy_ = false; + output_policy_ = {}; + has_output_mlh_ = false; + output_mlh_ = {}; +} +inline void OnnxModel::SetString(int field_id, std::string_view val) { + switch (field_id) { + case 1: set_model(val); break; + case 3: set_input_planes(val); break; + case 4: set_output_value(val); break; + case 5: set_output_wdl(val); break; + case 6: set_output_policy(val); break; + case 7: set_output_mlh(val); break; + } +} +inline void OnnxModel::SetVarInt(int field_id, std::uint64_t val) { + switch (field_id) { + case 2: set_data_type(static_cast(val)); break; + } +} +inline bool OnnxModel::has_model() const { return has_model_; } +inline std::string_view OnnxModel::model() const { return model_; } +inline void OnnxModel::set_model(std::string_view val) { + has_model_ = true; + model_ = val; +} +inline bool OnnxModel::has_data_type() const { return has_data_type_; } +inline OnnxModel_DataType OnnxModel::data_type() const { return data_type_; } +inline void OnnxModel::set_data_type(OnnxModel_DataType val) { + has_data_type_ = true; + data_type_ = val; +} +inline bool OnnxModel::has_input_planes() const { return has_input_planes_; } +inline std::string_view OnnxModel::input_planes() const { return input_planes_; } +inline void OnnxModel::set_input_planes(std::string_view val) { + has_input_planes_ = true; + input_planes_ = val; +} +inline bool OnnxModel::has_output_value() const { return has_output_value_; } +inline std::string_view OnnxModel::output_value() const { return output_value_; } +inline void OnnxModel::set_output_value(std::string_view val) { + has_output_value_ = true; + output_value_ = val; +} +inline bool OnnxModel::has_output_wdl() const { return has_output_wdl_; } +inline std::string_view OnnxModel::output_wdl() const { return output_wdl_; } +inline void OnnxModel::set_output_wdl(std::string_view val) { + has_output_wdl_ = true; + output_wdl_ = val; +} +inline bool OnnxModel::has_output_policy() const { return has_output_policy_; } +inline std::string_view OnnxModel::output_policy() const { return output_policy_; } +inline void OnnxModel::set_output_policy(std::string_view val) { + has_output_policy_ = true; + output_policy_ = val; +} +inline bool OnnxModel::has_output_mlh() const { return has_output_mlh_; } +inline std::string_view OnnxModel::output_mlh() const { return output_mlh_; } +inline void OnnxModel::set_output_mlh(std::string_view val) { + has_output_mlh_ = true; + output_mlh_ = val; +} +inline std::string Net::OutputAsString() const { + std::string out; + if (has_magic_) AppendInt32(1, magic_, &out); + if (has_license_) AppendString(2, license_, &out); + if (has_min_version_) AppendString(3, min_version_.OutputAsString(), &out); + if (has_format_) AppendString(4, format_.OutputAsString(), &out); + if (has_training_params_) AppendString(5, training_params_.OutputAsString(), &out); + if (has_weights_) AppendString(10, weights_.OutputAsString(), &out); + if (has_onnx_model_) AppendString(11, onnx_model_.OutputAsString(), &out); + return out; +} +inline std::string Net::OutputAsJson() const { + bool first = true; + std::string out = "{"; + if (has_magic_) AppendJsonField("magic", magic_, &first, &out); + if (has_license_) AppendJsonField("license", license_, &first, &out); + if (has_min_version_) AppendJsonField("min_version", min_version_, &first, &out); + if (has_format_) AppendJsonField("format", format_, &first, &out); + if (has_training_params_) AppendJsonField("training_params", training_params_, &first, &out); + if (has_weights_) AppendJsonField("weights", weights_, &first, &out); + if (has_onnx_model_) AppendJsonField("onnx_model", onnx_model_, &first, &out); + out += "}"; + return out; +} +inline void Net::Clear() { + has_magic_ = false; + magic_ = {}; + has_license_ = false; + license_ = {}; + has_min_version_ = false; + min_version_ = {}; + has_format_ = false; + format_ = {}; + has_training_params_ = false; + training_params_ = {}; + has_weights_ = false; + weights_ = {}; + has_onnx_model_ = false; + onnx_model_ = {}; +} +inline void Net::SetInt32(int field_id, std::uint32_t val) { + switch (field_id) { + case 1: set_magic(static_cast(val)); break; + } +} +inline void Net::SetString(int field_id, std::string_view val) { + switch (field_id) { + case 2: set_license(val); break; + case 3: mutable_min_version()->MergeFromString(val); break; + case 4: mutable_format()->MergeFromString(val); break; + case 5: mutable_training_params()->MergeFromString(val); break; + case 10: mutable_weights()->MergeFromString(val); break; + case 11: mutable_onnx_model()->MergeFromString(val); break; + } +} +inline bool Net::has_magic() const { return has_magic_; } +inline std::uint32_t Net::magic() const { return magic_; } +inline void Net::set_magic(std::uint32_t val) { + has_magic_ = true; + magic_ = val; +} +inline bool Net::has_license() const { return has_license_; } +inline std::string_view Net::license() const { return license_; } +inline void Net::set_license(std::string_view val) { + has_license_ = true; + license_ = val; +} +inline bool Net::has_min_version() const { return has_min_version_; } +inline const EngineVersion& Net::min_version() const { return min_version_; } +inline EngineVersion* Net::mutable_min_version() { + has_min_version_ = true; + return &min_version_; +} +inline bool Net::has_format() const { return has_format_; } +inline const Format& Net::format() const { return format_; } +inline Format* Net::mutable_format() { + has_format_ = true; + return &format_; +} +inline bool Net::has_training_params() const { return has_training_params_; } +inline const TrainingParams& Net::training_params() const { return training_params_; } +inline TrainingParams* Net::mutable_training_params() { + has_training_params_ = true; + return &training_params_; +} +inline bool Net::has_weights() const { return has_weights_; } +inline const Weights& Net::weights() const { return weights_; } +inline Weights* Net::mutable_weights() { + has_weights_ = true; + return &weights_; +} +inline bool Net::has_onnx_model() const { return has_onnx_model_; } +inline const OnnxModel& Net::onnx_model() const { return onnx_model_; } +inline OnnxModel* Net::mutable_onnx_model() { + has_onnx_model_ = true; + return &onnx_model_; +} +} // namespace pblczero