irt_ruby 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3864e3faec7cbf0a1d96649b1493a843df0fcb029a2106b99e682f1770b9f499
-  data.tar.gz: e6901babf0c08c5de4e8d644ee4c5e8607f1213a965864874455af2e1ea5ead5
+  metadata.gz: eb346c93f7beebb572f5c80663276c1f0285f55fe3382b0c6dc43ee17e3c2d04
+  data.tar.gz: 9fcc3c15cd54e969ffc531fd004d5911eed71234c1218a643ac137aca3ae85ea
 SHA512:
-  metadata.gz: 519eb1b5d1e5c74234482b83d72faacb85445b5259860278512a49f3212ce62840a8db8c801d6873be377b7b6cf808693af4456185bf2a64a679b20b6f21a33b
-  data.tar.gz: c6f4d4e13582c15045bc040815f88c5d07562ecbb1554daccd6ea6383462ff7c56f3c0adeecc8c4eb29f800faf865a896f0edba4a80979f35c5d46fd897ba72d
+  metadata.gz: 1c78192318e3fb78c9ee9c33919fb5dced7d09e4c38af7f56b9f508c1d5e26fc4aab9665e4acdd12ce711dedae12299ef054182ac9d2a25458a5561c9d31a501
+  data.tar.gz: 1577007bae07c567fc05b6d2ad6037b3264d0ec2a23086eabe317ec332d896416d94dd257eb18a4e63d9b7ba7a21356cf3a8579bd1a419d849946280934a8f58

data/lib/irt_ruby/rasch_model.rb

@@ -1,58 +1,148 @@
 # frozen_string_literal: true
 
-require "matrix"
-
 module IrtRuby
-  # A class representing the Rasch model for Item Response Theory.
+  # A class representing the Rasch model for Item Response Theory (ability - difficulty).
+  # Incorporates:
+  # - Adaptive learning rate
+  # - Missing data handling (skip nil)
+  # - Multiple convergence checks (log-likelihood + parameter updates)
   class RaschModel
-    def initialize(data, max_iter: 1000, tolerance: 1e-6, learning_rate: 0.01)
+    MISSING_STRATEGIES = %i[ignore treat_as_incorrect treat_as_correct].freeze
+
+    def initialize(data,
+                   max_iter: 1000,
+                   tolerance: 1e-6,
+                   param_tolerance: 1e-6,
+                   learning_rate: 0.01,
+                   decay_factor: 0.5,
+                   missing_strategy: :ignore)
+      # data: A Matrix or array-of-arrays of responses (0/1 or nil for missing).
+      # missing_strategy: :ignore (skip), :treat_as_incorrect, :treat_as_correct
+
       @data = data
-      @abilities = Array.new(data.row_count) { rand }
-      @difficulties = Array.new(data.column_count) { rand }
-      @max_iter = max_iter
-      @tolerance = tolerance
-      @learning_rate = learning_rate
+      @data_array = data.to_a
+      num_rows = @data_array.size
+      num_cols = @data_array.first.size
+
+      raise ArgumentError, "missing_strategy must be one of #{MISSING_STRATEGIES}" unless MISSING_STRATEGIES.include?(missing_strategy)
+
+      @missing_strategy = missing_strategy
+
+      # Initialize parameters near zero
+      @abilities    = Array.new(num_rows)  { rand(-0.25..0.25) }
+      @difficulties = Array.new(num_cols)  { rand(-0.25..0.25) }
+
+      @max_iter        = max_iter
+      @tolerance       = tolerance
+      @param_tolerance = param_tolerance
+      @learning_rate   = learning_rate
+      @decay_factor    = decay_factor
     end
 
-    # Sigmoid function to calculate probability
     def sigmoid(x)
       1.0 / (1.0 + Math.exp(-x))
     end
 
-    # Calculate the log-likelihood of the data given the current parameters
-    def likelihood
-      likelihood = 0
-      @data.row_vectors.each_with_index do |row, i|
-        row.to_a.each_with_index do |response, j|
+    def resolve_missing(resp)
+      return [resp, false] unless resp.nil?
+
+      case @missing_strategy
+      when :ignore
+        [nil, true]
+      when :treat_as_incorrect
+        [0, false]
+      when :treat_as_correct
+        [1, false]
+      end
+    end
+
+    def log_likelihood
+      total_ll = 0.0
+      @data_array.each_with_index do |row, i|
+        row.each_with_index do |resp, j|
+          value, skip = resolve_missing(resp)
+          next if skip
+
           prob = sigmoid(@abilities[i] - @difficulties[j])
