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

Refactor nested if causing error C1061 on MSVC.

Browse source
This commit is contained in:
DAN™ 2024-03-16 10:00:46 -04:00
parent a56d09a440
commit 0de79f7316
1 changed files with 962 additions and 772 deletions
Download patch file Download diff file Expand all files Collapse all files

438
common/common.cpp
View file

@ -139,6 +139,18 @@ bool gpt_params_parse(int argc, char ** argv, gpt_params & params) {
return result; return result;
} }
constexpr std::uint64_t constexpr_hash(const char* input) {
std::uint64_t hash = 0xcbf29ce484222325;
const std::uint64_t prime = 0x100000001b3;
for (; *input; ++input) {
hash ^= static_cast<std::uint64_t>(*input);
hash *= prime;
}
return hash;
}
bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) { bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
bool invalid_param = false; bool invalid_param = false;
std::string arg; std::string arg;
@ -151,13 +163,18 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
std::replace(arg.begin(), arg.end(), '_', '-'); std::replace(arg.begin(), arg.end(), '_', '-');
} }
if (arg == "-s" || arg == "--seed") { switch (constexpr_hash(argv[i]))
{
case constexpr_hash("-s"):
case constexpr_hash("--seed"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.seed = std::stoul(argv[i]); params.seed = std::stoul(argv[i]);
} else if (arg == "-t" || arg == "--threads") { break;
case constexpr_hash("-t"):
case constexpr_hash("--threads"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -166,7 +183,9 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
if (params.n_threads <= 0) { if (params.n_threads <= 0) {
params.n_threads = std::thread::hardware_concurrency(); params.n_threads = std::thread::hardware_concurrency();
} }
} else if (arg == "-tb" || arg == "--threads-batch") { break;
case constexpr_hash("-tb"):
case constexpr_hash("--threads-batch"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -175,7 +194,9 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
if (params.n_threads_batch <= 0) { if (params.n_threads_batch <= 0) {
params.n_threads_batch = std::thread::hardware_concurrency(); params.n_threads_batch = std::thread::hardware_concurrency();
} }
} else if (arg == "-td" || arg == "--threads-draft") { break;
case constexpr_hash("-td"):
case constexpr_hash("--threads-draft"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -184,7 +205,9 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
if (params.n_threads_draft <= 0) { if (params.n_threads_draft <= 0) {
params.n_threads_draft = std::thread::hardware_concurrency(); params.n_threads_draft = std::thread::hardware_concurrency();
} }
} else if (arg == "-tbd" || arg == "--threads-batch-draft") { break;
case constexpr_hash("-tbd"):
case constexpr_hash("--threads-batch-draft"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -193,25 +216,34 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
if (params.n_threads_batch_draft <= 0) { if (params.n_threads_batch_draft <= 0) {
params.n_threads_batch_draft = std::thread::hardware_concurrency(); params.n_threads_batch_draft = std::thread::hardware_concurrency();
} }
} else if (arg == "-p" || arg == "--prompt") { break;
case constexpr_hash("-p"):
case constexpr_hash("--prompt"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.prompt = argv[i]; params.prompt = argv[i];
} else if (arg == "-e" || arg == "--escape") { break;
case constexpr_hash("-e"):
case constexpr_hash("--escape"):
params.escape = true; params.escape = true;
} else if (arg == "--prompt-cache") { break;
case constexpr_hash("--prompt-cache"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.path_prompt_cache = argv[i]; params.path_prompt_cache = argv[i];
} else if (arg == "--prompt-cache-all") { break;
case constexpr_hash("--prompt-cache-all"):
params.prompt_cache_all = true; params.prompt_cache_all = true;
} else if (arg == "--prompt-cache-ro") { break;
case constexpr_hash("--prompt-cache-ro"):
params.prompt_cache_ro = true; params.prompt_cache_ro = true;
} else if (arg == "-bf" || arg == "--binary-file") { break;
case constexpr_hash("-bf"):
case constexpr_hash("--binary-file"): {
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -228,7 +260,10 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
ss << file.rdbuf(); ss << file.rdbuf();
params.prompt = ss.str(); params.prompt = ss.str();
fprintf(stderr, "Read %zu bytes from binary file %s\n", params.prompt.size(), argv[i]); fprintf(stderr, "Read %zu bytes from binary file %s\n", params.prompt.size(), argv[i]);
} else if (arg == "-f" || arg == "--file") { break;
}
case constexpr_hash("-f"):
case constexpr_hash("--file"): {
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -245,51 +280,62 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
if (!params.prompt.empty() && params.prompt.back() == '\n') { if (!params.prompt.empty() && params.prompt.back() == '\n') {
params.prompt.pop_back(); params.prompt.pop_back();
} }
} else if (arg == "-n" || arg == "--n-predict") { break;
}
case constexpr_hash("-n"):
case constexpr_hash("--n-predict"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.n_predict = std::stoi(argv[i]); params.n_predict = std::stoi(argv[i]);
} else if (arg == "--top-k") { break;
case constexpr_hash("--top-k"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.top_k = std::stoi(argv[i]); sparams.top_k = std::stoi(argv[i]);
} else if (arg == "-c" || arg == "--ctx-size") { break;
case constexpr_hash("-c"):
case constexpr_hash("--ctx-size"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.n_ctx = std::stoi(argv[i]); params.n_ctx = std::stoi(argv[i]);
} else if (arg == "--grp-attn-n" || arg == "-gan") { break;
case constexpr_hash("--grp-attn-n"):
case constexpr_hash("-gan"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.grp_attn_n = std::stoi(argv[i]); params.grp_attn_n = std::stoi(argv[i]);
} else if (arg == "--grp-attn-w" || arg == "-gaw") { break;
case constexpr_hash("--grp-attn-w"):
case constexpr_hash("-gaw"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.grp_attn_w = std::stoi(argv[i]); params.grp_attn_w = std::stoi(argv[i]);
} else if (arg == "--rope-freq-base") { break;
case constexpr_hash("--rope-freq-base"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.rope_freq_base = std::stof(argv[i]); params.rope_freq_base = std::stof(argv[i]);
} else if (arg == "--rope-freq-scale") { break;
case constexpr_hash("--rope-freq-scale"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.rope_freq_scale = std::stof(argv[i]); params.rope_freq_scale = std::stof(argv[i]);
} else if (arg == "--rope-scaling") { break;
case constexpr_hash("--rope-scaling"): {
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -299,43 +345,51 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
else if (value == "linear") { params.rope_scaling_type = LLAMA_ROPE_SCALING_TYPE_LINEAR; } else if (value == "linear") { params.rope_scaling_type = LLAMA_ROPE_SCALING_TYPE_LINEAR; }
else if (value == "yarn") { params.rope_scaling_type = LLAMA_ROPE_SCALING_TYPE_YARN; } else if (value == "yarn") { params.rope_scaling_type = LLAMA_ROPE_SCALING_TYPE_YARN; }
else { invalid_param = true; break; } else { invalid_param = true; break; }
} else if (arg == "--rope-scale") { break;
}
case constexpr_hash("--rope-scale"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.rope_freq_scale = 1.0f/std::stof(argv[i]); params.rope_freq_scale = 1.0f / std::stof(argv[i]);
} else if (arg == "--yarn-orig-ctx") { break;
case constexpr_hash("--yarn-orig-ctx"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.yarn_orig_ctx = std::stoi(argv[i]); params.yarn_orig_ctx = std::stoi(argv[i]);
} else if (arg == "--yarn-ext-factor") { break;
case constexpr_hash("--yarn-ext-factor"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.yarn_ext_factor = std::stof(argv[i]); params.yarn_ext_factor = std::stof(argv[i]);
} else if (arg == "--yarn-attn-factor") { break;
case constexpr_hash("--yarn-attn-factor"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.yarn_attn_factor = std::stof(argv[i]); params.yarn_attn_factor = std::stof(argv[i]);
} else if (arg == "--yarn-beta-fast") { break;
case constexpr_hash("--yarn-beta-fast"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.yarn_beta_fast = std::stof(argv[i]); params.yarn_beta_fast = std::stof(argv[i]);
} else if (arg == "--yarn-beta-slow") { break;
case constexpr_hash("--yarn-beta-slow"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.yarn_beta_slow = std::stof(argv[i]); params.yarn_beta_slow = std::stof(argv[i]);
} else if (arg == "--pooling") { break;
case constexpr_hash("--pooling"): {
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -345,118 +399,141 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
else if (value == "mean") { params.pooling_type = LLAMA_POOLING_TYPE_MEAN; } else if (value == "mean") { params.pooling_type = LLAMA_POOLING_TYPE_MEAN; }
else if (value == "cls") { params.pooling_type = LLAMA_POOLING_TYPE_CLS; } else if (value == "cls") { params.pooling_type = LLAMA_POOLING_TYPE_CLS; }
else { invalid_param = true; break; } else { invalid_param = true; break; }
} else if (arg == "--defrag-thold" || arg == "-dt") { break;
}
case constexpr_hash("--defrag-thold"):
case constexpr_hash("-dt"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.defrag_thold = std::stof(argv[i]); params.defrag_thold = std::stof(argv[i]);
} else if (arg == "--samplers") { break;
case constexpr_hash("--samplers"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
{
const auto sampler_names = string_split(argv[i], ';'); const auto sampler_names = string_split(argv[i], ';');
sparams.samplers_sequence = sampler_types_from_names(sampler_names, true); sparams.samplers_sequence = sampler_types_from_names(sampler_names, true);
} else if (arg == "--sampling-seq") { }
break;
case constexpr_hash("--sampling-seq"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.samplers_sequence = sampler_types_from_chars(argv[i]); sparams.samplers_sequence = sampler_types_from_chars(argv[i]);
} else if (arg == "--top-p") { break;
case constexpr_hash("--top-p"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.top_p = std::stof(argv[i]); sparams.top_p = std::stof(argv[i]);
} else if (arg == "--min-p") { break;
case constexpr_hash("--min-p"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.min_p = std::stof(argv[i]); sparams.min_p = std::stof(argv[i]);
} else if (arg == "--temp") { break;
case constexpr_hash("--temp"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.temp = std::stof(argv[i]); sparams.temp = std::stof(argv[i]);
sparams.temp = std::max(sparams.temp, 0.0f); sparams.temp = std::max(sparams.temp, 0.0f);
} else if (arg == "--tfs") { break;
case constexpr_hash("--tfs"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.tfs_z = std::stof(argv[i]); sparams.tfs_z = std::stof(argv[i]);
} else if (arg == "--typical") { break;
case constexpr_hash("--typical"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.typical_p = std::stof(argv[i]); sparams.typical_p = std::stof(argv[i]);
} else if (arg == "--repeat-last-n") { break;
case constexpr_hash("--repeat-last-n"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.penalty_last_n = std::stoi(argv[i]); sparams.penalty_last_n = std::stoi(argv[i]);
sparams.n_prev = std::max(sparams.n_prev, sparams.penalty_last_n); sparams.n_prev = std::max(sparams.n_prev, sparams.penalty_last_n);
} else if (arg == "--repeat-penalty") { break;
case constexpr_hash("--repeat-penalty"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.penalty_repeat = std::stof(argv[i]); sparams.penalty_repeat = std::stof(argv[i]);
} else if (arg == "--frequency-penalty") { break;
case constexpr_hash("--frequency-penalty"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.penalty_freq = std::stof(argv[i]); sparams.penalty_freq = std::stof(argv[i]);
} else if (arg == "--presence-penalty") { break;
case constexpr_hash("--presence-penalty"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.penalty_present = std::stof(argv[i]); sparams.penalty_present = std::stof(argv[i]);
} else if (arg == "--dynatemp-range") { break;
case constexpr_hash("--dynatemp-range"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.dynatemp_range = std::stof(argv[i]); sparams.dynatemp_range = std::stof(argv[i]);
} else if (arg == "--dynatemp-exp") { break;
case constexpr_hash("--dynatemp-exp"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.dynatemp_exponent = std::stof(argv[i]); sparams.dynatemp_exponent = std::stof(argv[i]);
} else if (arg == "--mirostat") { break;
case constexpr_hash("--mirostat"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.mirostat = std::stoi(argv[i]); sparams.mirostat = std::stoi(argv[i]);
} else if (arg == "--mirostat-lr") { break;
case constexpr_hash("--mirostat-lr"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.mirostat_eta = std::stof(argv[i]); sparams.mirostat_eta = std::stof(argv[i]);
} else if (arg == "--mirostat-ent") { break;
case constexpr_hash("--mirostat-ent"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.mirostat_tau = std::stof(argv[i]); sparams.mirostat_tau = std::stof(argv[i]);
} else if (arg == "--cfg-negative-prompt") { break;
case constexpr_hash("--cfg-negative-prompt"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.cfg_negative_prompt = argv[i]; sparams.cfg_negative_prompt = argv[i];
} else if (arg == "--cfg-negative-prompt-file") { break;
case constexpr_hash("--cfg-negative-prompt-file"): {
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -471,86 +548,109 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
if (!sparams.cfg_negative_prompt.empty() && sparams.cfg_negative_prompt.back() == '\n') { if (!sparams.cfg_negative_prompt.empty() && sparams.cfg_negative_prompt.back() == '\n') {
sparams.cfg_negative_prompt.pop_back(); sparams.cfg_negative_prompt.pop_back();
} }
} else if (arg == "--cfg-scale") { break;
}
case constexpr_hash("--cfg-scale"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.cfg_scale = std::stof(argv[i]); sparams.cfg_scale = std::stof(argv[i]);
} else if (arg == "-b" || arg == "--batch-size") { break;
case constexpr_hash("-b"):
case constexpr_hash("--batch-size"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.n_batch = std::stoi(argv[i]); params.n_batch = std::stoi(argv[i]);
} else if (arg == "-ub" || arg == "--ubatch-size") { break;
case constexpr_hash("-ub"):
case constexpr_hash("--ubatch-size"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.n_ubatch = std::stoi(argv[i]); params.n_ubatch = std::stoi(argv[i]);
} else if (arg == "--keep") { break;
case constexpr_hash("--keep"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.n_keep = std::stoi(argv[i]); params.n_keep = std::stoi(argv[i]);
} else if (arg == "--draft") { break;
case constexpr_hash("--draft"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.n_draft = std::stoi(argv[i]); params.n_draft = std::stoi(argv[i]);
} else if (arg == "--chunks") { break;
case constexpr_hash("--chunks"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.n_chunks = std::stoi(argv[i]); params.n_chunks = std::stoi(argv[i]);
} else if (arg == "-np" || arg == "--parallel") { break;
case constexpr_hash("-np"):
case constexpr_hash("--parallel"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.n_parallel = std::stoi(argv[i]); params.n_parallel = std::stoi(argv[i]);
} else if (arg == "-ns" || arg == "--sequences") { break;
case constexpr_hash("-ns"):
case constexpr_hash("--sequences"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.n_sequences = std::stoi(argv[i]); params.n_sequences = std::stoi(argv[i]);
} else if (arg == "--p-split" || arg == "-ps") { break;
case constexpr_hash("--p-split"):
case constexpr_hash("-ps"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.p_split = std::stof(argv[i]); params.p_split = std::stof(argv[i]);
} else if (arg == "-m" || arg == "--model") { break;
case constexpr_hash("-m"):
case constexpr_hash("--model"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.model = argv[i]; params.model = argv[i];
} else if (arg == "-md" || arg == "--model-draft") { break;
case constexpr_hash("-md"):
case constexpr_hash("--model-draft"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.model_draft = argv[i]; params.model_draft = argv[i];
} else if (arg == "-a" || arg == "--alias") { break;
case constexpr_hash("-a"):
case constexpr_hash("--alias"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.model_alias = argv[i]; params.model_alias = argv[i];
} else if (arg == "--lora") { break;
case constexpr_hash("--lora"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.lora_adapter.emplace_back(argv[i], 1.0f); params.lora_adapter.emplace_back(argv[i], 1.0f);
params.use_mmap = false; params.use_mmap = false;
} else if (arg == "--lora-scaled") { break;
case constexpr_hash("--lora-scaled"): {
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -562,30 +662,37 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
} }
params.lora_adapter.emplace_back(lora_adapter, std::stof(argv[i])); params.lora_adapter.emplace_back(lora_adapter, std::stof(argv[i]));
params.use_mmap = false; params.use_mmap = false;
} else if (arg == "--lora-base") { break;
}
case constexpr_hash("--lora-base"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.lora_base = argv[i]; params.lora_base = argv[i];
} else if (arg == "--control-vector") { break;
case constexpr_hash("--control-vector"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.control_vectors.push_back({ 1.0f, argv[i], }); params.control_vectors.push_back({ 1.0f, argv[i], });
} else if (arg == "--control-vector-scaled") { break;
case constexpr_hash("--control-vector-scaled"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
const char * fname = argv[i]; {
const char* fname = argv[i];
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.control_vectors.push_back({ std::stof(argv[i]), fname, }); params.control_vectors.push_back({ std::stof(argv[i]), fname, });
} else if (arg == "--control-vector-layer-range") { }
break;
case constexpr_hash("--control-vector-layer-range"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -596,49 +703,77 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
break; break;
} }
params.control_vector_layer_end = std::stoi(argv[i]); params.control_vector_layer_end = std::stoi(argv[i]);
} else if (arg == "--mmproj") { break;
case constexpr_hash("--mmproj"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.mmproj = argv[i]; params.mmproj = argv[i];
} else if (arg == "--image") { break;
case constexpr_hash("--image"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.image = argv[i]; params.image = argv[i];
} else if (arg == "-i" || arg == "--interactive") { break;
case constexpr_hash("-i"):
case constexpr_hash("--interactive"):
params.interactive = true; params.interactive = true;
} else if (arg == "--embedding") { break;
case constexpr_hash("--embedding"):
params.embedding = true; params.embedding = true;
} else if (arg == "--interactive-first") { break;
case constexpr_hash("--interactive-first"):
params.interactive_first = true; params.interactive_first = true;
} else if (arg == "-ins" || arg == "--instruct") { break;
case constexpr_hash("-ins"):
case constexpr_hash("--instruct"):
params.instruct = true; params.instruct = true;
} else if (arg == "-cml" || arg == "--chatml") { break;
case constexpr_hash("-cml"):
case constexpr_hash("--chatml"):
params.chatml = true; params.chatml = true;
} else if (arg == "--infill") { break;
case constexpr_hash("--infill"):
params.infill = true; params.infill = true;
} else if (arg == "-dkvc" || arg == "--dump-kv-cache") { break;
case constexpr_hash("-dkvc"):
case constexpr_hash("--dump-kv-cache"):
params.dump_kv_cache = true; params.dump_kv_cache = true;
} else if (arg == "-nkvo" || arg == "--no-kv-offload") { break;
case constexpr_hash("-nkvo"):
case constexpr_hash("--no-kv-offload"):
params.no_kv_offload = true; params.no_kv_offload = true;
} else if (arg == "-ctk" || arg == "--cache-type-k") { break;
case constexpr_hash("-ctk"):
case constexpr_hash("--cache-type-k"):
params.cache_type_k = argv[++i]; params.cache_type_k = argv[++i];
} else if (arg == "-ctv" || arg == "--cache-type-v") { break;
case constexpr_hash("-ctv"):
case constexpr_hash("--cache-type-v"):
params.cache_type_v = argv[++i]; params.cache_type_v = argv[++i];
} else if (arg == "--multiline-input") { break;
case constexpr_hash("--multiline-input"):
params.multiline_input = true; params.multiline_input = true;
} else if (arg == "--simple-io") { break;
case constexpr_hash("--simple-io"):
params.simple_io = true; params.simple_io = true;
} else if (arg == "-cb" || arg == "--cont-batching") { break;
case constexpr_hash("-cb"):
case constexpr_hash("--cont-batching"):
params.cont_batching = true; params.cont_batching = true;
} else if (arg == "--color") { break;
case constexpr_hash("--color"):
params.use_color = true; params.use_color = true;
} else if (arg == "--mlock") { break;
case constexpr_hash("--mlock"):
params.use_mlock = true; params.use_mlock = true;
} else if (arg == "--gpu-layers" || arg == "-ngl" || arg == "--n-gpu-layers") { break;
case constexpr_hash("--gpu-layers"):
case constexpr_hash("-ngl"):
case constexpr_hash("--n-gpu-layers"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -648,7 +783,10 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
fprintf(stderr, "warning: not compiled with GPU offload support, --n-gpu-layers option will be ignored\n"); fprintf(stderr, "warning: not compiled with GPU offload support, --n-gpu-layers option will be ignored\n");
fprintf(stderr, "warning: see main README.md for information on enabling GPU BLAS support\n"); fprintf(stderr, "warning: see main README.md for information on enabling GPU BLAS support\n");
} }
} else if (arg == "--gpu-layers-draft" || arg == "-ngld" || arg == "--n-gpu-layers-draft") { break;
case constexpr_hash("--gpu-layers-draft"):
case constexpr_hash("-ngld"):
case constexpr_hash("--n-gpu-layers-draft"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -658,7 +796,9 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
fprintf(stderr, "warning: not compiled with GPU offload support, --n-gpu-layers-draft option will be ignored\n"); fprintf(stderr, "warning: not compiled with GPU offload support, --n-gpu-layers-draft option will be ignored\n");
fprintf(stderr, "warning: see main README.md for information on enabling GPU BLAS support\n"); fprintf(stderr, "warning: see main README.md for information on enabling GPU BLAS support\n");
} }
} else if (arg == "--main-gpu" || arg == "-mg") { break;
case constexpr_hash("--main-gpu"):
case constexpr_hash("-mg"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -667,7 +807,9 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
#ifndef GGML_USE_CUBLAS_SYCL #ifndef GGML_USE_CUBLAS_SYCL
fprintf(stderr, "warning: llama.cpp was compiled without cuBLAS/SYCL. Setting the main GPU has no effect.\n"); fprintf(stderr, "warning: llama.cpp was compiled without cuBLAS/SYCL. Setting the main GPU has no effect.\n");
#endif // GGML_USE_CUBLAS_SYCL #endif // GGML_USE_CUBLAS_SYCL
} else if (arg == "--split-mode" || arg == "-sm") { break;
case constexpr_hash("--split-mode"):
case constexpr_hash("-sm"): {
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -690,8 +832,10 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
#ifndef GGML_USE_CUBLAS_SYCL #ifndef GGML_USE_CUBLAS_SYCL
fprintf(stderr, "warning: llama.cpp was compiled without cuBLAS/SYCL. Setting the split mode has no effect.\n"); fprintf(stderr, "warning: llama.cpp was compiled without cuBLAS/SYCL. Setting the split mode has no effect.\n");
#endif // GGML_USE_CUBLAS_SYCL #endif // GGML_USE_CUBLAS_SYCL
break;
} else if (arg == "--tensor-split" || arg == "-ts") { }
case constexpr_hash("--tensor-split"):
case constexpr_hash("-ts"): {
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -716,9 +860,12 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
#ifndef GGML_USE_CUBLAS_SYCL_VULKAN #ifndef GGML_USE_CUBLAS_SYCL_VULKAN
fprintf(stderr, "warning: llama.cpp was compiled without cuBLAS/SYCL/Vulkan. Setting a tensor split has no effect.\n"); fprintf(stderr, "warning: llama.cpp was compiled without cuBLAS/SYCL/Vulkan. Setting a tensor split has no effect.\n");
#endif // GGML_USE_CUBLAS_SYCL #endif // GGML_USE_CUBLAS_SYCL
} else if (arg == "--no-mmap") { break;
}
case constexpr_hash("--no-mmap"):
params.use_mmap = false; params.use_mmap = false;
} else if (arg == "--numa") { break;
case constexpr_hash("--numa"): {
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -728,17 +875,24 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
else if (value == "isolate") { params.numa = GGML_NUMA_STRATEGY_ISOLATE; } else if (value == "isolate") { params.numa = GGML_NUMA_STRATEGY_ISOLATE; }
else if (value == "numactl") { params.numa = GGML_NUMA_STRATEGY_NUMACTL; } else if (value == "numactl") { params.numa = GGML_NUMA_STRATEGY_NUMACTL; }
else { invalid_param = true; break; } else { invalid_param = true; break; }
} else if (arg == "--verbose-prompt") { break;
}
case constexpr_hash("--verbose-prompt"):
params.verbose_prompt = true; params.verbose_prompt = true;
} else if (arg == "--no-display-prompt") { break;
case constexpr_hash("--no-display-prompt"):
params.display_prompt = false; params.display_prompt = false;
} else if (arg == "-r" || arg == "--reverse-prompt") { break;
case constexpr_hash("-r"):
case constexpr_hash("--reverse-prompt"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.antiprompt.emplace_back(argv[i]); params.antiprompt.emplace_back(argv[i]);
} else if (arg == "-ld" || arg == "--logdir") { break;
case constexpr_hash("-ld"):
case constexpr_hash("--logdir"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -748,63 +902,82 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
if (params.logdir.back() != DIRECTORY_SEPARATOR) { if (params.logdir.back() != DIRECTORY_SEPARATOR) {
params.logdir += DIRECTORY_SEPARATOR; params.logdir += DIRECTORY_SEPARATOR;
} }
} else if (arg == "--save-all-logits" || arg == "--kl-divergence-base") { break;
case constexpr_hash("--save-all-logits"):
case constexpr_hash("--kl-divergence-base"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.logits_file = argv[i]; params.logits_file = argv[i];
} else if (arg == "--perplexity" || arg == "--all-logits") { break;
case constexpr_hash("--perplexity"):
case constexpr_hash("--all-logits"):
params.logits_all = true; params.logits_all = true;
} else if (arg == "--ppl-stride") { break;
case constexpr_hash("--ppl-stride"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.ppl_stride = std::stoi(argv[i]); params.ppl_stride = std::stoi(argv[i]);
} else if (arg == "-ptc" || arg == "--print-token-count") { break;
case constexpr_hash("-ptc"):
case constexpr_hash("--print-token-count"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.n_print = std::stoi(argv[i]); params.n_print = std::stoi(argv[i]);
} else if (arg == "--ppl-output-type") { break;
case constexpr_hash("--ppl-output-type"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.ppl_output_type = std::stoi(argv[i]); params.ppl_output_type = std::stoi(argv[i]);
} else if (arg == "--hellaswag") { break;
case constexpr_hash("--hellaswag"):
params.hellaswag = true; params.hellaswag = true;
} else if (arg == "--hellaswag-tasks") { break;
case constexpr_hash("--hellaswag-tasks"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.hellaswag_tasks = std::stoi(argv[i]); params.hellaswag_tasks = std::stoi(argv[i]);
} else if (arg == "--winogrande") { break;
case constexpr_hash("--winogrande"):
params.winogrande = true; params.winogrande = true;
} else if (arg == "--winogrande-tasks") { break;
case constexpr_hash("--winogrande-tasks"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.winogrande_tasks = std::stoi(argv[i]); params.winogrande_tasks = std::stoi(argv[i]);
} else if (arg == "--multiple-choice") { break;
case constexpr_hash("--multiple-choice"):
params.multiple_choice = true; params.multiple_choice = true;
} else if (arg == "--multiple-choice-tasks") { break;
case constexpr_hash("--multiple-choice-tasks"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.multiple_choice_tasks = std::stoi(argv[i]); params.multiple_choice_tasks = std::stoi(argv[i]);
} else if (arg == "--kl-divergence") { break;
case constexpr_hash("--kl-divergence"):
params.kl_divergence = true; params.kl_divergence = true;
} else if (arg == "--ignore-eos") { break;
case constexpr_hash("--ignore-eos"):
params.ignore_eos = true; params.ignore_eos = true;
} else if (arg == "--no-penalize-nl") { break;
case constexpr_hash("--no-penalize-nl"):
sparams.penalize_nl = false; sparams.penalize_nl = false;
} else if (arg == "-l" || arg == "--logit-bias") { break;
case constexpr_hash("-l"):
case constexpr_hash("--logit-bias"): {
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -823,36 +996,44 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
invalid_param = true; invalid_param = true;
break; break;
} }
} else if (arg == "-h" || arg == "--help") { break;
}
case constexpr_hash("-h"):
case constexpr_hash("--help"):
return false; return false;
case constexpr_hash("--version"):
} else if (arg == "--version") {
fprintf(stderr, "version: %d (%s)\n", LLAMA_BUILD_NUMBER, LLAMA_COMMIT); fprintf(stderr, "version: %d (%s)\n", LLAMA_BUILD_NUMBER, LLAMA_COMMIT);
fprintf(stderr, "built with %s for %s\n", LLAMA_COMPILER, LLAMA_BUILD_TARGET); fprintf(stderr, "built with %s for %s\n", LLAMA_COMPILER, LLAMA_BUILD_TARGET);
exit(0); exit(0);
} else if (arg == "--random-prompt") { break;
case constexpr_hash("--random-prompt"):
params.random_prompt = true; params.random_prompt = true;
} else if (arg == "--in-prefix-bos") { break;
case constexpr_hash("--in-prefix-bos"):
params.input_prefix_bos = true; params.input_prefix_bos = true;
} else if (arg == "--in-prefix") { break;
case constexpr_hash("--in-prefix"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.input_prefix = argv[i]; params.input_prefix = argv[i];
} else if (arg == "--in-suffix") { break;
case constexpr_hash("--in-suffix"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
params.input_suffix = argv[i]; params.input_suffix = argv[i];
} else if (arg == "--grammar") { break;
case constexpr_hash("--grammar"):
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
} }
sparams.grammar = argv[i]; sparams.grammar = argv[i];
} else if (arg == "--grammar-file") { break;
case constexpr_hash("--grammar-file"): {
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -868,7 +1049,9 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
std::istreambuf_iterator<char>(), std::istreambuf_iterator<char>(),
std::back_inserter(sparams.grammar) std::back_inserter(sparams.grammar)
); );
} else if (arg == "--override-kv") { break;
}
case constexpr_hash("--override-kv"): {
if (++i >= argc) { if (++i >= argc) {
invalid_param = true; invalid_param = true;
break; break;
@ -909,11 +1092,15 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
break; break;
} }
params.kv_overrides.push_back(kvo); params.kv_overrides.push_back(kvo);
break;
}
default:
#ifndef LOG_DISABLE_LOGS #ifndef LOG_DISABLE_LOGS
// Parse args for logging parameters // Parse args for logging parameters
} else if ( log_param_single_parse( argv[i] ) ) { if ( log_param_single_parse( argv[i] ) ) {
// Do nothing, log_param_single_parse automatically does it's thing // Do nothing, log_param_single_parse automatically does it's thing
// and returns if a match was found and parsed. // and returns if a match was found and parsed.
break;
} else if ( log_param_pair_parse( /*check_but_dont_parse*/ true, argv[i] ) ) { } else if ( log_param_pair_parse( /*check_but_dont_parse*/ true, argv[i] ) ) {
// We have a matching known parameter requiring an argument, // We have a matching known parameter requiring an argument,
// now we need to check if there is anything after this argv // now we need to check if there is anything after this argv
@ -927,10 +1114,13 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
break; break;
} }
// End of Parse args for logging parameters // End of Parse args for logging parameters
}
#endif // LOG_DISABLE_LOGS #endif // LOG_DISABLE_LOGS
} else {
throw std::invalid_argument("error: unknown argument: " + arg); throw std::invalid_argument("error: unknown argument: " + arg);
} }
if (invalid_param)
break;
} }
if (invalid_param) { if (invalid_param) {
throw std::invalid_argument("error: invalid parameter for argument: " + arg); throw std::invalid_argument("error: invalid parameter for argument: " + arg);