#pragma once

//

// GGML Tensor Library

//

// This documentation is still a work in progress.

// If you wish some specific topics to be covered, feel free to drop a comment:

//

// https://github.com/ggerganov/whisper.cpp/issues/40

//

// ## Overview

//

// This library implements:

//

// - a set of tensor operations

// - automatic differentiation

// - basic optimization algorithms

//

// The aim of this library is to provide a minimalistic approach for various machine learning tasks. This includes,

// but is not limited to, the following:

//

// - linear regression

// - support vector machines

// - neural networks

//

// The library allows the user to define a certain function using the available tensor operations. This function

// definition is represented internally via a computation graph. Each tensor operation in the function definition

// corresponds to a node in the graph. Having the computation graph defined, the user can choose to compute the

// function's value and/or its gradient with respect to the input variables. Optionally, the function can be optimized

// using one of the available optimization algorithms.

//

// For example, here we define the function: f(x) = a*x^2 + b

//

// {

// struct ggml_init_params params = {

// .mem_size = 16*1024*1024,

// .mem_buffer = NULL,

// };

//

// // memory allocation happens here

// struct ggml_context * ctx = ggml_init(params);

//

// struct ggml_tensor * x = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, 1);

//

// ggml_set_param(ctx, x); // x is an input variable

//

// struct ggml_tensor * a = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, 1);

// struct ggml_tensor * b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, 1);

// struct ggml_tensor * x2 = ggml_mul(ctx, x, x);

// struct ggml_tensor * f = ggml_add(ctx, ggml_mul(ctx, a, x2), b);

//

// ...

// }

//

// Notice that the function definition above does not involve any actual computation. The computation is performed only

// when the user explicitly requests it. For example, to compute the function's value at x = 2.0:

//

// {

// ...

//

// struct ggml_cgraph gf = ggml_build_forward(f);

//

// // set the input variable and parameter values

// ggml_set_f32(x, 2.0f);

// ggml_set_f32(a, 3.0f);

// ggml_set_f32(b, 4.0f);

//

// ggml_graph_compute_with_ctx(ctx, &gf, n_threads);

//

// printf("f = %f\n", ggml_get_f32_1d(f, 0));

//

// ...

// }

//

// The actual computation is performed in the ggml_graph_compute() function.

//

// The ggml_new_tensor_...() functions create new tensors. They are allocated in the memory buffer provided to the

// ggml_init() function. You have to be careful not to exceed the memory buffer size. Therefore, you have to know

// in advance how much memory you need for your computation. Alternatively, you can allocate a large enough memory

// and after defining the computation graph, call the ggml_used_mem() function to find out how much memory was

// actually needed.

//

// The ggml_set_param() function marks a tensor as an input variable. This is used by the automatic

// differentiation and optimization algorithms.

//

// The described approach allows to define the function graph once and then compute its forward or backward graphs

// multiple times. All computations will use the same memory buffer allocated in the ggml_init() function. This way

// the user can avoid the memory allocation overhead at runtime.

//

// The library supports multi-dimensional tensors - up to 4 dimensions. The FP16 and FP32 data types are first class

// citizens, but in theory the library can be extended to support FP8 and integer data types.

//

// Each tensor operation produces a new tensor. Initially the library was envisioned to support only the use of unary

// and binary operations. Most of the available operations fall into one of these two categories. With time, it became

// clear that the library needs to support more complex operations. The way to support these operations is not clear

// yet, but a few examples are demonstrated in the following operations:

//

// - ggml_permute()

// - ggml_conv_1d_1s()

// - ggml_conv_1d_2s()

//

// For each tensor operator, the library implements a forward and backward computation function. The forward function

// computes the output tensor value given the input tensor values. The backward function computes the adjoint of the

// input tensors given the adjoint of the output tensor. For a detailed explanation of what this means, take a

// calculus class, or watch the following video:

//

// What is Automatic Differentiation?

