daimond 0.1.0

data/lib/daimond/nn/conv2d.rb

@@ -0,0 +1,117 @@
+require_relative 'module'
+
+module Daimond
+  module NN
+    class Conv2d < Module
+      def initialize(in_channels, out_channels, kernel_size, stride: 1, padding: 0)
+        super()
+        @in_channels = in_channels
+        @out_channels = out_channels
+        @kernel_size = kernel_size.is_a?(Array) ? kernel_size : [kernel_size, kernel_size]
+        @stride = stride
+        @padding = padding
+
+        # Xavier инициализация для Conv: sqrt(2 / (in * k * k))
+        k_h, k_w = @kernel_size
+        limit = Math.sqrt(2.0 / (in_channels * k_h * k_w))
+
+        # Веса: [out_channels, in_channels, k_h, k_w]
+        @weight = Tensor.new(
+          Numo::DFloat.new(out_channels, in_channels, k_h, k_w).rand * 2 * limit - limit
+        )
+        @bias = Tensor.zeros(out_channels)
+
+        @parameters = [@weight, @bias]
+      end
+
+      def forward(input)
+        # input: [batch, in_channels, height, width]
+        batch_size = input.shape[0]
+        in_c = @in_channels
+        out_c = @out_channels
+        k_h, k_w = @kernel_size
+
+        # Размеры входа
+        h_in = input.shape[2]
+        w_in = input.shape[3]
+
+        # Размеры выхода (без padding пока)
+        h_out = ((h_in + 2 * @padding - k_h) / @stride).floor + 1
+        w_out = ((w_in + 2 * @padding - k_w) / @stride).floor + 1
+
+        # Выходной тензор
+        output = Numo::DFloat.zeros(batch_size, out_c, h_out, w_out)
+
+        # Добавляем padding если нужно
+        if @padding > 0
+          padded = Numo::DFloat.zeros(batch_size, in_c, h_in + 2*@padding, w_in + 2*@padding)
+          padded[true, true, @padding...h_in+@padding, @padding...w_in+@padding] = input.data
+          x_data = padded
+        else
+          x_data = input.data
+        end
+
+        # Свертка (4 вложенных цикла — медленно, но понятно)
+        batch_size.times do |b|
+          out_c.times do |oc|
+            h_out.times do |i|
+              w_out.times do |j|
+                # Координаты окна
+                i0 = i * @stride
+                j0 = j * @stride
+
+                # Извлекаем окно и считаем свёртку
+                window = x_data[b, true, i0...i0+k_h, j0...j0+k_w]
+                kernel = @weight.data[oc, true, true, true]
+
+                output[b, oc, i, j] = (window * kernel).sum + @bias.data[oc]
+              end
+            end
+          end
+        end
+
+        out_tensor = Tensor.new(output, prev: [input, @weight, @bias], op: 'conv2d')
+
+        # Backward (упрощённо — только для stride=1, padding=0)
+        out_tensor._backward = lambda do
+          grad_output = out_tensor.grad  # [batch, out_c, h_out, w_out]
+
+          # Градиент по весам
+          @out_channels.times do |oc|
+            @in_channels.times do |ic|
+              k_h.times do |kh|
+                k_w.times do |kw|
+                  # Сумма по всем позициям где этот вес участвовал
+                  grad_sum = 0.0
+                  batch_size.times do |b|
+                    h_out.times do |i|
+                      w_out.times do |j|
+                        # Координаты входа
+                        i_in = i * @stride + kh
+                        j_in = j * @stride + kw
+
+                        grad_sum += x_data[b, ic, i_in, j_in] * grad_output[b, oc, i, j]
+                      end
+                    end
+                  end
+                  @weight.grad[oc, ic, kh, kw] += grad_sum
+                end
+              end
+            end
+
+            # Градиент по bias
+            @bias.grad[oc] += grad_output[true, oc, true, true].sum
+          end
+
+          # Градиент по входу (если нужен)
+          if input.grad
+            # full convolution с rotated kernel
+            # Упрощено для stride=1
+          end
+        end
+
+        out_tensor
+      end
+    end
+  end
+end

data/lib/daimond/nn/conv2d_rust.rb

