llama_cpp 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf337091019bb773e47cf206ff2ff30ed0bef963094494e6493455cad7c59840
-  data.tar.gz: fdbae8e08a6b87d49c5658d5c1857f20bf8efdf5a5371906630dccf4eb0f1159
+  metadata.gz: 35afb5cc65c290036ae7e45459eadc9b509f34f33a3f7708244cf47f1a38829f
+  data.tar.gz: 3301158526c63d9d2004e22bda0d1cc8025b4343d8d737df96260786531b074d
 SHA512:
-  metadata.gz: f0fee68294960c5ab9f56ebfe7256a00f9330e55f4954f2b016e07cbc023570298fa8f8b578f3e187fe9183b869769085311931122f93a033c6c21158b4e9485
-  data.tar.gz: 7eec8c98ae9ec1a56fa4bdb4e83a2dc2bdea407fc037af8d1b8f09a30c0d1246333d410707f4d66f3f473bf73574757cf12e56a86a0cb47074501f63f65f0c02
+  metadata.gz: b0a50f9f012f44f119a70790d3de07c7fcc64151246791e270e4ff9fc479a85a01c53cf2775945eba3145a3ba89da55a8d14891c6236cfeae16aed5ae455cf0d
+  data.tar.gz: ede388584e115ae93d509b6c15b288303c348f3cfe8ea46879a1b69e6c96be31a321edbb52cfbeb309a8fb456738f3f6b7cc1d3f71ce7addbd05b3a1e73d4755

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+## [[0.3.4](https://github.com/yoshoku/llama_cpp.rb/compare/v0.3.3...v0.3.4)] - 2023-07-23
+
+- Bump bundled llama.cpp from master-32c5411 to master-d924522.
+  - Add `rope_freq_base` and `rope_freq_scale` options to ContextParams.
+  - Add `max_devices` module function to LLaMACpp.
+  - Add `n_vocab`, `n_ctx`, and `n_embd` methods to Model.
+  - Add `vocab`, `tokenize`, and `token_to_str` methods to Model.
+  ```ruby
+  require 'llama_cpp'
+
+  params = LLaMACpp::ContextParams.new
+  model = LLaMACpp::Model.new(model_path: '/path/to/model.bin', params: params)
+
+  p model.tokenize(text: 'hello, world')
+  # => [12199, 29892, 3186]
+
+  p model.token_to_str(12199)
+  # => "hello"
+  ```
+
+**Breaking Changes**
+- Fix to automatically call `backend_free` method when Ruby script exits.
+- Remove `smooth_factor` argument from `sample_classifier_free_guidance methos` on Context.
+
 ## [[0.3.3](https://github.com/yoshoku/llama_cpp.rb/compare/v0.3.2...v0.3.3)] - 2023-07-15
 
 - Bump bundled llama.cpp from master-481f793 to master-32c5411.

data/ext/llama_cpp/llama_cpp.cpp

@@ -406,6 +406,10 @@ public:
     rb_define_method(rb_cLLaMAContextParams, "main_gpu=", RUBY_METHOD_FUNC(_llama_context_params_set_main_gpu), 1);
     rb_define_method(rb_cLLaMAContextParams, "main_gpu", RUBY_METHOD_FUNC(_llama_context_params_get_main_gpu), 0);
     rb_define_method(rb_cLLaMAContextParams, "tensor_split", RUBY_METHOD_FUNC(_llama_context_params_get_tensor_split), 0);
