magnifier-ruby 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10ef01bc786e90cbc1f33214573a27b28ef4f00e
-  data.tar.gz: 3144c715c7f118d5b7462be5741f6bad4a948948
+  metadata.gz: 91fa371b828c434f81d74f542a76e905f15382c6
+  data.tar.gz: e02c99be650c6d4e133caa5080ad79859d153737
 SHA512:
-  metadata.gz: fa8f6619518a249fbd8d15f5aa504fd2a0726d451b58385dbe4741a4cfa8893d76e7a71219d4a5e3f870e5ecac48a6f3edc728eeb6ea27cb893ba6ca1627b7fd
-  data.tar.gz: e34d47c3359525e70066818f640df6e53017c36921219a753b71a2c6248b1f99c2b6f35fb534d20986aecf47abcbcdf4c8a1380a96eae4a526679fbc5be32cf5
+  metadata.gz: b06e954d69d67474975819b3fca01a8d0eb1eb14c658a4f7c7a3955f75b01a97f42992ea36c1a2cb58ed5c3f01a36212328b9ea85955492fe308f365f4ce5611
+  data.tar.gz: 27dc5211d0fc5ad0bc057dc139d454cc724a501760d25c28bf58889a37e5c88bc8221ea801d9c0d386e17f1fb6ffa10a478c9953066f78b1f20c460d1c40c1a8

data/lib/magnifier.rb

@@ -1,78 +1,3 @@
-require 'numo/narray'
-
-class Magnifier
-  # make configurable
-  # or check for convergence
-  LEARNING_STEPS = 1000
-
-  attr_reader :training_set, :training_set_size, :features_count, :f1_score
-  attr_accessor :mu_vector, :sigma_squared_vector, :threshold
-
-  # examples is exepcted to be 2-D array of real values
-  def initialize(examples, threshold = 0.01)
-    @training_set = Numo::DFloat[*examples].freeze
-    @training_set_size, @features_count = training_set.shape
-    @threshold = threshold
-    @mu_vector = Numo::DFloat.zeros(@features_count)
-    @sigma_squared_vector = Numo::DFloat.zeros(@features_count)
-    @f1_score = 0
-  end
-
-  def train
-    @mu_vector = @training_set.mean(0)
-    @sigma_squared_vector = (((training_set - mu_vector) ** 2).sum(0) / training_set_size).to_a
-  end
-
-  # optimize using F1 score
-  # requires cross-validation set (should differ from train set!)
-  # todo: convert base truth to boolean
-  def optimize_threshold(examples, base_truths)
-    boolean_base_thruths = base_truths.map{ |value| value == 1 || value == true }
-    examples_prob = examples.map { |example| probability(example) }
-
-    threshold_step = (examples_prob.max - examples_prob.min) / LEARNING_STEPS
-    @threshold = 0
-
-    (examples_prob.min..examples_prob.max).step(threshold_step) do |new_threshold|
-      predictions = examples_prob.map { |probability| probability < new_threshold }
-      current_f1 = compute_f1_score(predictions, boolean_base_thruths)
-
-      if current_f1 > @f1_score
-        @f1_score = current_f1
-        @threshold = new_threshold
-      end
-    end
-
-    [threshold, f1_score]
-  end
-
-  def probability(example)
-    probability = 1
-    example.each_with_index do |feature, i|
-      feature_prob = Math.exp(-((feature - mu_vector[i])**2 / (2 * sigma_squared_vector[i]))) / ((2 * Math::PI * sigma_squared_vector[i])**(0.5))
-
-      probability = probability * feature_prob
-    end
-
-    probability
-  end
-
-  def anomaly?(example)
-    probability(example) < threshold
-  end
-
-  private
-
-    def compute_f1_score(predictions, base_truths)
-      true_positives  = predictions.map.with_index { |val, i| val && base_truths[i] }.count(true)
-      false_positives = predictions.map.with_index { |val, i| val && !base_truths[i] }.count(true)
-      false_negatives = predictions.map.with_index { |val, i| !val && base_truths[i] }.count(true)
-
-      return 0 if true_positives == 0
-
-      precision = true_positives.to_f / (true_positives + false_positives);
-      recall = true_positives.to_f / (true_positives + false_negatives);
-
-      (2 * precision * recall) / (precision + recall) rescue 0;
-    end
-end
+require_relative "magnifier/magnifier"
+require_relative "magnifier/exporter"
+require_relative "magnifier/importer"

data/lib/magnifier/exporter.rb

