#include <assert.h>

#include <inttypes.h>

#include <stdarg.h>

#include <algorithm>

#include <cstring>

#include <fstream>

#include <iostream>

#include <iterator>

#include <map>

#include <random>

#include <regex>

#include <set>

#include <sstream>

#include <string>

#include <unordered_map>

#include <vector>

#include "ggml/ggml-alloc.h"

#include "ggml/ggml-backend.h"

#include "ggml/ggml.h"

#ifdef SD_USE_CUBLAS

#include "ggml-cuda.h"

#endif

#include "model.h"

#include "rng.h"

#include "rng_philox.h"

#include "stable-diffusion.h"

#include "util.h"

#define EPS 1e-05f

#define UNET_GRAPH_SIZE 3328

#define LORA_GRAPH_SIZE 4096

#define TIMESTEPS 1000

const char* model_version_to_str[] = {

"1.x",

"2.x",

"XL",

};

const char* sampling_methods_str[] = {

"Euler A",

"Euler",

"Heun",

"DPM2",

"DPM++ (2s)",

"DPM++ (2M)",

"modified DPM++ (2M)",

"LCM",

};

std::string sd_get_system_info() {

}

void ggml_tensor_set_f32_randn(struct ggml_tensor* tensor, std::shared_ptr<RNG> rng) {

}

void pretty_progress(int step, int steps, float time) {

}

void ggml_tensor_set_f32(struct ggml_tensor* tensor, float value, int l, int k = 0, int j = 0, int i = 0) {

GGML_ASSERT(tensor->nb[0] == sizeof(float));

*(float*)((char*)(tensor->data) + i * tensor->nb[3] + j * tensor->nb[2] + k * tensor->nb[1] + l * tensor->nb[0]) = value;

}

float ggml_tensor_get_f32(const ggml_tensor* tensor, int l, int k = 0, int j = 0, int i = 0) {

GGML_ASSERT(tensor->nb[0] == sizeof(float));

return *(float*)((char*)(tensor->data) + i * tensor->nb[3] + j * tensor->nb[2] + k * tensor->nb[1] + l * tensor->nb[0]);

}

ggml_fp16_t ggml_tensor_get_f16(const ggml_tensor* tensor, int l, int k = 0, int j = 0, int i = 0) {

GGML_ASSERT(tensor->nb[0] == sizeof(ggml_fp16_t));

return *(ggml_fp16_t*)((char*)(tensor->data) + i * tensor->nb[3] + j * tensor->nb[2] + k * tensor->nb[1] + l * tensor->nb[0]);

}

float ggml_mean(struct ggml_tensor* src) {

}

void sd_scale(struct ggml_tensor* src, float scale) {

}

void print_ggml_tensor(struct ggml_tensor* tensor, bool shape_only = false) {

}

ggml_tensor* load_tensor_from_file(ggml_context* ctx, const std::string& file_path) {

std::ifstream file(file_path, std::ios::binary);

if (!file.is_open()) {

LOG_ERROR("failed to open '%s'", file_path.c_str());

return NULL;

}

int32_t n_dims;

int32_t length;

int32_t ttype;

file.read(reinterpret_cast<char*>(&n_dims), sizeof(n_dims));

file.read(reinterpret_cast<char*>(&length), sizeof(length));

file.read(reinterpret_cast<char*>(&ttype), sizeof(ttype));

if (file.eof()) {

LOG_ERROR("incomplete file '%s'", file_path.c_str());

return NULL;

}

int32_t nelements = 1;

int32_t ne[4] = {1, 1, 1, 1};

for (int i = 0; i < n_dims; ++i) {

file.read(reinterpret_cast<char*>(&ne[i]), sizeof(ne[i]));

nelements *= ne[i];

}

std::string name(length, 0);

file.read(&name[0], length);

ggml_tensor* tensor = ggml_new_tensor_4d(ctx, (ggml_type)ttype, ne[0], ne[1], ne[2], ne[3]);

const size_t bpe = ggml_type_size(ggml_type(ttype));

file.read(reinterpret_cast<char*>(tensor->data), ggml_nbytes(tensor));

return tensor;

}

void sd_fread(void* ptr, size_t size, size_t count, FILE* stream) {

}

void copy_ggml_tensor(struct ggml_tensor* dst, struct ggml_tensor* src) {

}

void calculate_alphas_cumprod(float* alphas_cumprod,

}

void set_timestep_embedding(struct ggml_tensor* timesteps, struct ggml_tensor* embedding, int dim, int max_period = 10000) {

}

struct ggml_tensor* new_timestep_embedding(struct ggml_context* ctx, struct ggml_allocr* allocr, struct ggml_tensor* timesteps, int dim, int max_period = 10000) {

// timesteps: [N,]

// embedding: [(dim + 1)/2, N]

int acutual_dim = dim;

if (dim % 2 != 0) {

acutual_dim = dim + 1;

}

struct ggml_tensor* embedding = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, acutual_dim, timesteps->ne[0]);

if (allocr != NULL) {

ggml_allocr_alloc(allocr, embedding);

}

if (allocr != NULL && !ggml_allocr_is_measure(allocr)) {

set_timestep_embedding(timesteps, embedding, dim, max_period);

}

return embedding;

}

uint8_t* ggml_to_image_vec(struct ggml_tensor* t) {

int64_t w = t->ne[0];

int64_t h = t->ne[1];

int64_t c = t->ne[2];

uint8_t* img_data = (uint8_t*)malloc(w * h * c);

for (int i = 0; i < h; i++) {

for (int j = 0; j < w; j++) {

for (int k = 0; k < c; k++) {

float value = ggml_tensor_get_f32(t, j, i, k);

value = (value + 1.0f) * 0.5f;

if (value < 0) {

value = 0;

} else if (value > 1) {

value = 1;

}

value *= 255.f;

*(img_data + i * w * c + j * c + k) = (uint8_t)value;

}

}

}

return img_data;

}

void image_vec_to_ggml(const uint8_t* image_data,

}

struct ggml_tensor* ggml_group_norm_32(struct ggml_context* ctx,

struct ggml_tensor* a) {

return ggml_group_norm(ctx, a, 32);

}

std::pair<std::unordered_map<std::string, float>, std::string> extract_and_remove_lora(std::string text) {

}

const std::string UNK_TOKEN = "<|endoftext|>";

const std::string BOS_TOKEN = "<|startoftext|>";

const std::string EOS_TOKEN = "<|endoftext|>";

const std::string PAD_TOEKN = "<|endoftext|>";

const int UNK_TOKEN_ID = 49407;

const int BOS_TOKEN_ID = 49406;

const int EOS_TOKEN_ID = 49407;

const int PAD_TOKEN_ID = 49407;

class CLIPTokenizer {

};

std::vector<std::pair<std::string, float>> parse_prompt_attention(const std::string& text) {

}

struct ResidualAttentionBlock {

};

struct CLIPTextModel {