daimond 0.1.0

data/lib/daimond/tensor.rb

@@ -0,0 +1,241 @@
+require 'numo/narray'
+require_relative 'rust_backend' rescue nil
+
+module Daimond
+  class Tensor
+    attr_accessor :data, :grad, :prev, :op, :_backward, :label
+
+    def initialize(data, prev: [], op: nil, label: nil)
+      @data = data.is_a?(Numo::DFloat) ? data : Numo::DFloat[*data]
+      @grad = Numo::DFloat.zeros(*@data.shape)
+      @prev = prev
+      @op = op
+      @label = label
+      @_backward = lambda {}  # По умолчанию пустая функция
+    end
+
+    def shape
+      @data.shape
+    end
+
+    def +(other)
+      other = other.is_a?(Tensor) ? other : Tensor.new(other)
+      left = self
+      right = other
+      out = Tensor.new(@data + other.data, prev: [self, other], op: '+')
+
+      out._backward = lambda do
+        grad = out.grad
+
+        # Для left (может быть broadcasted, но здесь обычно нет)
+        if grad.shape.length > left.shape.length
+          left.grad += grad.sum(axis: 0)
+        else
+          left.grad += grad
+        end
+
+        # Для right (bias) — суммируем по batch
+        if grad.shape.length > right.shape.length
+          right.grad += grad.sum(axis: 0)
+        else
+          right.grad += grad
+        end
+      end
+
+      out
+    end
+
+    def -(other)
+      other = other.is_a?(Tensor) ? other : Tensor.new(other)
+      left = self
+      right = other
+      out = Tensor.new(@data - other.data, prev: [self, other], op: '-')
+
+      out._backward = lambda do
+        grad = out.grad
+        left.grad += grad
+
+        if grad.shape.length > right.shape.length
+          right.grad -= grad.sum(axis: 0)
+        else
+          right.grad -= grad
+        end
+      end
+
+      out
+    end
+
+    def *(other)  # Поэлементное
+      other = other.is_a?(Tensor) ? other : Tensor.new(other)
+      left = self
+      right = other
+      out = Tensor.new(@data * other.data, prev: [self, other], op: '*')
+
+      out._backward = lambda do
+        grad = out.grad
+        left.grad += right.data * grad
+        right.grad += left.data * grad
+      end
+
+      out
+    end
+
+    def dot(other)
+      other = other.is_a?(Tensor) ? other : Tensor.new(other)
+
+      inner_dim = @data.shape[1]
+      out_dim = other.data.shape[1]
+
+      # Глобальный счетчик для отладки
+      $rust_count ||= 0
+      $ruby_count ||= 0
+
+      rust_available = defined?(Daimond::Rust)
+      condition = (inner_dim > 100 || out_dim > 50)
+
+      if rust_available && condition
+        begin
+          rust_a = Daimond::Rust::Tensor.from_array(@data.to_a)
+          rust_b = Daimond::Rust::Tensor.from_array(other.data.to_a)
+          rust_result = rust_a.matmul(rust_b)
+
+          out = Tensor.new(Numo::DFloat[*rust_result.to_a], prev: [self, other], op: 'dot')
+          out._backward = lambda do
+            grad = out.grad
+            self.grad += grad.dot(other.data.transpose)
+            other.grad += self.data.transpose.dot(grad)
+          end
+
+          $rust_count += 1
+          out
+        rescue => e
+          $ruby_count += 1
+
+          # Fallback
+          out = Tensor.new(@data.dot(other.data), prev: [self, other], op: 'dot')
+          out._backward = lambda do
+            grad = out.grad
+            self.grad += grad.dot(other.data.transpose)
+            other.grad += self.data.transpose.dot(grad)
+          end
+          out
+        end
+      else
+        $ruby_count += 1
+        # Ruby version
+        out = Tensor.new(@data.dot(other.data), prev: [self, other], op: 'dot')
+        out._backward = lambda do
+          grad = out.grad
+          self.grad += grad.dot(other.data.transpose)
+          other.grad += self.data.transpose.dot(grad)
+        end
+        out
+      end
+    end
+
+    def relu
+      out_data = @data.map { |x| x > 0 ? x : 0.0 }
+      out = Tensor.new(out_data, prev: [self], op: 'relu')
+      input = self
+
+      out._backward = lambda do
+        grad = out.grad
+        mask = input.data.map { |x| x > 0 ? 1.0 : 0.0 }
+        input.grad += mask * grad
+      end
+
+      out
+    end
+
+    def sigmoid
+      input = self
+      s = @data.map { |x| 1.0 / (1.0 + Math.exp(-x)) }
+      out = Tensor.new(s, prev: [self], op: 'sigmoid')
+
+      out._backward = lambda do
+        grad = out.grad
+        input.grad += (out.data * (1.0 - out.data)) * grad
+      end
+
+      out
+    end
+
+    def sum
+      input = self
+      out = Tensor.new(Numo::DFloat[@data.sum], prev: [self], op: 'sum')
+
+      out._backward = lambda do
+        input.grad += Numo::DFloat.ones(*input.shape) * out.grad[0]
+      end
+
+      out
+    end
+
+    def mean
+      input = self
+      out = Tensor.new(Numo::DFloat[@data.mean], prev: [self], op: 'mean')
+      n = @data.size
+
+      out._backward = lambda do
+        input.grad += Numo::DFloat.ones(*input.shape) * (out.grad[0] / n)
+      end
+
+      out
+    end
+
+    def backward!
+      # Топологическая сортировка
+      topo = []
+      visited = []
+
+      build_topo = lambda do |v|
+        return if visited.include?(v)
+        visited << v
+        v.prev.each { |child| build_topo.call(child) }
+        topo << v
+      end
+
+      build_topo.call(self)
+
+      self.grad = Numo::DFloat[1.0]  # seed gradient
+
+      # Идём в обратном порядке (от loss к входам)
+      topo.reverse.each do |node|
+        node._backward.call
+      end
+    end
+
+    def to_s
+      "Tensor(shape=#{shape}, mean=#{@data.mean.round(4)})"
+    end
+
+    alias inspect to_s
+
+    def self.randn(*shape)
+      data = Numo::DFloat.new(*shape).rand_norm
+      Tensor.new(data)
+    end
+
+    def self.zeros(*shape)
+      Tensor.new(Numo::DFloat.zeros(*shape))
+    end
+
+    def softmax
+      input = self
+      # Численная стабильность: вычитаем max по каждой строке
+      max_val = @data.max(axis: 1).reshape(@data.shape[0], 1)
+      exp_data = Numo::NMath.exp(@data - max_val)
+      sum_exp = exp_data.sum(axis: 1).reshape(@data.shape[0], 1)
+      out_data = exp_data / sum_exp
+
+      out = Tensor.new(out_data, prev: [self], op: 'softmax')
+
+      # Backward упрощенный (для связки с CrossEntropy)
+      out._backward = lambda do
+        input.grad += out.grad
+      end
+
+      out
+    end
+  end
+end

