fix

.github/workflows/build.yml

@@ -149,7 +149,7 @@ jobs:
     runs-on: windows-2025
 
     env:
-      VULKAN_VERSION: 1.4.328.1
+      VULKAN_VERSION: 1.3.261.1
 
     strategy:
       matrix:
@@ -162,8 +162,8 @@ jobs:
             defines: "-DGGML_NATIVE=OFF -DGGML_AVX=ON -DGGML_AVX2=OFF -DSD_BUILD_SHARED_LIBS=ON"
           - build: "avx512"
             defines: "-DGGML_NATIVE=OFF -DGGML_AVX512=ON -DGGML_AVX=ON -DGGML_AVX2=ON -DSD_BUILD_SHARED_LIBS=ON"
-          - build: "cuda12"
-            defines: "-DSD_CUDA=ON -DSD_BUILD_SHARED_LIBS=ON -DCMAKE_CUDA_ARCHITECTURES=90;89;86;80;75"
+          # - build: "cuda12"
+          #   defines: "-DSD_CUDA=ON -DSD_BUILD_SHARED_LIBS=ON -DCMAKE_CUDA_ARCHITECTURES=90;89;86;80;75"
           # - build: "rocm5.5"
           #   defines: '-G Ninja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DSD_HIPBLAS=ON -DCMAKE_BUILD_TYPE=Release -DAMDGPU_TARGETS="gfx1100;gfx1102;gfx1030" -DSD_BUILD_SHARED_LIBS=ON'
           - build: 'vulkan'
@@ -199,9 +199,9 @@ jobs:
           version: 1.11.1
       - name: Install Vulkan SDK
         id: get_vulkan
-        if: ${{ matrix.build == 'vulkan' }} https://sdk.lunarg.com/sdk/download/1.4.328.1/windows/vulkansdk-windows-X64-1.4.328.1.exe
+        if: ${{ matrix.build == 'vulkan' }}
         run: |
-          curl.exe -o $env:RUNNER_TEMP/VulkanSDK-Installer.exe -L "https://sdk.lunarg.com/sdk/download/${env:VULKAN_VERSION}/windows/vulkansdk-windows-X64-${env:VULKAN_VERSION}.exe"
+          curl.exe -o $env:RUNNER_TEMP/VulkanSDK-Installer.exe -L "https://sdk.lunarg.com/sdk/download/${env:VULKAN_VERSION}/windows/VulkanSDK-${env:VULKAN_VERSION}-Installer.exe"
           & "$env:RUNNER_TEMP\VulkanSDK-Installer.exe" --accept-licenses --default-answer --confirm-command install
           Add-Content $env:GITHUB_ENV "VULKAN_SDK=C:\VulkanSDK\${env:VULKAN_VERSION}"
           Add-Content $env:GITHUB_PATH "C:\VulkanSDK\${env:VULKAN_VERSION}\bin"
@@ -305,6 +305,7 @@ jobs:
         id: commit_count
         run: |
           echo "count=$(git rev-list --count HEAD)" >> $GITHUB_OUTPUT
+          echo "DEBUG: commit count = $(git rev-list --count HEAD)"
 
       - name: Get commit hash
         id: commit
@@ -317,7 +318,10 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          tag_name: ${{ format('{0}-{1}-{2}', env.BRANCH_NAME, steps.commit_count.outputs.count, steps.commit.outputs.short) }}
+          tag_name: >
+            ${{ github.ref_name == 'master' &&
+                format('release_{0}_{1}', steps.commit_count.outputs.count, steps.commit.outputs.short) ||
+                format('{0}-{1}', env.BRANCH_NAME, steps.commit.outputs.short) }}
 
       - name: Upload release
         id: upload_release

CMakeLists.txt

@@ -33,7 +33,6 @@ option(SD_SYCL                       "sd: sycl backend" OFF)
 option(SD_MUSA                       "sd: musa backend" OFF)
 option(SD_FAST_SOFTMAX               "sd: x1.5 faster softmax, indeterministic (sometimes, same seed don't generate same image), cuda only" OFF)
 option(SD_BUILD_SHARED_LIBS          "sd: build shared libs" OFF)
-option(SD_BUILD_SHARED_GGML_LIB      "sd: build ggml as a separate shared lib" OFF)
 option(SD_USE_SYSTEM_GGML            "sd: use system-installed GGML library" OFF)
 #option(SD_BUILD_SERVER               "sd: build server example"                           ON)
 
@@ -87,21 +86,18 @@ file(GLOB SD_LIB_SOURCES
     "*.hpp"
 )
 
+# we can get only one share lib
 if(SD_BUILD_SHARED_LIBS)
     message("-- Build shared library")
     message(${SD_LIB_SOURCES})
-    if(NOT SD_BUILD_SHARED_GGML_LIB)
-        set(BUILD_SHARED_LIBS OFF)
-    endif()
+    set(BUILD_SHARED_LIBS OFF)
     add_library(${SD_LIB} SHARED ${SD_LIB_SOURCES})
     add_definitions(-DSD_BUILD_SHARED_LIB)
     target_compile_definitions(${SD_LIB} PRIVATE -DSD_BUILD_DLL)
     set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 else()
     message("-- Build static library")
-    if(NOT SD_BUILD_SHARED_GGML_LIB)
-        set(BUILD_SHARED_LIBS OFF)
-    endif()
+    set(BUILD_SHARED_LIBS OFF)
     add_library(${SD_LIB} STATIC ${SD_LIB_SOURCES})
 endif()
 

Dockerfile

@@ -1,21 +1,16 @@
 ARG UBUNTU_VERSION=22.04
 
-FROM ubuntu:$UBUNTU_VERSION AS build
+FROM ubuntu:$UBUNTU_VERSION as build
 
-RUN apt-get update && apt-get install -y --no-install-recommends build-essential git cmake
+RUN apt-get update && apt-get install -y build-essential git cmake
 
 WORKDIR /sd.cpp
 
 COPY . .
 
-RUN cmake . -B ./build
-RUN cmake --build ./build --config Release --parallel
+RUN mkdir build && cd build && cmake .. && cmake --build . --config Release
 
-FROM ubuntu:$UBUNTU_VERSION AS runtime
-
-RUN apt-get update && \
-    apt-get install --yes --no-install-recommends libgomp1 && \
-    apt-get clean
+FROM ubuntu:$UBUNTU_VERSION as runtime
 
 COPY --from=build /sd.cpp/build/bin/sd /sd
 

README.md

@@ -21,10 +21,8 @@ API and command-line option may change frequently.***
     - [SD3/SD3.5](./docs/sd3.md)
     - [Flux-dev/Flux-schnell](./docs/flux.md)
     - [Chroma](./docs/chroma.md)
-    - [Qwen Image](./docs/qwen_image.md)
   - Image Edit Models
     - [FLUX.1-Kontext-dev](./docs/kontext.md)
