wandb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0384522cf34b40d0a03a36f32799bb12cf1811b41688d35820638bb590fa7c3c'
+  data.tar.gz: 3a0fb90233c6545cf66e351d6b2694bd485cd63eb70fcbc7520c028829d0667d
+SHA512:
+  metadata.gz: 4aeafd34db937f033b25c0585eaa97d055ca521d4bd0f96ac3b83803dea8c779461a24452c0a6cbcdb075f57c1999ab1443c6e88af27131260ac6ec890fd55c9
+  data.tar.gz: 906f599bd6a224bedb92d74cdd9972079b1e54bbc182d4cfdb79cc074085cdf3dcb827dc389b5f01bc59183a6e4381d4ae459d1fa830297c30654ea5068f2944

data/lib/wandb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Wandb
+  VERSION = "0.1.0"
+end

data/lib/wandb/xgboost_callback.rb

@@ -0,0 +1,91 @@
+module Wandb
+  class XGBoostCallback
+    MINIMIZE_METRICS = %w[rmse logloss error] # Add other metrics as needed
+    MAXIMIZE_METRICS = %w[auc accuracy] # Add other metrics as needed
+
+    def initialize(log_model: false, log_feature_importance: true, importance_type: "gain", define_metric: true)
+      @log_model = log_model
+      @log_feature_importance = log_feature_importance
+      @importance_type = importance_type
+      @define_metric = define_metric
+
+      return if Wandb.current_run
+
+      raise "You must call wandb.init() before WandbCallback()"
+    end
+
+    def before_training(model:)
+      # Update Wandb config with model configuration
+      Wandb.current_run.config = model.params
+      Wandb.log(model.params)
+    end
+
+    def after_training(model:)
+      # Log the model as an artifact
+      log_model_as_artifact(model) if @log_model
+
+      # Log feature importance
+      log_feature_importance(model) if @log_feature_importance
+
+      # Log best score and best iteration
+      return unless model.best_score
+
+      Wandb.log(
+        "best_score" => model.best_score.to_f,
+        "best_iteration" => model.best_iteration.to_i
+      )
+    end
+
+    def before_iteration(model:, epoch:, evals:)
+      # noop
+    end
+
+    def after_iteration(model:, epoch:, evals:, res:)
+      res.each do |metric_name, value|
+        data, metric = metric_name.split("-", 2)
+        full_metric_name = "#{data}-#{metric}"
+
+        if @define_metric
+          define_metric(data, metric)
+          Wandb.log({ full_metric_name => value })
+        else
+          Wandb.log({ full_metric_name => value })
+        end
+      end
+
+      Wandb.log({ "epoch" => epoch })
+      @define_metric = false
+    end
+
+    private
+
+    def log_model_as_artifact(model)
+      model_name = "#{Wandb.current_run.id}_model.json"
+      model_path = File.join(Wandb.current_run.dir, model_name)
+      model.save_model(model_path)
+
+      model_artifact = Wandb.Artifact(name: model_name, type: "model")
+      model_artifact.add_file(model_path)
+      Wandb.current_run.log_artifact(model_artifact)
+    end
+
+    def log_feature_importance(model)
+      fi = model.score(importance_type: @importance_type)
+      fi_data = fi.map { |k, v| [k, v] }
+
+      table = Wandb.Table(data: fi_data, columns: %w[Feature Importance])
+      bar_plot = Wandb.plot.bar(table, "Feature", "Importance", title: "Feature Importance")
+      Wandb.log({ "Feature Importance" => bar_plot })
+    end
+
+    def define_metric(data, metric_name)
+      full_metric_name = "#{data}-#{metric_name}"
+
+      if metric_name.downcase.include?("loss") || MINIMIZE_METRICS.include?(metric_name.downcase)
+        Wandb.define_metric(full_metric_name, summary: "min")
+      elsif MAXIMIZE_METRICS.include?(metric_name.downcase)
+        Wandb.define_metric(full_metric_name, summary: "max")
+      end
+    end
+  end
+end

