types.h

Go to the documentation of this file.

#pragma once
 
#include "library_defines.h"
#include <cstdint>
#include <iosfwd> // for ostream
#include <optional>
#include <string>
#include <vector>
 
namespace blace {
namespace ml_core {
 
typedef std::vector<int64_t> TensorSizes;
 
constexpr int BYTE_MAX = 255;
constexpr float SHORT_MAX = 32768.;
constexpr float BYTE_MAX_FLOAT = 255.;
 
enum DeviceEnum : int { CPU = 0, CUDA = 1, MPS = 2, DML = 3 };
 
enum ValueRangeEnum : int {
  ZERO_TO_ONE = 0,
  MINUS_ONE_TO_ONE = 1,
  IMAGENET = 2,
  UNKNOWN_VALUE_RANGE = 3,
  ZERO_TO_255 = 4,
  MINUS_0_5_TO_0_5 = 5,
  ZERO_TO_32768 = 6
};
 
enum DataTypeEnum : int {
  INT_32 = 0,
  FLOAT_32 = 1,
  BLACE_BYTE = 2,
  BLACE_BOOL = 3,
  FLOAT_32_16 = 4,
  FLOAT_16 = 5,
  SHORT = 6,
  INT_64 = 7,
  FLOAT_64 = 8
};
 
enum OrderEnum : int {
  BTCHW = 0,
  BCHW = 1,
  CHW = 2,
  HWC = 3,
  BHWC = 4,
  HW = 5,
  W = 6,
  WC = 7,
  C = 8,
  BC = 9,
  BWCH = 10,
  BHW = 11,
  BCH = 12,
  CH = 13,
  TBCHW = 14,
  BCWH = 15,
  BWHC = 16,
  NO_DIMS = 17,
  UNKNOWN_ORDER = 18,
  BOUNDING_BOX_WITH_DIMS = 19,
  THWC = 20,
  TCHW = 21,
  H = 22,
  BAUDIO_MONO_44100HZ = 23
 
};
 
enum ColorFormatEnum : int {
  RGB = 0,
  R = 1,
  A = 2,
  ARGB = 3,
  ARBITRARY_CHANNELS = 4,
  BGRA = 5,
  BGR = 6,
  LAB = 7,
  AB = 8,
  L = 9,
  XYZ = 10,
  YCBCR = 11,
  Y = 12,
  BRG = 13,
  UV = 14
};
 
enum ModelDataType { tFloat = 0, tHalf };
 
struct LAB_NORMS {
  double l_norm;
  double l_cent;
  double ab_norm;
 
  bool operator==(const LAB_NORMS &other) const;
};
 
enum FORWARD_MODE { SIMPLE = 0, MULTIPASS, SLICED };
 
enum Interpolation {
  NEAREST = 0,
  LINEAR,
  BILINEAR,
  BICUBIC,
  TRILINEAR,
  AREA,
  PIL_BICUBIC
};
 
enum PADDING_MODE { REPLICATION = 0, REFLECTION, CONSTANT };
 
enum MODEL_OFFLOADING_STRATEGY { NO_OFFLOADING = 0, TO_RAM, FULL_UNLOAD };
 
enum DIRECTION { LEFT, TOP, RIGHT, BOTTOM };
 
enum Backend {
  TORCHSCRIPT_CUDA_FP32,
  TORCHSCRIPT_CUDA_FP16,
  TORCHSCRIPT_MPS_FP32,
  ONNX_CUDA_FP32,
  ONNX_CUDA_FP16,
  ONNX_CPU_FP32,
  TORCHSCRIPT_MPS_FP16,
  TORCHSCRIPT_CPU_FP32,
  ONNX_DML_FP32,
  ONNX_DML_FP16
};
 
enum Framework { TORCHSCRIPT, ONNXRUNTIME };
 
struct EXPORT_OR_IMPORT BlaceHash {
  uint64_t hash[4];
 
  bool operator==(const BlaceHash &rhs) const;
 
  bool operator!=(const BlaceHash &rhs) const;
 
  bool operator<(const BlaceHash &rhs) const;
 
