llama_cpp 0.2.2 → 0.3.1

data/ext/llama_cpp/llama_cpp.cpp

@@ -2,6 +2,7 @@
 #include "llama_cpp.h"
 
 VALUE rb_mLLaMACpp;
+VALUE rb_cLLaMAModel;
 VALUE rb_cLLaMAContext;
 VALUE rb_cLLaMAContextParams;
 VALUE rb_cLLaMAModelQuantizeParams;
@@ -403,6 +404,10 @@ private:
   // seed
   static VALUE _llama_context_params_set_seed(VALUE self, VALUE seed) {
     LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
+    if (NUM2INT(seed) < 0) {
+      rb_raise(rb_eArgError, "seed must be positive");
+      return Qnil;
+    }
     ptr->params.seed = NUM2INT(seed);
     return INT2NUM(ptr->params.seed);
   };
@@ -610,6 +615,206 @@ const rb_data_type_t RbLLaMAModelQuantizeParams::llama_model_quantize_params_typ
   RUBY_TYPED_FREE_IMMEDIATELY
 };
 
+class LLaMAModelWrapper {
+public:
+  struct llama_model* model;
+
+  LLaMAModelWrapper() : model(NULL){};
+
+  ~LLaMAModelWrapper() {
+    if (model != NULL) {
+      llama_free_model(model);
+    }
+  };
+};
+
+class RbLLaMAModel {
+public:
+  static VALUE llama_model_alloc(VALUE self) {
+    LLaMAModelWrapper* ptr = (LLaMAModelWrapper*)ruby_xmalloc(sizeof(LLaMAModelWrapper));
+    new (ptr) LLaMAModelWrapper();
+    return TypedData_Wrap_Struct(self, &llama_model_type, ptr);
+  }
+
+  static void llama_model_free(void* ptr) {
+    ((LLaMAModelWrapper*)ptr)->~LLaMAModelWrapper();
+    ruby_xfree(ptr);
+  }
+
+  static size_t llama_model_size(const void* ptr) {
+    return sizeof(*((LLaMAModelWrapper*)ptr));
+  }
+
+  static LLaMAModelWrapper* get_llama_model(VALUE self) {
+    LLaMAModelWrapper* ptr;
+    TypedData_Get_Struct(self, LLaMAModelWrapper, &llama_model_type, ptr);
+    return ptr;
+  }
+
+  static void define_class(VALUE outer) {
+    rb_cLLaMAModel = rb_define_class_under(outer, "Model", rb_cObject);
+    rb_define_alloc_func(rb_cLLaMAModel, llama_model_alloc);
+    rb_define_method(rb_cLLaMAModel, "initialize", RUBY_METHOD_FUNC(_llama_model_initialize), -1);
+    rb_define_method(rb_cLLaMAModel, "empty?", RUBY_METHOD_FUNC(_llama_model_empty), 0);
+    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);
+  }
+
+private:
+  static const rb_data_type_t llama_model_type;
+
+  static VALUE _llama_model_initialize(int argc, VALUE* argv, VALUE self) {
+    VALUE kw_args = Qnil;
+    ID kw_table[2] = { rb_intern("model_path"), rb_intern("params") };
+    VALUE kw_values[2] = { Qundef, Qundef };
+    rb_scan_args(argc, argv, ":", &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 0, 2, kw_values);
+
+    if (kw_values[0] == Qundef && kw_values[1] == Qundef) {
+      rb_iv_set(self, "@params", Qnil);
+      return Qnil;
+    }
+
+    if (!RB_TYPE_P(kw_values[0], T_STRING)) {
+      rb_raise(rb_eArgError, "model_path must be a string");
+      return Qnil;
+    }
+    if (!rb_obj_is_kind_of(kw_values[1], rb_cLLaMAContextParams)) {
+      rb_raise(rb_eArgError, "params must be a ContextParams");
+      return Qnil;
+    }
+
+    VALUE filename = kw_values[0];
+    LLaMAContextParamsWrapper* prms_ptr = RbLLaMAContextParams::get_llama_context_params(kw_values[1]);
+    LLaMAModelWrapper* model_ptr = get_llama_model(self);
+
+    if (prms_ptr->params.seed == LLAMA_DEFAULT_SEED) {
+      prms_ptr->params.seed = time(NULL);
+    }
+
+    try {
+      model_ptr->model = llama_load_model_from_file(StringValueCStr(filename), prms_ptr->params);
+    } catch (const std::runtime_error& e) {
+      rb_raise(rb_eRuntimeError, "%s", e.what());
+      return Qnil;
+    }
+
+    if (model_ptr->model == NULL) {
+      rb_raise(rb_eRuntimeError, "Failed to initialize LLaMA model");
+      return Qnil;
+    }
+
+    rb_iv_set(self, "@params", kw_values[1]);
+
+    RB_GC_GUARD(filename);
+    return Qnil;
+  }
+
+  static VALUE _llama_model_empty(VALUE self) {
+    LLaMAModelWrapper* ptr = get_llama_model(self);
+    if (ptr->model != NULL) {
+      return Qfalse;
+    }
+    return Qtrue;
+  }
+
+  static VALUE _llama_model_free(VALUE self) {
+    LLaMAModelWrapper* ptr = get_llama_model(self);
+    if (ptr->model != NULL) {
+      llama_free_model(ptr->model);
+      ptr->model = NULL;
+      rb_iv_set(self, "@params", Qnil);
+    }
+    return Qnil;
+  }
+
+  static VALUE _llama_model_load(int argc, VALUE* argv, VALUE self) {
+    VALUE kw_args = Qnil;
+    ID kw_table[2] = { rb_intern("model_path"), rb_intern("params") };
+    VALUE kw_values[2] = { Qundef, Qundef };
+    rb_scan_args(argc, argv, ":", &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 2, 0, kw_values);
+
+    if (!RB_TYPE_P(kw_values[0], T_STRING)) {
+      rb_raise(rb_eArgError, "model_path must be a string");
+      return Qnil;
+    }
+    if (!rb_obj_is_kind_of(kw_values[1], rb_cLLaMAContextParams)) {
+      rb_raise(rb_eArgError, "params must be a LLaMAContextParams");
+      return Qnil;
+    }
+
+    LLaMAModelWrapper* model_ptr = get_llama_model(self);
+    if (model_ptr->model != NULL) {
+      rb_raise(rb_eRuntimeError, "LLaMA model is already loaded");
+      return Qnil;
+    }
+
+    VALUE filename = kw_values[0];
+    LLaMAContextParamsWrapper* prms_ptr = RbLLaMAContextParams::get_llama_context_params(kw_values[1]);
+
+    try {
+      model_ptr->model = llama_load_model_from_file(StringValueCStr(filename), prms_ptr->params);
+    } catch (const std::runtime_error& e) {
+      rb_raise(rb_eRuntimeError, "%s", e.what());
+      return Qnil;
+    }
+
+    if (model_ptr->model == NULL) {
+      rb_raise(rb_eRuntimeError, "Failed to initialize LLaMA model");
+      return Qnil;
+    }
+
+    rb_iv_set(self, "@params", kw_values[1]);
+
+    RB_GC_GUARD(filename);
+    return Qnil;
+  }
+
+  static VALUE _llama_model_apply_lora_from_file(int argc, VALUE* argv, VALUE self) {
+    VALUE kw_args = Qnil;
+    ID kw_table[3] = { rb_intern("lora_path"), rb_intern("base_model_path"), rb_intern("n_threads") };
+    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, "lora_path must be a string");
+      return Qnil;
+    }
+    if (kw_values[1] != Qundef && !RB_TYPE_P(kw_values[1], T_STRING)) {
+      rb_raise(rb_eArgError, "base_model_path must be a string");
+      return Qnil;
+    }
+    if (kw_values[2] != Qundef && !RB_INTEGER_TYPE_P(kw_values[2])) {
+      rb_raise(rb_eArgError, "n_threads must be an integer");
+      return Qnil;
+    }
+
+    const char* lora_path = StringValueCStr(kw_values[0]);
+    const char* base_model_path = kw_values[1] == Qundef ? NULL : StringValueCStr(kw_values[1]);
+    const int n_threads = kw_values[2] == Qundef ? 1 : NUM2INT(kw_values[2]);
+
+    LLaMAModelWrapper* ptr = get_llama_model(self);
+    if (llama_model_apply_lora_from_file(ptr->model, lora_path, base_model_path, n_threads) != 0) {
+      rb_raise(rb_eRuntimeError, "Failed to apply LoRA");
+      return Qnil;
+    }
+    return Qnil;
+  };
+};
+
+const rb_data_type_t RbLLaMAModel::llama_model_type = {
+  "RbLLaMAModel",
+  { NULL,
+    RbLLaMAModel::llama_model_free,
+    RbLLaMAModel::llama_model_size },
+  NULL,
+  NULL,
+  RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 class LLaMAContextWrapper {
 public:
   struct llama_context* ctx;
@@ -651,6 +856,7 @@ public:
     rb_define_alloc_func(rb_cLLaMAContext, llama_context_alloc);
     rb_define_method(rb_cLLaMAContext, "initialize", RUBY_METHOD_FUNC(_llama_context_initialize), -1);
     rb_define_method(rb_cLLaMAContext, "eval", RUBY_METHOD_FUNC(_llama_context_eval), -1);
+    rb_define_method(rb_cLLaMAContext, "eval_embd", RUBY_METHOD_FUNC(_llama_context_eval_embd), -1);
     rb_define_method(rb_cLLaMAContext, "eval_export", RUBY_METHOD_FUNC(_llama_context_eval_export), 1);
     rb_define_method(rb_cLLaMAContext, "tokenize", RUBY_METHOD_FUNC(_llama_context_tokenize), -1);
     rb_define_method(rb_cLLaMAContext, "logits", RUBY_METHOD_FUNC(_llama_context_logits), 0);
@@ -662,10 +868,6 @@ public:
     rb_define_method(rb_cLLaMAContext, "n_embd", RUBY_METHOD_FUNC(_llama_context_n_embd), 0);
     rb_define_method(rb_cLLaMAContext, "print_timings", RUBY_METHOD_FUNC(_llama_context_print_timings), 0);
     rb_define_method(rb_cLLaMAContext, "reset_timings", RUBY_METHOD_FUNC(_llama_context_reset_timings), 0);
-    rb_define_method(rb_cLLaMAContext, "empty?", RUBY_METHOD_FUNC(_llama_context_empty), 0);
-    rb_define_method(rb_cLLaMAContext, "free", RUBY_METHOD_FUNC(_llama_context_free), 0);
-    rb_define_method(rb_cLLaMAContext, "load", RUBY_METHOD_FUNC(_llama_context_load), -1);
-    rb_define_method(rb_cLLaMAContext, "apply_lora_from_file", RUBY_METHOD_FUNC(_llama_context_apply_lora_from_file), -1);
     rb_define_method(rb_cLLaMAContext, "kv_cache_token_count", RUBY_METHOD_FUNC(_llama_context_kv_cache_token_count), 0);
     rb_define_method(rb_cLLaMAContext, "set_rng_seed", RUBY_METHOD_FUNC(_llama_context_set_rng_seed), 1);
     rb_define_method(rb_cLLaMAContext, "load_session_file", RUBY_METHOD_FUNC(_llama_context_load_session_file), -1);
@@ -689,46 +891,37 @@ private:
 
   static VALUE _llama_context_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE kw_args = Qnil;
-    ID kw_table[2] = { rb_intern("model_path"), rb_intern("params") };
-    VALUE kw_values[2] = { Qundef, Qundef };
+    ID kw_table[1] = { rb_intern("model") };
+    VALUE kw_values[1] = { Qundef };
     rb_scan_args(argc, argv, ":", &kw_args);
-    rb_get_kwargs(kw_args, kw_table, 0, 2, kw_values);
+    rb_get_kwargs(kw_args, kw_table, 1, 0, kw_values);
 
-    if (kw_values[0] == Qundef && kw_values[1] == Qundef) {
-      rb_iv_set(self, "@params", Qnil);
-      rb_iv_set(self, "@has_evaluated", Qfalse);
+    VALUE model = kw_values[0];
+    if (!rb_obj_is_kind_of(model, rb_cLLaMAModel)) {
+      rb_raise(rb_eArgError, "model must be a Model");
       return Qnil;
     }
 
-    if (!RB_TYPE_P(kw_values[0], T_STRING)) {
-      rb_raise(rb_eArgError, "model_path must be a string");
-      return Qnil;
-    }
-    if (!rb_obj_is_kind_of(kw_values[1], rb_cLLaMAContextParams)) {
-      rb_raise(rb_eArgError, "params must be a ContextParams");
+    LLaMAModelWrapper* model_ptr = RbLLaMAModel::get_llama_model(model);
+    if (model_ptr->model == NULL) {
+      rb_raise(rb_eRuntimeError, "Model is empty");
       return Qnil;
     }
 
-    VALUE filename = kw_values[0];
-    LLaMAContextParamsWrapper* prms_ptr = RbLLaMAContextParams::get_llama_context_params(kw_values[1]);
+    VALUE params = rb_iv_get(model, "@params");
+    LLaMAContextParamsWrapper* prms_ptr = RbLLaMAContextParams::get_llama_context_params(params);
     LLaMAContextWrapper* ctx_ptr = get_llama_context(self);
 
-    try {
-      ctx_ptr->ctx = llama_init_from_file(StringValueCStr(filename), prms_ptr->params);
-    } catch (const std::runtime_error& e) {
-      rb_raise(rb_eRuntimeError, "%s", e.what());
-      return Qnil;
-    }
+    ctx_ptr->ctx = llama_new_context_with_model(model_ptr->model, prms_ptr->params);
 
     if (ctx_ptr->ctx == NULL) {
       rb_raise(rb_eRuntimeError, "Failed to initialize LLaMA context");
       return Qnil;
     }
 
-    rb_iv_set(self, "@params", kw_values[1]);
+    rb_iv_set(self, "@model", model);
     rb_iv_set(self, "@has_evaluated", Qfalse);
 
-    RB_GC_GUARD(filename);
     return Qnil;
   };
 
@@ -787,6 +980,61 @@ private:
     return Qnil;
   };
 
+  static VALUE _llama_context_eval_embd(int argc, VALUE* argv, VALUE self) {
+    VALUE kw_args = Qnil;
+    ID kw_table[4] = { rb_intern("embd"), rb_intern("n_past"), rb_intern("n_tokens"), rb_intern("n_threads") };
+    VALUE kw_values[4] = { Qundef, Qundef, Qundef, Qundef };
+    rb_scan_args(argc, argv, ":", &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 2, 2, kw_values);
+
+    if (!RB_TYPE_P(kw_values[0], T_ARRAY)) {
+      rb_raise(rb_eArgError, "tokens must be an Array");
+      return Qnil;
+    }
+    if (!RB_INTEGER_TYPE_P(kw_values[1])) {
+      rb_raise(rb_eArgError, "n_past must be an integer");
+      return Qnil;
+    }
+    if (kw_values[2] != Qundef && !RB_INTEGER_TYPE_P(kw_values[2])) {
+      rb_raise(rb_eArgError, "n_tokens must be an integer");
+      return Qnil;
+    }
+    if (kw_values[3] != Qundef && !RB_INTEGER_TYPE_P(kw_values[3])) {
+      rb_raise(rb_eArgError, "n_threads must be an integer");
+      return Qnil;
+    }
+
+    const size_t tokens_len = RARRAY_LEN(kw_values[0]);
+    std::vector<float> embd(tokens_len);
+    for (size_t i = 0; i < tokens_len; i++) {
+      VALUE el = rb_ary_entry(kw_values[0], i);
+      if (!RB_FLOAT_TYPE_P(el)) {
+        rb_raise(rb_eArgError, "embd must be an array of floats");
+        return Qnil;
+      }
+      embd[i] = NUM2DBL(el);
+    }
+
+    const int n_tokens = kw_values[2] == Qundef ? (int)tokens_len : NUM2INT(kw_values[2]);
+    const int n_past = NUM2INT(kw_values[1]);
+    const int n_threads = kw_values[3] == Qundef ? 1 : NUM2INT(kw_values[3]);
+
+    LLaMAContextWrapper* ptr = get_llama_context(self);
+    if (ptr->ctx == NULL) {
+      rb_raise(rb_eRuntimeError, "LLaMA context is not initialized");
+      return Qnil;
+    }
+    if (llama_eval_embd(ptr->ctx, embd.data(), n_tokens, n_past, n_threads) != 0) {
+      rb_raise(rb_eRuntimeError, "Failed to evaluate");
+      return Qnil;
+    }
+
+    rb_iv_set(self, "@n_tokens", INT2NUM(n_tokens));
+    rb_iv_set(self, "@has_evaluated", Qtrue);
+
+    return Qnil;
+  }
+
   static VALUE _llama_context_eval_export(VALUE self, VALUE fname_) {
     LLaMAContextWrapper* ptr = get_llama_context(self);
     if (ptr->ctx == NULL) {
@@ -873,7 +1121,9 @@ private:
       return Qnil;
     }
 
-    LLaMAContextParamsWrapper* prms_ptr = RbLLaMAContextParams::get_llama_context_params(rb_iv_get(self, "@params"));
+    VALUE model = rb_iv_get(self, "@model");
+    VALUE params = rb_iv_get(model, "@params");
+    LLaMAContextParamsWrapper* prms_ptr = RbLLaMAContextParams::get_llama_context_params(params);
     const int n_tokens = prms_ptr->params.logits_all ? NUM2INT(rb_iv_get(self, "@n_tokens")) : 1;
     const int n_vocab = llama_n_vocab(ptr->ctx);
     const float* logits = llama_get_logits(ptr->ctx);
@@ -891,7 +1141,9 @@ private:
       rb_raise(rb_eRuntimeError, "LLaMA context is not initialized");
       return Qnil;
     }
-    LLaMAContextParamsWrapper* prms_ptr = RbLLaMAContextParams::get_llama_context_params(rb_iv_get(self, "@params"));
+    VALUE model = rb_iv_get(self, "@model");
+    VALUE params = rb_iv_get(model, "@params");
+    LLaMAContextParamsWrapper* prms_ptr = RbLLaMAContextParams::get_llama_context_params(params);
     if (!prms_ptr->params.embedding) {
       rb_raise(rb_eRuntimeError, "embedding parameter is false");
       return Qnil;
@@ -995,106 +1247,6 @@ private:
     return Qnil;
   };
 
-  static VALUE _llama_context_empty(VALUE self) {
-    LLaMAContextWrapper* ptr = get_llama_context(self);
-    if (ptr->ctx != NULL) {
-      return Qfalse;
-    }
-    return Qtrue;
-  }
-
-  static VALUE _llama_context_free(VALUE self) {
-    LLaMAContextWrapper* ptr = get_llama_context(self);
-    if (ptr->ctx != NULL) {
-      llama_free(ptr->ctx);
-      ptr->ctx = NULL;
-      rb_iv_set(self, "@params", Qnil);
-      rb_iv_set(self, "@has_evaluated", Qfalse);
-    }
-    return Qnil;
-  }
-
-  static VALUE _llama_context_load(int argc, VALUE* argv, VALUE self) {
-    VALUE kw_args = Qnil;
-    ID kw_table[2] = { rb_intern("model_path"), rb_intern("params") };
-    VALUE kw_values[2] = { Qundef, Qundef };
-    rb_scan_args(argc, argv, ":", &kw_args);
-    rb_get_kwargs(kw_args, kw_table, 2, 0, kw_values);
-
-    if (!RB_TYPE_P(kw_values[0], T_STRING)) {
-      rb_raise(rb_eArgError, "model_path must be a string");
-      return Qnil;
-    }
-    if (!rb_obj_is_kind_of(kw_values[1], rb_cLLaMAContextParams)) {
-      rb_raise(rb_eArgError, "params must be a LLaMAContextParams");
-      return Qnil;
-    }
-
-    LLaMAContextWrapper* ctx_ptr = get_llama_context(self);
-    if (ctx_ptr->ctx != NULL) {
-      rb_raise(rb_eRuntimeError, "LLaMA context is already loaded");
-      return Qnil;
-    }
-
-    VALUE filename = kw_values[0];
-    LLaMAContextParamsWrapper* prms_ptr = RbLLaMAContextParams::get_llama_context_params(kw_values[1]);
-
-    try {
-      ctx_ptr->ctx = llama_init_from_file(StringValueCStr(filename), prms_ptr->params);
-    } catch (const std::runtime_error& e) {
-      rb_raise(rb_eRuntimeError, "%s", e.what());
-      return Qnil;
-    }
-
-    if (ctx_ptr->ctx == NULL) {
-      rb_raise(rb_eRuntimeError, "Failed to initialize LLaMA context");
-      return Qnil;
-    }
-
-    rb_iv_set(self, "@params", kw_values[1]);
-    rb_iv_set(self, "@has_evaluated", Qfalse);
-
-    RB_GC_GUARD(filename);
-    return Qnil;
-  };
-
-  static VALUE _llama_context_apply_lora_from_file(int argc, VALUE* argv, VALUE self) {
-    VALUE kw_args = Qnil;
-    ID kw_table[3] = { rb_intern("lora_path"), rb_intern("base_model_path"), rb_intern("n_threads") };
-    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, "lora_path must be a string");
-      return Qnil;
-    }
-    if (kw_values[1] != Qundef && !RB_TYPE_P(kw_values[1], T_STRING)) {
-      rb_raise(rb_eArgError, "base_model_path must be a string");
-      return Qnil;
-    }
-    if (kw_values[2] != Qundef && !RB_INTEGER_TYPE_P(kw_values[2])) {
-      rb_raise(rb_eArgError, "n_threads must be an integer");
-      return Qnil;
-    }
-
-    const char* lora_path = StringValueCStr(kw_values[0]);
-    const char* base_model_path = kw_values[1] == Qundef ? NULL : StringValueCStr(kw_values[1]);
-    const int n_threads = kw_values[2] == Qundef ? 1 : NUM2INT(kw_values[2]);
-
-    LLaMAContextWrapper* ptr = get_llama_context(self);
-    if (ptr->ctx != NULL) {
-      rb_raise(rb_eRuntimeError, "LLaMA context is already loaded");
-      return Qnil;
-    }
-
-    if (llama_apply_lora_from_file(ptr->ctx, lora_path, base_model_path, n_threads) != 0) {
-      rb_raise(rb_eRuntimeError, "Failed to apply LoRA");
-      return Qnil;
-    }
-    return Qnil;
-  };
-
   static VALUE _llama_context_kv_cache_token_count(VALUE self) {
     LLaMAContextWrapper* ptr = get_llama_context(self);
     if (ptr->ctx == NULL) {
@@ -1110,7 +1262,11 @@ private:
       rb_raise(rb_eRuntimeError, "LLaMA context is not initialized");
       return Qnil;
     }
-    const int seed = NUM2INT(seed_);
+    if (NUM2INT(seed_) < 0) {
+      rb_raise(rb_eArgError, "seed must be a non-negative integer");
+      return Qnil;
+    }
+    const uint32_t seed = NUM2INT(seed_);
     llama_set_rng_seed(ptr->ctx, seed);
     return Qnil;
   };