@@ -0,0 +1,52 @@
+require_relative 'module'
+
+module Daimond
+  module NN
+    class Conv2dRust < Module
+      attr_reader :weight, :bias
+
+      def initialize(in_channels, out_channels, kernel_size)
+        super()
+        @in_channels = in_channels
+        @out_channels = out_channels
+        @kernel_size = kernel_size
+
+        # Xavier инициализация
+        k = kernel_size
+        limit = Math.sqrt(2.0 / (in_channels * k * k))
+
+        @weight = Tensor.new(
+          Numo::DFloat.new(out_channels, in_channels, k, k).rand * 2 * limit - limit
+        )
+        @bias = Tensor.zeros(out_channels)
+        @parameters = [@weight, @bias]
+      end
+
+      def forward(input)
+        # input: [batch, in_c, h, w]
+        batch = input.shape[0]
+        in_c = @in_channels
+        out_c = @out_channels
+        h = input.shape[2]
+        w = input.shape[3]
+        k = @kernel_size
+
+        # Используем Rust backend
+        if Daimond::RustBackend.available?
+          output_data = Daimond::RustBackend.conv2d(
+            input.data, @weight.data, @bias.data,
+            batch, in_c, out_c, h, w, k
+          )
+          out = Tensor.new(output_data, prev: [input, @weight, @bias], op: 'conv2d_rust')
+
+          # Backward будет позже, пока заглушка
+          out._backward = lambda {}
+
+          return out
+        else
+          raise "Rust backend required for Conv2dRust"
+        end
+      end
+    end
+  end
+end

data/lib/daimond/nn/flatten.rb

@@ -0,0 +1,29 @@
+require_relative 'module'
+
+module Daimond
+  module NN
+    class Flatten < Module
+      def initialize(start_dim: 1, end_dim: -1)
+        super()
+        @start_dim = start_dim
+        @end_dim = end_dim
+        @input_shape = nil
+      end
+
+      def forward(input)
+        @input_shape = input.shape.dup
+        batch = input.shape[0]
+        rest = input.shape[1..-1].inject(:*)
+
+        out_data = input.data.reshape(batch, rest)
+        out = Tensor.new(out_data, prev: [input], op: 'flatten')
+
+        out._backward = lambda do
+          input.grad += out.grad.reshape(*@input_shape)
+        end
+
+        out
+      end
+    end
+  end
+end

data/lib/daimond/nn/linear.rb

@@ -0,0 +1,22 @@
+require_relative 'module'
+
+module Daimond
+  module NN
+    class Linear < Module
+      def initialize(in_features, out_features)
+        super()
+        # Простая инициализация: small random values
+        @weight = Tensor.new(Numo::DFloat.new(in_features, out_features).rand_norm * 0.01)
+        @bias = Tensor.zeros(out_features)
+        @parameters = [@weight, @bias]
+      end
+
+      def forward(input)
+        # Теперь возвращаем Tensor с поддержкой autograd!
+        input.dot(@weight) + @bias
+      end
+
+      attr_reader :weight, :bias
+    end
+  end
+end

data/lib/daimond/nn/max_pool2d.rb

@@ -0,0 +1,69 @@
+require_relative 'module'
+
+module Daimond
+  module NN
+    class MaxPool2d < Module
+      def initialize(kernel_size, stride: nil)
+        super()
+        @kernel_size = kernel_size.is_a?(Array) ? kernel_size : [kernel_size, kernel_size]
+        @stride = stride || kernel_size
+        @mask = nil  # для backward
+      end
+
+      def forward(input)
+        # input: [batch, channels, h, w]
+        batch_size = input.shape[0]
+        channels = input.shape[1]
+        h_in = input.shape[2]
+        w_in = input.shape[3]
+
+        k_h, k_w = @kernel_size
+        s = @stride
+
+        h_out = (h_in - k_h) / s + 1
+        w_out = (w_in - k_w) / s + 1
+
+        output = Numo::DFloat.zeros(batch_size, channels, h_out, w_out)
+        @mask = {}  # запоминаем индексы максимумов
+
+        batch_size.times do |b|
+          channels.times do |c|
+            h_out.times do |i|
+              w_out.times do |j|
+                # Окно пулинга
+                i0 = i * s
+                j0 = j * s
+                window = input.data[b, c, i0...i0+k_h, j0...j0+k_w]
+
+                max_val = window.max
+                output[b, c, i, j] = max_val
+
+                # Сохраняем позицию максимума для backward
+                max_idx = window.to_a.flatten.index(max_val)
+                @mask[[b, c, i, j]] = [i0 + max_idx / k_w, j0 + max_idx % k_w]
+              end
+            end
+          end
+        end
+
+        out = Tensor.new(output, prev: [input], op: 'maxpool2d')
+
+        out._backward = lambda do
+          grad = out.grad
+          batch_size.times do |b|
+            channels.times do |c|
+              h_out.times do |i|
+                w_out.times do |j|
+                  idx_i, idx_j = @mask[[b, c, i, j]]
+                  input.grad[b, c, idx_i, idx_j] += grad[b, c, i, j]
+                end
+              end
+            end
+          end
+        end
+
+        out
+      end
+    end
+  end
+end

