scout-ai 0.2.0 → 1.0.1

data/lib/scout/model/python/torch/introspection.rb

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

data/lib/scout/model/python/torch/load_and_save.rb

@@ -0,0 +1,47 @@
+class TorchModel
+  def self.model_architecture(state_file)
+    state_file + '.architecture'
+  end
+
+  def self.save_state(state, state_file)
+    Log.debug "Saving model state into #{state_file}"
+    ScoutPython.torch.save(state.state_dict(), state_file)
+  end
+
+  def self.load_state(state, state_file)
+    return state unless Open.exists?(state_file)
+    Log.debug "Loading model state from #{state_file}"
+    state.load_state_dict(ScoutPython.torch.load(state_file))
+    state
+  end
+
+  def self.save_architecture(state, state_file)
+    model_architecture = model_architecture(state_file)
+    Log.debug "Saving model architecture into #{model_architecture}"
+    ScoutPython.torch.save(state, model_architecture)
+  end
+
+  def self.load_architecture(state_file)
+    model_architecture = model_architecture(state_file)
+    return unless Open.exists?(model_architecture)
+    Log.debug "Loading model architecture from #{model_architecture}"
+    ScoutPython.torch.load(model_architecture, weights_only: false)
+  end
+
+  def reset_state
+    @trainer = @state = nil
+    Open.rm_rf state_file
+    Open.rm_rf TorchModel.model_architecture(state_file)
+  end
+
+  def self.save(state_file, state)
+    TorchModel.save_architecture(state, state_file)
+    TorchModel.save_state(state, state_file)
+  end
+
+  def self.load(state_file, state = nil)
+    state ||= TorchModel.load_architecture(state_file)
+    TorchModel.load_state(state, state_file)
+    state
+  end
+end

data/lib/scout/model/python/torch.rb

@@ -0,0 +1,94 @@
+require_relative 'base'
+
+class TorchModel < PythonModel
+  attr_accessor :criterion, :optimizer, :device, :dtype
+
+  def fix_options
+    @options[:training_options] = @options.delete(:training_args) if @options.include?(:training_args)
+    training_args = IndiferentHash.pull_keys(@options, :training) || {}
+    @options[:training_args] = training_args
+  end
+
+  def initialize(...)
+
+    super(...)
+
+    fix_options
+
+    load_state do |state_file|
+      @state = TorchModel.load(state_file, @state)
+    end
+
+    save_state do |state_file,state|
+      TorchModel.save(state_file, state)
+    end
+
+    train do |features,labels|
+      TorchModel.init_python
+      device ||= TorchModel.device(options)
+      dtype ||= TorchModel.dtype(options)
+      state.to(device)
+      @optimizer ||= TorchModel.optimizer(state, options[:training_args] || {})
+      @criterion ||= TorchModel.optimizer(state, options[:training_args] || {})
+
+      epochs = options[:training_args][:epochs] || 3
+      batch_size = options[:batch_size]
+      batch_size ||= options[:training_args][:batch_size]
+      batch_size ||= 1
+
+      inputs = TorchModel.tensor(features, device, dtype)
+      #target = TorchModel.tensor(labels.collect{|v| [v] }, @device, @dtype)
+      target = TorchModel.tensor(labels, device, dtype)
+
+      Log::ProgressBar.with_bar epochs, :desc => "Training" do |bar|
+        epochs.times do |i|
+          optimizer.zero_grad()
+          outputs = state.call(inputs)
+          outputs = outputs.squeeze() if target.dim() == 1
+          loss = criterion.call(outputs, target)
+          loss.backward()
+          optimizer.step
+          Log.debug "Epoch #{i}, loss #{loss}"
+          bar.tick
+        end
+      end
+    end
+
+    self.eval do |features,list|
+      TorchModel.init_python
+      device ||= TorchModel.device(options)
+      dtype ||= TorchModel.dtype(options)
+      state.to(device)
+      state.eval
+
+      list = [features] if features
+
+      batch_size = options[:batch_size]
+      batch_size ||= options[:training_args][:batch_size]
+      batch_size ||= 1
+
+      res = Misc.chunk(list, batch_size).inject(nil) do |acc,batch|
+        tensor = TorchModel.tensor(batch, device, dtype)
+
+        loss, chunk_res = state.call(tensor)
+        tensor.del
+
+        chunk_res = loss if chunk_res.nil?
+
+        TorchModel::Tensor.setup(chunk_res)
+        chunk_res = chunk_res.to_ruby!
+
+        acc = acc.nil? ? chunk_res : acc + chunk_res
+
+        acc
+      end
+
+      features ? res[0] : res
+    end
+  end
+end
+
+require_relative 'torch/helpers'
+require_relative 'torch/dataloader'
+require_relative 'torch/load_and_save'
+require_relative 'torch/introspection'

