rbbt-dm 1.2.7 → 1.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c55843bf543c88167239f6e182495963e0683c5a7fdd7c3a7ab9bd501a78bc8
-  data.tar.gz: d01aaf45331766eac6d868749b8df72c49d1a6888f44f7a1d4f8cbfefe258c87
+  metadata.gz: 9d53609453e1c3bd589c95071569583bff5f11224a200850c0d9e85775e5a2ce
+  data.tar.gz: 501f436caff07c990c09adec4caa60d32fe577b35209a65e8f96418ab2acc422
 SHA512:
-  metadata.gz: 7b6a225ce0403759ab45f26d371d491c19fc76f6560771868a58b9de921fd3aa03750bd7aec95c34029f61f53e71e382958f2779ca790fde30958cfbd1169a0b
-  data.tar.gz: ae1b6d44072398fbde96a0cb31f9586076dee1a5c7e2ac32726c65ecaaa3d08b59ea627c7a0f9f4a8e87547d5a403452ea5bee1d0736d610bf73b6456cb99be9
+  metadata.gz: 4a53ccc8a5eac633e344beffd36073e1828d848d9743552f12e75a54cbda337050152b72fd95d7d97d4aeed50f811dcc8475c97bc292ba9bcdd57e9d32f0e91b
+  data.tar.gz: 30fef4ee2c023e141c0ef991ae35d1a0913d4444138fda778760b821ccc48d85d67dc44d4c251d7f84e3b1bbe6ecb6f3b64aee13fbdc443cb33bbed2b34a586a

data/lib/rbbt/matrix/barcode.rb

@@ -3,7 +3,7 @@ require 'rbbt/util/R'
 class RbbtMatrix
   def barcode(outfile, factor = 2)
 
