我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.clip()。
def clipped_linscale_img(img_array, cap=255.0, lomult=2.0, himult=2.0): ''' This clips the image between the values: [median(img_array) - lomult*stdev(img_array), median(img_array) + himult*stdev(img_array)] and returns a linearly scaled image using the cap given. ''' img_med, img_stdev = np.median(img_array), np.std(img_array) clipped_linear_img = np.clip(img_array, img_med-lomult*img_stdev, img_med+himult*img_stdev) return cap*clipped_linear_img/(img_med+himult*img_stdev)
def idle(self): """Updates the QLearning table, retrieves an action to be performed and checks for dead-ends.""" state = NavigationState(self.perception_) action = self.learning_model.update(state).action_ if (all(s.imminent_collision for s in self.sensors['proximity']) or self.sensors['orientation'][0].is_lying_on_the_ground): # There's nothing left to do. Flag this is a dead-end. self.behavior_ = self.BEHAVIORS.stuck else: move_to = self.INSTRUCTIONS_MAP[action] if action < ACTIONS.left: # It's walking straight or backwards. Reduce step size if it's # going against a close obstacle. dx = self.sensors['proximity'][action.index].distance move_to = np.clip(move_to, -dx, dx).tolist() self.motion.post.moveTo(move_to) self.behavior_ = self.BEHAVIORS.moving return self
def compHistDistance(h1, h2): def normalize(h): if np.sum(h) == 0: return h else: return h / np.sum(h) def smoothstep(x, x_min=0., x_max=1., k=2.): m = 1. / (x_max - x_min) b = - m * x_min x = m * x + b return betainc(k, k, np.clip(x, 0., 1.)) def fn(X, Y, k): return 4. * (1. - smoothstep(Y, 0, (1 - Y) * X + Y + .1)) \ * np.sqrt(2 * X) * smoothstep(X, 0., 1. / k, 2) \ + 2. * smoothstep(Y, 0, (1 - Y) * X + Y + .1) \ * (1. - 2. * np.sqrt(2 * X) * smoothstep(X, 0., 1. / k, 2) - 0.5) h1 = normalize(h1) h2 = normalize(h2) return max(0, np.sum(fn(h2, h1, len(h1)))) # return np.sum(np.where(h2 != 0, h2 * np.log10(h2 / (h1 + 1e-10)), 0)) # KL divergence
def _step(self, action): # Clip xor Assert #actions = np.clip(actions,-self.joints_max_velocity, self.joints_max_velocity) #assert self.action_space.contains(action), "%r (%s) invalid"%(action, type(action)) # Actuate self._make_action(action) #self._make_action(action*self.joints_max_velocity) # Step self.step_simulation() # Observe self._make_observation() # Reward torso_pos_z = self.observation[0] # up/down torso_lvel_x = self.observation[4] r_alive = 1.0 reward = (16.0)*(r_alive) +(8.0)*(torso_lvel_x) # Early stop stand_threshold = 0.10 done = (torso_pos_z < stand_threshold) return self.observation, reward, done, {}
def _build_graph(self, image_size): self.image_size = image_size self.images = tf.placeholder(tf.float32, shape = (None, image_size, image_size, 3)) images_mini = tf.image.resize_images(self.images, size = (int(image_size/4), int(image_size/4))) self.images_blur = tf.image.resize_images(images_mini, size = (image_size, image_size)) self.net = U_Net(output_ch = 3, block_fn = 'origin') self.images_reconst = self.net(self.images_blur, reuse = False) # self.image_reconst can be [-inf +inf], so need to clip its value if visualize them as images. self.loss = tf.reduce_mean((self.images_reconst - self.images)**2) self.opt = tf.train.AdamOptimizer()\ .minimize(self.loss, var_list = self.net.vars) self.saver = tf.train.Saver() self.sess.run(tf.global_variables_initializer())
def deprocess(img4d): img = img4d.copy() if K.image_dim_ordering() == "th": # (B, C, H, W) img = img.reshape((img4d.shape[1], img4d.shape[2], img4d.shape[3])) # (C, H, W) -> (H, W, C) img = img.transpose((1, 2, 0)) else: # (B, H, W, C) img = img.reshape((img4d.shape[1], img4d.shape[2], img4d.shape[3])) img[:, :, 0] += 103.939 img[:, :, 1] += 116.779 img[:, :, 2] += 123.68 # BGR -> RGB img = img[:, :, ::-1] img = np.clip(img, 0, 255).astype("uint8") return img ########################### main ###########################
def deprocess(img4d): img = img4d.copy() if K.image_dim_ordering() == "th": # (B, C, H, W) img = img.reshape((img4d.shape[1], img4d.shape[2], img4d.shape[3])) # (C, H, W) -> (H, W, C) img = img.transpose((1, 2, 0)) else: # (B, H, W, C) img = img.reshape((img4d.shape[1], img4d.shape[2], img4d.shape[3])) img[:, :, 0] += 103.939 img[:, :, 1] += 116.779 img[:, :, 2] += 123.68 # BGR -> RGB img = img[:, :, ::-1] img = np.clip(img, 0, 255).astype("uint8") return img
def forward(self, outputs, targets): """SoftmaxCategoricalCrossEntropy forward propagation. .. math:: L_i = - \\sum_j{t_{i,j} \\log(p_{i,j})} Parameters ---------- outputs : numpy.array Predictions in (0, 1), such as softmax output of a neural network, with data points in rows and class probabilities in columns. targets : numpy.array Either targets in [0, 1] matching the layout of `outputs`, or a vector of int giving the correct class index per data point. Returns ------- numpy 1D array An expression for the item-wise categorical cross-entropy. """ outputs = np.clip(outputs, self.epsilon, 1 - self.epsilon) return np.mean(-np.sum(targets * np.log(outputs), axis=1))
def backward(self, outputs, targets): """SoftmaxCategoricalCrossEntropy backward propagation. .. math:: dE = p - t Parameters ---------- outputs : numpy 2D array Predictions in (0, 1), such as softmax output of a neural network, with data points in rows and class probabilities in columns. targets : numpy 2D array Either targets in [0, 1] matching the layout of `outputs`, or a vector of int giving the correct class index per data point. Returns ------- numpy 1D array """ outputs = np.clip(outputs, self.epsilon, 1 - self.epsilon) return outputs - targets
def mouseDragEvent(self, ev): if self.movable and ev.button() == QtCore.Qt.LeftButton: if ev.isStart(): self._moving = True self._cursorOffset = self._posToRel(ev.buttonDownPos()) self._startPosition = self.orthoPos ev.accept() if not self._moving: return rel = self._posToRel(ev.pos()) self.orthoPos = np.clip(self._startPosition + rel - self._cursorOffset, 0, 1) self.updatePosition() if ev.isFinish(): self._moving = False
def test_rescaleData(): dtypes = map(np.dtype, ('ubyte', 'uint16', 'byte', 'int16', 'int', 'float')) for dtype1 in dtypes: for dtype2 in dtypes: data = (np.random.random(size=10) * 2**32 - 2**31).astype(dtype1) for scale, offset in [(10, 0), (10., 0.), (1, -50), (0.2, 0.5), (0.001, 0)]: if dtype2.kind in 'iu': lim = np.iinfo(dtype2) lim = lim.min, lim.max else: lim = (-np.inf, np.inf) s1 = np.clip(float(scale) * (data-float(offset)), *lim).astype(dtype2) s2 = pg.rescaleData(data, scale, offset, dtype2) assert s1.dtype == s2.dtype if dtype2.kind in 'iu': assert np.all(s1 == s2) else: assert np.allclose(s1, s2)
def map(self, data): data = data[self.fieldName] colors = np.empty((len(data), 4)) default = np.array(fn.colorTuple(self['Default'])) / 255. colors[:] = default for v in self.param('Values'): mask = data == v.maskValue c = np.array(fn.colorTuple(v.value())) / 255. colors[mask] = c #scaled = np.clip((data-self['Min']) / (self['Max']-self['Min']), 0, 1) #cmap = self.value() #colors = cmap.map(scaled, mode='float') #mask = np.isnan(data) | np.isinf(data) #nanColor = self['NaN'] #nanColor = (nanColor.red()/255., nanColor.green()/255., nanColor.blue()/255., nanColor.alpha()/255.) #colors[mask] = nanColor return colors
def _aperture(self): """ Determine aperture automatically under a variety of conditions. """ iso = self.iso exp = self.exposure light = self.lightMeter try: # shutter-priority mode sh = self.shutter # this raises RuntimeError if shutter has not # been specified ap = 4.0 * (sh / (1./60.)) * (iso / 100.) * (2 ** exp) * (2 ** light) ap = np.clip(ap, 2.0, 16.0) except RuntimeError: # program mode; we can select a suitable shutter # value at the same time. sh = (1./60.) raise return ap
def multiclass_log_loss(y_true, y_pred, eps=1e-15): """Multi class version of Logarithmic Loss metric. https://www.kaggle.com/wiki/MultiClassLogLoss Parameters ---------- y_true : array, shape = [n_samples] true class, intergers in [0, n_classes - 1) y_pred : array, shape = [n_samples, n_classes] Returns ------- loss : float """ predictions = np.clip(y_pred, eps, 1 - eps) # normalize row sums to 1 predictions /= predictions.sum(axis=1)[:, np.newaxis] actual = np.zeros(y_pred.shape) n_samples = actual.shape[0] actual[np.arange(n_samples), y_true.astype(int)] = 1 vectsum = np.sum(actual * np.log(predictions)) loss = -1.0 / n_samples * vectsum return loss
def eval(name,clip=False,bar=0.9): base = pd.read_csv('../input/stage1_solution_filtered.csv') base['Class'] = np.argmax(base[['class%d'%i for i in range(1,10)]].values,axis=1) sub = pd.read_csv(name) #sub = pd.merge(sub,base[['ID','Class']],on="ID",how='right') #print(sub.head()) y = base['Class'].values yp = sub[['class%d'%i for i in range(1,10)]].values if clip: yp = np.clip(yp,(1.0-bar)/8,bar) yp = yp/np.sum(yp,axis=1).reshape([yp.shape[0],1]) print(name,cross_entropy(y,yp),multiclass_log_loss(y,yp)) for i in range(9): y1 = y[y==i] yp1 = yp[y==i] print(i,y1.shape,cross_entropy(y1,yp1),multiclass_log_loss(y1,yp1))
def random_saturation(img, label, lower=0.5, upper=1.5): """ Multiplies saturation with a constant and clips the value between [0,1.0] Args: img: input image in float32 label: returns label unchanged lower: lower val for sampling upper: upper val for sampling """ alpha = lower + (upper - lower) * rand.rand() hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) # saturation should always be within [0,1.0] hsv[:, :, 1] = np.clip(alpha * hsv[:, :, 1], 0.0, 1.0) return cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR), label
def prior_cdf(self, u): """Inverse cumulative density function from Kroupa 2001b. output mass scaled to 0-1 interval min mass before scaling = 0.01 """ self._norm = 1. / self.kroupa_cdf(self._max_value, 1) if u < self.kroupa_cdf(0.08, self._norm): value = (u * (0.7) / self._norm * 0.08**(-0.3) + 0.01**0.7)**(1 / 0.7) elif u < self.kroupa_cdf(0.5, self._norm): value = (((u - (self._norm / 0.7 * 0.08**0.3 * (0.08**0.7 - 0.01**0.7))) * (-0.3) / self._norm * 0.08**(-1.3) + 0.08**(-0.3))**(1 / -0.3)) else: value = (((u - (self._norm / -0.3) * 0.08**1.3 * (0.5**(-0.3) - 0.08**(-0.3)) - (self._norm / 0.7 * 0.08**0.3 * (0.08**0.7 - 0.01**0.7))) * -1.3 / self._norm * 0.5**(-2.3) * (6.25)**1.3 + 0.5**(-1.3))**(1 / -1.3)) value = (value - self._min_value) / (self._max_value - self._min_value) # np.clip in case of python errors in line above return np.clip(value, 0.0, 1.0)
def sample_crop(self, n): kx = np.array([len(x) for x in self.maps_with_class]) class_hist = np.random.multinomial(n, self.class_probs * (kx != 0)) class_ids = np.repeat(np.arange(class_hist.shape[0]), class_hist) X = [] for class_id in class_ids: for i in range(20): random_image_idx = np.random.choice(self.maps_with_class[class_id]) if random_image_idx < 25: break x = self.kde_samplers[random_image_idx][class_id].sample()[0] x /= self.mask_size x = np.clip(x, 0., 1.) return x, class_id, random_image_idx X.append(x) return X
def rel_crop(im, rel_cx, rel_cy, crop_size): map_size = im.shape[1] r = crop_size / 2 abs_cx = rel_cx * map_size abs_cy = rel_cy * map_size na = np.floor([abs_cy-r, abs_cy+r, abs_cx-r, abs_cx+r]).astype(np.int32) a = np.clip(na, 0, map_size) px0 = a[2] - na[2] px1 = na[3] - a[3] py0 = a[0] - na[0] py1 = na[1] - a[1] crop = im[a[0]:a[1], a[2]:a[3]] crop = np.pad(crop, ((py0, py1), (px0, px1), (0, 0)), mode='reflect') assert crop.shape == (crop_size, crop_size, im.shape[2]) return crop
def deprocess_and_save(x, img_path): # Remove the batch dimension x = np.squeeze(x) # Restore the mean values on each channel x[:, :, 0] += 103.939 x[:, :, 1] += 116.779 x[:, :, 2] += 123.68 # BGR --> RGB x = x[:, :, ::-1] # Clip unprintable colours x = np.clip(x, 0, 255).astype('uint8') # Save the image imsave(img_path, x)
def _load_dataset_clipping(self, dataset_dir, epsilon): """Helper method which loads dataset and determines clipping range. Args: dataset_dir: location of the dataset. epsilon: maximum allowed size of adversarial perturbation. """ self.dataset_max_clip = {} self.dataset_min_clip = {} self._dataset_image_count = 0 for fname in os.listdir(dataset_dir): if not fname.endswith('.png'): continue image_id = fname[:-4] image = np.array( Image.open(os.path.join(dataset_dir, fname)).convert('RGB')) image = image.astype('int32') self._dataset_image_count += 1 self.dataset_max_clip[image_id] = np.clip(image + epsilon, 0, 255).astype('uint8') self.dataset_min_clip[image_id] = np.clip(image - epsilon, 0, 255).astype('uint8')
def cleverhans_attack_wrapper(cleverhans_attack_fn, reset=True): def attack(a): session = tf.Session() with session.as_default(): model = RVBCleverhansModel(a) adversarial_image = cleverhans_attack_fn(model, session, a) adversarial_image = np.squeeze(adversarial_image, axis=0) if reset: # optionally, reset to ignore other adversarials # found during the search a._reset() # run predictions to make sure the returned adversarial # is taken into account min_, max_ = a.bounds() adversarial_image = np.clip(adversarial_image, min_, max_) a.predictions(adversarial_image) return attack
def ExpM(self): """ Approximate a signal via element-wise exponentiation. As appears in : S.I. Mimilakis, K. Drossos, T. Virtanen, and G. Schuller, "Deep Neural Networks for Dynamic Range Compression in Mastering Applications," in proc. of the 140th Audio Engineering Society Convention, Paris, 2016. Args: sTarget: (2D ndarray) Magnitude Spectrogram of the target component nResidual: (2D ndarray) Magnitude Spectrogram of the residual component Returns: mask: (2D ndarray) Array that contains time frequency gain values """ print('Exponential mask') self._mask = np.divide(np.log(self._sTarget.clip(self._eps, np.inf)**self._alpha),\ np.log(self._nResidual.clip(self._eps, np.inf)**self._alpha))
def puzzle_plot(p): p.setup() def name(template): return template.format(p.__name__) from itertools import islice configs = list(islice(p.generate_configs(9), 1000)) # be careful, islice is not immutable!!! import numpy.random as random random.shuffle(configs) configs = configs[:10] puzzles = p.generate(configs, 3, 3) print(puzzles.shape, "mean", puzzles.mean(), "stdev", np.std(puzzles)) plot_image(puzzles[-1], name("{}.png")) plot_image(np.clip(puzzles[-1]+np.random.normal(0,0.1,puzzles[-1].shape),0,1),name("{}+noise.png")) plot_image(np.round(np.clip(puzzles[-1]+np.random.normal(0,0.1,puzzles[-1].shape),0,1)),name("{}+noise+round.png")) plot_grid(puzzles, name("{}s.png")) _transitions = p.transitions(3,3,configs=configs) print(_transitions.shape) transitions_for_show = \ np.einsum('ba...->ab...',_transitions) \ .reshape((-1,)+_transitions.shape[2:]) print(transitions_for_show.shape) plot_grid(transitions_for_show, name("{}_transitions.png"))
def test_simple_nonnative(self): # Test non native double input with scalar min/max. # Test native double input with non native double scalar min/max. a = self._generate_non_native_data(self.nr, self.nc) m = -0.5 M = 0.6 ac = self.fastclip(a, m, M) act = self.clip(a, m, M) assert_array_equal(ac, act) # Test native double input with non native double scalar min/max. a = self._generate_data(self.nr, self.nc) m = -0.5 M = self._neg_byteorder(0.6) assert_(not M.dtype.isnative) ac = self.fastclip(a, m, M) act = self.clip(a, m, M) assert_array_equal(ac, act)
def test_simple_complex(self): # Test native complex input with native double scalar min/max. # Test native input with complex double scalar min/max. a = 3 * self._generate_data_complex(self.nr, self.nc) m = -0.5 M = 1. ac = self.fastclip(a, m, M) act = self.clip(a, m, M) assert_array_strict_equal(ac, act) # Test native input with complex double scalar min/max. a = 3 * self._generate_data(self.nr, self.nc) m = -0.5 + 1.j M = 1. + 2.j ac = self.fastclip(a, m, M) act = self.clip(a, m, M) assert_array_strict_equal(ac, act)
def clip(val, minval, maxval): if val > HUGE_VALUE: val = HUGE_VALUE if val < EPSILON: val = EPSILON if val < minval: return minval if val > maxval: return maxval return val
def _clip(self, action): maxs = self.env.action_space.high mins = self.env.action_space.low if isinstance(action, np.ndarray): np.clip(action, mins, maxs, out=action) elif isinstance(action, list): for i in range(len(action)): action[i] = clip(action[i], mins[i], maxs[i]) else: action = clip(action, mins[0], maxs[0]) return action
def __init__(self, env, shape, clip=10.0, update_freq=100): self.env = env self.clip = clip self.update_freq = update_freq self.count = 0 self.sum = 0.0 self.sum_sqr = 0.0 self.mean = np.zeros(shape, dtype=np.double) self.std = np.ones(shape, dtype=np.double)
def _update(self): self.mean = self.sum / self.count self.std = self.sum_sqr / self.count - self.mean**2 self.std = np.clip(self.std, 1e-2, 1e9)**0.5
def normalize(self, new_state): # Update self.count += 1 self.sum += new_state self.sum_sqr += new_state**2 if self.count % self.update_freq == 0 and False: self._update() # Normalize new_state = new_state - self.mean new_state = new_state / self.std new_state = np.clip(new_state, -self.clip, self.clip) return new_state
def random_channel_shift(x, intensity, channel_axis=0): x = np.rollaxis(x, channel_axis, 0) min_x, max_x = np.min(x), np.max(x) channel_images = [np.clip(x_channel + np.random.uniform(-intensity, intensity), min_x, max_x) for x_channel in x] x = np.stack(channel_images, axis=0) x = np.rollaxis(x, 0, channel_axis + 1) return x
def saveFinalPlots(self, errors_train, errors_test, sparsity_train, sparsity_test, errors_train_vector, errors_test_vector, epoch=0): #plot errors plt.figure(2, figsize=(10, 7)) plt.clf() plt.plot(np.arange(len(errors_train)), errors_train, label='train error') plt.plot(np.arange(len(errors_train)), errors_test, label='test error') plt.colors() plt.legend() plt.title('Reconstruction error convergence') plt.xlabel('t') plt.ylabel('Reconstruction error') plt.savefig('plots/Reconstruction_errors_'+str(epoch)+'.pdf') #plot sparsity, real and non-zero plt.figure(3, figsize=(10, 7)) plt.clf() plt.plot(np.arange(len(sparsity_train)), sparsity_train, label='train error') plt.plot(np.arange(len(sparsity_test)), sparsity_test, label='test error') plt.colors() plt.legend() plt.title('Objective function error convergence') plt.xlabel('t') plt.ylabel('E') plt.savefig('plots/Sparsity_'+str(epoch)+'.pdf') # plot reconstruction error output progression over time plt.figure(12, figsize=(10, 7)) plt.clf() image=plt.imshow(np.clip(np.asarray(errors_train_vector).T, 0, 1), interpolation='nearest', aspect='auto', origin='lower') plt.xlabel('t') plt.ylabel('Output units \n (Rank Ordered)') plt.colors() plt.colorbar(image, label='reconstruction error') plt.title('Progressive reconstruction input error convergence') plt.savefig('plots/Reconstruction_errors_vector_' + str(epoch) + '.pdf')
def activation(self, X, out=None): return np.clip(X, 0, 1, out=out)
def clip(self, X, out=None): return np.clip(X, -1, 1, out=out)
def forward_prop(self): # backprop self.output_error = np.sum(self.errors * self.weights, axis=0).reshape(1, -1) self.output_error /= self.weights.shape[0] self.output_error *= self.derivative(self.output_raw, self.output_error) # clip gradient to not exceed zero self.output_error[self.output_raw > 0] = \ np.maximum(-self.output_raw[self.output_raw > 0],self.output_error[self.output_raw > 0]) self.output_error[self.output_raw < 0] = \ np.minimum(-self.output_raw[self.output_raw < 0],self.output_error[self.output_raw < 0])
def update_weights_final(self): # clip the gradient norm norm = np.sqrt(np.sum(self.gradient ** 2, axis=0)) norm_check = norm > self.norm_limit self.gradient[:, norm_check] = ((self.gradient[:, norm_check]) / norm[norm_check]) * self.norm_limit # update weights self.weights += self.gradient * (self.learning_rate) # update output average for sorting weights self.output_average *= 0.99999 self.output_average += self.output.ravel() * 0.00001
def _sample_noise_precision(self): prior_observations = .1 * self.batch_size shape = prior_observations + self.batch_size / 2 rate = prior_observations / self._noise_precision_value + np.mean(self._target_loss_ema) / 2 scale = 1. / rate sample = np.clip(np.random.gamma(shape, scale), 10., 1000.) return sample
def _sample_weights_precision(self): prior_observations = .1 * self.position_size shape = prior_observations + self.position_size / 2 rate = prior_observations / self._weights_precision_value + np.mean(self._weight_norm_ema) / 2 scale = 1. / rate sample = np.clip(np.random.gamma(shape, scale), .1, 10.) return sample
def _sample_weights(self, aim_error, accuracy_error): """Sample weights based on the error. Parameters ---------- aim_error : np.ndarray The aim errors for each sample. accuracy_error : np.ndarray The accuracy error errors for each sample. Returns ------- weights : np.ndarray The weights for each sample. Notes ----- This weighs samples based on their standard deviations above the mean with some clipping. """ aim_zscore = (aim_error - aim_error.mean()) / aim_error.std() aim_weight = np.clip(aim_zscore, 1, 4) / 4 accuracy_zscore = ( accuracy_error - accuracy_error.mean() ) / accuracy_error.std() accuracy_weight = np.clip(accuracy_zscore, 1, 4) / 4 return { 'aim_error': aim_weight, 'accuracy_error': accuracy_weight, }
def jitter_point_cloud(batch_data, sigma=0.01, clip=0.05): """ Randomly jitter points. jittering is per point. Input: BxNx3 array, original batch of point clouds Return: BxNx3 array, jittered batch of point clouds """ B, N, C = batch_data.shape assert(clip > 0) jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip) jittered_data += batch_data return jittered_data
def add_noise(x_clean, noise_factor): x = x_clean.copy() x_shape = x.shape x = x + noise_factor * 255 * (np.random.normal(loc=0.0, scale=1.0, size=x_shape) + 1) / 2 x_noisy = np.clip(x, 0., 255.) return x_noisy # converts image list to a normed image list (used as input for NN)
def to_32F(image): if image.max() > 1.0: image = image / 255.0 return np.clip(np.float32(image), 0, 1)
def to_8U(image): if image.max() <= 1.0: image = image * 255.0 return np.clip(np.uint8(image), 0, 255)
def applyColorAugmentation(self, img, std=0.55, gamma=2.5): '''Applies random color augmentation following [1]. An additional gamma transformation is added. [1] Alex Krizhevsky, Ilya Sutskever, Geoffrey E. Hinton. ImageNet Classification with Deep Convolutional Neural Networks. NIPS 2012. ''' alpha = np.clip(np.random.normal(0, std, size=3), -1.3 * std, 1.3 * std) perturbation = self.data_evecs.dot((alpha * np.sqrt(self.data_evals)).T) gamma = 1.0 - sum(perturbation) / gamma return np.power(np.clip(img + perturbation, 0., 1.), gamma) return np.clip((img + perturbation), 0., 1.)
def applyColorAugmentation(img, std=0.5): '''Applies random color augmentation following [1]. [1] Alex Krizhevsky, Ilya Sutskever, Geoffrey E. Hinton. \ ImageNet Classification with Deep Convolutional Neural Networks. \ NIPS 2012.''' alpha = np.clip(np.random.normal(0, std, size=3), -2 * std, 2. * std) perturbation = sld_evecs.dot((alpha * np.sqrt(sld_evals)).T) gamma = 1.0 - sum(perturbation) / 3. return np.power(np.clip(img + perturbation, 0., 1.), gamma) return np.clip((img + perturbation), 0., 1.)