data/lib/scout/model/util/run.rb

@@ -0,0 +1,181 @@
+class ScoutModel
+  def execute(method, *args)
+    case method
+    when Proc
+      instance_exec *args, &method
+    when nil
+      args.first
+    end
+  end
+
+  def save_state(&block)
+    if block_given?
+      @save_state = block
+    else
+      return @state unless @save_state
+      execute @save_state, state_file, @state
+    end
+  end
+
+  def load_state(&block)
+    if block_given?
+      @load_state = block
+    else
+      return @state unless @load_state
+      execute @load_state, state_file
+    end
+  end
+
+  def init(&block)
+    return @state if @state
+    if block_given?
+      @init = block
+    else
+      @state = execute @init
+      load_state
+      @state
+    end
+  end
+
+  def eval(sample = nil, &block)
+    if block_given?
+      @eval = block
+    else
+      features = extract_features sample
+
+      init unless @state
+      result = if @eval.arity == 2
+
+                 execute @eval, features, nil
+               else
+                 execute @eval, features
+               end
+
+      post_process result
+    end
+  end
+
+  def eval_list(list = nil, &block)
+    if block_given?
+       @eval_list = block
+    else
+      list = extract_features_list list
+
+      init unless @state
+      result = if @eval_list
+                 execute @eval_list, list
+               elsif @eval
+
+                 if @eval.arity == 2
+                   execute @eval, nil, list
+                 else
+                   list.collect{|features| execute @eval, features }
+                 end
+               end
+
+      post_process_list result
+    end
+  end
+
+  def post_process(result = nil, &block)
+    if block_given?
+      @post_process = block
+    else
+      return result if @post_process.nil?
+
+      if @post_process.arity == 2
+        execute @post_process, result, nil
+      else
+        execute @post_process, result
+      end
+    end
+  end
+
+  def post_process_list(list = nil, &block)
+    if block_given?
+       @post_process_list = block
+    else
+
+      if @post_process_list
+        execute @post_process_list, list
+      elsif @post_process
+        if @post_process.arity == 2
+          execute @post_process, nil, list
+        else
+          list.collect{|result| execute @post_process, result }
+        end
+      else
+        return list
+      end
+    end
+  end
+
+  def train(&block)
+    if block_given?
+      @train = block
+    else
+      init unless @state
+      execute @train, @features, @labels
+      save_state
+    end
+  end
+
+  def extract_features(sample = nil, &block)
+    if block_given?
+      @extract_features = block
+    else
+      return sample if @extract_features.nil?
+
+      if @extract_features.arity == 2
+        execute @extract_features, sample, nil
+      else
+        execute @extract_features, sample
+      end
+    end
+  end
+
+  def extract_features_list(list = nil, &block)
+    if block_given?
+       @extract_features_list = block
+    else
+      return list if @extract_features.nil?
+
+      if @extract_features_list
+        execute @extract_features_list, list
+      elsif @extract_features
+        if @extract_features.arity == 2
+          execute @extract_features, nil, list
+        else
+          list.collect{|sample| execute @extract_features, sample }
+        end
+      else
+        return list
+      end
+    end
+  end
+
+  def add(sample, label = nil)
+    features = extract_features sample
+    @features << features
+    @labels << label
+  end
+
+  def add_list(list, labels = nil)
+    if Hash === list
+      list.each do |sample,label|
+        add sample, label
+      end
+    else
+      list = extract_features_list list
+      @features.concat list
+
+      if Hash === labels
+        list.each do |sample|
+          @labels << labels[sample]
+        end
+      elsif labels
+        @labels.concat labels
+      end
+    end
+  end
+end

data/lib/scout/model/util/save.rb