-    FileUtils.mkdir_p File.dirname(outfile) unless outfile.nil? or File.exists? File.dirname(outfile)
+    FileUtils.mkdir_p File.dirname(outfile) unless outfile.nil? or File.exist? File.dirname(outfile)
     cmd =<<-EOF
 source('#{Rbbt.share.R['barcode.R'].find}')
 rbbt.GE.barcode.mode(#{ R.ruby2R self.data_file }, #{ R.ruby2R outfile }, #{ R.ruby2R factor })
@@ -49,7 +49,7 @@ rbbt.GE.barcode.mode(#{ R.ruby2R self.data_file }, #{ R.ruby2R outfile }, #{ R.r
 
     clusters = Array === clusters ? clusters : (2..clusters).to_a
 
-    FileUtils.mkdir_p File.dirname(outfile) unless outfile.nil? or File.exists? File.dirname(outfile)
+    FileUtils.mkdir_p File.dirname(outfile) unless outfile.nil? or File.exist? File.dirname(outfile)
     cmd =<<-EOF
 source('#{Rbbt.share.R['barcode.R'].find}')
 rbbt.GE.activity_cluster(#{ R.ruby2R self.data_file }, #{ R.ruby2R outfile }, #{R.ruby2R key_field}, #{R.ruby2R clusters})

data/lib/rbbt/matrix/differential.rb

@@ -45,7 +45,7 @@ class RbbtMatrix
       end
 
       file = file.find if Path === file
-      FileUtils.mkdir_p File.dirname(file) unless file.nil? or File.exists? File.dirname(file)
+      FileUtils.mkdir_p File.dirname(file) unless file.nil? or File.exist? File.dirname(file)
 
       cmd = <<-EOS
 
@@ -71,10 +71,10 @@ end
 
 
 #def self.analyze(datafile,  main, contrast = nil, log2 = false, outfile = nil, key_field = nil, two_channel = nil)
-#  FileUtils.mkdir_p File.dirname(outfile) unless outfile.nil? or File.exists? File.dirname(outfile)
+#  FileUtils.mkdir_p File.dirname(outfile) unless outfile.nil? or File.exist? File.dirname(outfile)
 #  GE.run_R("rbbt.GE.process(#{ R.ruby2R datafile }, main = #{R.ruby2R(main, :strings => true)}, contrast = #{R.ruby2R(contrast, :strings => true)}, log2=#{ R.ruby2R log2 }, outfile = #{R.ruby2R outfile}, key.field = #{R.ruby2R key_field}, two.channel = #{R.ruby2R two_channel})")
 #end
 #def self.barcode(datafile, outfile, factor = 2)
-#  FileUtils.mkdir_p File.dirname(outfile) unless outfile.nil? or File.exists? File.dirname(outfile)
+#  FileUtils.mkdir_p File.dirname(outfile) unless outfile.nil? or File.exist? File.dirname(outfile)
 #  GE.run_R("rbbt.GE.barcode(#{ R.ruby2R datafile }, #{ R.ruby2R outfile }, #{ R.ruby2R factor })")
 #end

data/lib/rbbt/matrix/knowledge_base.rb

@@ -13,7 +13,7 @@ class KnowledgeBase
 
     return matrix if RbbtMatrix === matrix
 
-    Path.setup(matrix) if not Path === matrix and File.exists? matrix
+    Path.setup(matrix) if not Path === matrix and File.exist? matrix
 
     raise "Registered matrix is strange: #{Misc.fingerprint matrix}" unless Path === matrix
 

data/lib/rbbt/plots/bar.rb

@@ -119,7 +119,7 @@ module BarPlot
     options = Misc.add_defaults options, :width => [options[:total], MAX_WIDTH].min, :height => 20, :background => PNG::Color::White
     width, height, background, canvas = Misc.process_options options, :width, :height, :background, :canvas
 
-    canvas ||= if options[:update] and options[:filename] and File.exists? options[:filename]
+    canvas ||= if options[:update] and options[:filename] and File.exist? options[:filename]
                  PNG.load_file options[:filename]
                else
                  PNG::Canvas.new width, height, get_color(background) 

data/lib/rbbt/stan.rb

@@ -130,7 +130,7 @@ print(fit)
       erase = true
     end
 
-    FileUtils.mkdir_p directory unless File.exists? directory
+    FileUtils.mkdir_p directory unless File.exist? directory
     input_directory  = File.join(directory, 'inputs')
     parameter_chains = File.join(directory, 'chains') unless erase
     summary          = File.join(directory, 'summary') unless erase

data/lib/rbbt/statistics/hypergeometric.rb

@@ -118,7 +118,7 @@ module TSV
 
     field_pos = fields.collect{|f| self.fields.index f}.compact
     persistence_path = self.respond_to?(:persistence_path)? self.persistence_path : nil
-    Persist.persist(filename, :yaml, :fields => fields, :persist => persistence, :prefix => "Hyp.Geo.Counts", :other => {:background => background, :rename => rename, :persistence_path => persistence_path}) do 
+    Persist.persist(filename, :yaml, :fields => fields, :persist => persistence, :prefix => "Hyp.Geo.Counts", :other => {:fields => fields, :background => background, :rename => rename, :persistence_path => persistence_path}) do 
       data ||= {}
 
       with_unnamed do
@@ -152,6 +152,7 @@ module TSV
 
       end
 
+
       if rename
         Log.debug("Using renames during annotation counts")
         Hash[*data.keys.zip(data.values.collect{|l| l.collect{|e| rename.include?(e)? rename[e] : e }.uniq.length }).flatten]

data/lib/rbbt/vector/model/huggingface/masked_lm.rb

@@ -0,0 +1,50 @@
+require 'rbbt/vector/model/huggingface'
+class MaskedLMModel < HuggingfaceModel
+
+  def initialize(checkpoint, dir = nil, model_options = {})
+    
+    model_options = Misc.add_defaults model_options, :max_length => 128
+    super("MaskedLM", checkpoint, dir, model_options)
+
+    train_model do |texts,labels|
+      model, tokenizer = self.init
+      max_length = @model_options[:max_length]
+      mask_id = tokenizer.mask_token_id
+
+      dataset = []
+      texts.zip(labels).each do |text,label_values|
+        fixed_text = text.gsub("[MASK]", "[PENDINGMASK]")
+        label_tokens = label_values.collect{|label| tokenizer.convert_tokens_to_ids(label) }
+        label_tokens.each do |ids|
+          ids = [ids] unless Array === ids
+          fixed_text.sub!("[PENDINGMASK]", "[MASK]" * ids.length)
+        end
+
+        tokenized_text = tokenizer.call(fixed_text, truncation: true, padding: "max_length")
+        input_ids = tokenized_text["input_ids"].to_a
+        attention_mask = tokenized_text["attention_mask"].to_a
+
+        all_label_tokens = label_tokens.flatten
+        label_ids = input_ids.collect do |id|
+          if id == mask_id
+            all_label_tokens.shift
+          else
+            -100
+          end
+        end
+        dataset << {input_ids: input_ids, labels: label_ids, attention_mask: attention_mask}
+      end
+
+      dataset_file = File.join(@directory, 'dataset.json')
+      Open.write(dataset_file, dataset.collect{|e| e.to_json} * "\n")
+
+      training_args_obj = RbbtPython.call_method("rbbt_dm.huggingface", :training_args, @model_path, @model_options[:training_args])
+      data_collator = RbbtPython.class_new_obj("transformers", "DefaultDataCollator", {}) 
+      RbbtPython.call_method("rbbt_dm.huggingface", :train_model, model, tokenizer, training_args_obj, dataset_file, @model_options[:class_weights], data_collator: data_collator)
+
+      model.save_pretrained(@model_path) if @model_path
+      tokenizer.save_pretrained(@model_path) if @model_path
+    end
+
+  end
+end

data/lib/rbbt/vector/model/huggingface.rb

@@ -1,50 +1,36 @@
-require 'rbbt/vector/model'
-require 'rbbt/util/python'
+require 'rbbt/vector/model/torch'
 
-RbbtPython.add_path Rbbt.python.find(:lib)
-RbbtPython.init_rbbt
+class HuggingfaceModel < TorchModel
 
-class HuggingfaceModel < VectorModel
+  def initialize(task, checkpoint, dir = nil, model_options = {})
+    super(dir, nil, model_options)
 
-  def self.tsv_dataset(tsv_dataset_file, elements, labels = nil)
+    @model_options = Misc.add_defaults @model_options, :task => task, :checkpoint => checkpoint
 
-    if labels
-      Open.write(tsv_dataset_file) do |ffile|
-        ffile.puts ["label", "text"].flatten * "\t"
-        elements.zip(labels).each do |element,label|
-          ffile.puts [label, element].flatten * "\t"
-        end
-      end
-    else
-      Open.write(tsv_dataset_file) do |ffile|
-        ffile.puts ["text"].flatten * "\t"
-        elements.each{|element| ffile.puts element }
-      end
-    end
+    init_model do 
+      checkpoint = @model_path && File.directory?(@model_path) ? @model_path : @model_options[:checkpoint]
 
-    tsv_dataset_file
-  end
+      model = RbbtPython.call_method("rbbt_dm.huggingface", :load_model, 
+                                     @model_options[:task], checkpoint, **(IndiferentHash.setup(model_options[:model_args]) || {}))
 
-  def initialize(task, checkpoint, *args)
-    options = args.pop if Hash === args.last
-    options = Misc.add_defaults options, :task => task, :checkpoint => checkpoint
-    super(*args)
-    @model_options ||= {}
-    @model_options.merge!(options)
+      tokenizer_checkpoint = @model_options[:tokenizer_checkpoint] || checkpoint
 
-    eval_model do |directory,texts|
-      checkpoint = directory && File.directory?(directory) ? directory : @model_options[:checkpoint]
+      tokenizer = RbbtPython.call_method("rbbt_dm.huggingface", :load_tokenizer, 
+                                         @model_options[:task], tokenizer_checkpoint, **(IndiferentHash.setup(model_options[:tokenizer_args]) || {}))
 
-      if @model.nil?
-        @model, @tokenizer = RbbtPython.call_method("rbbt_dm.huggingface", :load_model_and_tokenizer, @model_options[:task], checkpoint)
-      end
-      
-      if Array === texts
+      [model, tokenizer]
+    end
+
+    eval_model do |texts,is_list|
+      model, tokenizer = self.init
+
+      if is_list || @model_options[:task] == "MaskedLM"
+        texts = [texts] if ! is_list
 
         if @model_options.include?(:locate_tokens)
           locate_tokens = @model_options[:locate_tokens]
         elsif @model_options[:task] == "MaskedLM"
-          @model_options[:locate_tokens] = locate_tokens = @tokenizer.special_tokens_map["mask_token"] 
+          @model_options[:locate_tokens] = locate_tokens = tokenizer.special_tokens_map["mask_token"] 
         end
 
         if @directory
@@ -57,22 +43,21 @@ class HuggingfaceModel < VectorModel
           checkpoint_dir = File.join(tmpdir, 'checkpoints')
         end
 
-        dataset_file = HuggingfaceModel.tsv_dataset(tsv_file, texts)
+        dataset_file = TorchModel.text_dataset(tsv_file, texts)
         training_args_obj = RbbtPython.call_method("rbbt_dm.huggingface", :training_args, checkpoint_dir, @model_options[:training_args])
 
         begin
-          RbbtPython.call_method("rbbt_dm.huggingface", :predict_model, @model, @tokenizer, training_args_obj, dataset_file, locate_tokens)
+          RbbtPython.call_method("rbbt_dm.huggingface", :predict_model, model, tokenizer, training_args_obj, dataset_file, locate_tokens)
         ensure
           Open.rm_rf tmpdir if tmpdir
         end
       else
-        RbbtPython.call_method("rbbt_dm.huggingface", :eval_model, @model, @tokenizer, [texts], locate_tokens)
+        RbbtPython.call_method("rbbt_dm.huggingface", :eval_model, model, tokenizer, [texts], locate_tokens)
       end
     end
 
-    train_model do |directory,texts,labels|
-      checkpoint = directory && File.directory?(directory) ? directory : @model_options[:checkpoint]
-      @model, @tokenizer = RbbtPython.call_method("rbbt_dm.huggingface", :load_model_and_tokenizer, @model_options[:task], checkpoint)
+    train_model do |texts,labels|
+      model, tokenizer = self.init
 
       if @directory
         tsv_file = File.join(@directory, 'dataset.tsv')
@@ -85,17 +70,19 @@ class HuggingfaceModel < VectorModel
       end
 
       training_args_obj = RbbtPython.call_method("rbbt_dm.huggingface", :training_args, checkpoint_dir, @model_options[:training_args])
-      dataset_file = HuggingfaceModel.tsv_dataset(tsv_file, texts, labels)
+      dataset_file = HuggingfaceModel.text_dataset(tsv_file, texts, labels, @model_options[:class_labels])
 
-      RbbtPython.call_method("rbbt_dm.huggingface", :train_model, @model, @tokenizer, training_args_obj, dataset_file, @model_options[:class_weights])
+      RbbtPython.call_method("rbbt_dm.huggingface", :train_model, model, tokenizer, training_args_obj, dataset_file, @model_options[:class_weights])
 
       Open.rm_rf tmpdir if tmpdir
 
-      @model.save_pretrained(directory) if directory
-      @tokenizer.save_pretrained(directory) if directory
+      model.save_pretrained(@model_path) if @model_path
+      tokenizer.save_pretrained(@model_path) if @model_path
     end
 
-    post_process do |result|
+    post_process do |result,is_list|
+      model, tokenizer = self.init
+
       if result.respond_to?(:predictions)
         single = false
         predictions = result.predictions
@@ -137,25 +124,25 @@ class HuggingfaceModel < VectorModel
                        best_token
                      end
 
-                     best.collect{|b| @tokenizer.decode(b) } * "|"
+                     best.collect{|b| tokenizer.decode(b) } * "|"
                    end
                    Array === locate_tokens ? item_masks : item_masks.first
                  end
                else
-                 logits
+                 predictions
                end
 
-      single ? result.first : result
+      (! is_list || single) && Array === result ? result.first : result
     end
 
 
-    save_models if @directory
+    save_models if @model_path
   end
 
   def reset_model
     @model, @tokenizer = nil
-    Open.rm @model_file
+    Open.rm_rf @model_path
+    init
   end
-
 end
 

data/lib/rbbt/vector/model/python.rb

@@ -0,0 +1,33 @@
+require 'rbbt/vector/model'
+require 'rbbt/util/python'
+
+RbbtPython.add_path Rbbt.python.find(:lib)
+RbbtPython.init_rbbt
+
+class PythonModel < VectorModel
+  attr_accessor :python_class, :python_module
+  def initialize(dir, python_class = nil, python_module = nil, model_options = nil)
+    python_module = :model if python_module.nil?
+    model_options, python_module = python_module, :model if model_options.nil? && Hash === python_module
+    model_options = {} if model_options.nil?
+
+    super(dir, model_options)
+
+    @python_class = python_class
+    @python_module = python_module
+
+    init_model do
+      RbbtPython.add_path @directory 
+      RbbtPython.class_new_obj(@python_module, @python_class, **model_options)
+    end if python_class
+
+    eval_model do |features,list=false|
+      init
+      if list
+        model.eval(features)
+      else
+        model.eval([features])[0]
+      end
+    end
+  end
+end

data/lib/rbbt/vector/model/pytorch_lightning.rb

@@ -0,0 +1,31 @@
+require 'rbbt/vector/model/torch'
+
+class PytorchLightningModel < TorchModel
+  attr_accessor :loader, :val_loader, :trainer
+  def initialize(...)
+    super(...)
+
+    train_model do |features,labels|
+      model = init
+      loader = self.loader
+      val_loader = self.val_loader
+      if (features && features.any?) && loader.nil?
+        TmpFile.with_file do |tsv_dataset_file|
+          TorchModel.feature_dataset(tsv_dataset_file, features, labels)
+          RbbtPython.pyimport :rbbt_dm
+          loader = RbbtPython.rbbt_dm.tsv(tsv_dataset_file)
+        end
+      end
+      trainer.fit(model, loader, val_loader)
+      TorchModel.save_architecture(model, model_path) if @directory
+      TorchModel.save_state(model, model_path) if @directory
+    end
+  end
+
+  def trainer
+    @trainer ||= begin
+                   options = @model_options[:training_args] || @model_options[:trainer_args] 
+                   RbbtPython.class_new_obj("pytorch_lightning", "Trainer", options || {})
+                 end
+  end
+end

data/lib/rbbt/vector/model/random_forest.rb

@@ -27,7 +27,7 @@ label = predict(model, features);
   def importance
     TmpFile.with_file do |tmp|
       tsv = R.run <<-EOF
-load(file="#{model_file}");
+load(file="#{@model_path}");
 rbbt.tsv.write('#{tmp}', model$importance)
       EOF
       TSV.open(tmp)

data/lib/rbbt/vector/model/spaCy.rb

@@ -28,12 +28,12 @@ class SpaCyModel < VectorModel
 
     super(dir)
 
-    @train_model = Proc.new do |file, features, labels|
+    @train_model = Proc.new do |features, labels|
       texts = features
       docs = []
       unique_labels = labels.uniq
-      tmpconfig = File.join(file, 'config')
-      tmptrain = File.join(file, 'train.spacy')
+      tmpconfig = File.join(@model_path, 'config')
+      tmptrain = File.join(@model_path, 'train.spacy')
       SpaCy.config(@config, tmpconfig)
 
       bar = bar(features.length, "Training documents into spacy format")
@@ -54,20 +54,22 @@ class SpaCyModel < VectorModel
       end
 
       gpu = Rbbt::Config.get('gpu_id', :spacy, :spacy_train, :default => 0)
-      CMD.cmd_log(:spacy, "train #{tmpconfig} --output #{file} --paths.train #{tmptrain} --paths.dev #{tmptrain}",  "--gpu-id" => gpu)
+      CMD.cmd_log(:spacy, "train #{tmpconfig} --output #{@model_path} --paths.train #{tmptrain} --paths.dev #{tmptrain}",  "--gpu-id" => gpu)
     end
  
-    @eval_model = Proc.new do |file, features,list|
+    @eval_model = Proc.new do |features,list|
       texts = features
       texts = [texts] unless list
 
+      model_path = @model_path
+
       docs = []
       bar = bar(features.length, "Evaluating model")
       SpaCyModel.spacy do
         gpu = Rbbt::Config.get('gpu_id', :spacy, :spacy_train, :default => 0)
         gpu = gpu.to_i if gpu && gpu != ""
         spacy.require_gpu(gpu) if gpu
-        nlp = spacy.load("#{file}/model-best")
+        nlp = spacy.load("#{model_path}/model-best")
 
         docs = nlp.pipe(texts)
         RbbtPython.collect docs, :bar => bar do |d|

data/lib/rbbt/vector/model/tensorflow.rb

@@ -25,7 +25,7 @@ class TensorFlowModel < VectorModel
 
     super(dir)
 
-    @train_model = Proc.new do |file, features, labels|
+    @train_model = Proc.new do |features, labels|
       tensorflow do 
         features = tensorflow.convert_to_tensor(features)
         labels = tensorflow.convert_to_tensor(labels)
@@ -33,16 +33,17 @@ class TensorFlowModel < VectorModel
       @graph ||= keras_graph
       @graph.compile(**@compile_options)
       @graph.fit(features, labels, :epochs => @epochs, :verbose => true)
-      @graph.save(file)
+      @graph.save(@model_path)
     end
  
-    @eval_model = Proc.new do |file, features|
+    @eval_model = Proc.new do |features|
       tensorflow do 
         features = tensorflow.convert_to_tensor(features)
       end
+      model_path = @model_path
+      graph = @graph ||= keras.models.load_model(model_path)
       keras do
-        @graph ||= keras.models.load_model(file)
-        indices = @graph.predict(features, :verbose => false).tolist()
+        indices = graph.predict(features, :verbose => false).tolist()
         labels = indices.collect{|p| p.length > 1 ? p.index(p.max): p.first }
         labels
       end

data/lib/rbbt/vector/model/torch/dataloader.rb

@@ -0,0 +1,58 @@
+class TorchModel
+  def self.feature_tsv(elements, labels = nil, class_labels = nil)
+    tsv = TSV.setup({}, :key_field => "ID", :fields => ["features"], :type => :flat)
+    if labels
+      tsv.fields = tsv.fields + ["label"]
+      labels = case class_labels
+               when Array
+                 labels.collect{|l| class_labels.index l}
+               when Hash
+                 inverse_class_labels = {}
+                 class_labels.each{|c,l| inverse_class_labels[l] = c }
+                 labels.collect{|l| inverse_class_labels[l]}
+               else
+                 labels
+               end
+      elements.zip(labels).each_with_index do |p,i|
+        features, label = p
+        id = i
+        if Array === features
+          tsv[id] = features + [label]
+        else
+          tsv[id] = [features, label]
+        end
+      end
+    else
+      elements.each_with_index do |features,i|
+        id = i
+        if Array === features
+          tsv[id] = features
+        else
+          tsv[id] = [features]
+        end
+      end
+    end
+    tsv
+  end
+
+  def self.feature_dataset(tsv_dataset_file, elements, labels = nil, class_labels = nil)
+    tsv = feature_tsv(elements, labels, class_labels)
+    Open.write(tsv_dataset_file, tsv.to_s)
+    tsv_dataset_file
+  end
+
+  def self.text_dataset(tsv_dataset_file, elements, labels = nil, class_labels = nil)
+    elements = elements.collect{|e| e.gsub("\n", ' ') }
+    tsv = feature_tsv(elements, labels, class_labels)
+    if labels.nil?
+      tsv.fields[0] = "text"
+      tsv.type = :single
+    else
+      tsv.fields[0] = "text"
+      tsv.type = :list
+    end
+    Open.write(tsv_dataset_file, tsv.to_s)
+    tsv_dataset_file
+  end
+
+end

data/lib/rbbt/vector/model/torch/helpers.rb

@@ -0,0 +1,52 @@
+class TorchModel
+  module Tensor
+    def to_ruby
+      RbbtPython.numpy2ruby(self)
+    end
+    def self.setup(obj)
+      obj.extend Tensor
+    end
+  end
+
+  def self.init_python
+    RbbtPython.pyimport :torch
+    RbbtPython.pyimport :rbbt
+    RbbtPython.pyimport :rbbt_dm
+    RbbtPython.pyfrom :rbbt_dm, import: :util
+    RbbtPython.pyfrom :torch, import: :nn
+  end
+
+  def self.optimizer(model, training_args)
+    begin
+      learning_rate = training_args[:learning_rate] || 0.01
+      RbbtPython.torch.optim.SGD.new(model.parameters(), lr: learning_rate)
+    end
+  end
+
+  def self.device(model_options)
+    case model_options[:device]
+    when String, Symbol
+      RbbtPython.torch.device(model_options[:device].to_s)
+    when nil
+      RbbtPython.rbbt_dm.util.device()
+    else
+        model_options[:device]
+    end
+  end
+
+  def self.dtype(model_options)
+    case model_options[:dtype]
+    when String, Symbol
+      RbbtPython.torch.call(model_options[:dtype])
+    when nil
+      nil
+    else
+      model_options[:dtype]
+    end
+  end
+
+  def self.tensor(obj, device, dtype)
+    RbbtPython.torch.tensor(obj, dtype: dtype, device: device)
+  end
+
+end

data/lib/rbbt/vector/model/torch/introspection.rb

@@ -0,0 +1,31 @@
+class TorchModel
+  def self.get_layer(model, layer = nil)
+    if layer.nil?
+      model
+    else
+      layer.split(".").inject(model){|acc,l| PyCall.getattr(acc, l.to_sym) }
+    end
+  end
+  def get_layer(...); TorchModel.get_layer(model, ...); end
+
+  def self.get_weights(model, layer = nil)
+    Tensor.setup PyCall.getattr(get_layer(model, layer), :weight)
+  end
+  def get_weights(...); TorchModel.get_weights(model, ...); end
+
+  def self.freeze(layer)
+    begin
+      PyCall.getattr(layer, :weight).requires_grad = false
+    rescue
+    end
+    RbbtPython.iterate(layer.children) do |layer|
+      freeze(layer)
+    end
+  end
+  def self.freeze_layer(model, layer)
+    layer = get_layer(model, layer)
+    freeze(layer)
+  end
+  def freeze_layer(...); TorchModel.freeze_layer(model, ...); end
+
+end

data/lib/rbbt/vector/model/torch/load_and_save.rb

@@ -0,0 +1,30 @@
+class TorchModel
+  def self.model_architecture(model_path)
+    model_path + '.architecture'
+  end
+
+  def self.save_state(model, model_path)
+    Log.debug "Saving model state into #{model_path}"
+    RbbtPython.torch.save(model.state_dict(), model_path)
+  end
+
+  def self.load_state(model, model_path)
+    return model unless Open.exists?(model_path)
+    Log.debug "Loading model state from #{model_path}"
+    model.load_state_dict(RbbtPython.torch.load(model_path))
+    model
+  end
+
+  def self.save_architecture(model, model_path)
+    model_architecture = model_architecture(model_path)
+    Log.debug "Saving model architecture into #{model_architecture}"
+    RbbtPython.torch.save(model, model_architecture)
+  end
+
+  def self.load_architecture(model_path)
+    model_architecture = model_architecture(model_path)
+    return unless Open.exists?(model_architecture)
+    Log.debug "Loading model architecture from #{model_architecture}"
+    RbbtPython.torch.load(model_architecture)
+  end
+end