char-fork/llama.cpp

git clone https://git.t4t.associates/char-fork/llama.cpp

Oliver Simonssampler : remove "full-context windows" from history-based samplers (#26524)a6aa6f545

char/aliceai-t5-moe
brancheschar/aliceai-t5-moeall refs →
3.1 KiB104 linesraw
1#pragma once
2
3#include "server-common.h"
4#include "server-task.h"
5
6#include "sampling.h"
7#include "speculative.h"
8
9#include <climits>
10#include <functional>
11#include <limits>
12#include <memory>
13#include <string>
14#include <vector>
15
16namespace server_schema {
17
18struct field_eval_context {
19    task_params & params;
20    const llama_vocab * vocab = nullptr;
21    const std::vector<llama_logit_bias> * logit_bias_eog = nullptr;
22    field_eval_context(task_params & params) : params(params) {}
23};
24
25using field_handler = std::function<void(field_eval_context &, const json &)>;
26
27struct field {
28    std::vector<const char *> name;
29    const char * desc = "";
30    field_handler custom_handler;
31    field() = default;
32    field(const char * n) : name({n}) {}
33    virtual ~field() = default;
34    field * set_desc(const char * s) {
35        desc = s;
36        return this;
37    }
38    // if 'name' is present, use it, otherwise look for aliases following the order they were added
39    field * add_alias(const char * n) {
40        name.push_back(n);
41        return this;
42    }
43    field * set_handler(field_handler h) { this->custom_handler = h; return this; }
44    virtual void eval(field_eval_context & ctx, const json & data) = 0;
45};
46
47template <typename T = int32_t>
48struct field_num : public field {
49    T & val;
50    T min = std::numeric_limits<T>::lowest();
51    T max = std::numeric_limits<T>::max();
52    bool is_hard_limit = false; // if true, throw error if the value is invalid
53    field_num(const char * n, T & val) : field(n), val(val) {}
54    // limits are inclusive, min <= value <= max
55    field_num * set_limits(T min, T max) {
56        this->min = min;
57        this->max = max;
58        return this;
59    }
60    field_num * set_hard_limits(T min, T max) {
61        set_limits(min, max);
62        is_hard_limit = true;
63        return this;
64    }
65    virtual void eval(field_eval_context & ctx, const json & data) override;
66};
67
68struct field_str : public field {
69    field_str(const char * n) : field(n) {}
70    virtual void eval(field_eval_context & ctx, const json & data) override;
71};
72
73struct field_bool : public field {
74    bool & val;
75    field_bool(const char * n, bool & val) : field(n), val(val) {}
76    virtual void eval(field_eval_context & ctx, const json & data) override;
77};
78
79struct field_json : public field {
80    field_json(const char * n) : field(n) {}
81    virtual void eval(field_eval_context & ctx, const json & data) override;
82};
83
84struct field_nested : public field {
85    std::vector<std::unique_ptr<field>> subfields;
86    field_nested(const char * n) : field(n) {}
87    field_nested * add_subfield(field * f) {
88        subfields.emplace_back(std::unique_ptr<field>(f));
89        return this;
90    }
91    virtual void eval(field_eval_context & ctx, const json & data) override;
92};
93
94std::vector<std::unique_ptr<field>> make_llama_cmpl_schema(
95                    const common_params & params_base,
96                    task_params & params);
97
98task_params eval_llama_cmpl_schema(
99                    const llama_vocab * vocab,
100                    const common_params & params_base,
101                    const std::vector<llama_logit_bias> & logit_bias_eog,
102                    const json & data);
103
104} // namespace server_schema