@@ -0,0 +1,81 @@
+class ScoutModel
+  def state_file
+    return nil unless directory
+    directory.state
+  end
+
+  def save_options
+    file = directory['options.json']
+    file.write(options.to_json)
+  end
+
+  def load_options
+    file = directory['options.json']
+    if file.exists?
+      IndiferentHash.setup(JSON.parse(file.read)).merge @options
+    else
+      @options
+    end
+  end
+
+  def load_ruby_code(file)
+    Log.debug "Loading ruby file #{file}"
+    code = Open.read(file)
+    code.sub!(/.*(\sdo\b|{)/, 'Proc.new\1')
+    instance_eval code, file
+  end
+
+  def load_method(name)
+    file = directory[name.to_s]
+
+    if file.exists?
+      file.read
+    elsif file.set_extension('rb').exists?
+      load_ruby_code file.set_extension('rb')
+    end
+  end
+
+  def save_method(name, value)
+    file = directory[name.to_s]
+
+    Log.debug "Saving #{file}"
+    case
+    when Proc === value
+      require 'method_source'
+      Open.write(file.set_extension('rb'), value.source)
+    when String === train_model
+      Open.write(file, @train_model)
+    end
+  end
+
+  def save
+    save_options if @options
+
+    save_method(:eval, @eval) if @eval
+    save_method(:eval_list, @eval_list) if @eval_list
+    save_method(:extract_features, @extract_features) if @extract_features
+    save_method(:extract_features_list, @extract_features_list) if @extract_features_list
+    save_method(:post_process, @post_process) if @post_process
+    save_method(:post_process_list, @post_process_list) if @post_process_list
+    save_method(:train, @train) if @train
+    save_method(:init, @init) if @init
+    save_method(:load_state, @load_state) if @load_state
+    save_method(:save_state, @save_state) if @save_state
+
+    save_state if @state
+  end
+
+  def restore
+    @eval = load_method :eval
+    @eval_list = load_method :eval_list
+    @extract_features = load_method :extract_features
+    @extract_features_list = load_method :extract_features_list
+    @post_process = load_method :post_process
+    @post_process_list = load_method :post_process_list
+    @train = load_method :train
+    @init = load_method :init
+    @load_state = load_method :load_state
+    @save_state = load_method :save_state
+    @options = load_options
+  end
+end

data/lib/scout-ai.rb

@@ -1,7 +1,10 @@
 require 'scout'
 require 'scout/path'
 require 'scout/resource'
-Path.add_path :scout_ai, File.join(Path.caller_lib_dir(__FILE__), "{TOPLEVEL}/{SUBPATH}")
+
+Path.add_path :scout_ai_lib, File.join(Path.caller_lib_dir(__FILE__), "{TOPLEVEL}/{SUBPATH}")
 
 require 'scout/llm/ask'
+require 'scout/llm/chat'
 require 'scout/llm/embed'
+require 'scout/llm/agent'

data/python/scout_ai/__init__.py

@@ -0,0 +1,35 @@
+import scout
+import torch
+from .util import *
+
+class TSVDataset(torch.utils.data.Dataset):
+    def __init__(self, tsv):
+        self.tsv = tsv
+
+    def __getitem__(self, key):
+        if (type(key) == int):
+            row = self.tsv.iloc[key]
+        else:
+            row = self.tsv.loc[key]
+
+        row = row.to_numpy()
+        features = row[:-1]
+        label = row[-1]
+
+        return features, label
+
+    def __len__(self):
+        return len(self.tsv)
+
+def tsv_dataset(filename, *args, **kwargs):
+    return TSVDataset(scout.tsv(filename, *args, **kwargs))
+
+def tsv(*args, **kwargs):
+    return tsv_dataset(*args, **kwargs)
+
+def tsv_loader(*args, **kwargs):
+    dataset = tsv(*args, kwargs)
+    return torch.utils.data.DataLoader(dataset, batch_size=2, shuffle=True)
+
+def data_dir():
+    return scout.path('var/scout_dm/data')

data/python/scout_ai/huggingface/data.py

@@ -0,0 +1,48 @@
+import scout
+import pandas as pd
+import datasets
+from typing import Any, Dict, List
+
+def load_tsv(tsv_file):
+    tsv = scout.tsv(tsv_file)
+    ds = datasets.Dataset.from_pandas(tsv)
+    d = datasets.DatasetDict()
+    d["train"] = ds
+    return d
+
+def load_json(json_file):
+    return datasets.load_dataset('json', data_files=[json_file])
+
+def tokenize_dataset(tokenizer, dataset, max_length=32):
+    def preprocess_function(examples):
+        return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=max_length)
+    if isinstance(dataset, datasets.DatasetDict):
+        for split in dataset:
+            dataset[split] = dataset[split].map(preprocess_function, batched=True)
+        return dataset
+    else:
+        return dataset.map(preprocess_function, batched=True)
+
+def tsv_dataset(tokenizer, tsv_file):
+    dataset = load_tsv(tsv_file)
+    return tokenize_dataset(tokenizer, dataset)
+
+def json_dataset(tokenizer, json_file):
+    dataset = load_json(json_file)
+    return tokenize_dataset(tokenizer, dataset)
+
+def list_dataset(tokenizer, texts, labels=None, max_length=32):
+    data_dict = {"text": texts}
+    if labels is not None:
+        data_dict["label"] = labels
+    ds = datasets.Dataset.from_dict(data_dict)
+
+    def preprocess_function(examples):
+        output = tokenizer(examples["text"], truncation=True, padding="max_length", max_length=max_length)
+        if "label" in examples:
+            output["label"] = examples["label"]
+        return output
+
+    tokenized_ds = ds.map(preprocess_function, batched=True)
+    return tokenized_ds
+

