vbatts/llama.cpp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Editorconfig

Browse source
This commit is contained in:
M. Yusuf Sarıgöz 2023-11-05 15:22:47 +03:00
parent 803703478d
commit 52143f799b
2 changed files with 288 additions and 290 deletions
Download patch file Download diff file Expand all files Collapse all files

574
common/base64.hpp
View file

@ -36,357 +36,357 @@ For more information, please refer to <http://unlicense.org>
class base64_error : public std::runtime_error class base64_error : public std::runtime_error
{ {
public: public:
using std::runtime_error::runtime_error; using std::runtime_error::runtime_error;
}; };
class base64 class base64
{ {
public: public:
enum class alphabet enum class alphabet
{ {
/** the alphabet is detected automatically */ /** the alphabet is detected automatically */
auto_, auto_,
/** the standard base64 alphabet is used */ /** the standard base64 alphabet is used */
standard, standard,
/** like `standard` except that the characters `+` and `/` are replaced by `-` and `_` respectively*/ /** like `standard` except that the characters `+` and `/` are replaced by `-` and `_` respectively*/
url_filename_safe url_filename_safe
}; };
enum class decoding_behavior enum class decoding_behavior
{ {
/** if the input is not padded, the remaining bits are ignored */ /** if the input is not padded, the remaining bits are ignored */
moderate, moderate,
/** if a padding character is encounter decoding is finished */ /** if a padding character is encounter decoding is finished */
loose loose
}; };
/** /**
Encodes all the elements from `in_begin` to `in_end` to `out`. Encodes all the elements from `in_begin` to `in_end` to `out`.
@warning The source and destination cannot overlap. The destination must be able to hold at least @warning The source and destination cannot overlap. The destination must be able to hold at least
`required_encode_size(std::distance(in_begin, in_end))`, otherwise the behavior depends on the output iterator. `required_encode_size(std::distance(in_begin, in_end))`, otherwise the behavior depends on the output iterator.
@tparam Input_iterator the source; the returned elements are cast to `std::uint8_t` and should not be greater than @tparam Input_iterator the source; the returned elements are cast to `std::uint8_t` and should not be greater than
8 bits 8 bits
@tparam Output_iterator the destination; the elements written to it are from the type `char` @tparam Output_iterator the destination; the elements written to it are from the type `char`
@param in_begin the beginning of the source @param in_begin the beginning of the source
@param in_end the ending of the source @param in_end the ending of the source
@param out the destination iterator @param out the destination iterator
@param alphabet which alphabet should be used @param alphabet which alphabet should be used
@returns the iterator to the next element past the last element copied @returns the iterator to the next element past the last element copied
@throws see `Input_iterator` and `Output_iterator` @throws see `Input_iterator` and `Output_iterator`
*/ */
template<typename Input_iterator, typename Output_iterator> template<typename Input_iterator, typename Output_iterator>
static Output_iterator encode(Input_iterator in_begin, Input_iterator in_end, Output_iterator out, static Output_iterator encode(Input_iterator in_begin, Input_iterator in_end, Output_iterator out,
alphabet alphabet = alphabet::standard) alphabet alphabet = alphabet::standard)
{ {
constexpr auto pad = '='; constexpr auto pad = '=';
const char* alpha = alphabet == alphabet::url_filename_safe const char* alpha = alphabet == alphabet::url_filename_safe
? "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" ? "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
while (in_begin != in_end) { while (in_begin != in_end) {
std::uint8_t i0 = 0, i1 = 0, i2 = 0; std::uint8_t i0 = 0, i1 = 0, i2 = 0;
// first character // first character
i0 = static_cast<std::uint8_t>(*in_begin); i0 = static_cast<std::uint8_t>(*in_begin);
++in_begin; ++in_begin;
*out = alpha[i0 >> 2 & 0x3f]; *out = alpha[i0 >> 2 & 0x3f];
++out; ++out;
// part of first character and second // part of first character and second
if (in_begin != in_end) { if (in_begin != in_end) {
i1 = static_cast<std::uint8_t>(*in_begin); i1 = static_cast<std::uint8_t>(*in_begin);
++in_begin; ++in_begin;
*out = alpha[((i0 & 0x3) << 4) | (i1 >> 4 & 0x0f)]; *out = alpha[((i0 & 0x3) << 4) | (i1 >> 4 & 0x0f)];
++out; ++out;
} else { } else {
*out = alpha[(i0 & 0x3) << 4]; *out = alpha[(i0 & 0x3) << 4];
++out; ++out;
// last padding // last padding
*out = pad; *out = pad;
++out; ++out;
// last padding // last padding
*out = pad; *out = pad;
++out; ++out;
break; break;
} }
// part of second character and third // part of second character and third
if (in_begin != in_end) { if (in_begin != in_end) {
i2 = static_cast<std::uint8_t>(*in_begin); i2 = static_cast<std::uint8_t>(*in_begin);
++in_begin; ++in_begin;
*out = alpha[((i1 & 0xf) << 2) | (i2 >> 6 & 0x03)]; *out = alpha[((i1 & 0xf) << 2) | (i2 >> 6 & 0x03)];
++out; ++out;
} else { } else {
*out = alpha[(i1 & 0xf) << 2]; *out = alpha[(i1 & 0xf) << 2];
++out; ++out;
// last padding // last padding
*out = pad; *out = pad;
++out; ++out;
break; break;
} }
// rest of third // rest of third
*out = alpha[i2 & 0x3f]; *out = alpha[i2 & 0x3f];
++out; ++out;
} }
return out; return out;
} }
/** /**
Encodes a string. Encodes a string.
@param str the string that should be encoded @param str the string that should be encoded
@param alphabet which alphabet should be used @param alphabet which alphabet should be used
@returns the encoded base64 string @returns the encoded base64 string
@throws see base64::encode() @throws see base64::encode()
*/ */
static std::string encode(const std::string& str, alphabet alphabet = alphabet::standard) static std::string encode(const std::string& str, alphabet alphabet = alphabet::standard)
{ {
std::string result; std::string result;
result.reserve(required_encode_size(str.length()) + 1); result.reserve(required_encode_size(str.length()) + 1);
encode(str.begin(), str.end(), std::back_inserter(result), alphabet); encode(str.begin(), str.end(), std::back_inserter(result), alphabet);
return result; return result;
} }
/** /**
Encodes a char array. Encodes a char array.
@param buffer the char array @param buffer the char array
@param size the size of the array @param size the size of the array
@param alphabet which alphabet should be used @param alphabet which alphabet should be used
@returns the encoded string @returns the encoded string
*/ */
static std::string encode(const char* buffer, std::size_t size, alphabet alphabet = alphabet::standard) static std::string encode(const char* buffer, std::size_t size, alphabet alphabet = alphabet::standard)
{ {
std::string result; std::string result;
result.reserve(required_encode_size(size) + 1); result.reserve(required_encode_size(size) + 1);
encode(buffer, buffer + size, std::back_inserter(result), alphabet); encode(buffer, buffer + size, std::back_inserter(result), alphabet);
return result; return result;
} }
/** /**
Decodes all the elements from `in_begin` to `in_end` to `out`. `in_begin` may point to the same location as `out`, Decodes all the elements from `in_begin` to `in_end` to `out`. `in_begin` may point to the same location as `out`,
in other words: inplace decoding is possible. in other words: inplace decoding is possible.
@warning The destination must be able to hold at least `required_decode_size(std::distance(in_begin, in_end))`, @warning The destination must be able to hold at least `required_decode_size(std::distance(in_begin, in_end))`,
otherwise the behavior depends on the output iterator. otherwise the behavior depends on the output iterator.
@tparam Input_iterator the source; the returned elements are cast to `char` @tparam Input_iterator the source; the returned elements are cast to `char`
@tparam Output_iterator the destination; the elements written to it are from the type `std::uint8_t` @tparam Output_iterator the destination; the elements written to it are from the type `std::uint8_t`
@param in_begin the beginning of the source @param in_begin the beginning of the source
@param in_end the ending of the source @param in_end the ending of the source
@param out the destination iterator @param out the destination iterator
@param alphabet which alphabet should be used @param alphabet which alphabet should be used
@param behavior the behavior when an error was detected @param behavior the behavior when an error was detected
@returns the iterator to the next element past the last element copied @returns the iterator to the next element past the last element copied
@throws base64_error depending on the set behavior @throws base64_error depending on the set behavior
@throws see `Input_iterator` and `Output_iterator` @throws see `Input_iterator` and `Output_iterator`
*/ */
template<typename Input_iterator, typename Output_iterator> template<typename Input_iterator, typename Output_iterator>
static Output_iterator decode(Input_iterator in_begin, Input_iterator in_end, Output_iterator out, static Output_iterator decode(Input_iterator in_begin, Input_iterator in_end, Output_iterator out,
alphabet alphabet = alphabet::auto_, alphabet alphabet = alphabet::auto_,
decoding_behavior behavior = decoding_behavior::moderate) decoding_behavior behavior = decoding_behavior::moderate)
{ {
//constexpr auto pad = '='; //constexpr auto pad = '=';
std::uint8_t last = 0; std::uint8_t last = 0;
auto bits = 0; auto bits = 0;
while (in_begin != in_end) { while (in_begin != in_end) {
auto c = *in_begin; auto c = *in_begin;
++in_begin; ++in_begin;
if (c == '=') { if (c == '=') {
break; break;
} }
auto part = _base64_value(alphabet, c); auto part = _base64_value(alphabet, c);
// enough bits for one byte // enough bits for one byte
if (bits + 6 >= 8) { if (bits + 6 >= 8) {
*out = (last << (8 - bits)) | (part >> (bits - 2)); *out = (last << (8 - bits)) | (part >> (bits - 2));
++out; ++out;
bits -= 2; bits -= 2;
} else { } else {
bits += 6; bits += 6;
} }
last = part; last = part;
} }
// check padding // check padding
if (behavior != decoding_behavior::loose) { if (behavior != decoding_behavior::loose) {
while (in_begin != in_end) { while (in_begin != in_end) {
auto c = *in_begin; auto c = *in_begin;
++in_begin; ++in_begin;
if (c != '=') { if (c != '=') {
throw base64_error("invalid base64 character."); throw base64_error("invalid base64 character.");
} }
} }
} }
return out; return out;
} }
/** /**
Decodes a string. Decodes a string.
@param str the base64 encoded string @param str the base64 encoded string
@param alphabet which alphabet should be used @param alphabet which alphabet should be used
@param behavior the behavior when an error was detected @param behavior the behavior when an error was detected
@returns the decoded string @returns the decoded string
@throws see base64::decode() @throws see base64::decode()
*/ */
static std::string decode(const std::string& str, alphabet alphabet = alphabet::auto_, static std::string decode(const std::string& str, alphabet alphabet = alphabet::auto_,
decoding_behavior behavior = decoding_behavior::moderate) decoding_behavior behavior = decoding_behavior::moderate)
{ {
std::string result; std::string result;
result.reserve(max_decode_size(str.length())); result.reserve(max_decode_size(str.length()));
decode(str.begin(), str.end(), std::back_inserter(result), alphabet, behavior); decode(str.begin(), str.end(), std::back_inserter(result), alphabet, behavior);
return result; return result;
} }
/** /**
Decodes a string. Decodes a string.
@param buffer the base64 encoded buffer @param buffer the base64 encoded buffer
@param size the size of the buffer @param size the size of the buffer
@param alphabet which alphabet should be used @param alphabet which alphabet should be used
@param behavior the behavior when an error was detected @param behavior the behavior when an error was detected
@returns the decoded string @returns the decoded string
@throws see base64::decode() @throws see base64::decode()
*/ */
static std::string decode(const char* buffer, std::size_t size, alphabet alphabet = alphabet::auto_, static std::string decode(const char* buffer, std::size_t size, alphabet alphabet = alphabet::auto_,
decoding_behavior behavior = decoding_behavior::moderate) decoding_behavior behavior = decoding_behavior::moderate)
{ {
std::string result; std::string result;
result.reserve(max_decode_size(size)); result.reserve(max_decode_size(size));
decode(buffer, buffer + size, std::back_inserter(result), alphabet, behavior); decode(buffer, buffer + size, std::back_inserter(result), alphabet, behavior);
return result; return result;
} }
/** /**
Decodes a string inplace. Decodes a string inplace.
@param[in,out] str the base64 encoded string @param[in,out] str the base64 encoded string
@param alphabet which alphabet should be used @param alphabet which alphabet should be used
@param behavior the behavior when an error was detected @param behavior the behavior when an error was detected
@throws base64::decode_inplace() @throws base64::decode_inplace()
*/ */
static void decode_inplace(std::string& str, alphabet alphabet = alphabet::auto_, static void decode_inplace(std::string& str, alphabet alphabet = alphabet::auto_,
decoding_behavior behavior = decoding_behavior::moderate) decoding_behavior behavior = decoding_behavior::moderate)
{ {
str.resize(decode(str.begin(), str.end(), str.begin(), alphabet, behavior) - str.begin()); str.resize(decode(str.begin(), str.end(), str.begin(), alphabet, behavior) - str.begin());
} }
/** /**
Decodes a char array inplace. Decodes a char array inplace.
@param[in,out] str the string array @param[in,out] str the string array
@param size the length of the array @param size the length of the array
@param alphabet which alphabet should be used @param alphabet which alphabet should be used
@param behavior the behavior when an error was detected @param behavior the behavior when an error was detected
@returns the pointer to the next element past the last element decoded @returns the pointer to the next element past the last element decoded
@throws base64::decode_inplace() @throws base64::decode_inplace()
*/ */
static char* decode_inplace(char* str, std::size_t size, alphabet alphabet = alphabet::auto_, static char* decode_inplace(char* str, std::size_t size, alphabet alphabet = alphabet::auto_,
decoding_behavior behavior = decoding_behavior::moderate) decoding_behavior behavior = decoding_behavior::moderate)
{ {
return decode(str, str + size, str, alphabet, behavior); return decode(str, str + size, str, alphabet, behavior);
} }
/** /**
Returns the required decoding size for a given size. The value is calculated with the following formula: Returns the required decoding size for a given size. The value is calculated with the following formula:
$$ $$
\lceil \frac{size}{4} \rceil \cdot 3 \lceil \frac{size}{4} \rceil \cdot 3
$$ $$
@param size the size of the encoded input @param size the size of the encoded input
@returns the size of the resulting decoded buffer; this the absolute maximum @returns the size of the resulting decoded buffer; this the absolute maximum
*/ */
static std::size_t max_decode_size(std::size_t size) noexcept static std::size_t max_decode_size(std::size_t size) noexcept
{ {
return (size / 4 + (size % 4 ? 1 : 0)) * 3; return (size / 4 + (size % 4 ? 1 : 0)) * 3;
} }
/** /**
Returns the required encoding size for a given size. The value is calculated with the following formula: Returns the required encoding size for a given size. The value is calculated with the following formula:
$$ $$
\lceil \frac{size}{3} \rceil \cdot 4 \lceil \frac{size}{3} \rceil \cdot 4
$$ $$
@param size the size of the decoded input @param size the size of the decoded input
@returns the size of the resulting encoded buffer @returns the size of the resulting encoded buffer
*/ */
static std::size_t required_encode_size(std::size_t size) noexcept static std::size_t required_encode_size(std::size_t size) noexcept
{ {
return (size / 3 + (size % 3 ? 1 : 0)) * 4; return (size / 3 + (size % 3 ? 1 : 0)) * 4;
} }
private: private:
static std::uint8_t _base64_value(alphabet& alphabet, char c) static std::uint8_t _base64_value(alphabet& alphabet, char c)
{ {
if (c >= 'A' && c <= 'Z') { if (c >= 'A' && c <= 'Z') {
return c - 'A'; return c - 'A';
} else if (c >= 'a' && c <= 'z') { } else if (c >= 'a' && c <= 'z') {
return c - 'a' + 26; return c - 'a' + 26;
} else if (c >= '0' && c <= '9') { } else if (c >= '0' && c <= '9') {
return c - '0' + 52; return c - '0' + 52;
} }
// comes down to alphabet // comes down to alphabet
if (alphabet == alphabet::standard) { if (alphabet == alphabet::standard) {
if (c == '+') { if (c == '+') {
return 62; return 62;
} else if (c == '/') { } else if (c == '/') {
return 63; return 63;
} }
} else if (alphabet == alphabet::url_filename_safe) { } else if (alphabet == alphabet::url_filename_safe) {
if (c == '-') { if (c == '-') {
return 62; return 62;
} else if (c == '_') { } else if (c == '_') {
return 63; return 63;
} }
} // auto detect } // auto detect
else { else {
if (c == '+') { if (c == '+') {
alphabet = alphabet::standard; alphabet = alphabet::standard;
return 62; return 62;
} else if (c == '/') { } else if (c == '/') {
alphabet = alphabet::standard; alphabet = alphabet::standard;
return 63; return 63;
} else if (c == '-') { } else if (c == '-') {
alphabet = alphabet::url_filename_safe; alphabet = alphabet::url_filename_safe;
return 62; return 62;
} else if (c == '_') { } else if (c == '_') {
alphabet = alphabet::url_filename_safe; alphabet = alphabet::url_filename_safe;
return 63; return 63;
} }
} }
throw base64_error("invalid base64 character."); throw base64_error("invalid base64 character.");
} }
}; };
#endif // !PUBLIC_DOMAIN_BASE64_HPP_ #endif // !PUBLIC_DOMAIN_BASE64_HPP_

4
examples/llava/llava-cli.cpp
View file

@ -74,19 +74,17 @@ static void process_prompt(struct llava_context * ctx_llava, struct llava_image_
} }
printf("\n"); printf("\n");
} }
static struct llava_context * llava_init(gpt_params * params) { static struct llava_context * llava_init(gpt_params * params) {
const char * clip_path = params->mmproj.c_str(); const char * clip_path = params->mmproj.c_str();
auto prompt = params->prompt; auto prompt = params->prompt;
if (prompt.empty()) { if (prompt.empty()) {
prompt = "describe the image in detail."; prompt = "describe the image in detail.";
} }
auto ctx_clip = clip_model_load(clip_path, /*verbosity=*/ 1); auto ctx_clip = clip_model_load(clip_path, /*verbosity=*/ 1);
llama_backend_init(params->numa); llama_backend_init(params->numa);