@@ -1137,7 +1293,9 @@ private:
       return Qnil;
     }
 
-    LLaMAContextParamsWrapper* prms_ptr = RbLLaMAContextParams::get_llama_context_params(rb_iv_get(self, "@params"));
+    VALUE model = rb_iv_get(self, "@model");
+    VALUE params = rb_iv_get(model, "@params");
+    LLaMAContextParamsWrapper* prms_ptr = RbLLaMAContextParams::get_llama_context_params(params);
     const int n_ctx = prms_ptr->params.n_ctx;
 
     std::vector<llama_token> session_tokens(n_ctx);
@@ -1664,8 +1822,16 @@ const rb_data_type_t RbLLaMAContext::llama_context_type = {
 
 // module functions
 
-static VALUE rb_llama_llama_init_backend(VALUE self) {
-  llama_init_backend();
+static VALUE rb_llama_llama_init_backend(int argc, VALUE* argv, VALUE self) {
+  VALUE kw_args = Qnil;
+  ID kw_table[1] = { rb_intern("numa") };
+  VALUE kw_values[1] = { Qundef };
+  rb_scan_args(argc, argv, ":", &kw_args);
+  rb_get_kwargs(kw_args, kw_table, 0, 1, kw_values);
+
+  const bool numa = kw_values[0] == Qundef ? false : (RTEST ? true : false);
+  llama_init_backend(numa);
+
   return Qnil;
 }
 
@@ -1731,10 +1897,11 @@ extern "C" void Init_llama_cpp(void) {
 
   RbLLaMATokenData::define_class(rb_mLLaMACpp);
   RbLLaMATokenDataArray::define_class(rb_mLLaMACpp);
+  RbLLaMAModel::define_class(rb_mLLaMACpp);
   RbLLaMAContext::define_class(rb_mLLaMACpp);
   RbLLaMAContextParams::define_class(rb_mLLaMACpp);
 
-  rb_define_module_function(rb_mLLaMACpp, "init_backend", rb_llama_llama_init_backend, 0);
+  rb_define_module_function(rb_mLLaMACpp, "init_backend", rb_llama_llama_init_backend, -1);
   rb_define_module_function(rb_mLLaMACpp, "model_quantize", rb_llama_model_quantize, -1);
   rb_define_module_function(rb_mLLaMACpp, "token_bos", rb_llama_token_bos, 0);
   rb_define_module_function(rb_mLLaMACpp, "token_eos", rb_llama_token_eos, 0);
@@ -1802,6 +1969,11 @@ extern "C" void Init_llama_cpp(void) {
   ss_magic << std::showbase << std::hex << LLAMA_SESSION_MAGIC;
   rb_define_const(rb_mLLaMACpp, "LLAMA_SESSION_MAGIC", rb_str_new2(ss_magic.str().c_str()));
 
+  ss_magic.str("");
+  ss_magic.clear(std::stringstream::goodbit);
+  ss_magic << std::showbase << std::hex << LLAMA_DEFAULT_SEED;
+  rb_define_const(rb_mLLaMACpp, "LLAMA_DEFAULT_SEED", rb_str_new2(ss_magic.str().c_str()));
+
   rb_define_const(rb_mLLaMACpp, "LLAMA_FILE_VERSION", rb_str_new2(std::to_string(LLAMA_FILE_VERSION).c_str()));
   rb_define_const(rb_mLLaMACpp, "LLAMA_SESSION_VERSION", rb_str_new2(std::to_string(LLAMA_SESSION_VERSION).c_str()));
 }