+    rb_define_method(rb_cLLaMAContextParams, "rope_freq_base=", RUBY_METHOD_FUNC(_llama_context_params_set_rope_freq_base), 1);
+    rb_define_method(rb_cLLaMAContextParams, "rope_freq_base", RUBY_METHOD_FUNC(_llama_context_params_get_rope_freq_base), 0);
+    rb_define_method(rb_cLLaMAContextParams, "rope_freq_scale=", RUBY_METHOD_FUNC(_llama_context_params_set_rope_freq_scale), 1);
+    rb_define_method(rb_cLLaMAContextParams, "rope_freq_scale", RUBY_METHOD_FUNC(_llama_context_params_get_rope_freq_scale), 0);
     rb_define_method(rb_cLLaMAContextParams, "low_vram=", RUBY_METHOD_FUNC(_llama_context_params_set_low_vram), 1);
     rb_define_method(rb_cLLaMAContextParams, "low_vram", RUBY_METHOD_FUNC(_llama_context_params_get_low_vram), 0);
     rb_define_method(rb_cLLaMAContextParams, "seed=", RUBY_METHOD_FUNC(_llama_context_params_set_seed), 1);
@@ -494,6 +498,30 @@ private:
     return ret;
   }
 
+  // rope_freq_base
+  static VALUE _llama_context_params_set_rope_freq_base(VALUE self, VALUE rope_freq_base) {
+    LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
+    ptr->params.rope_freq_base = NUM2DBL(rope_freq_base);
+    return DBL2NUM(ptr->params.rope_freq_base);
+  }
+
+  static VALUE _llama_context_params_get_rope_freq_base(VALUE self) {
+    LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
+    return DBL2NUM(ptr->params.rope_freq_base);
+  }
+
+  // rope_freq_scale
+  static VALUE _llama_context_params_set_rope_freq_scale(VALUE self, VALUE rope_freq_scale) {
+    LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
+    ptr->params.rope_freq_scale = NUM2DBL(rope_freq_scale);
+    return DBL2NUM(ptr->params.rope_freq_scale);
+  }
+
+  static VALUE _llama_context_params_get_rope_freq_scale(VALUE self) {
+    LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
+    return DBL2NUM(ptr->params.rope_freq_scale);
+  }
+
   // low_vram
   static VALUE _llama_context_params_set_low_vram(VALUE self, VALUE low_vram) {
     LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
@@ -764,6 +792,12 @@ public:
     rb_define_method(rb_cLLaMAModel, "free", RUBY_METHOD_FUNC(_llama_model_free), 0);
     rb_define_method(rb_cLLaMAModel, "load", RUBY_METHOD_FUNC(_llama_model_load), -1);
     rb_define_method(rb_cLLaMAModel, "apply_lora_from_file", RUBY_METHOD_FUNC(_llama_model_apply_lora_from_file), -1);
+    rb_define_method(rb_cLLaMAModel, "n_vocab", RUBY_METHOD_FUNC(_llama_model_get_n_vocab_from_model), 0);
+    rb_define_method(rb_cLLaMAModel, "n_ctx", RUBY_METHOD_FUNC(_llama_model_get_n_ctx_from_model), 0);
+    rb_define_method(rb_cLLaMAModel, "n_embd", RUBY_METHOD_FUNC(_llama_model_get_n_embd_from_model), 0);
+    rb_define_method(rb_cLLaMAModel, "vocab", RUBY_METHOD_FUNC(_llama_model_get_vocab_from_model), -1);
+    rb_define_method(rb_cLLaMAModel, "token_to_str", RUBY_METHOD_FUNC(_llama_model_token_to_str_with_model), 1);
+    rb_define_method(rb_cLLaMAModel, "tokenize", RUBY_METHOD_FUNC(_llama_model_tokenize_with_model), -1);
   }
 
 private:
@@ -908,6 +942,109 @@ private:
     }
     return Qnil;
   }