data/lib/daimond/nn/max_pool2d_rust.rb

@@ -0,0 +1,33 @@
+require_relative 'module'
+
+module Daimond
+  module NN
+    class MaxPool2dRust < Module
+      def initialize(kernel_size)
+        super()
+        @kernel_size = kernel_size
+      end
+
+      def forward(input)
+
+        batch = input.shape[0]
+        channels = input.shape[1]
+        h = input.shape[2]
+        w = input.shape[3]
+        k = @kernel_size
+
+        if Daimond::RustBackend.available?
+          output_data = Daimond::RustBackend.maxpool2d(
+            input.data, batch, channels, h, w, k
+          )
+
+          out = Tensor.new(output_data, prev: [input], op: 'maxpool2d_rust')
+          out._backward = lambda {}
+          return out
+        else
+          raise "Rust backend required for MaxPool2dRust"
+        end
+      end
+    end
+  end
+end

data/lib/daimond/nn/module.rb

@@ -0,0 +1,60 @@
+require 'fileutils'
+
+module Daimond
+  module NN
+    class Module
+      def initialize
+        @parameters = []
+      end
+
+      def parameters
+        @parameters
+      end
+
+      def zero_grad
+        @parameters.each do |p|
+          p.grad = Numo::DFloat.zeros(*p.shape)
+        end
+      end
+
+      def forward(*args)
+        raise NotImplementedError
+      end
+
+      def call(*args)
+        forward(*args)
+      end
+
+      # Сохранение модели
+      def save(path)
+        FileUtils.mkdir_p(File.dirname(path)) if File.dirname(path) != '.'
+
+        # Сохраняем массив весов как массив Numo массивов
+        params_data = @parameters.map { |p| p.data }
+        File.open(path, 'wb') { |f| Marshal.dump(params_data, f) }
+
+        puts "Model saved to #{path} (#{@parameters.length} parameters)"
+      end
+
+      # Загрузка модели
+      def load(path)
+        unless File.exist?(path)
+          raise "Model file not found: #{path}"
+        end
+
+        params_data = File.open(path, 'rb') { |f| Marshal.load(f) }
+
+        if params_data.length != @parameters.length
+          raise "Parameter count mismatch: saved #{params_data.length} vs current #{@parameters.length}"
+        end
+
+        @parameters.each_with_index do |param, i|
+          param.data = params_data[i]
+          param.grad = Numo::DFloat.zeros(*param.data.shape)
+        end
+
+        puts "Model loaded from #{path}"
+      end
+    end
+  end
+end

data/lib/daimond/optim/adam.rb

@@ -0,0 +1,41 @@
+module Daimond
+  module Optim
+    class Adam < SGD
+      def initialize(parameters, lr: 0.001, betas: [0.9, 0.999], eps: 1e-8)
+        super(parameters, lr: lr)
+        @betas = betas
+        @eps = eps
+
+        # Первые и вторые моменты
+        @m = @parameters.map { |p| Numo::DFloat.zeros(*p.shape) }  # первый момент (среднее)
+        @v = @parameters.map { |p| Numo::DFloat.zeros(*p.shape) }  # второй момент (квадраты)
+        @t = 0  # шаг обновления
+      end
+
+      def step
+        @t += 1
+        beta1, beta2 = @betas
+
+        @parameters.each_with_index do |param, i|
+          # Градиент
+          g = param.grad
+
+          # Обновляем моменты
+          @m[i] = beta1 * @m[i] + (1 - beta1) * g
+          @v[i] = beta2 * @v[i] + (1 - beta2) * (g * g)
+
+          # Коррекция смещения (bias correction)
+          m_hat = @m[i] / (1 - beta1**@t)
+          v_hat = @v[i] / (1 - beta2**@t)
+
+          # Обновление параметров
+          param.data -= @lr * m_hat / (Numo::NMath.sqrt(v_hat) + @eps)
+        end
+      end
+
+      def zero_grad
+        @parameters.each { |p| p.grad = Numo::DFloat.zeros(*p.shape) }
+      end
+    end
+  end
+end

