def __init__(self, parent=None): super().__init__(parent=parent) # create pfgraph with pf.Graph() as graph: imageio = pf.import_('imageio') ndimage = pf.import_('scipy.ndimage') np = pf.import_('numpy') x = PFSlider(name="x") y = PFSlider(name="y") r = (x * y).set_name("r") frame = pf.placeholder("frame") readop(path=pf.placeholder('filepath'), frame=frame) # image = imageio.imread(filename).set_name('imread') self.setLayout(QHBoxLayout()) self.model = PFGraphModel( graph, **{ 'x': 90, 'y': 30, 'frame': 0, 'filepath': "C:/Users/andris/Videos/M2U00001.MPG" }) self.graphview = GraphView() self.graphview.setModel(self.model) self.viewer = Viewer() self.layout().addWidget(self.graphview) self.layout().addWidget(self.viewer) self.renderer = GraphicsRenderer() self.viewer.addItem(self.renderer) self.viewer.body.centerOn(0, 0) def onSelectionChange(): """show output results in viewer""" if len(self.model.nodeSelection()) > 0: for node in self.model.nodeSelection(): outputPorts = self.model.nodeOutputs(node) port = outputPorts[0] outputValue = self.model.portData((port, "value"), Qt.EditRole) self.renderer.setInput(outputValue) self.renderer.update() else: self.renderer.setInput(None) self.renderer.update() def onDataChange(index): for node in self.model.nodeSelection(): outputPorts = self.model.nodeOutputs(node) port = outputPorts[0] outputValue = self.model.portData((port, "value"), Qt.EditRole) self.renderer.setInput(outputValue) self.renderer.update() self.model.nodeSelectionChange.connect(onSelectionChange) self.model.portDataChange.connect(onDataChange)
def __init__(self, target, graph, **kwargs): self.t_exp = target self.t_sym = '_' + target self.graph_ops = graph.operations if self.t_sym not in self.graph_ops: pf.placeholder(self.t_sym) super(LazySymbol, self).__init__(**kwargs)
def test_cache(): calls = [] cache = {} @pf.opmethod def _cached_add(x, y): calls.append((x, y)) return x + y with pf.Graph() as graph: a = pf.placeholder() b = pf.placeholder() c = pf.cache(_cached_add(a, b), cache.__getitem__, cache.setdefault) for _ in range(3): assert graph(c, {a: 1, b: 2}) == 3 assert len(calls) == 1 assert len(cache) == 1 # Modify the cache value key, = cache.keys() assert key == hash((1, 2)) cache[key] = -1 assert graph(c, {a: 1, b: 2}) == -1 # Check another call assert graph(c, {a: 1, b: 4}) == 5 assert len(calls) == 2 assert len(cache) == 2
def test_context(): with pf.Graph() as graph: a = pf.placeholder(name='a') b = pf.placeholder(name='b') c = pf.placeholder(name='c') x = a * b + c actual = graph(x, {a: 4, 'b': 7}, c=9) assert actual == 37
def test_try_not_caught(): with pf.Graph() as graph: a = pf.placeholder() b = pf.placeholder() c = pf.try_(a / b, [(ValueError, 'value-error')]) with pytest.raises(ZeroDivisionError): graph(c, {a: 1, b: 0})
def run_processor(): with pf.Graph() as graph: x = pf.placeholder('x') a = pf.placeholder('a') y = (a * x).set_name('y') with pf.Processor.from_graph('tcp://127.0.0.1:5555', 'tcp://127.0.0.1:5556', graph) as processor: processor.run()
def __call__(self, fetches, **placeholders): vs = {'_' + k: v for k, v in placeholders.items()} with self.graph: for key in vs: if key not in self.graph.operations: pf.placeholder(key) return self.graph(fetches, **vs)
def make_simple_graph(node): """ Defines environment logic by building pf.Graph with provided nodes. Args: node: dictionary of Node instances Returns: pf.Graph instance, dictionaries of input of and output handles.s """ with pf.Graph() as graph: # Input placeholders to graph: is_reset = pf.placeholder(name='reset_input_flag') episode_duration = pf.placeholder(name='episode_duration_input') dataset = pf.placeholder(name='entire_dataset_input') action = pf.placeholder(name='incoming_mdp_action') # Connect nodes, define runtime logic: episode = node['episode'](input_state=dataset, reset=is_reset, sample_length=episode_duration) market_state = node['market'](input_state=episode, reset=is_reset) orders = node['order'](input_state=action, reset=is_reset) portfolio_state = node['manager'](input_state=market_state, reset=is_reset, orders=orders) reward = node['reward'](input_state=portfolio_state, reset=is_reset) done = node['done'](input_state=market_state) # Filter out all irrelevant fields to get observation tensor(s): observation_state = { 'market_features': market_state['features'], 'value': portfolio_state['portfolio_value'], 'reward': reward, } # Service node, processes dictionaries, dataframes # and emits numpy arrays ready to feed to estimator: observation_state = node['observation'](input_state=observation_state) # Group graph input and output handles: graph_input = dict(reset=is_reset, dataset=dataset, episode_duration=episode_duration, action=action) graph_output = dict( observation=observation_state, reward=reward, done=done, ) return graph, graph_input, graph_output
def test_stack_trace(): with pf.Graph() as graph: a = pf.placeholder() b = pf.placeholder() c = a / b try: graph(c, {a: 1, b: 0}) raise RuntimeError("did not raise ZeroDivisionError") except ZeroDivisionError as ex: assert isinstance(ex.__cause__, pf.EvaluationError)
def test_try(context, expected): finally_reached = [] with pf.Graph() as graph: a = pf.placeholder('a') b = pf.placeholder('b') c = pf.try_(a / b, [(ZeroDivisionError, 'zero-division')], pf.func_op(lambda: finally_reached.append('done'))) assert graph(c, context) == expected assert finally_reached
def test_conditional(): with pf.Graph() as graph: x = pf.constant(4) y = pf.placeholder(name='y') condition = pf.placeholder(name='condition') z = pf.conditional(condition, x, y) assert graph(z, condition=True) == 4 assert graph(z, condition=False, y=5) == 5 # We expect a value error if we evaluate the other branch without a placeholder with pytest.raises(ValueError): graph(z, condition=False)
def test_conditional_with_length(): def f(a): return a, a with pf.Graph() as graph: x = pf.constant(4) y = pf.placeholder(name='y') condition = pf.placeholder(name='condition') z1, z2 = pf.conditional(condition, pf.func_op(f, x), pf.func_op(f, y), length=2) assert graph([z1, z2], condition=True) == (4, 4) assert graph([z1, z2], condition=False, y=5) == (5, 5)
def test_cache_file(): with tempfile.TemporaryDirectory() as tmpdir: with pf.Graph() as graph: a = pf.placeholder() b = pf.placeholder() c = pf.cache_file(a + b, f"{tmpdir}/%s.pkl") assert graph(c, {a: 5, b: 9}) == 14 filename = f"{tmpdir}/{hash((5, 9))}.pkl" assert os.path.isfile(filename) # Move the file to a different location and ensure the value is loaded os.rename(filename, f"{tmpdir}/{hash((8, 1))}.pkl") assert graph(c, {a: 8, b: 1}) == 14
def test_cache_file(): make_tmpdir = Py2TemporaryDirectory if six.PY2 else tempfile.TemporaryDirectory with make_tmpdir() as tmpdir: with pf.Graph() as graph: a = pf.placeholder() b = pf.placeholder() c = pf.cache_file(a + b, "{}/%s.pkl".format(tmpdir)) assert graph(c, {a: 5, b: 9}) == 14 filename = "{}/{}.pkl".format(tmpdir, hash((5, 9))) assert os.path.isfile(filename) # Move the file to a different location and ensure the value is loaded os.rename(filename, "{}/{}.pkl".format(tmpdir, hash((8, 1)))) assert graph(c, {a: 8, b: 1}) == 14
def test_context(): with pf.Graph() as graph: a = pf.placeholder(name='a') b = pf.placeholder(name='b') c = pf.placeholder(name='c') x = a * b + c actual = graph(x, {a: 4, 'b': 7}, c=9) assert actual == 37 # ~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~ # @slipform() def graph(a, b, c): x = a * b + c actual = graph('x', a=4, b=7, c=9) assert actual == 37
def _(x, lhs=None, graph=None): name = resolve_name(x) if name.startswith('_'): if name in graph.operations: return graph.operations[name] else: return pf.placeholder(name) elif lhs == name: name = '_' + name if name in graph.operations: return graph.operations[name] else: return pf.placeholder(name) else: return LazySymbol(name, graph=graph)
def test_contains(): with pf.Graph() as graph: test = pf.placeholder() alphabet = pf.constant('abc') contains = pf.contains(alphabet, test) assert graph(contains, {test: 'a'}) assert not graph(contains, {test: 'x'})
def test_assert_with_value(): with pf.Graph() as graph: x = pf.placeholder(name='x') assertion = pf.assert_(x < 10, value=2 * x) assert graph(assertion, x=9) == 18 with pytest.raises(AssertionError): graph(assertion, x=11)
def test_duplicate_value(): with pf.Graph() as graph: a = pf.placeholder('a') with pytest.raises(ValueError): graph([], {a: 1}, a=1) with pytest.raises(ValueError): graph([], {a: 1, 'a': 1})
def test_graph_pickle(): with pf.Graph() as graph: x = pf.placeholder('x') y = pf.pow_(x, 3, name='y') _x = random.uniform(0, 1) desired = graph('y', x=_x) pickled = pickle.dumps(graph) graph = pickle.loads(pickled) actual = graph('y', x=_x) assert desired == actual
def workers(broker): with pf.Graph() as graph: x = pf.placeholder('x') y = pf.placeholder('y') sleep = pf.func_op(time.sleep, pf.func_op(random.uniform, 0, .1)) with pf.control_dependencies([sleep]): (x / y).set_name('z') # Can't pickle entire modules pf.constant(pf).set_name('not_pickleable') # Create multiple workers _workers = [] while len(_workers) < 10: worker = pfmq.Worker.from_graph(graph, broker.backend_address) worker.run_async() _workers.append(worker) yield _workers # Shut down all the workers for worker in _workers: worker.cancel()
def test_invalid_fetches(): with pf.Graph(): a = pf.placeholder() graph = pf.Graph() with pytest.raises(RuntimeError): graph(a) with pytest.raises(KeyError): graph('a') with pytest.raises(ValueError): graph(123)
def _(ass, graph=None): lhs, rhs = ass.target, ass.value lhs_name = resolve_name(lhs) phname = '_' + lhs_name if phname not in graph.operations: old = pf.placeholder(phname) else: old = graph.operations[phname] (old + unwind(rhs, lhs=lhs_name, graph=graph)).set_name(lhs_name) return lhs_name
def test_try_callback(): with pf.Graph() as graph: a = pf.placeholder('a') b = pf.assert_((a > 0).set_name('condition'), value=a, name='b') c = pf.try_( b, [(AssertionError, (pf.constant(41, name='41') + 1).set_name('alternative'))]) tracer = pf.Profiler() graph(c, {a: 3}, callback=tracer) == 3 assert len(tracer.times) == 3 graph(c, {a: -2}, callback=tracer) == 42 assert len(tracer.times) == 5
def test_conditional_callback(): with pf.Graph() as graph: a = pf.constant(1) b = pf.constant(2) c = pf.placeholder() d = pf.conditional(c, a, b + 1) # Check that we have "traced" the correct number of operation evaluations tracer = pf.Profiler() assert graph(d, {c: True}, callback=tracer) == 1 assert len(tracer.times) == 2 tracer = pf.Profiler() assert graph(d, {c: False}, callback=tracer) == 3 assert len(tracer.times) == 3
def test_contains(): with pf.Graph() as graph: test = pf.placeholder() alphabet = pf.constant('abc') contains = pf.contains(alphabet, test) assert graph(contains, {test: 'a'}) assert not graph(contains, {test: 'x'}) # ~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~ # @slipform() def graph(test): alphabet = 'abc' contains = test in alphabet assert graph('contains', {'test': 'a'}) assert not graph('contains', {'test': 'x'})
def test_profiling(): with pf.Graph() as graph: duration = pf.placeholder('duration') # Use a conditional to make sure we also test the evaluation of conditionals with callbacks positive_duration = pf.conditional(duration < 0, 0, duration) sleep = pf.import_('time').sleep(positive_duration) callback = pf.Profiler() graph(sleep, callback=callback, duration=0.5) assert callback.times[sleep] > 0.5 # We never evaluate duration because it is already provided in the context assert duration not in callback.times # Check that the slowest operation comes first callback_str = str(callback) assert callback_str.startswith(str(sleep)) assert len(callback_str.split('\n')) == 5
def test_assert_with_dependencies(message): with pf.Graph() as graph: x = pf.placeholder(name='x') if message: assertion = pf.assert_(x < 10, message, 10, x) else: assertion = pf.assert_(x < 10) with pf.control_dependencies([assertion]): y = 2 * x assert len(y.dependencies) == 1 assert graph(y, x=9) == 18 with pytest.raises(AssertionError) as exc_info: graph(y, x=11) if message: exc_info.match(message % (10, 11))
def test_unpack_without_length(): with pytest.raises(TypeError): with pf.Graph(): _1, _2 = pf.placeholder()
def test_bool(): with pf.Graph() as graph: a = pf.placeholder() assert a