我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用six.moves.zip()。
def estimate_tree(grid, edge_logits): """Compute a maximum likelihood spanning tree of a dense weighted graph. Args: grid: A 3 x K array as returned by make_complete_graph(). edge_logits: A length-K array of nonnormalized log probabilities. Returns: A list of (vertex, vertex) pairs. """ K = len(edge_logits) assert grid.shape == (3, K) weights = triangular_to_square(grid, edge_logits) weights *= -1 weights -= weights.min() weights += 1.0 csr = minimum_spanning_tree(weights, overwrite=True) coo = csr.tocoo() edges = zip(coo.row, coo.col) edges = sorted(tuple(sorted(pair)) for pair in edges) assert len(edges) == weights.shape[0] - 1 return edges
def describe_arguments(func): """ Analyze a function's signature and return a data structure suitable for passing in as arguments to an argparse parser's add_argument() method.""" argspec = inspect.getargspec(func) # we should probably raise an exception somewhere if func includes **kwargs if argspec.defaults: positional_args = argspec.args[:-len(argspec.defaults)] keyword_names = argspec.args[-len(argspec.defaults):] for arg, default in zip(keyword_names, argspec.defaults): yield ('--{}'.format(arg),), {'default': default} else: positional_args = argspec.args for arg in positional_args: yield (arg,), {} if argspec.varargs: yield (argspec.varargs,), {'nargs': '*'}
def dict_factory(colnames, rows): """ Returns each row as a dict. Example:: >>> from cassandra.query import dict_factory >>> session = cluster.connect('mykeyspace') >>> session.row_factory = dict_factory >>> rows = session.execute("SELECT name, age FROM users LIMIT 1") >>> print rows[0] {u'age': 42, u'name': u'Bob'} .. versionchanged:: 2.0.0 moved from ``cassandra.decoder`` to ``cassandra.query`` """ return [dict(zip(colnames, row)) for row in rows]
def as_cql_query(self, formatted=False): """ Returns a CQL query that can be used to recreate this type. If `formatted` is set to :const:`True`, extra whitespace will be added to make the query more readable. """ ret = "CREATE TYPE %s.%s (%s" % ( protect_name(self.keyspace), protect_name(self.name), "\n" if formatted else "") if formatted: field_join = ",\n" padding = " " else: field_join = ", " padding = "" fields = [] for field_name, field_type in zip(self.field_names, self.field_types): fields.append("%s %s" % (protect_name(field_name), field_type)) ret += field_join.join("%s%s" % (padding, field) for field in fields) ret += "\n)" if formatted else ")" return ret
def as_cql_query(self, formatted=False): """ Returns a CQL query that can be used to recreate this function. If `formatted` is set to :const:`True`, extra whitespace will be added to make the query more readable. """ sep = '\n ' if formatted else ' ' keyspace = protect_name(self.keyspace) name = protect_name(self.name) arg_list = ', '.join(["%s %s" % (protect_name(n), t) for n, t in zip(self.argument_names, self.argument_types)]) typ = self.return_type lang = self.language body = self.body on_null = "CALLED" if self.called_on_null_input else "RETURNS NULL" return "CREATE FUNCTION %(keyspace)s.%(name)s(%(arg_list)s)%(sep)s" \ "%(on_null)s ON NULL INPUT%(sep)s" \ "RETURNS %(typ)s%(sep)s" \ "LANGUAGE %(lang)s%(sep)s" \ "AS $$%(body)s$$" % locals()
def to_table_data(self): """ :raises ValueError: :raises pytablereader.error.ValidationError: """ self._validate_source_data() self._loader.inc_table_count() header_list = sorted(six.viewkeys(self._buffer)) yield TableData( table_name=self._make_table_name(), header_list=header_list, record_list=zip( *[self._buffer.get(header) for header in header_list]), quoting_flags=self._loader.quoting_flags)
def to_table_data(self): """ :raises ValueError: :raises pytablereader.error.ValidationError: """ self._validate_source_data() for table_key, json_record_list in six.iteritems(self._buffer): header_list = sorted(six.viewkeys(json_record_list)) self._loader.inc_table_count() self._table_key = table_key yield TableData( table_name=self._make_table_name(), header_list=header_list, record_list=zip( *[json_record_list.get(header) for header in header_list]), quoting_flags=self._loader.quoting_flags)
def get_updates(self, params, loss): grads = self.get_gradients(loss, params) lr = self.lr * (1.0 / (1.0 + self.decay * self.iterations)) self.updates = [(self.iterations, self.iterations + 1.)] for p, g in zip(params, grads): m = shared_zeros(p.get_value().shape) # momentum v = self.momentum * m - lr * g # velocity self.updates.append((m, v)) if self.nesterov: new_p = p + self.momentum * v - lr * g else: new_p = p + v self.updates.append((p, new_p)) # apply constraints return self.updates
def get_updates(self, params, loss): grads = self.get_gradients(loss, params) accumulators = [shared_zeros(p.get_value().shape) for p in params] delta_accumulators = [shared_zeros(p.get_value().shape) for p in params] # self.updates = [] self.updates = [(self.iterations, self.iterations + 1.)] for p, g, a, d_a in zip(params, grads, accumulators, delta_accumulators): new_a = self.rho * a + (1 - self.rho) * g ** 2 # update accumulator self.updates.append((a, new_a)) # use the new accumulator and the *old* delta_accumulator update = g * T.sqrt(d_a + self.epsilon) / T.sqrt(new_a + self.epsilon) new_p = p - self.lr * update self.updates.append((p, new_p)) # update delta_accumulator new_d_a = self.rho * d_a + (1 - self.rho) * update ** 2 self.updates.append((d_a, new_d_a)) return self.updates
def axis_iter(self, axes=0): """Returns an iterator yielding Sub-MPArrays of ``self`` by iterating over the specified physical axes. **Example:** If ``self`` represents a bipartite (i.e. length 2) array with 2 physical dimensions on each site ``A[(k,l), (m,n)]``, ``self.axis_iter(0)`` is equivalent to:: (A[(k, :), (m, :)] for m in range(...) for k in range(...)) :param axes: Iterable or int specifiying the physical axes to iterate over (default 0 for each site) :returns: Iterator over :class:`.MPArray` """ if not isinstance(axes, collections.Iterable): axes = it.repeat(axes, len(self)) ltens_iter = it.product(*(iter(np.rollaxis(lten, i + 1)) for i, lten in zip(axes, self.lt))) return (MPArray(ltens) for ltens in ltens_iter) ########################## # Algebraic operations # ##########################
def reshape(self, newshapes): """Reshape physical legs in place. Use :py:attr:`~shape` to obtain the shape of the physical legs. :param newshapes: A single new shape or a list of new shape. Alternatively, you can pass 'prune' to get rid of all legs of dimension 1. :returns: Reshaped MPA .. todo:: Why is this here? What's wrong with the purne function? """ if newshapes == 'prune': newshapes = (tuple(s for s in pdim if s > 1) for pdim in self.shape) newshapes = tuple(newshapes) if not isinstance(newshapes[0], collections.Iterable): newshapes = it.repeat(newshapes, times=len(self)) ltens = [_local_reshape(lten, newshape) for lten, newshape in zip(self._lt, newshapes)] return MPArray(LocalTensors(ltens, cform=self.canonical_form))
def singularvals(self): """Return singular values of ``self`` for all bipartitions :returns: Iterate over bipartitions with 1, 2, ... len(self) - 1 sites on the left hand side. Yields a ``np.ndarray`` containing singular values for each bipartition. .. note:: May decrease the rank (without changing the represented tensor). """ if len(self) == 1: return # No bipartitions with two non-empty parts for a single site self.canonicalize(right=1) iterator = self._compress_svd_r(max(self.ranks), None, truncated_svd) # We want everything from the iterator except for the last element. for _, (sv, rank) in zip(range(len(self) - 1), iterator): # We could verify that `rank` did not decrease but it may # decrease because of zero singular values -- let's trust # that relerr=0.0 behaves as intended. # assert old_rank == rank yield sv
def inner(mpa1, mpa2): """Compute the inner product `<mpa1|mpa2>`. Both have to have the same physical dimensions. If these represent a MPS, ``inner(...)`` corresponds to the canoncial Hilbert space scalar product. If these represent a MPO, ``inner(...)`` corresponds to the Frobenius scalar product (with Hermitian conjugation in the first argument) :param mpa1: MPArray with same number of physical legs on each site :param mpa2: MPArray with same physical shape as mpa1 :returns: <mpa1|mpa2> """ assert len(mpa1) == len(mpa2), \ "Length is not equal: {} != {}".format(len(mpa1), len(mpa2)) ltens_new = (_local_dot(_local_ravel(l).conj(), _local_ravel(r), axes=(1, 1)) for l, r in zip(mpa1.lt, mpa2.lt)) return _ltens_to_array(ltens_new)[0, ..., 0]
def sandwich(mpo, mps, mps2=None): """Compute ``<mps|MPO|mps>`` efficiently This function computes the same value as ``mp.inner(mps, mp.dot(mpo, mps))`` in a more efficient way. The runtime of this method scales with ``D**3 * Dp + D**2 * Dp**3`` where ``D`` and ``Dp`` are the ranks of ``mps`` and ``mpo``. This is more efficient than ``mp.inner(mps, mp.dot(mpo, mps))``, whose runtime scales with ``D**4 * Dp**3``, and also more efficient than ``mp.dot(mps.conj(), mp.dot(mpo, mps)).to_array()``, whose runtime scales with ``D**6 * Dp**3``. If ``mps2`` is given, ``<mps2|MPO|mps>`` is computed instead (i.e. ``mp.inner(mps2, mp.dot(mpo, mps))``; see also :func:`dot()`). """ # Fortunately, the contraction has been implemented already: arr = np.ones((1, 1, 1)) for mpo_lt, mps_lt, mps2_lt in zip(mpo.lt, mps.lt, (mps2 or mps).lt): arr = mp.linalg._eig_leftvec_add(arr, mpo_lt, mps_lt, mps2_lt) assert arr.size == 1 return arr.flat[0]
def test_sumup(nr_sites, local_dim, rank, rgen, dtype): mpas = [factory.random_mpa(nr_sites, local_dim, 3, dtype=dtype, randstate=rgen) for _ in range(rank if rank is not np.nan else 1)] sum_naive = ft.reduce(mp.MPArray.__add__, mpas) sum_mp = mp.sumup(mpas) assert_array_almost_equal(sum_naive.to_array(), sum_mp.to_array()) assert all(r <= 3 * rank for r in sum_mp.ranks) assert(sum_mp.dtype is dtype) weights = rgen.randn(len(mpas)) summands = [w * mpa for w, mpa in zip(weights, mpas)] sum_naive = ft.reduce(mp.MPArray.__add__, summands) sum_mp = mp.sumup(mpas, weights=weights) assert_array_almost_equal(sum_naive.to_array(), sum_mp.to_array()) assert all(r <= 3 * rank for r in sum_mp.ranks) assert(sum_mp.dtype is dtype)
def test_diag_2plegs(nr_sites, local_dim, rank, rgen): mpa = factory.random_mpa(nr_sites, 2 * (local_dim,), rank, randstate=rgen) mpa_np = mpa.to_array() # this should be a single, 1D numpy array diag_mp = mp.diag(mpa, axis=1) diag_np = np.array([mpa_np[(slice(None), i) * nr_sites] for i in range(local_dim)]) for a, b in zip(diag_mp, diag_np): assert a.ndims[0] == 1 assert_array_almost_equal(a.to_array(), b) ############################################################################### # Shape changes, conversions # ############################################################################### # nr_sites, local_dim, rank, sites_per_group
def test_mppovmlist_pack_unpack_samples( method, n_samples, nr_sites, local_dim, rank, measure_width, rgen, eps=1e-10): """Check that packing and unpacking samples does not change them""" mps = factory.random_mps(nr_sites, local_dim, rank, rgen) mps.canonicalize() s_povm = povm.pauli_mpp(measure_width, local_dim).block(nr_sites) samples = tuple(s_povm.sample( rgen, mps, n_samples, method, mode='mps', pack=False, eps=eps)) packed = tuple(s_povm.pack_samples(samples)) unpacked = tuple(s_povm.unpack_samples(packed)) assert all(s.dtype == np.uint8 for s in samples) assert all(s.dtype == np.uint8 for s in unpacked) assert all((s == u).all() for s, u in zip(samples, unpacked))
def limits(self): if self.is_empty(): return (0, 1) # Fall back to the range if the limits # are not set or if any is None or NaN if self._limits is not None and self.range.range is not None: limits = [] if len(self._limits) == len(self.range.range): for l, r in zip(self._limits, self.range.range): value = r if pd.isnull(l) else l limits.append(value) else: limits = self._limits return tuple(limits) return self.range.range
def count_mismatches_before_variant(reference_prefix, cdna_prefix): """ Computes the number of mismatching nucleotides between two cDNA sequences before a variant locus. Parameters ---------- reference_prefix : str cDNA sequence of a reference transcript before a variant locus cdna_prefix : str cDNA sequence detected from RNAseq before a variant locus """ if len(reference_prefix) != len(cdna_prefix): raise ValueError( "Expected reference prefix '%s' to be same length as %s" % ( reference_prefix, cdna_prefix)) return sum(xi != yi for (xi, yi) in zip(reference_prefix, cdna_prefix))
def count_mismatches_after_variant(reference_suffix, cdna_suffix): """ Computes the number of mismatching nucleotides between two cDNA sequences after a variant locus. Parameters ---------- reference_suffix : str cDNA sequence of a reference transcript after a variant locus cdna_suffix : str cDNA sequence detected from RNAseq after a variant locus """ len_diff = len(cdna_suffix) - len(reference_suffix) # if the reference is shorter than the read, the read runs into the intron - these count as # mismatches return sum(xi != yi for (xi, yi) in zip(reference_suffix, cdna_suffix)) + max(0, len_diff)
def _write(self, samples, keyvals): """Write new metadata to the Digital Metadata channel. This function does no input checking, see `write` for that. Parameters ---------- samples : 1-D numpy array of type uint64 sorted in ascending order An array of sample indices, given in the number of samples since the epoch (time_since_epoch*sample_rate). keyvals : iterable of iterables same length as `samples` Each element of this iterable corresponds to a sample in `samples` and should be another iterable that produces (key, value) pairs to write for that sample. """ grp_iter = self._sample_group_generator(samples) for grp, keyval in zip(grp_iter, keyvals): for key, val in keyval: if val is not None: grp.create_dataset(key, data=val)
def set_weights(self, weights): '''Sets the weights of the optimizer, from Numpy arrays. Should only be called after computing the gradients (otherwise the optimizer has no weights). # Arguments weights: a list of Numpy arrays. The number of arrays and their shape must match number of the dimensions of the weights of the optimizer (i.e. it should match the output of `get_weights`). ''' params = self.weights weight_value_tuples = [] param_values = K.batch_get_value(params) for pv, p, w in zip(param_values, params, weights): if pv.shape != w.shape: raise Exception('Optimizer weight shape ' + str(pv.shape) + ' not compatible with ' 'provided weight shape ' + str(w.shape)) weight_value_tuples.append((p, w)) K.batch_set_value(weight_value_tuples)
def get_updates(self, params, constraints, loss): grads = self.get_gradients(loss, params) shapes = [K.get_variable_shape(p) for p in params] accumulators = [K.zeros(shape) for shape in shapes] self.weights = accumulators self.updates = [] lr = self.lr if self.inital_decay > 0: lr *= (1. / (1. + self.decay * self.iterations)) self.updates.append(K.update_add(self.iterations, 1)) for p, g, a in zip(params, grads, accumulators): # update accumulator new_a = self.rho * a + (1. - self.rho) * K.square(g) self.updates.append(K.update(a, new_a)) new_p = p - lr * g / (K.sqrt(new_a) + self.epsilon) # apply constraints if p in constraints: c = constraints[p] new_p = c(new_p) self.updates.append(K.update(p, new_p)) return self.updates
def _get_protocol_and_headers(self, headerline, parts): headers = [] if headerline.startswith('filedesc://'): rec_type = 'warcinfo' else: rec_type = 'response' parts[3] = 'application/http;msgtype=response' headers.append(('WARC-Type', rec_type)) headers.append(('WARC-Record-ID', StatusAndHeadersParser.make_warc_id())) for name, value in zip(self.headernames, parts): if name == 'WARC-Date': value = timestamp_to_iso_date(value) if rec_type == 'warcinfo' and name == 'WARC-Target-URI': name = 'WARC-Filename' value = value[len('filedesc://'):] headers.append((name, value)) return ('WARC/1.0', headers)
def compactify(self): """ Assign new word ids to all words. This is done to make the ids more compact, e.g. after some tokens have been removed via :func:`filter_tokens` and there are gaps in the id series. Calling this method will remove the gaps. """ logger.debug("rebuilding dictionary, shrinking gaps") # build mapping from old id -> new id idmap = dict(izip(itervalues(self.token2id), xrange(len(self.token2id)))) # reassign mappings to new ids self.token2id = dict((token, idmap[tokenid]) for token, tokenid in iteritems(self.token2id)) self.id2token = {} self.dfs = dict((idmap[tokenid], freq) for tokenid, freq in iteritems(self.dfs))
def var_dropout(observed, x, n, net_size, n_particles, is_training): with zs.BayesianNet(observed=observed) as model: h = x normalizer_params = {'is_training': is_training, 'updates_collections': None} for i, [n_in, n_out] in enumerate(zip(net_size[:-1], net_size[1:])): eps_mean = tf.ones([n, n_in]) eps = zs.Normal( 'layer' + str(i) + '/eps', eps_mean, std=1., n_samples=n_particles, group_ndims=1) h = layers.fully_connected( h * eps, n_out, normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params) if i < len(net_size) - 2: h = tf.nn.relu(h) y = zs.OnehotCategorical('y', h) return model, h
def __init__(self, log_prior, log_joint, prior_sampler, hmc, observed, latent, n_chains=25, n_temperatures=1000, verbose=False): # Shape of latent: [chain_axis, num_data, data dims] # Construct the tempered objective self.n_chains = n_chains self.n_temperatures = n_temperatures self.verbose = verbose with tf.name_scope("AIS"): self.temperature = tf.placeholder(tf.float32, shape=[], name="temperature") def log_fn(observed): return log_prior(observed) * (1 - self.temperature) + \ log_joint(observed) * self.temperature self.log_fn = log_fn self.log_fn_val = log_fn(merge_dicts(observed, latent)) self.sample_op, self.hmc_info = hmc.sample( log_fn, observed, latent) self.init_latent = [tf.assign(z, z_s) for z, z_s in zip(latent.values(), prior_sampler.values())]
def update(self, x): # x: (chain_dims data_dims) new_t = tf.assign(self.t, self.t + 1) weight = (1 - self.decay) / (1 - tf.pow(self.decay, new_t)) # incr: (chain_dims data_dims) incr = [weight * (q - mean) for q, mean in zip(x, self.mean)] # mean: (1,...,1 data_dims) update_mean = [mean.assign_add( tf.reduce_mean(i, axis=self.chain_axes, keep_dims=True)) for mean, i in zip(self.mean, incr)] # var: (1,...,1 data_dims) new_var = [ (1 - weight) * var + tf.reduce_mean(i * (q - mean), axis=self.chain_axes, keep_dims=True) for var, i, q, mean in zip(self.var, incr, x, update_mean)] update_var = [tf.assign(var, n_var) for var, n_var in zip(self.var, new_var)] return update_var
def parse_csv_file(thefile): """Parse csv file, yielding rows as dictionary. The csv file should have an header. Args: thefile (file): File like object Yields: dict: Dictionary with column header name as key and cell as value """ reader = csv.reader(codecs.iterdecode(thefile, 'ISO-8859-1')) # read header colnames = next(reader) # data rows for row in reader: pdb = {} for k, v in zip(colnames, row): if v is '': v = None pdb[k] = v yield pdb
def _minimum_selection(tau_idxs, lambda_idxs, sparse=False, regularized=False): r"""Selection of the miminum error coordinates. Given two ranges of minimum errors coordinates selects the right pair according to the two parameters sparse, regularized. """ from collections import defaultdict d = defaultdict(list) for t, l in izip(tau_idxs, lambda_idxs): d[t].append(l) tau_idx = max(d.keys()) if sparse else min(d.keys()) lam_idx = max(d[tau_idx]) if regularized else min(d[tau_idx]) return tau_idx, lam_idx
