evoc 3.5.0

data/lib/evoc/scenario.rb

@@ -0,0 +1,303 @@
+module Evoc
+  class Scenario
+    include Comparable, Logging
+
+    attr_accessor :case_id,
+                  :granularity,
+                  :scenario_id,
+                  :tx,
+                  :algorithm,
+                  :measures,
+                  :aggregator,
+                  :tx_index,
+                  :tx_id,
+                  :permutation,
+                  :query,
+                  :model_size,
+                  :model_age,
+                  :max_size,
+                  :opts
+
+    def initialize(opts = Hash.new)
+      logger.debug "Initialized new scenario with configuration: #{opts}"
+      self.opts        = opts
+      self.scenario_id = opts.hash
+
+      # model_size depends on model_age, so set model_age first
+      self.model_age = opts[:model_age]
+      opts.each do |attribute,value|
+        self.send("#{attribute}=", value)
+      end
+    end
+
+
+    ##
+    # <=> defines how to compare two Query objects
+    def <=> other
+      return nil unless other.is_a?(Query)
+      comparison = 0
+      # first we compare the tx id
+      if (self.tx_id <=> other.tx_id) == 0
+        # if we also have the same query
+        if (self.query.sort <=> other.query.sort) == 0
+        # use history size as comparator
+           comparison = (self.model_size <=> other.model_size)
+        else
+          # use the query
+          comparison = (self.query.sort <=> other.query.sort)
+        end
+      else
+        # use the tx id
+        comparison = (self.tx_id <=> other.tx_id)
+      end
+      comparison
+    end
+
+    ##
+    # Executes a query given the current paramaters
+    # This results in a set of association rules, i.e., a recommendation
+    #
+    # Producing a recommendation is done through the following process:
+    #
+    # 1. Generate rules using a mining algorithm on the specified history
+    # 2. Calculate interestingness measures on the generated rules
+    # (optional) 3. Aggregate rules to further improve recommendation
+    # (optional) 4. Evaluate how good the recommendation is
+    #
+    # @return [Hash] containing the query + scenario + recommendation + other metadata
+    def call(evaluators: [])
+      #generate recommendation in cache (generate rules + measures on rules)
+      self.recommendation
+
+      # evaluate if requested
+      if !evaluators.empty?
+        Evoc::RecommendationCache.evaluate(evaluators: evaluators,expected_outcome: self.expected_outcome,measure_combination: self.measures)
+      end
+      # build return hash
+      recommendation = Evoc::RecommendationCache.to_h(measures: self.measures)
+      return self.to_h.merge(recommendation)
+    end
+
+    def to_h
+      fields = %w(case_id granularity scenario_id tx_id tx_index tx_size query_size query_percentage expected_outcome_size model_size model_hours model_age max_size algorithm aggregator measures)
+      hash = Hash.new
+      fields.each do |key|
+        value = self.method(key).call
+        hash[key] = value.is_a?(Array) ? value.join(',') : value
+      end
+      return hash
+    end
+
+    def recommendation
+        Evoc::RecommendationCache.get_recommendation(algorithm: self.algorithm,
+                                                      query: self.query,
+                                                      model_start: self.model_start,
+                                                      model_end: self.model_end,
+                                                      max_size: self.max_size,
+                                                      aggregator: self.aggregator,
+                                                      measures: self.measures)
+    end
+
+    def recommendation?
+        Evoc::RecommendationCache.recommendation_cached?(algorithm: self.algorithm,
+                                                      query: self.query,
+                                                      model_start: self.model_start,
+                                                      model_end: self.model_end,
+                                                      max_size: self.max_size)
+    end
+
+    def to_s
+      self.opts
+    end
+
+
+    ##
+    # CUSTOM SETTERS AND GETTERS
+    #
+    
+    ##
+    # @return [Evoc::Tx] the transaction of this scenario
+    def tx
+      tx = nil
+      if !self.tx_id.nil?
+        tx = Evoc::HistoryStore.base_history.get_tx(id: self.tx_id, id_type: :id)
+      end
+      return tx
+    end
+
+    ##
+    # @return [Integer] the size of the query
+    def query_size
+      self.query.size
+    end
+
+    ##
+    # @return [Float] the percentage of the whole history that is used in the model
+    def model_percentage
+      self.model_size.to_i == 0 ? 100 : ((self.model_size.to_f/self.tx_index)*100).round(2)
+    end
+
+    ##
+    # Sets the model size in this scenario
+    #
+    # If set to 0 (zero), the maximum possible size is calculated
+    # In this case, model age will be taken into account
+    # 
+    # @param [Integer] the size of the model
+    def model_size=(size)
+      if size.to_i == 0
+        @model_size = (self.model_age.nil? ? self.tx_index : self.tx_index - self.model_age)
+      else
+        @model_size = size.to_i
+      end
+    end
+
+    ##
+    # @return [Integer] the index in the history where the model starts
+    def model_start
+      value = self.tx_index - self.model_size.to_i - self.model_age.to_i
+      if value < 0
+        raise ArgumentError, "The model start index was negative (model_size:#{self.model_size}, tx_index:#{self.tx_index})"
+      end
+      return value
+    end
+
+    ##
+    # @return [Integer] the index in the history where the model ends
+    def model_end
+      value = (self.tx_index - 1 - self.model_age.to_i)
+      if value < 0
+        raise ArgumentError, "The model end index was negative (model_size:#{self.model_size}, tx_index:#{self.tx_index})"
+      elsif value < self.model_start
+        raise ArgumentError, "The model end was before the model start (start: #{self.model_start}, end: #{value})"
+      end
+      return value
+    end
+
+    ##
+    # @return [Integer] the time between the first and last transaction in the model
+    def model_hours
+        model_end_tx = Evoc::HistoryStore.base_history.get_tx(id: self.model_end)
+        model_start_tx = Evoc::HistoryStore.base_history.get_tx(id: self.model_start)
+        return TimeDifference.between(model_start_tx.date,model_end_tx.date).in_hours
+    end
+
+    ##
+    # query_percentage
+    def query_percentage
+      total_items = self.query.size.to_i + self.expected_outcome.size
+      (self.query.size.to_f/total_items*100).round
+    end
+
+    
+    ##
+    # max_size
+    def max_size=(value)
+      if !value.nil?
+        if value.respond_to?(:to_i)
+          @max_size = value.to_i
+        else
+          raise ArgumentError.new, "value for max_size could not be converted to integer, value was: #{value}"
+        end
+      end
+    end
+
+    ##
+  	# custom setter for query
+    def query=(query)
+      if !query.nil?
+        @query = query
+        # convert to list of integers
+        @query.map!(&:to_i) 
+        if !self.tx.nil?
+          if @query.size >= (self.tx.size)
+            $stderr.warn "The query was larger than or equal to the size of the transaction (Qs: #{@query.size}, Tx size: #{self.tx.size})"
+          end
+        end
+        if @query.empty?
+          raise ArgumentError, "The query was empty"
+        end
+      end
+    end
+
+    ##
+    # Custom setter for measures
+    def measures=(measures)
+      if !measures.nil?
+        # internally, all interestingness measures are 
+        # represented as :m_measurename (symbols), so we concatinate
+        # 'm_' and symbolize the list of given measures
+        if measures.is_a?(String)
+          measures = measures.split(',')
+        end
+        @measures = measures.map {|m| (/\Am_/ =~ m).nil? ? ('m_'+m).to_sym : m.to_sym}
+      end
+    end
+
+    ##
+    # @return [Array] the list of expected items
+  	def expected_outcome
+      expected_outcome = (self.tx.items - self.query)
+      if expected_outcome.empty?
+        logger.warn "The expected outcome was empty"
+      end
+      return expected_outcome
+  	end
+    
+    ##
+    # @return [Integer] the size of the expected outcome
+  	def expected_outcome_size
+      self.expected_outcome.size
+  	end
+
+    ##
+    # @return [String] the history index of this scenarios transaction
+    def tx_index
+      self.tx.index
+    end
+
+    ##
+    # @return [Integer] the size of this scenarios transaction
+    def tx_size
+      self.tx.size
+    end
+
+    ##
+    #
+    def instance_values_for_csv
+      dont_include = ['opts', 'logger','time','filtered_model_size']
+      self.instance_values.delete_if {|k,v| dont_include.include?(k)}
+    end
+
+    ##
+    # generate an array suitable for a csv header
+    def csv_header
+      query = self.instance_values_for_csv.keys
+      rule_store = !self.recommendation? ? [] : self.recommendation.csv_header
+      rule_store + query
+    end
+
+    ##
+    # generate an array of the current values of <self>
+    # converts any array values to a comma separated string representation
+    def to_csv_row
+      query = self.instance_values_for_csv.values.map {|val| val.is_a?(Array) ? val.join(',') : val}
+      rule_store = !self.recommendation? ? [] : self.recommendation.to_csv_row
+      rule_store + query
+    end
+
+
+
+  	##
+  	# Prints the rules to standard out
+  	# sorted by strength
+  	def print
+      if !self.recommendation?
+          $stdout.puts ""
+      else
+        self.recommendation.print(measures)
+      end
+  	end
+
+  end
+end

