neighbor 0.1.2 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e64a3292445759187b7c08fd9cc54fe0da340ea3e3ab5de909620de6395b4984
-  data.tar.gz: 274d73ed464a0503973c5549022dca8820257fe470c9746b5599da9a153d46e3
+  metadata.gz: da5f64785d929d673be65b5cf224894b6e5d6bbd8d66a27b84339ced5e8c1334
+  data.tar.gz: fbb217005dcd6a3c1d946eec178acf7f0f87ac3521e2deb4b7c8c2bc5433b633
 SHA512:
-  metadata.gz: 17df9f8a5848337fc570c6fa685f54f4aa9d49bea8e52e74fbec098e0bc9e450b655c7d96cb66c6e8b6aaae4824f2c831ea26a14f7f46b50ef64c955cfb9839b
-  data.tar.gz: a47165d174ec86ebfdcd128e62c50b85d097aac535b6b6d424ea31988428a57237cdade2829d8e22a15e566ac7597371c95fabafad42cdbc5d56f063abab55e4
+  metadata.gz: d293a32bfd18e00851bcbbaecac507374e9105071fbf7ab8446eaea093b9741b573356a7b292bf19dd420c2d7208c62023be4f7106711e19f9e84970aedba2bd
+  data.tar.gz: 07ed7bccab0924fe183df1176937d6ce98d1e53313e2be53d96605d691ad697ff4e14abc722b7a3501b20a5ca2880774625a306c274f81d308895fa78a1bf068

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 0.2.2 (2022-07-13)
+
+- Added support for configurable attribute name
+- Added support for multiple attributes per model
+
+## 0.2.1 (2021-12-15)
+
+- Added support for Active Record 7
+
+## 0.2.0 (2021-04-21)
+
+- Added support for pgvector
+- Added `normalize` option
+- Made `dimensions` optional
+- Raise an error if `nearest_neighbors` already defined
+- Raise an error for non-finite values
+- Fixed NaN with zero vectors and cosine distance
+
+Breaking changes
+
+- The `distance` option has been moved from `has_neighbors` to `nearest_neighbors`, and there is no longer a default
+
 ## 0.1.2 (2021-02-21)
 
 - Added `nearest_neighbors` scope

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2021 Andrew Kane
+Copyright (c) 2021-2022 Andrew Kane
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -9,18 +9,26 @@ Nearest neighbor search for Rails and Postgres
 Add this line to your application’s Gemfile:
 
 ```ruby
-gem 'neighbor'
+gem "neighbor"
 ```
 
