def apply(t: Table) -> Table:
return t.update("f = a + b")
def learn(table: Table = None,
model_func: Callable = None,
inputs: List[Input] = [],
outputs: List[Output] = [],
batch_size: int = None) -> Table:
""" Learn gathers data from multiple rows of the input table, performs a calculation, and scatters values from the
calculation into an output table. This is a common computing paradigm for artificial intelligence, machine learning,
and deep learning.
Args:
table (Table): the Deephaven table to perform computations on.
model_func (Callable): function that performs computations on the table.
inputs (List[Input]): list of Input objects that determine how data gets extracted from the table.
outputs (List[Output]): list of Output objects that determine how data gets scattered back into the results table.
batch_size (int): maximum number of rows for which model_func is evaluated at once.
Returns:
a Table with added columns containing the results of evaluating model_func.
Raises:
DHError
"""
try:
_validate(inputs, outputs, table)
if batch_size is None:
raise ValueError(
"Batch size cannot be inferred. Please specify a batch size.")
# TODO: When ticket #1072 is resolved, the following code should be replaced with
# Globals["__computer"] = _Computer_(table, model_func, [input.input for input in inputs], batch_size)
# and remove from globals at the end of function
(jpy.get_type("io.deephaven.engine.table.lang.QueryScope").addParam(
"__computer",
_JLearnComputer(table.j_table, model_func,
[input_.input for input_ in inputs], batch_size)))
future_offset = _create_non_conflicting_col_name(
table, "__FutureOffset")
clean = _create_non_conflicting_col_name(table, "__CleanComputer")
if outputs is not None:
__scatterer = _JLearnScatterer(
[output.output for output in outputs])
# TODO: Similarly at resolution of #1072, replace the following code with
# Globals["__scatterer"] = __scatterer
# and remove from Globals at end of function
jpy.get_type("io.deephaven.engine.table.lang.QueryScope").addParam(
"__scatterer", __scatterer)
return (table.update(formulas=[
f"{future_offset} = __computer.compute(k)",
]).update(formulas=[
__scatterer.generateQueryStrings(f"{future_offset}"),
]).update(formulas=[
f"{clean} = __computer.clear()",
]).drop_columns(cols=[
f"{future_offset}",
f"{clean}",
]))
result = _create_non_conflicting_col_name(table, "__Result")
return (table.update(formulas=[
f"{future_offset} = __computer.compute(k)",
f"{result} = {future_offset}.getFuture().get()",
f"{clean} = __computer.clear()",
]).drop_columns(cols=[
f"{future_offset}",
f"{clean}",
f"{result}",
]))
except Exception as e:
raise DHError(e, "failed to complete the learn function.") from e
def transform_func(t: Table) -> Table:
return t.update("f = a + b")