scout-ai 0.2.0 → 1.0.0

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,9 @@
 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/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/atcold/plot_lib.py

@@ -0,0 +1,141 @@
+from matplotlib import pyplot as plt
+import numpy as np
+import torch
+from IPython.display import HTML, display
+
+
+def set_default(figsize=(10, 10), dpi=100):
+    plt.style.use(['dark_background', 'bmh'])
+    plt.rc('axes', facecolor='k')
+    plt.rc('figure', facecolor='k')
+    plt.rc('figure', figsize=figsize, dpi=dpi)
+
+
+def plot_data(X, y, d=0, auto=False, zoom=1):
+    X = X.cpu()
+    y = y.cpu()
+    plt.scatter(X.numpy()[:, 0], X.numpy()[:, 1], c=y, s=20, cmap=plt.cm.Spectral)
+    plt.axis('square')
+    plt.axis(np.array((-1.1, 1.1, -1.1, 1.1)) * zoom)
+    if auto is True: plt.axis('equal')
+    plt.axis('off')
+
+    _m, _c = 0, '.15'
+    plt.axvline(0, ymin=_m, color=_c, lw=1, zorder=0)
+    plt.axhline(0, xmin=_m, color=_c, lw=1, zorder=0)
+
+
+def plot_model(X, y, model):
+    model.cpu()
+    mesh = np.arange(-1.1, 1.1, 0.01)
+    xx, yy = np.meshgrid(mesh, mesh)
+    with torch.no_grad():
+        data = torch.from_numpy(np.vstack((xx.reshape(-1), yy.reshape(-1))).T).float()
+        Z = model(data).detach()
+    Z = np.argmax(Z, axis=1).reshape(xx.shape)
+    plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.3)
+    plot_data(X, y)
+
+
+def show_scatterplot(X, colors, title=''):
+    colors = colors.cpu().numpy()
+    X = X.cpu().numpy()
+    plt.figure()
+    plt.axis('equal')
+    plt.scatter(X[:, 0], X[:, 1], c=colors, s=30)
+    # plt.grid(True)
+    plt.title(title)
+    plt.axis('off')
+
+
+def plot_bases(bases, width=0.04):
+    bases = bases.cpu()
+    bases[2:] -= bases[:2]
+    plt.arrow(*bases[0], *bases[2], width=width, color=(1,0,0), zorder=10, alpha=1., length_includes_head=True)
+    plt.arrow(*bases[1], *bases[3], width=width, color=(0,1,0), zorder=10, alpha=1., length_includes_head=True)
+
+
+def show_mat(mat, vect, prod, threshold=-1):
+    # Subplot grid definition
+    fig, (ax1, ax2, ax3) = plt.subplots(1, 3, sharex=False, sharey=True,
+                                        gridspec_kw={'width_ratios':[5,1,1]})
+    # Plot matrices
+    cax1 = ax1.matshow(mat.numpy(), clim=(-1, 1))
+    ax2.matshow(vect.numpy(), clim=(-1, 1))
+    cax3 = ax3.matshow(prod.numpy(), clim=(threshold, 1))
+
+    # Set titles
+    ax1.set_title(f'A: {mat.size(0)} \u00D7 {mat.size(1)}')
+    ax2.set_title(f'a^(i): {vect.numel()}')
+    ax3.set_title(f'p: {prod.numel()}')
+
+    # Remove xticks for vectors
+    ax2.set_xticks(tuple())
+    ax3.set_xticks(tuple())
+    
+    # Plot colourbars
+    fig.colorbar(cax1, ax=ax2)
+    fig.colorbar(cax3, ax=ax3)
+
+    # Fix y-axis limits
+    ax1.set_ylim(bottom=max(len(prod), len(vect)) - 0.5)
+
+
+colors = dict(
+    aqua='#8dd3c7',
+    yellow='#ffffb3',
+    lavender='#bebada',
+    red='#fb8072',
+    blue='#80b1d3',
+    orange='#fdb462',
+    green='#b3de69',
+    pink='#fccde5',
+    grey='#d9d9d9',
+    violet='#bc80bd',
+    unk1='#ccebc5',
+    unk2='#ffed6f',
+)
+
+
+def _cstr(s, color='black'):
+    if s == ' ':
+        return f'<text style=color:#000;padding-left:10px;background-color:{color}> </text>'
+    else:
+        return f'<text style=color:#000;background-color:{color}>{s} </text>'
+
+# print html
+def _print_color(t):
+    display(HTML(''.join([_cstr(ti, color=ci) for ti, ci in t])))
+
+# get appropriate color for value
+def _get_clr(value):
+    colors = ('#85c2e1', '#89c4e2', '#95cae5', '#99cce6', '#a1d0e8',
+              '#b2d9ec', '#baddee', '#c2e1f0', '#eff7fb', '#f9e8e8',
+              '#f9e8e8', '#f9d4d4', '#f9bdbd', '#f8a8a8', '#f68f8f',
+              '#f47676', '#f45f5f', '#f34343', '#f33b3b', '#f42e2e')
+    value = int((value * 100) / 5)
+    if value == len(colors): value -= 1  # fixing bugs...
+    return colors[value]
+
+def _visualise_values(output_values, result_list):
+    text_colours = []
+    for i in range(len(output_values)):
+        text = (result_list[i], _get_clr(output_values[i]))
+        text_colours.append(text)
+    _print_color(text_colours)
+
+def print_colourbar():
+    color_range = torch.linspace(-2.5, 2.5, 20)
+    to_print = [(f'{x:.2f}', _get_clr((x+2.5)/5)) for x in color_range]
+    _print_color(to_print)
+
+
+# Let's only focus on the last time step for now
+# First, the cell state (Long term memory)
+def plot_state(data, state, b, decoder):
+    actual_data = decoder(data[b, :, :].numpy())
+    seq_len = len(actual_data)
+    seq_len_w_pad = len(state)
+    for s in range(state.size(2)):
+        states = torch.sigmoid(state[:, b, s])
+        _visualise_values(states[seq_len_w_pad - seq_len:], list(actual_data))

data/python/scout_ai/atcold/spiral.py

@@ -0,0 +1,27 @@
+import torch
+import math
+def spiral_data(N=1000, D=2, C=3):
+    X = torch.zeros(N * C, D)
+    y = torch.zeros(N * C, dtype=torch.long)
+    for c in range(C):
+        index = 0
+        t = torch.linspace(0, 1, N)
+        # When c = 0 and t = 0: start of linspace
+        # When c = 0 and t = 1: end of linpace
+        # This inner_var is for the formula inside sin() and cos() like sin(inner_var) and cos(inner_Var)
+        inner_var = torch.linspace(
+            # When t = 0
+            (2 * math.pi / C) * (c),
+            # When t = 1
+            (2 * math.pi / C) * (2 + c),
+            N
+        ) + torch.randn(N) * 0.2
+
+        for ix in range(N * c, N * (c + 1)):
+            X[ix] = t[index] * torch.FloatTensor((
+                math.sin(inner_var[index]), math.cos(inner_var[index])
+            ))
+            y[ix] = c
+            index += 1
+
+    return (X, y)

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
+