def get(self): """ Get sampled `SubGraph`. Return: An `SubGraph` object. Raise: `graphlearn.OutOfRangeError` """ state = self._graph.node_state.get(self._seed_type) req = pywrap.new_subgraph_request( self._seed_type, self._nbr_type, strategy2op(self._strategy, "SubGraphSampler"), self._batch_size, state) res = pywrap.new_subgraph_response() status = self._client.sample_subgraph(req, res) if not status.ok(): self._graph.node_state.inc(self._seed_type) else: node_ids = pywrap.get_node_set(res) row_idx = pywrap.get_row_idx(res) col_idx = pywrap.get_col_idx(res) edge_ids = pywrap.get_edge_set(res) pywrap.del_op_response(res) pywrap.del_op_request(req) errors.raise_exception_on_not_ok_status(status) nodes = self._graph.get_nodes(self._node_type, node_ids) return SubGraph(np.stack([row_idx, col_idx], axis=0), nodes, Edges(edge_ids=edge_ids))
def negative_sampler(self, object_type, expand_factor, strategy="random", conditional=False, **kwargs): """Sampler for sampling negative dst nodes of the given src nodes with edge_type. Args: edge_type (string): Sample negative nodes of the source node with specified edge_type. strategy (string or list): Indicates how to sample negative edges, "random" and "in_degree" are supported. "random": randomly sample negative nodes. "in_degree": sample negative nodes by the in degree of the target nodes. expand_factor (int): Indicates how many negatives to sample for one node. conditional(bool): Indicates whether sample under condition. Return: A 'NegativeSampler' object. """ if not conditional: sampler = utils.strategy2op(strategy, "NegativeSampler") return getattr(samplers, sampler)(self, object_type, expand_factor, strategy=strategy) else: return getattr(samplers, "ConditionalNegativeSampler")(self, object_type, expand_factor, strategy=strategy, **kwargs)
def edge_sampler(self, edge_type, batch_size=64, strategy="by_order", mask=utils.Mask.NONE): """Sampler for sample one type of edges. Args: edge_type (string): Sample edges of the edge_type. batch_size (int, Optional): How many edges will be returned for get(). strategy (string, Optional):Indicates how to sample edges, "by_order", "random" and "shuffle" are supported. "by_order": Get edge by order. Raise `graphlearn.OutOfRangeError` when all the edges are visited. Each edge will be visited and only be visited once. "random": Randomly get edges. No visting state will be hold, so out of range will not happened. "shuffle": Get edges with shuffle. Raise `graphlearn.OutOfRangeError` when all the edges are visited. Each edge will be visited and only be visited once. Return: An `EdgeSampler` object. """ sampler = utils.strategy2op(strategy, "EdgeSampler") return getattr(samplers, sampler)(self, edge_type, batch_size=batch_size, strategy=strategy, mask=mask)
def neighbor_sampler(self, meta_path, expand_factor, strategy="random"): """ Sampler for sample neighbors and edges along a meta path. The neighbors of the seed nodes and edges between seed nodes and neighbors are called layer. Args: meta_path (list): A list of edge_type. expand_factor (int | list): Number of neighbors sampled from all the dst nodes of the node along the corresponding meta_path. int: indicates the number of neighbors sampled for each node. list of int: indicates the number of neighbors sampled for each node of each hop, and length of expand_factor is same with length of meta_path. strategy (string): Indicates how to sample meta paths, "edge_weight", "random", "in_degree" are supported. "edge_weight": sample neighbor nodes by the edge weight between seed node and dst node. "random": randomly sample neighbor nodes. "in_degree": sample neighbor nodes by the in degree of the neighbors. Return: A 'NeighborSampler' object. """ sampler = utils.strategy2op(strategy, "NeighborSampler") return getattr(samplers, sampler)(self, meta_path, expand_factor, strategy=strategy)
def _make_req(self, index, src_ids): """ Make rpc request. """ if len(self._meta_path) > len(self._expand_factor): raise ValueError("The length of meta_path must be same with hop count.") sampler = strategy2op(self._strategy[index], "Sampler") req = pywrap.new_sampling_request( self._meta_path[index], sampler, self._expand_factor[index], 0) pywrap.set_sampling_request(req, src_ids) return req
def _make_req(self, index, src_ids): """ Make rpc request. """ if len(self._meta_path) > len(self._expand_factor): raise ValueError("input too many meta_path, and can not decide each hops") sampler = strategy2op(self._strategy[index], "Sampler") req = pywrap.new_sampling_request( self._meta_path[index], sampler, self._expand_factor[index]) pywrap.set_sampling_request(req, src_ids) return req
def _agg(self, func, segment_ids, num_segments): req = pywrap.new_agg_nodes_req(self._type, utils.strategy2op(func, "Aggregator")) pywrap.set_agg_nodes_req(req, self._ids.flatten(), np.array(segment_ids, dtype=np.int32), num_segments) res = pywrap.new_agg_nodes_res() raise_exception_on_not_ok_status(self.graph.get_client().agg_nodes( req, res)) agged = pywrap.get_node_agg_res(res) pywrap.del_agg_nodes_res(res) pywrap.del_agg_nodes_req(req) return agged
def _agg(self, func, segment_ids, num_segments): req = pywrap.new_aggregating_request( self._type, utils.strategy2op(func, "Aggregator")) pywrap.set_aggregating_request(req, self._ids.flatten(), np.array(segment_ids, dtype=np.int32), num_segments) res = pywrap.new_aggregating_response() status = self.graph.get_client().agg_nodes(req, res) if status.ok(): agged = pywrap.get_aggregating_nodes(res) pywrap.del_op_response(res) pywrap.del_op_request(req) errors.raise_exception_on_not_ok_status(status) return agged
def by(self, strategy): self._strategy = strategy if self._op_name == "NegativeSampler": assert strategy in [ "random", "in_degree", "conditional", "node_weight" ] elif self._op_name == "Sampler": assert strategy in \ ["random", "topk", "in_degree", "edge_weight", "full"] else: raise ValueError( "`by(strategy)` can only be used after`sample(count)`") self._sparse = (strategy == "full") self._op_name = strategy2op(self._strategy, self._op_name) self._add_param(pywrap.kStrategy, self._op_name) return self
def node_sampler(self, t, batch_size=64, strategy="by_order", node_from=pywrap.NodeFrom.NODE, mask=utils.Mask.NONE): """ Sampler for sample one type of nodes. Args: t (string): Sample nodes of the given type `t`. `t` can be node type which indicates that sampling node dat, otherwise, `t` can be edge type which indicate that sampling source node or dst node of edge data. batch_size (int, Optional): How many nodes will be returned for get(). strategy (string, Optional): Indicates how to sample edges, "by_order", "random" and "shuffle" are supported. "by_order": Get node by order. Raise `graphlearn.OutOfRangeError` when all the nodes are visited. Each node will be visited and only be visited once. "random": Randomly get nodes. No visting state will be hold, so out of range will not happened. "shuffle": Get nodes with shuffle. Raise `graphlearn.OutOfRangeError` when all the nodes are visited. Each node will be visited and only be visited once. node_from (graphlearn.NODE | graphlearn.EDGE_SRC | graphlearn.EDGE_DST): `graphlearn.NODE`: get node from node data, and `t` must be a node type. `graphlearn.EDGE_SRC`: get node from source node of edge data, and `t` must be an edge type. `graphlearn.EDGE_DST`: get node from destination node of edge data, and `t` must be an edge type. Return: A `NodeSampler` object. """ sampler = utils.strategy2op(strategy, "NodeSampler") return getattr(samplers, sampler)(self, t, batch_size=batch_size, strategy=strategy, node_from=node_from, mask=mask)
def negative_sampler(self, object_type, expand_factor, strategy="random"): """Sampler for sample negative dst nodes of the given src nodes with edge_type. Args: edge_type (string): Sample negative nodes of the source node with specified edge_type. strategy (string or list): Indicates how to sample negative edges, "random" and "in_degree" are supported. "random": randomly sample negative nodes. "in_degree": sample negative nodes by the in degree of the target nodes. expand_factor (int): Indicates how many negatives to sample for one node. Return: A 'NegativeSampler' object. """ sampler = strategy2op(strategy, "NegativeSampler") return getattr(samplers, sampler)(self, object_type, expand_factor, strategy=strategy)
def subgraph_sampler(self, seed_type, nbr_type, batch_size=64, strategy="random_node"): """Sampler for sample SubGraph. Args: graph (`Graph` object): The graph which sample from. seed_type (string): Sample seed type, either node type or edge type. nbr_type (string): Neighbor type of seeds nodes/edges. batch_size (int): How many nodes will be returned for `get()`. strategy (string, Optional): Sampling strategy. "random_node". Return: An `SubGraphSampler` object. """ sampler = utils.strategy2op(strategy, "SubGraphSampler") return getattr(samplers, sampler)(self, seed_type, nbr_type, batch_size=batch_size, strategy=strategy)
def _make_req(self, ids): sampler = strategy2op(self._strategy, "NegativeSampler") req = pywrap.new_sampling_request(self._object_type, sampler, self._expand_factor) pywrap.set_sampling_request(req, ids) return req
def _make_req(self, ids): sampler = strategy2op(self._strategy, "NegativeSampler") req = pywrap.new_nbr_req(self._edge_type, sampler, self._expand_factor) pywrap.set_nbr_req(req, ids) return req