-          likelihood += response == 1 ? Math.log(prob) : Math.log(1 - prob)
+          total_ll += if value == 1
+                        Math.log(prob + 1e-15)
+                      else
+                        Math.log((1 - prob) + 1e-15)
+                      end
         end
       end
-      likelihood
+      total_ll
     end
 
-    # Update parameters using gradient ascent
-    def update_parameters
-      last_likelihood = likelihood
-      @max_iter.times do |_iter|
-        @data.row_vectors.each_with_index do |row, i|
-          row.to_a.each_with_index do |response, j|
-            prob = sigmoid(@abilities[i] - @difficulties[j])
-            error = response - prob
-            @abilities[i] += @learning_rate * error
-            @difficulties[j] -= @learning_rate * error
-          end
+    def compute_gradient
+      grad_abilities    = Array.new(@abilities.size, 0.0)
+      grad_difficulties = Array.new(@difficulties.size, 0.0)
+
+      @data_array.each_with_index do |row, i|
+        row.each_with_index do |resp, j|
+          value, skip = resolve_missing(resp)
+          next if skip
+
+          prob = sigmoid(@abilities[i] - @difficulties[j])
+          error = value - prob
+
+          grad_abilities[i]    += error
+          grad_difficulties[j] -= error
         end
-        current_likelihood = likelihood
-        break if (last_likelihood - current_likelihood).abs < @tolerance
+      end
 
-        last_likelihood = current_likelihood
+      [grad_abilities, grad_difficulties]
+    end
+
+    def apply_gradient_update(grad_abilities, grad_difficulties)
+      old_abilities    = @abilities.dup
+      old_difficulties = @difficulties.dup
+
+      @abilities.each_index do |i|
+        @abilities[i] += @learning_rate * grad_abilities[i]
+      end
+
+      @difficulties.each_index do |j|
+        @difficulties[j] += @learning_rate * grad_difficulties[j]
+      end
+
+      [old_abilities, old_difficulties]
+    end
+
+    def average_param_update(old_abilities, old_difficulties)
+      deltas = []
+      @abilities.each_with_index do |a, i|
+        deltas << (a - old_abilities[i]).abs
+      end
+      @difficulties.each_with_index do |d, j|
+        deltas << (d - old_difficulties[j]).abs
       end
+      deltas.sum / deltas.size
     end
 
-    # Fit the model to the data
     def fit
-      update_parameters
+      prev_ll = log_likelihood
+
+      @max_iter.times do
+        grad_abilities, grad_difficulties = compute_gradient
+
+        old_a, old_d = apply_gradient_update(grad_abilities, grad_difficulties)
+
+        current_ll  = log_likelihood
+        param_delta = average_param_update(old_a, old_d)
+
+        if current_ll < prev_ll
+          @abilities    = old_a
+          @difficulties = old_d
+          @learning_rate *= @decay_factor
+        else
+          ll_diff = (current_ll - prev_ll).abs
+          break if ll_diff < @tolerance && param_delta < @param_tolerance
+
+          prev_ll = current_ll
+        end
+      end
+
       { abilities: @abilities, difficulties: @difficulties }
     end
   end

data/lib/irt_ruby/three_parameter_model.rb

@@ -1,68 +1,181 @@
 # frozen_string_literal: true
 
-require "matrix"
-
 module IrtRuby
-  # A class representing the Three-Parameter model for Item Response Theory.
+  # A class representing the Three-Parameter model (3PL) for Item Response Theory.
+  # Incorporates:
+  # - Adaptive learning rate
+  # - Missing data handling
+  # - Parameter clamping for discrimination, guessing
+  # - Multiple convergence checks
+  # - Separate gradient calculation & updates
   class ThreeParameterModel
