safetensors_loader.cpp File Reference

#include "safetensors_loader.h"
#include "model.h"
#include "logger.h"
#include "model_macros.h"
#include <fstream>
#include <stdexcept>
#include <nlohmann/json.hpp>
#include <algorithm>
#include <cctype>
#include <vector>
#include <string>
#include <map>
#include <memory>
#include <filesystem>
#include <sys/stat.h>
#include <cerrno>

Include dependency graph for safetensors_loader.cpp:

Go to the source code of this file.

Functions
float	cpu_bf16_to_float32 (uint16_t bf16_raw)
float	cpu_f16_to_float32 (uint16_t f16_raw)

Function Documentation

cpu_bf16_to_float32()

float cpu_bf16_to_float32 ( uint16_t  bf16_raw )

inline

Definition at line 31 of file safetensors_loader.cpp.

                                                    {
    unsigned int bits = ((unsigned int)bf16_raw) << 16;
    float result;
    memcpy(&result, &bits, sizeof(float));
    return result;
}

References j.

Referenced by SafeTensorsLoader::convert_tensor_data().

cpu_f16_to_float32()

float cpu_f16_to_float32 ( uint16_t  f16_raw )

inline

Definition at line 37 of file safetensors_loader.cpp.

                                                  {
    const uint32_t sign_mask_f16 = 0x8000;
    const uint32_t exp_mask_f16 = 0x7C00;
    const uint32_t mant_mask_f16 = 0x03FF;
    const int32_t exp_bias_f16 = 15;
    const int32_t exp_bias_f32 = 127;
 
    uint32_t sign_f32 = (static_cast<uint32_t>(f16_raw & sign_mask_f16)) << 16;
    int32_t exp_f16 = (f16_raw & exp_mask_f16) >> 10;
    uint32_t mant_f16 = (f16_raw & mant_mask_f16);
 
    uint32_t f32_bits;
 
    if (exp_f16 == 0x1F) { // F16 NaN or Inf
        f32_bits = sign_f32 | 0x7F800000U | (mant_f16 << 13); // Propagate mantissa for NaN
    } else if (exp_f16 == 0) { // F16 zero or subnormal
        if (mant_f16 == 0) { // Zero
            f32_bits = sign_f32;
        } else { // Subnormal F16 to normal or subnormal F32
            int32_t s = -1;
            mant_f16 <<= 1;
            while ((mant_f16 & 0x0400) == 0) {
                mant_f16 <<= 1;
                s--;
            }
            mant_f16 &= 0x03FF; // Clear leading 1
            int32_t f32_exp_val = (1 - exp_bias_f16) + s + exp_bias_f32;
            if (f32_exp_val <= 0) { // Result is subnormal F32 or zero
                int32_t shift = 1 - f32_exp_val;
                if (shift > 23) { // Underflow to zero
                     f32_bits = sign_f32;
                } else {
                     f32_bits = sign_f32 | ((mant_f16 << 13) >> shift) ; 
                }
            } else { // Result is normal F32
                 f32_bits = sign_f32 | (static_cast<uint32_t>(f32_exp_val) << 23) | (mant_f16 << 13);
            }
        }
    } else { // Normal F16
        int32_t f32_exp = exp_f16 - exp_bias_f16 + exp_bias_f32;
        f32_bits = sign_f32 | (static_cast<uint32_t>(f32_exp) << 23) | (mant_f16 << 13);
    }
 
    float result;
    memcpy(&result, &f32_bits, sizeof(float));
    return result;
}

References j.

Referenced by SafeTensorsLoader::convert_tensor_data().