def __init__(self, dmax, nmax, emax, cmax, vmax, np_optimize):
"""PrimeGenerator __init__."""
if not igraph:
raise NotImplementedError('cannot use PrimeGenerator without igraph')
self.ve = VariableElimination(np_optimize)
# store parameters
transfer(self, locals(), ['dmax', 'nmax', 'emax', 'cmax', 'vmax',])
# setup N and e values to be used
self.ns = list(range(1, self.nmax+1))
self.emaxs = {n: min(self.emax, int(n/2*(n-1))) for n in self.ns}
self.esbyn = {n: list(range(n-1, self.emaxs[n]+1)) for n in self.ns}
# this could be more complicated than the same max for all (n,e)
self.dmaxs = {(n,e): self.dmax for n in self.ns for e in self.esbyn[n]}
# setup storage containers
quantities = ['simple_graphs_d', 'edges_d', 'chis_d', 'einpaths_d',
'einstrs_d', 'weights_d']
for q in quantities:
setattr(self, q, {(n,e): [] for n in self.ns for e in self.esbyn[n]})
# get simple connected graphs
self._generate_simple()
# get weighted connected graphs
self._generate_weights()
# flatten structures
self._flatten_structures()
def __init__(self, measure, beta=1, kappa=1, normed=None, coords=None, check_input=True):
r"""Processes inputs according to the measure choice and other options.
**Arguments**
- **measure** : _string_
- The string specifying the energy and angular measures to use.
- **beta** : _float_
- The angular weighting exponent $\beta$. Must be positive.
- **kappa** : {_float_, `'pf'`}
- If a number, the energy weighting exponent $\kappa$. If `'pf'`,
use $\kappa=v$ where $v$ is the valency of the vertex. `'pf'`
cannot be used with measure `'hadr'`. Only IRC-safe for `kappa=1`.
- **normed** : bool
- Whether or not to use normalized energies/transverse momenta. A
value of `None` defaults to `True`.
- **coords** : {`'ptyphim'`, `'epxpypz'`, `None`}
- Controls which coordinates are assumed for the input. If
`'ptyphim'`, the fourth column (the masses) is optional and
massless particles are assumed if it is not present. If `None`,
coords with be `'ptyphim'` if using a hadronic measure and
`'epxpypz'` if using the e+e- measure.
- **check_input** : bool
- Whether to check the type of input each time or assume the first
input type.
"""
# store parameters
transfer(self, locals(), ['measure', 'kappa', 'normed', 'coords', 'check_input'])
# check that coords is appropriate
if self.coords not in [None, 'epxpypz', 'ptyphim']:
raise ValueError('coords must be one of epxpypz, ptyphim, or None')
# verify beta
self.beta = float(beta)
self.half_beta = self.beta/2
assert self.beta > 0
# measure function is not yet set
self.need_meas_func = True
# handle kappa options
self._k_func = _kappa_func
if self.kappa == PF_MARKER:
# cannot subslice when kappa = pf
self.subslicing = False
# if normed was set to True, warn them about this
if self.normed:
warnings.warn('Normalization not supported when kappa=\'' + PF_MARKER + '\', '
'setting normed=False.')
self.normed = False
self._k_func = _pf_func
# normed default to True if it's None at this point
if self.normed is None:
self.normed = True
def __init__(self, edges, weights=None, einstr=None, einpath=None, k=None):
transfer(self, locals(), ['einstr', 'einpath', 'k'])
self.process_edges(edges, weights)
self.pow2d = 2**self.d
self.ndk = (self.n, self.d, self.k)
def __init__(self,
measure,
beta=1,
kappa=1,
normed=True,
coords=None,
check_input=True):
r"""Processes inputs according to the measure choice.
**Arguments**
- **measure** : _string_
- The string specifying the energy and angular measures to use.
- **beta** : _float_
- The angular weighting exponent $\beta$. Must be positive.
- **kappa** : {_float_, `'pf'`}
- If a number, the energy weighting exponent $\kappa$. If `'pf'`,
use $\kappa=v$ where $v$ is the valency of the vertex. `'pf'`
cannot be used with measure `'hadr'`. Only IRC-safe for `kappa=1`.
- **normed** : bool
- Whether or not to use normalized energies.
- **coords** : {`'ptyphim'`, `'epxpypz'`, `None`}
- Controls which coordinates are assumed for the input. If `'ptyphim'`, the
fourth column (the masses) is optional and massless particles are assumed
if it is not present. If `None`, coords with be `'ptyphim'` if using a
hadronic measure and `'epxpypz'` if using the e+e- measure.
- **check_input** : bool
- Whether to check the type of input each time or assume the first input type.
"""
transfer(self, locals(),
['measure', 'kappa', 'normed', 'coords', 'check_input'])
self.beta = float(beta)
self.half_beta = self.beta / 2
assert self.beta > 0
if self.coords not in [None, 'epxpypz', 'ptyphim']:
raise ValueError('coords must be one of epxpypz, ptyphim, or None')
self.need_meas_func = True
def __init__(self, dmax=None, nmax=None, emax=None, cmax=None, vmax=None, comp_dmaxs=None,
filename=None, gen_efms=True, np_optimize='greedy', verbose=False):
r"""Doing a fresh generation of connected multigraphs (`filename=None`)
requires that `igraph` be installed.
**Arguments**
- **dmax** : _int_
- The maximum number of edges of the generated connected graphs.
- **nmax** : _int_
- The maximum number of vertices of the generated connected graphs.
- **emax** : _int_
- The maximum number of edges of the generated connected simple
graphs.
- **cmax** : _int_
- The maximum VE complexity $\chi$ of the generated connected
graphs.
- **vmax** : _int_
- The maximum valency of the generated connected graphs.
- **comp_dmaxs** : {_dict_, _int_}
- If an integer, the maximum number of edges of the generated
disconnected graphs. If a dictionary, the keys are numbers of
vertices and the values are the maximum number of edges of the
generated disconnected graphs with that number of vertices.
- **filename** : _str_
- If `None`, do a complete generation from scratch. If set to a
string, read in connected graphs from the file given, restrict them
according to the various 'max' parameters, and do a fresh
disconnected generation. The special value `filename='default'`
means to read in graphs from the default file. This is useful when
various disconnected graph parameters are to be varied since the
generation of large simple graphs is the most computationlly
intensive part.
- **gen_efms** : _bool_
- Controls whether EFM information is generated.
- **np_optimize** : {`True`, `False`, `'greedy'`, `'optimal'`}
- The `optimize` keyword of `numpy.einsum_path`.
- **verbose** : _bool_
- A flag to control printing.
"""
start = time.time()
# check for new generation
if dmax is not None and filename is None:
# set maxs
self._set_maxs(dmax, nmax, emax, cmax, vmax)
# set options
self.np_optimize = np_optimize
self.gen_efms = gen_efms
# get prime generator instance
self.pr_gen = PrimeGenerator(self.dmax, self.nmax, self.emax, self.cmax, self.vmax,
self.gen_efms, self.np_optimize, verbose, start)
self.cols = self.pr_gen.cols
self._set_col_inds()
if verbose:
print('Finished generating prime graphs in {:.3f}.'.format(time.time() - start))
# store lists of important quantities
transfer(self, self.pr_gen, self._prime_attrs())
# if filename is set, read in file
else:
file = load_efp_file(filename)
# setup cols and col inds
self.cols = file['cols']
self._set_col_inds()
# get maxs from file and passed in options
c_specs = np.asarray(file['c_specs'])
for m in ['dmax','nmax','emax','cmax','vmax']:
setattr(self, m, min(file[m], none2inf(locals()[m])))
# select connected specs based on maxs
mask = ((c_specs[:,self.d_ind] <= self.dmax) &
(c_specs[:,self.n_ind] <= self.nmax) &
(c_specs[:,self.e_ind] <= self.emax) &
(c_specs[:,self.c_ind] <= self.cmax) &
(c_specs[:,self.v_ind] <= self.vmax))
# set ve options
self.np_optimize = file['np_optimize']
# get lists of important quantities
self.gen_efms = file['gen_efms'] and gen_efms
for attr in (self._prime_attrs()):
setattr(self, attr, [x for x,m in zip(file[attr],mask) if m])
self.c_specs = c_specs[mask]
# setup generator of disconnected graphs
self._set_comp_dmaxs(comp_dmaxs)
self.comp_gen = CompositeGenerator(self.c_specs, self.cols, self.comp_dmaxs)
if verbose:
print('Finished generating composite graphs in {:.3f}.'.format(time.time() - start))
# get results and store
transfer(self, self.comp_gen, self._comp_attrs())
def __init__(self,
measure,
beta=1,
kappa=1,
normed=True,
coords=None,
check_input=True,
kappa_normed_behavior='new'):
r"""Processes inputs according to the measure choice and other options.
**Arguments**
- **measure** : _string_
- The string specifying the energy and angular measures to use.
- **beta** : _float_
- The angular weighting exponent $\beta$. Must be positive.
- **kappa** : {_float_, `'pf'`}
- If a number, the energy weighting exponent $\kappa$. If `'pf'`,
use $\kappa=v$ where $v$ is the valency of the vertex. `'pf'`
cannot be used with measure `'hadr'`. Only IRC-safe for `kappa=1`.
- **normed** : bool
- Whether or not to use normalized energies/transverse momenta.
- **coords** : {`'ptyphim'`, `'epxpypz'`, `None`}
- Controls which coordinates are assumed for the input. If
`'ptyphim'`, the fourth column (the masses) is optional and
massless particles are assumed if it is not present. If `None`,
coords with be `'ptyphim'` if using a hadronic measure and
`'epxpypz'` if using the e+e- measure.
- **check_input** : bool
- Whether to check the type of input each time or assume the first
input type.
- **kappa_normed_behavior** : {`'new'`, `'orig'`}
- Determines how `'kappa'`!=1 interacts with normalization of the
energies. A value of `'new'` will ensure that `z` is truly the
energy fraction of a particle, so that $z_i=E_i^\kappa/\left(
\sum_{i=1}^ME_i\right)^\kappa$. A value of `'orig'` will keep the
behavior prior to version `1.1.0`, which used $z_i=E_i^\kappa/
\sum_{i=1}^M E_i^\kappa$.
"""
# store parameters
transfer(self, locals(), [
'measure', 'kappa', 'normed', 'coords', 'check_input',
'kappa_normed_behavior'
])
# check that options are appropriate
if self.coords not in {None, 'epxpypz', 'ptyphim'}:
raise ValueError(
"coords must be one of 'epxpypz', 'ptyphim', or None")
if self.kappa_normed_behavior not in {'new', 'orig'}:
raise ValueError("kappa_normed_behavior must be 'new' or 'orig'")
# verify beta
self.beta = float(beta)
self.half_beta = self.beta / 2
assert self.beta > 0
# measure function is not yet set
self.need_meas_func = True
# handle normed and kappa options
self._z_func, self._phat_func = self._z_unnormed_func, _phat_func
if self.kappa == PF_MARKER:
self._phat_func = _pf_phat_func
# cannot subslice when kappa = pf
self.subslicing = False
# if normed was set to True, warn them about this
if self.normed:
raise ValueError("Normalization not supported when kappa='pf'")
self._z_func = self._pf_z_func
# we're norming the correlators
elif self.normed:
if self.kappa_normed_behavior == 'new':
self._z_func = self._z_normed_new_func
else:
self._z_func = self._z_normed_orig_func
def process_hps(self):
"""See [`ArchBase`](#archbase) for how to pass in hyperparameters.
**Required CNN Hyperparameters**
- **input_shape** : {_tuple_, _list_} of _int_
- The shape of a single jet image. Assuming that `data_format`
is set to `channels_first`, this is `(nb_chan,npix,npix)`.
- **filter_sizes** : {_tuple_, _list_} of _int_
- The size of the filters, which are taken to be square, in each
convolutional layer of the network. The length of the list will be
the number of convolutional layers in the network.
- **num_filters** : {_tuple_, _list_} of _int_
- The number of filters in each convolutional layer. The length of
`num_filters` must match that of `filter_sizes`.
**Default CNN Hyperparameters**
- **dense_sizes**=`None` : {_tuple_, _list_} of _int_
- The sizes of the dense layer backend. A value of `None` is
equivalent to an empty list.
- **pool_sizes**=`None` : {_tuple_, _list_} of _int_
- Size of maxpooling filter, taken to be a square. A value of
`None` will not use maxpooling.
- **conv_acts**=`'relu'` : {_tuple_, _list_} of _str_
- Activation function(s) for the conv layers. A single string
will apply the same activation to all conv layers. See the
[Keras activations docs](https://keras.io/activations/) for
more detail.
- **dense_acts**=`'relu'` : {_tuple_, _list_} of _str_
- Activation functions(s) for the dense layers. A single string
will apply the same activation to all dense layers.
- **conv_k_inits**=`'he_uniform'` : {_tuple_, _list_} of _str_
- Kernel initializers for the convolutional layers. A single
string will apply the same initializer to all layers. See the
[Keras initializer docs](https://keras.io/initializers/) for
more detail.
- **dense_k_inits**=`'he_uniform'` : {_tuple_, _list_} of _str_
- Kernel initializers for the dense layers. A single string will
apply the same initializer to all layers.
- **conv_dropouts**=`0` : {_tuple_, _list_} of _float_
- Dropout rates for the convolutional layers. A single float will
apply the same dropout rate to all conv layers. See the [Keras
Dropout layer](https://keras.io/layers/core/#dropout) for more
detail.
- **num_spatial2d_dropout**=`0` : _int_
- The number of convolutional layers, starting from the beginning
of the model, for which to apply [SpatialDropout2D](https://keras
.io/layers/core/#spatialdropout2d) instead of Dropout.
- **dense_dropouts**=`0` : {_tuple_, _list_} of _float_
- Dropout rates for the dense layers. A single float will apply
the same dropout rate to all dense layers.
- **paddings**=`'valid'` : {_tuple_, _list_} of _str_
- Controls how the filters are convoled with the inputs. See
the [Keras Conv2D layer](https://keras.io/layers/convolutional/#conv2d)
for more detail.
- **data_format**=`'channels_first'` : {`'channels_first'`, `'channels_last'`}
- Sets which axis is expected to contain the different channels.
"""
# process generic NN hps
super(CNN, self).process_hps()
# required hyperparameters
transfer(self, self.hps,
['input_shape', 'filter_sizes', 'num_filters'])
# required checks
m = 'filter_sizes and num_filters must be the same length'
assert len(self.filter_sizes) == len(self.num_filters), m
# optional (but likely provided) hyperparameters with defaults
self.pool_sizes = iter_or_rep(self.hps.get('pool_sizes', None))
self.dense_sizes = self.hps.get('dense_sizes', None)
# activations
self.conv_acts = iter_or_rep(self.hps.get('conv_acts', 'relu'))
self.dense_acts = iter_or_rep(self.hps.get('dense_acts', 'relu'))
# initializations
self.conv_k_inits = iter_or_rep(
self.hps.get('conv_k_inits', 'he_uniform'))
self.dense_k_inits = iter_or_rep(
self.hps.get('dense_k_inits', 'he_uniform'))
# regularization
self.conv_dropouts = iter_or_rep(self.hps.get('conv_dropouts', 0))
self.num_spatial2d_dropout = self.hps.get('num_spatial2d_dropout', 0)
self.dense_dropouts = iter_or_rep(self.hps.get('dense_dropouts', 0))
# padding
self.paddings = iter_or_rep(self.hps.get('padding', 'valid'))
self.data_format = self.hps.get('data_format', 'channels_first')
