2023-03-25 19:26:40 +01:00
|
|
|
#include "common.h"
|
|
|
|
#include "llama.h"
|
2023-05-01 18:23:47 +02:00
|
|
|
#include "build-info.h"
|
2023-03-25 19:26:40 +01:00
|
|
|
|
2023-03-28 18:48:20 +02:00
|
|
|
#include <cmath>
|
2023-04-16 12:13:00 +02:00
|
|
|
#include <ctime>
|
2023-03-28 18:48:20 +02:00
|
|
|
|
2023-06-16 20:23:53 +02:00
|
|
|
#if defined(_MSC_VER)
|
|
|
|
#pragma warning(disable: 4244 4267) // possible loss of data
|
|
|
|
#endif
|
|
|
|
|
2023-03-28 18:48:20 +02:00
|
|
|
std::vector<float> softmax(const std::vector<float>& logits) {
|
|
|
|
std::vector<float> probs(logits.size());
|
2023-03-25 19:26:40 +01:00
|
|
|
float max_logit = logits[0];
|
|
|
|
for (float v : logits) max_logit = std::max(max_logit, v);
|
|
|
|
double sum_exp = 0.0;
|
|
|
|
for (size_t i = 0; i < logits.size(); i++) {
|
|
|
|
// Subtract the maximum logit value from the current logit value for numerical stability
|
2023-03-28 18:48:20 +02:00
|
|
|
const float logit = logits[i] - max_logit;
|
|
|
|
const float exp_logit = expf(logit);
|
2023-03-25 19:26:40 +01:00
|
|
|
sum_exp += exp_logit;
|
|
|
|
probs[i] = exp_logit;
|
|
|
|
}
|
|
|
|
for (size_t i = 0; i < probs.size(); i++) probs[i] /= sum_exp;
|
|
|
|
return probs;
|
|
|
|
}
|
|
|
|
|
|
|
|
void perplexity(llama_context * ctx, const gpt_params & params) {
|
|
|
|
// Download: https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-2-raw-v1.zip?ref=salesforce-research
|
2023-03-26 15:14:01 +02:00
|
|
|
// Run `./perplexity -m models/7B/ggml-model-q4_0.bin -f wiki.test.raw`
|
2023-03-25 19:26:40 +01:00
|
|
|
// Output: `perplexity: 13.5106 [114/114]`
|
2023-05-08 16:41:54 +02:00
|
|
|
// BOS tokens will be added for each chunk before eval
|
2023-03-25 19:26:40 +01:00
|
|
|
auto tokens = ::llama_tokenize(ctx, params.prompt, true);
|
|
|
|
|
2023-05-08 16:41:54 +02:00
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
const int n_chunk = tokens.size() / params.n_ctx;
|
|
|
|
const int n_vocab = llama_n_vocab(ctx);
|
|
|
|
const int n_batch = params.n_batch;
|
2023-03-25 19:26:40 +01:00
|
|
|
|
2023-03-28 18:48:20 +02:00
|
|
|
double nll = 0.0;
|
2023-05-08 16:41:54 +02:00
|
|
|
fprintf(stderr, "%s: calculating perplexity over %d chunks, batch_size=%d\n", __func__, n_chunk, n_batch);
|
|
|
|
|
|
|
|
for (int i = 0; i < n_chunk; ++i) {
|
|
|
|
const int start = i * params.n_ctx;
|
|
|
|
const int end = start + params.n_ctx;
|
2023-03-25 19:26:40 +01:00
|
|
|
|
2023-05-08 16:41:54 +02:00
|
|
|
const int num_batches = (params.n_ctx + n_batch - 1) / n_batch;
|
2023-04-13 23:50:42 +02:00
|
|
|
|
|
|
|
std::vector<float> logits;
|
2023-05-08 16:41:54 +02:00
|
|
|
|
|
|
|
const auto t_start = std::chrono::high_resolution_clock::now();
|
|
|
|
|
2023-04-13 23:50:42 +02:00
|
|
|
for (int j = 0; j < num_batches; ++j) {
|
2023-05-08 16:41:54 +02:00
|
|
|
const int batch_start = start + j * n_batch;
|
|
|
|
const int batch_size = std::min(end - batch_start, n_batch);
|
|
|
|
|
|
|
|
// save original token and restore it after eval
|
|
|
|
const auto token_org = tokens[batch_start];
|
|
|
|
|
|
|
|
// add BOS token for the first batch of each chunk
|
|
|
|
if (j == 0) {
|
|
|
|
tokens[batch_start] = llama_token_bos();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (llama_eval(ctx, tokens.data() + batch_start, batch_size, j * n_batch, params.n_threads)) {
|
2023-04-13 23:50:42 +02:00
|
|
|
fprintf(stderr, "%s : failed to eval\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
2023-05-08 16:41:54 +02:00
|
|
|
|
|
|
|
// restore the original token in case it was set to BOS
|
|
|
|
tokens[batch_start] = token_org;
|
|
|
|
|
|
|
|
const auto batch_logits = llama_get_logits(ctx);
|
2023-04-13 23:50:42 +02:00
|
|
|
logits.insert(logits.end(), batch_logits, batch_logits + batch_size * n_vocab);
|
2023-03-25 19:26:40 +01:00
|
|
|
}
|
2023-05-08 16:41:54 +02:00
|
|
|
|
|
|
|
const auto t_end = std::chrono::high_resolution_clock::now();
|
|
|
|
|
2023-03-25 19:26:40 +01:00
|
|
|
if (i == 0) {
|
2023-05-08 16:41:54 +02:00
|
|
|
const float t_total = std::chrono::duration<float>(t_end - t_start).count();
|
|
|
|
fprintf(stderr, "%s: %.2f seconds per pass - ETA ", __func__, t_total);
|
|
|
|
int total_seconds = (int)(t_total * n_chunk);
|
2023-04-21 14:57:57 +02:00
|
|
|
if (total_seconds >= 60*60) {
|
2023-05-08 16:41:54 +02:00
|
|
|
fprintf(stderr, "%d hours ", total_seconds / (60*60));
|
2023-04-21 14:57:57 +02:00
|
|
|
total_seconds = total_seconds % (60*60);
|
|
|
|
}
|
2023-05-08 16:41:54 +02:00
|
|
|
fprintf(stderr, "%d minutes\n", total_seconds / 60);
|
2023-03-25 19:26:40 +01:00
|
|
|
}
|
2023-05-08 16:41:54 +02:00
|
|
|
|
2023-03-25 19:26:40 +01:00
|
|
|
// We get the logits for all the tokens in the context window (params.n_ctx)
|
|
|
|
// from llama_eval above. Now, based on https://huggingface.co/docs/transformers/perplexity,
|
2023-05-08 16:41:54 +02:00
|
|
|
// calculate the perplexity over the last half of the window (so the model always has
|
2023-03-25 19:26:40 +01:00
|
|
|
// some context to predict the token).
|
|
|
|
//
|
|
|
|
// We rely on the fact that attention in the forward pass only looks at previous
|
|
|
|
// tokens here, so the logits returned for each token are an accurate representation
|
|
|
|
// of what the model would have predicted at that point.
|
|
|
|
//
|
|
|
|
// Example, we have a context window of 512, we will compute perplexity for each of the
|
|
|
|
// last 256 tokens. Then, we split the input up into context window size chunks to
|
|
|
|
// process the entire prompt.
|
2023-04-13 23:50:42 +02:00
|
|
|
for (int j = std::min(512, params.n_ctx / 2); j < params.n_ctx - 1; ++j) {
|
2023-03-25 19:26:40 +01:00
|
|
|
// Calculate probability of next token, given the previous ones.
|
2023-05-08 16:41:54 +02:00
|
|
|
const std::vector<float> tok_logits(
|
|
|
|
logits.begin() + (j + 0) * n_vocab,
|
2023-04-13 23:50:42 +02:00
|
|
|
logits.begin() + (j + 1) * n_vocab);
|
2023-05-08 16:41:54 +02:00
|
|
|
|
|
|
|
const float prob = softmax(tok_logits)[tokens[start + j + 1]];
|
|
|
|
|
2023-03-25 19:26:40 +01:00
|
|
|
nll += -std::log(prob);
|
|
|
|
++count;
|
|
|
|
}
|
|
|
|
// perplexity is e^(average negative log-likelihood)
|
|
|
|
printf("[%d]%.4lf,", i + 1, std::exp(nll / count));
|
|
|
|
fflush(stdout);
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char ** argv) {
|
|
|
|
gpt_params params;
|
|
|
|
|
2023-04-13 23:50:42 +02:00
|
|
|
params.n_batch = 512;
|
2023-03-25 19:26:40 +01:00
|
|
|
if (gpt_params_parse(argc, argv, params) == false) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
params.perplexity = true;
|
2023-04-13 23:50:42 +02:00
|
|
|
params.n_batch = std::min(params.n_batch, params.n_ctx);
|
2023-03-25 19:26:40 +01:00
|
|
|
|
|
|
|
if (params.n_ctx > 2048) {
|
|
|
|
fprintf(stderr, "%s: warning: model does not support context sizes greater than 2048 tokens (%d specified);"
|
|
|
|
"expect poor results\n", __func__, params.n_ctx);
|
|
|
|
}
|
|
|
|
|
2023-05-01 18:23:47 +02:00
|
|
|
fprintf(stderr, "%s: build = %d (%s)\n", __func__, BUILD_NUMBER, BUILD_COMMIT);
|
|
|
|
|
2023-06-29 15:15:15 +02:00
|
|
|
if (params.seed == LLAMA_DEFAULT_SEED) {
|
2023-03-25 19:26:40 +01:00
|
|
|
params.seed = time(NULL);
|
|
|
|
}
|
|
|
|
|
2023-06-29 15:15:15 +02:00
|
|
|
fprintf(stderr, "%s: seed = %u\n", __func__, params.seed);
|
2023-03-25 19:26:40 +01:00
|
|
|
|
|
|
|
std::mt19937 rng(params.seed);
|
|
|
|
if (params.random_prompt) {
|
|
|
|
params.prompt = gpt_random_prompt(rng);
|
|
|
|
}
|
|
|
|
|
2023-06-26 19:57:59 +02:00
|
|
|
llama_init_backend(params.numa);
|
2023-05-20 10:06:11 +02:00
|
|
|
|
2023-06-24 10:47:58 +02:00
|
|
|
llama_model * model;
|
2023-03-25 19:26:40 +01:00
|
|
|
llama_context * ctx;
|
|
|
|
|
2023-05-02 22:39:51 +02:00
|
|
|
// load the model and apply lora adapter, if any
|
2023-06-24 10:47:58 +02:00
|
|
|
std::tie(model, ctx) = llama_init_from_gpt_params(params);
|
|
|
|
if (model == NULL) {
|
2023-05-02 22:39:51 +02:00
|
|
|
fprintf(stderr, "%s: error: unable to load model\n", __func__);
|
|
|
|
return 1;
|
2023-04-17 17:28:55 +02:00
|
|
|
}
|
|
|
|
|
2023-03-25 19:26:40 +01:00
|
|
|
// print system information
|
|
|
|
{
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
fprintf(stderr, "system_info: n_threads = %d / %d | %s\n",
|
|
|
|
params.n_threads, std::thread::hardware_concurrency(), llama_print_system_info());
|
|
|
|
}
|
|
|
|
|
|
|
|
perplexity(ctx, params);
|
|
|
|
|
|
|
|
llama_print_timings(ctx);
|
|
|
|
llama_free(ctx);
|
2023-06-24 10:47:58 +02:00
|
|
|
llama_free_model(model);
|
2023-03-25 19:26:40 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|