mirror of
https://github.com/ggerganov/llama.cpp.git
synced 2024-12-27 03:44:35 +00:00
cf658adc83
* llama : refactor GGUF constants into static maps * llama : check if model architecture is known * llama : refactor llama_model_load_internal() * gguf : add KV constant maps * llm : read arch-specific KVs * convert : add dummy scores + types * falcon : load tensor data (CPU only) * llama : fix loading progress bar * llama : add arch member to llama_model * falcon : CPU inference working * falcon : support non-40B models * falcon : minor * llama : minor updates ggml-ci * convert-falcon-hf-to-gguf.py : fix special token mapping * llama.cpp : llama default UNK token = id 0 * llama.cpp : fix bpe tokenizer * llama.cpp : fix the fix of bpe tokenizer * ggml : pass eps to ggml_norm * metal : implement RoPE (mode = 2) + avoid ggml_repeat * ggml : ggml_repeat always creates new tensor * falcon : copy-paste self-attention from LLaMA * metal : print extra compute pipeline info * falcon : minor changes (still chasing the Metal problem) * llama.cpp : fix linefeed token * metal : fix GELU kernel numerical stability by using precise::tanh * metal : temporary workaround for the concurrency optimization bug * falcon : add CUDA offloading (#2739) * llama : better model naming and size reporting * llama : prep new tokenizer support * llama : advanced BPE tokenizer based on ggllm.cpp imlpementation * llama : remove oboslete comment ggml-ci * common : remove obsolete BPE API + disable test-tokenizer-1 * llama : revert BPE special-case in llama_byte_to_token() * cuda : add TODOs for RoPE NeoX implementation * llama : default special tokens based on vocab type * perplexity : add log for start of tokenization --------- Co-authored-by: klosax <131523366+klosax@users.noreply.github.com> Co-authored-by: slaren <slarengh@gmail.com>
117 lines
3.4 KiB
C++
117 lines
3.4 KiB
C++
#include "llama.h"
|
|
#include "common.h"
|
|
|
|
#include <cassert>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <string>
|
|
#include <codecvt>
|
|
#include <map>
|
|
#include <vector>
|
|
#include <locale>
|
|
|
|
static std::string escape_whitespace(const std::string& text) {
|
|
std::string result = "\xe2\x96\x81";
|
|
for (size_t offs = 0; offs < text.length(); ++offs) {
|
|
if (text[offs] == ' ') {
|
|
result += "\xe2\x96\x81";
|
|
} else {
|
|
result += text[offs];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static std::string unescape_whitespace(llama_context * ctx, const std::vector<llama_token> & tokens) {
|
|
std::string result;
|
|
for (size_t i = 0; i < tokens.size(); ++i) {
|
|
result += llama_token_to_str(ctx, tokens[i]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
if (argc < 2) {
|
|
fprintf(stderr, "Usage: %s <vocab-file>\n", argv[0]);
|
|
return 1;
|
|
}
|
|
|
|
const std::string fname = argv[1];
|
|
|
|
fprintf(stderr, "%s : reading vocab from: '%s'\n", __func__, fname.c_str());
|
|
|
|
llama_model * model;
|
|
llama_context * ctx;
|
|
|
|
llama_backend_init(false);
|
|
|
|
// load the vocab
|
|
{
|
|
auto lparams = llama_context_default_params();
|
|
|
|
lparams.vocab_only = true;
|
|
|
|
model = llama_load_model_from_file(fname.c_str(), lparams);
|
|
|
|
if (model == NULL) {
|
|
fprintf(stderr, "%s: error: failed to load vocab '%s'\n", __func__, fname.c_str());
|
|
return 1;
|
|
}
|
|
|
|
ctx = llama_new_context_with_model(model, lparams);
|
|
|
|
if (ctx == NULL) {
|
|
fprintf(stderr, "%s: error: failed to load vocab '%s'\n", __func__, fname.c_str());
|
|
llama_free_model(model);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
GGML_ASSERT(llama_vocab_type(ctx) == LLAMA_VOCAB_TYPE_BPE);
|
|
|
|
const int n_vocab = llama_n_vocab(ctx);
|
|
|
|
for (int i = 0; i < n_vocab; ++i) {
|
|
std::string forward = llama_token_to_str(ctx, i);
|
|
std::vector<llama_token> tokens = llama_tokenize(ctx, forward, false);
|
|
if (tokens.size() == 1) {
|
|
if (i != tokens[0]) {
|
|
std::string backward = llama_token_to_str(ctx, tokens[0]);
|
|
fprintf(stderr, "%s : error: token %d is string %s but bpe returns token %d %s\n",
|
|
__func__, i, llama_token_to_str(ctx, i).c_str(), tokens[0], backward.c_str());
|
|
return 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
std::wstring_convert<typename std::codecvt_utf8<char16_t>, char16_t> u16converter;
|
|
for (char16_t ch = 0x0000; ch < 0xffff; ++ch) {
|
|
std::u16string u16str(1, ch);
|
|
std::string str = u16converter.to_bytes(u16str);
|
|
std::vector<llama_token> tokens = llama_tokenize(ctx, escape_whitespace(str).c_str(), false);
|
|
if (tokens.size() == 1) {
|
|
fprintf(stderr, "%s : info: %s tokenized to %d \n",
|
|
__func__, str.c_str(), tokens[0]);
|
|
}
|
|
}
|
|
|
|
std::wstring_convert<typename std::codecvt_utf8<char32_t>, char32_t> u32converter;
|
|
for (char32_t ch = 0x0000; ch < 0x0010ffff; ++ch) {
|
|
std::u32string u32str(1, ch);
|
|
std::string str = u32converter.to_bytes(u32str);
|
|
std::vector<llama_token> tokens = llama_tokenize(ctx, escape_whitespace(str).c_str(), false);
|
|
if (tokens.size() == 1) {
|
|
fprintf(stderr, "%s : info: %s tokenized to %d \n", __func__, str.c_str(), tokens[0]);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
llama_free_model(model);
|
|
llama_free(ctx);
|
|
|
|
llama_backend_free();
|
|
|
|
return 0;
|
|
}
|