@@ -0,0 +1,37 @@
+require 'yaml'
+
+class Magnifier::Exporter
+
+  attr_reader :magnifier_object, :path_object
+
+  def self.export(path_object, magnifier_object)
+    new(path_object, magnifier_object).export
+  end
+
+  def initialize(path_object, magnifier_object)
+    @path_object = path_object
+    @magnifier_object = magnifier_object
+  end
+
+  def export
+    file = File.open(@path_object, 'w')
+    file.write(compose_yaml)
+    file.close
+
+    file
+  end
+
+  private
+
+    def compose_yaml
+      result = {}
+      @magnifier_object.instance_variables.each do |var_name|
+        value = @magnifier_object.instance_variable_get(var_name)
+        value = value.to_a if value.respond_to?(:to_a) # convert martixes to arrays
+
+        result[var_name.to_s.slice(1..-1)] = value
+      end
+
+      result.to_yaml
+    end
+end

data/lib/magnifier/importer.rb

@@ -0,0 +1,29 @@
+require 'yaml'
+
+class Magnifier::Importer
+
+  attr_reader :magnifier_object, :path_object
+
+  def self.import(path_object, magnifier_object = Magnifier.new([[0],[0]]))
+    new(path_object, magnifier_object).import
+  end
+
+  def initialize(path_object, magnifier_object)
+    @path_object = path_object
+    @magnifier_object = magnifier_object
+  end
+
+  def import
+    yaml_content = {}
+    File.open(@path_object, 'r') do |file|
+      yaml_content = YAML.load(file.read)
+    end
+
+    yaml_content.each_pair do |key, value|
+      value = Numo::DFloat[*value] if value.is_a?(Array)
+      @magnifier_object.instance_variable_set("@#{key}", value)
+    end
+
+    @magnifier_object
+  end
+end

data/lib/magnifier/magnifier.rb

@@ -0,0 +1,89 @@
+require 'numo/narray'
+
+class Magnifier
+  # make configurable
+  # or check for convergence
+  LEARNING_STEPS = 1000
+
+  attr_reader :training_set, :training_set_size,
+              :features_count, :f1_score,
+              :mu_vector, :sigma_squared_vector
+  attr_accessor :threshold
+
+  # examples is exepcted to be 2-D array of real values
+  def initialize(examples, threshold = 0.01)
+    @training_set = Numo::DFloat[*examples]
+    @training_set_size, @features_count = training_set.shape
+    @features_count ||= 1
+    @threshold = threshold
+    @mu_vector = Numo::DFloat.zeros(@features_count)
+    @sigma_squared_vector = Numo::DFloat.zeros(@features_count)
+    @f1_score = 0
+  end
+
+  def train
+    @mu_vector = @training_set.mean(0)
+    @sigma_squared_vector = (((training_set - mu_vector) ** 2).sum(0) / training_set_size).to_a
+  end
+
+  # optimize using F1 score
+  # requires cross-validation set (should differ from train set!)
+  # todo: convert base truth to boolean
+  def optimize_threshold(examples, base_truths)
+    boolean_base_thruths = base_truths.map{ |value| value == 1 || value == true }
+    examples_prob = examples.map { |example| probability(example) }
+
+    threshold_step = (examples_prob.max - examples_prob.min) / LEARNING_STEPS
+    @threshold = 0
+
+    (examples_prob.min..examples_prob.max).step(threshold_step) do |new_threshold|
+      predictions = examples_prob.map { |probability| probability < new_threshold }
+      current_f1 = compute_f1_score(predictions, boolean_base_thruths)
+
+      if current_f1 > @f1_score
+        @f1_score = current_f1
+        @threshold = new_threshold
+      end
+    end
+
+    [threshold, f1_score]
+  end
+
+  def probability(example)
+    probability = 1
+    example.each_with_index do |feature, i|
+      feature_prob = Math.exp(-((feature - mu_vector[i])**2 / (2 * sigma_squared_vector[i]))) / ((2 * Math::PI * sigma_squared_vector[i])**(0.5))
+
+      probability = probability * feature_prob
+    end
+
+    probability
+  end
+
+  def anomaly?(example)
+    probability(example) < threshold
+  end
+
+  def import(path_or_file)
+    Magnifier::Importer.export(path_or_file, self)
+  end
+
+  def export(path_or_file)
+    Magnifier::Exporter.export(path_or_file, self)
+  end
+
+  private
+
+    def compute_f1_score(predictions, base_truths)
+      true_positives  = predictions.map.with_index { |val, i| val && base_truths[i] }.count(true)
+      false_positives = predictions.map.with_index { |val, i| val && !base_truths[i] }.count(true)
+      false_negatives = predictions.map.with_index { |val, i| !val && base_truths[i] }.count(true)
+
+      return 0 if true_positives == 0
+
+      precision = true_positives.to_f / (true_positives + false_positives);
+      recall = true_positives.to_f / (true_positives + false_negatives);
+
+      (2 * precision * recall) / (precision + recall) rescue 0;
+    end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: magnifier-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Nick Grysimov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-06 00:00:00.000000000 Z
+date: 2018-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -59,6 +59,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/magnifier.rb
+- lib/magnifier/exporter.rb
+- lib/magnifier/importer.rb
+- lib/magnifier/magnifier.rb
 homepage: https://github.com/tuned-up/magnifier-ruby
 licenses:
 - MIT