def ports_setup_from_types(self, types):
port_type = PortsSpecSchema.port_type
input_ports = {self.INPUT_PORT_NAME: {port_type: types}}
output_ports = {
self.OUTPUT_PORT_NAME_TRAIN: {
port_type: types
},
self.OUTPUT_PORT_NAME_TEST: {
port_type: types
}
}
input_connections = self.get_connected_inports()
if self.INPUT_PORT_NAME in input_connections:
determined_type = input_connections[self.INPUT_PORT_NAME]
# connected
return NodePorts(
inports={self.INPUT_PORT_NAME: {
port_type: determined_type
}},
outports={
self.OUTPUT_PORT_NAME_TEST: {
port_type: determined_type
},
self.OUTPUT_PORT_NAME_TRAIN: {
port_type: determined_type
}
})
else:
return NodePorts(inports=input_ports, outports=output_ports)
def ports_setup_from_types(self, types):
port_type = PortsSpecSchema.port_type
input_ports = {
self.INPUT_PORT_NAME: {
port_type: types
},
self.INPUT_PORT_MODEL_NAME: {
port_type: [Booster, dict]
}
}
output_ports = {
self.OUTPUT_PORT_NAME: {
port_type: types
}
}
input_connections = self.get_connected_inports()
if self.INPUT_PORT_NAME in input_connections:
determined_type = input_connections[self.INPUT_PORT_NAME]
input_ports.update({self.INPUT_PORT_NAME:
{port_type: determined_type}})
output_ports.update({self.OUTPUT_PORT_NAME:
{port_type: determined_type}})
return NodePorts(inports=input_ports,
outports=output_ports)
else:
return NodePorts(inports=input_ports, outports=output_ports)
def ports_setup_from_types(self, types):
port_type = PortsSpecSchema.port_type
input_ports = {
self.INPUT_PORT_NAME: {
port_type: types
},
self.INPUT_MAP_NAME: {
port_type: StockMap
}
}
output_ports = {
self.OUTPUT_PORT_NAME: {
port_type: types
},
self.OUTPUT_ASSET_NAME: {
port_type: str
}
}
input_connections = self.get_connected_inports()
if self.INPUT_PORT_NAME in input_connections:
determined_type = input_connections[self.INPUT_PORT_NAME]
input_ports.update({self.INPUT_PORT_NAME:
{port_type: determined_type}})
output_ports.update({self.OUTPUT_PORT_NAME: {
port_type: determined_type}})
# connected
return NodePorts(inports=input_ports,
outports=output_ports)
else:
return NodePorts(inports=input_ports, outports=output_ports)
def ports_setup(self):
cache_key, task_graph, replacementObj = self._compute_hash_key()
if cache_key in CACHE_PORTS:
# print('cache hit')
return CACHE_PORTS[cache_key]
inports = {}
outports = {}
if task_graph:
task_graph.build(replace=replacementObj)
def inputNode_fun(inputNode, in_ports):
inport = {}
before_fix = inputNode.ports_setup().inports
for key in before_fix.keys():
if key in in_ports:
inport[key] = before_fix[key]
inports.update(fix_port_name(inport, inputNode.uid))
def outNode_fun(outNode, out_ports):
ouport = {}
before_fix = outNode.ports_setup().outports
for key in before_fix.keys():
if key in out_ports:
ouport[key] = before_fix[key]
outports.update(fix_port_name(ouport, outNode.uid))
self._make_sub_graph_connection(task_graph,
inputNode_fun, outNode_fun)
output_port = NodePorts(inports=inports, outports=outports)
CACHE_PORTS[cache_key] = output_port
return output_port
def ports_setup(self):
task_graph = self.task_graph
inports = {}
outports = {}
if task_graph:
def inputNode_fun(inputNode, in_ports):
inport = {}
before_fix = inputNode.ports_setup().inports
for key in before_fix.keys():
if key in in_ports:
inport[key] = before_fix[key]
inports.update(fix_port_name(inport, inputNode.uid))
def outNode_fun(outNode, out_ports):
ouport = {}
before_fix = outNode.ports_setup().outports
for key in before_fix.keys():
if key in out_ports:
ouport[key] = before_fix[key]
outports.update(fix_port_name(ouport, outNode.uid))
self._make_sub_graph_connection(task_graph, inputNode_fun,
outNode_fun)
output_port = NodePorts(inports=inports, outports=outports)
return output_port
def ports_setup(self):
types = [cudf.DataFrame, DaskDataFrame, pd.DataFrame]
port_type = PortsSpecSchema.port_type
input_ports = {
self.SHAP_INPUT_PORT_NAME: {
port_type: types
},
self.MODEL_INPUT_PORT_NAME: {
port_type: [Booster, dict]
},
self.DATA_INPUT_PORT_NAME: {
port_type: types
}
}
output_ports = {self.OUTPUT_PORT_NAME: {port_type: Figure}}
input_connections = self.get_connected_inports()
if (self.SHAP_INPUT_PORT_NAME in input_connections):
determined_type = input_connections[self.SHAP_INPUT_PORT_NAME]
input_ports[self.SHAP_INPUT_PORT_NAME] = {
port_type: determined_type
}
if (self.DATA_INPUT_PORT_NAME in input_connections):
determined_type = input_connections[self.DATA_INPUT_PORT_NAME]
input_ports[self.DATA_INPUT_PORT_NAME] = {
port_type: determined_type
}
if (self.MODEL_INPUT_PORT_NAME in input_connections):
determined_type = input_connections[self.MODEL_INPUT_PORT_NAME]
input_ports[self.MODEL_INPUT_PORT_NAME] = {
port_type: determined_type
}
ports = NodePorts(inports=input_ports, outports=output_ports)
return ports
def ports_setup(self):
port_type = PortsSpecSchema.port_type
if self.instance is not None:
inports = self.instance.input_ports
outports = self.instance.output_ports
else:
try:
p_inports = self.instanceClass.input_ports
p_outports = self.instanceClass.output_ports
feeder = FeedProperty(self.conf)
inports = p_inports.fget(feeder)
outports = p_outports.fget(feeder)
except Exception:
inports = None
outports = None
o_inports = {}
o_outports = {}
if inports is not None:
for k in inports.keys():
o_inports[k] = {port_type: NmTensor}
if outports is not None:
for k in outports.keys():
o_outports[k] = {port_type: NmTensor}
if issubclass(self.instanceClass, TrainableNM):
# added the port for tying the weights
o_inports[self.INPUT_NM] = {port_type: TrainableNM}
o_outports[self.OUTPUT_NM] = {port_type: TrainableNM}
elif issubclass(self.instanceClass, LossNM):
o_outports[self.OUTPUT_NM] = {port_type: LossNM}
elif issubclass(self.instanceClass, DataLayerNM):
o_outports[self.OUTPUT_NM] = {port_type: DataLayerNM}
return NodePorts(inports=o_inports, outports=o_outports)
def template_ports_setup(self, in_ports=None, out_ports=None):
if in_ports is not None:
self.__port_inports = in_ports
if out_ports is not None:
self.__port_outports = out_ports
return NodePorts(inports=self.__port_inports,
outports=self.__port_outports)
def ports_setup_different_output_type(self, out_type):
types = [cudf.DataFrame, dask_cudf.DataFrame, pd.DataFrame]
port_type = PortsSpecSchema.port_type
input_ports = {self.INPUT_PORT_NAME: {port_type: types}}
output_ports = {self.OUTPUT_PORT_NAME: {port_type: out_type}}
input_connections = self.get_connected_inports()
if (self.INPUT_PORT_NAME in input_connections):
determined_type = input_connections[self.INPUT_PORT_NAME]
# connected
return NodePorts(
inports={self.INPUT_PORT_NAME: {
port_type: determined_type
}},
outports=output_ports)
else:
return NodePorts(inports=input_ports, outports=output_ports)
def ports_setup(self):
ports = super().ports_setup()
port_type = PortsSpecSchema.port_type
inports = ports.inports
outports = ports.outports
for k in outports.keys():
outports[k][port_type] = [DaskDataFrame]
output_port = NodePorts(inports=inports, outports=outports)
return output_port
def ports_setup(self):
ports = super().ports_setup()
port_type = PortsSpecSchema.port_type
inports = ports.inports
outports = ports.outports
inports[self.INPUT_CONFIG] = {port_type: ConfData}
outports[self.OUTPUT_CONFIG] = {port_type: ConfData}
output_port = NodePorts(inports=inports, outports=outports)
return output_port
def ports_setup(self):
input_ports = {}
output_ports = {
CUDF_PORT_NAME: {
PortsSpecSchema.port_type: cudf.DataFrame
},
DASK_CUDF_PORT_NAME: {
PortsSpecSchema.port_type: dask_cudf.DataFrame
}
}
return NodePorts(inports=input_ports, outports=output_ports)
def ports_setup(self):
input_ports = {}
output_ports = {
STOCK_NAME_PORT_NAME: {
PortsSpecSchema.port_type: cudf.DataFrame
},
STOCK_MAP_PORT_NAME: {
PortsSpecSchema.port_type: StockMap
}
}
return NodePorts(inports=input_ports, outports=output_ports)
def ports_setup_from_types(self, types):
"""
overwrite the _PortTypesMixin.ports_setup_from_types
method, which is invoked by the _PortTypesMixin.ports_setup
"""
port_type = PortsSpecSchema.port_type
input_ports = {
self.INPUT_PORT_NAME: {
port_type: types
},
self.INPUT_NORM_MODEL_NAME: {
port_type: NormalizationData
}
}
output_ports = {
self.OUTPUT_PORT_NAME: {
port_type: types
},
self.OUTPUT_NORM_MODEL_NAME: {
port_type: NormalizationData
}
}
input_connections = self.get_connected_inports()
if self.INPUT_PORT_NAME in input_connections:
determined_type = input_connections[self.INPUT_PORT_NAME]
input_ports.update(
{self.INPUT_PORT_NAME: {
port_type: determined_type
}})
output_ports.update(
{self.OUTPUT_PORT_NAME: {
port_type: determined_type
}})
# connected
return NodePorts(inports=input_ports, outports=output_ports)
else:
return NodePorts(inports=input_ports, outports=output_ports)
def ports_setup_from_types(self, types):
port_type = PortsSpecSchema.port_type
input_ports = {
self.INPUT_PORT_LEFT_NAME: {
port_type: types
},
self.INPUT_PORT_RIGHT_NAME: {
port_type: types
}
}
output_ports = {self.OUTPUT_PORT_NAME: {port_type: types}}
input_connections = self.get_connected_inports()
if (self.INPUT_PORT_LEFT_NAME in input_connections
and self.INPUT_PORT_RIGHT_NAME in input_connections):
determined_type1 = input_connections[self.INPUT_PORT_LEFT_NAME]
determined_type2 = input_connections[self.INPUT_PORT_RIGHT_NAME]
if (determined_type1 == determined_type2):
# connected
return NodePorts(inports={
self.INPUT_PORT_LEFT_NAME: {
port_type: determined_type1
},
self.INPUT_PORT_RIGHT_NAME: {
port_type: determined_type1
}
},
outports={
self.OUTPUT_PORT_NAME: {
port_type: determined_type1
}
})
else:
return NodePorts(inports=input_ports, outports=output_ports)
else:
return NodePorts(inports=input_ports, outports=output_ports)
def ports_setup(self):
port_type = PortsSpecSchema.port_type
dy = PortsSpecSchema.dynamic
o_inports = {}
o_inports[self.INPUT_PORT_NAME] = {port_type: str}
o_inports['input_tensor'] = {port_type: NmTensor, dy: True}
# if hasattr(self, 'inputs'):
# for inp in self.inputs:
# if inp['to_port'] in (self.INPUT_PORT_NAME,):
# continue
# # TODO: Move TaskGrah rewire logic here instead of in
# # chartEngine.tsx ChartEngine._fixNeMoPorts
# o_inports[inp['from_node'].uid+'@'+inp['from_port']] = {
# port_type: NmTensor}
o_outports = {}
o_outports[self.OUTPUT_PORT_NAME] = {port_type: list}
return NodePorts(inports=o_inports, outports=o_outports)
def ports_setup(self):
port_type = PortsSpecSchema.port_type
input_connections = self.get_connected_inports()
if (self.INPUT_PORT_NAME in input_connections):
determined_type = input_connections[self.INPUT_PORT_NAME]
inports = {self.INPUT_PORT_NAME: {port_type: determined_type}}
else:
intypes = [
cudf.DataFrame, dask_cudf.DataFrame, pd.DataFrame,
DaskDataFrame
]
inports = {self.INPUT_PORT_NAME: {port_type: intypes}}
out_types = [cudf.DataFrame, pd.DataFrame]
outports = {self.OUTPUT_PORT_NAME: {port_type: out_types}}
return NodePorts(inports=inports, outports=outports)
def update(self):
'''Updates state of a Node with resolved ports and meta.
'''
ports_template = \
NodePorts(inports=self.__port_inports,
outports=self.__port_outports)
ports = self._resolve_ports(ports_template)
port_inports = ports.inports
meta_template = \
MetaData(inports=self.__meta_inports,
outports=self.__meta_outports)
meta = self._resolve_meta(meta_template, port_inports)
self.__port_inports = ports.inports
self.__port_outports = ports.outports
self.__meta_inports = meta.inports
self.__meta_outports = meta.outports
def ports_setup(self):
port_type = PortsSpecSchema.port_type
output_ports = {self.OUTPUT_PORT_NAME: {port_type: Figure}}
input_ports = {self.INPUT_PORT_NAME: {port_type: [Booster, dict]}}
return NodePorts(inports=input_ports, outports=output_ports)
def ports_setup(self):
# it will be something like { input_port: types }
return NodePorts(inports={}, outports=inports)
def ports_setup(self):
ports = NodePorts(inports=self.__port_inports,
outports=self.__port_outports)
return self.ports_setup_ext(ports)
