silicium 0.0.14 → 0.0.22

data/lib/graph_visualizer.rb

@@ -0,0 +1,286 @@
+require 'chunky_png'
+require 'ruby2d'
+require 'ruby2d/window'
+module Silicium
+  module GraphVisualizer
+    include Silicium::Graphs
+    include Ruby2D
+
+
+    ##
+    # Changes window size
+    def change_window_size(w, h)
+      (Window.get :window).set width: w, height: h
+    end
+
+    ##
+    # Changes width of edges
+    def change_edge_width(w)
+      @@line_width = w
+    end
+
+    ##
+    # Changes radius of vertices
+    def change_vertices_radius(r)
+      @@vert_radius = r
+    end
+
+    ##
+    # Changes labels size
+    def change_label_size(s)
+      @@label_size = s
+    end
+
+    ##
+    # Changes labels color
+    def change_label_color(c)
+      @@label_color = Color.new(c)
+    end
+
+    ##
+    # Changes vertices color
+    def change_vertex_color(c)
+      @@vertex_color = Color.new(c)
+    end
+
+    ##
+    # Set the graph for visualization
+    def set_graph(graph)
+      if graph.class != OrientedGraph and graph.class != UnorientedGraph
+        raise ArgumentError, "Invalid graph type!"
+      end
+      clear_window
+      set_vertices(graph)
+      set_edges(graph)
+      set_labels(graph)
+    end
+
+    ##
+    # clear screen
+    def clear_window
+      Window.clear
+    end
+
+    ##
+    # close screen
+    def close_window
+      Window.close
+    end
+
+    ##
+    # show graph on the screen
+    def show_window
+      Window.show
+    end
+
+    ##
+    # radius of vertices circles
+    @@vert_radius = 15
+    ##
+    # width of the edges
+    @@line_width = 5
+    # size of labels
+    @@label_size = 15
+    ##
+    # color of labels
+    @@label_color = Color.new('red')
+    ##
+    # color of vertices
+    @@vertex_color = Color.new('white')
+
+    private
+
+    ##
+    # creates labels of edges and vertices
+    def set_labels(graph)
+      @v_labels = {}
+      graph.vertex_labels.keys.each do |v|
+        @v_labels[v] = draw_vertex_label(v, graph.vertex_labels[v])
+      end
+
+      @e_labels = {}
+      graph.edge_labels.keys.each do |pair|
+        @e_labels[pair] = draw_edge_label(pair, graph.edge_labels[pair])
+      end
+    end
+
+    ##
+    # draws label on vertex
+    def draw_vertex_label(v,label)
+      if (label.class != String and label.class != Integer)
+        return
+      end
+      x = @vertices[v].x - Math.sqrt(2)/2*@@vert_radius
+      y = @vertices[v].y - Math.sqrt(2)/2*@@vert_radius
+      return Text.new(label,x: x, y: y, size: @@label_size, color: @@label_color)
+    end
+
+    ##
+    # draws label on edge
+    def draw_edge_label(pair,label)
+      if (label.class != String and label.class != Integer)
+        return
+      end
+      x1 = @vertices[pair[:first]].x
+      y1 = @vertices[pair[:first]].y
+      x2 = @vertices[pair[:second]].x
+      y2 = @vertices[pair[:second]].y
+      x = (x1+x2)/2
+      y = (y1+y2)/2
+
+      if x1 == x2 and y1 == y2
+        x = @edges[pair][:line].x
+        y = @edges[pair][:line].y
+      end
+
+      return Text.new(label,x: x, y: y, size: @@label_size, color: @@label_color)
+    end
+
+    ##
+    # set all edges of the graph
+    def set_edges(graph)
+      @edges = {}
+      @is_oriented = graph.class == OrientedGraph
+      graph.vertices.keys.each do |from_vert|
+        graph.vertices[from_vert].each do |to_vert|
+          push_edge(from_vert,to_vert)
+        end
+      end
+    end
+
+    ##
+    # creates edge and push it to the @edges
+    def push_edge(from_vert, to_vert)
+      col = get_random_color
+      if @is_oriented and has_edge?(to_vert,from_vert)
+        col = @edges[Pair.new(to_vert,from_vert)][:line].color
+      end
+      arrow = @is_oriented ? draw_oriented_edge(from_vert,to_vert,col):draw_edge(from_vert,to_vert,col)
+      @edges[Pair.new(from_vert,to_vert)] = arrow
+    end
+
+    ##
+    # return true if graph contains current edge
+    def has_edge?(from_vert, to_vert)
+      if @is_oriented
+        return @edges.has_key?(Pair.new(from_vert,to_vert))
+      end
+      return (@edges.has_key?(Pair.new(to_vert,from_vert)) or @edges.has_key?(Pair.new(from_vert,to_vert)))
+    end
+
+    ##
+    # returns random color
+    def get_random_color
+      col = Color.new('random')
+      while (col == @@label_color) or (col == @@vertex_color)
+        col = Color.new('random')
+      end
+      return col
+    end
+
+    ##
+    # draws all vertices of the graph
+    def set_vertices(graph)
+      @vertices = {}
+      w = Window.get :width
+      h = Window.get :height
+      radius= [w,h].min*1.0 / 2 - @@vert_radius*4
+      vert_step = (360.0  / graph.vertex_number)*(Math::PI/180)
+      position = 0
+      graph.vertices.keys.each do |vert|
+        x = w/2 + Math.cos(position)*radius
+        y = h/2 + Math.sin(position)*radius
+        @vertices[vert] = draw_vertex(x,y)
+        position += vert_step
+      end
+    end
+
+    ##
+    # creates circle for vertex
+    def draw_vertex(x, y)
+      circle = Circle.new(x: x, y: y, radius: @@vert_radius, sectors: 128, color: @@vertex_color)
+      return circle
+    end
+
+    ##
+    # creates arrow of edge between vertices
+    def draw_oriented_edge(v1,v2,col)
+      line = draw_edge(v1,v2,col)
+
+      x1 = @vertices[v1].x
+      y1 = @vertices[v1].y
+      x2 = @vertices[v2].x
+      y2 = @vertices[v2].y
+
+      x_len = x2-x1
+      y_len = y2-y1
+      len = Math.sqrt(x_len*x_len+y_len*y_len)
+      sin = y_len/len
+      cos = x_len/len
+      pos_x1 = x2 - @@vert_radius*cos
+      pos_y1 = y2 - @@vert_radius*sin
+      height_x= pos_x1 - @@line_width*4*cos
+      height_y= pos_y1 - @@line_width*4*sin
+      sin, cos = cos, sin
+      pos_x2 = height_x + @@line_width*2*cos
+      pos_y3 = height_y + @@line_width*2*sin
+      pos_x3 = height_x - @@line_width*2*cos
+      pos_y2 = height_y - @@line_width*2*sin
+      #triangle = Circle.new(x: pos_x2, y: pos_y3,radius: 4, color: col)
+      #Circle.new(x: pos_x3, y: pos_y2,radius: 4, color: col)
+      triangle = Triangle.new(x1: pos_x1, y1: pos_y1, x2: pos_x2, y2: pos_y2, x3: pos_x3, y3: pos_y3, color: col)
+
+      return {line: line, triangle: triangle}
+    end
+
+    ##
+    # creates edge between vertices
+    def draw_edge(v1,v2,col)
+      x1 = @vertices[v1].x
+      y1 = @vertices[v1].y
+      x2 = @vertices[v2].x
+      y2 = @vertices[v2].y
+      x_len = x1-x2
+      y_len = y1-y2
+      len = Math.sqrt(x_len*x_len+y_len*y_len)
+
+      if len == 0
+        return draw_loop(v1,col)
+      end
+
+      sin = y_len/len
+      cos = x_len/len
+      pos_x0 = x1 - @@vert_radius*cos
+      pos_y0 = y1 - @@vert_radius*sin
+
+      x_len = x2-x1
+      y_len = y2-y1
+      sin = y_len/len
+      cos = x_len/len
+      pos_x1 = x2 - @@vert_radius*cos
+      pos_y1 = y2 - @@vert_radius*sin
+      return Line.new(x1: pos_x0, y1: pos_y0, x2: pos_x1, y2: pos_y1, width: @@line_width, color: col)
+    end
+
+    ##
+    # create loop edge
+    def draw_loop(v,col)
+      x = @vertices[v].x
+      y = @vertices[v].y
+      center_x = (Window.get :width) / 2
+      center_y = (Window.get :height) / 2
+      x_len = center_x-x
+      y_len = center_y-y
+      len = Math.sqrt(x_len*x_len+y_len*y_len)
+      sin = y_len/len
+      cos = x_len/len
+      pos_x1 = x - @@vert_radius*cos*2
+      pos_y1 = y - @@vert_radius*sin*2
+      circle = Circle.new(x: pos_x1, y: pos_y1, radius: @@vert_radius*2, color: col)
+      Circle.new(x: pos_x1, y: pos_y1, radius: @@vert_radius*2-@@line_width, color: Window.get( :background))
+      @vertices[v] = Circle.new(x: x, y: y, radius: @@vert_radius+1, color: @@vertex_color)
+      return circle
+    end
+
+  end
+end