// https://www.youtube.com/watch?v=wG_nF1awSSY

//

//

// ## Tensor data (struct ggml_tensor)

//

// The tensors are stored in memory via the ggml_tensor struct. The structure provides information about the size of

// the tensor, the data type, and the memory buffer where the tensor data is stored. Additionally, it contains

// pointers to the "source" tensors - i.e. the tensors that were used to compute the current tensor. For example:

//

// {

// struct ggml_tensor * c = ggml_add(ctx, a, b);

//

// assert(c->src[0] == a);

// assert(c->src[1] == b);

// }

//

// The multi-dimensional tensors are stored in row-major order. The ggml_tensor struct contains fields for the

// number of elements in each dimension ("ne") as well as the number of bytes ("nb", a.k.a. stride). This allows

// to store tensors that are not contiguous in memory, which is useful for operations such as transposition and

// permutation. All tensor operations have to take the stride into account and not assume that the tensor is

// contiguous in memory.

//

// The data of the tensor is accessed via the "data" pointer. For example:

//

// {

// const int nx = 2;

// const int ny = 3;

//

// struct ggml_tensor * a = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, nx, ny);

//

// for (int y = 0; y < ny; y++) {

// for (int x = 0; x < nx; x++) {

// *(float *) ((char *) a->data + y*a->nb[1] + x*a->nb[0]) = x + y;

// }

// }

//

// ...

// }

//

// Alternatively, there are helper functions, such as ggml_get_f32_1d() and ggml_set_f32_1d() that can be used.

//

// ## The matrix multiplication operator (ggml_mul_mat)

//

// TODO

//

//

// ## Multi-threading

//

// TODO

//

//

// ## Overview of ggml.c

//

// TODO

//

//

// ## SIMD optimizations

//

// TODO

//

//

// ## Debugging ggml

//

// TODO

//

//

#ifdef GGML_SHARED

# if defined(_WIN32) && !defined(__MINGW32__)

# ifdef GGML_BUILD

# define GGML_API __declspec(dllexport)

# else

# define GGML_API __declspec(dllimport)

# endif

# else

# define GGML_API __attribute__ ((visibility ("default")))

# endif

#else

# define GGML_API

#endif

// TODO: support for clang

#ifdef __GNUC__

# define GGML_DEPRECATED(func, hint) func __attribute__((deprecated(hint)))

#elif defined(_MSC_VER)

# define GGML_DEPRECATED(func, hint) __declspec(deprecated(hint)) func

#else

# define GGML_DEPRECATED(func, hint) func

#endif

#ifndef __GNUC__

# define GGML_ATTRIBUTE_FORMAT(...)

#elif defined(__MINGW32__)

# define GGML_ATTRIBUTE_FORMAT(...) __attribute__((format(gnu_printf, __VA_ARGS__)))

#else

# define GGML_ATTRIBUTE_FORMAT(...) __attribute__((format(printf, __VA_ARGS__)))

#endif

#include <stdint.h>

#include <stddef.h>

#include <stdbool.h>

#define GGML_FILE_MAGIC 0x67676d6c // "ggml"

#define GGML_FILE_VERSION 1

#define GGML_QNT_VERSION 2 // bump this on quantization format changes

#define GGML_QNT_VERSION_FACTOR 1000 // do not change this

#define GGML_MAX_DIMS 4

#define GGML_MAX_NODES 16384

#define GGML_MAX_PARAMS 1024

#define GGML_MAX_CONTEXTS 64

#define GGML_MAX_SRC 6

#define GGML_MAX_NAME 64

#define GGML_MAX_OP_PARAMS 32

#define GGML_DEFAULT_N_THREADS 4

#if UINTPTR_MAX == 0xFFFFFFFF

#define GGML_MEM_ALIGN 4

#else

#define GGML_MEM_ALIGN 16

#endif

#define GGML_EXIT_SUCCESS 0

#define GGML_EXIT_ABORTED 1

