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)