data/lib/ml_algorithms.rb

@@ -0,0 +1,181 @@
+# Class represents computational graph
+module BackPropogation
+  class ComputationalGraph
+
+    PRIORITY = Hash['(' => 0, '+' => 1, '-' => 1, '*' => 2, '/' => 2, '^' => 3]
+    TEMPLATES = {
+        operand: /^\s*([^\+\-\*\/\(\)\^\s]+)\s*(.*)/,
+        string: /^\s*([\+\-\*\/\^])\s*(.*)/,
+        brackets: /^\s*\(\s*(.*)/,
+        nested: /^\s*\)\s*(.*)/
+    }
+
+    attr_accessor :graph
+    def initialize(expr_s)
+      exprproc = ComputationalGraph::polish_parser(expr_s, [])
+      pregraph = []
+      @graph = []
+      exprproc.split.each do |elem|
+        case elem
+        when '+'
+          dot = ComputationalGates::SummGate.new(elem)
+          dot.connect(pregraph.pop,pregraph.pop)
+        when '*'
+          dot = ComputationalGates::MultGate.new(elem)
+          dot.connect(pregraph.pop,pregraph.pop)
+        when '/'
+          dot = ComputationalGates::DivGate.new(elem)
+          scnd = pregraph.pop
+          frst = pregraph.pop
+          dot.connect(frst,scnd)
+        else
+          dot = ComputationalGates::CompGate.new(elem)
+        end
+        pregraph.push(dot)
+        @graph.push(dot)
+      end
+    end
+    #Compute a value of expression
+    def forward_pass(variables_val)
+      @graph.each do |elem|
+        if elem.class != ComputationalGates::CompGate
+          elem.forward_pass
+        else
+          elem.frwrd = variables_val[elem.name]
+        end
+      end
+      graph.last.frwrd
+    end
+    #Compute a gradient value for inputs
+    def backward_pass(loss_value)
+      param_grad = Hash.new()
+      @graph.last.bckwrd = loss_value
+      @graph.reverse.each do |elem|
+        if elem.class != ComputationalGates::CompGate
+          elem.backward_pass
+        else
+          param_grad[elem.name] = elem.bckwrd
+        end
+      end
+      param_grad
+    end
+
+
+    def self.parse_operand(left, right, stack)
+      left + ' ' + polish_parser(right, stack)
+    end
+
+    def self.parse_string(left, right, i_str, stack)
+      if stack.empty? || PRIORITY[stack.last] < PRIORITY[left]
+        polish_parser(right, stack.push(left))
+      else 
+        stack.pop + ' ' + polish_parser(i_str, stack) 
+      end
+    end
+
+    def self.parse_nested(left, right, stack)
+      raise ArgumentError, 'Error: Excess of closing brackets.' if stack.empty?
+
+      head = stack.pop
+      PRIORITY[head].positive? ? head + ' ' + polish_parser(right, stack) : polish_parser(left, stack)
+    end
+
+    def self.parse_brackets(left, stack)
+      polish_parser(left, stack)
+    end
+
+    def self.parse_default(left, stack)
+      return '' if stack.empty?
+      raise ArgumentError, 'Error: Excess of opening brackets.'  unless PRIORITY[stack.last] > 0
+
+      stack.pop + ' ' + polish_parser(left, stack)
+    end
+    
+    #String preprocessing algorithm expression for computation
+    def self.polish_parser(i_str, stack)
+      case i_str
+      when TEMPLATES[:operand]
+        parse_operand(Regexp.last_match(1), Regexp.last_match(2), stack)
+      when TEMPLATES[:string]
+        parse_string(Regexp.last_match(1), Regexp.last_match(2), i_str, stack)
+      when TEMPLATES[:brackets]
+        parse_brackets(Regexp.last_match(1), stack.push('('))
+      when TEMPLATES[:nested]
+        parse_nested(Regexp.last_match(1), i_str, stack)
+      else
+        parse_default(i_str, stack)
+      end
+    end
+  end
+
+  module ComputationalGates
+    class CompGate
+      attr_accessor :frwrd,:bckwrd,:out,:name
+      def initialize(name)
+        @name = name
+        @frwrd = self
+      end
+    end
+    class SummGate < CompGate
+      attr_accessor :in_frst,:in_scnd
+      def initialize(name)
+        super(name)
+      end
+      def connect(f_n,s_n)
+        @in_frst = f_n
+        @in_scnd = s_n
+        f_n.out = self
+        s_n.out = self
+      end
+
+      def forward_pass()
+        @frwrd = @in_frst.frwrd + @in_scnd.frwrd
+      end
+      def backward_pass()
+        @in_frst.bckwrd = @bckwrd
+        @in_scnd.bckwrd = @bckwrd
+      end
+
+    end
+    class MultGate < CompGate
+      attr_accessor :in_frst,:in_scnd
+      def initialize(name)
+        super(name)
+      end
+      def connect(f_n,s_n)
+        @in_frst = f_n
+        @in_scnd = s_n
+        f_n.out = self
+        s_n.out = self
+      end
+      def forward_pass()
+        @frwrd = @in_frst.frwrd * @in_scnd.frwrd
+      end
+      def backward_pass()
+        @in_frst.bckwrd = @bckwrd * @in_scnd.frwrd
+        @in_scnd.bckwrd = @bckwrd * @in_frst.frwrd
+      end
+
+    end
+    class DivGate < CompGate
+      attr_accessor :in_frst,:in_scnd
+      def initialize(name)
+        super(name)
+      end
+      def connect(f_n,s_n)
+        @in_frst = f_n
+        @in_scnd = s_n
+        f_n.out = self
+        s_n.out = self
+      end
+      def forward_pass()
+        @frwrd = @in_frst.frwrd / @in_scnd.frwrd
+      end
+      def backward_pass()
+        @in_frst.bckwrd = @bckwrd * ((-1)/(@in_scnd.frwrd ** 2))
+        @in_scnd.bckwrd = @bckwrd * ((-1)/(@in_frst.frwrd ** 2))
+      end
+
+    end
+  end
+end