-    - [Qwen Image Edit/Qwen Image Edit 2509](./docs/qwen_image_edit.md)
   - Video Models
     - [Wan2.1/Wan2.2](./docs/wan.md)
   - [PhotoMaker](https://github.com/TencentARC/PhotoMaker) support.
@@ -127,14 +125,13 @@ cmake --build . --config Release
 
 ##### Using HipBLAS
 This provides BLAS acceleration using the ROCm cores of your AMD GPU. Make sure to have the ROCm toolkit installed.
-To build for another GPU architecture than installed in your system, set `$GFX_NAME` manually to the desired architecture (replace first command). This is also necessary if your GPU is not officially supported by ROCm, for example you have to set `$GFX_NAME` manually to `gfx1030` for consumer RDNA2 cards.
 
 Windows User Refer to [docs/hipBLAS_on_Windows.md](docs%2FhipBLAS_on_Windows.md) for a comprehensive guide.
 
 ```
-if command -v rocminfo; then export GFX_NAME=$(rocminfo | awk '/ *Name: +gfx[1-9]/ {print $2; exit}'); else echo "rocminfo missing!"; fi
-if [ -z "${GFX_NAME}" ]; then echo "Error: Couldn't detect GPU!"; else echo "Building for GPU: ${GFX_NAME}"; fi
-cmake .. -G "Ninja" -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DSD_HIPBLAS=ON -DCMAKE_BUILD_TYPE=Release -DGPU_TARGETS=$GFX_NAME -DAMDGPU_TARGETS=$GFX_NAME -DCMAKE_BUILD_WITH_INSTALL_RPATH=ON -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+export GFX_NAME=$(rocminfo | grep -m 1 -E "gfx[^0]{1}" | sed -e 's/ *Name: *//' | awk '{$1=$1; print}' || echo "rocminfo missing")
+echo $GFX_NAME
+cmake .. -G "Ninja" -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DSD_HIPBLAS=ON -DCMAKE_BUILD_TYPE=Release -DGPU_TARGETS=$GFX_NAME -DCMAKE_BUILD_WITH_INSTALL_RPATH=ON
 cmake --build . --config Release
 ```
 
@@ -287,7 +284,7 @@ usage: ./bin/sd [arguments]
 
 arguments:
   -h, --help                         show this help message and exit
-  -M, --mode [MODE]                  run mode, one of: [img_gen, vid_gen, upscale, convert], default: img_gen
+  -M, --mode [MODE]                  run mode, one of: [img_gen, vid_gen, convert], default: img_gen
   -t, --threads N                    number of threads to use during computation (default: -1)
                                      If threads <= 0, then threads will be set to the number of CPU physical cores
   --offload-to-cpu                   place the weights in RAM to save VRAM, and automatically load them into VRAM when needed
@@ -298,13 +295,11 @@ arguments:
   --clip_g                           path to the clip-g text encoder
   --clip_vision                      path to the clip-vision encoder
   --t5xxl                            path to the t5xxl text encoder
-  --qwen2vl                          path to the qwen2vl text encoder
-  --qwen2vl_vision                   path to the qwen2vl vit
   --vae [VAE]                        path to vae
   --taesd [TAESD_PATH]               path to taesd. Using Tiny AutoEncoder for fast decoding (low quality)
   --control-net [CONTROL_PATH]       path to control net model
   --embd-dir [EMBEDDING_PATH]        path to embeddings
-  --upscale-model [ESRGAN_PATH]      path to esrgan model. For img_gen mode, upscale images after generate, just RealESRGAN_x4plus_anime_6B supported by now
+  --upscale-model [ESRGAN_PATH]      path to esrgan model. Upscale images after generate, just RealESRGAN_x4plus_anime_6B supported by now
   --upscale-repeats                  Run the ESRGAN upscaler this many times (default 1)
   --type [TYPE]                      weight type (examples: f32, f16, q4_0, q4_1, q5_0, q5_1, q8_0, q2_K, q3_K, q4_K)
                                      If not specified, the default is the type of the weight file
@@ -358,7 +353,6 @@ arguments:
   --rng {std_default, cuda}          RNG (default: cuda)
   -s SEED, --seed SEED               RNG seed (default: 42, use random seed for < 0)
   -b, --batch-count COUNT            number of images to generate
-  --prediction {eps, v, edm_v, sd3_flow, flux_flow} Prediction type override
   --clip-skip N                      ignore last layers of CLIP network; 1 ignores none, 2 ignores one layer (default: -1)
                                      <= 0 represents unspecified, will be 1 for SD1.x, 2 for SD2.x
   --vae-tiling                       process vae in tiles to reduce memory usage
@@ -390,6 +384,7 @@ arguments:
   --pm-id-images-dir [DIR]           path to PHOTOMAKER input id images dir
   --pm-id-embed-path [PATH]          path to PHOTOMAKER v2 id embed
   --pm-style-strength                strength for keeping PHOTOMAKER input identity (default: 20)
+  --normalize-input                  normalize PHOTOMAKER input id images
   -v, --verbose                      print extra info
 ```
 
@@ -454,7 +449,6 @@ These projects use `stable-diffusion.cpp` as a backend for their image generatio
 - [Local Diffusion](https://github.com/rmatif/Local-Diffusion)
 - [sd.cpp-webui](https://github.com/daniandtheweb/sd.cpp-webui)
 - [LocalAI](https://github.com/mudler/LocalAI)
-- [Neural-Pixel](https://github.com/Luiz-Alcantara/Neural-Pixel)
 
 ## Contributors
 
@@ -469,7 +463,6 @@ Thank you to all the people who have already contributed to stable-diffusion.cpp
 ## References
 
 - [ggml](https://github.com/ggerganov/ggml)
-- [diffusers](https://github.com/huggingface/diffusers)
 - [stable-diffusion](https://github.com/CompVis/stable-diffusion)
 - [sd3-ref](https://github.com/Stability-AI/sd3-ref)
 - [stable-diffusion-stability-ai](https://github.com/Stability-AI/stablediffusion)
@@ -480,4 +473,4 @@ Thank you to all the people who have already contributed to stable-diffusion.cpp
 - [generative-models](https://github.com/Stability-AI/generative-models/)
 - [PhotoMaker](https://github.com/TencentARC/PhotoMaker)
 - [Wan2.1](https://github.com/Wan-Video/Wan2.1)
-- [Wan2.2](https://github.com/Wan-Video/Wan2.2)
+- [Wan2.2](https://github.com/Wan-Video/Wan2.2)

clip.hpp

@@ -6,7 +6,7 @@
 
 /*================================================== CLIPTokenizer ===================================================*/
 
-__STATIC_INLINE__ std::pair<std::unordered_map<std::string, float>, std::string> extract_and_remove_lora(std::string text) {
+std::pair<std::unordered_map<std::string, float>, std::string> extract_and_remove_lora(std::string text) {
     std::regex re("<lora:([^:]+):([^>]+)>");
     std::smatch matches;
     std::unordered_map<std::string, float> filename2multiplier;
@@ -31,7 +31,7 @@ __STATIC_INLINE__ std::pair<std::unordered_map<std::string, float>, std::string>
     return std::make_pair(filename2multiplier, text);
 }
 
-__STATIC_INLINE__ std::vector<std::pair<int, std::u32string>> bytes_to_unicode() {
+std::vector<std::pair<int, std::u32string>> bytes_to_unicode() {
     std::vector<std::pair<int, std::u32string>> byte_unicode_pairs;
     std::set<int> byte_set;
     for (int b = static_cast<int>('!'); b <= static_cast<int>('~'); ++b) {
@@ -553,12 +553,12 @@ protected:
     void init_params(struct ggml_context* ctx, const String2GGMLType& tensor_types = {}, const std::string prefix = "") {
         enum ggml_type token_wtype = GGML_TYPE_F32;
         if (!force_clip_f32) {
-            token_wtype = get_type(prefix + "token_embedding.weight", tensor_types, GGML_TYPE_F32);
-            if (!support_get_rows(token_wtype)) {
-                token_wtype = GGML_TYPE_F32;
-            }
+            auto tensor_type = tensor_types.find(prefix + "token_embedding.weight");
+            if (tensor_type != tensor_types.end())
+                token_wtype = tensor_type->second;
         }
-        enum ggml_type position_wtype       = GGML_TYPE_F32;
+        enum ggml_type position_wtype = GGML_TYPE_F32;
+
         params["token_embedding.weight"]    = ggml_new_tensor_2d(ctx, token_wtype, embed_dim, vocab_size);
         params["position_embedding.weight"] = ggml_new_tensor_2d(ctx, position_wtype, embed_dim, num_positions);
     }

common.hpp

@@ -177,7 +177,7 @@ public:
     }
 };
 
-class GEGLU : public UnaryBlock {
+class GEGLU : public GGMLBlock {
 protected:
     int64_t dim_in;
     int64_t dim_out;
@@ -216,57 +216,23 @@ public:
     }
 };
 
-class GELU : public UnaryBlock {
-public:
-    GELU(int64_t dim_in, int64_t dim_out, bool bias = true) {
-        blocks["proj"] = std::shared_ptr<GGMLBlock>(new Linear(dim_in, dim_out, bias));
-    }
-
-    struct ggml_tensor* forward(struct ggml_context* ctx, struct ggml_tensor* x) {
-        // x: [ne3, ne2, ne1, dim_in]
-        // return: [ne3, ne2, ne1, dim_out]
-        auto proj = std::dynamic_pointer_cast<Linear>(blocks["proj"]);
-
-        x = proj->forward(ctx, x);
-        x = ggml_gelu_inplace(ctx, x);
-        return x;
-    }
-};
-
 class FeedForward : public GGMLBlock {
 public:
-    enum class Activation {
-        GEGLU,
-        GELU
-    };
     FeedForward(int64_t dim,
                 int64_t dim_out,
-                int64_t mult          = 4,
-                Activation activation = Activation::GEGLU,
-                bool precision_fix    = false) {
+                int64_t mult = 4) {
         int64_t inner_dim = dim * mult;
-        if (activation == Activation::GELU) {
-            blocks["net.0"] = std::shared_ptr<GGMLBlock>(new GELU(dim, inner_dim));
-        } else {
-            blocks["net.0"] = std::shared_ptr<GGMLBlock>(new GEGLU(dim, inner_dim));
-        }
 
+        blocks["net.0"] = std::shared_ptr<GGMLBlock>(new GEGLU(dim, inner_dim));
         // net_1 is nn.Dropout(), skip for inference
-        float scale = 1.f;
-        if (precision_fix) {
-            scale = 1.f / 128.f;
-        }
-        // The purpose of the scale here is to prevent NaN issues in certain situations.
-        // For example, when using Vulkan without enabling force_prec_f32,
-        // or when using CUDA but the weights are k-quants.
-        blocks["net.2"] = std::shared_ptr<GGMLBlock>(new Linear(inner_dim, dim_out, true, false, false, scale));
+        blocks["net.2"] = std::shared_ptr<GGMLBlock>(new Linear(inner_dim, dim_out));
     }
 
     struct ggml_tensor* forward(struct ggml_context* ctx, struct ggml_tensor* x) {
         // x: [ne3, ne2, ne1, dim]
         // return: [ne3, ne2, ne1, dim_out]
 
-        auto net_0 = std::dynamic_pointer_cast<UnaryBlock>(blocks["net.0"]);
+        auto net_0 = std::dynamic_pointer_cast<GEGLU>(blocks["net.0"]);
         auto net_2 = std::dynamic_pointer_cast<Linear>(blocks["net.2"]);
 
         x = net_0->forward(ctx, x);  // [ne3, ne2, ne1, inner_dim]

conditioner.hpp

@@ -2,7 +2,6 @@
 #define __CONDITIONER_HPP__
 
 #include "clip.hpp"
-#include "qwenvl.hpp"
 #include "t5.hpp"
 
 struct SDCondition {
@@ -15,34 +14,30 @@ struct SDCondition {
         : c_crossattn(c_crossattn), c_vector(c_vector), c_concat(c_concat) {}
 };
 
-struct ConditionerParams {
-    std::string text;
-    int clip_skip                       = -1;
-    int width                           = -1;
-    int height                          = -1;
-    int adm_in_channels                 = -1;
-    bool zero_out_masked                = false;
-    int num_input_imgs                  = 0;   // for photomaker
-    std::vector<sd_image_t*> ref_images = {};  // for qwen image edit
-};
-
 struct Conditioner {
     virtual SDCondition get_learned_condition(ggml_context* work_ctx,
                                               int n_threads,
-                                              const ConditionerParams& conditioner_params) = 0;
-    virtual void alloc_params_buffer()                                                     = 0;
-    virtual void free_params_buffer()                                                      = 0;
-    virtual void get_param_tensors(std::map<std::string, struct ggml_tensor*>& tensors)    = 0;
-    virtual size_t get_params_buffer_size()                                                = 0;
+                                              const std::string& text,
+                                              int clip_skip,
+                                              int width,
+                                              int height,
+                                              int adm_in_channels  = -1,
+                                              bool zero_out_masked = false)                                             = 0;
+    virtual void alloc_params_buffer()                                                                                  = 0;
+    virtual void free_params_buffer()                                                                                   = 0;
+    virtual void get_param_tensors(std::map<std::string, struct ggml_tensor*>& tensors)                                 = 0;
+    virtual size_t get_params_buffer_size()                                                                             = 0;
     virtual std::tuple<SDCondition, std::vector<bool>> get_learned_condition_with_trigger(ggml_context* work_ctx,
                                                                                           int n_threads,
-                                                                                          const ConditionerParams& conditioner_params) {
-        GGML_ABORT("Not implemented yet!");
-    }
+                                                                                          const std::string& text,
+                                                                                          int clip_skip,
+                                                                                          int width,
+                                                                                          int height,
+                                                                                          int num_input_imgs,
+                                                                                          int adm_in_channels  = -1,
+                                                                                          bool zero_out_masked = false) = 0;
     virtual std::string remove_trigger_from_prompt(ggml_context* work_ctx,
-                                                   const std::string& prompt) {
-        GGML_ABORT("Not implemented yet!");
-    }
+                                                   const std::string& prompt)                                           = 0;
 };
 
 // ldm.modules.encoders.modules.FrozenCLIPEmbedder
@@ -146,7 +141,7 @@ struct FrozenCLIPEmbedderWithCustomWords : public Conditioner {
             }
             return true;
         };
-        model_loader.load_tensors(on_load, 1);
+        model_loader.load_tensors(on_load);
         readed_embeddings.push_back(embd_name);
         if (embd) {
             int64_t hidden_size = text_model->model.hidden_size;
@@ -555,14 +550,20 @@ struct FrozenCLIPEmbedderWithCustomWords : public Conditioner {
     std::tuple<SDCondition, std::vector<bool>>
     get_learned_condition_with_trigger(ggml_context* work_ctx,
                                        int n_threads,
-                                       const ConditionerParams& conditioner_params) {
+                                       const std::string& text,
+                                       int clip_skip,
+                                       int width,
+                                       int height,
+                                       int num_input_imgs,
+                                       int adm_in_channels  = -1,
+                                       bool zero_out_masked = false) {
         auto image_tokens = convert_token_to_id(trigger_word);
         // if(image_tokens.size() == 1){
         //     printf(" image token id is: %d \n", image_tokens[0]);
         // }
         GGML_ASSERT(image_tokens.size() == 1);
-        auto tokens_and_weights     = tokenize_with_trigger_token(conditioner_params.text,
-                                                                  conditioner_params.num_input_imgs,
+        auto tokens_and_weights     = tokenize_with_trigger_token(text,
+                                                                  num_input_imgs,
                                                                   image_tokens[0],
                                                                   true);
         std::vector<int>& tokens    = std::get<0>(tokens_and_weights);
@@ -576,15 +577,7 @@ struct FrozenCLIPEmbedderWithCustomWords : public Conditioner {
         // for(int i = 0; i < clsm.size(); ++i)
         //    printf("%d ", clsm[i]?1:0);
         // printf("\n");
-        auto cond = get_learned_condition_common(work_ctx,
-                                                 n_threads,
-                                                 tokens,
-                                                 weights,
-                                                 conditioner_params.clip_skip,
-                                                 conditioner_params.width,
-                                                 conditioner_params.height,
-                                                 conditioner_params.adm_in_channels,
-                                                 conditioner_params.zero_out_masked);
+        auto cond = get_learned_condition_common(work_ctx, n_threads, tokens, weights, clip_skip, width, height, adm_in_channels, zero_out_masked);
         return std::make_tuple(cond, clsm);
     }
 
@@ -602,19 +595,16 @@ struct FrozenCLIPEmbedderWithCustomWords : public Conditioner {
 
     SDCondition get_learned_condition(ggml_context* work_ctx,
                                       int n_threads,
-                                      const ConditionerParams& conditioner_params) {
-        auto tokens_and_weights     = tokenize(conditioner_params.text, true);
+                                      const std::string& text,
+                                      int clip_skip,
+                                      int width,
+                                      int height,
+                                      int adm_in_channels  = -1,
+                                      bool zero_out_masked = false) {
+        auto tokens_and_weights     = tokenize(text, true);
         std::vector<int>& tokens    = tokens_and_weights.first;
         std::vector<float>& weights = tokens_and_weights.second;
-        return get_learned_condition_common(work_ctx,
-                                            n_threads,
-                                            tokens,
-                                            weights,
-                                            conditioner_params.clip_skip,
-                                            conditioner_params.width,
-                                            conditioner_params.height,
-                                            conditioner_params.adm_in_channels,
-                                            conditioner_params.zero_out_masked);
+        return get_learned_condition_common(work_ctx, n_threads, tokens, weights, clip_skip, width, height, adm_in_channels, zero_out_masked);
     }
 };
 
@@ -979,13 +969,31 @@ struct SD3CLIPEmbedder : public Conditioner {
 
     SDCondition get_learned_condition(ggml_context* work_ctx,
                                       int n_threads,
-                                      const ConditionerParams& conditioner_params) {
-        auto tokens_and_weights = tokenize(conditioner_params.text, 77, true);
-        return get_learned_condition_common(work_ctx,
-                                            n_threads,
-                                            tokens_and_weights,
-                                            conditioner_params.clip_skip,
-                                            conditioner_params.zero_out_masked);
+                                      const std::string& text,
+                                      int clip_skip,
+                                      int width,
+                                      int height,
+                                      int adm_in_channels  = -1,
+                                      bool zero_out_masked = false) {
+        auto tokens_and_weights = tokenize(text, 77, true);
+        return get_learned_condition_common(work_ctx, n_threads, tokens_and_weights, clip_skip, zero_out_masked);
+    }
+
+    std::tuple<SDCondition, std::vector<bool>> get_learned_condition_with_trigger(ggml_context* work_ctx,
+                                                                                  int n_threads,
+                                                                                  const std::string& text,
+                                                                                  int clip_skip,
+                                                                                  int width,
+                                                                                  int height,
+                                                                                  int num_input_imgs,
+                                                                                  int adm_in_channels  = -1,
+                                                                                  bool zero_out_masked = false) {
+        GGML_ASSERT(0 && "Not implemented yet!");
+    }
+
+    std::string remove_trigger_from_prompt(ggml_context* work_ctx,
+                                           const std::string& prompt) {
+        GGML_ASSERT(0 && "Not implemented yet!");
     }
 };
 
@@ -1178,13 +1186,31 @@ struct FluxCLIPEmbedder : public Conditioner {
 
     SDCondition get_learned_condition(ggml_context* work_ctx,
                                       int n_threads,
-                                      const ConditionerParams& conditioner_params) {
-        auto tokens_and_weights = tokenize(conditioner_params.text, chunk_len, true);
-        return get_learned_condition_common(work_ctx,
-                                            n_threads,
-                                            tokens_and_weights,
-                                            conditioner_params.clip_skip,
-                                            conditioner_params.zero_out_masked);
+                                      const std::string& text,
+                                      int clip_skip,
+                                      int width,
+                                      int height,
+                                      int adm_in_channels  = -1,
+                                      bool zero_out_masked = false) {
+        auto tokens_and_weights = tokenize(text, chunk_len, true);
+        return get_learned_condition_common(work_ctx, n_threads, tokens_and_weights, clip_skip, zero_out_masked);
+    }
+
+    std::tuple<SDCondition, std::vector<bool>> get_learned_condition_with_trigger(ggml_context* work_ctx,
+                                                                                  int n_threads,
+                                                                                  const std::string& text,
+                                                                                  int clip_skip,
+                                                                                  int width,
+                                                                                  int height,
+                                                                                  int num_input_imgs,
+                                                                                  int adm_in_channels  = -1,
+                                                                                  bool zero_out_masked = false) {
+        GGML_ASSERT(0 && "Not implemented yet!");
+    }
+
+    std::string remove_trigger_from_prompt(ggml_context* work_ctx,
+                                           const std::string& prompt) {
+        GGML_ASSERT(0 && "Not implemented yet!");
     }
 };
 
@@ -1363,214 +1389,31 @@ struct T5CLIPEmbedder : public Conditioner {
 
     SDCondition get_learned_condition(ggml_context* work_ctx,
                                       int n_threads,
-                                      const ConditionerParams& conditioner_params) {
-        auto tokens_and_weights = tokenize(conditioner_params.text, chunk_len, true);
-        return get_learned_condition_common(work_ctx,
-                                            n_threads,
-                                            tokens_and_weights,
-                                            conditioner_params.clip_skip,
-                                            conditioner_params.zero_out_masked);
-    }
-};
-
-struct Qwen2_5_VLCLIPEmbedder : public Conditioner {
-    Qwen::Qwen2Tokenizer tokenizer;
-    std::shared_ptr<Qwen::Qwen2_5_VLRunner> qwenvl;
-
-    Qwen2_5_VLCLIPEmbedder(ggml_backend_t backend,
-                           bool offload_params_to_cpu,
-                           const String2GGMLType& tensor_types = {},
-                           const std::string prefix            = "",
-                           bool enable_vision                  = false) {
-        qwenvl = std::make_shared<Qwen::Qwen2_5_VLRunner>(backend,
-                                                          offload_params_to_cpu,
-                                                          tensor_types,
-                                                          "text_encoders.qwen2vl",
-                                                          enable_vision);
+                                      const std::string& text,
+                                      int clip_skip,
+                                      int width,
+                                      int height,
+                                      int adm_in_channels  = -1,
+                                      bool zero_out_masked = false) {
+        auto tokens_and_weights = tokenize(text, chunk_len, true);
+        return get_learned_condition_common(work_ctx, n_threads, tokens_and_weights, clip_skip, zero_out_masked);
     }
 
-    void get_param_tensors(std::map<std::string, struct ggml_tensor*>& tensors) {
-        qwenvl->get_param_tensors(tensors, "text_encoders.qwen2vl");
+    std::tuple<SDCondition, std::vector<bool>> get_learned_condition_with_trigger(ggml_context* work_ctx,
+                                                                                  int n_threads,
+                                                                                  const std::string& text,
+                                                                                  int clip_skip,
+                                                                                  int width,
+                                                                                  int height,
+                                                                                  int num_input_imgs,
+                                                                                  int adm_in_channels  = -1,
+                                                                                  bool zero_out_masked = false) {
+        GGML_ASSERT(0 && "Not implemented yet!");
     }
 
-    void alloc_params_buffer() {
-        qwenvl->alloc_params_buffer();
-    }
-
-    void free_params_buffer() {
-        qwenvl->free_params_buffer();
-    }
-
-    size_t get_params_buffer_size() {
-        size_t buffer_size = 0;
-        buffer_size += qwenvl->get_params_buffer_size();
-        return buffer_size;
-    }
-
-    std::tuple<std::vector<int>, std::vector<float>> tokenize(std::string text,
-                                                              size_t max_length           = 0,
-                                                              size_t system_prompt_length = 0,
-                                                              bool padding                = false) {
-        std::vector<std::pair<std::string, float>> parsed_attention;
-        if (system_prompt_length > 0) {
-            parsed_attention.emplace_back(text.substr(0, system_prompt_length), 1.f);
-            auto new_parsed_attention = parse_prompt_attention(text.substr(system_prompt_length, text.size() - system_prompt_length));
-            parsed_attention.insert(parsed_attention.end(),
-                                    new_parsed_attention.begin(),
-                                    new_parsed_attention.end());
-        } else {
-            parsed_attention = parse_prompt_attention(text);
-        }
-
-        {
-            std::stringstream ss;
-            ss << "[";
-            for (const auto& item : parsed_attention) {
-                ss << "['" << item.first << "', " << item.second << "], ";
-            }
-            ss << "]";
-            LOG_DEBUG("parse '%s' to %s", text.c_str(), ss.str().c_str());
-        }
-
-        std::vector<int> tokens;
-        std::vector<float> weights;
-        for (const auto& item : parsed_attention) {
-            const std::string& curr_text = item.first;
-            float curr_weight            = item.second;
-            std::vector<int> curr_tokens = tokenizer.tokenize(curr_text, nullptr);
-            tokens.insert(tokens.end(), curr_tokens.begin(), curr_tokens.end());
-            weights.insert(weights.end(), curr_tokens.size(), curr_weight);
-        }
-
-        tokenizer.pad_tokens(tokens, weights, max_length, padding);
-
-        // for (int i = 0; i < tokens.size(); i++) {
-        //     std::cout << tokens[i] << ":" << weights[i] << ", " << i << std::endl;
-        // }
-        // std::cout << std::endl;
-
-        return {tokens, weights};
-    }
-
-    SDCondition get_learned_condition(ggml_context* work_ctx,
-                                      int n_threads,
-                                      const ConditionerParams& conditioner_params) {
-        std::string prompt;
-        std::vector<std::pair<int, ggml_tensor*>> image_embeds;
-        size_t system_prompt_length = 0;
-        int prompt_template_encode_start_idx = 34;
-        if (qwenvl->enable_vision && conditioner_params.ref_images.size() > 0) {
-            LOG_INFO("QwenImageEditPlusPipeline");
-            prompt_template_encode_start_idx = 64;
-            int image_embed_idx              = 64 + 6;
-
-            int min_pixels          = 384 * 384;
-            int max_pixels          = 560 * 560;
-            std::string placeholder = "<|image_pad|>";
-            std::string img_prompt;
-
-            for (int i = 0; i < conditioner_params.ref_images.size(); i++) {
-                sd_image_f32_t image = sd_image_t_to_sd_image_f32_t(*conditioner_params.ref_images[i]);
-                double factor        = qwenvl->params.vision.patch_size * qwenvl->params.vision.spatial_merge_size;
-                int height           = image.height;
-                int width            = image.width;
-                int h_bar            = static_cast<int>(std::round(height / factor)) * factor;
-                int w_bar            = static_cast<int>(std::round(width / factor)) * factor;
-
-                if (static_cast<double>(h_bar) * w_bar > max_pixels) {
-                    double beta = std::sqrt((height * width) / static_cast<double>(max_pixels));
-                    h_bar       = std::max(static_cast<int>(factor),
-                                           static_cast<int>(std::floor(height / beta / factor)) * static_cast<int>(factor));
-                    w_bar       = std::max(static_cast<int>(factor),
-                                           static_cast<int>(std::floor(width / beta / factor)) * static_cast<int>(factor));
-                } else if (static_cast<double>(h_bar) * w_bar < min_pixels) {
-                    double beta = std::sqrt(static_cast<double>(min_pixels) / (height * width));
-                    h_bar       = static_cast<int>(std::ceil(height * beta / factor)) * static_cast<int>(factor);
-                    w_bar       = static_cast<int>(std::ceil(width * beta / factor)) * static_cast<int>(factor);
-                }
-
-                LOG_DEBUG("resize conditioner ref image %d from %dx%d to %dx%d", i, image.height, image.width, h_bar, w_bar);
-
-                sd_image_f32_t resized_image = clip_preprocess(image, w_bar, h_bar);
-                free(image.data);
-                image.data = nullptr;
-
-                ggml_tensor* image_tensor = ggml_new_tensor_4d(work_ctx, GGML_TYPE_F32, resized_image.width, resized_image.height, 3, 1);
-                sd_image_f32_to_tensor(resized_image, image_tensor, false);
-                free(resized_image.data);
-                resized_image.data = nullptr;
-
-                ggml_tensor* image_embed = nullptr;
-                qwenvl->encode_image(n_threads, image_tensor, &image_embed, work_ctx);
-                image_embeds.emplace_back(image_embed_idx, image_embed);
-                image_embed_idx += 1 + image_embed->ne[1] + 6;
-
-                img_prompt += "Picture " + std::to_string(i + 1) + ": <|vision_start|>";  // [24669, 220, index, 25, 220, 151652]
-                int64_t num_image_tokens = image_embed->ne[1];
-                img_prompt.reserve(num_image_tokens * placeholder.size());
-                for (int j = 0; j < num_image_tokens; j++) {
-                    img_prompt += placeholder;
-                }
-                img_prompt += "<|vision_end|>";
-            }
-
-            prompt = "<|im_start|>system\nDescribe the key features of the input image (color, shape, size, texture, objects, background), then explain how the user's text instruction should alter or modify the image. Generate a new image that meets the user's requirements while maintaining consistency with the original input where appropriate.<|im_end|>\n<|im_start|>user\n";
-
-            system_prompt_length = prompt.size();
-
-            prompt += img_prompt;
-            prompt += conditioner_params.text;
-            prompt += "<|im_end|>\n<|im_start|>assistant\n";
-        } else {
-            prompt = "<|im_start|>system\nDescribe the image by detailing the color, shape, size, texture, quantity, text, spatial relationships of the objects and background:<|im_end|>\n<|im_start|>user\n" + conditioner_params.text + "<|im_end|>\n<|im_start|>assistant\n";
-        }
-
-        auto tokens_and_weights = tokenize(prompt, 0, system_prompt_length, false);
-        auto& tokens            = std::get<0>(tokens_and_weights);
-        auto& weights           = std::get<1>(tokens_and_weights);
-
-        int64_t t0                        = ggml_time_ms();
-        struct ggml_tensor* hidden_states = NULL;  // [N, n_token, 3584]
-
-        auto input_ids = vector_to_ggml_tensor_i32(work_ctx, tokens);
-
-        qwenvl->compute(n_threads,
-                        input_ids,
-                        image_embeds,
-                        &hidden_states,
-                        work_ctx);
-        {
-            auto tensor         = hidden_states;
-            float original_mean = ggml_tensor_mean(tensor);
-            for (int i2 = 0; i2 < tensor->ne[2]; i2++) {
-                for (int i1 = 0; i1 < tensor->ne[1]; i1++) {
-                    for (int i0 = 0; i0 < tensor->ne[0]; i0++) {
-                        float value = ggml_tensor_get_f32(tensor, i0, i1, i2);
-                        value *= weights[i1];
-                        ggml_tensor_set_f32(tensor, value, i0, i1, i2);
-                    }
-                }
-            }
-            float new_mean = ggml_tensor_mean(tensor);
-            ggml_tensor_scale(tensor, (original_mean / new_mean));
-        }
-
-        GGML_ASSERT(hidden_states->ne[1] > prompt_template_encode_start_idx);
-
-        ggml_tensor* new_hidden_states = ggml_new_tensor_3d(work_ctx,
-                                                            GGML_TYPE_F32,
-                                                            hidden_states->ne[0],
-                                                            hidden_states->ne[1] - prompt_template_encode_start_idx,
-                                                            hidden_states->ne[2]);
-
-        ggml_tensor_iter(new_hidden_states, [&](ggml_tensor* new_hidden_states, int64_t i0, int64_t i1, int64_t i2, int64_t i3) {
-            float value = ggml_tensor_get_f32(hidden_states, i0, i1 + prompt_template_encode_start_idx, i2, i3);
-            ggml_tensor_set_f32(new_hidden_states, value, i0, i1, i2, i3);
-        });
-
-        int64_t t1 = ggml_time_ms();
-        LOG_DEBUG("computing condition graph completed, taking %" PRId64 " ms", t1 - t0);
-        return SDCondition(new_hidden_states, nullptr, nullptr);
+    std::string remove_trigger_from_prompt(ggml_context* work_ctx,
+                                           const std::string& prompt) {
+        GGML_ASSERT(0 && "Not implemented yet!");
     }
 };
 

control.hpp

@@ -445,7 +445,7 @@ struct ControlNet : public GGMLRunner {
         guided_hint_cached = true;
     }
 
-    bool load_from_file(const std::string& file_path, int n_threads) {
+    bool load_from_file(const std::string& file_path) {
         LOG_INFO("loading control net from '%s'", file_path.c_str());
         alloc_params_buffer();
         std::map<std::string, ggml_tensor*> tensors;
@@ -458,7 +458,7 @@ struct ControlNet : public GGMLRunner {
             return false;
         }
 
-        bool success = model_loader.load_tensors(tensors, ignore_tensors, n_threads);
+        bool success = model_loader.load_tensors(tensors, ignore_tensors);
 
         if (!success) {
             LOG_ERROR("load control net tensors from model loader failed");

diffusion_model.hpp

@@ -3,7 +3,6 @@
 
 #include "flux.hpp"
 #include "mmdit.hpp"
-#include "qwen_image.hpp"
 #include "unet.hpp"
 #include "wan.hpp"
 
@@ -264,60 +263,4 @@ struct WanModel : public DiffusionModel {
     }
 };
 
-struct QwenImageModel : public DiffusionModel {
-    std::string prefix;
-    Qwen::QwenImageRunner qwen_image;
-
-    QwenImageModel(ggml_backend_t backend,
-                   bool offload_params_to_cpu,
-                   const String2GGMLType& tensor_types = {},
-                   const std::string prefix            = "model.diffusion_model",
-                   SDVersion version                   = VERSION_QWEN_IMAGE,
-                   bool flash_attn                     = false)
-        : prefix(prefix), qwen_image(backend, offload_params_to_cpu, tensor_types, prefix, version, flash_attn) {
-    }
-
-    std::string get_desc() {
-        return qwen_image.get_desc();
-    }
-
-    void alloc_params_buffer() {
-        qwen_image.alloc_params_buffer();
-    }
-
-    void free_params_buffer() {
-        qwen_image.free_params_buffer();
-    }
-
-    void free_compute_buffer() {
-        qwen_image.free_compute_buffer();
-    }
-
-    void get_param_tensors(std::map<std::string, struct ggml_tensor*>& tensors) {
-        qwen_image.get_param_tensors(tensors, prefix);
-    }
-
-    size_t get_params_buffer_size() {
-        return qwen_image.get_params_buffer_size();
-    }
-
-    int64_t get_adm_in_channels() {
-        return 768;
-    }
-
-    void compute(int n_threads,
-                 DiffusionParams diffusion_params,
-                 struct ggml_tensor** output     = NULL,
-                 struct ggml_context* output_ctx = NULL) {
-        return qwen_image.compute(n_threads,
-                                  diffusion_params.x,
-                                  diffusion_params.timesteps,
-                                  diffusion_params.context,
-                                  diffusion_params.ref_latents,
-                                  true,  // increase_ref_index
-                                  output,
-                                  output_ctx);
-    }
-};
-
 #endif

docs/lora.md

@@ -20,30 +20,20 @@ Here's a simple example:
 
 NOTE: The other backends may have different support.
 
-| Quant / Type | CUDA | Vulkan |
-|--------------|------|--------|
-| F32          | ✔️   | ✔️   |
-| F16          | ✔️   | ✔️   |
-| BF16         | ✔️   | ✔️   |
-| I32          | ✔️   | ❌   |
-| Q4_0         | ✔️   | ✔️   |
-| Q4_1         | ✔️   | ✔️   |
-| Q5_0         | ✔️   | ✔️   |
-| Q5_1         | ✔️   | ✔️   |
-| Q8_0         | ✔️   | ✔️   |
-| Q2_K         | ❌   | ❌   |
-| Q3_K         | ❌   | ❌   |
-| Q4_K         | ❌   | ❌   |
-| Q5_K         | ❌   | ❌   |
-| Q6_K         | ❌   | ❌   |
-| Q8_K         | ❌   | ❌   |
-| IQ1_S        | ❌   | ✔️   |
-| IQ1_M        | ❌   | ✔️   |
-| IQ2_XXS      | ❌   | ✔️   |
-| IQ2_XS       | ❌   | ✔️   |
-| IQ2_S        | ❌   | ✔️   |
-| IQ3_XXS      | ❌   | ✔️   |
-| IQ3_S        | ❌   | ✔️   |
-| IQ4_XS       | ❌   | ✔️   |
-| IQ4_NL       | ❌   | ✔️   |
-| MXFP4        | ❌   | ✔️   |
+| Quant / Type | CUDA |
+|--------------|------|
+| F32          | ✔️   |
+| F16          | ✔️   |
+| BF16         | ✔️   |
+| I32          | ✔️   |
+| Q4_0         | ✔️   |
+| Q4_1         | ✔️   |
+| Q5_0         | ✔️   |
+| Q5_1         | ✔️   |
+| Q8_0         | ✔️   |
+| Q2_K         | ❌   |
+| Q3_K         | ❌   |
+| Q4_K         | ❌   |
+| Q5_K         | ❌   |
+| Q6_K         | ❌   |
+| Q8_K         | ❌   |

docs/qwen_image.md

@@ -1,23 +0,0 @@
-# How to Use
-
-## Download weights
-
-- Download Qwen Image
-    - safetensors: https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/tree/main/split_files/diffusion_models
-    - gguf: https://huggingface.co/QuantStack/Qwen-Image-GGUF/tree/main
-- Download vae
-    - safetensors: https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/tree/main/split_files/vae
-- Download qwen_2.5_vl 7b
-    - safetensors: https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/tree/main/split_files/text_encoders
-    - gguf: https://huggingface.co/mradermacher/Qwen2.5-VL-7B-Instruct-GGUF/tree/main
-
-## Examples
-
-```
-.\bin\Release\sd.exe --diffusion-model  ..\..\ComfyUI\models\diffusion_models\qwen-image-Q8_0.gguf --vae ..\..\ComfyUI\models\vae\qwen_image_vae.safetensors  --qwen2vl ..\..\ComfyUI\models\text_encoders\Qwen2.5-VL-7B-Instruct-Q8_0.gguf  -p '一个穿着"QWEN"标志的T恤的中国美女正拿着黑色的马克笔面相镜头微笑。她身后的玻璃板上手写体写着 “一、Qwen-Image的技术路线： 探索视觉生成基础模型的极限，开创理解与生成一体化的未来。二、Qwen-Image的模型特色：1、复杂文字渲染。支持中英渲染、自动布局； 2、精准图像编辑。支持文字编辑、物体增减、风格变换。三、Qwen-Image的未来愿景：赋能专业内容创作、助力生成式AI发展。”' --cfg-scale 2.5 --sampling-method euler -v --offload-to-cpu -H 1024 -W 1024 --diffusion-fa --flow-shift 3
-```
-
-<img alt="qwen example" src="../assets/qwen/example.png" />
-
-
-

docs/qwen_image_edit.md

@@ -1,35 +0,0 @@
-# How to Use
-
-## Download weights
-
-- Download Qwen Image
-    - Qwen Image Edit
-        - safetensors: https://huggingface.co/Comfy-Org/Qwen-Image-Edit_ComfyUI/tree/main/split_files/diffusion_models
-        - gguf: https://huggingface.co/QuantStack/Qwen-Image-Edit-GGUF/tree/main
-    - Qwen Image Edit 2509
-        - safetensors: https://huggingface.co/Comfy-Org/Qwen-Image-Edit_ComfyUI/tree/main/split_files/diffusion_models
-        - gguf: https://huggingface.co/QuantStack/Qwen-Image-Edit-2509-GGUF/tree/main
-- Download vae
-    - safetensors: https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/tree/main/split_files/vae
-- Download qwen_2.5_vl 7b
-    - safetensors: https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/tree/main/split_files/text_encoders
-    - gguf: https://huggingface.co/mradermacher/Qwen2.5-VL-7B-Instruct-GGUF/tree/main
-
-## Examples
-
-### Qwen Image Edit
-
-```
-.\bin\Release\sd.exe --diffusion-model  ..\..\ComfyUI\models\diffusion_models\Qwen_Image_Edit-Q8_0.gguf --vae ..\..\ComfyUI\models\vae\qwen_image_vae.safetensors  --qwen2vl ..\..\ComfyUI\models\text_encoders\qwen_2.5_vl_7b.safetensors --cfg-scale 2.5 --sampling-method euler -v --offload-to-cpu --diffusion-fa --flow-shift 3 -r ..\assets\flux\flux1-dev-q8_0.png -p "change 'flux.cpp' to 'edit.cpp'" --seed 1118877715456453
-```
-
-<img alt="qwen_image_edit" src="../assets/qwen/qwen_image_edit.png" />
-
-
-### Qwen Image Edit 2509
-
-```
-.\bin\Release\sd.exe --diffusion-model  ..\..\ComfyUI\models\diffusion_models\Qwen-Image-Edit-2509-Q4_K_S.gguf --vae ..\..\ComfyUI\models\vae\qwen_image_vae.safetensors  --qwen2vl ..\..\ComfyUI\models\text_encoders\Qwen2.5-VL-7B-Instruct-Q8_0.gguf --qwen2vl_vision ..\..\ComfyUI\models\text_encoders\Qwen2.5-VL-7B-Instruct.mmproj-Q8_0.gguf --cfg-scale 2.5 --sampling-method euler -v --offload-to-cpu --diffusion-fa --flow-shift 3 -r ..\assets\flux\flux1-dev-q8_0.png -p "change 'flux.cpp' to 'Qwen Image Edit 2509'"
-```
-
-<img alt="qwen_image_edit_2509" src="../assets/qwen/qwen_image_edit_2509.png" />

esrgan.hpp

@@ -83,44 +83,39 @@ public:
 
 class RRDBNet : public GGMLBlock {
 protected:
-    int scale       = 4;
-    int num_block   = 23;
+    int scale       = 4;  // default RealESRGAN_x4plus_anime_6B
+    int num_block   = 6;  // default RealESRGAN_x4plus_anime_6B
     int num_in_ch   = 3;
     int num_out_ch  = 3;
-    int num_feat    = 64;
-    int num_grow_ch = 32;
+    int num_feat    = 64;  // default RealESRGAN_x4plus_anime_6B
+    int num_grow_ch = 32;  // default RealESRGAN_x4plus_anime_6B
 
 public:
-    RRDBNet(int scale, int num_block, int num_in_ch, int num_out_ch, int num_feat, int num_grow_ch)
-        : scale(scale), num_block(num_block), num_in_ch(num_in_ch), num_out_ch(num_out_ch), num_feat(num_feat), num_grow_ch(num_grow_ch) {
+    RRDBNet() {
         blocks["conv_first"] = std::shared_ptr<GGMLBlock>(new Conv2d(num_in_ch, num_feat, {3, 3}, {1, 1}, {1, 1}));
         for (int i = 0; i < num_block; i++) {
             std::string name = "body." + std::to_string(i);
             blocks[name]     = std::shared_ptr<GGMLBlock>(new RRDB(num_feat, num_grow_ch));
         }
         blocks["conv_body"] = std::shared_ptr<GGMLBlock>(new Conv2d(num_feat, num_feat, {3, 3}, {1, 1}, {1, 1}));
-        if (scale >= 2) {
-            blocks["conv_up1"] = std::shared_ptr<GGMLBlock>(new Conv2d(num_feat, num_feat, {3, 3}, {1, 1}, {1, 1}));
-        }
-        if (scale == 4) {
-            blocks["conv_up2"] = std::shared_ptr<GGMLBlock>(new Conv2d(num_feat, num_feat, {3, 3}, {1, 1}, {1, 1}));
-        }
+        // upsample
+        blocks["conv_up1"]  = std::shared_ptr<GGMLBlock>(new Conv2d(num_feat, num_feat, {3, 3}, {1, 1}, {1, 1}));
+        blocks["conv_up2"]  = std::shared_ptr<GGMLBlock>(new Conv2d(num_feat, num_feat, {3, 3}, {1, 1}, {1, 1}));
         blocks["conv_hr"]   = std::shared_ptr<GGMLBlock>(new Conv2d(num_feat, num_feat, {3, 3}, {1, 1}, {1, 1}));
         blocks["conv_last"] = std::shared_ptr<GGMLBlock>(new Conv2d(num_feat, num_out_ch, {3, 3}, {1, 1}, {1, 1}));
     }
 
-    int get_scale() { return scale; }
-    int get_num_block() { return num_block; }
-
     struct ggml_tensor* lrelu(struct ggml_context* ctx, struct ggml_tensor* x) {
         return ggml_leaky_relu(ctx, x, 0.2f, true);
     }
 
     struct ggml_tensor* forward(struct ggml_context* ctx, struct ggml_tensor* x) {
         // x: [n, num_in_ch, h, w]
-        // return: [n, num_out_ch, h*scale, w*scale]
+        // return: [n, num_out_ch, h*4, w*4]
         auto conv_first = std::dynamic_pointer_cast<Conv2d>(blocks["conv_first"]);
         auto conv_body  = std::dynamic_pointer_cast<Conv2d>(blocks["conv_body"]);
+        auto conv_up1   = std::dynamic_pointer_cast<Conv2d>(blocks["conv_up1"]);
+        auto conv_up2   = std::dynamic_pointer_cast<Conv2d>(blocks["conv_up2"]);
         auto conv_hr    = std::dynamic_pointer_cast<Conv2d>(blocks["conv_hr"]);
         auto conv_last  = std::dynamic_pointer_cast<Conv2d>(blocks["conv_last"]);
 
@@ -135,22 +130,15 @@ public:
         body_feat = conv_body->forward(ctx, body_feat);
         feat      = ggml_add(ctx, feat, body_feat);
         // upsample
-        if (scale >= 2) {
-            auto conv_up1 = std::dynamic_pointer_cast<Conv2d>(blocks["conv_up1"]);
-            feat          = lrelu(ctx, conv_up1->forward(ctx, ggml_upscale(ctx, feat, 2, GGML_SCALE_MODE_NEAREST)));
-            if (scale == 4) {
-                auto conv_up2 = std::dynamic_pointer_cast<Conv2d>(blocks["conv_up2"]);
-                feat          = lrelu(ctx, conv_up2->forward(ctx, ggml_upscale(ctx, feat, 2, GGML_SCALE_MODE_NEAREST)));
-            }
-        }
-        // for all scales
+        feat     = lrelu(ctx, conv_up1->forward(ctx, ggml_upscale(ctx, feat, 2, GGML_SCALE_MODE_NEAREST)));
+        feat     = lrelu(ctx, conv_up2->forward(ctx, ggml_upscale(ctx, feat, 2, GGML_SCALE_MODE_NEAREST)));
         auto out = conv_last->forward(ctx, lrelu(ctx, conv_hr->forward(ctx, feat)));
         return out;
     }
 };
 
 struct ESRGAN : public GGMLRunner {
-    std::unique_ptr<RRDBNet> rrdb_net;
+    RRDBNet rrdb_net;
     int scale     = 4;
     int tile_size = 128;  // avoid cuda OOM for 4gb VRAM
 
@@ -158,14 +146,12 @@ struct ESRGAN : public GGMLRunner {
            bool offload_params_to_cpu,
            const String2GGMLType& tensor_types = {})
         : GGMLRunner(backend, offload_params_to_cpu) {
-        // rrdb_net will be created in load_from_file
+        rrdb_net.init(params_ctx, tensor_types, "");
     }
 
     void enable_conv2d_direct() {
-        if (!rrdb_net)
-            return;
         std::vector<GGMLBlock*> blocks;
-        rrdb_net->get_all_blocks(blocks);
+        rrdb_net.get_all_blocks(blocks);
         for (auto block : blocks) {
             if (block->get_desc() == "Conv2d") {
                 auto conv_block = (Conv2d*)block;
@@ -178,188 +164,34 @@ struct ESRGAN : public GGMLRunner {
         return "esrgan";
     }
 
-    bool load_from_file(const std::string& file_path, int n_threads) {
+    bool load_from_file(const std::string& file_path) {
         LOG_INFO("loading esrgan from '%s'", file_path.c_str());
 
+        alloc_params_buffer();
+        std::map<std::string, ggml_tensor*> esrgan_tensors;
+        rrdb_net.get_param_tensors(esrgan_tensors);
+
         ModelLoader model_loader;
         if (!model_loader.init_from_file(file_path)) {
             LOG_ERROR("init esrgan model loader from file failed: '%s'", file_path.c_str());
             return false;
         }
 
-        // Get tensor names
-        auto tensor_names = model_loader.get_tensor_names();
-
-        // Detect if it's ESRGAN format
-        bool is_ESRGAN = std::find(tensor_names.begin(), tensor_names.end(), "model.0.weight") != tensor_names.end();
-
-        // Detect parameters from tensor names
-        int detected_num_block = 0;
-        if (is_ESRGAN) {
-            for (const auto& name : tensor_names) {
-                if (name.find("model.1.sub.") == 0) {
-                    size_t first_dot = name.find('.', 12);
-                    if (first_dot != std::string::npos) {
-                        size_t second_dot = name.find('.', first_dot + 1);
-                        if (second_dot != std::string::npos && name.substr(first_dot + 1, 3) == "RDB") {
-                            try {
-                                int idx            = std::stoi(name.substr(12, first_dot - 12));
-                                detected_num_block = std::max(detected_num_block, idx + 1);
-                            } catch (...) {
-                            }
-                        }
-                    }
-                }
-            }
-        } else {
-            // Original format
-            for (const auto& name : tensor_names) {
-                if (name.find("body.") == 0) {
-                    size_t pos = name.find('.', 5);
-                    if (pos != std::string::npos) {
-                        try {
-                            int idx            = std::stoi(name.substr(5, pos - 5));
-                            detected_num_block = std::max(detected_num_block, idx + 1);
-                        } catch (...) {
-                        }
-                    }
-                }
-            }
-        }
-
-        int detected_scale = 4;  // default
-        if (is_ESRGAN) {
-            // For ESRGAN format, detect scale by highest model number
-            int max_model_num = 0;
-            for (const auto& name : tensor_names) {
-                if (name.find("model.") == 0) {
-                    size_t dot_pos = name.find('.', 6);
-                    if (dot_pos != std::string::npos) {
-                        try {
-                            int num       = std::stoi(name.substr(6, dot_pos - 6));
-                            max_model_num = std::max(max_model_num, num);
-                        } catch (...) {
-                        }
-                    }
-                }
-            }
-            if (max_model_num <= 4) {
-                detected_scale = 1;
-            } else if (max_model_num <= 7) {
-                detected_scale = 2;
-            } else {
-                detected_scale = 4;
-            }
-        } else {
-            // Original format
-            bool has_conv_up2 = std::any_of(tensor_names.begin(), tensor_names.end(), [](const std::string& name) {
-                return name == "conv_up2.weight";
-            });
-            bool has_conv_up1 = std::any_of(tensor_names.begin(), tensor_names.end(), [](const std::string& name) {
-                return name == "conv_up1.weight";
-            });
-            if (has_conv_up2) {
-                detected_scale = 4;
-            } else if (has_conv_up1) {
-                detected_scale = 2;
-            } else {
-                detected_scale = 1;
-            }
-        }
-
-        int detected_num_in_ch   = 3;
-        int detected_num_out_ch  = 3;
-        int detected_num_feat    = 64;
-        int detected_num_grow_ch = 32;
-
-        // Create RRDBNet with detected parameters
-        rrdb_net = std::make_unique<RRDBNet>(detected_scale, detected_num_block, detected_num_in_ch, detected_num_out_ch, detected_num_feat, detected_num_grow_ch);
-        rrdb_net->init(params_ctx, {}, "");
-
-        alloc_params_buffer();
-        std::map<std::string, ggml_tensor*> esrgan_tensors;
-        rrdb_net->get_param_tensors(esrgan_tensors);
-
-        bool success;
-        if (is_ESRGAN) {
-            // Build name mapping for ESRGAN format
-            std::map<std::string, std::string> expected_to_model;
-            expected_to_model["conv_first.weight"] = "model.0.weight";
-            expected_to_model["conv_first.bias"]   = "model.0.bias";
-
-            for (int i = 0; i < detected_num_block; i++) {
-                for (int j = 1; j <= 3; j++) {
-                    for (int k = 1; k <= 5; k++) {
-                        std::string expected_weight        = "body." + std::to_string(i) + ".rdb" + std::to_string(j) + ".conv" + std::to_string(k) + ".weight";
-                        std::string model_weight           = "model.1.sub." + std::to_string(i) + ".RDB" + std::to_string(j) + ".conv" + std::to_string(k) + ".0.weight";
-                        expected_to_model[expected_weight] = model_weight;
-
-                        std::string expected_bias        = "body." + std::to_string(i) + ".rdb" + std::to_string(j) + ".conv" + std::to_string(k) + ".bias";
-                        std::string model_bias           = "model.1.sub." + std::to_string(i) + ".RDB" + std::to_string(j) + ".conv" + std::to_string(k) + ".0.bias";
-                        expected_to_model[expected_bias] = model_bias;
-                    }
-                }
-            }
-
-            if (detected_scale == 1) {
-                expected_to_model["conv_body.weight"] = "model.1.sub." + std::to_string(detected_num_block) + ".weight";
-                expected_to_model["conv_body.bias"]   = "model.1.sub." + std::to_string(detected_num_block) + ".bias";
-                expected_to_model["conv_hr.weight"]   = "model.2.weight";
-                expected_to_model["conv_hr.bias"]     = "model.2.bias";
-                expected_to_model["conv_last.weight"] = "model.4.weight";
-                expected_to_model["conv_last.bias"]   = "model.4.bias";
-            } else {
-                expected_to_model["conv_body.weight"] = "model.1.sub." + std::to_string(detected_num_block) + ".weight";
-                expected_to_model["conv_body.bias"]   = "model.1.sub." + std::to_string(detected_num_block) + ".bias";
-                if (detected_scale >= 2) {
-                    expected_to_model["conv_up1.weight"] = "model.3.weight";
-                    expected_to_model["conv_up1.bias"]   = "model.3.bias";
-                }
-                if (detected_scale == 4) {
-                    expected_to_model["conv_up2.weight"]  = "model.6.weight";
-                    expected_to_model["conv_up2.bias"]    = "model.6.bias";
-                    expected_to_model["conv_hr.weight"]   = "model.8.weight";
-                    expected_to_model["conv_hr.bias"]     = "model.8.bias";
-                    expected_to_model["conv_last.weight"] = "model.10.weight";
-                    expected_to_model["conv_last.bias"]   = "model.10.bias";
-                } else if (detected_scale == 2) {
-                    expected_to_model["conv_hr.weight"]   = "model.5.weight";
-                    expected_to_model["conv_hr.bias"]     = "model.5.bias";
-                    expected_to_model["conv_last.weight"] = "model.7.weight";
-                    expected_to_model["conv_last.bias"]   = "model.7.bias";
-                }
-            }
-
-            std::map<std::string, ggml_tensor*> model_tensors;
-            for (auto& p : esrgan_tensors) {
-                auto it = expected_to_model.find(p.first);
-                if (it != expected_to_model.end()) {
-                    model_tensors[it->second] = p.second;
-                }
-            }
-
-            success = model_loader.load_tensors(model_tensors, {}, n_threads);
-        } else {
-            success = model_loader.load_tensors(esrgan_tensors, {}, n_threads);
-        }
+        bool success = model_loader.load_tensors(esrgan_tensors);
 
         if (!success) {
             LOG_ERROR("load esrgan tensors from model loader failed");
             return false;
         }
 
-        scale = rrdb_net->get_scale();
-        LOG_INFO("esrgan model loaded with scale=%d, num_block=%d", scale, detected_num_block);
+        LOG_INFO("esrgan model loaded");
         return success;
     }
 
     struct ggml_cgraph* build_graph(struct ggml_tensor* x) {
-        if (!rrdb_net)
-            return nullptr;
-        constexpr int kGraphNodes = 1 << 16;  // 65k
-        struct ggml_cgraph* gf    = ggml_new_graph_custom(compute_ctx, kGraphNodes, /*grads*/ false);
-        x                         = to_backend(x);
-        struct ggml_tensor* out   = rrdb_net->forward(compute_ctx, x);
+        struct ggml_cgraph* gf  = ggml_new_graph(compute_ctx);
+        x                       = to_backend(x);
+        struct ggml_tensor* out = rrdb_net.forward(compute_ctx, x);
         ggml_build_forward_expand(gf, out);
         return gf;
     }

examples/cli/main.cpp

@@ -41,15 +41,13 @@ const char* modes_str[] = {
     "img_gen",
     "vid_gen",
     "convert",
-    "upscale",
 };
-#define SD_ALL_MODES_STR "img_gen, vid_gen, convert, upscale"
+#define SD_ALL_MODES_STR "img_gen, vid_gen, convert"
 
 enum SDMode {
     IMG_GEN,
     VID_GEN,
     CONVERT,
-    UPSCALE,
     MODE_COUNT
 };
 
@@ -61,8 +59,6 @@ struct SDParams {
     std::string clip_g_path;
     std::string clip_vision_path;
     std::string t5xxl_path;
-    std::string qwen2vl_path;
-    std::string qwen2vl_vision_path;
     std::string diffusion_model_path;
     std::string high_noise_diffusion_model_path;
     std::string vae_path;
@@ -84,7 +80,6 @@ struct SDParams {
 
     std::string prompt;
     std::string negative_prompt;
-
     int clip_skip   = -1;  // <= 0 represents unspecified
     int width       = 512;
     int height      = 512;
@@ -108,6 +103,7 @@ struct SDParams {
     bool verbose               = false;
     bool offload_params_to_cpu = false;
     bool control_net_cpu       = false;
+    bool normalize_input       = false;
     bool clip_on_cpu           = false;
     bool vae_on_cpu            = false;
     bool diffusion_flash_attn  = false;
@@ -128,8 +124,6 @@ struct SDParams {
     int chroma_t5_mask_pad   = 1;
     float flow_shift         = INFINITY;
 
-    prediction_t prediction = DEFAULT_PRED;
-
     sd_tiling_params_t vae_tiling_params = {false, 0, 0, 0.5f, 0.0f, 0.0f};
 
     SDParams() {
@@ -151,8 +145,6 @@ void print_params(SDParams params) {
     printf("    clip_g_path:                       %s\n", params.clip_g_path.c_str());
     printf("    clip_vision_path:                  %s\n", params.clip_vision_path.c_str());
     printf("    t5xxl_path:                        %s\n", params.t5xxl_path.c_str());
-    printf("    qwen2vl_path:                      %s\n", params.qwen2vl_path.c_str());
-    printf("    qwen2vl_vision_path:               %s\n", params.qwen2vl_vision_path.c_str());
     printf("    diffusion_model_path:              %s\n", params.diffusion_model_path.c_str());
     printf("    high_noise_diffusion_model_path:   %s\n", params.high_noise_diffusion_model_path.c_str());
     printf("    vae_path:                          %s\n", params.vae_path.c_str());
@@ -164,6 +156,7 @@ void print_params(SDParams params) {
     printf("    pm_id_images_dir:                  %s\n", params.pm_id_images_dir.c_str());
     printf("    pm_id_embed_path:                  %s\n", params.pm_id_embed_path.c_str());
     printf("    pm_style_strength:                 %.2f\n", params.pm_style_strength);
+    printf("    normalize input image:             %s\n", params.normalize_input ? "true" : "false");
     printf("    output_path:                       %s\n", params.output_path.c_str());
     printf("    init_image_path:                   %s\n", params.init_image_path.c_str());
     printf("    end_image_path:                    %s\n", params.end_image_path.c_str());
@@ -191,7 +184,6 @@ void print_params(SDParams params) {
     printf("    sample_params:                     %s\n", SAFE_STR(sample_params_str));
     printf("    high_noise_sample_params:          %s\n", SAFE_STR(high_noise_sample_params_str));
     printf("    moe_boundary:                      %.3f\n", params.moe_boundary);
-    printf("    prediction:                        %s\n", sd_prediction_name(params.prediction));
     printf("    flow_shift:                        %.2f\n", params.flow_shift);
     printf("    strength(img2img):                 %.2f\n", params.strength);
     printf("    rng:                               %s\n", sd_rng_type_name(params.rng_type));
@@ -214,7 +206,7 @@ void print_usage(int argc, const char* argv[]) {
     printf("\n");
     printf("arguments:\n");
     printf("  -h, --help                         show this help message and exit\n");
-    printf("  -M, --mode [MODE]                  run mode, one of: [img_gen, vid_gen, upscale, convert], default: img_gen\n");
+    printf("  -M, --mode [MODE]                  run mode, one of: [img_gen, vid_gen, convert], default: img_gen\n");
     printf("  -t, --threads N                    number of threads to use during computation (default: -1)\n");
     printf("                                     If threads <= 0, then threads will be set to the number of CPU physical cores\n");
     printf("  --offload-to-cpu                   place the weights in RAM to save VRAM, and automatically load them into VRAM when needed\n");
@@ -225,13 +217,11 @@ void print_usage(int argc, const char* argv[]) {
     printf("  --clip_g                           path to the clip-g text encoder\n");
     printf("  --clip_vision                      path to the clip-vision encoder\n");
     printf("  --t5xxl                            path to the t5xxl text encoder\n");
-    printf("  --qwen2vl                          path to the qwen2vl text encoder\n");
-    printf("  --qwen2vl_vision                   path to the qwen2vl vit\n");
     printf("  --vae [VAE]                        path to vae\n");
     printf("  --taesd [TAESD_PATH]               path to taesd. Using Tiny AutoEncoder for fast decoding (low quality)\n");
     printf("  --control-net [CONTROL_PATH]       path to control net model\n");
     printf("  --embd-dir [EMBEDDING_PATH]        path to embeddings\n");
-    printf("  --upscale-model [ESRGAN_PATH]      path to esrgan model. For img_gen mode, upscale images after generate, just RealESRGAN_x4plus_anime_6B supported by now\n");
+    printf("  --upscale-model [ESRGAN_PATH]      path to esrgan model. Upscale images after generate, just RealESRGAN_x4plus_anime_6B supported by now\n");
     printf("  --upscale-repeats                  Run the ESRGAN upscaler this many times (default 1)\n");
     printf("  --type [TYPE]                      weight type (examples: f32, f16, q4_0, q4_1, q5_0, q5_1, q8_0, q2_K, q3_K, q4_K)\n");
     printf("                                     If not specified, the default is the type of the weight file\n");
@@ -285,7 +275,6 @@ void print_usage(int argc, const char* argv[]) {
     printf("  --rng {std_default, cuda}          RNG (default: cuda)\n");
     printf("  -s SEED, --seed SEED               RNG seed (default: 42, use random seed for < 0)\n");
     printf("  -b, --batch-count COUNT            number of images to generate\n");
-    printf("  --prediction {eps, v, edm_v, sd3_flow, flux_flow}        Prediction type override.\n");
     printf("  --clip-skip N                      ignore last layers of CLIP network; 1 ignores none, 2 ignores one layer (default: -1)\n");
     printf("                                     <= 0 represents unspecified, will be 1 for SD1.x, 2 for SD2.x\n");
     printf("  --vae-tiling                       process vae in tiles to reduce memory usage\n");
@@ -317,6 +306,7 @@ void print_usage(int argc, const char* argv[]) {
     printf("  --pm-id-images-dir [DIR]           path to PHOTOMAKER input id images dir\n");
     printf("  --pm-id-embed-path [PATH]          path to PHOTOMAKER v2 id embed\n");
     printf("  --pm-style-strength                strength for keeping PHOTOMAKER input identity (default: 20)\n");
+    printf("  --normalize-input                  normalize PHOTOMAKER input id images\n");
     printf("  -v, --verbose                      print extra info\n");
 }
 
@@ -497,8 +487,6 @@ void parse_args(int argc, const char** argv, SDParams& params) {
         {"", "--clip_g", "", &params.clip_g_path},
         {"", "--clip_vision", "", &params.clip_vision_path},
         {"", "--t5xxl", "", &params.t5xxl_path},
-        {"", "--qwen2vl", "", &params.qwen2vl_path},
-        {"", "--qwen2vl_vision", "", &params.qwen2vl_vision_path},
         {"", "--diffusion-model", "", &params.diffusion_model_path},
         {"", "--high-noise-diffusion-model", "", &params.high_noise_diffusion_model_path},
         {"", "--vae", "", &params.vae_path},
@@ -564,6 +552,7 @@ void parse_args(int argc, const char** argv, SDParams& params) {
         {"", "--vae-tiling", "", true, &params.vae_tiling_params.enabled},
         {"", "--offload-to-cpu", "", true, &params.offload_params_to_cpu},
         {"", "--control-net-cpu", "", true, &params.control_net_cpu},
+        {"", "--normalize-input", "", true, &params.normalize_input},
         {"", "--clip-on-cpu", "", true, &params.clip_on_cpu},
         {"", "--vae-on-cpu", "", true, &params.vae_on_cpu},
         {"", "--diffusion-fa", "", true, &params.diffusion_flash_attn},
@@ -656,20 +645,6 @@ void parse_args(int argc, const char** argv, SDParams& params) {
         return 1;
     };
 
-    auto on_prediction_arg = [&](int argc, const char** argv, int index) {
-        if (++index >= argc) {
-            return -1;
-        }
-        const char* arg   = argv[index];
-        params.prediction = str_to_prediction(arg);
-        if (params.prediction == PREDICTION_COUNT) {
-            fprintf(stderr, "error: invalid prediction type %s\n",
-                    arg);
-            return -1;
-        }
-        return 1;
-    };
-
     auto on_sample_method_arg = [&](int argc, const char** argv, int index) {
         if (++index >= argc) {
             return -1;
@@ -826,7 +801,6 @@ void parse_args(int argc, const char** argv, SDParams& params) {
         {"", "--rng", "", on_rng_arg},
         {"-s", "--seed", "", on_seed_arg},
         {"", "--sampling-method", "", on_sample_method_arg},
-        {"", "--prediction", "", on_prediction_arg},
         {"", "--scheduler", "", on_schedule_arg},
         {"", "--skip-layers", "", on_skip_layers_arg},
         {"", "--high-noise-sampling-method", "", on_high_noise_sample_method_arg},
@@ -847,13 +821,13 @@ void parse_args(int argc, const char** argv, SDParams& params) {
         params.n_threads = get_num_physical_cores();
     }
 
-    if ((params.mode == IMG_GEN || params.mode == VID_GEN) && params.prompt.length() == 0) {
+    if (params.mode != CONVERT && params.mode != VID_GEN && params.prompt.length() == 0) {
         fprintf(stderr, "error: the following arguments are required: prompt\n");
         print_usage(argc, argv);
         exit(1);
     }
 
-    if (params.mode != UPSCALE && params.model_path.length() == 0 && params.diffusion_model_path.length() == 0) {
+    if (params.model_path.length() == 0 && params.diffusion_model_path.length() == 0) {
         fprintf(stderr, "error: the following arguments are required: model_path/diffusion_model\n");
         print_usage(argc, argv);
         exit(1);
@@ -913,17 +887,6 @@ void parse_args(int argc, const char** argv, SDParams& params) {
         exit(1);
     }
 
-    if (params.mode == UPSCALE) {
-        if (params.esrgan_path.length() == 0) {
-            fprintf(stderr, "error: upscale mode needs an upscaler model (--upscale-model)\n");
-            exit(1);
-        }
-        if (params.init_image_path.length() == 0) {
-            fprintf(stderr, "error: upscale mode needs an init image (--init-img)\n");
-            exit(1);
-        }
-    }
-
     if (params.seed < 0) {
         srand((int)time(NULL));
         params.seed = rand();
@@ -934,6 +897,14 @@ void parse_args(int argc, const char** argv, SDParams& params) {
             params.output_path = "output.gguf";
         }
     }
+
+    if (!isfinite(params.sample_params.guidance.img_cfg)) {
+        params.sample_params.guidance.img_cfg = params.sample_params.guidance.txt_cfg;
+    }
+
+    if (!isfinite(params.high_noise_sample_params.guidance.img_cfg)) {
+        params.high_noise_sample_params.guidance.img_cfg = params.high_noise_sample_params.guidance.txt_cfg;
+    }
 }
 
 static std::string sd_basename(const std::string& path) {
@@ -976,7 +947,7 @@ std::string get_image_params(SDParams params, int64_t seed) {
         parameter_string += " " + std::string(sd_schedule_name(params.sample_params.scheduler));
     }
     parameter_string += ", ";
-    for (const auto& te : {params.clip_l_path, params.clip_g_path, params.t5xxl_path, params.qwen2vl_path, params.qwen2vl_vision_path}) {
+    for (const auto& te : {params.clip_l_path, params.clip_g_path, params.t5xxl_path}) {
         if (!te.empty()) {
             parameter_string += "TE: " + sd_basename(te) + ", ";
         }
@@ -1136,19 +1107,10 @@ bool load_images_from_dir(const std::string dir,
         return false;
     }
 
-    std::vector<fs::directory_entry> entries;
     for (const auto& entry : fs::directory_iterator(dir)) {
-        if (entry.is_regular_file()) {
-            entries.push_back(entry);
-        }
-    }
+        if (!entry.is_regular_file())
+            continue;
 
-    std::sort(entries.begin(), entries.end(),
-              [](const fs::directory_entry& a, const fs::directory_entry& b) {
-                  return a.path().filename().string() < b.path().filename().string();
-              });
-
-    for (const auto& entry : entries) {
         std::string path = entry.path().string();
         std::string ext  = entry.path().extension().string();
         std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
@@ -1288,7 +1250,7 @@ int main(int argc, const char* argv[]) {
         }
     }
 
-    if (params.control_image_path.size() > 0) {
+    if (params.control_net_path.size() > 0 && params.control_image_path.size() > 0) {
         int width          = 0;
         int height         = 0;
         control_image.data = load_image(params.control_image_path.c_str(), width, height, params.width, params.height);
@@ -1359,8 +1321,6 @@ int main(int argc, const char* argv[]) {
         params.clip_g_path.c_str(),
         params.clip_vision_path.c_str(),
         params.t5xxl_path.c_str(),
-        params.qwen2vl_path.c_str(),
-        params.qwen2vl_vision_path.c_str(),
         params.diffusion_model_path.c_str(),
         params.high_noise_diffusion_model_path.c_str(),
         params.vae_path.c_str(),
@@ -1374,7 +1334,6 @@ int main(int argc, const char* argv[]) {
         params.n_threads,
         params.wtype,
         params.rng_type,
-        params.prediction,
         params.offload_params_to_cpu,
         params.clip_on_cpu,
         params.control_net_cpu,
@@ -1388,92 +1347,77 @@ int main(int argc, const char* argv[]) {
         params.flow_shift,
     };
 
-    sd_image_t* results = nullptr;
-    int num_results     = 0;
+    sd_ctx_t* sd_ctx = new_sd_ctx(&sd_ctx_params);
 
-    if (params.mode == UPSCALE) {
-        num_results = 1;
-        results     = (sd_image_t*)calloc(num_results, sizeof(sd_image_t));
-        if (results == NULL) {
-            printf("failed to allocate results array\n");
-            release_all_resources();
-            return 1;
-        }
+    if (sd_ctx == NULL) {
+        printf("new_sd_ctx_t failed\n");
+        release_all_resources();
+        return 1;
+    }
 
-        results[0]      = init_image;
-        init_image.data = NULL;
-    } else {
-        sd_ctx_t* sd_ctx = new_sd_ctx(&sd_ctx_params);
+    if (params.sample_params.sample_method == SAMPLE_METHOD_DEFAULT) {
+        params.sample_params.sample_method = sd_get_default_sample_method(sd_ctx);
+    }
 
-        if (sd_ctx == NULL) {
-            printf("new_sd_ctx_t failed\n");
-            release_all_resources();
-            return 1;
-        }
+    sd_image_t* results;
+    int num_results = 1;
+    if (params.mode == IMG_GEN) {
+        sd_img_gen_params_t img_gen_params = {
+            params.prompt.c_str(),
+            params.negative_prompt.c_str(),
+            params.clip_skip,
+            init_image,
+            ref_images.data(),
+            (int)ref_images.size(),
+            params.increase_ref_index,
+            mask_image,
+            params.width,
+            params.height,
+            params.sample_params,
+            params.strength,
+            params.seed,
+            params.batch_count,
+            control_image,
+            params.control_strength,
+            params.normalize_input,
+            {
+                pmid_images.data(),
+                (int)pmid_images.size(),
+                params.pm_id_embed_path.c_str(),
+                params.pm_style_strength,
+            },  // pm_params
+            params.vae_tiling_params,
+        };
 
-        if (params.sample_params.sample_method == SAMPLE_METHOD_DEFAULT) {
-            params.sample_params.sample_method = sd_get_default_sample_method(sd_ctx);
-        }
+        results     = generate_image(sd_ctx, &img_gen_params);
+        num_results = params.batch_count;
+    } else if (params.mode == VID_GEN) {
+        sd_vid_gen_params_t vid_gen_params = {
+            params.prompt.c_str(),
+            params.negative_prompt.c_str(),
+            params.clip_skip,
+            init_image,
+            end_image,
+            control_frames.data(),
+            (int)control_frames.size(),
+            params.width,
+            params.height,
+            params.sample_params,
+            params.high_noise_sample_params,
+            params.moe_boundary,
+            params.strength,
+            params.seed,
+            params.video_frames,
+            params.vace_strength,
+        };
 
-        if (params.mode == IMG_GEN) {
-            sd_img_gen_params_t img_gen_params = {
-                params.prompt.c_str(),
-                params.negative_prompt.c_str(),
-                params.clip_skip,
-                init_image,
-                ref_images.data(),
-                (int)ref_images.size(),
-                params.increase_ref_index,
-                mask_image,
-                params.width,
-                params.height,
-                params.sample_params,
-                params.strength,
-                params.seed,
-                params.batch_count,
-                control_image,
-                params.control_strength,
-                {
-                    pmid_images.data(),
-                    (int)pmid_images.size(),
-                    params.pm_id_embed_path.c_str(),
-                    params.pm_style_strength,
-                },  // pm_params
-                params.vae_tiling_params,
-            };
-
-            results     = generate_image(sd_ctx, &img_gen_params);
-            num_results = params.batch_count;
-        } else if (params.mode == VID_GEN) {
-            sd_vid_gen_params_t vid_gen_params = {
-                params.prompt.c_str(),
-                params.negative_prompt.c_str(),
-                params.clip_skip,
-                init_image,
-                end_image,
-                control_frames.data(),
-                (int)control_frames.size(),
-                params.width,
-                params.height,
-                params.sample_params,
-                params.high_noise_sample_params,
-                params.moe_boundary,
-                params.strength,
-                params.seed,
-                params.video_frames,
-                params.vace_strength,
-            };
-
-            results = generate_video(sd_ctx, &vid_gen_params, &num_results);
-        }
-
-        if (results == NULL) {
-            printf("generate failed\n");
-            free_sd_ctx(sd_ctx);
-            return 1;
-        }
+        results = generate_video(sd_ctx, &vid_gen_params, &num_results);
+    }
 
+    if (results == NULL) {
+        printf("generate failed\n");
         free_sd_ctx(sd_ctx);
+        return 1;
     }
 
     int upscale_factor = 4;  // unused for RealESRGAN_x4plus_anime_6B.pth
@@ -1486,7 +1430,7 @@ int main(int argc, const char* argv[]) {
         if (upscaler_ctx == NULL) {
             printf("new_upscaler_ctx failed\n");
         } else {
-            for (int i = 0; i < num_results; i++) {
+            for (int i = 0; i < params.batch_count; i++) {
                 if (results[i].data == NULL) {
                     continue;
                 }
@@ -1572,6 +1516,7 @@ int main(int argc, const char* argv[]) {
         results[i].data = NULL;
     }
     free(results);
+    free_sd_ctx(sd_ctx);
 
     release_all_resources();
 

flux.hpp

@@ -81,6 +81,56 @@ namespace Flux {
         }
     };
 
+    __STATIC_INLINE__ struct ggml_tensor* apply_rope(struct ggml_context* ctx,
+                                                     struct ggml_tensor* x,
+                                                     struct ggml_tensor* pe) {
+        // x: [N, L, n_head, d_head]
+        // pe: [L, d_head/2, 2, 2]
+        int64_t d_head = x->ne[0];
+        int64_t n_head = x->ne[1];
+        int64_t L      = x->ne[2];
+        int64_t N      = x->ne[3];
+        x              = ggml_cont(ctx, ggml_permute(ctx, x, 0, 2, 1, 3));       // [N, n_head, L, d_head]
+        x              = ggml_reshape_4d(ctx, x, 2, d_head / 2, L, n_head * N);  // [N * n_head, L, d_head/2, 2]
+        x              = ggml_cont(ctx, ggml_permute(ctx, x, 3, 0, 1, 2));       // [2, N * n_head, L, d_head/2]
+
+        int64_t offset = x->nb[2] * x->ne[2];
+        auto x_0       = ggml_view_3d(ctx, x, x->ne[0], x->ne[1], x->ne[2], x->nb[1], x->nb[2], offset * 0);  // [N * n_head, L, d_head/2]
+        auto x_1       = ggml_view_3d(ctx, x, x->ne[0], x->ne[1], x->ne[2], x->nb[1], x->nb[2], offset * 1);  // [N * n_head, L, d_head/2]
+        x_0            = ggml_reshape_4d(ctx, x_0, 1, x_0->ne[0], x_0->ne[1], x_0->ne[2]);                    // [N * n_head, L, d_head/2, 1]
+        x_1            = ggml_reshape_4d(ctx, x_1, 1, x_1->ne[0], x_1->ne[1], x_1->ne[2]);                    // [N * n_head, L, d_head/2, 1]
+        auto temp_x    = ggml_new_tensor_4d(ctx, x_0->type, 2, x_0->ne[1], x_0->ne[2], x_0->ne[3]);
+        x_0            = ggml_repeat(ctx, x_0, temp_x);  // [N * n_head, L, d_head/2, 2]
+        x_1            = ggml_repeat(ctx, x_1, temp_x);  // [N * n_head, L, d_head/2, 2]
+
+        pe        = ggml_cont(ctx, ggml_permute(ctx, pe, 3, 0, 1, 2));  // [2, L, d_head/2, 2]
+        offset    = pe->nb[2] * pe->ne[2];
+        auto pe_0 = ggml_view_3d(ctx, pe, pe->ne[0], pe->ne[1], pe->ne[2], pe->nb[1], pe->nb[2], offset * 0);  // [L, d_head/2, 2]
+        auto pe_1 = ggml_view_3d(ctx, pe, pe->ne[0], pe->ne[1], pe->ne[2], pe->nb[1], pe->nb[2], offset * 1);  // [L, d_head/2, 2]
+
+        auto x_out = ggml_add_inplace(ctx, ggml_mul(ctx, x_0, pe_0), ggml_mul(ctx, x_1, pe_1));  // [N * n_head, L, d_head/2, 2]
+        x_out      = ggml_reshape_3d(ctx, x_out, d_head, L, n_head * N);                         // [N*n_head, L, d_head]
+        return x_out;
+    }
+
+    __STATIC_INLINE__ struct ggml_tensor* attention(struct ggml_context* ctx,
+                                                    ggml_backend_t backend,
+                                                    struct ggml_tensor* q,
+                                                    struct ggml_tensor* k,
+                                                    struct ggml_tensor* v,
+                                                    struct ggml_tensor* pe,
+                                                    struct ggml_tensor* mask,
+                                                    bool flash_attn) {
+        // q,k,v: [N, L, n_head, d_head]
+        // pe: [L, d_head/2, 2, 2]
+        // return: [N, L, n_head*d_head]
+        q = apply_rope(ctx, q, pe);  // [N*n_head, L, d_head]
+        k = apply_rope(ctx, k, pe);  // [N*n_head, L, d_head]
+
+        auto x = ggml_nn_attention_ext(ctx, backend, q, k, v, v->ne[1], mask, false, true, flash_attn);  // [N, L, n_head*d_head]
+        return x;
+    }
+
     struct SelfAttention : public GGMLBlock {
     public:
         int64_t num_heads;
@@ -128,9 +178,9 @@ namespace Flux {
             // x: [N, n_token, dim]
             // pe: [n_token, d_head/2, 2, 2]
             // return [N, n_token, dim]
-            auto qkv = pre_attention(ctx, x);                                                        // q,k,v: [N, n_token, n_head, d_head]
-            x        = Rope::attention(ctx, backend, qkv[0], qkv[1], qkv[2], pe, mask, flash_attn);  // [N, n_token, dim]
-            x        = post_attention(ctx, x);                                                       // [N, n_token, dim]
+            auto qkv = pre_attention(ctx, x);                                                  // q,k,v: [N, n_token, n_head, d_head]
+            x        = attention(ctx, backend, qkv[0], qkv[1], qkv[2], pe, mask, flash_attn);  // [N, n_token, dim]
+            x        = post_attention(ctx, x);                                                 // [N, n_token, dim]
             return x;
         }
     };
@@ -318,8 +368,8 @@ namespace Flux {
             auto k = ggml_concat(ctx, txt_k, img_k, 2);  // [N, n_txt_token + n_img_token, n_head, d_head]
             auto v = ggml_concat(ctx, txt_v, img_v, 2);  // [N, n_txt_token + n_img_token, n_head, d_head]
 
-            auto attn         = Rope::attention(ctx, backend, q, k, v, pe, mask, flash_attn);  // [N, n_txt_token + n_img_token, n_head*d_head]
-            attn              = ggml_cont(ctx, ggml_permute(ctx, attn, 0, 2, 1, 3));           // [n_txt_token + n_img_token, N, hidden_size]
+            auto attn         = attention(ctx, backend, q, k, v, pe, mask, flash_attn);  // [N, n_txt_token + n_img_token, n_head*d_head]
+            attn              = ggml_cont(ctx, ggml_permute(ctx, attn, 0, 2, 1, 3));     // [n_txt_token + n_img_token, N, hidden_size]
             auto txt_attn_out = ggml_view_3d(ctx,
                                              attn,
                                              attn->ne[0],
@@ -453,7 +503,7 @@ namespace Flux {
             auto v           = ggml_reshape_4d(ctx, qkv_vec[2], head_dim, num_heads, qkv_vec[2]->ne[1], qkv_vec[2]->ne[2]);  // [N, n_token, n_head, d_head]
             q                = norm->query_norm(ctx, q);
             k                = norm->key_norm(ctx, k);
-            auto attn        = Rope::attention(ctx, backend, q, k, v, pe, mask, flash_attn);  // [N, n_token, hidden_size]
+            auto attn        = attention(ctx, backend, q, k, v, pe, mask, flash_attn);  // [N, n_token, hidden_size]
 
             auto attn_mlp = ggml_concat(ctx, attn, ggml_gelu_inplace(ctx, mlp), 0);  // [N, n_token, hidden_size + mlp_hidden_dim]
             auto output   = linear2->forward(ctx, attn_mlp);                         // [N, n_token, hidden_size]
@@ -565,7 +615,6 @@ namespace Flux {
         bool guidance_embed         = true;
         bool flash_attn             = true;
         bool is_chroma              = false;
-        SDVersion version           = VERSION_FLUX;
     };
 
     struct Flux : public GGMLBlock {
@@ -800,8 +849,7 @@ namespace Flux {
             auto img            = process_img(ctx, x);
             uint64_t img_tokens = img->ne[1];
 
-            if (params.version == VERSION_FLUX_FILL) {
-                GGML_ASSERT(c_concat != NULL);
+            if (c_concat != NULL) {
                 ggml_tensor* masked = ggml_view_4d(ctx, c_concat, c_concat->ne[0], c_concat->ne[1], C, 1, c_concat->nb[1], c_concat->nb[2], c_concat->nb[3], 0);
                 ggml_tensor* mask   = ggml_view_4d(ctx, c_concat, c_concat->ne[0], c_concat->ne[1], 8 * 8, 1, c_concat->nb[1], c_concat->nb[2], c_concat->nb[3], c_concat->nb[2] * C);
 
@@ -809,27 +857,6 @@ namespace Flux {
                 mask   = process_img(ctx, mask);
 
                 img = ggml_concat(ctx, img, ggml_concat(ctx, masked, mask, 0), 0);
-            } else if (params.version == VERSION_FLEX_2) {
-                GGML_ASSERT(c_concat != NULL);
-                ggml_tensor* masked  = ggml_view_4d(ctx, c_concat, c_concat->ne[0], c_concat->ne[1], C, 1, c_concat->nb[1], c_concat->nb[2], c_concat->nb[3], 0);
-                ggml_tensor* mask    = ggml_view_4d(ctx, c_concat, c_concat->ne[0], c_concat->ne[1], 1, 1, c_concat->nb[1], c_concat->nb[2], c_concat->nb[3], c_concat->nb[2] * C);
-                ggml_tensor* control = ggml_view_4d(ctx, c_concat, c_concat->ne[0], c_concat->ne[1], C, 1, c_concat->nb[1], c_concat->nb[2], c_concat->nb[3], c_concat->nb[2] * (C + 1));
-
-                masked  = ggml_pad(ctx, masked, pad_w, pad_h, 0, 0);
-                mask    = ggml_pad(ctx, mask, pad_w, pad_h, 0, 0);
-                control = ggml_pad(ctx, control, pad_w, pad_h, 0, 0);
-
-                masked  = patchify(ctx, masked, patch_size);
-                mask    = patchify(ctx, mask, patch_size);
-                control = patchify(ctx, control, patch_size);
-
-                img = ggml_concat(ctx, img, ggml_concat(ctx, ggml_concat(ctx, masked, mask, 0), control, 0), 0);
-            } else if (params.version == VERSION_FLUX_CONTROLS) {
-                GGML_ASSERT(c_concat != NULL);
-
-                ggml_tensor* control = ggml_pad(ctx, c_concat, pad_w, pad_h, 0, 0);
-                control              = patchify(ctx, control, patch_size);
-                img                  = ggml_concat(ctx, img, control, 0);
             }
 
             if (ref_latents.size() > 0) {
@@ -840,7 +867,6 @@ namespace Flux {
             }
 
             auto out = forward_orig(ctx, backend, img, context, timestep, y, guidance, pe, mod_index_arange, skip_layers);  // [N, num_tokens, C * patch_size * patch_size]
-
             if (out->ne[1] > img_tokens) {
                 out = ggml_cont(ctx, ggml_permute(ctx, out, 0, 2, 1, 3));  // [num_tokens, N, C * patch_size * patch_size]
                 out = ggml_view_3d(ctx, out, out->ne[0], out->ne[1], img_tokens, out->nb[1], out->nb[2], 0);
@@ -870,18 +896,13 @@ namespace Flux {
                    SDVersion version                   = VERSION_FLUX,
                    bool flash_attn                     = false,
                    bool use_mask                       = false)
-            : GGMLRunner(backend, offload_params_to_cpu), version(version), use_mask(use_mask) {
-            flux_params.version             = version;
+            : GGMLRunner(backend, offload_params_to_cpu), use_mask(use_mask) {
             flux_params.flash_attn          = flash_attn;
             flux_params.guidance_embed      = false;
             flux_params.depth               = 0;
             flux_params.depth_single_blocks = 0;
             if (version == VERSION_FLUX_FILL) {
                 flux_params.in_channels = 384;
-            } else if (version == VERSION_FLUX_CONTROLS) {
-                flux_params.in_channels = 128;
-            } else if (version == VERSION_FLEX_2) {
-                flux_params.in_channels = 196;
             }
             for (auto pair : tensor_types) {
                 std::string tensor_name = pair.first;

ggml_extend.hpp

@@ -56,10 +56,6 @@
 #define __STATIC_INLINE__ static inline
 #endif
 
-#ifndef SD_UNUSED
-#define SD_UNUSED(x) (void)(x)
-#endif
-
 __STATIC_INLINE__ void ggml_log_callback_default(ggml_log_level level, const char* text, void*) {
     switch (level) {
         case GGML_LOG_LEVEL_DEBUG:
@@ -197,11 +193,8 @@ __STATIC_INLINE__ float sd_image_get_f32(sd_image_t image, int iw, int ih, int i
     return value;
 }
 
-__STATIC_INLINE__ float sd_image_get_f32(sd_image_f32_t image, int iw, int ih, int ic, bool scale = true) {
+__STATIC_INLINE__ float sd_image_get_f32(sd_image_f32_t image, int iw, int ih, int ic) {
     float value = *(image.data + ih * image.width * image.channel + iw * image.channel + ic);
-    if (scale) {
-        value /= 255.f;
-    }
     return value;
 }
 
@@ -375,14 +368,12 @@ __STATIC_INLINE__ float sigmoid(float x) {
 
 // SPECIAL OPERATIONS WITH TENSORS
 
-__STATIC_INLINE__ uint8_t* sd_tensor_to_image(struct ggml_tensor* input, uint8_t* image_data = nullptr) {
+__STATIC_INLINE__ uint8_t* sd_tensor_to_image(struct ggml_tensor* input) {
     int64_t width    = input->ne[0];
     int64_t height   = input->ne[1];
     int64_t channels = input->ne[2];
     GGML_ASSERT(channels == 3 && input->type == GGML_TYPE_F32);
-    if (image_data == nullptr) {
-        image_data = (uint8_t*)malloc(width * height * channels);
-    }
+    uint8_t* image_data = (uint8_t*)malloc(width * height * channels);
     for (int iy = 0; iy < height; iy++) {
         for (int ix = 0; ix < width; ix++) {
             for (int k = 0; k < channels; k++) {
@@ -437,42 +428,42 @@ __STATIC_INLINE__ void sd_image_to_tensor(sd_image_t image,
 
 __STATIC_INLINE__ void sd_apply_mask(struct ggml_tensor* image_data,
                                      struct ggml_tensor* mask,
-                                     struct ggml_tensor* output,
-                                     float masked_value = 0.5f) {
+                                     struct ggml_tensor* output) {
     int64_t width    = output->ne[0];
     int64_t height   = output->ne[1];
     int64_t channels = output->ne[2];
-    float rescale_mx = mask->ne[0] / output->ne[0];
-    float rescale_my = mask->ne[1] / output->ne[1];
     GGML_ASSERT(output->type == GGML_TYPE_F32);
     for (int ix = 0; ix < width; ix++) {
         for (int iy = 0; iy < height; iy++) {
-            int mx  = (int)(ix * rescale_mx);
-            int my  = (int)(iy * rescale_my);
-            float m = ggml_tensor_get_f32(mask, mx, my);
+            float m = ggml_tensor_get_f32(mask, ix, iy);
             m       = round(m);  // inpaint models need binary masks
-            ggml_tensor_set_f32(mask, m, mx, my);
+            ggml_tensor_set_f32(mask, m, ix, iy);
             for (int k = 0; k < channels; k++) {
-                float value = ggml_tensor_get_f32(image_data, ix, iy, k);
-                value       = (1 - m) * (value - masked_value) + masked_value;
+                float value = (1 - m) * (ggml_tensor_get_f32(image_data, ix, iy, k) - .5) + .5;
                 ggml_tensor_set_f32(output, value, ix, iy, k);
             }
         }
     }
 }
 
-__STATIC_INLINE__ void sd_image_f32_to_tensor(sd_image_f32_t image,
-                                              ggml_tensor* tensor,
+__STATIC_INLINE__ void sd_image_f32_to_tensor(const float* image_data,
+                                              struct ggml_tensor* output,
                                               bool scale = true) {
-    GGML_ASSERT(image.width == tensor->ne[0]);
-    GGML_ASSERT(image.height == tensor->ne[1]);
-    GGML_ASSERT(image.channel == tensor->ne[2]);
-    GGML_ASSERT(1 == tensor->ne[3]);
-    GGML_ASSERT(tensor->type == GGML_TYPE_F32);
-    ggml_tensor_iter(tensor, [&](ggml_tensor* tensor, int64_t i0, int64_t i1, int64_t i2, int64_t i3) {
-        float value = sd_image_get_f32(image, i0, i1, i2, scale);
-        ggml_tensor_set_f32(tensor, value, i0, i1, i2, i3);
-    });
+    int64_t width    = output->ne[0];
+    int64_t height   = output->ne[1];
+    int64_t channels = output->ne[2];
+    GGML_ASSERT(channels == 3 && output->type == GGML_TYPE_F32);
+    for (int iy = 0; iy < height; iy++) {
+        for (int ix = 0; ix < width; ix++) {
+            for (int k = 0; k < channels; k++) {
+                int value = *(image_data + iy * width * channels + ix * channels + k);
+                if (scale) {
+                    value /= 255.f;
+                }
+                ggml_tensor_set_f32(output, value, ix, iy, k);
+            }
+        }
+    }
 }
 
 __STATIC_INLINE__ void ggml_split_tensor_2d(struct ggml_tensor* input,
@@ -482,15 +473,12 @@ __STATIC_INLINE__ void ggml_split_tensor_2d(struct ggml_tensor* input,
     int64_t width    = output->ne[0];
     int64_t height   = output->ne[1];
     int64_t channels = output->ne[2];
-    int64_t ne3      = output->ne[3];
     GGML_ASSERT(input->type == GGML_TYPE_F32 && output->type == GGML_TYPE_F32);
     for (int iy = 0; iy < height; iy++) {
         for (int ix = 0; ix < width; ix++) {
             for (int k = 0; k < channels; k++) {
-                for (int l = 0; l < ne3; l++) {
-                    float value = ggml_tensor_get_f32(input, ix + x, iy + y, k, l);
-                    ggml_tensor_set_f32(output, value, ix, iy, k, l);
-                }
+                float value = ggml_tensor_get_f32(input, ix + x, iy + y, k);
+                ggml_tensor_set_f32(output, value, ix, iy, k);
             }
         }
     }
@@ -513,7 +501,6 @@ __STATIC_INLINE__ void ggml_merge_tensor_2d(struct ggml_tensor* input,
     int64_t width    = input->ne[0];
     int64_t height   = input->ne[1];
     int64_t channels = input->ne[2];
-    int64_t ne3      = input->ne[3];
 
     int64_t img_width  = output->ne[0];
     int64_t img_height = output->ne[1];
@@ -522,26 +509,24 @@ __STATIC_INLINE__ void ggml_merge_tensor_2d(struct ggml_tensor* input,
     for (int iy = y_skip; iy < height; iy++) {
         for (int ix = x_skip; ix < width; ix++) {
             for (int k = 0; k < channels; k++) {
-                for (int l = 0; l < ne3; l++) {
-                    float new_value = ggml_tensor_get_f32(input, ix, iy, k, l);
-                    if (overlap_x > 0 || overlap_y > 0) {  // blend colors in overlapped area
-                        float old_value = ggml_tensor_get_f32(output, x + ix, y + iy, k, l);
+                float new_value = ggml_tensor_get_f32(input, ix, iy, k);
+                if (overlap_x > 0 || overlap_y > 0) {  // blend colors in overlapped area
+                    float old_value = ggml_tensor_get_f32(output, x + ix, y + iy, k);
 
-                        const float x_f_0 = (overlap_x > 0 && x > 0) ? (ix - x_skip) / float(overlap_x) : 1;
-                        const float x_f_1 = (overlap_x > 0 && x < (img_width - width)) ? (width - ix) / float(overlap_x) : 1;
-                        const float y_f_0 = (overlap_y > 0 && y > 0) ? (iy - y_skip) / float(overlap_y) : 1;
-                        const float y_f_1 = (overlap_y > 0 && y < (img_height - height)) ? (height - iy) / float(overlap_y) : 1;
+                    const float x_f_0 = (overlap_x > 0 && x > 0) ? (ix - x_skip) / float(overlap_x) : 1;
+                    const float x_f_1 = (overlap_x > 0 && x < (img_width - width)) ? (width - ix) / float(overlap_x) : 1;
+                    const float y_f_0 = (overlap_y > 0 && y > 0) ? (iy - y_skip) / float(overlap_y) : 1;
+                    const float y_f_1 = (overlap_y > 0 && y < (img_height - height)) ? (height - iy) / float(overlap_y) : 1;
 
-                        const float x_f = std::min(std::min(x_f_0, x_f_1), 1.f);
-                        const float y_f = std::min(std::min(y_f_0, y_f_1), 1.f);
+                    const float x_f = std::min(std::min(x_f_0, x_f_1), 1.f);
+                    const float y_f = std::min(std::min(y_f_0, y_f_1), 1.f);
 
-                        ggml_tensor_set_f32(
-                            output,
-                            old_value + new_value * ggml_smootherstep_f32(y_f) * ggml_smootherstep_f32(x_f),
-                            x + ix, y + iy, k, l);
-                    } else {
-                        ggml_tensor_set_f32(output, new_value, x + ix, y + iy, k, l);
-                    }
+                    ggml_tensor_set_f32(
+                        output,
+                        old_value + new_value * ggml_smootherstep_f32(y_f) * ggml_smootherstep_f32(x_f),
+                        x + ix, y + iy, k);
+                } else {
+                    ggml_tensor_set_f32(output, new_value, x + ix, y + iy, k);
                 }
             }
         }
@@ -857,8 +842,8 @@ __STATIC_INLINE__ void sd_tiling_non_square(ggml_tensor* input,
     }
 
     struct ggml_init_params params = {};
-    params.mem_size += input_tile_size_x * input_tile_size_y * input->ne[2] * input->ne[3] * sizeof(float);      // input chunk
-    params.mem_size += output_tile_size_x * output_tile_size_y * output->ne[2] * output->ne[3] * sizeof(float);  // output chunk
+    params.mem_size += input_tile_size_x * input_tile_size_y * input->ne[2] * sizeof(float);     // input chunk
+    params.mem_size += output_tile_size_x * output_tile_size_y * output->ne[2] * sizeof(float);  // output chunk
     params.mem_size += 3 * ggml_tensor_overhead();
     params.mem_buffer = NULL;
     params.no_alloc   = false;
@@ -873,8 +858,8 @@ __STATIC_INLINE__ void sd_tiling_non_square(ggml_tensor* input,
     }
 
     // tiling
-    ggml_tensor* input_tile  = ggml_new_tensor_4d(tiles_ctx, GGML_TYPE_F32, input_tile_size_x, input_tile_size_y, input->ne[2], input->ne[3]);
-    ggml_tensor* output_tile = ggml_new_tensor_4d(tiles_ctx, GGML_TYPE_F32, output_tile_size_x, output_tile_size_y, output->ne[2], output->ne[3]);
+    ggml_tensor* input_tile  = ggml_new_tensor_4d(tiles_ctx, GGML_TYPE_F32, input_tile_size_x, input_tile_size_y, input->ne[2], 1);
+    ggml_tensor* output_tile = ggml_new_tensor_4d(tiles_ctx, GGML_TYPE_F32, output_tile_size_x, output_tile_size_y, output->ne[2], 1);
     int num_tiles            = num_tiles_x * num_tiles_y;
     LOG_INFO("processing %i tiles", num_tiles);
     pretty_progress(0, num_tiles, 0.0f);
@@ -948,19 +933,8 @@ __STATIC_INLINE__ struct ggml_tensor* ggml_group_norm_32(struct ggml_context* ct
 __STATIC_INLINE__ struct ggml_tensor* ggml_nn_linear(struct ggml_context* ctx,
                                                      struct ggml_tensor* x,
                                                      struct ggml_tensor* w,
-                                                     struct ggml_tensor* b,
-                                                     bool force_prec_f32 = false,
-                                                     float scale         = 1.f) {
-    if (scale != 1.f) {
-        x = ggml_scale(ctx, x, scale);
-    }
+                                                     struct ggml_tensor* b) {
     x = ggml_mul_mat(ctx, w, x);
-    if (force_prec_f32) {
-        ggml_mul_mat_set_prec(x, GGML_PREC_F32);
-    }
-    if (scale != 1.f) {
-        x = ggml_scale(ctx, x, 1.f / scale);
-    }
     if (b != NULL) {
         x = ggml_add_inplace(ctx, x, b);
     }
@@ -1145,9 +1119,9 @@ __STATIC_INLINE__ struct ggml_tensor* ggml_nn_attention(struct ggml_context* ctx
     return kqv;
 }
 
-// q: [N, L_q, C(n_head*d_head)] or [N*n_head, L_q, d_head]
-// k: [N, L_k, n_kv_head*d_head] or [N*n_kv_head, L_k, d_head]
-// v: [N, L_k, n_kv_head*d_head] or [N, L_k, n_kv_head, d_head]
+// q: [N, L_q, C] or [N*n_head, L_q, d_head]
+// k: [N, L_k, C] or [N*n_head, L_k, d_head]
+// v: [N, L_k, C] or [N, L_k, n_head, d_head]
 // mask: [N, L_q, L_k]
 // return: [N, L_q, C]
 __STATIC_INLINE__ struct ggml_tensor* ggml_nn_attention_ext(struct ggml_context* ctx,
@@ -1159,38 +1133,33 @@ __STATIC_INLINE__ struct ggml_tensor* ggml_nn_attention_ext(struct ggml_context*
                                                             struct ggml_tensor* mask = NULL,
                                                             bool diag_mask_inf       = false,
                                                             bool skip_reshape        = false,
-                                                            bool flash_attn          = false,  // avoid overflow
-                                                            float kv_scale           = 1.0f) {
+                                                            bool flash_attn          = false) {
     int64_t L_q;
     int64_t L_k;
     int64_t C;
     int64_t N;
     int64_t d_head;
-    int64_t n_kv_head;
     if (!skip_reshape) {
-        L_q       = q->ne[1];
-        L_k       = k->ne[1];
-        C         = q->ne[0];
-        N         = q->ne[2];
-        d_head    = C / n_head;
-        n_kv_head = k->ne[0] / d_head;
+        L_q    = q->ne[1];
+        L_k    = k->ne[1];
+        C      = q->ne[0];
+        N      = q->ne[2];
+        d_head = C / n_head;
+        q      = ggml_reshape_4d(ctx, q, d_head, n_head, L_q, N);      // [N, L_q, n_head, d_head]
+        q      = ggml_nn_cont(ctx, ggml_permute(ctx, q, 0, 2, 1, 3));  // [N, n_head, L_q, d_head]
+        q      = ggml_reshape_3d(ctx, q, d_head, L_q, n_head * N);     // [N * n_head, L_q, d_head]
 
-        q = ggml_reshape_4d(ctx, q, d_head, n_head, L_q, N);      // [N, L_q, n_head, d_head]
-        q = ggml_nn_cont(ctx, ggml_permute(ctx, q, 0, 2, 1, 3));  // [N, n_head, L_q, d_head]
-        q = ggml_reshape_3d(ctx, q, d_head, L_q, n_head * N);     // [N * n_head, L_q, d_head]
+        k = ggml_reshape_4d(ctx, k, d_head, n_head, L_k, N);      // [N, L_k, n_head, d_head]
+        k = ggml_nn_cont(ctx, ggml_permute(ctx, k, 0, 2, 1, 3));  // [N, n_head, L_k, d_head]
+        k = ggml_reshape_3d(ctx, k, d_head, L_k, n_head * N);     // [N * n_head, L_k, d_head]
 
-        k = ggml_reshape_4d(ctx, k, d_head, n_kv_head, L_k, N);   // [N, L_k, n_kv_head, d_head]
-        k = ggml_nn_cont(ctx, ggml_permute(ctx, k, 0, 2, 1, 3));  // [N, n_kv_head, L_k, d_head]
-        k = ggml_reshape_3d(ctx, k, d_head, L_k, n_kv_head * N);  // [N * n_kv_head, L_k, d_head]
-
-        v = ggml_reshape_4d(ctx, v, d_head, n_kv_head, L_k, N);  // [N, L_k, n_kv_head, d_head]
+        v = ggml_reshape_4d(ctx, v, d_head, n_head, L_k, N);  // [N, L_k, n_head, d_head]
     } else {
-        L_q       = q->ne[1];
-        L_k       = k->ne[1];
-        d_head    = v->ne[0];
-        N         = v->ne[3];
-        n_kv_head = k->ne[2] / N;
-        C         = d_head * n_head;
+        L_q    = q->ne[1];
+        L_k    = k->ne[1];
+        d_head = v->ne[0];
+        N      = v->ne[3];
+        C      = d_head * n_head;
     }
 
     float scale = (1.0f / sqrt((float)d_head));
@@ -1202,19 +1171,13 @@ __STATIC_INLINE__ struct ggml_tensor* ggml_nn_attention_ext(struct ggml_context*
         if (kv_pad != 0) {
             k_in = ggml_pad(ctx, k_in, 0, kv_pad, 0, 0);
         }
-        if (kv_scale != 1.0f) {
-            k_in = ggml_scale(ctx, k_in, kv_scale);
-        }
         k_in = ggml_cast(ctx, k_in, GGML_TYPE_F16);
 
         v_in = ggml_nn_cont(ctx, ggml_permute(ctx, v_in, 0, 2, 1, 3));
-        v_in = ggml_reshape_3d(ctx, v_in, d_head, L_k, n_kv_head * N);
+        v_in = ggml_reshape_3d(ctx, v_in, d_head, L_k, n_head * N);
         if (kv_pad != 0) {
             v_in = ggml_pad(ctx, v_in, 0, kv_pad, 0, 0);
         }
-        if (kv_scale != 1.0f) {
-            v_in = ggml_scale(ctx, v_in, kv_scale);
-        }
         v_in = ggml_cast(ctx, v_in, GGML_TYPE_F16);
 
         if (mask_in != nullptr) {
@@ -1238,11 +1201,8 @@ __STATIC_INLINE__ struct ggml_tensor* ggml_nn_attention_ext(struct ggml_context*
             mask_in = ggml_cast(ctx, mask_in, GGML_TYPE_F16);
         }
 
-        auto out = ggml_flash_attn_ext(ctx, q_in, k_in, v_in, mask_in, scale / kv_scale, 0, 0);
+        auto out = ggml_flash_attn_ext(ctx, q_in, k_in, v_in, mask_in, scale, 0, 0);
         ggml_flash_attn_ext_set_prec(out, GGML_PREC_F32);
-        if (kv_scale != 1.0f) {
-            out = ggml_scale(ctx, out, 1.0f / kv_scale);
-        }
         return out;
     };
 
@@ -1272,8 +1232,8 @@ __STATIC_INLINE__ struct ggml_tensor* ggml_nn_attention_ext(struct ggml_context*
         // if (flash_attn) {
         //     LOG_DEBUG("fallback to default attention, L_q:%d L_k:%d n_head:%d C:%d d_head:%d N:%d", L_q, L_k, n_head, C, d_head, N);
         // }
-        v = ggml_nn_cont(ctx, ggml_permute(ctx, v, 1, 2, 0, 3));  // [N, n_kv_head, d_head, L_k]
-        v = ggml_reshape_3d(ctx, v, L_k, d_head, n_kv_head * N);  // [N * n_kv_head, d_head, L_k]
+        v = ggml_nn_cont(ctx, ggml_permute(ctx, v, 1, 2, 0, 3));  // [N, n_head, d_head, L_k]
+        v = ggml_reshape_3d(ctx, v, L_k, d_head, n_head * N);     // [N * n_head, d_head, L_k]
 
         auto kq = ggml_mul_mat(ctx, k, q);  // [N * n_head, L_q, L_k]
         kq      = ggml_scale_inplace(ctx, kq, scale);
@@ -1389,13 +1349,15 @@ __STATIC_INLINE__ std::vector<float> arange(float start, float end, float step =
 // Ref: https://github.com/CompVis/stable-diffusion/blob/main/ldm/modules/diffusionmodules/util.py#L151
 __STATIC_INLINE__ std::vector<float> timestep_embedding(std::vector<float> timesteps,
                                                         int dim,
-                                                        int max_period       = 10000,
-                                                        bool flip_sin_to_cos = true,
-                                                        float scale          = 1.f) {
+                                                        int max_period = 10000) {
     // timesteps: [N,]
     // embedding: [N, dim]
-    size_t N = timesteps.size();
-    std::vector<float> embedding(N * dim, 0.f);
+    size_t N        = timesteps.size();
+    int acutual_dim = dim;
+    if (dim % 2 != 0) {
+        acutual_dim = dim + 1;
+    }
+    std::vector<float> embedding(N * acutual_dim, 0.f);
     int half = dim / 2;
     std::vector<float> freqs(half);
     for (int i = 0; i < half; ++i) {
@@ -1403,14 +1365,9 @@ __STATIC_INLINE__ std::vector<float> timestep_embedding(std::vector<float> times
     }
     for (int i = 0; i < N; ++i) {
         for (int j = 0; j < half; ++j) {
-            float arg = timesteps[i] * freqs[j] * scale;
-            if (flip_sin_to_cos) {
-                embedding[i * dim + j]        = std::cos(arg);
-                embedding[i * dim + j + half] = std::sin(arg);
-            } else {
-                embedding[i * dim + j]        = std::sin(arg);
-                embedding[i * dim + j + half] = std::cos(arg);
-            }
+            float arg                             = timesteps[i] * freqs[j];
+            embedding[i * acutual_dim + j]        = std::cos(arg);
+            embedding[i * acutual_dim + j + half] = std::sin(arg);
         }
     }
     return embedding;
@@ -1431,7 +1388,11 @@ __STATIC_INLINE__ struct ggml_tensor* new_timestep_embedding(struct ggml_context
     // timesteps: [N,]
     // embedding: [N, dim]
     std::vector<float> embedding_vec = timestep_embedding(timesteps, dim, max_period);
-    struct ggml_tensor* embedding    = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, dim, timesteps.size());
+    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.size());
     if (embedding->data != NULL) {
         memcpy(((char*)embedding->data), ((char*)embedding_vec.data()), ggml_nbytes(embedding));
     } else {
@@ -1973,8 +1934,6 @@ protected:
     int64_t out_features;
     bool bias;
     bool force_f32;
-    bool force_prec_f32;
-    float scale;
 
     void init_params(struct ggml_context* ctx, const String2GGMLType& tensor_types = {}, const std::string prefix = "") {
         enum ggml_type wtype = get_type(prefix + "weight", tensor_types, GGML_TYPE_F32);
@@ -1991,16 +1950,12 @@ protected:
 public:
     Linear(int64_t in_features,
            int64_t out_features,
-           bool bias           = true,
-           bool force_f32      = false,
-           bool force_prec_f32 = false,
-           float scale         = 1.f)
+           bool bias      = true,
+           bool force_f32 = false)
         : in_features(in_features),
           out_features(out_features),
           bias(bias),
-          force_f32(force_f32),
-          force_prec_f32(force_prec_f32),
-          scale(scale) {}
+          force_f32(force_f32) {}
 
     struct ggml_tensor* forward(struct ggml_context* ctx, struct ggml_tensor* x) {
         struct ggml_tensor* w = params["weight"];
@@ -2008,28 +1963,17 @@ public:
         if (bias) {
             b = params["bias"];
         }
-        return ggml_nn_linear(ctx, x, w, b, force_prec_f32, scale);
+        return ggml_nn_linear(ctx, x, w, b);
     }
 };
 
-__STATIC_INLINE__ bool support_get_rows(ggml_type wtype) {
-    std::set<ggml_type> allow_types = {GGML_TYPE_F16, GGML_TYPE_Q8_0, GGML_TYPE_Q5_1, GGML_TYPE_Q5_0, GGML_TYPE_Q4_1, GGML_TYPE_Q4_0};
-    if (allow_types.find(wtype) != allow_types.end()) {
-        return true;
-    }
-    return false;
-}
-
 class Embedding : public UnaryBlock {
 protected:
     int64_t embedding_dim;
     int64_t num_embeddings;
     void init_params(struct ggml_context* ctx, const String2GGMLType& tensor_types, const std::string prefix = "") {
         enum ggml_type wtype = get_type(prefix + "weight", tensor_types, GGML_TYPE_F32);
-        if (!support_get_rows(wtype)) {
-            wtype = GGML_TYPE_F32;
-        }
-        params["weight"] = ggml_new_tensor_2d(ctx, wtype, embedding_dim, num_embeddings);
+        params["weight"]     = ggml_new_tensor_2d(ctx, wtype, embedding_dim, num_embeddings);
     }
 
 public:

lora.hpp

@@ -116,7 +116,7 @@ struct LoraModel : public GGMLRunner {
         return "lora";
     }
 
-    bool load_from_file(bool filter_tensor, int n_threads) {
+    bool load_from_file(bool filter_tensor = false, int n_threads = 0) {
         LOG_INFO("loading LoRA from '%s'", file_path.c_str());
 
         if (load_failed) {

model.cpp

@@ -1,5 +1,4 @@
 #include <stdarg.h>
-#include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <fstream>
@@ -17,7 +16,6 @@
 #include "stable-diffusion.h"
 #include "util.h"
 #include "vocab.hpp"
-#include "vocab_qwen.hpp"
 #include "vocab_umt5.hpp"
 
 #include "ggml-alloc.h"
@@ -111,8 +109,6 @@ const char* unused_tensors[] = {
     "embedding_manager",
     "denoiser.sigmas",
     "text_encoders.t5xxl.transformer.encoder.embed_tokens.weight",  // only used during training
-    "text_encoders.qwen2vl.output.weight",
-    "text_encoders.qwen2vl.lm_head.",
 };
 
 bool is_unused_tensor(std::string name) {
@@ -196,39 +192,6 @@ std::unordered_map<std::string, std::string> pmid_v2_name_map = {
      "pmid.qformer_perceiver.token_proj.fc2.weight"},
 };
 
-std::unordered_map<std::string, std::string> qwenvl_name_map{
-    {"token_embd.", "model.embed_tokens."},
-    {"blk.", "model.layers."},
-    {"attn_q.", "self_attn.q_proj."},
-    {"attn_k.", "self_attn.k_proj."},
-    {"attn_v.", "self_attn.v_proj."},
-    {"attn_output.", "self_attn.o_proj."},
-    {"attn_norm.", "input_layernorm."},
-    {"ffn_down.", "mlp.down_proj."},
-    {"ffn_gate.", "mlp.gate_proj."},
-    {"ffn_up.", "mlp.up_proj."},
-    {"ffn_norm.", "post_attention_layernorm."},
-    {"output_norm.", "model.norm."},
-};
-
-std::unordered_map<std::string, std::string> qwenvl_vision_name_map{
-    {"mm.", "merger.mlp."},
-    {"v.post_ln.", "merger.ln_q."},
-    {"v.patch_embd.weight", "patch_embed.proj.0.weight"},
-    {"patch_embed.proj.0.weight.1", "patch_embed.proj.1.weight"},
-    {"v.patch_embd.weight.1", "patch_embed.proj.1.weight"},
-    {"v.blk.", "blocks."},
-    {"attn_q.", "attn.q_proj."},
-    {"attn_k.", "attn.k_proj."},
-    {"attn_v.", "attn.v_proj."},
-    {"attn_out.", "attn.proj."},
-    {"ffn_down.", "mlp.down_proj."},
-    {"ffn_gate.", "mlp.gate_proj."},
-    {"ffn_up.", "mlp.up_proj."},
-    {"ln1.", "norm1."},
-    {"ln2.", "norm2."},
-};
-
 std::string convert_cond_model_name(const std::string& name) {
     std::string new_name = name;
     std::string prefix;
@@ -286,22 +249,6 @@ std::string convert_cond_model_name(const std::string& name) {
         if (pos != std::string::npos) {
             new_name.replace(pos, 11, "layer.0.SelfAttention.relative_attention_bias.");
         }
-    } else if (contains(name, "qwen2vl")) {
-        if (contains(name, "qwen2vl.visual")) {
-            for (auto kv : qwenvl_vision_name_map) {
-                size_t pos = new_name.find(kv.first);
-                if (pos != std::string::npos) {
-                    new_name.replace(pos, kv.first.size(), kv.second);
-                }
-            }
-        } else {
-            for (auto kv : qwenvl_name_map) {
-                size_t pos = new_name.find(kv.first);
-                if (pos != std::string::npos) {
-                    new_name.replace(pos, kv.first.size(), kv.second);
-                }
-            }
-        }
     } else if (name == "text_encoders.t5xxl.transformer.token_embd.weight") {
         new_name = "text_encoders.t5xxl.transformer.shared.weight";
     }
@@ -632,11 +579,7 @@ std::string convert_tensor_name(std::string name) {
     //     name.replace(pos, strlen("lora_B"), "lora_down");
     // }
     std::string new_name = name;
-    if (starts_with(name, "cond_stage_model.") ||
-        starts_with(name, "conditioner.embedders.") ||
-        starts_with(name, "text_encoders.") ||
-        ends_with(name, ".vision_model.visual_projection.weight") ||
-        starts_with(name, "qwen2vl")) {
+    if (starts_with(name, "cond_stage_model.") || starts_with(name, "conditioner.embedders.") || starts_with(name, "text_encoders.") || ends_with(name, ".vision_model.visual_projection.weight")) {
         new_name = convert_cond_model_name(name);
     } else if (starts_with(name, "first_stage_model.decoder")) {
         new_name = convert_vae_decoder_name(name);
@@ -755,7 +698,6 @@ void preprocess_tensor(TensorStorage tensor_storage,
 
     // convert unet transformer linear to conv2d 1x1
     if (starts_with(new_name, "model.diffusion_model.") &&
-        !starts_with(new_name, "model.diffusion_model.proj_out.") &&
         (ends_with(new_name, "proj_in.weight") || ends_with(new_name, "proj_out.weight"))) {
         tensor_storage.unsqueeze();
     }
@@ -1789,9 +1731,6 @@ SDVersion ModelLoader::get_sd_version() {
             if (tensor_storage.name.find("model.diffusion_model.joint_blocks.") != std::string::npos) {
                 return VERSION_SD3;
             }
-            if (tensor_storage.name.find("model.diffusion_model.transformer_blocks.0.img_mod.1.weight") != std::string::npos) {
-                return VERSION_QWEN_IMAGE;
-            }
             if (tensor_storage.name.find("model.diffusion_model.blocks.0.cross_attn.norm_k.weight") != std::string::npos) {
                 is_wan = true;
             }
@@ -1863,15 +1802,10 @@ SDVersion ModelLoader::get_sd_version() {
     }
 
     if (is_flux) {
-        if (input_block_weight.ne[0] == 384) {
+        is_inpaint = input_block_weight.ne[0] == 384;
+        if (is_inpaint) {
             return VERSION_FLUX_FILL;
         }
-        if (input_block_weight.ne[0] == 128) {
-            return VERSION_FLUX_CONTROLS;
-        }
-        if (input_block_weight.ne[0] == 196) {
-            return VERSION_FLEX_2;
-        }
         return VERSION_FLUX;
     }
 
@@ -2005,11 +1939,6 @@ std::string ModelLoader::load_merges() {
     return merges_utf8_str;
 }
 
-std::string ModelLoader::load_qwen2_merges() {
-    std::string merges_utf8_str(reinterpret_cast<const char*>(qwen2_merges_utf8_c_str), sizeof(qwen2_merges_utf8_c_str));
-    return merges_utf8_str;
-}
-
 std::string ModelLoader::load_t5_tokenizer_json() {
     std::string json_str(reinterpret_cast<const char*>(t5_tokenizer_json_str), sizeof(t5_tokenizer_json_str));
     return json_str;
@@ -2027,8 +1956,7 @@ bool ModelLoader::load_tensors(on_new_tensor_cb_t on_new_tensor_cb, int n_thread
     std::atomic<int64_t> copy_to_backend_time_ms(0);
     std::atomic<int64_t> convert_time_ms(0);
 
-    int num_threads_to_use = n_threads_p > 0 ? n_threads_p : get_num_physical_cores();
-    LOG_DEBUG("using %d threads for model loading", num_threads_to_use);
+    int num_threads_to_use = n_threads_p > 0 ? n_threads_p : (int)std::thread::hardware_concurrency();
 
     int64_t start_time = ggml_time_ms();
     std::vector<TensorStorage> processed_tensor_storages;
@@ -2078,25 +2006,13 @@ bool ModelLoader::load_tensors(on_new_tensor_cb_t on_new_tensor_cb, int n_thread
             w.join();
         }
 
-        std::vector<IndexedStorage> deduplicated;
-        deduplicated.reserve(all_results.size());
-        std::unordered_map<std::string, size_t> name_to_pos;
+        std::unordered_map<std::string, IndexedStorage> latest_map;
         for (auto& entry : all_results) {
-            auto it = name_to_pos.find(entry.ts.name);
-            if (it == name_to_pos.end()) {
-                name_to_pos.emplace(entry.ts.name, deduplicated.size());
-                deduplicated.push_back(entry);
-            } else if (deduplicated[it->second].index < entry.index) {
-                deduplicated[it->second] = entry;
-            }
+            latest_map[entry.ts.name] = entry;
         }
 
-        std::sort(deduplicated.begin(), deduplicated.end(), [](const IndexedStorage& a, const IndexedStorage& b) {
-            return a.index < b.index;
-        });
-
-        processed_tensor_storages.reserve(deduplicated.size());
-        for (auto& entry : deduplicated) {
+        processed_tensor_storages.reserve(latest_map.size());
+        for (auto& [name, entry] : latest_map) {
             processed_tensor_storages.push_back(entry.ts);
         }
     }
@@ -2492,8 +2408,6 @@ bool ModelLoader::tensor_should_be_converted(const TensorStorage& tensor_storage
             // Pass, do not convert. For MMDiT
         } else if (contains(name, "time_embed.") || contains(name, "label_emb.")) {
             // Pass, do not convert. For Unet
-        } else if (contains(name, "embedding")) {
-            // Pass, do not convert embedding
         } else {
             return true;
         }
@@ -2513,7 +2427,6 @@ bool ModelLoader::save_to_gguf_file(const std::string& file_path, ggml_type type
 
     auto tensor_type_rules = parse_tensor_type_rules(tensor_type_rules_str);
 
-    std::mutex tensor_mutex;
     auto on_new_tensor_cb = [&](const TensorStorage& tensor_storage, ggml_tensor** dst_tensor) -> bool {
         const std::string& name = tensor_storage.name;
         ggml_type tensor_type   = tensor_storage.type;
@@ -2531,7 +2444,6 @@ bool ModelLoader::save_to_gguf_file(const std::string& file_path, ggml_type type
             tensor_type = dst_type;
         }
 
-        std::lock_guard<std::mutex> lock(tensor_mutex);
         ggml_tensor* tensor = ggml_new_tensor(ggml_ctx, tensor_type, tensor_storage.n_dims, tensor_storage.ne);
         if (tensor == NULL) {
             LOG_ERROR("ggml_new_tensor failed");

model.h

@@ -31,12 +31,9 @@ enum SDVersion {
     VERSION_SD3,
     VERSION_FLUX,
     VERSION_FLUX_FILL,
-    VERSION_FLUX_CONTROLS,
-    VERSION_FLEX_2,
     VERSION_WAN2,
     VERSION_WAN2_2_I2V,
     VERSION_WAN2_2_TI2V,
-    VERSION_QWEN_IMAGE,
     VERSION_COUNT,
 };
 
@@ -69,7 +66,7 @@ static inline bool sd_version_is_sd3(SDVersion version) {
 }
 
 static inline bool sd_version_is_flux(SDVersion version) {
-    if (version == VERSION_FLUX || version == VERSION_FLUX_FILL || version == VERSION_FLUX_CONTROLS || version == VERSION_FLEX_2) {
+    if (version == VERSION_FLUX || version == VERSION_FLUX_FILL) {
         return true;
     }
     return false;
@@ -82,25 +79,15 @@ static inline bool sd_version_is_wan(SDVersion version) {
     return false;
 }
 
-static inline bool sd_version_is_qwen_image(SDVersion version) {
-    if (version == VERSION_QWEN_IMAGE) {
-        return true;
-    }
-    return false;
-}
-
 static inline bool sd_version_is_inpaint(SDVersion version) {
-    if (version == VERSION_SD1_INPAINT || version == VERSION_SD2_INPAINT || version == VERSION_SDXL_INPAINT || version == VERSION_FLUX_FILL || version == VERSION_FLEX_2) {
+    if (version == VERSION_SD1_INPAINT || version == VERSION_SD2_INPAINT || version == VERSION_SDXL_INPAINT || version == VERSION_FLUX_FILL) {
         return true;
     }
     return false;
 }
 
 static inline bool sd_version_is_dit(SDVersion version) {
-    if (sd_version_is_flux(version) ||
-        sd_version_is_sd3(version) ||
-        sd_version_is_wan(version) ||
-        sd_version_is_qwen_image(version)) {
+    if (sd_version_is_flux(version) || sd_version_is_sd3(version) || sd_version_is_wan(version)) {
         return true;
     }
     return false;
@@ -110,12 +97,8 @@ static inline bool sd_version_is_unet_edit(SDVersion version) {
     return version == VERSION_SD1_PIX2PIX || version == VERSION_SDXL_PIX2PIX;
 }
 
-static inline bool sd_version_is_control(SDVersion version) {
-    return version == VERSION_FLUX_CONTROLS || version == VERSION_FLEX_2;
-}
-
 static bool sd_version_is_inpaint_or_unet_edit(SDVersion version) {
-    return sd_version_is_unet_edit(version) || sd_version_is_inpaint(version) || sd_version_is_control(version);
+    return sd_version_is_unet_edit(version) || sd_version_is_inpaint(version);
 }
 
 enum PMVersion {
@@ -269,21 +252,12 @@ public:
                       std::set<std::string> ignore_tensors = {},
                       int n_threads                        = 0);
 
-    std::vector<std::string> get_tensor_names() const {
-        std::vector<std::string> names;
-        for (const auto& ts : tensor_storages) {
-            names.push_back(ts.name);
-        }
-        return names;
-    }
-
     bool save_to_gguf_file(const std::string& file_path, ggml_type type, const std::string& tensor_type_rules);
     bool tensor_should_be_converted(const TensorStorage& tensor_storage, ggml_type type);
     int64_t get_params_mem_size(ggml_backend_t backend, ggml_type type = GGML_TYPE_COUNT);
     ~ModelLoader() = default;
 
     static std::string load_merges();
-    static std::string load_qwen2_merges();
     static std::string load_t5_tokenizer_json();
     static std::string load_umt5_tokenizer_json();
 };

pmid.hpp

@@ -591,7 +591,7 @@ struct PhotoMakerIDEmbed : public GGMLRunner {
         return "id_embeds";
     }
 
-    bool load_from_file(bool filter_tensor, int n_threads) {
+    bool load_from_file(bool filter_tensor = false) {
         LOG_INFO("loading PhotoMaker ID Embeds from '%s'", file_path.c_str());
 
         if (load_failed) {
@@ -599,8 +599,7 @@ struct PhotoMakerIDEmbed : public GGMLRunner {
             return false;
         }
 
-        bool dry_run = true;
-        std::mutex tensor_mutex;
+        bool dry_run          = true;
         auto on_new_tensor_cb = [&](const TensorStorage& tensor_storage, ggml_tensor** dst_tensor) -> bool {
             const std::string& name = tensor_storage.name;
 
@@ -609,7 +608,6 @@ struct PhotoMakerIDEmbed : public GGMLRunner {
                 return true;
             }
             if (dry_run) {
-                std::lock_guard<std::mutex> lock(tensor_mutex);
                 struct ggml_tensor* real = ggml_new_tensor(params_ctx,
                                                            tensor_storage.type,
                                                            tensor_storage.n_dims,
@@ -623,11 +621,11 @@ struct PhotoMakerIDEmbed : public GGMLRunner {
             return true;
         };
 
-        model_loader->load_tensors(on_new_tensor_cb, n_threads);
+        model_loader->load_tensors(on_new_tensor_cb);
         alloc_params_buffer();
 
         dry_run = false;
-        model_loader->load_tensors(on_new_tensor_cb, n_threads);
+        model_loader->load_tensors(on_new_tensor_cb);
 
         LOG_DEBUG("finished loading PhotoMaker ID Embeds ");
         return true;

preprocessing.hpp

@@ -6,7 +6,7 @@
 
 void convolve(struct ggml_tensor* input, struct ggml_tensor* output, struct ggml_tensor* kernel, int padding) {
     struct ggml_init_params params;
-    params.mem_size                 = 80 * input->ne[0] * input->ne[1];  // 20M for 512x512
+    params.mem_size                 = 20 * 1024 * 1024;  // 10
     params.mem_buffer               = NULL;
     params.no_alloc                 = false;
     struct ggml_context* ctx0       = ggml_init(params);
@@ -164,7 +164,7 @@ void threshold_hystersis(struct ggml_tensor* img, float high_threshold, float lo
 
 bool preprocess_canny(sd_image_t img, float high_threshold, float low_threshold, float weak, float strong, bool inverse) {
     struct ggml_init_params params;
-    params.mem_size               = static_cast<size_t>(40 * img.width * img.height);  // 10MB for 512x512
+    params.mem_size               = static_cast<size_t>(10 * 1024 * 1024);  // 10MB
     params.mem_buffer             = NULL;
     params.no_alloc               = false;
     struct ggml_context* work_ctx = ggml_init(params);
@@ -218,7 +218,9 @@ bool preprocess_canny(sd_image_t img, float high_threshold, float low_threshold,
             ggml_tensor_set_f32(image, gray, ix, iy, 2);
         }
     }
-    sd_tensor_to_image(image, img.data);
+    uint8_t* output = sd_tensor_to_image(image);
+    free(img.data);
+    img.data = output;
     ggml_free(work_ctx);
     return true;
 }

qwen_image.hpp

@@ -1,694 +0,0 @@
-#ifndef __QWEN_IMAGE_HPP__
-#define __QWEN_IMAGE_HPP__
-
-#include "common.hpp"
-#include "flux.hpp"
-#include "ggml_extend.hpp"
-
-namespace Qwen {
-    constexpr int QWEN_IMAGE_GRAPH_SIZE = 20480;
-
-    struct TimestepEmbedding : public GGMLBlock {
-    public:
-        TimestepEmbedding(int64_t in_channels,
-                          int64_t time_embed_dim,
-                          int64_t out_dim       = 0,
-                          int64_t cond_proj_dim = 0,
-                          bool sample_proj_bias = true) {
-            blocks["linear_1"] = std::shared_ptr<GGMLBlock>(new Linear(in_channels, time_embed_dim, sample_proj_bias));
-            if (cond_proj_dim > 0) {
-                blocks["cond_proj"] = std::shared_ptr<GGMLBlock>(new Linear(cond_proj_dim, in_channels, false));
-            }
-            if (out_dim <= 0) {
-                out_dim = time_embed_dim;
-            }
-            blocks["linear_2"] = std::shared_ptr<GGMLBlock>(new Linear(time_embed_dim, out_dim, sample_proj_bias));
-        }
-
-        struct ggml_tensor* forward(struct ggml_context* ctx,
-                                    struct ggml_tensor* sample,
-                                    struct ggml_tensor* condition = nullptr) {
-            if (condition != nullptr) {
-                auto cond_proj = std::dynamic_pointer_cast<Linear>(blocks["cond_proj"]);
-                sample         = ggml_add(ctx, sample, cond_proj->forward(ctx, condition));
-            }
-            auto linear_1 = std::dynamic_pointer_cast<Linear>(blocks["linear_1"]);
-            auto linear_2 = std::dynamic_pointer_cast<Linear>(blocks["linear_2"]);
-
-            sample = linear_1->forward(ctx, sample);
-            sample = ggml_silu_inplace(ctx, sample);
-            sample = linear_2->forward(ctx, sample);
-            return sample;
-        }
-    };
-
-    struct QwenTimestepProjEmbeddings : public GGMLBlock {
-    public:
-        QwenTimestepProjEmbeddings(int64_t embedding_dim) {
-            blocks["timestep_embedder"] = std::shared_ptr<GGMLBlock>(new TimestepEmbedding(256, embedding_dim));
-        }
-
-        struct ggml_tensor* forward(struct ggml_context* ctx,
-                                    struct ggml_tensor* timesteps) {
-            // timesteps: [N,]
-            // return: [N, embedding_dim]
-            auto timestep_embedder = std::dynamic_pointer_cast<TimestepEmbedding>(blocks["timestep_embedder"]);
-
-            auto timesteps_proj = ggml_nn_timestep_embedding(ctx, timesteps, 256, 10000, 1.f);
-            auto timesteps_emb  = timestep_embedder->forward(ctx, timesteps_proj);
-            return timesteps_emb;
-        }
-    };
-
-    struct QwenImageAttention : public GGMLBlock {
-    protected:
-        int64_t dim_head;
-        bool flash_attn;
-
-    public:
-        QwenImageAttention(int64_t query_dim,
-                           int64_t dim_head,
-                           int64_t num_heads,
-                           int64_t out_dim         = 0,
-                           int64_t out_context_dim = 0,
-                           bool bias               = true,
-                           bool out_bias           = true,
-                           float eps               = 1e-6,
-                           bool flash_attn         = false)
-            : dim_head(dim_head), flash_attn(flash_attn) {
-            int64_t inner_dim = out_dim > 0 ? out_dim : dim_head * num_heads;
-            out_dim           = out_dim > 0 ? out_dim : query_dim;
-            out_context_dim   = out_context_dim > 0 ? out_context_dim : query_dim;
-
-            blocks["to_q"] = std::shared_ptr<GGMLBlock>(new Linear(query_dim, inner_dim, bias));
-            blocks["to_k"] = std::shared_ptr<GGMLBlock>(new Linear(query_dim, inner_dim, bias));
-            blocks["to_v"] = std::shared_ptr<GGMLBlock>(new Linear(query_dim, inner_dim, bias));
-
-            blocks["norm_q"] = std::shared_ptr<GGMLBlock>(new RMSNorm(dim_head, eps));
-            blocks["norm_k"] = std::shared_ptr<GGMLBlock>(new RMSNorm(dim_head, eps));
-
-            blocks["add_q_proj"] = std::shared_ptr<GGMLBlock>(new Linear(query_dim, inner_dim, bias));
-            blocks["add_k_proj"] = std::shared_ptr<GGMLBlock>(new Linear(query_dim, inner_dim, bias));
-            blocks["add_v_proj"] = std::shared_ptr<GGMLBlock>(new Linear(query_dim, inner_dim, bias));
-
-            blocks["norm_added_q"] = std::shared_ptr<GGMLBlock>(new RMSNorm(dim_head, eps));
-            blocks["norm_added_k"] = std::shared_ptr<GGMLBlock>(new RMSNorm(dim_head, eps));
-
-            float scale = 1.f / 32.f;
-            // The purpose of the scale here is to prevent NaN issues in certain situations.
-            // For example when using CUDA but the weights are k-quants (not all prompts).
-            blocks["to_out.0"] = std::shared_ptr<GGMLBlock>(new Linear(inner_dim, out_dim, out_bias, false, false, scale));
-            // to_out.1 is nn.Dropout
-
-            blocks["to_add_out"] = std::shared_ptr<GGMLBlock>(new Linear(inner_dim, out_context_dim, out_bias, false, false, scale));
-        }
-
-        std::pair<ggml_tensor*, ggml_tensor*> forward(struct ggml_context* ctx,
-                                                      ggml_backend_t backend,
-                                                      struct ggml_tensor* img,
-                                                      struct ggml_tensor* txt,
-                                                      struct ggml_tensor* pe,
-                                                      struct ggml_tensor* mask = nullptr) {
-            // img: [N, n_img_token, hidden_size]
-            // txt: [N, n_txt_token, hidden_size]
-            // pe: [n_img_token + n_txt_token, d_head/2, 2, 2]
-            // return: ([N, n_img_token, hidden_size], [N, n_txt_token, hidden_size])
-
-            auto norm_q = std::dynamic_pointer_cast<UnaryBlock>(blocks["norm_q"]);
-            auto norm_k = std::dynamic_pointer_cast<UnaryBlock>(blocks["norm_k"]);
-
-            auto to_q     = std::dynamic_pointer_cast<Linear>(blocks["to_q"]);
-            auto to_k     = std::dynamic_pointer_cast<Linear>(blocks["to_k"]);
-            auto to_v     = std::dynamic_pointer_cast<Linear>(blocks["to_v"]);
-            auto to_out_0 = std::dynamic_pointer_cast<Linear>(blocks["to_out.0"]);
-
-            auto norm_added_q = std::dynamic_pointer_cast<UnaryBlock>(blocks["norm_added_q"]);
-            auto norm_added_k = std::dynamic_pointer_cast<UnaryBlock>(blocks["norm_added_k"]);
-
-            auto add_q_proj = std::dynamic_pointer_cast<Linear>(blocks["add_q_proj"]);
-            auto add_k_proj = std::dynamic_pointer_cast<Linear>(blocks["add_k_proj"]);
-            auto add_v_proj = std::dynamic_pointer_cast<Linear>(blocks["add_v_proj"]);
-            auto to_add_out = std::dynamic_pointer_cast<Linear>(blocks["to_add_out"]);
-
-            int64_t N           = img->ne[2];
-            int64_t n_img_token = img->ne[1];
-            int64_t n_txt_token = txt->ne[1];
-
-            auto img_q        = to_q->forward(ctx, img);
-            int64_t num_heads = img_q->ne[0] / dim_head;
-            img_q             = ggml_reshape_4d(ctx, img_q, dim_head, num_heads, n_img_token, N);  // [N, n_img_token, n_head, d_head]
-            auto img_k        = to_k->forward(ctx, img);
-            img_k             = ggml_reshape_4d(ctx, img_k, dim_head, num_heads, n_img_token, N);  // [N, n_img_token, n_head, d_head]
-            auto img_v        = to_v->forward(ctx, img);
-            img_v             = ggml_reshape_4d(ctx, img_v, dim_head, num_heads, n_img_token, N);  // [N, n_img_token, n_head, d_head]
-
-            img_q = norm_q->forward(ctx, img_q);
-            img_k = norm_k->forward(ctx, img_k);
-
-            auto txt_q = add_q_proj->forward(ctx, txt);
-            txt_q      = ggml_reshape_4d(ctx, txt_q, dim_head, num_heads, n_txt_token, N);  // [N, n_txt_token, n_head, d_head]
-            auto txt_k = add_k_proj->forward(ctx, txt);
-            txt_k      = ggml_reshape_4d(ctx, txt_k, dim_head, num_heads, n_txt_token, N);  // [N, n_txt_token, n_head, d_head]
-            auto txt_v = add_v_proj->forward(ctx, txt);
-            txt_v      = ggml_reshape_4d(ctx, txt_v, dim_head, num_heads, n_txt_token, N);  // [N, n_txt_token, n_head, d_head]
-
-            txt_q = norm_added_q->forward(ctx, txt_q);
-            txt_k = norm_added_k->forward(ctx, txt_k);
-
-            auto q = ggml_concat(ctx, txt_q, img_q, 2);  // [N, n_txt_token + n_img_token, n_head, d_head]
-            auto k = ggml_concat(ctx, txt_k, img_k, 2);  // [N, n_txt_token + n_img_token, n_head, d_head]
-            auto v = ggml_concat(ctx, txt_v, img_v, 2);  // [N, n_txt_token + n_img_token, n_head, d_head]
-
-            auto attn         = Rope::attention(ctx, backend, q, k, v, pe, mask, flash_attn, (1.0f / 128.f));  // [N, n_txt_token + n_img_token, n_head*d_head]
-            attn              = ggml_cont(ctx, ggml_permute(ctx, attn, 0, 2, 1, 3));                           // [n_txt_token + n_img_token, N, hidden_size]
-            auto txt_attn_out = ggml_view_3d(ctx,
-                                             attn,
-                                             attn->ne[0],
-                                             attn->ne[1],
-                                             txt->ne[1],
-                                             attn->nb[1],
-                                             attn->nb[2],
-                                             0);                                              // [n_txt_token, N, hidden_size]
-            txt_attn_out      = ggml_cont(ctx, ggml_permute(ctx, txt_attn_out, 0, 2, 1, 3));  // [N, n_txt_token, hidden_size]
-            auto img_attn_out = ggml_view_3d(ctx,
-                                             attn,
-                                             attn->ne[0],
-                                             attn->ne[1],
-                                             img->ne[1],
-                                             attn->nb[1],
-                                             attn->nb[2],
-                                             attn->nb[2] * txt->ne[1]);                       // [n_img_token, N, hidden_size]
-            img_attn_out      = ggml_cont(ctx, ggml_permute(ctx, img_attn_out, 0, 2, 1, 3));  // [N, n_img_token, hidden_size]
-
-            img_attn_out = to_out_0->forward(ctx, img_attn_out);
-            txt_attn_out = to_add_out->forward(ctx, txt_attn_out);
-
-            return {img_attn_out, txt_attn_out};
-        }
-    };
-
-    class QwenImageTransformerBlock : public GGMLBlock {
-    public:
-        QwenImageTransformerBlock(int64_t dim,
-                                  int64_t num_attention_heads,
-                                  int64_t attention_head_dim,
-                                  float eps       = 1e-6,
-                                  bool flash_attn = false) {
-            // img_mod.0 is nn.SiLU()
-            blocks["img_mod.1"] = std::shared_ptr<GGMLBlock>(new Linear(dim, 6 * dim, true));
-
-            blocks["img_norm1"] = std::shared_ptr<GGMLBlock>(new LayerNorm(dim, eps, false));
-            blocks["img_norm2"] = std::shared_ptr<GGMLBlock>(new LayerNorm(dim, eps, false));
-            blocks["img_mlp"]   = std::shared_ptr<GGMLBlock>(new FeedForward(dim, dim, 4, FeedForward::Activation::GELU, true));
-
-            // txt_mod.0 is nn.SiLU()
-            blocks["txt_mod.1"] = std::shared_ptr<GGMLBlock>(new Linear(dim, 6 * dim, true));
-
-            blocks["txt_norm1"] = std::shared_ptr<GGMLBlock>(new LayerNorm(dim, eps, false));
-            blocks["txt_norm2"] = std::shared_ptr<GGMLBlock>(new LayerNorm(dim, eps, false));
-            blocks["txt_mlp"]   = std::shared_ptr<GGMLBlock>(new FeedForward(dim, dim, 4, FeedForward::Activation::GELU));
-
-            blocks["attn"] = std::shared_ptr<GGMLBlock>(new QwenImageAttention(dim,
-                                                                               attention_head_dim,
-                                                                               num_attention_heads,
-                                                                               0,     // out_dim
-                                                                               0,     // out_context-dim
-                                                                               true,  // bias
-                                                                               true,  // out_bias
-                                                                               eps,
-                                                                               flash_attn));
-        }
-
-        virtual std::pair<ggml_tensor*, ggml_tensor*> forward(struct ggml_context* ctx,
-                                                              ggml_backend_t backend,
-                                                              struct ggml_tensor* img,
-                                                              struct ggml_tensor* txt,
-                                                              struct ggml_tensor* t_emb,
-                                                              struct ggml_tensor* pe) {
-            // img: [N, n_img_token, hidden_size]
-            // txt: [N, n_txt_token, hidden_size]
-            // pe: [n_img_token + n_txt_token, d_head/2, 2, 2]
-            // return: ([N, n_img_token, hidden_size], [N, n_txt_token, hidden_size])
-
-            auto img_mod_1 = std::dynamic_pointer_cast<Linear>(blocks["img_mod.1"]);
-            auto img_norm1 = std::dynamic_pointer_cast<LayerNorm>(blocks["img_norm1"]);
-            auto img_norm2 = std::dynamic_pointer_cast<LayerNorm>(blocks["img_norm2"]);
-            auto img_mlp   = std::dynamic_pointer_cast<FeedForward>(blocks["img_mlp"]);
-
-            auto txt_mod_1 = std::dynamic_pointer_cast<Linear>(blocks["txt_mod.1"]);
-            auto txt_norm1 = std::dynamic_pointer_cast<LayerNorm>(blocks["txt_norm1"]);
-            auto txt_norm2 = std::dynamic_pointer_cast<LayerNorm>(blocks["txt_norm2"]);
-            auto txt_mlp   = std::dynamic_pointer_cast<FeedForward>(blocks["txt_mlp"]);
-
-            auto attn = std::dynamic_pointer_cast<QwenImageAttention>(blocks["attn"]);
-
-            auto img_mod_params    = ggml_silu(ctx, t_emb);
-            img_mod_params         = img_mod_1->forward(ctx, img_mod_params);
-            auto img_mod_param_vec = ggml_chunk(ctx, img_mod_params, 6, 0);
-
-            auto txt_mod_params    = ggml_silu(ctx, t_emb);
-            txt_mod_params         = txt_mod_1->forward(ctx, txt_mod_params);
-            auto txt_mod_param_vec = ggml_chunk(ctx, txt_mod_params, 6, 0);
-
-            auto img_normed    = img_norm1->forward(ctx, img);
-            auto img_modulated = Flux::modulate(ctx, img_normed, img_mod_param_vec[0], img_mod_param_vec[1]);
-            auto img_gate1     = img_mod_param_vec[2];
-
-            auto txt_normed    = txt_norm1->forward(ctx, txt);
-            auto txt_modulated = Flux::modulate(ctx, txt_normed, txt_mod_param_vec[0], txt_mod_param_vec[1]);
-            auto txt_gate1     = txt_mod_param_vec[2];
-
-            auto [img_attn_output, txt_attn_output] = attn->forward(ctx, backend, img_modulated, txt_modulated, pe);
-
-            img = ggml_add(ctx, img, ggml_mul(ctx, img_attn_output, img_gate1));
-            txt = ggml_add(ctx, txt, ggml_mul(ctx, txt_attn_output, txt_gate1));
-
-            auto img_normed2    = img_norm2->forward(ctx, img);
-            auto img_modulated2 = Flux::modulate(ctx, img_normed2, img_mod_param_vec[3], img_mod_param_vec[4]);
-            auto img_gate2      = img_mod_param_vec[5];
-
-            auto txt_normed2    = txt_norm2->forward(ctx, txt);
-            auto txt_modulated2 = Flux::modulate(ctx, txt_normed2, txt_mod_param_vec[3], txt_mod_param_vec[4]);
-            auto txt_gate2      = txt_mod_param_vec[5];
-
-            auto img_mlp_out = img_mlp->forward(ctx, img_modulated2);
-            auto txt_mlp_out = txt_mlp->forward(ctx, txt_modulated2);
-
-            img = ggml_add(ctx, img, ggml_mul(ctx, img_mlp_out, img_gate2));
-            txt = ggml_add(ctx, txt, ggml_mul(ctx, txt_mlp_out, txt_gate2));
-
-            return {img, txt};
-        }
-    };
-
-    struct AdaLayerNormContinuous : public GGMLBlock {
-    public:
-        AdaLayerNormContinuous(int64_t embedding_dim,
-                               int64_t conditioning_embedding_dim,
-                               bool elementwise_affine = true,
-                               float eps               = 1e-5f,
-                               bool bias               = true) {
-            blocks["norm"]   = std::shared_ptr<GGMLBlock>(new LayerNorm(conditioning_embedding_dim, eps, elementwise_affine, bias));
-            blocks["linear"] = std::shared_ptr<GGMLBlock>(new Linear(conditioning_embedding_dim, embedding_dim * 2, bias));
-        }
-
-        struct ggml_tensor* forward(struct ggml_context* ctx,
-                                    struct ggml_tensor* x,
-                                    struct ggml_tensor* c) {
-            // x: [N, n_token, hidden_size]
-            // c: [N, hidden_size]
-            // return: [N, n_token, patch_size * patch_size * out_channels]
-
-            auto norm   = std::dynamic_pointer_cast<LayerNorm>(blocks["norm"]);
-            auto linear = std::dynamic_pointer_cast<Linear>(blocks["linear"]);
-
-            auto emb   = linear->forward(ctx, ggml_silu(ctx, c));
-            auto mods  = ggml_chunk(ctx, emb, 2, 0);
-            auto scale = mods[0];
-            auto shift = mods[1];
-
-            x = norm->forward(ctx, x);
-            x = Flux::modulate(ctx, x, shift, scale);
-
-            return x;
-        }
-    };
-
-    struct QwenImageParams {
-        int64_t patch_size          = 2;
-        int64_t in_channels         = 64;
-        int64_t out_channels        = 16;
-        int64_t num_layers          = 60;
-        int64_t attention_head_dim  = 128;
-        int64_t num_attention_heads = 24;
-        int64_t joint_attention_dim = 3584;
-        float theta                 = 10000;
-        std::vector<int> axes_dim   = {16, 56, 56};
-        int64_t axes_dim_sum        = 128;
-        bool flash_attn             = false;
-    };
-
-    class QwenImageModel : public GGMLBlock {
-    protected:
-        QwenImageParams params;
-
-    public:
-        QwenImageModel() {}
-        QwenImageModel(QwenImageParams params)
-            : params(params) {
-            int64_t inner_dim         = params.num_attention_heads * params.attention_head_dim;
-            blocks["time_text_embed"] = std::shared_ptr<GGMLBlock>(new QwenTimestepProjEmbeddings(inner_dim));
-            blocks["txt_norm"]        = std::shared_ptr<GGMLBlock>(new RMSNorm(params.joint_attention_dim, 1e-6f));
-            blocks["img_in"]          = std::shared_ptr<GGMLBlock>(new Linear(params.in_channels, inner_dim));
-            blocks["txt_in"]          = std::shared_ptr<GGMLBlock>(new Linear(params.joint_attention_dim, inner_dim));
-
-            // blocks
-            for (int i = 0; i < params.num_layers; i++) {
-                auto block                                        = std::shared_ptr<GGMLBlock>(new QwenImageTransformerBlock(inner_dim,
-                                                                                                                             params.num_attention_heads,
-                                                                                                                             params.attention_head_dim,
-                                                                                                                             1e-6f,
-                                                                                                                             params.flash_attn));
-                blocks["transformer_blocks." + std::to_string(i)] = block;
-            }
-
-            blocks["norm_out"] = std::shared_ptr<GGMLBlock>(new AdaLayerNormContinuous(inner_dim, inner_dim, false, 1e-6f));
-            blocks["proj_out"] = std::shared_ptr<GGMLBlock>(new Linear(inner_dim, params.patch_size * params.patch_size * params.out_channels));
-        }
-
-        struct ggml_tensor* pad_to_patch_size(struct ggml_context* ctx,
-                                              struct ggml_tensor* x) {
-            int64_t W = x->ne[0];
-            int64_t H = x->ne[1];
-
-            int pad_h = (params.patch_size - H % params.patch_size) % params.patch_size;
-            int pad_w = (params.patch_size - W % params.patch_size) % params.patch_size;
-            x         = ggml_pad(ctx, x, pad_w, pad_h, 0, 0);  // [N, C, H + pad_h, W + pad_w]
-            return x;
-        }
-
-        struct ggml_tensor* patchify(struct ggml_context* ctx,
-                                     struct ggml_tensor* x) {
-            // x: [N, C, H, W]
-            // return: [N, h*w, C * patch_size * patch_size]
-            int64_t N = x->ne[3];
-            int64_t C = x->ne[2];
-            int64_t H = x->ne[1];
-            int64_t W = x->ne[0];
-            int64_t p = params.patch_size;
-            int64_t h = H / params.patch_size;
-            int64_t w = W / params.patch_size;
-
-            GGML_ASSERT(h * p == H && w * p == W);
-
-            x = ggml_reshape_4d(ctx, x, p, w, p, h * C * N);       // [N*C*h, p, w, p]
-            x = ggml_cont(ctx, ggml_permute(ctx, x, 0, 2, 1, 3));  // [N*C*h, w, p, p]
-            x = ggml_reshape_4d(ctx, x, p * p, w * h, C, N);       // [N, C, h*w, p*p]
-            x = ggml_cont(ctx, ggml_permute(ctx, x, 0, 2, 1, 3));  // [N, h*w, C, p*p]
-            x = ggml_reshape_3d(ctx, x, p * p * C, w * h, N);      // [N, h*w, C*p*p]
-            return x;
-        }
-
-        struct ggml_tensor* process_img(struct ggml_context* ctx,
-                                        struct ggml_tensor* x) {
-            x = pad_to_patch_size(ctx, x);
-            x = patchify(ctx, x);
-            return x;
-        }
-
-        struct ggml_tensor* unpatchify(struct ggml_context* ctx,
-                                       struct ggml_tensor* x,
-                                       int64_t h,
-                                       int64_t w) {
-            // x: [N, h*w, C*patch_size*patch_size]
-            // return: [N, C, H, W]
-            int64_t N = x->ne[2];
-            int64_t C = x->ne[0] / params.patch_size / params.patch_size;
-            int64_t H = h * params.patch_size;
-            int64_t W = w * params.patch_size;
-            int64_t p = params.patch_size;
-
-            GGML_ASSERT(C * p * p == x->ne[0]);
-
-            x = ggml_reshape_4d(ctx, x, p * p, C, w * h, N);       // [N, h*w, C, p*p]
-            x = ggml_cont(ctx, ggml_permute(ctx, x, 0, 2, 1, 3));  // [N, C, h*w, p*p]
-            x = ggml_reshape_4d(ctx, x, p, p, w, h * C * N);       // [N*C*h, w, p, p]
-            x = ggml_cont(ctx, ggml_permute(ctx, x, 0, 2, 1, 3));  // [N*C*h, p, w, p]
-            x = ggml_reshape_4d(ctx, x, W, H, C, N);               // [N, C, h*p, w*p]
-
-            return x;
-        }
-
-        struct ggml_tensor* forward_orig(struct ggml_context* ctx,
-                                         ggml_backend_t backend,
-                                         struct ggml_tensor* x,
-                                         struct ggml_tensor* timestep,
-                                         struct ggml_tensor* context,
-                                         struct ggml_tensor* pe) {
-            auto time_text_embed = std::dynamic_pointer_cast<QwenTimestepProjEmbeddings>(blocks["time_text_embed"]);
-            auto txt_norm        = std::dynamic_pointer_cast<RMSNorm>(blocks["txt_norm"]);
-            auto img_in          = std::dynamic_pointer_cast<Linear>(blocks["img_in"]);
-            auto txt_in          = std::dynamic_pointer_cast<Linear>(blocks["txt_in"]);
-            auto norm_out        = std::dynamic_pointer_cast<AdaLayerNormContinuous>(blocks["norm_out"]);
-            auto proj_out        = std::dynamic_pointer_cast<Linear>(blocks["proj_out"]);
-
-            auto t_emb = time_text_embed->forward(ctx, timestep);
-            auto img   = img_in->forward(ctx, x);
-            auto txt   = txt_norm->forward(ctx, context);
-            txt        = txt_in->forward(ctx, txt);
-
-            for (int i = 0; i < params.num_layers; i++) {
-                auto block = std::dynamic_pointer_cast<QwenImageTransformerBlock>(blocks["transformer_blocks." + std::to_string(i)]);
-
-                auto result = block->forward(ctx, backend, img, txt, t_emb, pe);
-                img         = result.first;
-                txt         = result.second;
-            }
-
-            img = norm_out->forward(ctx, img, t_emb);
-            img = proj_out->forward(ctx, img);
-
-            return img;
-        }
-
-        struct ggml_tensor* forward(struct ggml_context* ctx,
-                                    ggml_backend_t backend,
-                                    struct ggml_tensor* x,
-                                    struct ggml_tensor* timestep,
-                                    struct ggml_tensor* context,
-                                    struct ggml_tensor* pe,
-                                    std::vector<ggml_tensor*> ref_latents = {}) {
-            // Forward pass of DiT.
-            // x: [N, C, H, W]
-            // timestep: [N,]
-            // context: [N, L, D]
-            // pe: [L, d_head/2, 2, 2]
-            // return: [N, C, H, W]
-
-            int64_t W = x->ne[0];
-            int64_t H = x->ne[1];
-            int64_t C = x->ne[2];
-            int64_t N = x->ne[3];
-
-            auto img            = process_img(ctx, x);
-            uint64_t img_tokens = img->ne[1];
-
-            if (ref_latents.size() > 0) {
-                for (ggml_tensor* ref : ref_latents) {
-                    ref = process_img(ctx, ref);
-                    img = ggml_concat(ctx, img, ref, 1);
-                }
-            }
-
-            int64_t h_len = ((H + (params.patch_size / 2)) / params.patch_size);
-            int64_t w_len = ((W + (params.patch_size / 2)) / params.patch_size);
-
-            auto out = forward_orig(ctx, backend, img, timestep, context, pe);  // [N, h_len*w_len, ph*pw*C]
-
-            if (out->ne[1] > img_tokens) {
-                out = ggml_cont(ctx, ggml_permute(ctx, out, 0, 2, 1, 3));  // [num_tokens, N, C * patch_size * patch_size]
-                out = ggml_view_3d(ctx, out, out->ne[0], out->ne[1], img_tokens, out->nb[1], out->nb[2], 0);
-                out = ggml_cont(ctx, ggml_permute(ctx, out, 0, 2, 1, 3));  // [N, h*w, C * patch_size * patch_size]
-            }
-
-            out = unpatchify(ctx, out, h_len, w_len);  // [N, C, H + pad_h, W + pad_w]
-
-            // slice
-            out = ggml_slice(ctx, out, 1, 0, H);  // [N, C, H, W + pad_w]
-            out = ggml_slice(ctx, out, 0, 0, W);  // [N, C, H, W]
-
-            return out;
-        }
-    };
-
-    struct QwenImageRunner : public GGMLRunner {
-    public:
-        QwenImageParams qwen_image_params;
-        QwenImageModel qwen_image;
-        std::vector<float> pe_vec;
-        SDVersion version;
-
-        QwenImageRunner(ggml_backend_t backend,
-                        bool offload_params_to_cpu,
-                        const String2GGMLType& tensor_types = {},
-                        const std::string prefix            = "",
-                        SDVersion version                   = VERSION_QWEN_IMAGE,
-                        bool flash_attn                     = false)
-            : GGMLRunner(backend, offload_params_to_cpu) {
-            qwen_image_params.flash_attn = flash_attn;
-            qwen_image_params.num_layers = 0;
-            for (auto pair : tensor_types) {
-                std::string tensor_name = pair.first;
-                if (tensor_name.find(prefix) == std::string::npos)
-                    continue;
-                size_t pos = tensor_name.find("transformer_blocks.");
-                if (pos != std::string::npos) {
-                    tensor_name = tensor_name.substr(pos);  // remove prefix
-                    auto items  = split_string(tensor_name, '.');
-                    if (items.size() > 1) {
-                        int block_index = atoi(items[1].c_str());
-                        if (block_index + 1 > qwen_image_params.num_layers) {
-                            qwen_image_params.num_layers = block_index + 1;
-                        }
-                    }
-                    continue;
-                }
-            }
-            LOG_ERROR("qwen_image_params.num_layers: %ld", qwen_image_params.num_layers);
-            qwen_image                   = QwenImageModel(qwen_image_params);
-            qwen_image.init(params_ctx, tensor_types, prefix);
-        }
-
-        std::string get_desc() {
-            return "qwen_image";
-        }
-
-        void get_param_tensors(std::map<std::string, struct ggml_tensor*>& tensors, const std::string prefix) {
-            qwen_image.get_param_tensors(tensors, prefix);
-        }
-
-        struct ggml_cgraph* build_graph(struct ggml_tensor* x,
-                                        struct ggml_tensor* timesteps,
-                                        struct ggml_tensor* context,
-                                        std::vector<ggml_tensor*> ref_latents = {},
-                                        bool increase_ref_index               = false) {
-            GGML_ASSERT(x->ne[3] == 1);
-            struct ggml_cgraph* gf = ggml_new_graph_custom(compute_ctx, QWEN_IMAGE_GRAPH_SIZE, false);
-
-            x         = to_backend(x);
-            context   = to_backend(context);
-            timesteps = to_backend(timesteps);
-
-            for (int i = 0; i < ref_latents.size(); i++) {
-                ref_latents[i] = to_backend(ref_latents[i]);
-            }
-
-            pe_vec      = Rope::gen_qwen_image_pe(x->ne[1],
-                                                  x->ne[0],
-                                                  qwen_image_params.patch_size,
-                                                  x->ne[3],
-                                                  context->ne[1],
-                                                  ref_latents,
-                                                  increase_ref_index,
-                                                  qwen_image_params.theta,
-                                                  qwen_image_params.axes_dim);
-            int pos_len = pe_vec.size() / qwen_image_params.axes_dim_sum / 2;
-            // LOG_DEBUG("pos_len %d", pos_len);
-            auto pe = ggml_new_tensor_4d(compute_ctx, GGML_TYPE_F32, 2, 2, qwen_image_params.axes_dim_sum / 2, pos_len);
-            // pe->data = pe_vec.data();
-            // print_ggml_tensor(pe, true, "pe");
-            // pe->data = NULL;
-            set_backend_tensor_data(pe, pe_vec.data());
-
-            struct ggml_tensor* out = qwen_image.forward(compute_ctx,
-                                                         runtime_backend,
-                                                         x,
-                                                         timesteps,
-                                                         context,
-                                                         pe,
-                                                         ref_latents);
-
-            ggml_build_forward_expand(gf, out);
-
-            return gf;
-        }
-
-        void compute(int n_threads,
-                     struct ggml_tensor* x,
-                     struct ggml_tensor* timesteps,
-                     struct ggml_tensor* context,
-                     std::vector<ggml_tensor*> ref_latents = {},
-                     bool increase_ref_index               = false,
-                     struct ggml_tensor** output           = NULL,
-                     struct ggml_context* output_ctx       = NULL) {
-            // x: [N, in_channels, h, w]
-            // timesteps: [N, ]
-            // context: [N, max_position, hidden_size]
-            auto get_graph = [&]() -> struct ggml_cgraph* {
-                return build_graph(x, timesteps, context, ref_latents, increase_ref_index);
-            };
-
-            GGMLRunner::compute(get_graph, n_threads, false, output, output_ctx);
-        }
-
-        void test() {
-            struct ggml_init_params params;
-            params.mem_size   = static_cast<size_t>(1024 * 1024) * 1024;  // 1GB
-            params.mem_buffer = NULL;
-            params.no_alloc   = false;
-
-            struct ggml_context* work_ctx = ggml_init(params);
-            GGML_ASSERT(work_ctx != NULL);
-
-            {
-                // auto x = ggml_new_tensor_4d(work_ctx, GGML_TYPE_F32, 16, 16, 16, 1);
-                // ggml_set_f32(x, 0.01f);
-                auto x = load_tensor_from_file(work_ctx, "./qwen_image_x.bin");
-                print_ggml_tensor(x);
-
-                std::vector<float> timesteps_vec(1, 1000.f);
-                auto timesteps = vector_to_ggml_tensor(work_ctx, timesteps_vec);
-
-                // auto context = ggml_new_tensor_3d(work_ctx, GGML_TYPE_F32, 3584, 256, 1);
-                // ggml_set_f32(context, 0.01f);
-                auto context = load_tensor_from_file(work_ctx, "./qwen_image_context.bin");
-                print_ggml_tensor(context);
-
-                struct ggml_tensor* out = NULL;
-
-                int t0 = ggml_time_ms();
-                compute(8, x, timesteps, context, {}, false, &out, work_ctx);
-                int t1 = ggml_time_ms();
-
-                print_ggml_tensor(out);
-                LOG_DEBUG("qwen_image test done in %dms", t1 - t0);
-            }
-        }
-
-        static void load_from_file_and_test(const std::string& file_path) {
-            // cuda q8: pass
-            // cuda q8 fa: nan
-            // ggml_backend_t backend    = ggml_backend_cuda_init(0);
-            ggml_backend_t backend    = ggml_backend_cpu_init();
-            ggml_type model_data_type = GGML_TYPE_Q8_0;
-
-            ModelLoader model_loader;
-            if (!model_loader.init_from_file(file_path, "model.diffusion_model.")) {
-                LOG_ERROR("init model loader from file failed: '%s'", file_path.c_str());
-                return;
-            }
-
-            auto tensor_types = model_loader.tensor_storages_types;
-            for (auto& item : tensor_types) {
-                // LOG_DEBUG("%s %u", item.first.c_str(), item.second);
-                if (ends_with(item.first, "weight")) {
-                    item.second = model_data_type;
-                }
-            }
-
-            std::shared_ptr<QwenImageRunner> qwen_image = std::shared_ptr<QwenImageRunner>(new QwenImageRunner(backend,
-                                                                                                               false,
-                                                                                                               tensor_types,
-                                                                                                               "model.diffusion_model",
-                                                                                                               VERSION_QWEN_IMAGE,
-                                                                                                               true));
-
-            qwen_image->alloc_params_buffer();
-            std::map<std::string, ggml_tensor*> tensors;
-            qwen_image->get_param_tensors(tensors, "model.diffusion_model");
-
-            bool success = model_loader.load_tensors(tensors);
-
-            if (!success) {
-                LOG_ERROR("load tensors from model loader failed");
-                return;
-            }
-
-            LOG_INFO("qwen_image model loaded");
-            qwen_image->test();
-        }
-    };
-
-}  // namespace name
-
-#endif  // __QWEN_IMAGE_HPP__

rope.hpp

@@ -4,9 +4,9 @@
 #include <vector>
 #include "ggml_extend.hpp"
 
-namespace Rope {
+struct Rope {
     template <class T>
-    __STATIC_INLINE__ std::vector<T> linspace(T start, T end, int num) {
+    static std::vector<T> linspace(T start, T end, int num) {
         std::vector<T> result(num);
         if (num == 1) {
             result[0] = start;
@@ -19,7 +19,7 @@ namespace Rope {
         return result;
     }
 
-    __STATIC_INLINE__ std::vector<std::vector<float>> transpose(const std::vector<std::vector<float>>& mat) {
+    static std::vector<std::vector<float>> transpose(const std::vector<std::vector<float>>& mat) {
         int rows = mat.size();
         int cols = mat[0].size();
         std::vector<std::vector<float>> transposed(cols, std::vector<float>(rows));
@@ -31,7 +31,7 @@ namespace Rope {
         return transposed;
     }
 
-    __STATIC_INLINE__ std::vector<float> flatten(const std::vector<std::vector<float>>& vec) {
+    static std::vector<float> flatten(const std::vector<std::vector<float>>& vec) {
         std::vector<float> flat_vec;
         for (const auto& sub_vec : vec) {
             flat_vec.insert(flat_vec.end(), sub_vec.begin(), sub_vec.end());
@@ -39,7 +39,7 @@ namespace Rope {
         return flat_vec;
     }
 
-    __STATIC_INLINE__ std::vector<std::vector<float>> rope(const std::vector<float>& pos, int dim, int theta) {
+    static std::vector<std::vector<float>> rope(const std::vector<float>& pos, int dim, int theta) {
         assert(dim % 2 == 0);
         int half_dim = dim / 2;
 
@@ -72,11 +72,11 @@ namespace Rope {
     }
 
     // Generate IDs for image patches and text
-    __STATIC_INLINE__ std::vector<std::vector<float>> gen_txt_ids(int bs, int context_len) {
+    static std::vector<std::vector<float>> gen_txt_ids(int bs, int context_len) {
         return std::vector<std::vector<float>>(bs * context_len, std::vector<float>(3, 0.0));
     }
 
-    __STATIC_INLINE__ std::vector<std::vector<float>> gen_img_ids(int h, int w, int patch_size, int bs, int index = 0, int h_offset = 0, int w_offset = 0) {
+    static std::vector<std::vector<float>> gen_img_ids(int h, int w, int patch_size, int bs, int index = 0, int h_offset = 0, int w_offset = 0) {
         int h_len = (h + (patch_size / 2)) / patch_size;
         int w_len = (w + (patch_size / 2)) / patch_size;
 
@@ -102,9 +102,9 @@ namespace Rope {
         return img_ids_repeated;
     }
 
-    __STATIC_INLINE__ std::vector<std::vector<float>> concat_ids(const std::vector<std::vector<float>>& a,
-                                                                 const std::vector<std::vector<float>>& b,
-                                                                 int bs) {
+    static std::vector<std::vector<float>> concat_ids(const std::vector<std::vector<float>>& a,
+                                                      const std::vector<std::vector<float>>& b,
+                                                      int bs) {
         size_t a_len = a.size() / bs;
         size_t b_len = b.size() / bs;
         std::vector<std::vector<float>> ids(a.size() + b.size(), std::vector<float>(3));
@@ -119,10 +119,10 @@ namespace Rope {
         return ids;
     }
 
-    __STATIC_INLINE__ std::vector<float> embed_nd(const std::vector<std::vector<float>>& ids,
-                                                  int bs,
-                                                  int theta,
-                                                  const std::vector<int>& axes_dim) {
+    static std::vector<float> embed_nd(const std::vector<std::vector<float>>& ids,
+                                       int bs,
+                                       int theta,
+                                       const std::vector<int>& axes_dim) {
         std::vector<std::vector<float>> trans_ids = transpose(ids);
         size_t pos_len                            = ids.size() / bs;
         int num_axes                              = axes_dim.size();
@@ -151,11 +151,17 @@ namespace Rope {
         return flatten(emb);
     }
 
-    __STATIC_INLINE__ std::vector<std::vector<float>> gen_refs_ids(int patch_size,
-                                                                   int bs,
-                                                                   const std::vector<ggml_tensor*>& ref_latents,
-                                                                   bool increase_ref_index) {
-        std::vector<std::vector<float>> ids;
+    static std::vector<std::vector<float>> gen_flux_ids(int h,
+                                                        int w,
+                                                        int patch_size,
+                                                        int bs,
+                                                        int context_len,
+                                                        std::vector<ggml_tensor*> ref_latents,
+                                                        bool increase_ref_index) {
+        auto txt_ids = gen_txt_ids(bs, context_len);
+        auto img_ids = gen_img_ids(h, w, patch_size, bs);
+
+        auto ids               = concat_ids(txt_ids, img_ids, bs);
         uint64_t curr_h_offset = 0;
         uint64_t curr_w_offset = 0;
         int index              = 1;
@@ -183,88 +189,30 @@ namespace Rope {
         return ids;
     }
 
-    __STATIC_INLINE__ std::vector<std::vector<float>> gen_flux_ids(int h,
-                                                                   int w,
-                                                                   int patch_size,
-                                                                   int bs,
-                                                                   int context_len,
-                                                                   const std::vector<ggml_tensor*>& ref_latents,
-                                                                   bool increase_ref_index) {
-        auto txt_ids = gen_txt_ids(bs, context_len);
-        auto img_ids = gen_img_ids(h, w, patch_size, bs);
-
-        auto ids = concat_ids(txt_ids, img_ids, bs);
-        if (ref_latents.size() > 0) {
-            auto refs_ids = gen_refs_ids(patch_size, bs, ref_latents, increase_ref_index);
-            ids           = concat_ids(ids, refs_ids, bs);
-        }
-        return ids;
-    }
-
     // Generate flux positional embeddings
-    __STATIC_INLINE__ std::vector<float> gen_flux_pe(int h,
-                                                     int w,
-                                                     int patch_size,
-                                                     int bs,
-                                                     int context_len,
-                                                     const std::vector<ggml_tensor*>& ref_latents,
-                                                     bool increase_ref_index,
-                                                     int theta,
-                                                     const std::vector<int>& axes_dim) {
+    static std::vector<float> gen_flux_pe(int h,
+                                          int w,
+                                          int patch_size,
+                                          int bs,
+                                          int context_len,
+                                          std::vector<ggml_tensor*> ref_latents,
+                                          bool increase_ref_index,
+                                          int theta,
+                                          const std::vector<int>& axes_dim) {
         std::vector<std::vector<float>> ids = gen_flux_ids(h, w, patch_size, bs, context_len, ref_latents, increase_ref_index);
         return embed_nd(ids, bs, theta, axes_dim);
     }
 
-    __STATIC_INLINE__ std::vector<std::vector<float>> gen_qwen_image_ids(int h,
-                                                                         int w,
-                                                                         int patch_size,
-                                                                         int bs,
-                                                                         int context_len,
-                                                                         const std::vector<ggml_tensor*>& ref_latents,
-                                                                         bool increase_ref_index) {
-        int h_len        = (h + (patch_size / 2)) / patch_size;
-        int w_len        = (w + (patch_size / 2)) / patch_size;
-        int txt_id_start = std::max(h_len, w_len);
-        auto txt_ids     = linspace<float>(txt_id_start, context_len + txt_id_start, context_len);
-        std::vector<std::vector<float>> txt_ids_repeated(bs * context_len, std::vector<float>(3));
-        for (int i = 0; i < bs; ++i) {
-            for (int j = 0; j < txt_ids.size(); ++j) {
-                txt_ids_repeated[i * txt_ids.size() + j] = {txt_ids[j], txt_ids[j], txt_ids[j]};
-            }
-        }
-        auto img_ids = gen_img_ids(h, w, patch_size, bs);
-        auto ids     = concat_ids(txt_ids_repeated, img_ids, bs);
-        if (ref_latents.size() > 0) {
-            auto refs_ids = gen_refs_ids(patch_size, bs, ref_latents, increase_ref_index);
-            ids           = concat_ids(ids, refs_ids, bs);
-        }
-        return ids;
-    }
-
-    // Generate qwen_image positional embeddings
-    __STATIC_INLINE__ std::vector<float> gen_qwen_image_pe(int h,
-                                                           int w,
-                                                           int patch_size,
-                                                           int bs,
-                                                           int context_len,
-                                                           const std::vector<ggml_tensor*>& ref_latents,
-                                                           bool increase_ref_index,
-                                                           int theta,
-                                                           const std::vector<int>& axes_dim) {
-        std::vector<std::vector<float>> ids = gen_qwen_image_ids(h, w, patch_size, bs, context_len, ref_latents, increase_ref_index);
-        return embed_nd(ids, bs, theta, axes_dim);
-    }
-
-    __STATIC_INLINE__ std::vector<std::vector<float>> gen_vid_ids(int t,
-                                                                  int h,
-                                                                  int w,
-                                                                  int pt,
-                                                                  int ph,
-                                                                  int pw,
-                                                                  int bs,
-                                                                  int t_offset = 0,
-                                                                  int h_offset = 0,
-                                                                  int w_offset = 0) {
+    static std::vector<std::vector<float>> gen_vid_ids(int t,
+                                                       int h,
+                                                       int w,
+                                                       int pt,
+                                                       int ph,
+                                                       int pw,
+                                                       int bs,
+                                                       int t_offset = 0,
+                                                       int h_offset = 0,
+                                                       int w_offset = 0) {
         int t_len = (t + (pt / 2)) / pt;
         int h_len = (h + (ph / 2)) / ph;
         int w_len = (w + (pw / 2)) / pw;
@@ -296,115 +244,18 @@ namespace Rope {
     }
 
     // Generate wan positional embeddings
-    __STATIC_INLINE__ std::vector<float> gen_wan_pe(int t,
-                                                    int h,
-                                                    int w,
-                                                    int pt,
-                                                    int ph,
-                                                    int pw,
-                                                    int bs,
-                                                    int theta,
-                                                    const std::vector<int>& axes_dim) {
+    static std::vector<float> gen_wan_pe(int t,
+                                         int h,
+                                         int w,
+                                         int pt,
+                                         int ph,
+                                         int pw,
+                                         int bs,
+                                         int theta,
+                                         const std::vector<int>& axes_dim) {
         std::vector<std::vector<float>> ids = gen_vid_ids(t, h, w, pt, ph, pw, bs);
         return embed_nd(ids, bs, theta, axes_dim);
     }
-
-    __STATIC_INLINE__ std::vector<std::vector<float>> gen_qwen2vl_ids(int grid_h,
-                                                                      int grid_w,
-                                                                      int merge_size,
-                                                                      const std::vector<int>& window_index) {
-        std::vector<std::vector<float>> ids(grid_h * grid_w, std::vector<float>(2, 0.0));
-        int index = 0;
-        for (int ih = 0; ih < grid_h; ih += merge_size) {
-            for (int iw = 0; iw < grid_w; iw += merge_size) {
-                for (int iy = 0; iy < merge_size; iy++) {
-                    for (int ix = 0; ix < merge_size; ix++) {
-                        int inverse_index = window_index[index / (merge_size * merge_size)];
-                        int i             = inverse_index * (merge_size * merge_size) + index % (merge_size * merge_size);
-
-                        GGML_ASSERT(i < grid_h * grid_w);
-
-                        ids[i][0] = ih + iy;
-                        ids[i][1] = iw + ix;
-                        index++;
-                    }
-                }
-            }
-        }
-        return ids;
-    }
-
-    // Generate qwen2vl positional embeddings
-    __STATIC_INLINE__ std::vector<float> gen_qwen2vl_pe(int grid_h,
-                                                        int grid_w,
-                                                        int merge_size,
-                                                        const std::vector<int>& window_index,
-                                                        int theta,
-                                                        const std::vector<int>& axes_dim) {
-        std::vector<std::vector<float>> ids = gen_qwen2vl_ids(grid_h, grid_w, merge_size, window_index);
-        return embed_nd(ids, 1, theta, axes_dim);
-    }
-
-    __STATIC_INLINE__ struct ggml_tensor* apply_rope(struct ggml_context* ctx,
-                                                     struct ggml_tensor* x,
-                                                     struct ggml_tensor* pe,
-                                                     bool rope_interleaved = true) {
-        // x: [N, L, n_head, d_head]
-        // pe: [L, d_head/2, 2, 2], [[cos, -sin], [sin, cos]]
-        int64_t d_head = x->ne[0];
-        int64_t n_head = x->ne[1];
-        int64_t L      = x->ne[2];
-        int64_t N      = x->ne[3];
-        x              = ggml_cont(ctx, ggml_permute(ctx, x, 0, 2, 1, 3));  // [N, n_head, L, d_head]
-        if (rope_interleaved) {
-            x = ggml_reshape_4d(ctx, x, 2, d_head / 2, L, n_head * N);  // [N * n_head, L, d_head/2, 2]
-            x = ggml_cont(ctx, ggml_permute(ctx, x, 3, 0, 1, 2));       // [2, N * n_head, L, d_head/2]
-        } else {
-            x = ggml_reshape_4d(ctx, x, d_head / 2, 2, L, n_head * N);   // [N * n_head, L, 2, d_head/2]
-            x = ggml_cont(ctx, ggml_torch_permute(ctx, x, 0, 2, 3, 1));  // [2, N * n_head, L, d_head/2]
-        }
-
-        int64_t offset = x->nb[2] * x->ne[2];
-        auto x_0       = ggml_view_3d(ctx, x, x->ne[0], x->ne[1], x->ne[2], x->nb[1], x->nb[2], offset * 0);  // [N * n_head, L, d_head/2]
-        auto x_1       = ggml_view_3d(ctx, x, x->ne[0], x->ne[1], x->ne[2], x->nb[1], x->nb[2], offset * 1);  // [N * n_head, L, d_head/2]
-        x_0            = ggml_reshape_4d(ctx, x_0, 1, x_0->ne[0], x_0->ne[1], x_0->ne[2]);                    // [N * n_head, L, d_head/2, 1]
-        x_1            = ggml_reshape_4d(ctx, x_1, 1, x_1->ne[0], x_1->ne[1], x_1->ne[2]);                    // [N * n_head, L, d_head/2, 1]
-        auto temp_x    = ggml_new_tensor_4d(ctx, x_0->type, 2, x_0->ne[1], x_0->ne[2], x_0->ne[3]);
-        x_0            = ggml_repeat(ctx, x_0, temp_x);  // [N * n_head, L, d_head/2, 2]
-        x_1            = ggml_repeat(ctx, x_1, temp_x);  // [N * n_head, L, d_head/2, 2]
-
-        pe        = ggml_cont(ctx, ggml_permute(ctx, pe, 3, 0, 1, 2));  // [2, L, d_head/2, 2]
-        offset    = pe->nb[2] * pe->ne[2];
-        auto pe_0 = ggml_view_3d(ctx, pe, pe->ne[0], pe->ne[1], pe->ne[2], pe->nb[1], pe->nb[2], offset * 0);  // [L, d_head/2, 2]
-        auto pe_1 = ggml_view_3d(ctx, pe, pe->ne[0], pe->ne[1], pe->ne[2], pe->nb[1], pe->nb[2], offset * 1);  // [L, d_head/2, 2]
-
-        auto x_out = ggml_add_inplace(ctx, ggml_mul(ctx, x_0, pe_0), ggml_mul(ctx, x_1, pe_1));  // [N * n_head, L, d_head/2, 2]
-        if (!rope_interleaved) {
-            x_out = ggml_cont(ctx, ggml_permute(ctx, x_out, 1, 0, 2, 3));  // [N * n_head, L, x, d_head/2]
-        }
-        x_out = ggml_reshape_3d(ctx, x_out, d_head, L, n_head * N);  // [N*n_head, L, d_head]
-        return x_out;
-    }
-
-    __STATIC_INLINE__ struct ggml_tensor* attention(struct ggml_context* ctx,
-                                                    ggml_backend_t backend,
-                                                    struct ggml_tensor* q,
-                                                    struct ggml_tensor* k,
-                                                    struct ggml_tensor* v,
-                                                    struct ggml_tensor* pe,
-                                                    struct ggml_tensor* mask,
-                                                    bool flash_attn,
-                                                    float kv_scale        = 1.0f,
-                                                    bool rope_interleaved = true) {
-        // q,k,v: [N, L, n_head, d_head]
-        // pe: [L, d_head/2, 2, 2]
-        // return: [N, L, n_head*d_head]
-        q = apply_rope(ctx, q, pe, rope_interleaved);  // [N*n_head, L, d_head]
-        k = apply_rope(ctx, k, pe, rope_interleaved);  // [N*n_head, L, d_head]
-
-        auto x = ggml_nn_attention_ext(ctx, backend, q, k, v, v->ne[1], mask, false, true, flash_attn, kv_scale);  // [N, L, n_head*d_head]
-        return x;
-    }
-};  // namespace Rope
+};  // struct Rope
 
 #endif  // __ROPE_HPP__

stable-diffusion.h

@@ -64,16 +64,6 @@ enum scheduler_t {
     SCHEDULE_COUNT
 };
 
-enum prediction_t {
-    DEFAULT_PRED,
-    EPS_PRED,
-    V_PRED,
-    EDM_V_PRED,
-    SD3_FLOW_PRED,
-    FLUX_FLOW_PRED,
-    PREDICTION_COUNT
-};
-
 // same as enum ggml_type
 enum sd_type_t {
     SD_TYPE_F32  = 0,
@@ -141,8 +131,6 @@ typedef struct {
     const char* clip_g_path;
     const char* clip_vision_path;
     const char* t5xxl_path;
-    const char* qwen2vl_path;
-    const char* qwen2vl_vision_path;
     const char* diffusion_model_path;
     const char* high_noise_diffusion_model_path;
     const char* vae_path;
@@ -156,7 +144,6 @@ typedef struct {
     int n_threads;
     enum sd_type_t wtype;
     enum rng_type_t rng_type;
-    enum prediction_t prediction;
     bool offload_params_to_cpu;
     bool keep_clip_on_cpu;
     bool keep_control_net_on_cpu;
@@ -225,6 +212,7 @@ typedef struct {
     int batch_count;
     sd_image_t control_image;
     float control_strength;
+    bool normalize_input;
     sd_pm_params_t pm_params;
     sd_tiling_params_t vae_tiling_params;
 } sd_img_gen_params_t;
@@ -266,8 +254,6 @@ SD_API const char* sd_sample_method_name(enum sample_method_t sample_method);
 SD_API enum sample_method_t str_to_sample_method(const char* str);
 SD_API const char* sd_schedule_name(enum scheduler_t scheduler);
 SD_API enum scheduler_t str_to_schedule(const char* str);
-SD_API const char* sd_prediction_name(enum prediction_t prediction);
-SD_API enum prediction_t str_to_prediction(const char* str);
 
 SD_API void sd_ctx_params_init(sd_ctx_params_t* sd_ctx_params);
 SD_API char* sd_ctx_params_to_str(const sd_ctx_params_t* sd_ctx_params);
@@ -298,8 +284,6 @@ SD_API sd_image_t upscale(upscaler_ctx_t* upscaler_ctx,
                           sd_image_t input_image,
                           uint32_t upscale_factor);
 
-SD_API int get_upscale_factor(upscaler_ctx_t* upscaler_ctx);
-
 SD_API bool convert(const char* input_path,
                     const char* vae_path,
                     const char* output_path,

t5.hpp

@@ -504,9 +504,7 @@ public:
     T5DenseGatedActDense(int64_t model_dim, int64_t ff_dim) {
         blocks["wi_0"] = std::shared_ptr<GGMLBlock>(new Linear(model_dim, ff_dim, false));
         blocks["wi_1"] = std::shared_ptr<GGMLBlock>(new Linear(model_dim, ff_dim, false));
-        float scale    = 1.f / 32.f;
-        // The purpose of the scale here is to prevent NaN issues on some backends(CUDA, ...).
-        blocks["wo"] = std::shared_ptr<GGMLBlock>(new Linear(ff_dim, model_dim, false, false, false, scale));
+        blocks["wo"]   = std::shared_ptr<GGMLBlock>(new Linear(ff_dim, model_dim, false));
     }
 
     struct ggml_tensor* forward(struct ggml_context* ctx, struct ggml_tensor* x) {

tae.hpp

@@ -222,7 +222,7 @@ struct TinyAutoEncoder : public GGMLRunner {
         return "taesd";
     }
 
-    bool load_from_file(const std::string& file_path, int n_threads) {
+    bool load_from_file(const std::string& file_path) {
         LOG_INFO("loading taesd from '%s', decode_only = %s", file_path.c_str(), decode_only ? "true" : "false");
         alloc_params_buffer();
         std::map<std::string, ggml_tensor*> taesd_tensors;
@@ -238,7 +238,7 @@ struct TinyAutoEncoder : public GGMLRunner {
             return false;
         }
 
-        bool success = model_loader.load_tensors(taesd_tensors, ignore_tensors, n_threads);
+        bool success = model_loader.load_tensors(taesd_tensors, ignore_tensors);
 
         if (!success) {
             LOG_ERROR("load tae tensors from model loader failed");

tokenize_util.cpp

@@ -1,985 +0,0 @@
-#include <algorithm>
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include "tokenize_util.h"
-
-bool is_number(char32_t ch) {
-    return (ch >= U'0' && ch <= U'9');
-}
-
-bool is_letter(char32_t ch) {
-    static const struct { char32_t start, end; } ranges[] = {
-        {0x41, 0x5A},
-        {0x61, 0x7A},
-        {0xAA, 0xAA},
-        {0xB5, 0xB5},
-        {0xBA, 0xBA},
-        {0xC0, 0xD6},
-        {0xD8, 0xF6},
-        {0xF8, 0x2C1},
-        {0x2C6, 0x2D1},
-        {0x2E0, 0x2E4},
-        {0x2EC, 0x2EC},
-        {0x2EE, 0x2EE},
-        {0x370, 0x374},
-        {0x376, 0x377},
-        {0x37A, 0x37D},
-        {0x37F, 0x37F},
-        {0x386, 0x386},
-        {0x388, 0x38A},
-        {0x38C, 0x38C},
-        {0x38E, 0x3A1},
-        {0x3A3, 0x3F5},
-        {0x3F7, 0x481},
-        {0x48A, 0x52F},
-        {0x531, 0x556},
-        {0x559, 0x559},
-        {0x560, 0x588},
-        {0x5D0, 0x5EA},
-        {0x5EF, 0x5F2},
-        {0x620, 0x64A},
-        {0x66E, 0x66F},
-        {0x671, 0x6D3},
-        {0x6D5, 0x6D5},
-        {0x6E5, 0x6E6},
-        {0x6EE, 0x6EF},
-        {0x6FA, 0x6FC},
-        {0x6FF, 0x6FF},
-        {0x710, 0x710},
-        {0x712, 0x72F},
-        {0x74D, 0x7A5},
-        {0x7B1, 0x7B1},
-        {0x7CA, 0x7EA},
-        {0x7F4, 0x7F5},
-        {0x7FA, 0x7FA},
-        {0x800, 0x815},
-        {0x81A, 0x81A},
-        {0x824, 0x824},
-        {0x828, 0x828},
-        {0x840, 0x858},
-        {0x860, 0x86A},
-        {0x870, 0x887},
-        {0x889, 0x88F},
-        {0x8A0, 0x8C9},
-        {0x904, 0x939},
-        {0x93D, 0x93D},
-        {0x950, 0x950},
-        {0x958, 0x961},
-        {0x971, 0x980},
-        {0x985, 0x98C},
-        {0x98F, 0x990},
-        {0x993, 0x9A8},
-        {0x9AA, 0x9B0},
-        {0x9B2, 0x9B2},
-        {0x9B6, 0x9B9},
-        {0x9BD, 0x9BD},
-        {0x9CE, 0x9CE},
-        {0x9DC, 0x9DD},
-        {0x9DF, 0x9E1},
-        {0x9F0, 0x9F1},
-        {0x9FC, 0x9FC},
-        {0xA05, 0xA0A},
-        {0xA0F, 0xA10},
-        {0xA13, 0xA28},
-        {0xA2A, 0xA30},
-        {0xA32, 0xA33},
-        {0xA35, 0xA36},
-        {0xA38, 0xA39},
-        {0xA59, 0xA5C},
-        {0xA5E, 0xA5E},
-        {0xA72, 0xA74},
-        {0xA85, 0xA8D},
-        {0xA8F, 0xA91},
-        {0xA93, 0xAA8},
-        {0xAAA, 0xAB0},
-        {0xAB2, 0xAB3},
-        {0xAB5, 0xAB9},
-        {0xABD, 0xABD},
-        {0xAD0, 0xAD0},
-        {0xAE0, 0xAE1},
-        {0xAF9, 0xAF9},
-        {0xB05, 0xB0C},
-        {0xB0F, 0xB10},
-        {0xB13, 0xB28},
-        {0xB2A, 0xB30},
-        {0xB32, 0xB33},
-        {0xB35, 0xB39},
-        {0xB3D, 0xB3D},
-        {0xB5C, 0xB5D},
-        {0xB5F, 0xB61},
-        {0xB71, 0xB71},
-        {0xB83, 0xB83},
-        {0xB85, 0xB8A},
-        {0xB8E, 0xB90},
-        {0xB92, 0xB95},
-        {0xB99, 0xB9A},
-        {0xB9C, 0xB9C},
-        {0xB9E, 0xB9F},
-        {0xBA3, 0xBA4},
-        {0xBA8, 0xBAA},
-        {0xBAE, 0xBB9},
-        {0xBD0, 0xBD0},
-        {0xC05, 0xC0C},
-        {0xC0E, 0xC10},
-        {0xC12, 0xC28},
-        {0xC2A, 0xC39},
-        {0xC3D, 0xC3D},
-        {0xC58, 0xC5A},
-        {0xC5C, 0xC5D},
-        {0xC60, 0xC61},
-        {0xC80, 0xC80},
-        {0xC85, 0xC8C},
-        {0xC8E, 0xC90},
-        {0xC92, 0xCA8},
-        {0xCAA, 0xCB3},
-        {0xCB5, 0xCB9},
-        {0xCBD, 0xCBD},
-        {0xCDC, 0xCDE},
-        {0xCE0, 0xCE1},
-        {0xCF1, 0xCF2},
-        {0xD04, 0xD0C},
-        {0xD0E, 0xD10},
-        {0xD12, 0xD3A},
-        {0xD3D, 0xD3D},
-        {0xD4E, 0xD4E},
-        {0xD54, 0xD56},
-        {0xD5F, 0xD61},
-        {0xD7A, 0xD7F},
-        {0xD85, 0xD96},
-        {0xD9A, 0xDB1},
-        {0xDB3, 0xDBB},
-        {0xDBD, 0xDBD},
-        {0xDC0, 0xDC6},
-        {0xE01, 0xE30},
-        {0xE32, 0xE33},
-        {0xE40, 0xE46},
-        {0xE81, 0xE82},
-        {0xE84, 0xE84},
-        {0xE86, 0xE8A},
-        {0xE8C, 0xEA3},
-        {0xEA5, 0xEA5},
-        {0xEA7, 0xEB0},
-        {0xEB2, 0xEB3},
-        {0xEBD, 0xEBD},
-        {0xEC0, 0xEC4},
-        {0xEC6, 0xEC6},
-        {0xEDC, 0xEDF},
-        {0xF00, 0xF00},
-        {0xF40, 0xF47},
-        {0xF49, 0xF6C},
-        {0xF88, 0xF8C},
-        {0x1000, 0x102A},
-        {0x103F, 0x103F},
-        {0x1050, 0x1055},
-        {0x105A, 0x105D},
-        {0x1061, 0x1061},
-        {0x1065, 0x1066},
-        {0x106E, 0x1070},
-        {0x1075, 0x1081},
-        {0x108E, 0x108E},
-        {0x10A0, 0x10C5},
-        {0x10C7, 0x10C7},
-        {0x10CD, 0x10CD},
-        {0x10D0, 0x10FA},
-        {0x10FC, 0x1248},
-        {0x124A, 0x124D},
-        {0x1250, 0x1256},
-        {0x1258, 0x1258},
-        {0x125A, 0x125D},
-        {0x1260, 0x1288},
-        {0x128A, 0x128D},
-        {0x1290, 0x12B0},
-        {0x12B2, 0x12B5},
-        {0x12B8, 0x12BE},
-        {0x12C0, 0x12C0},
-        {0x12C2, 0x12C5},
-        {0x12C8, 0x12D6},
-        {0x12D8, 0x1310},
-        {0x1312, 0x1315},
-        {0x1318, 0x135A},
-        {0x1380, 0x138F},
-        {0x13A0, 0x13F5},
-        {0x13F8, 0x13FD},
-        {0x1401, 0x166C},
-        {0x166F, 0x167F},
-        {0x1681, 0x169A},
-        {0x16A0, 0x16EA},
-        {0x16F1, 0x16F8},
-        {0x1700, 0x1711},
-        {0x171F, 0x1731},
-        {0x1740, 0x1751},
-        {0x1760, 0x176C},
-        {0x176E, 0x1770},
-        {0x1780, 0x17B3},
-        {0x17D7, 0x17D7},
-        {0x17DC, 0x17DC},
-        {0x1820, 0x1878},
-        {0x1880, 0x1884},
-        {0x1887, 0x18A8},
-        {0x18AA, 0x18AA},
-        {0x18B0, 0x18F5},
-        {0x1900, 0x191E},
-        {0x1950, 0x196D},
-        {0x1970, 0x1974},
-        {0x1980, 0x19AB},
-        {0x19B0, 0x19C9},
-        {0x1A00, 0x1A16},
-        {0x1A20, 0x1A54},
-        {0x1AA7, 0x1AA7},
-        {0x1B05, 0x1B33},
-        {0x1B45, 0x1B4C},
-        {0x1B83, 0x1BA0},
-        {0x1BAE, 0x1BAF},
-        {0x1BBA, 0x1BE5},
-        {0x1C00, 0x1C23},
-        {0x1C4D, 0x1C4F},
-        {0x1C5A, 0x1C7D},
-        {0x1C80, 0x1C8A},
-        {0x1C90, 0x1CBA},
-        {0x1CBD, 0x1CBF},
-        {0x1CE9, 0x1CEC},
-        {0x1CEE, 0x1CF3},
-        {0x1CF5, 0x1CF6},
-        {0x1CFA, 0x1CFA},
-        {0x1D00, 0x1DBF},
-        {0x1E00, 0x1F15},
-        {0x1F18, 0x1F1D},
-        {0x1F20, 0x1F45},
-        {0x1F48, 0x1F4D},
-        {0x1F50, 0x1F57},
-        {0x1F59, 0x1F59},
-        {0x1F5B, 0x1F5B},
-        {0x1F5D, 0x1F5D},
-        {0x1F5F, 0x1F7D},
-        {0x1F80, 0x1FB4},
-        {0x1FB6, 0x1FBC},
-        {0x1FBE, 0x1FBE},
-        {0x1FC2, 0x1FC4},
-        {0x1FC6, 0x1FCC},
-        {0x1FD0, 0x1FD3},
-        {0x1FD6, 0x1FDB},
-        {0x1FE0, 0x1FEC},
-        {0x1FF2, 0x1FF4},
-        {0x1FF6, 0x1FFC},
-        {0x2071, 0x2071},
-        {0x207F, 0x207F},
-        {0x2090, 0x209C},
-        {0x2102, 0x2102},
-        {0x2107, 0x2107},
-        {0x210A, 0x2113},
-        {0x2115, 0x2115},
-        {0x2119, 0x211D},
-        {0x2124, 0x2124},
-        {0x2126, 0x2126},
-        {0x2128, 0x2128},
-        {0x212A, 0x212D},
-        {0x212F, 0x2139},
-        {0x213C, 0x213F},
-        {0x2145, 0x2149},
-        {0x214E, 0x214E},
-        {0x2183, 0x2184},
-        {0x2C00, 0x2CE4},
-        {0x2CEB, 0x2CEE},
-        {0x2CF2, 0x2CF3},
-        {0x2D00, 0x2D25},
-        {0x2D27, 0x2D27},
-        {0x2D2D, 0x2D2D},
-        {0x2D30, 0x2D67},
-        {0x2D6F, 0x2D6F},
-        {0x2D80, 0x2D96},
-        {0x2DA0, 0x2DA6},
-        {0x2DA8, 0x2DAE},
-        {0x2DB0, 0x2DB6},
-        {0x2DB8, 0x2DBE},
-        {0x2DC0, 0x2DC6},
-        {0x2DC8, 0x2DCE},
-        {0x2DD0, 0x2DD6},
-        {0x2DD8, 0x2DDE},
-        {0x2E2F, 0x2E2F},
-        {0x3005, 0x3006},
-        {0x3031, 0x3035},
-        {0x303B, 0x303C},
-        {0x3041, 0x3096},
-        {0x309D, 0x309F},
-        {0x30A1, 0x30FA},
-        {0x30FC, 0x30FF},
-        {0x3105, 0x312F},
-        {0x3131, 0x318E},
-        {0x31A0, 0x31BF},
-        {0x31F0, 0x31FF},
-        {0x3400, 0x4DBF},
-        {0x4E00, 0xA48C},
-        {0xA4D0, 0xA4FD},
-        {0xA500, 0xA60C},
-        {0xA610, 0xA61F},
-        {0xA62A, 0xA62B},
-        {0xA640, 0xA66E},
-        {0xA67F, 0xA69D},
-        {0xA6A0, 0xA6E5},
-        {0xA717, 0xA71F},
-        {0xA722, 0xA788},
-        {0xA78B, 0xA7DC},
-        {0xA7F1, 0xA801},
-        {0xA803, 0xA805},
-        {0xA807, 0xA80A},
-        {0xA80C, 0xA822},
-        {0xA840, 0xA873},
-        {0xA882, 0xA8B3},
-        {0xA8F2, 0xA8F7},
-        {0xA8FB, 0xA8FB},
-        {0xA8FD, 0xA8FE},
-        {0xA90A, 0xA925},
-        {0xA930, 0xA946},
-        {0xA960, 0xA97C},
-        {0xA984, 0xA9B2},
-        {0xA9CF, 0xA9CF},
-        {0xA9E0, 0xA9E4},
-        {0xA9E6, 0xA9EF},
-        {0xA9FA, 0xA9FE},
-        {0xAA00, 0xAA28},
-        {0xAA40, 0xAA42},
-        {0xAA44, 0xAA4B},
-        {0xAA60, 0xAA76},
-        {0xAA7A, 0xAA7A},
-        {0xAA7E, 0xAAAF},
-        {0xAAB1, 0xAAB1},
-        {0xAAB5, 0xAAB6},
-        {0xAAB9, 0xAABD},
-        {0xAAC0, 0xAAC0},
-        {0xAAC2, 0xAAC2},
-        {0xAADB, 0xAADD},
-        {0xAAE0, 0xAAEA},
-        {0xAAF2, 0xAAF4},
-        {0xAB01, 0xAB06},
-        {0xAB09, 0xAB0E},
-        {0xAB11, 0xAB16},
-        {0xAB20, 0xAB26},
-        {0xAB28, 0xAB2E},
-        {0xAB30, 0xAB5A},
-        {0xAB5C, 0xAB69},
-        {0xAB70, 0xABE2},
-        {0xAC00, 0xD7A3},
-        {0xD7B0, 0xD7C6},
-        {0xD7CB, 0xD7FB},
-        {0xF900, 0xFA6D},
-        {0xFA70, 0xFAD9},
-        {0xFB00, 0xFB06},
-        {0xFB13, 0xFB17},
-        {0xFB1D, 0xFB1D},
-        {0xFB1F, 0xFB28},
-        {0xFB2A, 0xFB36},
-        {0xFB38, 0xFB3C},
-        {0xFB3E, 0xFB3E},
-        {0xFB40, 0xFB41},
-        {0xFB43, 0xFB44},
-        {0xFB46, 0xFBB1},
-        {0xFBD3, 0xFD3D},
-        {0xFD50, 0xFD8F},
-        {0xFD92, 0xFDC7},
-        {0xFDF0, 0xFDFB},
-        {0xFE70, 0xFE74},
-        {0xFE76, 0xFEFC},
-        {0xFF21, 0xFF3A},
-        {0xFF41, 0xFF5A},
-        {0xFF66, 0xFFBE},
-        {0xFFC2, 0xFFC7},
-        {0xFFCA, 0xFFCF},
-        {0xFFD2, 0xFFD7},
-        {0xFFDA, 0xFFDC},
-        {0x10000, 0x1000B},
-        {0x1000D, 0x10026},
-        {0x10028, 0x1003A},
-        {0x1003C, 0x1003D},
-        {0x1003F, 0x1004D},
-        {0x10050, 0x1005D},
-        {0x10080, 0x100FA},
-        {0x10280, 0x1029C},
-        {0x102A0, 0x102D0},
-        {0x10300, 0x1031F},
-        {0x1032D, 0x10340},
-        {0x10342, 0x10349},
-        {0x10350, 0x10375},
-        {0x10380, 0x1039D},
-        {0x103A0, 0x103C3},
-        {0x103C8, 0x103CF},
-        {0x10400, 0x1049D},
-        {0x104B0, 0x104D3},
-        {0x104D8, 0x104FB},
-        {0x10500, 0x10527},
-        {0x10530, 0x10563},
-        {0x10570, 0x1057A},
-        {0x1057C, 0x1058A},
-        {0x1058C, 0x10592},
-        {0x10594, 0x10595},
-        {0x10597, 0x105A1},
-        {0x105A3, 0x105B1},
-        {0x105B3, 0x105B9},
-        {0x105BB, 0x105BC},
-        {0x105C0, 0x105F3},
-        {0x10600, 0x10736},
-        {0x10740, 0x10755},
-        {0x10760, 0x10767},
-        {0x10780, 0x10785},
-        {0x10787, 0x107B0},
-        {0x107B2, 0x107BA},
-        {0x10800, 0x10805},
-        {0x10808, 0x10808},
-        {0x1080A, 0x10835},
-        {0x10837, 0x10838},
-        {0x1083C, 0x1083C},
-        {0x1083F, 0x10855},
-        {0x10860, 0x10876},
-        {0x10880, 0x1089E},
-        {0x108E0, 0x108F2},
-        {0x108F4, 0x108F5},
-        {0x10900, 0x10915},
-        {0x10920, 0x10939},
-        {0x10940, 0x10959},
-        {0x10980, 0x109B7},
-        {0x109BE, 0x109BF},
-        {0x10A00, 0x10A00},
-        {0x10A10, 0x10A13},
-        {0x10A15, 0x10A17},
-        {0x10A19, 0x10A35},
-        {0x10A60, 0x10A7C},
-        {0x10A80, 0x10A9C},
-        {0x10AC0, 0x10AC7},
-        {0x10AC9, 0x10AE4},
-        {0x10B00, 0x10B35},
-        {0x10B40, 0x10B55},
-        {0x10B60, 0x10B72},
-        {0x10B80, 0x10B91},
-        {0x10C00, 0x10C48},
-        {0x10C80, 0x10CB2},
-        {0x10CC0, 0x10CF2},
-        {0x10D00, 0x10D23},
-        {0x10D4A, 0x10D65},
-        {0x10D6F, 0x10D85},
-        {0x10E80, 0x10EA9},
-        {0x10EB0, 0x10EB1},
-        {0x10EC2, 0x10EC7},
-        {0x10F00, 0x10F1C},
-        {0x10F27, 0x10F27},
-        {0x10F30, 0x10F45},
-        {0x10F70, 0x10F81},
-        {0x10FB0, 0x10FC4},
-        {0x10FE0, 0x10FF6},
-        {0x11003, 0x11037},
-        {0x11071, 0x11072},
-        {0x11075, 0x11075},
-        {0x11083, 0x110AF},
-        {0x110D0, 0x110E8},
-        {0x11103, 0x11126},
-        {0x11144, 0x11144},
-        {0x11147, 0x11147},
-        {0x11150, 0x11172},
-        {0x11176, 0x11176},
-        {0x11183, 0x111B2},
-        {0x111C1, 0x111C4},
-        {0x111DA, 0x111DA},
-        {0x111DC, 0x111DC},
-        {0x11200, 0x11211},
-        {0x11213, 0x1122B},
-        {0x1123F, 0x11240},
-        {0x11280, 0x11286},
-        {0x11288, 0x11288},
-        {0x1128A, 0x1128D},
-        {0x1128F, 0x1129D},
-        {0x1129F, 0x112A8},
-        {0x112B0, 0x112DE},
-        {0x11305, 0x1130C},
-        {0x1130F, 0x11310},
-        {0x11313, 0x11328},
-        {0x1132A, 0x11330},
-        {0x11332, 0x11333},
-        {0x11335, 0x11339},
-        {0x1133D, 0x1133D},
-        {0x11350, 0x11350},
-        {0x1135D, 0x11361},
-        {0x11380, 0x11389},
-        {0x1138B, 0x1138B},
-        {0x1138E, 0x1138E},
-        {0x11390, 0x113B5},
-        {0x113B7, 0x113B7},
-        {0x113D1, 0x113D1},
-        {0x113D3, 0x113D3},
-        {0x11400, 0x11434},
-        {0x11447, 0x1144A},
-        {0x1145F, 0x11461},
-        {0x11480, 0x114AF},
-        {0x114C4, 0x114C5},
-        {0x114C7, 0x114C7},
-        {0x11580, 0x115AE},
-        {0x115D8, 0x115DB},
-        {0x11600, 0x1162F},
-        {0x11644, 0x11644},
-        {0x11680, 0x116AA},
-        {0x116B8, 0x116B8},
-        {0x11700, 0x1171A},
-        {0x11740, 0x11746},
-        {0x11800, 0x1182B},
-        {0x118A0, 0x118DF},
-        {0x118FF, 0x11906},
-        {0x11909, 0x11909},
-        {0x1190C, 0x11913},
-        {0x11915, 0x11916},
-        {0x11918, 0x1192F},
-        {0x1193F, 0x1193F},
-        {0x11941, 0x11941},
-        {0x119A0, 0x119A7},
-        {0x119AA, 0x119D0},
-        {0x119E1, 0x119E1},
-        {0x119E3, 0x119E3},
-        {0x11A00, 0x11A00},
-        {0x11A0B, 0x11A32},
-        {0x11A3A, 0x11A3A},
-        {0x11A50, 0x11A50},
-        {0x11A5C, 0x11A89},
-        {0x11A9D, 0x11A9D},
-        {0x11AB0, 0x11AF8},
-        {0x11BC0, 0x11BE0},
-        {0x11C00, 0x11C08},
-        {0x11C0A, 0x11C2E},
-        {0x11C40, 0x11C40},
-        {0x11C72, 0x11C8F},
-        {0x11D00, 0x11D06},
-        {0x11D08, 0x11D09},
-        {0x11D0B, 0x11D30},
-        {0x11D46, 0x11D46},
-        {0x11D60, 0x11D65},
-        {0x11D67, 0x11D68},
-        {0x11D6A, 0x11D89},
-        {0x11D98, 0x11D98},
-        {0x11DB0, 0x11DDB},
-        {0x11EE0, 0x11EF2},
-        {0x11F02, 0x11F02},
-        {0x11F04, 0x11F10},
-        {0x11F12, 0x11F33},
-        {0x11FB0, 0x11FB0},
-        {0x12000, 0x12399},
-        {0x12480, 0x12543},
-        {0x12F90, 0x12FF0},
-        {0x13000, 0x1342F},
-        {0x13441, 0x13446},
-        {0x13460, 0x143FA},
-        {0x14400, 0x14646},
-        {0x16100, 0x1611D},
-        {0x16800, 0x16A38},
-        {0x16A40, 0x16A5E},
-        {0x16A70, 0x16ABE},
-        {0x16AD0, 0x16AED},
-        {0x16B00, 0x16B2F},
-        {0x16B40, 0x16B43},
-        {0x16B63, 0x16B77},
-        {0x16B7D, 0x16B8F},
-        {0x16D40, 0x16D6C},
-        {0x16E40, 0x16E7F},
-        {0x16EA0, 0x16EB8},
-        {0x16EBB, 0x16ED3},
-        {0x16F00, 0x16F4A},
-        {0x16F50, 0x16F50},
-        {0x16F93, 0x16F9F},
-        {0x16FE0, 0x16FE1},
-        {0x16FE3, 0x16FE3},
-        {0x16FF2, 0x16FF3},
-        {0x17000, 0x18CD5},
-        {0x18CFF, 0x18D1E},
-        {0x18D80, 0x18DF2},
-        {0x1AFF0, 0x1AFF3},
-        {0x1AFF5, 0x1AFFB},
-        {0x1AFFD, 0x1AFFE},
-        {0x1B000, 0x1B122},
-        {0x1B132, 0x1B132},
-        {0x1B150, 0x1B152},
-        {0x1B155, 0x1B155},
-        {0x1B164, 0x1B167},
-        {0x1B170, 0x1B2FB},
-        {0x1BC00, 0x1BC6A},
-        {0x1BC70, 0x1BC7C},
-        {0x1BC80, 0x1BC88},
-        {0x1BC90, 0x1BC99},
-        {0x1D400, 0x1D454},
-        {0x1D456, 0x1D49C},
-        {0x1D49E, 0x1D49F},
-        {0x1D4A2, 0x1D4A2},
-        {0x1D4A5, 0x1D4A6},
-        {0x1D4A9, 0x1D4AC},
-        {0x1D4AE, 0x1D4B9},
-        {0x1D4BB, 0x1D4BB},
-        {0x1D4BD, 0x1D4C3},
-        {0x1D4C5, 0x1D505},
-        {0x1D507, 0x1D50A},
-        {0x1D50D, 0x1D514},
-        {0x1D516, 0x1D51C},
-        {0x1D51E, 0x1D539},
-        {0x1D53B, 0x1D53E},
-        {0x1D540, 0x1D544},
-        {0x1D546, 0x1D546},
-        {0x1D54A, 0x1D550},
-        {0x1D552, 0x1D6A5},
-        {0x1D6A8, 0x1D6C0},
-        {0x1D6C2, 0x1D6DA},
-        {0x1D6DC, 0x1D6FA},
-        {0x1D6FC, 0x1D714},
-        {0x1D716, 0x1D734},
-        {0x1D736, 0x1D74E},
-        {0x1D750, 0x1D76E},
-        {0x1D770, 0x1D788},
-        {0x1D78A, 0x1D7A8},
-        {0x1D7AA, 0x1D7C2},
-        {0x1D7C4, 0x1D7CB},
-        {0x1DF00, 0x1DF1E},
-        {0x1DF25, 0x1DF2A},
-        {0x1E030, 0x1E06D},
-        {0x1E100, 0x1E12C},
-        {0x1E137, 0x1E13D},
-        {0x1E14E, 0x1E14E},
-        {0x1E290, 0x1E2AD},
-        {0x1E2C0, 0x1E2EB},
-        {0x1E4D0, 0x1E4EB},
-        {0x1E5D0, 0x1E5ED},
-        {0x1E5F0, 0x1E5F0},
-        {0x1E6C0, 0x1E6DE},
-        {0x1E6E0, 0x1E6E2},
-        {0x1E6E4, 0x1E6E5},
-        {0x1E6E7, 0x1E6ED},
-        {0x1E6F0, 0x1E6F4},
-        {0x1E6FE, 0x1E6FF},
-        {0x1E7E0, 0x1E7E6},
-        {0x1E7E8, 0x1E7EB},
-        {0x1E7ED, 0x1E7EE},
-        {0x1E7F0, 0x1E7FE},
-        {0x1E800, 0x1E8C4},
-        {0x1E900, 0x1E943},
-        {0x1E94B, 0x1E94B},
-        {0x1EE00, 0x1EE03},
-        {0x1EE05, 0x1EE1F},
-        {0x1EE21, 0x1EE22},
-        {0x1EE24, 0x1EE24},
-        {0x1EE27, 0x1EE27},
-        {0x1EE29, 0x1EE32},
-        {0x1EE34, 0x1EE37},
-        {0x1EE39, 0x1EE39},
-        {0x1EE3B, 0x1EE3B},
-        {0x1EE42, 0x1EE42},
-        {0x1EE47, 0x1EE47},
-        {0x1EE49, 0x1EE49},
-        {0x1EE4B, 0x1EE4B},
-        {0x1EE4D, 0x1EE4F},
-        {0x1EE51, 0x1EE52},
-        {0x1EE54, 0x1EE54},
-        {0x1EE57, 0x1EE57},
-        {0x1EE59, 0x1EE59},
-        {0x1EE5B, 0x1EE5B},
-        {0x1EE5D, 0x1EE5D},
-        {0x1EE5F, 0x1EE5F},
-        {0x1EE61, 0x1EE62},
-        {0x1EE64, 0x1EE64},
-        {0x1EE67, 0x1EE6A},
-        {0x1EE6C, 0x1EE72},
-        {0x1EE74, 0x1EE77},
-        {0x1EE79, 0x1EE7C},
-        {0x1EE7E, 0x1EE7E},
-        {0x1EE80, 0x1EE89},
-        {0x1EE8B, 0x1EE9B},
-        {0x1EEA1, 0x1EEA3},
-        {0x1EEA5, 0x1EEA9},
-        {0x1EEAB, 0x1EEBB},
-        {0x20000, 0x2A6DF},
-        {0x2A700, 0x2B81D},
-        {0x2B820, 0x2CEAD},
-        {0x2CEB0, 0x2EBE0},
-        {0x2EBF0, 0x2EE5D},
-        {0x2F800, 0x2FA1D},
-        {0x30000, 0x3134A},
-        {0x31350, 0x33479},
-    };
-
-    for (const auto& r : ranges) {
-        if (ch >= r.start && ch <= r.end)
-            return true;
-    }
-    return false;
-}
-
-bool is_space(char32_t cp) {
-    switch (cp) {
-        case 0x0009:  // TAB \t
-        case 0x000A:  // LF \n
-        case 0x000B:  // VT
-        case 0x000C:  // FF
-        case 0x000D:  // CR \r
-        case 0x0020:  // Space
-        case 0x00A0:  // No-Break Space
-        case 0x1680:  // Ogham Space Mark
-        case 0x2000:  // En Quad
-        case 0x2001:  // Em Quad
-        case 0x2002:  // En Space
-        case 0x2003:  // Em Space
-        case 0x2004:  // Three-Per-Em Space
-        case 0x2005:  // Four-Per-Em Space
-        case 0x2006:  // Six-Per-Em Space
-        case 0x2007:  // Figure Space
-        case 0x2008:  // Punctuation Space
-        case 0x2009:  // Thin Space
-        case 0x200A:  // Hair Space
-        case 0x202F:  // Narrow No-Break Space
-        case 0x205F:  // Medium Mathematical Space
-        case 0x3000:  // Ideographic Space
-            return true;
-        default:
-            return false;
-    }
-}
-
-std::string str_to_lower(const std::string& input) {
-    std::string result = input;
-    std::transform(result.begin(), result.end(), result.begin(),
-                   [](unsigned char c) { return std::tolower(c); });
-    return result;
-}
-
-// UTF-8 -> Unicode code points
-std::vector<char32_t> utf8_to_codepoints(const std::string& str) {
-    std::vector<char32_t> codepoints;
-    size_t i = 0;
-    while (i < str.size()) {
-        unsigned char c    = str[i];
-        char32_t cp        = 0;
-        size_t extra_bytes = 0;
-
-        if ((c & 0x80) == 0)
-            cp = c;
-        else if ((c & 0xE0) == 0xC0) {
-            cp          = c & 0x1F;
-            extra_bytes = 1;
-        } else if ((c & 0xF0) == 0xE0) {
-            cp          = c & 0x0F;
-            extra_bytes = 2;
-        } else if ((c & 0xF8) == 0xF0) {
-            cp          = c & 0x07;
-            extra_bytes = 3;
-        } else {
-            ++i;
-            continue;
-        }  // Invalid UTF-8
-
-        if (i + extra_bytes >= str.size())
-            break;
-
-        for (size_t j = 1; j <= extra_bytes; ++j)
-            cp = (cp << 6) | (str[i + j] & 0x3F);
-
-        codepoints.push_back(cp);
-        i += 1 + extra_bytes;
-    }
-    return codepoints;
-}
-
-// Unicode code point -> UTF-8
-std::string codepoint_to_utf8(char32_t cp) {
-    std::string out;
-    if (cp <= 0x7F)
-        out.push_back(static_cast<char>(cp));
-    else if (cp <= 0x7FF) {
-        out.push_back(static_cast<char>(0xC0 | (cp >> 6)));
-        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
-    } else if (cp <= 0xFFFF) {
-        out.push_back(static_cast<char>(0xE0 | (cp >> 12)));
-        out.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
-        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
-    } else {
-        out.push_back(static_cast<char>(0xF0 | (cp >> 18)));
-        out.push_back(static_cast<char>(0x80 | ((cp >> 12) & 0x3F)));
-        out.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
-        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
-    }
-    return out;
-}
-
-bool starts_with(const std::vector<char32_t>& text,
-                 const std::vector<char32_t>& prefix,
-                 std::size_t index) {
-    if (index > text.size()) {
-        return false;
-    }
-    if (prefix.size() > text.size() - index) {
-        return false;
-    }
-    return std::equal(prefix.begin(), prefix.end(), text.begin() + index);
-}
-
-std::vector<std::string> token_split(const std::string& text) {
-    std::vector<std::string> tokens;
-    auto cps = utf8_to_codepoints(text);
-    size_t i = 0;
-
-    while (i < cps.size()) {
-        char32_t cp = cps[i];
-
-        // `(?i:'s|'t|'re|'ve|'m|'ll|'d)`
-        if (cp == U'\'' && i + 1 < cps.size()) {
-            std::string next = str_to_lower(codepoint_to_utf8(cps[i + 1]));
-            if (next == "s" || next == "t" || next == "m") {
-                tokens.push_back("'" + next);
-                i += 2;
-                continue;
-            }
-            if (i + 2 < cps.size()) {
-                next += str_to_lower(codepoint_to_utf8(cps[i + 2]));
-                if (next == "re" || next == "ve" || next == "ll" || next == "d") {
-                    tokens.push_back("'" + next);
-                    i += 3;
-                    continue;
-                }
-            }
-        }
-
-        // `\p{N}`
-        if (is_number(cp)) {
-            tokens.push_back(codepoint_to_utf8(cp));
-            ++i;
-            continue;
-        }
-
-        // `[^\r\n\p{L}\p{N}]?\p{L}+`
-        {
-            // `[^\r\n\p{L}\p{N}]\p{L}+`
-            if (!is_letter(cp) && cp != U'\r' && cp != U'\n' && i + 1 < cps.size() && is_letter(cps[i + 1])) {
-                std::string token = codepoint_to_utf8(cp);
-                ++i;
-
-                while (i < cps.size() && is_letter(cps[i])) {
-                    token += codepoint_to_utf8(cps[i]);
-                    ++i;
-                }
-                tokens.push_back(token);
-                continue;
-            }
-
-            // `\p{L}+`
-            if (is_letter(cp)) {
-                std::string token = codepoint_to_utf8(cp);
-                ++i;
-                while (i < cps.size() && is_letter(cps[i])) {
-                    token += codepoint_to_utf8(cps[i]);
-                    ++i;
-                }
-                tokens.push_back(token);
-                continue;
-            }
-        }
-
-        // ` ?[^\s\p{L}\p{N}]+[\r\n]*`
-        {
-            // ` [^\s\p{L}\p{N}]+[\r\n]*`
-            if (cp == U' ' && i + 1 < cps.size() && !isspace(cps[i + 1]) && !is_letter(cps[i + 1]) && !is_number(cps[i + 1])) {
-                std::string token = codepoint_to_utf8(cp);
-                token += codepoint_to_utf8(cps[i + 1]);
-                i += 2;
-
-                while (i < cps.size() && !is_letter(cps[i]) && !is_number(cps[i]) && !isspace(cps[i])) {
-                    token += codepoint_to_utf8(cps[i]);
-                    ++i;
-                }
-
-                while (i < cps.size() && (cps[i] == U'\r' || cps[i] == U'\n')) {
-                    token += codepoint_to_utf8(cps[i]);
-                    ++i;
-                }
-
-                tokens.push_back(token);
-                continue;
-            }
-
-            // `[^\s\p{L}\p{N}]+[\r\n]*`
-            std::string token;
-            if (!is_letter(cps[i]) && !is_number(cps[i]) && !isspace(cps[i])) {
-                std::string token = codepoint_to_utf8(cp);
-                ++i;
-
-                while (i < cps.size() && !is_letter(cps[i]) && !is_number(cps[i]) && !isspace(cps[i])) {
-                    token += codepoint_to_utf8(cps[i]);
-                    ++i;
-                }
-
-                while (i < cps.size() && (cps[i] == U'\r' || cps[i] == U'\n')) {
-                    token += codepoint_to_utf8(cps[i]);
-                    ++i;
-                }
-
-                tokens.push_back(token);
-                continue;
-            }
-        }
-
-        // `\s*[\r\n]+|\s+(?!\S)|\s+`
-        if (is_space(cp)) {
-            std::string token = codepoint_to_utf8(cp);
-            ++i;
-
-            while (i < cps.size() && is_space(cps[i])) {
-                token += codepoint_to_utf8(cps[i]);
-                ++i;
-                if (cps[i] == U'\r' || cps[i] == U'\n') {
-                    break;
-                }
-            }
-
-            tokens.push_back(token);
-            continue;
-        }
-
-        // skip
-        ++i;
-    }
-
-    return tokens;
-}
-
-std::vector<std::string> split_with_special_tokens(
-    const std::string& text,
-    const std::vector<std::string>& special_tokens) {
-    std::vector<std::string> result;
-    size_t pos      = 0;
-    size_t text_len = text.size();
-
-    while (pos < text_len) {
-        size_t next_pos = text_len;
-        std::string matched_token;
-
-        for (const auto& token : special_tokens) {
-            size_t token_pos = text.find(token, pos);
-            if (token_pos != std::string::npos && token_pos < next_pos) {
-                next_pos      = token_pos;
-                matched_token = token;
-            }
-        }
-
-        if (next_pos > pos) {
-            result.push_back(text.substr(pos, next_pos - pos));
-        }
-
-        if (!matched_token.empty()) {
-            result.push_back(matched_token);
-            pos = next_pos + matched_token.size();
-        } else {
-            break;
-        }
-    }
-
-    return result;
-}
-
-// int main() {
-//     std::string text = "I'm testing C++ token_split function. 你好，世界! 123";
-//     auto tokens = token_split(text);
-
-//     for (const auto& t : tokens) {
-//         std::cout << "[" << t << "] ";
-//     }
-//     std::cout << "\n";
-//     return 0;
-// }