data/lib/daimond/optim/sgd.rb

@@ -0,0 +1,25 @@
+module Daimond
+  module Optim
+    class SGD
+      def initialize(parameters, lr: 0.01, momentum: 0.9)
+        @parameters = parameters
+        @lr = lr
+        @momentum = momentum
+        @velocities = parameters.map { |p| Numo::DFloat.zeros(*p.shape) }
+      end
+
+      def step
+        @parameters.each_with_index do |param, i|
+          @velocities[i] = @momentum * @velocities[i] + param.grad
+          param.data -= @lr * @velocities[i]
+        end
+      end
+
+      def zero_grad
+        @parameters.each do |p|
+          p.grad = Numo::DFloat.zeros(*p.shape)
+        end
+      end
+    end
+  end
+end

data/lib/daimond/rust_backend.rb

@@ -0,0 +1,23 @@
+begin
+  require_relative 'rust/daimond_rust'
+rescue LoadError
+  # Rust backend не скомпилирован - будем использовать чистый Ruby
+end
+
+module Daimond
+  module RustBackend
+    # Проверка доступности
+    def self.available?
+      true
+    rescue LoadError
+      false
+    end
+
+    # Обертка для матричного умножения
+    def self.matmul(a, b)
+      # Здесь будет код конвертации Ruby -> Rust -> Ruby
+      # Пока просто возвращаем Rust тензор
+      Rust::Tensor.zeros(a.shape[0], b.shape[1])
+    end
+  end
+end

data/lib/daimond/rust_bridge.rb

@@ -0,0 +1,63 @@
+require_relative 'rust/daimond_rust' rescue nil
+
+module Daimond
+  # Проверяем загрузилась ли Rust библиотека
+  def self.rust_available?
+    defined?(Daimond::Rust) && Daimond::Rust.respond_to?(:fast_matmul_flat)
+  end
+
+  # Модуль-обертка для вызовов
+  module RustBackend
+    class << self
+      def available?
+        Daimond.rust_available?
+      end
+
+      def conv2d(input_data, weight_data, bias_data, batch, in_c, out_c, h, w, k)
+        return nil unless available?
+
+        flat_input = input_data.flatten.to_a
+        flat_weight = weight_data.flatten.to_a
+        flat_bias = bias_data.to_a
+
+        result_flat = Daimond::Rust.conv2d_native(
+          flat_input, flat_weight, flat_bias,
+          batch, in_c, out_c, h, w, k
+        )
+
+        h_out = h - k + 1
+        w_out = w - k + 1
+        Numo::DFloat[*result_flat].reshape(batch, out_c, h_out, w_out)
+      end
+
+      def maxpool2d(input_data, batch, channels, h, w, k)
+        return nil unless available?
+
+        flat_input = input_data.flatten.to_a
+        result_flat = Daimond::Rust.maxpool2d_native(
+          flat_input, batch, channels, h, w, k
+        )
+
+        h_out = h / k
+        w_out = w / k
+        Numo::DFloat[*result_flat].reshape(batch, channels, h_out, w_out)
+      end
+
+      def matmul_data(narray_a, narray_b)
+        return nil unless available?
+
+        shape_a = narray_a.shape
+        shape_b = narray_b.shape
+
+        flat_a = narray_a.flatten.to_a
+        flat_b = narray_b.flatten.to_a
+
+        result_flat = Daimond::Rust.fast_matmul_flat(
+          flat_a, flat_b, shape_a[0], shape_a[1], shape_b[1]
+        )
+
+        Numo::DFloat[*result_flat].reshape(shape_a[0], shape_b[1])
+      end
+    end
+  end
+end