data/lib/evoc/svd.rb

@@ -0,0 +1,124 @@
+module Evoc
+  ##
+  # CLASS SVD
+  #
+  # public fields:
+  #    index: 
+  #       hash of {index -> file}, where file is at "index" in the co_change_matrix and svd matrix 
+  class SVD
+    attr_accessor :co_change_matrix, :u, :s, :v 
+
+    def initialize(tx_store = nil)
+      if tx_store.is_a?(Evoc::TxStore)
+        @index2item,@item2index,@co_change_matrix = txstore_2_co_change_matrix(tx_store)
+        @u,@s,@v = svd(@co_change_matrix)
+      end
+    end
+
+    def indexes
+      @index2item.keys
+    end
+
+    def items
+      @item2index.keys
+    end
+
+    def index2item index
+      @index2item[index]
+    end
+
+    def item2index item
+      @item2index[item]
+    end
+
+    def svd(co_change_matrix)
+      u,s,v = co_change_matrix.gesvd
+    end
+
+    ##
+    # Find the clusters in the current svd given a change-vector/query
+    #
+    # threshold: the minimum value of an element in the U matrix, 
+    #            to be considered as part of an cluster
+    def clusters(query,threshold = 0)
+      clusters = Hash.new
+      perfect_match = []
+      query_indexes = query.map {|q_item| item2index(q_item)}.compact #remove nil values
+      col_index = 0
+      self.u.each_column do |col|
+        #initiate cluster
+        clusters[col_index] = {pos: {query_match: [], clustered: []},
+                                neg: {query_match: [], clustered: []}}
+        # get the column of the item
+        col.each_with_index do |row_item,row_index|
+          # check that the row item is part of cluster
+          if row_item.abs > threshold 
+            sign = row_item > 0 ? :pos : :neg
+            # check if its another item from the query
+            if query_indexes.include? row_index
+              clusters[col_index][sign][:query_match] << index2item(row_index)
+              # check if all items in the cluster was in the query (perfect match)
+              if clusters[col_index][sign][:query_match].size == query.size
+                perfect_match << [col_index,sign]
+              end
+            else
+              clusters[col_index][sign][:clustered] << [index2item(row_index),row_item]
+            end
+          end
+        end
+        col_index += 1
+      end
+      [perfect_match,clusters]
+    end
+
+
+    ##
+    # Returns the co-change matrix of currently loaded files
+    # each column/row combination specifies how many times the 
+    # two files changed together
+    #
+    #    f1 f2 f3
+    # f1 2  1  1 
+    # f2 1  3  1
+    # f3 1  1  1
+    def txstore_2_co_change_matrix(tx_store)
+      co_change_hash = Hash.new
+      tx_store.each do |tx|
+        tx.items.each do |file_id| 
+          if co_change_hash[file_id] == nil
+            co_change_hash[file_id] = {:co_changed => Hash.new}
+          end
+          tx.items.each do |co_changed_file_id|
+            if co_change_hash[file_id][:co_changed][co_changed_file_id] == nil
+              co_change_hash[file_id][:co_changed][co_changed_file_id] = 1
+            else
+              co_change_hash[file_id][:co_changed][co_changed_file_id] += 1
+            end
+          end
+        end		
+      end
+      # add indexes
+      co_change_hash.each_with_index do |(key,value),index|
+        co_change_hash[key][:index] = index
+      end
+      # Generate the 2 wise dependency weight array
+      #
+      n = co_change_hash.size
+      co_change_matrix = NMatrix.new(n,0,dtype: :float64)
+      co_change_hash.each_with_index do |(key,value),index|
+        this_file = index
+        value[:co_changed].each do |(co_changed_file,sum_co_changes)|
+          co_index = (co_change_hash[co_changed_file][:index])
+          co_change_matrix[co_index,this_file] = sum_co_changes
+        end
+      end
+      index2item = Hash.new
+      item2index = Hash.new
+      co_change_hash.each do |k,v|
+        index2item[v[:index]] = k
+        item2index[k] = v[:index]
+      end
+      [index2item,item2index,co_change_matrix]
+    end
+  end
+end

data/lib/evoc/tx.rb

@@ -0,0 +1,34 @@
+module Evoc
+  class Tx
+    include Comparable
+    attr_reader :id, :date
+    attr_accessor :items, :index
+
+    def initialize(index: nil,id:,date: nil,items:)
+      @index = index
+      @id    = id
+      @date  = date
+      @items = items
+    end
+
+    def size
+      self.items.size
+    end
+
+    def <=> other
+      self.index <=> other.index
+    end
+
+    def to_i
+      self.index.to_i
+    end
+
+    def to_s
+      self.id.to_s
+    end
+
+    def to_a
+      self.items.to_a
+    end
+  end
+end