Class: TensorStream::Graph

Inherits:
Object
  • Object
show all
Defined in:
lib/tensor_stream/graph.rb

Overview

A class that defines a TensorStream graph

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Graph

Returns a new instance of Graph.



6
7
8
9
10
11
12
13
 
# File 'lib/tensor_stream/graph.rb', line 6

def initialize
  @eager_execution = false
  @nodes = {}
  @collections = {
    :"#{GraphKeys::GLOBAL_VARIABLES}" => []
  }
  @constants = {}
end

Instance Attribute Details

#collections ⇒ Object

Returns the value of attribute collections.



4
5
6
 
# File 'lib/tensor_stream/graph.rb', line 4

def collections
  @collections
end

#constants ⇒ Object

Returns the value of attribute constants.



4
5
6
 
# File 'lib/tensor_stream/graph.rb', line 4

def constants
  @constants
end

#eager_execution ⇒ Object

Returns the value of attribute eager_execution.



4
5
6
 
# File 'lib/tensor_stream/graph.rb', line 4

def eager_execution
  @eager_execution
end

#nodes ⇒ Object

Returns the value of attribute nodes.



4
5
6
 
# File 'lib/tensor_stream/graph.rb', line 4

def nodes
  @nodes
end

#random_seed ⇒ Object

Returns the value of attribute random_seed.



4
5
6
 
# File 'lib/tensor_stream/graph.rb', line 4

def random_seed
  @random_seed
end

Class Method Details

.create_default ⇒ Object 



63
64
65
 
# File 'lib/tensor_stream/graph.rb', line 63

def self.create_default
  Thread.current[:tensor_stream_current_graph] = TensorStream::Graph.new
end

.get_default_graph ⇒ Object 



59
60
61
 
# File 'lib/tensor_stream/graph.rb', line 59

def self.get_default_graph
  Thread.current[:tensor_stream_current_graph] || create_default
end

Instance Method Details

#add_node(node) ⇒ Object 



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/tensor_stream/graph.rb', line 76

def add_node(node)
  raise 'Placeholder cannot be used when eager_execution is enabled' if @eager_execution && node.is_a?(Placeholder)

  node.name = if @nodes[node.name]
                uniqunify(node.name)
              else
                node.name
              end

  node.device = get_device_scope
  @nodes[node.name] = node
  @constants[node.name] = node if node.is_const
  node.send(:propagate_outputs)
  node.send(:propagate_consumer, node)
  node.value = node.eval if @eager_execution
end

#add_node!(name, node) ⇒ Object 



101
102
103
104
 
# File 'lib/tensor_stream/graph.rb', line 101

def add_node!(name, node)
  @nodes[name] = node
  node
end

#add_to_collection(collection_name, val) ⇒ Object 



71
72
73
74
 
# File 'lib/tensor_stream/graph.rb', line 71

def add_to_collection(collection_name, val)
  @collections[collection_name.to_sym] ||= []
  @collections[collection_name.to_sym] << val
end

#add_variable(node, options = {}) ⇒ Object 



106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/tensor_stream/graph.rb', line 106

def add_variable(node, options = {})
  scope = _variable_scope

  raise "duplicate variable detected #{node.name} and reuse=false in current scope" if @nodes[node.name] && !scope.reuse
  return @nodes[node.name] if @nodes[node.name]
  raise "shape is not declared for #{node.name}" if node.shape.nil?

  if !options[:collections].nil? && !options[:collections].empty?
    options[:collections] = [options[:collections]] unless options[:collections].is_a?(Array)
    options[:collections].each { |coll| add_to_collection(coll, node) }
  end

  add_to_collection(GraphKeys::GLOBAL_VARIABLES, node)
  add_to_collection(GraphKeys::TRAINABLE_VARIABLES, node) if node.trainable?
  add_node(node)
end

#as_default {|_self| ... } ⇒ Object

Yields:

  • (_self)

Yield Parameters:



28
29
30
31
32
 
# File 'lib/tensor_stream/graph.rb', line 28

def as_default
  Thread.current[:tensor_stream_current_graph] = self
  yield(self) if block_given?
  self
end

#as_graph_def ⇒ Object 



200
201
202
 
# File 'lib/tensor_stream/graph.rb', line 200

def as_graph_def
  TensorStream::Pbtext.new.get_string(self)
end

#control_dependencies(control_inputs = [], &block) ⇒ Object 



123
124
125
126
127
128
129
130
131
132
 
# File 'lib/tensor_stream/graph.rb', line 123

def control_dependencies(control_inputs = [], &block)
  Thread.current["ts_graph_#{object_id}"] ||= {}
  Thread.current["ts_graph_#{object_id}"][:control_dependencies] ||= []
  Thread.current["ts_graph_#{object_id}"][:control_dependencies] << Operation.new(:no_op, *control_inputs)
  begin
    block.call
  ensure
    Thread.current["ts_graph_#{object_id}"][:control_dependencies].pop
  end
end

#device(device_name) ⇒ Object

Returns a context manager that specifies the default device to use.