  long long to_long_long();
 
  std::string to_hex(int len = 8);
 
  friend std::ostream &operator<<(std::ostream &os, const BlaceHash &obj);
 
  BlaceHash();
 
  BlaceHash(int seed);
 
  BlaceHash(std::string str);
 
  BlaceHash(int64_t a, int64_t b, int64_t c, int64_t d);
 
  std::string print() {
    std::string returnstring = "";
    for (int temp = 0; temp < 4; temp++)
      returnstring += std::to_string(hash[temp]) + "\n";
    return returnstring;
  }
 
  static void mix_string_into_hash(BlaceHash &hash, std::string str);
 
  static void mix_float_into_hash(BlaceHash &hash, float data);
 
  static void mix_hash_into_hash(BlaceHash &hash, BlaceHash data);
};
 
struct ModelInferenceArgs {
  std::vector<Backend> backends;
  int deprecated = true;
  int seed = 0;
  int run_threaded = false;
  int plot_inputs = false;
  MODEL_OFFLOADING_STRATEGY model_offloading_strategy =
      MODEL_OFFLOADING_STRATEGY::FULL_UNLOAD;
  int empty_cache_after_inference = false;
 
  int experimental_torchscript_autocast = false;
 
  ml_core::BlaceHash hash();
 
  bool operator==(const ModelInferenceArgs &other) const;
 
  bool operator!=(const ModelInferenceArgs &other) const {
    return !(*this == other);
  }
};
 
struct MultisampleInferenceArgs {
  int parallel = true;
  int samples = 1;
  int allow_mirroring = true;
  Interpolation jitter_interpolation = BILINEAR;
  int jitter_keep_size = false;
  int max_extension = 32;
  PADDING_MODE padding_mode = PADDING_MODE::REFLECTION;
  int result_to_input_num = 1;
  int result_to_input_denum = 1;
 
  ml_core::BlaceHash hash();
 
  bool operator==(const MultisampleInferenceArgs &other) const;
 
  bool operator!=(const MultisampleInferenceArgs &other) const {
    return !(*this == other);
  }
};
 
struct SlicedInferenceArgs {
  int parallel = true;
  int slices = 1;
  int overlap = 32;
  int result_to_input_num = 1;
  int result_to_input_denum = 1;
 
  ml_core::BlaceHash hash();
 
  bool operator==(const SlicedInferenceArgs &other) const;
 
  bool operator!=(const SlicedInferenceArgs &other) const {
    return !(*this == other);
  }
};
 
class InferenceArgsCollection {
public:
  ModelInferenceArgs inference_args;
  ml_core::FORWARD_MODE mode = FORWARD_MODE::SIMPLE;
  std::optional<MultisampleInferenceArgs> multi_args = std::nullopt;
  std::optional<SlicedInferenceArgs> sliced_args = std::nullopt;
 
  ml_core::BlaceHash hash();
 
  bool operator==(const InferenceArgsCollection &other) const;
 
  bool operator!=(const InferenceArgsCollection &other) const {
    return !(*this == other);
  }
};
 
class ModelIdent : public std::string {
public:
  using std::string::string;
 
  ModelIdent(const std::string &str) : std::string(str) {
    // Additional initialization or processing can be done here
  }
};
 
enum class ReturnCode {
  OK = 0,
  Error = 1,         // Returned on generic errors
  UserCancelled = 2, // This will be returned if a callback passed to the
                     // evaluator signalled cancelation.
  UserKilled = 3, // This will be returned if a callback passed to the evaluator
                  // signalled a killing wish.
  MissingData =
      4,         // Returned if missing data was encountered during computation
  Error_OOM = 5, // Returned if method run into an OOM situation. Will only
                 // happen if returned from RawMemoryFetcher.
  ModelFileNotPresent = 6, // Model file was not found
  Error_Inference_OOM = 7, // Returned if worker ran out of RAM / VRAM during
                           // inference.
  Error_IPC_Timeout = 8    // Returned if IPC process timed out.
 
};
 
} // namespace ml_core
} // namespace blace