data/lib/daimond/utils/training_logger.rb

@@ -0,0 +1,111 @@
+require 'csv'
+
+module Daimond
+  module Utils
+    class TrainingLogger
+      def initialize(filename = 'training_log.csv')
+        @filename = filename
+        @history = []
+        @start_time = Time.now
+
+        CSV.open(@filename, 'w') do |csv|
+          csv << ['epoch', 'loss', 'accuracy', 'time_elapsed']
+        end
+      end
+
+      def log(epoch, loss, accuracy)
+        elapsed = Time.now - @start_time
+        @history << {epoch: epoch, loss: loss, accuracy: accuracy, time: elapsed}
+
+        CSV.open(@filename, 'a') do |csv|
+          csv << [epoch, loss, accuracy, elapsed.round(2)]
+        end
+      end
+
+      def plot_loss(width: 60, height: 10)
+        return if @history.empty?
+
+        losses = @history.map { |h| h[:loss] }
+        min_loss = losses.min
+        max_loss = losses.max
+        range = max_loss - min_loss
+        range = 1.0 if range == 0
+
+        puts "\n📉 Loss Curve:"
+        puts "-" * (width + 10)
+
+        height.times do |row|
+          y_val = max_loss - (row * range / height)
+          line = sprintf("%6.3f |", y_val)
+          line = line.ljust(width + 9)  # <-- Важно!
+
+          @history.each_with_index do |h, i|
+            x_pos = (i * (width - 1) / [@history.size - 1, 1].max).to_i
+            idx = 8 + x_pos
+
+            if idx < line.length && (h[:loss] - y_val).abs < (range / height / 2)
+              line[idx] = "●"
+            end
+          end
+
+          puts line
+        end
+
+        puts "       +" + "-" * width
+        puts "       Epoch: 1" + " " * (width - 10) + "#{@history.size}"
+      end
+
+      def plot_accuracy(width: 60, height: 10)
+        return if @history.empty?
+
+        accs = @history.map { |h| h[:accuracy] }
+        min_acc = [accs.min, 0].min
+        max_acc = [accs.max, 100].max
+        range = max_acc - min_acc
+        range = 100 if range == 0
+
+        puts "\n📈 Accuracy Curve:"
+        puts "-" * (width + 10)
+
+        height.times do |row|
+          y_val = min_acc + ((height - row) * range / height)
+          line = sprintf("%6.1f%%|", y_val)
+          line = line.ljust(width + 9)  # <-- Важно!
+
+          @history.each_with_index do |h, i|
+            x_pos = (i * (width - 1) / [@history.size - 1, 1].max).to_i
+            idx = 8 + x_pos
+
+            if idx < line.length && (h[:accuracy] - y_val).abs < (range / height / 2)
+              line[idx] = "★"
+            end
+          end
+
+          puts line
+        end
+
+        puts "       +" + "-" * width
+        puts "       Epoch: 1" + " " * (width - 10) + "#{@history.size}"
+      end
+
+      def summary
+        return if @history.empty?
+
+        first = @history.first
+        last = @history.last
+
+        puts "\n📊 Training Summary:"
+        puts "=" * 50
+        puts "Duration:        #{(last[:time] / 60).round(1)} minutes"
+        puts "Epochs:          #{last[:epoch]}"
+        puts "Initial Loss:    #{first[:loss].round(4)}"
+        puts "Final Loss:      #{last[:loss].round(4)}"
+        puts "Initial Acc:     #{first[:accuracy].round(2)}%"
+        puts "Final Acc:       #{last[:accuracy].round(2)}%"
+        puts "Improvement:     +#{(last[:accuracy] - first[:accuracy]).round(2)}%"
+        puts "=" * 50
+        puts "Log saved to:    #{@filename}"
+      end
+    end
+  end
+end