tokenize_util.h

@@ -1,10 +0,0 @@
-#ifndef __TOKENIZE_UTIL__
-#define __TOKENIZE_UTIL__
-
-#include <string>
-#include <vector>
-
-std::vector<std::string> token_split(const std::string& text);
-std::vector<std::string> split_with_special_tokens(const std::string& text, const std::vector<std::string>& special_tokens);
-
-#endif  // __TOKENIZE_UTIL__

upscaler.cpp

@@ -18,8 +18,7 @@ struct UpscalerGGML {
     }
 
     bool load_from_file(const std::string& esrgan_path,
-                        bool offload_params_to_cpu,
-                        int n_threads) {
+                        bool offload_params_to_cpu) {
         ggml_log_set(ggml_log_callback_default, nullptr);
 #ifdef SD_USE_CUDA
         LOG_DEBUG("Using CUDA backend");
@@ -55,7 +54,7 @@ struct UpscalerGGML {
         if (direct) {
             esrgan_upscaler->enable_conv2d_direct();
         }
-        if (!esrgan_upscaler->load_from_file(esrgan_path, n_threads)) {
+        if (!esrgan_upscaler->load_from_file(esrgan_path)) {
             return false;
         }
         return true;
@@ -125,7 +124,7 @@ upscaler_ctx_t* new_upscaler_ctx(const char* esrgan_path_c_str,
         return NULL;
     }
 
-    if (!upscaler_ctx->upscaler->load_from_file(esrgan_path, offload_params_to_cpu, n_threads)) {
+    if (!upscaler_ctx->upscaler->load_from_file(esrgan_path, offload_params_to_cpu)) {
         delete upscaler_ctx->upscaler;
         upscaler_ctx->upscaler = NULL;
         free(upscaler_ctx);
@@ -138,13 +137,6 @@ sd_image_t upscale(upscaler_ctx_t* upscaler_ctx, sd_image_t input_image, uint32_
     return upscaler_ctx->upscaler->upscale(input_image, upscale_factor);
 }
 
-int get_upscale_factor(upscaler_ctx_t* upscaler_ctx) {
-    if (upscaler_ctx == NULL || upscaler_ctx->upscaler == NULL || upscaler_ctx->upscaler->esrgan_upscaler == NULL) {
-        return 1;
-    }
-    return upscaler_ctx->upscaler->esrgan_upscaler->scale;
-}
-
 void free_upscaler_ctx(upscaler_ctx_t* upscaler_ctx) {
     if (upscaler_ctx->upscaler != NULL) {
         delete upscaler_ctx->upscaler;

util.cpp

@@ -84,7 +84,6 @@ int round_up_to(int value, int base) {
 }
 
 #ifdef _WIN32  // code for windows
-#define NOMINMAX
 #include <windows.h>
 
 bool file_exists(const std::string& filename) {
@@ -299,7 +298,7 @@ std::string trim(const std::string& s) {
 static sd_log_cb_t sd_log_cb = NULL;
 void* sd_log_cb_data         = NULL;
 
-#define LOG_BUFFER_SIZE 4096
+#define LOG_BUFFER_SIZE 1024
 
 void log_printf(sd_log_level_t level, const char* file, int line, const char* format, ...) {
     va_list args;
@@ -388,10 +387,10 @@ sd_image_f32_t resize_sd_image_f32_t(sd_image_f32_t image, int target_width, int
             float original_x = (float)x * image.width / target_width;
             float original_y = (float)y * image.height / target_height;
 
-            uint32_t x1 = (uint32_t)original_x;
-            uint32_t y1 = (uint32_t)original_y;
-            uint32_t x2 = std::min(x1 + 1, image.width - 1);
-            uint32_t y2 = std::min(y1 + 1, image.height - 1);
+            int x1 = (int)original_x;
+            int y1 = (int)original_y;
+            int x2 = x1 + 1;
+            int y2 = y1 + 1;
 
             for (int k = 0; k < image.channel; k++) {
                 float v1 = *(image.data + y1 * image.width * image.channel + x1 * image.channel + k);
@@ -428,26 +427,23 @@ float means[3] = {0.48145466, 0.4578275, 0.40821073};
 float stds[3]  = {0.26862954, 0.26130258, 0.27577711};
 
 // Function to clip and preprocess sd_image_f32_t
-sd_image_f32_t clip_preprocess(sd_image_f32_t image, int target_width, int target_height) {
-    float width_scale  = (float)target_width / image.width;
-    float height_scale = (float)target_height / image.height;
-
-    float scale = std::fmax(width_scale, height_scale);
+sd_image_f32_t clip_preprocess(sd_image_f32_t image, int size) {
+    float scale = (float)size / fmin(image.width, image.height);
 
     // Interpolation
-    int resized_width   = (int)(scale * image.width);
-    int resized_height  = (int)(scale * image.height);
-    float* resized_data = (float*)malloc(resized_width * resized_height * image.channel * sizeof(float));
+    int new_width       = (int)(scale * image.width);
+    int new_height      = (int)(scale * image.height);
+    float* resized_data = (float*)malloc(new_width * new_height * image.channel * sizeof(float));
 
-    for (int y = 0; y < resized_height; y++) {
-        for (int x = 0; x < resized_width; x++) {
-            float original_x = (float)x * image.width / resized_width;
-            float original_y = (float)y * image.height / resized_height;
+    for (int y = 0; y < new_height; y++) {
+        for (int x = 0; x < new_width; x++) {
+            float original_x = (float)x * image.width / new_width;
+            float original_y = (float)y * image.height / new_height;
 
-            uint32_t x1 = (uint32_t)original_x;
-            uint32_t y1 = (uint32_t)original_y;
-            uint32_t x2 = std::min(x1 + 1, image.width - 1);
-            uint32_t y2 = std::min(y1 + 1, image.height - 1);
+            int x1 = (int)original_x;
+            int y1 = (int)original_y;
+            int x2 = x1 + 1;
+            int y2 = y1 + 1;
 
             for (int k = 0; k < image.channel; k++) {
                 float v1 = *(image.data + y1 * image.width * image.channel + x1 * image.channel + k);
@@ -460,28 +456,26 @@ sd_image_f32_t clip_preprocess(sd_image_f32_t image, int target_width, int targe
 
                 float value = interpolate(v1, v2, v3, v4, x_ratio, y_ratio);
 
-                *(resized_data + y * resized_width * image.channel + x * image.channel + k) = value;
+                *(resized_data + y * new_width * image.channel + x * image.channel + k) = value;
             }
         }
     }
 
     // Clip and preprocess
-    int h_offset = std::max((int)(resized_height - target_height) / 2, 0);
-    int w_offset = std::max((int)(resized_width - target_width) / 2, 0);
+    int h = (new_height - size) / 2;
+    int w = (new_width - size) / 2;
 
     sd_image_f32_t result;
-    result.width   = target_width;
-    result.height  = target_height;
+    result.width   = size;
+    result.height  = size;
     result.channel = image.channel;
-    result.data    = (float*)malloc(target_height * target_width * image.channel * sizeof(float));
+    result.data    = (float*)malloc(size * size * image.channel * sizeof(float));
 
     for (int k = 0; k < image.channel; k++) {
-        for (int i = 0; i < result.height; i++) {
-            for (int j = 0; j < result.width; j++) {
-                int src_y = std::min(i + h_offset, resized_height - 1);
-                int src_x = std::min(j + w_offset, resized_width - 1);
-                *(result.data + i * result.width * image.channel + j * image.channel + k) =
-                    fmin(fmax(*(resized_data + src_y * resized_width * image.channel + src_x * image.channel + k), 0.0f), 255.0f) / 255.0f;
+        for (int i = 0; i < size; i++) {
+            for (int j = 0; j < size; j++) {
+                *(result.data + i * size * image.channel + j * image.channel + k) =
+                    fmin(fmax(*(resized_data + (i + h) * new_width * image.channel + (j + w) * image.channel + k), 0.0f), 255.0f) / 255.0f;
             }
         }
     }
@@ -491,10 +485,10 @@ sd_image_f32_t clip_preprocess(sd_image_f32_t image, int target_width, int targe
 
     // Normalize
     for (int k = 0; k < image.channel; k++) {
-        for (int i = 0; i < result.height; i++) {
-            for (int j = 0; j < result.width; j++) {
+        for (int i = 0; i < size; i++) {
+            for (int j = 0; j < size; j++) {
                 // *(result.data + i * size * image.channel + j * image.channel + k) = 0.5f;
-                int offset  = i * result.width * image.channel + j * image.channel + k;
+                int offset  = i * size * image.channel + j * image.channel + k;
                 float value = *(result.data + offset);
                 value       = (value - means[k]) / stds[k];
                 // value = 0.5f;

util.h

@@ -42,7 +42,7 @@ sd_image_f32_t sd_image_t_to_sd_image_f32_t(sd_image_t image);
 
 sd_image_f32_t resize_sd_image_f32_t(sd_image_f32_t image, int target_width, int target_height);
 
-sd_image_f32_t clip_preprocess(sd_image_f32_t image, int target_width, int target_height);
+sd_image_f32_t clip_preprocess(sd_image_f32_t image, int size);
 
 std::string path_join(const std::string& p1, const std::string& p2);
 std::vector<std::string> split_string(const std::string& str, char delimiter);

vae.hpp

@@ -583,7 +583,6 @@ struct AutoEncoderKL : public VAE {
                  bool decode_graph,
                  struct ggml_tensor** output,
                  struct ggml_context* output_ctx = NULL) {
-        GGML_ASSERT(!decode_only || decode_graph);
         auto get_graph = [&]() -> struct ggml_cgraph* {
             return build_graph(z, decode_graph);
         };

wan.hpp

@@ -1333,7 +1333,7 @@ namespace WAN {
             k = ggml_reshape_4d(ctx, k, head_dim, num_heads, n_token, N);  // [N, n_token, n_head, d_head]
             v = ggml_reshape_4d(ctx, v, head_dim, num_heads, n_token, N);  // [N, n_token, n_head, d_head]
 
-            x = Rope::attention(ctx, backend, q, k, v, pe, mask, flash_attn);  // [N, n_token, dim]
+            x = Flux::attention(ctx, backend, q, k, v, pe, mask, flash_attn);  // [N, n_token, dim]
 
             x = o_proj->forward(ctx, x);  // [N, n_token, dim]
             return x;
@@ -1833,7 +1833,7 @@ namespace WAN {
                                               struct ggml_tensor* x) {
             int64_t W = x->ne[0];
             int64_t H = x->ne[1];
-            int64_t T = x->ne[2];
+            int64_t T = x->ne[1];
 
             int pad_t = (std::get<0>(params.patch_size) - T % std::get<0>(params.patch_size)) % std::get<0>(params.patch_size);
             int pad_h = (std::get<1>(params.patch_size) - H % std::get<1>(params.patch_size)) % std::get<1>(params.patch_size);