-    def initialize(data, max_iter: 1000, tolerance: 1e-6, learning_rate: 0.01)
+    MISSING_STRATEGIES = %i[ignore treat_as_incorrect treat_as_correct].freeze
+
+    def initialize(data,
+                   max_iter: 1000,
+                   tolerance: 1e-6,
+                   param_tolerance: 1e-6,
+                   learning_rate: 0.01,
+                   decay_factor: 0.5,
+                   missing_strategy: :ignore)
       @data = data
-      @abilities = Array.new(data.row_count) { rand }
-      @difficulties = Array.new(data.column_count) { rand }
-      @discriminations = Array.new(data.column_count) { rand }
-      @guessings = Array.new(data.column_count) { rand * 0.3 }
-      @max_iter = max_iter
-      @tolerance = tolerance
-      @learning_rate = learning_rate
+      @data_array = data.to_a
+      num_rows = @data_array.size
+      num_cols = @data_array.first.size
+
+      raise ArgumentError, "missing_strategy must be one of #{MISSING_STRATEGIES}" unless MISSING_STRATEGIES.include?(missing_strategy)
+
+      @missing_strategy = missing_strategy
+
+      # Initialize parameters
+      @abilities       = Array.new(num_rows)  { rand(-0.25..0.25) }
+      @difficulties    = Array.new(num_cols)  { rand(-0.25..0.25) }
+      @discriminations = Array.new(num_cols)  { rand(0.5..1.5) }
+      @guessings       = Array.new(num_cols)  { rand(0.0..0.3) }
+
+      @max_iter        = max_iter
+      @tolerance       = tolerance
+      @param_tolerance = param_tolerance
+      @learning_rate   = learning_rate
+      @decay_factor    = decay_factor
     end
 
-    # Sigmoid function to calculate probability
     def sigmoid(x)
       1.0 / (1.0 + Math.exp(-x))
     end
 
-    # Probability function for the 3PL model
+    # Probability for the 3PL model: c + (1-c)*sigmoid(a*(θ - b))
     def probability(theta, a, b, c)
-      c + (1 - c) * sigmoid(a * (theta - b))
+      c + (1.0 - c) * sigmoid(a * (theta - b))
+    end
+
+    def resolve_missing(resp)
+      return [resp, false] unless resp.nil?
+
+      case @missing_strategy
+      when :ignore
+        [nil, true]
+      when :treat_as_incorrect
+        [0, false]
+      when :treat_as_correct
+        [1, false]
+      end
     end
 
-    # Calculate the log-likelihood of the data given the current parameters
-    def likelihood
-      likelihood = 0
-      @data.row_vectors.each_with_index do |row, i|
-        row.to_a.each_with_index do |response, j|
-          prob = probability(@abilities[i], @discriminations[j], @difficulties[j], @guessings[j])
-          likelihood += response == 1 ? Math.log(prob) : Math.log(1 - prob)
+    def log_likelihood
+      ll = 0.0
+      @data_array.each_with_index do |row, i|
+        row.each_with_index do |resp, j|
+          value, skip = resolve_missing(resp)
+          next if skip
+
+          prob = probability(@abilities[i],
+                             @discriminations[j],
+                             @difficulties[j],
+                             @guessings[j])
+
+          ll += if value == 1
+                  Math.log(prob + 1e-15)
+                else
+                  Math.log((1 - prob) + 1e-15)
+                end
         end
       end
-      likelihood
+      ll
     end
 
-    # Update parameters using gradient ascent
-    def update_parameters
-      last_likelihood = likelihood
-      @max_iter.times do |_iter|
-        @data.row_vectors.each_with_index do |row, i|
-          row.to_a.each_with_index do |response, j|
-            prob = probability(@abilities[i], @discriminations[j], @difficulties[j], @guessings[j])
-            error = response - prob
-            @abilities[i] += @learning_rate * error * @discriminations[j]
-            @difficulties[j] -= @learning_rate * error * @discriminations[j]
-            @discriminations[j] += @learning_rate * error * (@abilities[i] - @difficulties[j])
-            @guessings[j] += @learning_rate * error * (1 - prob)
-            @guessings[j] = [[@guessings[j], 0].max, 1].min # Keep guessings within [0, 1]
-          end
+    def compute_gradient
+      grad_abilities       = Array.new(@abilities.size, 0.0)
+      grad_difficulties    = Array.new(@difficulties.size, 0.0)
+      grad_discriminations = Array.new(@discriminations.size, 0.0)
+      grad_guessings       = Array.new(@guessings.size, 0.0)
+
+      @data_array.each_with_index do |row, i|
+        row.each_with_index do |resp, j|
+          value, skip = resolve_missing(resp)
+          next if skip
+
+          theta = @abilities[i]
+          a     = @discriminations[j]
+          b     = @difficulties[j]
+          c     = @guessings[j]
+
+          prob  = probability(theta, a, b, c)
+          error = value - prob
+
+          grad_abilities[i]       += error * a * (1 - c)
+          grad_difficulties[j]    -= error * a * (1 - c)
+          grad_discriminations[j] += error * (theta - b) * (1 - c)
+
+          grad_guessings[j]       += error * 1.0
         end