data/lib/wandb.rb

@@ -0,0 +1,139 @@
+require_relative "wandb/version"
+require "pry"
+require "pycall/import"
+
+# Ensure wandb executable isn't set using Ruby context
+ENV["WANDB__EXECUTABLE"] = `which python3`.chomp.empty? ? `which python`.chomp : `which python3`.chomp
+py_sys = PyCall.import_module("sys")
+py_sys.executable = ENV["WANDB__EXECUTABLE"]
+
+module Wandb
+  include PyCall::Import
+
+  class << self
+    # Lazy-load the wandb Python module
+    def __pyptr__
+      @wandb ||= PyCall.import_module("wandb")
+    end
+
+    def Table(*args, **kwargs)
+      __pyptr__.Table.new(*args, **kwargs)
+    end
+
+    # Expose wandb.plot
+    delegate :plot, to: :__pyptr__
+
+    # Expose define_metric
+    def define_metric(metric_name, **kwargs)
+      __pyptr__.define_metric(name: metric_name.force_encoding("UTF-8"), **kwargs)
+    end
+
+    # Expose wandb.Artifact
+    def Artifact(*args, **kwargs)
+      __pyptr__.Artifact.new(*args, **kwargs)
+    end
+
+    # Expose wandb.Error
+    delegate :Error, to: :__pyptr__
+
+    # Login to Wandb
+    def login(api_key: nil, **kwargs)
+      kwargs = kwargs.to_h
+      kwargs[:key] = api_key if api_key
+      __pyptr__.login(**kwargs)
+    end
+
+    # Initialize a new run
+    def init(**kwargs)
+      run = __pyptr__.init(**kwargs)
+      @current_run = Run.new(run)
+    end
+
+    # Get the current run
+    attr_reader :current_run
+
+    # Log metrics to the current run
+    def log(metrics = {})
+      raise "No active run. Call Wandb.init() first." unless @current_run
+
+      @current_run.log(metrics.symbolize_keys)
+    end
+
+    # Finish the current run
+    def finish
+      @current_run.finish if @current_run
+      @current_run = nil
+      __pyptr__.finish
+    end
+
+    # Access the Wandb API
+    def api
+      @api ||= Api.new(__pyptr__.Api.new)
+    end
+  end
+
+  # Run class
+  class Run
+    def initialize(run)
+      @run = run
+    end
+
+    def log(metrics = {})
+      metrics.symbolize_keys!
+      @run.log(metrics, {})
+    end
+
+    def finish
+      @run.finish
+    end
+
+    def name
+      @run.name
+    end
+
+    def name=(new_name)
+      @run.name = new_name
+    end
+
+    def config
+      @run.config
+    end
+
+    def config=(new_config)
+      @run.config.update(PyCall::Dict.new(new_config))
+    end
+  end
+
+  # Api class
+  class Api
+    def initialize(api)
+      @api = api
+    end
+
+    def projects(entity = nil)
+      projects = @api.projects(entity)
+      projects.map { |proj| Project.new(proj) }
+    end
+
+    def project(name, entity = nil)
+      proj = @api.project(name, entity)
+      Project.new(proj)
+    end
+  end
+
+  # Project class
+  class Project
+    def initialize(project)
+      @project = project
+    end
+
+    def name
+      @project.name
+    end
+
+    def description
+      @project.description
+    end
+end
+
+require_relative "wandb/xgboost_callback"

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: wandb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Brett Shollenberger
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-10-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pycall
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Log model runs to Weights & Biases
+email:
+- brett.shollenberger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/wandb.rb
+- lib/wandb/version.rb
+- lib/wandb/xgboost_callback.rb
+homepage: https://github.com/brettshollenberger/wandb_rb.git
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/brettshollenberger/wandb_rb.git
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: A Ruby integration for the Weights & Biases platform
+test_files: []