48
49
50
51
52
53
54
55
56
57
 
# File 'lib/tensor_stream/graph.rb', line 48

def device(device_name)
  Thread.current["ts_graph_#{object_id}"] ||= {}
  Thread.current["ts_graph_#{object_id}"][:default_device] ||= []
  Thread.current["ts_graph_#{object_id}"][:default_device] << device_name
  begin
    yield
  ensure
    Thread.current["ts_graph_#{object_id}"][:default_device].pop
  end
end

#disable_eager_execution ⇒ Object 



138
139
140
 
# File 'lib/tensor_stream/graph.rb', line 138

def disable_eager_execution
  @eager_execution = false
end

#enable_eager_execution ⇒ Object 



134
135
136
 
# File 'lib/tensor_stream/graph.rb', line 134

def enable_eager_execution
  @eager_execution = true
end

#executing_eagerly? ⇒ Boolean

Returns:

  • (Boolean) 


142
143
144
 
# File 'lib/tensor_stream/graph.rb', line 142

def executing_eagerly?
  @eager_execution
end

#get_collection(name, _options = {}) ⇒ Object 



67
68
69
 
# File 'lib/tensor_stream/graph.rb', line 67

def get_collection(name, _options = {})
  @collections[name.to_sym]
end

#get_const_counter ⇒ Object 



172
173
174
175
176
177
178
179
 
# File 'lib/tensor_stream/graph.rb', line 172

def get_const_counter
  @const_counter ||= 0

  name = @const_counter.zero? ? '' : "_#{@const_counter}"

  @const_counter += 1
  name
end

#get_dependency_scope ⇒ Object 



188
189
190
191
192
 
# File 'lib/tensor_stream/graph.rb', line 188

def get_dependency_scope
  graph_thread_storage = Thread.current["ts_graph_#{object_id}"]
  return nil if graph_thread_storage.nil? || graph_thread_storage[:control_dependencies].nil?
  graph_thread_storage[:control_dependencies].last
end

#get_device_scope ⇒ Object 



194
195
196
197
198
 
# File 'lib/tensor_stream/graph.rb', line 194

def get_device_scope
  graph_thread_storage = Thread.current["ts_graph_#{object_id}"]
  return :default if graph_thread_storage.nil? || graph_thread_storage[:default_device].nil?
  graph_thread_storage[:default_device].last
end

#get_name_scope ⇒ Object 



181
182
183
184
185
186
 
# File 'lib/tensor_stream/graph.rb', line 181

def get_name_scope
  graph_thread_storage = Thread.current["ts_graph_#{object_id}"]
  return nil if graph_thread_storage.nil? || graph_thread_storage[:current_scope].nil?

  graph_thread_storage[:current_scope].join('/')
end

#get_node(name) ⇒ Object 



97
98
99
 
# File 'lib/tensor_stream/graph.rb', line 97

def get_node(name)
  @nodes[name]
end

#get_operation_counter ⇒ Object 



146
147
148
149
150
151
152
153
154
 
# File 'lib/tensor_stream/graph.rb', line 146

def get_operation_counter
  @op_counter ||= 0

  name = @op_counter.zero? ? '' : "_#{@op_counter}"

  @op_counter += 1

  name
end

#get_placeholder_counter ⇒ Object 



156
157
158
159
160
161
162
 
# File 'lib/tensor_stream/graph.rb', line 156

def get_placeholder_counter
  @placeholder_counter ||= 0
  @placeholder_counter += 1

  return '' if @placeholder_counter == 1
  "_#{@placeholder_counter}"
end

#get_var_counter ⇒ Object 



164
165
166
167
168
169
170
 
# File 'lib/tensor_stream/graph.rb', line 164

def get_var_counter
  @var_counter ||= 0
  @var_counter += 1

  return '' if @var_counter == 1
  "_#{@var_counter}"
end

#graph_def_versions ⇒ Object 



204
205
206
 
# File 'lib/tensor_stream/graph.rb', line 204

def graph_def_versions
  "producer: 26"
end

#name_scope(name = nil) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/tensor_stream/graph.rb', line 34

def name_scope(name = nil)
  Thread.current["ts_graph_#{object_id}"] ||= {}
  Thread.current["ts_graph_#{object_id}"][:current_scope] ||= []
  Thread.current["ts_graph_#{object_id}"][:current_scope] << name

  begin
    yield get_name_scope if block_given?
  ensure
    Thread.current["ts_graph_#{object_id}"][:current_scope].pop
  end
end

#node_added?(name) ⇒ Boolean

Returns:

  • (Boolean) 


93
94
95
 
# File 'lib/tensor_stream/graph.rb', line 93

def node_added?(name)
  @nodes.key?(name)
end

#reset ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/tensor_stream/graph.rb', line 15

def reset
  @placeholder_counter = 0
  @const_counter = 0
  @var_counter = 0
  @op_counter = 0
  @random_seed = nil
  @nodes = {}
  @collections = {
    :"#{GraphKeys::GLOBAL_VARIABLES}" => []
  }
  @constants = {}
end