-        current_likelihood = likelihood
-        break if (last_likelihood - current_likelihood).abs < @tolerance
+      end
 
-        last_likelihood = current_likelihood
+      [grad_abilities, grad_difficulties, grad_discriminations, grad_guessings]
+    end
+
+    def apply_gradient_update(ga, gd, gdisc, gc)
+      old_a    = @abilities.dup
+      old_d    = @difficulties.dup
+      old_disc = @discriminations.dup
+      old_c    = @guessings.dup
+
+      @abilities.each_index do |i|
+        @abilities[i] += @learning_rate * ga[i]
       end
+
+      @difficulties.each_index do |j|
+        @difficulties[j] += @learning_rate * gd[j]
+      end
+
+      @discriminations.each_index do |j|
+        @discriminations[j] += @learning_rate * gdisc[j]
+        @discriminations[j] = 0.01 if @discriminations[j] < 0.01
+        @discriminations[j] = 5.0  if @discriminations[j] > 5.0
+      end
+
+      @guessings.each_index do |j|
+        @guessings[j] += @learning_rate * gc[j]
+        @guessings[j] = 0.0  if @guessings[j] < 0.0
+        @guessings[j] = 0.35 if @guessings[j] > 0.35
+      end
+
+      [old_a, old_d, old_disc, old_c]
+    end
+
+    def average_param_update(old_a, old_d, old_disc, old_c)
+      deltas = []
+      @abilities.each_with_index       { |x, i| deltas << (x - old_a[i]).abs }
+      @difficulties.each_with_index    { |x, j| deltas << (x - old_d[j]).abs }
+      @discriminations.each_with_index { |x, j| deltas << (x - old_disc[j]).abs }
+      @guessings.each_with_index       { |x, j| deltas << (x - old_c[j]).abs }
+      deltas.sum / deltas.size
     end
 
-    # Fit the model to the data
     def fit