data/lib/daimond/version.rb

@@ -0,0 +1,3 @@
+module Daimond
+  VERSION = "0.1.0"
+end

data/lib/daimond.rb

@@ -0,0 +1,40 @@
+require 'numo/narray'
+
+require_relative 'daimond/tensor'
+require_relative 'daimond/nn/module'
+require_relative 'daimond/nn/linear'
+require_relative 'daimond/nn/functional'
+require_relative 'daimond/optim/sgd'
+require_relative 'daimond/loss/mse'
+require_relative 'daimond/loss/cross_entropy'
+require_relative 'daimond/data/mnist'
+require_relative 'daimond/data/data_loader'
+require_relative 'daimond/nn/conv2d'
+require_relative 'daimond/nn/max_pool2d'
+require_relative 'daimond/nn/flatten'
+require_relative 'daimond/optim/adam'
+require_relative 'daimond/nn/conv2d_rust'
+require_relative 'daimond/nn/max_pool2d_rust'
+require_relative 'daimond/version'
+begin
+  require_relative 'daimond/rust_bridge'
+rescue LoadError
+  # Rust backend не обязателен
+end
+
+module Daimond
+
+  def self.randn(*args)
+    Tensor.randn(*args)
+  end
+
+  def self.zeros(*args)
+    Tensor.zeros(*args)
+  end
+end
+
+begin
+  require_relative 'daimond/rust_backend'
+rescue LoadError
+  # Rust backend optional
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: daimond
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hudzone
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: dAImond is a PyTorch-inspired deep learning framework for Ruby featuring
+  automatic differentiation, neural networks, and a high-performance Rust backend
+  for tensor operations. Achieves 89%+ accuracy on MNIST.
+email:
+- your-email@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CONTRIBUTIONG.md
+- README.ja.md
+- README.md
+- README.ru.md
+- ext/daimond_rust/Cargo.lock
+- ext/daimond_rust/Cargo.toml
+- ext/daimond_rust/build.rs
+- ext/daimond_rust/src/lib.rs
+- lib/daimond.rb
+- lib/daimond/autograd.rb
+- lib/daimond/data/data_loader.rb
+- lib/daimond/data/mnist.rb
+- lib/daimond/loss/cross_entropy.rb
+- lib/daimond/loss/mse.rb
+- lib/daimond/nn/conv2d.rb
+- lib/daimond/nn/conv2d_rust.rb
+- lib/daimond/nn/flatten.rb
+- lib/daimond/nn/functional.rb
+- lib/daimond/nn/linear.rb
+- lib/daimond/nn/max_pool2d.rb
+- lib/daimond/nn/max_pool2d_rust.rb
+- lib/daimond/nn/module.rb
+- lib/daimond/optim/adam.rb
+- lib/daimond/optim/sgd.rb
+- lib/daimond/rust/daimond_rust.bundle
+- lib/daimond/rust_backend.rb
+- lib/daimond/rust_bridge.rb
+- lib/daimond/tensor.rb
+- lib/daimond/utils/training_logger.rb
+- lib/daimond/version.rb
+homepage: https://github.com/Hudzone/daimond-ml
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Hudzone/daimond-ml
+  source_code_uri: https://github.com/Hudzone/daimond-ml
+  bug_tracker_uri: https://github.com/Hudzone/daimond-ml/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Deep Learning framework for Ruby with Rust backend
+test_files: []