我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.add()。
def add_row(self, row_id): logger.debug('TreeCatTrainer.add_row %d', row_id) assert row_id not in self._added_rows, row_id self._added_rows.add(row_id) # These are used for scratch work, so we create them each step. np.add(self._vert_ss, self._vert_prior, out=self._vert_probs) np.add(self._feat_ss, self._feat_prior, out=self._feat_probs) np.add(self._meas_ss, self._meas_prior, out=self._meas_probs) treecat_add_row( self._table.feature_types, self._table.ragged_index, self._table.data[row_id, :], self._tree.tree_grid, self._program, self._assignments[row_id, :], self._vert_ss, self._edge_ss, self._feat_ss, self._meas_ss, self._vert_probs, self._edge_probs, self._feat_probs, self._meas_probs, )
def test_out_parameter(self): """ Test that the kwargs ``out`` is correctly passed to reduction function """ with self.subTest('axis = -1'): not_out = last(ireduce_ufunc(self.source, np.add, axis = -1)) out = np.empty_like(self.source[0]) last(ireduce_ufunc(self.source, ufunc = np.add, out = out)) self.assertTrue(np.allclose(not_out, out)) with self.subTest('axis != -1'): not_out = last(ireduce_ufunc(self.source, np.add, axis = 2)) out = np.empty_like(self.source[0]) from_out = last(ireduce_ufunc(self.source, ufunc = np.add, out = out, axis = 2)) self.assertTrue(np.allclose(not_out, from_out))
def proc(csv_na,con): dicts=[] for i in range(0,len(con)): dicts.append(dict()) sum=0 f=csv.DictReader(open(csv_na)) for rec in f: rec['single']='1' #print(csv_na,rec['clickTime']) label=int(rec['label']) for i in range(0,len(con)): k=rec[con[i][0]]+'#'+rec[con[i][1]] if dicts[i].__contains__(k): dicts[i][k]=np.add(dicts[i][k],[label,1]) else: dicts[i][k]=[label,1] sum+=1 return dicts,sum
def train(self, training_data_array): for data in training_data_array: # ?????????? y1 = np.dot(np.mat(self.theta1), np.mat(data.y0).T) sum1 = y1 + np.mat(self.input_layer_bias) y1 = self.sigmoid(sum1) y2 = np.dot(np.array(self.theta2), y1) y2 = np.add(y2, self.hidden_layer_bias) y2 = self.sigmoid(y2) # ?????????? actual_vals = [0] * 10 actual_vals[data.label] = 1 output_errors = np.mat(actual_vals).T - np.mat(y2) hidden_errors = np.multiply(np.dot(np.mat(self.theta2).T, output_errors), self.sigmoid_prime(sum1)) # ??????????? self.theta1 += self.LEARNING_RATE * np.dot(np.mat(hidden_errors), np.mat(data.y0)) self.theta2 += self.LEARNING_RATE * np.dot(np.mat(output_errors), np.mat(y1).T) self.hidden_layer_bias += self.LEARNING_RATE * output_errors self.input_layer_bias += self.LEARNING_RATE * hidden_errors
def getComplexRepr(sequenza, K): """ Crea la rappresentazione ottenuta dalla somma delle varie rappresentazioni in una unica matrice. K e' la lista delle dimensioni dei k-mers. """ m_init=getMatrice(sequenza, K[0]) dim=2**K[-1] #out=np.zeros((dim, dim)) for ki in K[1:]: m_init=espandiMatrice(m_init) # divido gli elementi per due per diminuire l'impatto dei termini # piu' corti e quindi piu' comuni m_init /= 2.0 temp=getMatrice(sequenza, ki) m_init=np.add(m_init,temp) return m_init
def test_ufunc_override_normalize_signature(self): # 2016-01-29: NUMPY_UFUNC_DISABLED return # gh-5674 class SomeClass(object): def __numpy_ufunc__(self, ufunc, method, i, inputs, **kw): return kw a = SomeClass() kw = np.add(a, [1]) assert_('sig' not in kw and 'signature' not in kw) kw = np.add(a, [1], sig='ii->i') assert_('sig' not in kw and 'signature' in kw) assert_equal(kw['signature'], 'ii->i') kw = np.add(a, [1], signature='ii->i') assert_('sig' not in kw and 'signature' in kw) assert_equal(kw['signature'], 'ii->i')
def test_forced_sig(self): a = 0.5*np.arange(3, dtype='f8') assert_equal(np.add(a, 0.5), [0.5, 1, 1.5]) assert_equal(np.add(a, 0.5, sig='i', casting='unsafe'), [0, 0, 1]) assert_equal(np.add(a, 0.5, sig='ii->i', casting='unsafe'), [0, 0, 1]) assert_equal(np.add(a, 0.5, sig=('i4',), casting='unsafe'), [0, 0, 1]) assert_equal(np.add(a, 0.5, sig=('i4', 'i4', 'i4'), casting='unsafe'), [0, 0, 1]) b = np.zeros((3,), dtype='f8') np.add(a, 0.5, out=b) assert_equal(b, [0.5, 1, 1.5]) b[:] = 0 np.add(a, 0.5, sig='i', out=b, casting='unsafe') assert_equal(b, [0, 0, 1]) b[:] = 0 np.add(a, 0.5, sig='ii->i', out=b, casting='unsafe') assert_equal(b, [0, 0, 1]) b[:] = 0 np.add(a, 0.5, sig=('i4',), out=b, casting='unsafe') assert_equal(b, [0, 0, 1]) b[:] = 0 np.add(a, 0.5, sig=('i4', 'i4', 'i4'), out=b, casting='unsafe') assert_equal(b, [0, 0, 1])
def test_safe_casting(self): # In old versions of numpy, in-place operations used the 'unsafe' # casting rules. In versions >= 1.10, 'same_kind' is the # default and an exception is raised instead of a warning. # when 'same_kind' is not satisfied. a = np.array([1, 2, 3], dtype=int) # Non-in-place addition is fine assert_array_equal(assert_no_warnings(np.add, a, 1.1), [2.1, 3.1, 4.1]) assert_raises(TypeError, np.add, a, 1.1, out=a) def add_inplace(a, b): a += b assert_raises(TypeError, add_inplace, a, 1.1) # Make sure that explicitly overriding the exception is allowed: assert_no_warnings(np.add, a, 1.1, out=a, casting="unsafe") assert_array_equal(a, [2, 3, 4])
def _test_type_repr(self, t): finfo = np.finfo(t) last_fraction_bit_idx = finfo.nexp + finfo.nmant last_exponent_bit_idx = finfo.nexp storage_bytes = np.dtype(t).itemsize*8 # could add some more types to the list below for which in ['small denorm', 'small norm']: # Values from http://en.wikipedia.org/wiki/IEEE_754 constr = np.array([0x00]*storage_bytes, dtype=np.uint8) if which == 'small denorm': byte = last_fraction_bit_idx // 8 bytebit = 7-(last_fraction_bit_idx % 8) constr[byte] = 1 << bytebit elif which == 'small norm': byte = last_exponent_bit_idx // 8 bytebit = 7-(last_exponent_bit_idx % 8) constr[byte] = 1 << bytebit else: raise ValueError('hmm') val = constr.view(t)[0] val_repr = repr(val) val2 = t(eval(val_repr)) if not (val2 == 0 and val < 1e-100): assert_equal(val, val2)
def test_addsumprod(self): # Tests add, sum, product. (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d assert_equal(np.add.reduce(x), add.reduce(x)) assert_equal(np.add.accumulate(x), add.accumulate(x)) assert_equal(4, sum(array(4), axis=0)) assert_equal(4, sum(array(4), axis=0)) assert_equal(np.sum(x, axis=0), sum(x, axis=0)) assert_equal(np.sum(filled(xm, 0), axis=0), sum(xm, axis=0)) assert_equal(np.sum(x, 0), sum(x, 0)) assert_equal(np.product(x, axis=0), product(x, axis=0)) assert_equal(np.product(x, 0), product(x, 0)) assert_equal(np.product(filled(xm, 1), axis=0), product(xm, axis=0)) s = (3, 4) x.shape = y.shape = xm.shape = ym.shape = s if len(s) > 1: assert_equal(np.concatenate((x, y), 1), concatenate((xm, ym), 1)) assert_equal(np.add.reduce(x, 1), add.reduce(x, 1)) assert_equal(np.sum(x, 1), sum(x, 1)) assert_equal(np.product(x, 1), product(x, 1))
def test_datafriendly_add(self): # Test keeping data w/ (inplace) addition x = array([1, 2, 3], mask=[0, 0, 1]) # Test add w/ scalar xx = x + 1 assert_equal(xx.data, [2, 3, 3]) assert_equal(xx.mask, [0, 0, 1]) # Test iadd w/ scalar x += 1 assert_equal(x.data, [2, 3, 3]) assert_equal(x.mask, [0, 0, 1]) # Test add w/ array x = array([1, 2, 3], mask=[0, 0, 1]) xx = x + array([1, 2, 3], mask=[1, 0, 0]) assert_equal(xx.data, [1, 4, 3]) assert_equal(xx.mask, [1, 0, 1]) # Test iadd w/ array x = array([1, 2, 3], mask=[0, 0, 1]) x += array([1, 2, 3], mask=[1, 0, 0]) assert_equal(x.data, [1, 4, 3]) assert_equal(x.mask, [1, 0, 1])
def test_testAddSumProd(self): # Test add, sum, product. (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d self.assertTrue(eq(np.add.reduce(x), add.reduce(x))) self.assertTrue(eq(np.add.accumulate(x), add.accumulate(x))) self.assertTrue(eq(4, sum(array(4), axis=0))) self.assertTrue(eq(4, sum(array(4), axis=0))) self.assertTrue(eq(np.sum(x, axis=0), sum(x, axis=0))) self.assertTrue(eq(np.sum(filled(xm, 0), axis=0), sum(xm, axis=0))) self.assertTrue(eq(np.sum(x, 0), sum(x, 0))) self.assertTrue(eq(np.product(x, axis=0), product(x, axis=0))) self.assertTrue(eq(np.product(x, 0), product(x, 0))) self.assertTrue(eq(np.product(filled(xm, 1), axis=0), product(xm, axis=0))) if len(s) > 1: self.assertTrue(eq(np.concatenate((x, y), 1), concatenate((xm, ym), 1))) self.assertTrue(eq(np.add.reduce(x, 1), add.reduce(x, 1))) self.assertTrue(eq(np.sum(x, 1), sum(x, 1))) self.assertTrue(eq(np.product(x, 1), product(x, 1)))
def _as_spline(curve, geometry): """ add a spline into a blender curve @curve : blender curve """ if hasattr(geometry, 'exterior'): # Polygon Io._add_spline(curve, geometry.exterior) for geom in geometry.interiors: Io._add_spline(curve, geom) elif hasattr(geometry, 'geoms'): # Multi and Collections for geom in geometry.geoms: Io._as_spline(curve, geom) else: # LinearRing, LineString and Shape Io._add_spline(curve, geometry)
def test_cputensor_fusion(): """TODO.""" M = ng.make_axis(length=1) N = ng.make_axis(length=3) np_a = np.array([[1, 2, 3]], dtype=np.float32) np_b = np.array([[3, 2, 1]], dtype=np.float32) np_d = np.multiply(np_b, np.add(np_a, 2)) a = ng.constant(np_a, [M, N]) b = ng.constant(np_b, [M, N]) c = ng.constant(2) d = ng.multiply(b, ng.add(a, c)) with executor(d) as ex: result = ex() print(result) assert np.array_equal(result, np_d)
def test_4d_elementwise(transformer_factory, input_axes): # Limiting maximum absolute value for tensors elements to 7.9. # See description in function test_exit_condition above is_flex = is_flex_factory(transformer_factory) clip_val = 7.9 if is_flex else 0 x_val = rng.randn_abs_clip(input_axes, clip_max=clip_val) y_val = rng.randn_abs_clip(input_axes, clip_max=clip_val) x = ng.constant(x_val, input_axes) y = ng.constant(y_val, input_axes) out = ng.add(x, y) with executor(out) as ex: graph_val = ex() np_val = np.add(x_val, y_val) ng.testing.assert_allclose(graph_val, np_val, rtol=1e-4)
def discrete_uniform(self, low, high, quantum, axes, dtype=None): """ Returns a tensor initialized with a discrete uniform distribution. Arguments: low: The lower limit of the values. high: The upper limit of the values. quantum: Distance between values. axes: The axes of the tensor. Returns: The tensor. """ if dtype is None: dtype = self.dtype n = math.floor((high - low) / quantum) result = np.array(self.rng.random_integers( 0, n, ng.make_axes(axes).lengths), dtype=dtype) np.multiply(result, quantum, result) np.add(result, low, result) return result
def get_centroid_idf(text, emb, idf, stopwords, D): # Computing Terms' Frequency tf = defaultdict(int) tokens = bioclean(text) for word in tokens: if word in emb and word not in stopwords: tf[word] += 1 # Computing the centroid centroid = np.zeros((1, D)) div = 0 for word in tf: if word in idf: p = tf[word] * idf[word] centroid = np.add(centroid, emb[word]*p) div += p if div != 0: centroid = np.divide(centroid, div) return centroid
def apply_cmvn(utt, mean, variance, reverse=False): """Apply mean and variance normalisation based on previously computed statistics. Args: utt: The utterance feature numpy matrix. stats: A numpy array containing the mean and variance statistics. The first row contains the sum of all the fautures and as a last element the total numbe of features. The second row contains the squared sum of the features and a zero at the end Returns: A numpy array containing the mean and variance normalized features """ if not reverse: #return mean and variance normalised utterance return np.divide(np.subtract(utt, mean), np.sqrt(variance)) else: #reversed normalization return np.add(np.multiply(utt, np.sqrt(variance)), mean)
def sumNormalizedFeatures(features, levels=9, startSize=(1983*8, 1088*8)): """ Normalizes the feature maps in argument features and combines them into one. Arguments: features : list of feature maps (images) levels : the levels of the Gaussian pyramid used to calculate the feature maps. startSize : the base size of the Gaussian pyramit used to calculate the feature maps. returns: a combined feature map. """ commonWidth = startSize[0] / 2**(levels/2 - 1) commonHeight = startSize[1] / 2**(levels/2 - 1) commonSize = commonWidth, commonHeight logger.info("Size of conspicuity map: %s", commonSize) consp = N(cv2.resize(features[0][1], commonSize)) for f in features[1:]: resized = N(cv2.resize(f[1], commonSize)) consp = cv2.add(consp, resized) return consp
def __getitem__(self, idx): img_name = self.img_names[idx] ensembled = np.zeros(const.img_size) for i, pred_dir in enumerate(self.pred_dirs): pred_path = os.path.join(const.OUTPUT_DIR, pred_dir, const.PROBS_DIR_NAME, img_name + '.npy') img_prob = np.load(pred_path) weighted_img_prob = np.multiply(img_prob, self.weights[i]) ensembled = np.add(ensembled, weighted_img_prob) # save into new output/ folder submit.save_ensembled_prob_map(self.ensemble_dir, img_name, ensembled) #plt.imshow(ensembled) #plt.show() return img_name, ensembled
def __getitem__(self, idx): img_name = self.img_names[idx] ensembled_mask = np.zeros((const.img_size[0], const.img_size[1])) for i, submission in enumerate(self.submissions): rle = submission[img_name] mask = run_length.decode(rle) weighted_mask = np.multiply(mask, self.weights[i]) ensembled_mask = np.add(ensembled_mask, weighted_mask) ensembled_mask[ ensembled_mask > 0.5 ] = 1 ensembled_mask[ ensembled_mask <= 0.5 ] = 0 # plt.imshow(ensembled_mask) # plt.show() ensembled_rle = run_length.encode(ensembled_mask) return img_name, ensembled_rle
def compute_num_adds(self, cell, composition_space, random): """ Computes the number of atoms (or stoichiometries worth of atoms) to add or remove. Returns a non-zero integer. Args: cell: the Cell of the parent organism composition_space: the CompositionSpace of the search random: a copy of Python's built in PRNG """ num_adds = int(round(random.gauss(self.mu_num_adds, self.sigma_num_adds))) # keep trying until we get a valid number while num_adds == 0 or \ (composition_space.objective_function == 'epa' and num_adds*-1 >= cell.num_sites/composition_space.endpoints[0].num_atoms) or \ (composition_space.objective_function == 'pd' and num_adds*-1 >= cell.num_sites): num_adds = int(round(random.gauss(self.mu_num_adds, self.sigma_num_adds))) return num_adds
def _get_boll(cls, df): """ Get Bollinger bands. boll_ub means the upper band of the Bollinger bands boll_lb means the lower band of the Bollinger bands boll_ub = MA + K? boll_lb = MA ? K? M = BOLL_PERIOD K = BOLL_STD_TIMES :param df: data :return: None """ moving_avg = df['close_{}_sma'.format(cls.BOLL_PERIOD)] moving_std = df['close_{}_mstd'.format(cls.BOLL_PERIOD)] df['boll'] = moving_avg moving_avg = list(map(np.float64, moving_avg)) moving_std = list(map(np.float64, moving_std)) # noinspection PyTypeChecker df['boll_ub'] = np.add(moving_avg, np.multiply(cls.BOLL_STD_TIMES, moving_std)) # noinspection PyTypeChecker df['boll_lb'] = np.subtract(moving_avg, np.multiply(cls.BOLL_STD_TIMES, moving_std))
def __add__(self, other): """Implicitly broadcast lesser operand to a higher conformable dimension""" if type(self) in self._types or type(other) in self._types: return super().__add__(other) # Stimuli become vectorized, but bias units remain 1D. To add wx + b, must broadcast if self.ndim == 2 and other.ndim == 1: return Array(np.add(self, np.tile(other[..., np.newaxis], self.shape[1]))) if self.ndim == 1 and other.ndim == 2: return Array(np.add(np.tile(self[..., np.newaxis], other.shape[1]), other)) if self.ndim == 3 and other.ndim == 2: return Array(np.add(self, np.tile(other[..., np.newaxis], self.shape[2]))) if self.ndim == 2 and other.ndim == 3: return Array(np.add(np.tile(self[..., np.newaxis], other.shape[2]), other)) return np.add(self, other)
def logprob_dc(counts, prior, axis=None): """Non-normalized log probability of a Dirichlet-Categorical distribution. See https://en.wikipedia.org/wiki/Dirichlet-multinomial_distribution """ # Note that this excludes the factorial(counts) term, since we explicitly # track permutations in assignments. return gammaln(np.add(counts, prior, dtype=np.float32)).sum(axis)
def set_edges(self, edges): TreeTrainer.set_edges(self, edges) V, E, K, M = self._VEKM assignments = self._assignments[sorted(self._added_rows), :] for e, v1, v2 in self._tree.tree_grid.T: self._edge_ss[e, :, :] = count_pairs(assignments, v1, v2, M) np.add(self._edge_ss, self._edge_prior, out=self._edge_probs)
def add_row(self, row_id): logger.debug('TreeGaussTrainer.add_row %d', row_id) assert row_id not in self._added_rows, row_id self._added_rows.add(row_id) treegauss_add_row( self._data[row_id, :], self._tree.tree_grid, self._program, self._latent[row_id, :, :], self._vert_ss, self._edge_ss, self._feat_ss, )
def isum(arrays, axis = -1, dtype = None, ignore_nan = False): """ Streaming sum of array elements. Parameters ---------- arrays : iterable Arrays to be summed. axis : int or None, optional Reduction axis. Default is to sum the arrays in the stream as if they had been stacked along a new axis, then sum along this new axis. If None, arrays are flattened before summing. If `axis` is an int larger that the number of dimensions in the arrays of the stream, arrays are summed along the new axis. dtype : numpy.dtype, optional The type of the yielded array and of the accumulator in which the elements are summed. The dtype of a is used by default unless a has an integer dtype of less precision than the default platform integer. In that case, if a is signed then the platform integer is used while if a is unsigned then an unsigned integer of the same precision as the platform integer is used. ignore_nan : bool, optional If True, NaNs are ignored. Default is propagation of NaNs. Yields ------ online_sum : ndarray """ yield from ireduce_ufunc(arrays, ufunc = np.add, axis = axis, ignore_nan = ignore_nan, dtype = dtype)
def test_no_side_effects(self): """ Test that no arrays in the stream are modified """ for arr in self.source: arr.setflags(write = False) out = last(ireduce_ufunc(self.source, np.add))
def test_single_array(self): """ Test ireduce_ufunc on a single array, not a sequence """ source = np.ones( (16, 16), dtype = np.int) out = last(ireduce_ufunc(source, np.add, axis = -1)) self.assertTrue(np.allclose(source, out))
def test_output_shape(self): """ Test output shape """ for axis in (0, 1, 2, 3, None): with self.subTest('axis = {}'.format(axis)): from_numpy = np.add.reduce(self.stack, axis = axis) out = last(ireduce_ufunc(self.source, np.add, axis = axis)) self.assertSequenceEqual(from_numpy.shape, out.shape) self.assertTrue(np.allclose(out, from_numpy))
def test_ignore_nan(self): """ Test that ignore_nan is working """ for axis in (0, 1, 2, 3, None): with self.subTest('axis = {}'.format(axis)): out = last(ireduce_ufunc(self.source, np.add, axis = axis, ignore_nan = True)) self.assertFalse(np.any(np.isnan(out))) # Dynamics generation of tests on binary ufuncs
def con_two_dict(dic1,dic2): dic=[] for item in dic1: dic.append(item.copy()) for i in range(0,len(dic)): for k in dic2[i].keys(): if dic[i].__contains__(k): dic[i][k]=np.add(dic[i][k],dic2[i][k]) else: dic[i][k]=dic2[i][k] return dic
def compute_conf_intervals(data, cumulative=False): ''' Args: data (list): A 3D matrix, [algorithm][instance][episode] cumulative (bool) *opt ''' confidence_intervals_each_alg = [] # [alg][conf_inv_for_episode] for i, all_instances in enumerate(data): num_instances = len(data[i]) num_episodes = len(data[i][0]) all_instances = np.array(all_instances) alg_i_ci = [] total_so_far = np.zeros(num_instances) for j in xrange(num_episodes): # Compute datum for confidence interval. episode_j_all_instances = all_instances[:, j] if cumulative: # Cumulative. summed_vector = np.add(episode_j_all_instances, total_so_far) total_so_far = np.add(episode_j_all_instances, total_so_far) episode_j_all_instances = summed_vector # Compute the interval and add it to list. conf_interv = compute_single_conf_interval(episode_j_all_instances) alg_i_ci.append(conf_interv) confidence_intervals_each_alg.append(alg_i_ci) return confidence_intervals_each_alg
def __call__(self, sample): # keep tract of absolute value of self.diff = np.add(self.diff, np.absolute(np.asarray(sample.channel_data))) self.sample_count = self.sample_count + 1 elapsed_time = timeit.default_timer() - self.last_report if elapsed_time > self.polling_interval: channel_noise_power = np.divide(self.diff, self.sample_count) print (channel_noise_power) self.diff = np.zeros(self.eeg_channels) self.last_report = timeit.default_timer() # # Instanciate "monitor" thread
def predict(self, test): print('predict') y1 = np.dot(np.mat(self.theta1), np.mat(test).T) y1 = y1 + np.mat(self.input_layer_bias) # Add the bias y1 = self.sigmoid(y1) y2 = np.dot(np.array(self.theta2), y1) y2 = np.add(y2, self.hidden_layer_bias) # Add the bias y2 = self.sigmoid(y2) results = y2.T.tolist()[0] return results.index(max(results))
def sample(gt, n, im_size, scale_factor, transfer_range, scale_range, valid, verbose=False): samp = np.array([gt[0]+gt[2]/2.0, gt[1]+gt[3]/2.0, gt[2], gt[3]]) samples = np.repeat(np.reshape(samp, [1, -1]), n, axis=0) h, w = im_size if verbose: print(w, h) print(gt) print(samp) print(transfer_range) print(scale_range) samples[:, 0] = np.add(samples[:, 0], transfer_range*samp[2]*(np.random.rand(n)*2-1)) samples[:, 1] = np.add(samples[:, 1], transfer_range*samp[3]*(np.random.rand(n)*2-1)) samples[:, 2:] = np.multiply(samples[:, 2:], np.power(scale_factor, scale_range*np.repeat(np.random.rand(n,1)*2-1,2,axis=1))) samples[:, 2] = np.maximum(0, np.minimum(w-5, samples[:,2])) samples[:, 3] = np.maximum(0, np.minimum(h-5, samples[:,3])) if verbose: print(samples[0]) samples = np.c_[samples[:,0]-samples[:,2]/2, samples[:,1]-samples[:,3]/2, samples[:,2], samples[:,3]] if verbose: print(samples[0]) if valid: samples[:,0] = np.maximum(0,np.minimum(w-samples[:,2],samples[:,0])) samples[:,1] = np.maximum(0,np.minimum(h-samples[:,3],samples[:,1])) else: samples[:,0] = np.maximum(0-samples[:,2]/2,np.minimum(w-samples[:,2]/2,samples[:,0])) samples[:,1] = np.maximum(0-samples[:,3]/2,np.minimum(h-samples[:,3]/2,samples[:,1])) if verbose: print(samples[0]) return samples ########################################################################### # overlap_ratio # ###########################################################################
def set_attributes(self, task): """Set key replacement dictionary.""" Utility.set_attributes(self, task) self._operands = task.get('operands', []) if not self._operands: raise ValueError('`Operator` must have at least one operand.') self._result = task.get('result', 'result') self._op = self.ops.get(task.get('operator', '+'), np.add)
def evaluate_model(self, x, w): if not self.regularization or self.lambd == 0: edge_weight = x.dot(w) edge_weight = np.multiply(edge_weight, self.skipped) else: edge_weight = np.zeros((1, self.num_edges)) for idx, value in izip(x.indices, x.data): # edge_weight = np.add(edge_weight, np.multiply(value, np.multiply(np.maximum(np.subtract(np.abs(w[idx, :]), self.lambd), 0), np.sign(w[idx, :])))) for edge in xrange(self.num_edges): if w[idx, edge] > self.lambd: edge_weight[0, edge] += value * (w[idx, edge] - self.lambd) elif w[idx, edge] < -self.lambd: edge_weight[0, edge] += value * (w[idx, edge] + self.lambd) return edge_weight
def get_unseen_labels(self, y): unseen = set(y).difference(self.classes_seen) for c in unseen: self.classes_seen.add(c) return unseen
def pathl(cop_dat): # to calculate COP path length delt = np.diff(cop_dat[:,(0,1)], axis = 0) sqs = np.square(delt) sum_s = np.add(sqs[:,0],sqs[:,1]) lgths = np.sqrt(sum_s) return np.sum(lgths)
def test_reduce(self,level=rlevel): # Ticket #40 assert_almost_equal(np.add.reduce([1., .5], dtype=None), 1.5)
def test_add_identity(self,level=rlevel): # Ticket #143 assert_equal(0, np.add.identity)
