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