-      update_parameters
+      prev_ll = log_likelihood
+
+      @max_iter.times do
+        ga, gd, gdisc, gc = compute_gradient
+        old_a, old_d, old_disc, old_c = apply_gradient_update(ga, gd, gdisc, gc)
+
+        curr_ll     = log_likelihood
+        param_delta = average_param_update(old_a, old_d, old_disc, old_c)
+
+        if curr_ll < prev_ll
+          @abilities       = old_a
+          @difficulties    = old_d
+          @discriminations = old_disc
+          @guessings       = old_c
+          @learning_rate  *= @decay_factor
+        else
+          ll_diff = (curr_ll - prev_ll).abs
+          break if ll_diff < @tolerance && param_delta < @param_tolerance
+
+          prev_ll = curr_ll
+        end
+      end
+
       {
         abilities: @abilities,
         difficulties: @difficulties,

data/lib/irt_ruby/two_parameter_model.rb

@@ -1,65 +1,156 @@
 # frozen_string_literal: true
 
-require "matrix"
-
 module IrtRuby
-  # A class representing the Two-Parameter model for Item Response Theory.
+  # A class representing the Two-Parameter model (2PL) for IRT.
+  # Incorporates:
+  # - Adaptive learning rate
+  # - Missing data handling
+  # - Parameter clamping for discrimination
+  # - Multiple convergence checks
+  # - Separate gradient calculation & parameter update
   class TwoParameterModel
-    def initialize(data, max_iter: 1000, tolerance: 1e-6, learning_rate: 0.01)
+    MISSING_STRATEGIES = %i[ignore treat_as_incorrect treat_as_correct].freeze
+
+    def initialize(data, max_iter: 1000, tolerance: 1e-6, param_tolerance: 1e-6,
+                   learning_rate: 0.01, decay_factor: 0.5,
+                   missing_strategy: :ignore)
       @data = data
-      @abilities = Array.new(data.row_count) { rand }
-      @difficulties = Array.new(data.column_count) { rand }
-      @discriminations = Array.new(data.column_count) { rand }
-      @max_iter = max_iter
-      @tolerance = tolerance
-      @learning_rate = learning_rate
+      @data_array = data.to_a
+      num_rows = @data_array.size
+      num_cols = @data_array.first.size
+
+      raise ArgumentError, "missing_strategy must be one of #{MISSING_STRATEGIES}" unless MISSING_STRATEGIES.include?(missing_strategy)
+
+      @missing_strategy = missing_strategy
+
+      # Initialize parameters
+      # Typically: ability ~ 0, difficulty ~ 0, discrimination ~ 1
+      @abilities       = Array.new(num_rows)  { rand(-0.25..0.25) }
+      @difficulties    = Array.new(num_cols)  { rand(-0.25..0.25) }
+      @discriminations = Array.new(num_cols)  { rand(0.5..1.5) }
+
+      @max_iter         = max_iter
+      @tolerance        = tolerance
+      @param_tolerance  = param_tolerance
+      @learning_rate    = learning_rate
+      @decay_factor     = decay_factor
     end
 
-    # Sigmoid function
     def sigmoid(x)
       1.0 / (1.0 + Math.exp(-x))
     end
 
-    # Calculate the log-likelihood of the data given the current parameters
-    def likelihood
-      likelihood = 0
-      @data.row_vectors.each_with_index do |row, i|
-        row.to_a.each_with_index do |response, j|
+    def resolve_missing(resp)
+      return [resp, false] unless resp.nil?
+
+      case @missing_strategy
+      when :ignore
+        [nil, true]
+      when :treat_as_incorrect
+        [0, false]
+      when :treat_as_correct
+        [1, false]
+      end
+    end
+
+    def log_likelihood
+      ll = 0.0
+      @data_array.each_with_index do |row, i|
+        row.each_with_index do |resp, j|
+          value, skip = resolve_missing(resp)
+          next if skip
+
           prob = sigmoid(@discriminations[j] * (@abilities[i] - @difficulties[j]))
-          if response == 1
-            likelihood += Math.log(prob)
-          elsif response.zero?
-            likelihood += Math.log(1 - prob)
-          end
+          ll += if value == 1
+                  Math.log(prob + 1e-15)
+                else
+                  Math.log((1 - prob) + 1e-15)
+                end
         end
       end
-      likelihood
+      ll
     end
 
-    # Update parameters using gradient ascent
-    def update_parameters
-      last_likelihood = likelihood
-      @max_iter.times do |_iter|
-        @data.row_vectors.each_with_index do |row, i|
-          row.to_a.each_with_index do |response, j|
-            prob = sigmoid(@discriminations[j] * (@abilities[i] - @difficulties[j]))
-            error = response - prob
-            @abilities[i] += @learning_rate * error * @discriminations[j]
-            @difficulties[j] -= @learning_rate * error * @discriminations[j]
-            @discriminations[j] += @learning_rate * error * (@abilities[i] - @difficulties[j])
-          end
+    def compute_gradient
+      grad_abilities       = Array.new(@abilities.size, 0.0)
+      grad_difficulties    = Array.new(@difficulties.size, 0.0)
+      grad_discriminations = Array.new(@discriminations.size, 0.0)
+
+      @data_array.each_with_index do |row, i|
+        row.each_with_index do |resp, j|
+          value, skip = resolve_missing(resp)
+          next if skip
+
+          prob  = sigmoid(@discriminations[j] * (@abilities[i] - @difficulties[j]))
+          error = value - prob
+
+          grad_abilities[i]       += error * @discriminations[j]
+          grad_difficulties[j]    -= error * @discriminations[j]
+          grad_discriminations[j] += error * (@abilities[i] - @difficulties[j])
         end
-        current_likelihood = likelihood
-        break if (last_likelihood - current_likelihood).abs < @tolerance
+      end
+
+      [grad_abilities, grad_difficulties, grad_discriminations]
+    end
+
+    def apply_gradient_update(ga, gd, gdisc)
+      old_a    = @abilities.dup
+      old_d    = @difficulties.dup
+      old_disc = @discriminations.dup
+
+      @abilities.each_index do |i|
+        @abilities[i] += @learning_rate * ga[i]
+      end
 
-        last_likelihood = current_likelihood
+      @difficulties.each_index do |j|
+        @difficulties[j] += @learning_rate * gd[j]
       end
+
+      @discriminations.each_index do |j|
+        @discriminations[j] += @learning_rate * gdisc[j]
+        @discriminations[j] = 0.01 if @discriminations[j] < 0.01
+        @discriminations[j] = 5.0  if @discriminations[j] > 5.0
+      end
+
+      [old_a, old_d, old_disc]
+    end
+
+    def average_param_update(old_a, old_d, old_disc)
+      deltas = []
+      @abilities.each_with_index    { |x, i| deltas << (x - old_a[i]).abs }
+      @difficulties.each_with_index { |x, j| deltas << (x - old_d[j]).abs }
+      @discriminations.each_with_index { |x, j| deltas << (x - old_disc[j]).abs }
+      deltas.sum / deltas.size
     end
 
-    # Fit the model to the data
     def fit
-      update_parameters
-      { abilities: @abilities, difficulties: @difficulties, discriminations: @discriminations }
+      prev_ll = log_likelihood
+
+      @max_iter.times do
+        ga, gd, gdisc = compute_gradient
+        old_a, old_d, old_disc = apply_gradient_update(ga, gd, gdisc)
+
+        curr_ll     = log_likelihood
+        param_delta = average_param_update(old_a, old_d, old_disc)
+
+        if curr_ll < prev_ll
+          @abilities       = old_a
+          @difficulties    = old_d
+          @discriminations = old_disc
+          @learning_rate  *= @decay_factor
+        else
+          ll_diff = (curr_ll - prev_ll).abs
+          break if ll_diff < @tolerance && param_delta < @param_tolerance
+
+          prev_ll = curr_ll
+        end
+      end
+
+      {
+        abilities: @abilities,
+        difficulties: @difficulties,
+        discriminations: @discriminations
+      }
     end
   end
 end

data/lib/irt_ruby/version.rb

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

data/lib/irt_ruby.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "irt_ruby/version"
+require "matrix"
 require "irt_ruby/rasch_model"
 require "irt_ruby/two_parameter_model"
 require "irt_ruby/three_parameter_model"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: irt_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Alex Kholodniak
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-09 00:00:00.000000000 Z
+date: 2025-03-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: matrix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,10 +66,12 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: IrtRuby is a Ruby gem that provides implementations of the Rasch model,
-  Two-Parameter model, and Three-Parameter model for Item Response Theory (IRT). It
-  allows you to estimate the abilities of individuals and the difficulties, discriminations,
-  and guessing parameters of items based on their responses to a set of items.
+description: "IrtRuby provides implementations of the Rasch model, Two-Parameter model,
+  \nand Three-Parameter model for Item Response Theory (IRT). \nIt allows you to estimate
+  the abilities of individuals and the difficulties, \ndiscriminations, and guessing
+  parameters of items based on their responses \nto a set of items. This version adds
+  support for multiple missing data \nstrategies (:ignore, :treat_as_incorrect, :treat_as_correct),
+  expanded \ntest coverage, and improved adaptive optimization.\n"
 email:
 - alexandrkholodniak@gmail.com
 executables: []
@@ -73,7 +89,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/SyntaxSpirits/irt_ruby
   source_code_uri: https://github.com/SyntaxSpirits/irt_ruby
-  changelog_uri: https://github.com/SyntaxSpirits/irt_ruby/CHANGELOG.md
+  changelog_uri: https://github.com/SyntaxSpirits/irt_ruby/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -89,9 +105,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.16
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
-summary: A Ruby gem that provides implementations of Rasch, Two-Parameter, and Three-Parameter
-  models for Item Response Theory (IRT).
+summary: A Ruby gem that provides Rasch, 2PL, and 3PL models for Item Response Theory
+  (IRT), with flexible missing data strategies.
 test_files: []