+
+  static VALUE _llama_model_get_n_vocab_from_model(VALUE self) {
+    LLaMAModelWrapper* ptr = get_llama_model(self);
+    return INT2NUM(llama_n_vocab_from_model(ptr->model));
+  }
+
+  static VALUE _llama_model_get_n_ctx_from_model(VALUE self) {
+    LLaMAModelWrapper* ptr = get_llama_model(self);
+    return INT2NUM(llama_n_ctx_from_model(ptr->model));
+  }
+
+  static VALUE _llama_model_get_n_embd_from_model(VALUE self) {
+    LLaMAModelWrapper* ptr = get_llama_model(self);
+    return INT2NUM(llama_n_embd_from_model(ptr->model));
+  }
+
+  static VALUE _llama_model_get_vocab_from_model(int argc, VALUE* argv, VALUE self) {
+    VALUE kw_args = Qnil;
+    ID kw_table[1] = { rb_intern("capacity") };
+    VALUE kw_values[1] = { Qundef };
+    rb_scan_args(argc, argv, ":", &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 1, 0, kw_values);
+
+    if (!RB_INTEGER_TYPE_P(kw_values[0])) {
+      rb_raise(rb_eArgError, "capacity must be an integer");
+      return Qnil;
+    }
+
+    const int capacity = NUM2INT(kw_values[0]);
+
+    LLaMAModelWrapper* ptr = get_llama_model(self);
+    const int n = std::min(capacity, llama_n_vocab_from_model(ptr->model));
+    const char** vocabs = ALLOCA_N(const char*, n);
+    float* scores = ALLOCA_N(float, n);
+
+    llama_get_vocab_from_model(ptr->model, vocabs, scores, capacity);
+
+    VALUE vocabs_ary = rb_ary_new();
+    VALUE scores_ary = rb_ary_new();
+
+    for (int i = 0; i < n; i++) {
+      rb_ary_push(vocabs_ary, rb_str_new_cstr(vocabs[i]));
+      rb_ary_push(scores_ary, DBL2NUM(scores[i]));
+    }
+
+    VALUE ret = rb_ary_new3(2, vocabs_ary, scores_ary);
+
+    return ret;
+  }
+
+  static VALUE _llama_model_token_to_str_with_model(VALUE self, VALUE token_) {
+    if (!RB_INTEGER_TYPE_P(token_)) {
+      rb_raise(rb_eArgError, "token must be an integer");
+      return Qnil;
+    }
+    const llama_token token = NUM2INT(token_);
+    LLaMAModelWrapper* ptr = get_llama_model(self);
+    const char* str = llama_token_to_str_with_model(ptr->model, token);
+    return rb_str_new_cstr(str);
+  }
+
+  static VALUE _llama_model_tokenize_with_model(int argc, VALUE* argv, VALUE self) {
+    VALUE kw_args = Qnil;
+    ID kw_table[3] = { rb_intern("text"), rb_intern("n_max_tokens"), rb_intern("add_bos") };
+    VALUE kw_values[3] = { Qundef, Qundef, Qundef };
+    rb_scan_args(argc, argv, ":", &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 1, 2, kw_values);
+
+    if (!RB_TYPE_P(kw_values[0], T_STRING)) {
+      rb_raise(rb_eArgError, "text must be a String");
+      return Qnil;
+    }
+    if (kw_values[1] != Qundef && !RB_INTEGER_TYPE_P(kw_values[1])) {
+      rb_raise(rb_eArgError, "n_max_tokens must be an integer");
+      return Qnil;
+    }
+    if (kw_values[2] != Qundef && (kw_values[2] != Qtrue && kw_values[2] != Qfalse)) {
+      rb_raise(rb_eArgError, "add_bos must be a boolean");
+      return Qnil;
+    }
+
+    VALUE text_ = kw_values[0];
+    std::string text = StringValueCStr(text_);
+    const bool add_bos = kw_values[2] == Qtrue ? true : false;
+    const int n_max_tokens = kw_values[1] != Qundef ? NUM2INT(kw_values[1]) : text.size() + (add_bos ? 1 : 0);
+
+    llama_token* tokens = ALLOCA_N(llama_token, n_max_tokens);
+    LLaMAModelWrapper* ptr = get_llama_model(self);
+    const int n_tokens = llama_tokenize_with_model(ptr->model, text.c_str(), tokens, n_max_tokens, add_bos);
+
+    if (n_tokens < 0) {
+      rb_raise(rb_eRuntimeError, "failed to tokenize. The numebr of tokens (%d) is greater than n_max_tokens.", -n_tokens);
+      return Qnil;
+    }
+
+    VALUE ret = rb_ary_new2(n_tokens);
+    for (int i = 0; i < n_tokens; i++) {
+      rb_ary_store(ret, i, INT2NUM(tokens[i]));
+    }
+
+    RB_GC_GUARD(text_);
+    return ret;
+  }
 };
 
 const rb_data_type_t RbLLaMAModel::llama_model_type = {
@@ -1581,11 +1718,11 @@ private:
 
   static VALUE _llama_context_sample_classifier_free_guidance(int argc, VALUE* argv, VALUE self) {
     VALUE kw_args = Qnil;
-    ID kw_table[3] = { rb_intern("guidance"), rb_intern("scale"), rb_intern("smooth_factor") };
-    VALUE kw_values[3] = { Qundef, Qundef, Qundef };
+    ID kw_table[2] = { rb_intern("guidance"), rb_intern("scale") };
+    VALUE kw_values[2] = { Qundef, Qundef };
     VALUE candidates = Qnil;
     rb_scan_args(argc, argv, "1:", &candidates, &kw_args);
-    rb_get_kwargs(kw_args, kw_table, 3, 0, kw_values);
+    rb_get_kwargs(kw_args, kw_table, 2, 0, kw_values);
 
     if (!rb_obj_is_kind_of(kw_values[0], rb_cLLaMAContext)) {
       rb_raise(rb_eArgError, "guidance must be a Context");
@@ -1595,10 +1732,6 @@ private:
       rb_raise(rb_eArgError, "scale must be a float");
       return Qnil;
     }
-    if (!RB_FLOAT_TYPE_P(kw_values[2])) {
-      rb_raise(rb_eArgError, "smooth_factor must be a float");
-      return Qnil;
-    }
 
     LLaMAContextWrapper* ctx_ptr = get_llama_context(self);
     if (ctx_ptr->ctx == NULL) {
@@ -1617,9 +1750,8 @@ private:
       return Qnil;
     }
     const float scale = NUM2DBL(kw_values[1]);
-    const float smooth_factor = NUM2DBL(kw_values[2]);
 
-    llama_sample_classifier_free_guidance(ctx_ptr->ctx, &(cnd_ptr->array), guidance_ptr->ctx, scale, smooth_factor);
+    llama_sample_classifier_free_guidance(ctx_ptr->ctx, &(cnd_ptr->array), guidance_ptr->ctx, scale);
 
     return Qnil;
   }
@@ -2062,6 +2194,10 @@ static VALUE rb_llama_mlock_supported(VALUE self) {
   return llama_mlock_supported() ? Qtrue : Qfalse;
 }
 
+static VALUE rb_llama_max_devices(VALUE self) {
+  return INT2NUM(llama_max_devices());
+}
+
 extern "C" void Init_llama_cpp(void) {
   rb_mLLaMACpp = rb_define_module("LLaMACpp");
 
@@ -2082,6 +2218,7 @@ extern "C" void Init_llama_cpp(void) {
   rb_define_module_function(rb_mLLaMACpp, "print_system_info", rb_llama_print_system_info, 0);
   rb_define_module_function(rb_mLLaMACpp, "mmap_supported?", rb_llama_mmap_supported, 0);
   rb_define_module_function(rb_mLLaMACpp, "mlock_supported?", rb_llama_mlock_supported, 0);
+  rb_define_module_function(rb_mLLaMACpp, "max_devices", rb_llama_max_devices, 0);
 
   rb_define_const(rb_mLLaMACpp, "LLAMA_MAX_DEVICES", INT2NUM(LLAMA_MAX_DEVICES));