-And run:
+## Choose An Extension
+
+Neighbor supports two extensions: [cube](https://www.postgresql.org/docs/current/cube.html) and [vector](https://github.com/pgvector/pgvector). cube ships with Postgres, while vector supports approximate nearest neighbor search.
+
+For cube, run:
 
 ```sh
-bundle install
-rails generate neighbor:install
+rails generate neighbor:cube
 rails db:migrate
 ```
 
-This enables the [cube extension](https://www.postgresql.org/docs/current/cube.html) in Postgres
+For vector, [install pgvector](https://github.com/pgvector/pgvector#installation) and run:
+
+```sh
+rails generate neighbor:vector
+rails db:migrate
+```
 
 ## Getting Started
 
@@ -30,6 +38,8 @@ Create a migration
 class AddNeighborVectorToItems < ActiveRecord::Migration[6.1]
   def change
     add_column :items, :neighbor_vector, :cube
+    # or
+    add_column :items, :neighbor_vector, :vector, limit: 3 # dimensions
   end
 end
 ```
@@ -38,7 +48,7 @@ Add to your model
 
 ```ruby
 class Item < ApplicationRecord
-  has_neighbors dimensions: 3
+  has_neighbors
 end
 ```
 
@@ -48,49 +58,76 @@ Update the vectors
 item.update(neighbor_vector: [1.0, 1.2, 0.5])
 ```
 
-> With cosine distance (the default), vectors are normalized before being stored
-
 Get the nearest neighbors to a record
 
 ```ruby
-item.nearest_neighbors.first(5)
+item.nearest_neighbors(distance: "euclidean").first(5)
 ```
 
 Get the nearest neighbors to a vector
 
 ```ruby
-Item.nearest_neighbors([1, 2, 3])
+Item.nearest_neighbors([0.9, 1.3, 1.1], distance: "euclidean").first(5)
 ```
 
 ## Distance
 
-Specify the distance metric
+Supported values are:
+
+- `euclidean`
+- `cosine`
+- `taxicab` (cube only)
+- `chebyshev` (cube only)
+- `inner_product` (vector only)
+
+For cosine distance with cube, vectors must be normalized before being stored.
 
 ```ruby
 class Item < ApplicationRecord
-  has_neighbors dimensions: 20, distance: "euclidean"
+  has_neighbors normalize: true
 end
 ```
 
-Supported values are:
-
-- `cosine` (default)
-- `euclidean`
-- `taxicab`
-- `chebyshev`
-
-For inner product, see [this example](examples/disco_user_recs.rb)
+For inner product with cube, see [this example](examples/disco_user_recs_cube.rb).
 
 Records returned from `nearest_neighbors` will have a `neighbor_distance` attribute
 
 ```ruby
-nearest_item = item.nearest_neighbors.first
+nearest_item = item.nearest_neighbors(distance: "euclidean").first
 nearest_item.neighbor_distance
 ```
 
 ## Dimensions
 
-By default, Postgres limits the `cube` data type to 100 dimensions. See the [Postgres docs](https://www.postgresql.org/docs/current/cube.html) for how to increase this.
+The cube data type is limited 100 dimensions by default. See the [Postgres docs](https://www.postgresql.org/docs/current/cube.html) for how to increase this. The vector data type is limited to 1024 dimensions.
+
+For cube, it’s a good idea to specify the number of dimensions to ensure all records have the same number.
+
+```ruby
+class Movie < ApplicationRecord
+  has_neighbors dimensions: 3
+end
+```
+
+## Indexing
+
+For vector, add an approximate index to speed up queries. Create a migration with:
+
+```ruby
+class AddIndexToItemsNeighborVector < ActiveRecord::Migration[6.1]
+  def change
+    add_index :items, :neighbor_vector, using: :ivfflat, opclass: :vector_l2_ops
+  end
+end
+```
+
+Use `:vector_cosine_ops` for cosine distance and `:vector_ip_ops` for inner product.
+
+Set the number of probes
+
+```ruby
+Item.connection.execute("SET ivfflat.probes = 3")
+```
 
 ## Example
 
@@ -107,7 +144,7 @@ And add `has_neighbors`
 
 ```ruby
 class Movie < ApplicationRecord
-  has_neighbors dimensions: 20
+  has_neighbors dimensions: 20, normalize: true
 end
 ```
 
@@ -122,19 +159,33 @@ recommender.fit(data)
 Use item factors for the neighbor vector
 
 ```ruby
+movies = []
 recommender.item_ids.each do |item_id|
-  Movie.create!(name: item_id, neighbor_vector: recommender.item_factors(item_id))
+  movies << {name: item_id, neighbor_vector: recommender.item_factors(item_id)}
 end
+Movie.insert_all!(movies) # use create! for Active Record < 6
 ```
 
 And get similar movies
 
 ```ruby
 movie = Movie.find_by(name: "Star Wars (1977)")
-movie.nearest_neighbors.first(5).map(&:name)
+movie.nearest_neighbors(distance: "cosine").first(5).map(&:name)
 ```
 
-[Complete code](examples/disco_item_recs.rb)
+See the complete code for [cube](examples/disco_item_recs_cube.rb) and [vector](examples/disco_item_recs_vector.rb)
+
+## Upgrading
+
+### 0.2.0
+
+The `distance` option has been moved from `has_neighbors` to `nearest_neighbors`, and there is no longer a default. If you use cosine distance, set:
+
+```ruby
+class Item < ApplicationRecord
+  has_neighbors normalize: true
+end
+```
 
 ## History
 
@@ -155,5 +206,11 @@ To get started with development:
 git clone https://github.com/ankane/neighbor.git
 cd neighbor
 bundle install
+createdb neighbor_test
+
+# cube
 bundle exec rake test
+
+# vector
+EXT=vector bundle exec rake test
 ```

data/lib/generators/neighbor/{install_generator.rb → cube_generator.rb}

@@ -2,12 +2,12 @@ require "rails/generators/active_record"
 
 module Neighbor
   module Generators
-    class InstallGenerator < Rails::Generators::Base
+    class CubeGenerator < Rails::Generators::Base
       include ActiveRecord::Generators::Migration
       source_root File.join(__dir__, "templates")
 
       def copy_migration
-        migration_template "migration.rb", "db/migrate/install_neighbor.rb", migration_version: migration_version
+        migration_template "cube.rb", "db/migrate/install_neighbor_cube.rb", migration_version: migration_version
       end
 
       def migration_version

data/lib/generators/neighbor/templates/vector.rb.tt

@@ -0,0 +1,5 @@
+class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    enable_extension "vector"
+  end
+end

data/lib/generators/neighbor/vector_generator.rb

@@ -0,0 +1,18 @@
+require "rails/generators/active_record"
+
+module Neighbor
+  module Generators
+    class VectorGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+      source_root File.join(__dir__, "templates")
+
+      def copy_migration
+        migration_template "vector.rb", "db/migrate/install_neighbor_vector.rb", migration_version: migration_version
+      end
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/neighbor/model.rb

@@ -1,42 +1,105 @@
 module Neighbor
   module Model
-    def has_neighbors(dimensions:, distance: "cosine")
-      distance = distance.to_s
-      raise ArgumentError, "Invalid distance: #{distance}" unless %w(cosine euclidean taxicab chebyshev).include?(distance)
-
-      # TODO make configurable
-      # likely use argument
-      attribute_name = :neighbor_vector
+    def has_neighbors(attribute_name = :neighbor_vector, dimensions: nil, normalize: nil)
+      attribute_name = attribute_name.to_sym
 
       class_eval do
-        attribute attribute_name, Neighbor::Vector.new(dimensions: dimensions, distance: distance)
+        @neighbor_attributes ||= {}
+
+        if @neighbor_attributes.empty?
+          def self.neighbor_attributes
+            parent_attributes =
+              if superclass.respond_to?(:neighbor_attributes)
+                superclass.neighbor_attributes
+              else
+                {}
+              end
+
+            parent_attributes.merge(@neighbor_attributes || {})
+          end
+        end
+
+        raise Error, "has_neighbors already called for #{attribute_name.inspect}" if neighbor_attributes[attribute_name]
+        @neighbor_attributes[attribute_name] = {dimensions: dimensions, normalize: normalize}
+
+        attribute attribute_name, Neighbor::Vector.new(dimensions: dimensions, normalize: normalize, model: self, attribute_name: attribute_name)
+
+        return if @neighbor_attributes.size != 1
+
+        scope :nearest_neighbors, ->(attribute_name, vector = nil, distance:) {
+          if vector.nil? && !attribute_name.nil? && attribute_name.respond_to?(:to_a)
+            vector = attribute_name
+            attribute_name = :neighbor_vector
+          end
+          attribute_name = attribute_name.to_sym
+
+          options = neighbor_attributes[attribute_name]
+          raise ArgumentError, "Invalid attribute" unless options
+          normalize = options[:normalize]
+          dimensions = options[:dimensions]
 
-        scope :nearest_neighbors, ->(vector) {
           return none if vector.nil?
 
+          distance = distance.to_s
+
           quoted_attribute = "#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(attribute_name)}"
 
+          column_info = klass.type_for_attribute(attribute_name).column_info
+
           operator =
-            case distance
-            when "taxicab"
-              "<#>"
-            when "chebyshev"
-              "<=>"
+            if column_info[:type] == :vector
+              case distance
+              when "inner_product"
+                "<#>"
+              when "cosine"
+                "<=>"
+              when "euclidean"
+                "<->"
+              end
             else
-              "<->"
+              case distance
+              when "taxicab"
+                "<#>"
+              when "chebyshev"
+                "<=>"
+              when "euclidean", "cosine"
+                "<->"
+              end
             end
 
+          raise ArgumentError, "Invalid distance: #{distance}" unless operator
+
+          # ensure normalize set (can be true or false)
+          if distance == "cosine" && column_info[:type] == :cube && normalize.nil?
+            raise Neighbor::Error, "Set normalize for cosine distance with cube"
+          end
+
+          vector = Neighbor::Vector.cast(vector, dimensions: dimensions, normalize: normalize, column_info: column_info)
+
           # important! neighbor_vector should already be typecast
           # but use to_f as extra safeguard against SQL injection
-          vector = Neighbor::Vector.cast(vector, dimensions: dimensions, distance: distance)
-          order = "#{quoted_attribute} #{operator} cube(array[#{vector.map(&:to_f).join(", ")}])"
+          query =
+            if column_info[:type] == :vector
+              connection.quote("[#{vector.map(&:to_f).join(", ")}]")
+            else
+              "cube(array[#{vector.map(&:to_f).join(", ")}])"
+            end
+
+          order = "#{quoted_attribute} #{operator} #{query}"
 
           # https://stats.stackexchange.com/questions/146221/is-cosine-similarity-identical-to-l2-normalized-euclidean-distance
           # with normalized vectors:
           # cosine similarity = 1 - (euclidean distance)**2 / 2
           # cosine distance = 1 - cosine similarity
           # this transformation doesn't change the order, so only needed for select
-          neighbor_distance = distance == "cosine" ? "POWER(#{order}, 2) / 2.0" : order
+          neighbor_distance =
+            if column_info[:type] != :vector && distance == "cosine"
+              "POWER(#{order}, 2) / 2.0"
+            elsif column_info[:type] == :vector && distance == "inner_product"
+              "(#{order}) * -1"
+            else
+              order
+            end
 
           # for select, use column_names instead of * to account for ignored columns
           select(*column_names, "#{neighbor_distance} AS neighbor_distance")
@@ -44,10 +107,14 @@ module Neighbor
             .order(Arel.sql(order))
         }
 
-        define_method :nearest_neighbors do
+        def nearest_neighbors(attribute_name = :neighbor_vector, **options)
+          attribute_name = attribute_name.to_sym
+          # important! check if neighbor attribute before calling send
+          raise ArgumentError, "Invalid attribute" unless self.class.neighbor_attributes[attribute_name]
+
           self.class
             .where.not(self.class.primary_key => send(self.class.primary_key))
-            .nearest_neighbors(send(attribute_name))
+            .nearest_neighbors(attribute_name, send(attribute_name), **options)
         end
       end
     end

data/lib/neighbor/vector.rb

@@ -1,29 +1,61 @@
 module Neighbor
   class Vector < ActiveRecord::Type::Value
-    def initialize(dimensions:, distance:)
+    def initialize(dimensions:, normalize:, model:, attribute_name:)
       super()
       @dimensions = dimensions
-      @distance = distance
+      @normalize = normalize
+      @model = model
+      @attribute_name = attribute_name
     end
 
-    def self.cast(value, dimensions:, distance:)
+    def self.cast(value, dimensions:, normalize:, column_info:)
       value = value.to_a.map(&:to_f)
-      raise Error, "Expected #{dimensions} dimensions, not #{value.size}" unless value.size == dimensions
 
-      if distance == "cosine"
+      dimensions ||= column_info[:dimensions]
+      raise Error, "Expected #{dimensions} dimensions, not #{value.size}" if dimensions && value.size != dimensions
+
+      raise Error, "Values must be finite" unless value.all?(&:finite?)
+
+      if normalize
         norm = Math.sqrt(value.sum { |v| v * v })
-        value.map { |v| v / norm }
-      else
-        value
+
+        # store zero vector as all zeros
+        # since NaN makes the distance always 0
+        # could also throw error
+
+        # safe to update in-place since earlier map dups
+        value.map! { |v| v / norm } if norm > 0
       end
+
+      value
+    end
+
+    def self.column_info(model, attribute_name)
+      attribute_name = attribute_name.to_s
+      column = model.columns.detect { |c| c.name == attribute_name }
+      {
+        type: column.try(:type),
+        dimensions: column.try(:limit)
+      }
+    end
+
+    # need to be careful to avoid loading column info before needed
+    def column_info
+      @column_info ||= self.class.column_info(@model, @attribute_name)
     end
 
     def cast(value)
-      self.class.cast(value, dimensions: @dimensions, distance: @distance) unless value.nil?
+      self.class.cast(value, dimensions: @dimensions, normalize: @normalize, column_info: column_info) unless value.nil?
     end
 
     def serialize(value)
-      "(#{cast(value).join(", ")})" unless value.nil?
+      unless value.nil?
+        if column_info[:type] == :vector
+          "[#{cast(value).join(", ")}]"
+        else
+          "(#{cast(value).join(", ")})"
+        end
+      end
     end
 
     def deserialize(value)

data/lib/neighbor/version.rb

@@ -1,3 +1,3 @@
 module Neighbor
-  VERSION = "0.1.2"
+  VERSION = "0.2.2"
 end

data/lib/neighbor.rb

@@ -7,10 +7,14 @@ require "neighbor/version"
 module Neighbor
   class Error < StandardError; end
 
-  module RegisterCubeType
+  module RegisterTypes
     def initialize_type_map(m = type_map)
       super
       m.register_type "cube", ActiveRecord::ConnectionAdapters::PostgreSQL::OID::SpecializedString.new(:cube)
+      m.register_type "vector" do |_, _, sql_type|
+        limit = extract_limit(sql_type)
+        ActiveRecord::ConnectionAdapters::PostgreSQL::OID::SpecializedString.new(:vector, limit: limit)
+      end
     end
   end
 end
@@ -25,16 +29,24 @@ ActiveSupport.on_load(:active_record) do
 
   # ensure schema can be dumped
   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:cube] = {name: "cube"}
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:vector] = {name: "vector"}
 
   # ensure schema can be loaded
   if ActiveRecord::VERSION::MAJOR >= 6
-    ActiveRecord::ConnectionAdapters::TableDefinition.send(:define_column_methods, :cube)
+    ActiveRecord::ConnectionAdapters::TableDefinition.send(:define_column_methods, :cube, :vector)
   else
     ActiveRecord::ConnectionAdapters::TableDefinition.define_method :cube do |*args, **options|
       args.each { |name| column(name, :cube, options) }
     end
+    ActiveRecord::ConnectionAdapters::TableDefinition.define_method :vector do |*args, **options|
+      args.each { |name| column(name, :vector, options) }
+    end
   end
 
   # prevent unknown OID warning
-  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(Neighbor::RegisterCubeType)
+  if ActiveRecord::VERSION::MAJOR >= 7
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.singleton_class.prepend(Neighbor::RegisterTypes)
+  else
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(Neighbor::RegisterTypes)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neighbor
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.2
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-22 00:00:00.000000000 Z
+date: 2022-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.2'
 description:
 email: andrew@ankane.org
 executables: []
@@ -33,8 +33,10 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
-- lib/generators/neighbor/install_generator.rb
-- lib/generators/neighbor/templates/migration.rb.tt
+- lib/generators/neighbor/cube_generator.rb
+- lib/generators/neighbor/templates/cube.rb.tt
+- lib/generators/neighbor/templates/vector.rb.tt
+- lib/generators/neighbor/vector_generator.rb
 - lib/neighbor.rb
 - lib/neighbor/model.rb
 - lib/neighbor/vector.rb
@@ -58,7 +60,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Nearest neighbor search for Rails and Postgres