#define GGUF_MAGIC 0x46554747 // "GGUF"

#define GGUF_VERSION 2

#define GGUF_DEFAULT_ALIGNMENT 32

#define GGML_UNUSED(x) (void)(x)

#define GGML_PAD(x, n) (((x) + (n) - 1) & ~((n) - 1))

#define GGML_ASSERT(x) \

do { \

if (!(x)) { \

fprintf(stderr, "GGML_ASSERT: %s:%d: %s\n", __FILE__, __LINE__, #x); \

abort(); \

} \

} while (0)

#ifndef NDEBUG

#define GGML_UNREACHABLE() GGML_ASSERT(!"statement should not be reached")

#elif defined(__GNUC__)

#define GGML_UNREACHABLE() __builtin_unreachable()

#else

#define GGML_UNREACHABLE() ((void) 0)

#endif

// used to copy the number of elements and stride in bytes of tensors into local variables.

// main purpose is to reduce code duplication and improve readability.

//

// example:

//

// GGML_TENSOR_LOCALS(int64_t, ne1, src1, ne);

// GGML_TENSOR_LOCALS(size_t, nb1, src1, nb);

//

#define GGML_TENSOR_LOCALS_1(type, prefix, pointer, array) \

const type prefix##0 = (pointer)->array[0]; \

GGML_UNUSED(prefix##0);

#define GGML_TENSOR_LOCALS_2(type, prefix, pointer, array) \

GGML_TENSOR_LOCALS_1 (type, prefix, pointer, array) \

const type prefix##1 = (pointer)->array[1]; \

GGML_UNUSED(prefix##1);

#define GGML_TENSOR_LOCALS_3(type, prefix, pointer, array) \

GGML_TENSOR_LOCALS_2 (type, prefix, pointer, array) \

const type prefix##2 = (pointer)->array[2]; \

GGML_UNUSED(prefix##2);

#define GGML_TENSOR_LOCALS(type, prefix, pointer, array) \

GGML_TENSOR_LOCALS_3 (type, prefix, pointer, array) \

const type prefix##3 = (pointer)->array[3]; \

GGML_UNUSED(prefix##3);

#ifdef __cplusplus

extern "C" {

#endif

#if defined(__ARM_NEON) && defined(__CUDACC__)

typedef half ggml_fp16_t;

#elif defined(__ARM_NEON)

typedef __fp16 ggml_fp16_t;

#else

typedef uint16_t ggml_fp16_t;

#endif

// convert FP16 <-> FP32

GGML_API float ggml_fp16_to_fp32(ggml_fp16_t x);

GGML_API ggml_fp16_t ggml_fp32_to_fp16(float x);

GGML_API void ggml_fp16_to_fp32_row(const ggml_fp16_t * x, float * y, int n);

GGML_API void ggml_fp32_to_fp16_row(const float * x, ggml_fp16_t * y, int n);

struct ggml_object;

struct ggml_context;

enum ggml_type {

GGML_TYPE_F32 = 0,

GGML_TYPE_F16 = 1,

GGML_TYPE_Q4_0 = 2,

GGML_TYPE_Q4_1 = 3,

// GGML_TYPE_Q4_2 = 4, support has been removed

// GGML_TYPE_Q4_3 (5) support has been removed

GGML_TYPE_Q5_0 = 6,

GGML_TYPE_Q5_1 = 7,

GGML_TYPE_Q8_0 = 8,

GGML_TYPE_Q8_1 = 9,

// k-quantizations

GGML_TYPE_Q2_K = 10,

GGML_TYPE_Q3_K = 11,

GGML_TYPE_Q4_K = 12,

GGML_TYPE_Q5_K = 13,

GGML_TYPE_Q6_K = 14,

GGML_TYPE_Q8_K = 15,

GGML_TYPE_I8,

GGML_TYPE_I16,

GGML_TYPE_I32,

GGML_TYPE_COUNT,

};

enum ggml_backend_type {

GGML_BACKEND_CPU = 0,

GGML_BACKEND_GPU = 10,

GGML_BACKEND_GPU_SPLIT = 20,

};

// model file types

enum ggml_ftype {

GGML_FTYPE_UNKNOWN = -1,

GGML_FTYPE_ALL_F32 = 0,

GGML_FTYPE_MOSTLY_F16 = 1, // except 1d tensors

GGML_FTYPE_MOSTLY_Q4_0 = 2, // except 1d tensors

GGML_FTYPE_MOSTLY_Q4_1 = 3, // except 1d tensors

GGML_FTYPE_MOSTLY_Q4_1_SOME_F16 = 4, // tok_embeddings.weight and output.weight are F16

GGML_FTYPE_MOSTLY_Q8_0 = 7, // except 1d tensors

GGML_FTYPE_MOSTLY_Q5_0 = 8, // except 1d tensors

GGML_FTYPE_MOSTLY_Q5_1 = 9, // except 1d tensors

GGML_FTYPE_MOSTLY_Q2_K = 10, // except 1d tensors

GGML_FTYPE_MOSTLY_Q3_K = 11, // except 1d tensors

GGML_FTYPE_MOSTLY_Q4_K = 12, // except 1d tensors

GGML_FTYPE_MOSTLY_Q5_K = 13, // except 1d tensors

GGML_FTYPE_MOSTLY_Q6_K = 14, // except 1d tensors

};

// available tensor operations:

enum ggml_op {

GGML_OP_NONE = 0,

GGML_OP_DUP,

GGML_OP_ADD,

GGML_OP_ADD1,

GGML_OP_ACC,

GGML_OP_SUB,

GGML_OP_MUL,

GGML_OP_DIV,

GGML_OP_SQR,

GGML_OP_SQRT,

GGML_OP_LOG,

GGML_OP_SUM,

GGML_OP_SUM_ROWS,

GGML_OP_MEAN,

GGML_OP_ARGMAX,

GGML_OP_REPEAT,

GGML_OP_REPEAT_BACK,

GGML_OP_CONCAT,

GGML_OP_SILU_BACK,

GGML_OP_NORM, // normalize

GGML_OP_RMS_NORM,

GGML_OP_RMS_NORM_BACK,

GGML_OP_GROUP_NORM,

GGML_OP_MUL_MAT,

GGML_OP_OUT_PROD,

GGML_OP_SCALE,

GGML_OP_SET,

GGML_OP_CPY,

GGML_OP_CONT,

GGML_OP_RESHAPE,

GGML_OP_VIEW,

GGML_OP_PERMUTE,

GGML_OP_TRANSPOSE,

GGML_OP_GET_ROWS,

GGML_OP_GET_ROWS_BACK,

GGML_OP_DIAG,

GGML_OP_DIAG_MASK_INF,

GGML_OP_DIAG_MASK_ZERO,

GGML_OP_SOFT_MAX,

GGML_OP_SOFT_MAX_BACK,

GGML_OP_ROPE,

GGML_OP_ROPE_BACK,

GGML_OP_ALIBI,

GGML_OP_CLAMP,

GGML_OP_CONV_1D,

GGML_OP_CONV_2D,

GGML_OP_CONV_TRANSPOSE_1D,

GGML_OP_CONV_TRANSPOSE_2D,

GGML_OP_POOL_1D,

GGML_OP_POOL_2D,

GGML_OP_CONV_1D_STAGE_0, // internal

GGML_OP_CONV_1D_STAGE_1, // internal

GGML_OP_UPSCALE, // nearest interpolate

GGML_OP_FLASH_ATTN,

GGML_OP_FLASH_FF,

GGML_OP_FLASH_ATTN_BACK,

GGML_OP_WIN_PART,

GGML_OP_WIN_UNPART,

GGML_OP_GET_REL_POS,

GGML_OP_ADD_REL_POS,

GGML_OP_UNARY,

GGML_OP_MAP_UNARY,

GGML_OP_MAP_BINARY,

GGML_OP_MAP_CUSTOM1_F32,

GGML_OP_MAP_CUSTOM2_F32,

GGML_OP_MAP_CUSTOM3_F32,

GGML_OP_MAP_CUSTOM1,

GGML_OP_MAP_CUSTOM2,

GGML_OP_MAP_CUSTOM3,

GGML_OP_CROSS_ENTROPY_LOSS,

GGML_OP_CROSS_ENTROPY_LOSS_BACK,

GGML_OP_COUNT,

};

enum ggml_unary_op {

GGML_UNARY_OP_ABS,

GGML_UNARY_OP_SGN,

GGML_UNARY_OP_NEG,

GGML_UNARY_OP_STEP,

GGML_UNARY_OP_TANH,

GGML_UNARY_OP_ELU,

GGML_UNARY_OP_RELU,

GGML_UNARY_OP_GELU,

GGML_UNARY_OP_GELU_QUICK,

GGML_UNARY_OP_SILU,

};

enum ggml_object_type {

GGML_OBJECT_TENSOR,

GGML_OBJECT_GRAPH,

GGML_OBJECT_WORK_BUFFER

};

enum ggml_log_level {

GGML_LOG_LEVEL_ERROR = 2,

GGML_LOG_LEVEL_WARN = 3,

GGML_LOG_LEVEL_INFO = 4

};

// ggml object

struct ggml_object {

size_t offs;

size_t size;

struct ggml_object * next;

enum ggml_object_type type;

char padding[4];

};

static const size_t GGML_OBJECT_SIZE = sizeof(struct ggml_object);

// n-dimensional tensor

struct ggml_tensor {

enum ggml_type type;

enum ggml_backend_type backend;

struct ggml_backend_buffer * buffer;

int n_dims;

int64_t ne[GGML_MAX_DIMS]; // number of elements

size_t nb[GGML_MAX_DIMS]; // stride in bytes:

// nb[0] = ggml_type_size(type)

// nb[1] = nb[0] * (ne[0] / ggml_blck_size(type)) + padding

// nb[i] = nb[i-1] * ne[i-1]

// compute data

enum ggml_op op;

// op params - allocated as int32_t for alignment

int32_t op_params[GGML_MAX_OP_PARAMS / sizeof(int32_t)];

bool is_param;

struct ggml_tensor * grad;

struct ggml_tensor * src[GGML_MAX_SRC];

// performance

int perf_runs;

int64_t perf_cycles;

int64_t perf_time_us;

struct ggml_tensor * view_src;

size_t view_offs;

void * data;

char name[GGML_MAX_NAME];

void * extra; // extra things e.g. for ggml-cuda.cu

char padding[12];

};

static const size_t GGML_TENSOR_SIZE = sizeof(struct ggml_tensor);

// the compute plan that needs to be prepared for ggml_graph_compute()

// since https://github.com/ggerganov/ggml/issues/287

struct ggml_cplan {

size_t work_size; // size of work buffer, calculated by `ggml_graph_plan()`

uint8_t * work_data; // work buffer, to be allocated by caller before calling to `ggml_graph_compute()`

int n_threads;

// the `n_tasks` of nodes, 1:1 mapping to cgraph nodes

int n_tasks[GGML_MAX_NODES];

// abort ggml_graph_compute when true

bool (*abort_callback)(void * data);

void * abort_callback_data;

};

// next prime after GGML_MAX_NODES

// #define GGML_GRAPH_HASHTABLE_SIZE 4099

// next prime after GGML_MAX_NODES * 2 (nodes + leafs)

// #define GGML_GRAPH_HASHTABLE_SIZE 8273

// #define GGML_GRAPH_HASHTABLE_SIZE 16411

#define GGML_GRAPH_HASHTABLE_SIZE 32771

enum ggml_cgraph_eval_order {

GGML_CGRAPH_EVAL_ORDER_LEFT_TO_RIGHT = 0,

GGML_CGRAPH_EVAL_ORDER_RIGHT_TO_LEFT,

GGML_CGRAPH_EVAL_ORDER_COUNT

};

// computation graph

struct ggml_cgraph {

int n_nodes;

int n_leafs;

struct ggml_tensor * nodes[GGML_MAX_NODES];

struct ggml_tensor * grads[GGML_MAX_NODES];

struct ggml_tensor * leafs[GGML_MAX_NODES];

void * visited_hash_table[GGML_GRAPH_HASHTABLE_SIZE];

enum ggml_cgraph_eval_order order;

// performance

int perf_runs;

int64_t perf_cycles;

int64_t perf_time_us;

};

static const size_t GGML_GRAPH_SIZE = sizeof(struct ggml_cgraph);

// scratch buffer

struct ggml_scratch {

size_t offs;

size_t size;

void * data;

};

struct ggml_init_params {

// memory pool

size_t mem_size; // bytes

void * mem_buffer; // if NULL, memory will be allocated internally

bool no_alloc; // don't allocate memory for the tensor data

};

// compute types

// NOTE: the INIT or FINALIZE pass is not scheduled unless explicitly enabled.

// This behavior was changed since https://github.com/ggerganov/llama.cpp/pull/1995.

enum ggml_task_type {

GGML_TASK_INIT = 0,

GGML_TASK_COMPUTE,

GGML_TASK_FINALIZE,

};

struct ggml_compute_params {

enum ggml_task_type type;

// ith = thread index, nth = number of threads

int ith, nth;

// work buffer for all threads

size_t wsize;

void * wdata;

};

// misc

GGML_API void ggml_time_init(void); // call this once at the beginning of the program

GGML_API int64_t ggml_time_ms(void);

GGML_API int64_t ggml_time_us(void);

GGML_API int64_t ggml_cycles(void);

GGML_API int64_t ggml_cycles_per_ms(void);

GGML_API void ggml_numa_init(void); // call once for better performance on NUMA systems

GGML_API bool ggml_is_numa(void); // true if init detected that system has >1 NUMA node

GGML_API void ggml_print_object (const struct ggml_object * obj);

GGML_API void ggml_print_objects(const struct ggml_context * ctx);

GGML_API int64_t ggml_nelements (const struct ggml_tensor * tensor);

GGML_API int64_t ggml_nrows (const struct ggml_tensor * tensor);

GGML_API size_t ggml_nbytes (const struct ggml_tensor * tensor);

GGML_API size_t ggml_nbytes_pad (const struct ggml_tensor * tensor); // same as ggml_nbytes() but padded to GGML_MEM_ALIGN

GGML_API size_t ggml_nbytes_split(const struct ggml_tensor * tensor, int nrows_split);

GGML_API int ggml_blck_size (enum ggml_type type);

GGML_API size_t ggml_type_size (enum ggml_type type); // size in bytes for all elements in a block

GGML_API float ggml_type_sizef(enum ggml_type type); // ggml_type_size()/ggml_blck_size() as float

GGML_API const char * ggml_type_name(enum ggml_type type);

GGML_API const char * ggml_op_name (enum ggml_op op);

GGML_API const char * ggml_op_symbol(enum ggml_op op);

GGML_API size_t ggml_element_size(const struct ggml_tensor * tensor);

GGML_API bool ggml_is_quantized(enum ggml_type type);

// TODO: temporary until model loading of ggml examples is refactored

GGML_API enum ggml_type ggml_ftype_to_ggml_type(enum ggml_ftype ftype);

GGML_API bool ggml_is_transposed(const struct ggml_tensor * tensor);

GGML_API bool ggml_is_contiguous(const struct ggml_tensor * tensor);

GGML_API bool ggml_is_permuted (const struct ggml_tensor * tensor);

GGML_API bool ggml_are_same_shape(const struct ggml_tensor * t0, const struct ggml_tensor * t1);

// use this to compute the memory overhead of a tensor

GGML_API size_t ggml_tensor_overhead(void);

// main

GGML_API struct ggml_context * ggml_init(struct ggml_init_params params);

GGML_API void ggml_free(struct ggml_context * ctx);

GGML_API size_t ggml_used_mem(const struct ggml_context * ctx);

GGML_API size_t ggml_set_scratch (struct ggml_context * ctx, struct ggml_scratch scratch);

GGML_API bool ggml_get_no_alloc(struct ggml_context * ctx);

GGML_API void ggml_set_no_alloc(struct ggml_context * ctx, bool no_alloc);

GGML_API void * ggml_get_mem_buffer (const struct ggml_context * ctx);

GGML_API size_t ggml_get_mem_size (const struct ggml_context * ctx);

GGML_API size_t ggml_get_max_tensor_size(const struct ggml_context * ctx);

GGML_API struct ggml_tensor * ggml_new_tensor(

struct ggml_context * ctx,

enum ggml_type type,

int n_dims,

const int64_t *ne);

GGML_API struct ggml_tensor * ggml_new_tensor_1d(

struct ggml_context * ctx,

enum ggml_type type,

int64_t ne0);

GGML_API struct ggml_tensor * ggml_new_tensor_2d(

struct ggml_context * ctx,

enum ggml_type type,

int64_t ne0,

int64_t ne1);

GGML_API struct ggml_tensor * ggml_new_tensor_3d(

struct ggml_context * ctx,

enum ggml_type type,

int64_t ne0,

int64_t ne1,

int64_t ne2);

GGML_API struct ggml_tensor * ggml_new_tensor_4d(

struct ggml_context * ctx,

enum ggml_type type,

int64_t ne0,

int64_t ne1,

int64_t ne2,

int64_t ne3);

GGML_API struct ggml_tensor * ggml_new_i32(struct ggml_context * ctx, int32_t value);

GGML_API struct ggml_tensor * ggml_new_f32(struct ggml_context * ctx, float value);

GGML_API struct ggml_tensor * ggml_dup_tensor (struct ggml_context * ctx, const struct ggml_tensor * src);

GGML_API struct ggml_tensor * ggml_view_tensor(struct ggml_context * ctx, struct ggml_tensor * src);

GGML_API struct ggml_tensor * ggml_get_tensor(struct ggml_context * ctx, const char * name);

GGML_API struct ggml_tensor * ggml_set_zero(struct ggml_tensor * tensor);

GGML_API struct ggml_tensor * ggml_set_i32 (struct ggml_tensor * tensor, int32_t value);

GGML_API struct ggml_tensor * ggml_set_f32 (struct ggml_tensor * tensor, float value);

// Converts a flat index into coordinates

GGML_API void ggml_unravel_index(const struct ggml_tensor * tensor, int64_t i, int64_t * i0, int64_t * i1, int64_t * i2, int64_t * i3);

GGML_API int32_t ggml_get_i32_1d(const struct ggml_tensor * tensor, int i);

GGML_API void ggml_set_i32_1d(const struct ggml_tensor * tensor, int i, int32_t value);

GGML_API int32_t ggml_get_i32_nd(const struct ggml_tensor * tensor, int i0, int i1, int i2, int i3);

GGML_API void ggml_set_i32_nd(const struct ggml_tensor * tensor, int i0, int i1, int i2, int i3, int32_t value);

GGML_API float ggml_get_f32_1d(const struct ggml_tensor * tensor, int i);

GGML_API void ggml_set_f32_1d(const struct ggml_tensor * tensor, int i, float value);

GGML_API float ggml_get_f32_nd(const struct ggml_tensor * tensor, int i0, int i1, int i2, int i3);

GGML_API void ggml_set_f32_nd(const struct ggml_tensor * tensor, int i0, int i1, int i2, int i3, float value);

GGML_API void * ggml_get_data (const struct ggml_tensor * tensor);

GGML_API float * ggml_get_data_f32(const struct ggml_tensor * tensor);

GGML_API enum ggml_unary_op ggml_get_unary_op(const struct ggml_tensor * tensor);

GGML_API const char * ggml_get_name (const struct ggml_tensor * tensor);

GGML_API struct ggml_tensor * ggml_set_name ( struct ggml_tensor * tensor, const char * name);

GGML_ATTRIBUTE_FORMAT(2, 3)

GGML_API struct ggml_tensor * ggml_format_name( struct ggml_tensor * tensor, const char * fmt, ...);

//

// operations on tensors with backpropagation

//

GGML_API struct ggml_tensor * ggml_dup(

struct ggml_context * ctx,

struct ggml_tensor * a);

// in-place, returns view(a)

GGML_API struct ggml_tensor * ggml_dup_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_add(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_add_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_add_cast(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b,

enum ggml_type type);

GGML_API struct ggml_tensor * ggml_add1(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_add1_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_acc(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b,

size_t nb1,

size_t nb2,

size_t nb3,

size_t offset);

GGML_API struct ggml_tensor * ggml_acc_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b,

size_t nb1,

size_t nb2,

size_t nb3,

size_t offset);

GGML_API struct ggml_tensor * ggml_sub(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_sub_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_mul(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_mul_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_div(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_div_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_sqr(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_sqr_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_sqrt(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_sqrt_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_log(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_log_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

// return scalar

GGML_API struct ggml_tensor * ggml_sum(

struct ggml_context * ctx,

struct ggml_tensor * a);

// sums along rows, with input shape [a,b,c,d] return shape [1,b,c,d]

GGML_API struct ggml_tensor * ggml_sum_rows(

struct ggml_context * ctx,

struct ggml_tensor * a);

// mean along rows

GGML_API struct ggml_tensor * ggml_mean(

struct ggml_context * ctx,

struct ggml_tensor * a);

// argmax along rows

GGML_API struct ggml_tensor * ggml_argmax(

struct ggml_context * ctx,

struct ggml_tensor * a);

// if a is the same shape as b, and a is not parameter, return a

// otherwise, return a new tensor: repeat(a) to fit in b

GGML_API struct ggml_tensor * ggml_repeat(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

// sums repetitions in a into shape of b

GGML_API struct ggml_tensor * ggml_repeat_back(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

// concat a and b on dim 2

// used in stable-diffusion

GGML_API struct ggml_tensor * ggml_concat(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

GGML_API struct ggml_tensor * ggml_abs(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_abs_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_sgn(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_sgn_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_neg(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_neg_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_step(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_step_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_tanh(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_tanh_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_elu(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_elu_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_relu(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_relu_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

// TODO: double-check this computation is correct

GGML_API struct ggml_tensor * ggml_gelu(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_gelu_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_gelu_quick(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_gelu_quick_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_silu(

struct ggml_context * ctx,

struct ggml_tensor * a);

GGML_API struct ggml_tensor * ggml_silu_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a);

// a - x

// b - dy

GGML_API struct ggml_tensor * ggml_silu_back(

struct ggml_context * ctx,

struct ggml_tensor * a,

struct ggml_tensor * b);

// normalize along rows

GGML_API struct ggml_tensor * ggml_norm(

struct ggml_context * ctx,

struct ggml_tensor * a,

float eps);

GGML_API struct ggml_tensor * ggml_norm_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a,

float eps);

GGML_API struct ggml_tensor * ggml_rms_norm(

struct ggml_context * ctx,

struct ggml_tensor * a,

float eps);

GGML_API struct ggml_tensor * ggml_rms_norm_inplace(

struct ggml_context * ctx,

struct ggml_tensor * a,

float eps);

// group normalize along ne0*ne1*n_groups

// used in stable-diffusion

// TODO: eps is hardcoded to 1e-6 for now