data/python/scout_ai/huggingface/eval.py

@@ -0,0 +1,60 @@
+def forward(model, features):
+    return model(**features)
+
+def get_logits(predictions):
+    logits = predictions["logits"]
+    return [v.detach().cpu().numpy() for v in logits]
+
+def eval_model(model, tokenizer, texts, return_logits=True):
+    features = tokenizer(texts, return_tensors='pt', truncation=True).to(model.device)
+    model.eval()
+    predictions = forward(model, features)
+    if return_logits:
+        return get_logits(predictions)
+    return predictions
+
+def eval_causal_lm_chat(
+    model, tokenizer, messages,
+    chat_template=None,
+    chat_template_kwargs=None,
+    generation_kwargs=None
+):
+    """
+    Evaluate a CausalLM model given chat messages. Uses tokenizer's chat template by default.
+
+    Args:
+        model: Huggingface CausalLM
+        tokenizer: Huggingface tokenizer
+        messages: List[Dict[str, str]] (OpenAI API style, 'role' and 'content')
+        chat_template: (Optional) Override string for the chat template.
+        chat_template_kwargs: (Optional) Dict, kwargs for apply_chat_template (like tokenize, add_generation_prompt, etc).
+        generation_kwargs: (Optional) Dict for model.generate
+
+    Returns:
+        Generated text (or list, depending on settings).
+    """
+    chat_template_kwargs = chat_template_kwargs or {}
+    generation_kwargs = generation_kwargs or {}
+
+    # If the tokenizer has a chat template (HF 4.34+)
+    if hasattr(tokenizer, "___apply_chat_template"):
+        kwargs = dict(add_generation_prompt=True, tokenize=False)
+        kwargs.update(chat_template_kwargs)
+        if chat_template is not None:
+            # Override the template (may require tokenizer._chat_template)
+            tokenizer._chat_template = chat_template
+        prompt = tokenizer.apply_chat_template(messages, **kwargs)
+    else:
+        # Fallback: simple concatenation
+        prompt = "\n".join([msg['content'] for msg in messages])
+
+    # Tokenize as usual
+    inputs = tokenizer(prompt, return_tensors='pt').to(model.device)
+    model.eval()
+    # Use generate
+    output_ids = model.generate(**inputs, **generation_kwargs)
+    # Decode only the newly generated tokens (not the prompt)
+    output_text = tokenizer.decode(
+        output_ids[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True
+    )
+    return output_text

data/python/scout_ai/huggingface/model.py

@@ -0,0 +1,29 @@
+# huggingface_model.py
+import importlib
+from typing import Optional, Any
+
+def import_module_class(module: str, class_name: str) -> Any:
+    """Dynamically import a class from a module."""
+    mod = importlib.import_module(module)
+    return getattr(mod, class_name)
+
+def load_model(task: Optional[str], checkpoint: str, **kwargs) -> Any:
+    """Load a Huggingface model by task and checkpoint"""
+    if task is None or task.lower() == 'embedding':
+        model_class = import_module_class('transformers', 'AutoModel')
+    elif ":" in task:
+        module, class_name = task.split(":")
+        model_class = import_module_class(module, class_name)
+    else:
+        model_class = import_module_class('transformers', f'AutoModelFor{task}')
+    return model_class.from_pretrained(checkpoint, **kwargs)
+
+def load_tokenizer(checkpoint: str, **kwargs) -> Any:
+    """Load a Huggingface tokenizer"""
+    tokenizer_class = import_module_class('transformers', 'AutoTokenizer')
+    return tokenizer_class.from_pretrained(checkpoint, **kwargs)
+
+def load_model_and_tokenizer(task: Optional[str], checkpoint: str, **kwargs):
+    model = load_model(task, checkpoint, **kwargs)
+    tokenizer = load_tokenizer(checkpoint, **kwargs)
+    return model, tokenizer