def add_boolean_proxy_for(self, label: str, shape: Collection[int] = None) -> Vertex:
"""
Creates a proxy vertex for the given label and adds to the sequence item
"""
if shape is None:
return Vertex._from_java_vertex(self.unwrap().addBooleanProxyFor(_VertexLabel(label).unwrap()))
else:
return Vertex._from_java_vertex(self.unwrap().addBooleanProxyFor(_VertexLabel(label).unwrap(), shape))
def proxy_label_for(label: str) -> str:
"""
>>> Sequence.proxy_label_for("foo")
'proxy_for.foo'
"""
label_java = _VertexLabel(label).unwrap()
proxy_label_java = k.jvm_view().SequenceBuilder.proxyLabelFor(label_java)
return proxy_label_java.getQualifiedName()
def __check_output_equals(sequence: Sequence, label: str,
desired_output: float) -> None:
sequence_unwrapped = sequence.unwrap()
x1_result = sequence_unwrapped.getLastItem().get(
_VertexLabel(label).unwrap())
assert len(x1_result.getShape()) == 0
print(x1_result.getValue())
print(x1_result.getValue().scalar())
assert x1_result.getValue().scalar() == desired_output
def __init__(self,
factories: Union[Callable[..., None], Iterable[Callable[..., None]]] = None,
count: int = None,
name: str = None,
data_generator: Iterator[Dict[str, Any]] = None,
initial_state: Dict[str, vertex_constructor_param_types] = None):
builder = k.jvm_view().SequenceBuilder().named(name)
if initial_state is not None:
initial_state_java = k.to_java_map(
{_VertexLabel(k): cast_to_double_vertex(v).unwrap() for (k, v) in initial_state.items()})
vertex_dictionary = k.jvm_view().SimpleVertexDictionary.backedBy(initial_state_java)
builder = builder.withInitialState(vertex_dictionary)
if count is None and data_generator is None:
raise ValueError(
"Cannot create a sequence of an unknown size: you must specify either a count of a data_generator")
elif count is not None and data_generator is not None:
raise ValueError("If you pass in a data_generator you cannot also pass in a count")
elif factories is None:
raise ValueError("You must provide a value for the 'factories' input")
if not isinstance(factories, CollectionsIterable):
factories = [factories]
if count is not None:
functions = [Consumer(partial(lambda f, p: f(SequenceItem(p)), f)) for f in factories]
java_functions = ListConverter().convert(functions, k._gateway._gateway_client)
builder = builder.count(count).withFactories(java_functions)
if data_generator is not None:
bifunctions = [BiConsumer(partial(lambda f, p, data: f(SequenceItem(p), data), f)) for f in factories]
java_bifunctions = ListConverter().convert(bifunctions, k._gateway._gateway_client)
data_generator_java = (k.to_java_map(m) for m in data_generator)
builder = builder.fromIterator(JavaIterator(data_generator_java)).withFactories(java_bifunctions)
sequence = builder.build()
super().__init__(sequence)
def get_double_model_output_vertex(self, label: str) -> Vertex:
label_unwrapped = _VertexLabel(label).unwrap()
result = self.unwrap().getDoubleModelOutputVertex(label_unwrapped)
return Vertex._from_java_vertex(result)
def __update_unwrapped_vertices(vertices_wrapped: Dict[str, Vertex],
vertices_unwrapped: JavaMap) -> None:
for k, v in vertices_wrapped.items():
vertices_unwrapped[_VertexLabel(k).unwrap()] = v.unwrap()
def __to_java_map(inputs: Dict[str, Vertex]) -> JavaMap:
inputs_with_wrapped_keys = {
_VertexLabel(k): v
for k, v in inputs.items()
}
return context.to_java_map(inputs_with_wrapped_keys)
def IntegerProxy(shape: Collection[int], label: str) -> Vertex:
return Integer(context.jvm_view().IntegerProxyVertex, label, cast_to_long_array(shape), _VertexLabel(label))
def DoubleProxy(shape: Collection[int], label: str) -> Vertex:
return Double(context.jvm_view().DoubleProxyVertex, label, cast_to_long_array(shape), _VertexLabel(label))
def BooleanProxy(shape: Collection[int], label: str) -> Vertex:
return Boolean(context.jvm_view().BooleanProxyVertex, label, cast_to_long_array(shape), _VertexLabel(label))
def get(self, label: str) -> Vertex:
return Vertex._from_java_vertex(self.unwrap().get(_VertexLabel(label).unwrap()))
def add(self, vertex: Vertex, label: Optional[str] = None) -> None:
if label is None:
self.unwrap().add(vertex.unwrap())
else:
self.unwrap().add(_VertexLabel(label).unwrap(), vertex.unwrap())
def set_label(self, label: Optional[str]) -> None:
if label is None:
raise ValueError("label cannot be None.")
self.unwrap().setLabel(_VertexLabel(label).unwrap())