def vertex_labels(self, target=4, return_name=False): rawlb, raw_names = self.__vertex_raw_labels(return_name=True) if target == 'raw': lb = rawlb label_names = raw_names else: lb = rawlb.copy() # TODO: make sure the order of lb (i.e. order of feat) is 0:nnodes def mapper(x): if x == target: return 1 elif x == -1: return 0 else: return -1 lb = np.vectorize(mapper)(lb) label_names = {-1: 'Others', 1: raw_names[target], 0: 'Unknown'} assert lb.shape == (len(self.gtgraphs), self.gtgraphs['any'].num_vertices()), \ "{}, ({}, {})".format(lb.shape, len(self.gtgraphs), self.gtgraphs['any'].num_vertices()) if return_name: return utils.OffsetList(self.localstep, len(lb), lb, copy=False), label_names else: return utils.OffsetList(self.localstep, len(lb), lb, copy=False)
def _load_graph(self, step): curunit = self._time2unit(self.step2time(step)) graphs = [] for u in range(curunit, curunit + self.stepsize): graphs.append(self._load_unit_graph(self._unit2time(u))) return self._merge_unit_graphs( utils.OffsetList(0, self.stepsize, graphs, copy=False), step)
def slim_storage(self, keep_size): startstep = min(self._history[-1][1] - keep_size, self._history[-1][0]) startstep = max(startstep, self._sequence.offset) self._sequence = utils.OffsetList(startstep, self._history[-1][1] - startstep, self._sequence[startstep:], copy=False, managed=True)
def __init__(self, **kwargs): self._pos = None self._pos_range = [-1, 1] self._neg = None self._valid = None self._negdup = kwargs.get('negdup', 1) self.__enable_cache = kwargs.get('replace_cache', False) self._replace_cache = utils.OffsetList(self.dataset.gtgraphs.offset, len(self.dataset.gtgraphs), lambda x: None)
def __init__(self, **kwargs): super(Sampler, self).__init__(**kwargs) self.__enable_cache = kwargs.get('triangle_cache', False) self._triangular_cache = utils.OffsetList(self.dataset.localstep, self.dataset.nsteps, lambda x: None) # self._triangular_cache = [None for _ in range(len(self.dataset.gtgraphs))] # self._edge_cache = [None for _ in range(len(self.dataset.gtgraphs))] self.__nbr_cache = [{} for _ in range(self.dataset.nsteps)] self.__succ_trial, self.__all_trial = 10, 12
def __init__(self, inittime, localtime, nsteps, stepsize, stepstride, stepoffset): # Timeline anchors the starting time while DynamicGraph bounds the ending Timeline.__init__(self, inittime, stepsize, stepstride) self.localstep = self.time2step(localtime) + stepoffset self.localunit = self._step2unit(self.localstep) if self._step2unit(self.localstep) < self._time2unit(inittime): raise RuntimeError( "localstep smaller than initial step, with inittime={}, localtime={}," " step_stride={}, step_offset={}".format( inittime, localtime, stepstride, stepoffset)) self.nsteps = nsteps self.nunits = self._step2unit(self.localstep + self.nsteps - 1) - self.localunit + self.stepsize # we use mygraph as main data, with supportive gtgraphs available self._mygraphs = utils.OffsetList(self.localstep, self.nsteps, lambda step: self._load_graph(step)) self._gtgraphs = utils.OffsetList( self.localstep, self.nsteps, lambda i: gconv.mygraph2graphtool(self._mygraphs[i], convert_to='undirected'))
def __init__(self, **flowargs): self.__arg_names = ['embdim', 'beta', 'trainmod', 'datasetmod'] self.__args = {k: flowargs.get(k, None) for k in self.__arg_names} # self.__args = {'embdim': embdim, 'beta': beta, 'trainmod': trainmod, 'datasetmod': datasetmod} self._history = [] self._sequence = utils.OffsetList( 0, 0, [], managed=True) # to make the sequence managed by OffsetList self._tagged = {} self.__training = False self.__curbegin = None self.__curend = None
def load_archive(self, ar, copy=True, name=None): if self.__training: raise RuntimeError( "archive should be loaded before training starts") if name is None: prefix = 'TrainFlow' else: prefix = '{}_TrainFlow'.format(name) super(TrainFlow, self).load_archive(ar, copy=copy, name=name) self._sequence, self._tagged = utils.OffsetList(*ar['{}_sequence'.format(prefix)], copy=copy, managed=True), \ ar['{}_tagged'.format(prefix)] self._history = ar['{}_history'.format(prefix)] print("[debug] train history: {}".format(self._history)) self.__check_flowargs(ar['{}_args'.format(prefix)]) if copy: self._history = deepcopy(self._history)
def start_training(self, begin, end): self.__training = True self.__curbegin, self.__curend = begin, end if len(self._history) == 0: # pretrain self._sequence = utils.OffsetList(begin, 0, [], managed=True) self.__add_history([begin, end])
def clear(self): self._history = [] self._sequence = utils.OffsetList(0, 0, [], managed=True) self._tagged = {} self.__training = False