Python math.sqrt() Examples
The following are 30
code examples of math.sqrt().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
math
, or try the search function
.
Example #1
Source File: model.py From cat-bbs with MIT License | 8 votes |
def __init__(self, block, layers, num_classes=1000): self.inplanes = 64 super(MyResNet, self).__init__() self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) # note the increasing dilation self.layer1 = self._make_layer(block, 64, layers[0]) self.layer2 = self._make_layer(block, 128, layers[1], stride=2, dilation=1) self.layer3 = self._make_layer(block, 256, layers[2], stride=1, dilation=2) self.layer4 = self._make_layer(block, 512, layers[3], stride=1, dilation=4) # these layers will not be used self.avgpool = nn.AvgPool2d(7) self.fc = nn.Linear(512 * block.expansion, num_classes) for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1) m.bias.data.zero_()
Example #2
Source File: resnet_v1.py From Collaborative-Learning-for-Weakly-Supervised-Object-Detection with MIT License | 7 votes |
def __init__(self, block, layers, num_classes=1000): self.inplanes = 64 super(ResNet, self).__init__() self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) # maxpool different from pytorch-resnet, to match tf-faster-rcnn self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = self._make_layer(block, 64, layers[0]) self.layer2 = self._make_layer(block, 128, layers[1], stride=2) self.layer3 = self._make_layer(block, 256, layers[2], stride=2) # use stride 1 for the last conv4 layer (same as tf-faster-rcnn) self.layer4 = self._make_layer(block, 512, layers[3], stride=1) for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1) m.bias.data.zero_()
Example #3
Source File: L.E.S.M.A. - Fabrica de Noobs Speedtest.py From L.E.S.M.A with Apache License 2.0 | 6 votes |
def distance(origin, destination): """Determine distance between 2 sets of [lat,lon] in km""" lat1, lon1 = origin lat2, lon2 = destination radius = 6371 # km dlat = math.radians(lat2 - lat1) dlon = math.radians(lon2 - lon1) a = (math.sin(dlat / 2) * math.sin(dlat / 2) + math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) * math.sin(dlon / 2) * math.sin(dlon / 2)) c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a)) d = radius * c return d
Example #4
Source File: accountant.py From DOTA_models with Apache License 2.0 | 6 votes |
def get_privacy_spent(self, sess, target_eps=None): """Report the spending so far. Args: sess: the session to run the tensor. target_eps: the target epsilon. Unused. Returns: the list containing a single EpsDelta, with values as Python floats (as opposed to numpy.float64). This is to be consistent with MomentAccountant which can return a list of (eps, delta) pair. """ # pylint: disable=unused-argument unused_target_eps = target_eps eps_squared_sum, delta_sum = sess.run([self._eps_squared_sum, self._delta_sum]) return [EpsDelta(math.sqrt(eps_squared_sum), float(delta_sum))]
Example #5
Source File: test_optimizer.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def update(self, index, weight, grad, state): self._update_count(index) wd = self._get_wd(index) lr = self._get_lr(index) num_rows = weight.shape[0] dn, n = state for row in range(num_rows): all_zeros = mx.test_utils.almost_equal(grad[row].asnumpy(), np.zeros_like(grad[row].asnumpy())) if all_zeros and self.lazy_update: continue grad[row] = grad[row] * self.rescale_grad if self.clip_gradient is not None: mx.nd.clip(grad[row], -self.clip_gradient, self.clip_gradient, out=grad[row]) #update dn, n dn[row] += grad[row] - (mx.nd.sqrt(n[row] + grad[row] * grad[row]) - mx.nd.sqrt(n[row])) * weight[row] / lr n[row] += grad[row] * grad[row] # update weight weight[row] = (mx.nd.sign(dn[row]) * self.lamda1 - dn[row]) / \ ((self.beta + mx.nd.sqrt(n[row])) / lr + wd) * (mx.nd.abs(dn[row]) > self.lamda1)
Example #6
Source File: optimizer.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def update(self, index, weight, grad, state): assert(isinstance(weight, NDArray)) assert(isinstance(grad, NDArray)) wd = self._get_wd(index) self._update_count(index) # preprocess grad grad *= self.rescale_grad if self.clip_gradient is not None: grad = clip(grad, -self.clip_gradient, self.clip_gradient) # accumulated g and delta initlization acc_g, acc_delta = state # update g, delta acc_g[:] = self.rho * acc_g + (1. - self.rho) * grad * grad current_delta = sqrt(acc_delta + self.epsilon) / sqrt(acc_g + self.epsilon) * grad acc_delta[:] = self.rho * acc_delta + (1. - self.rho) * current_delta * current_delta # update weight weight[:] -= current_delta + wd * weight #pylint: disable=invalid-name #pylint: disable=line-too-long
Example #7
Source File: graph_layout.py From EDeN with MIT License | 6 votes |
def _compute_dE(self, pos=None, lengths=None, weights=None, m=None): dEx = 0 dEy = 0 d2Ex2 = 0 d2Ey2 = 0 d2Exy = 0 d2Eyx = 0 for i in pos: if i != m: xmi = pos[m][0] - pos[i][0] ymi = pos[m][1] - pos[i][1] xmi2 = xmi * xmi ymi2 = ymi * ymi xmi_ymi2 = xmi2 + ymi2 lmi = lengths[m][i] kmi = weights[m][i] / (lmi * lmi) dEx += kmi * (xmi - (lmi * xmi) / math.sqrt(xmi_ymi2)) dEy += kmi * (ymi - (lmi * ymi) / math.sqrt(xmi_ymi2)) d2Ex2 += kmi * (1 - (lmi * ymi2) / math.pow(xmi_ymi2, 1.5)) d2Ey2 += kmi * (1 - (lmi * xmi2) / math.pow(xmi_ymi2, 1.5)) res = kmi * (lmi * xmi * ymi) / math.pow(xmi_ymi2, 1.5) d2Exy += res d2Eyx += res return dEx, dEy, d2Ex2, d2Ey2, d2Exy, d2Eyx
Example #8
Source File: demo.py From unicorn-hat-hd with MIT License | 6 votes |
def swirl(x, y, step): x -= (u_width / 2) y -= (u_height / 2) dist = math.sqrt(pow(x, 2) + pow(y, 2)) / 2.0 angle = (step / 10.0) + (dist * 1.5) s = math.sin(angle) c = math.cos(angle) xs = x * c - y * s ys = x * s + y * c r = abs(xs + ys) r = r * 12.0 r -= 20 return (r, r + (s * 130), r + (c * 130)) # roto-zooming checker board
Example #9
Source File: optimizer.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def update(self, index, weight, grad, state): assert(isinstance(weight, NDArray)) assert(isinstance(grad, NDArray)) self._update_count(index) lr = self._get_lr(index) wd = self._get_wd(index) is_sparse = grad.stype == 'row_sparse' history = state if is_sparse: kwargs = {'epsilon': self.float_stable_eps, 'rescale_grad': self.rescale_grad} if self.clip_gradient: kwargs['clip_gradient'] = self.clip_gradient sparse.adagrad_update(weight, grad, history, out=weight, lr=lr, wd=wd, **kwargs) else: grad = grad * self.rescale_grad if self.clip_gradient is not None: grad = clip(grad, -self.clip_gradient, self.clip_gradient) history[:] += square(grad) div = grad / sqrt(history + self.float_stable_eps) weight[:] += (div + weight * wd) * -lr
Example #10
Source File: optimizer.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def _get_lbmult(self, nup): """Returns lr scaling factor for large batch according to warmup schedule (to be implemented) """ nwup = self.warmup_epochs * self.updates_per_epoch strategy = self.warmup_strategy maxmult = float(self.batch_scale) if nup >= nwup: mult = maxmult elif nwup <= 1: mult = 1.0 else: if (strategy == 'linear'): mult = 1.0 + (maxmult - 1) * nup / nwup elif (strategy == 'power2'): mult = 1.0 + (maxmult-1) * (nup*nup)/(nwup*nwup) elif (strategy == 'sqrt'): mult = 1.0 + (maxmult - 1) * math.sqrt(float(nup) / nwup) else: mult = 1.0 return mult
Example #11
Source File: initializer.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def _init_weight(self, name, arr): shape = arr.shape hw_scale = 1. if len(shape) < 2: raise ValueError('Xavier initializer cannot be applied to vector {0}. It requires at' ' least 2D.'.format(name)) if len(shape) > 2: hw_scale = np.prod(shape[2:]) fan_in, fan_out = shape[1] * hw_scale, shape[0] * hw_scale factor = 1. if self.factor_type == "avg": factor = (fan_in + fan_out) / 2.0 elif self.factor_type == "in": factor = fan_in elif self.factor_type == "out": factor = fan_out else: raise ValueError("Incorrect factor type") scale = np.sqrt(self.magnitude / factor) if self.rnd_type == "uniform": random.uniform(-scale, scale, out=arr) elif self.rnd_type == "gaussian": random.normal(0, scale, out=arr) else: raise ValueError("Unknown random type")
Example #12
Source File: initializer.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def set_verbosity(self, verbose=False, print_func=None): """Switch on/off verbose mode Parameters ---------- verbose : bool switch on/off verbose mode print_func : function A function that computes statistics of initialized arrays. Takes an `NDArray` and returns an `str`. Defaults to mean absolute value str((|x|/size(x)).asscalar()). """ self._verbose = verbose if print_func is None: def asum_stat(x): """returns |x|/size(x), async execution.""" return str((ndarray.norm(x)/sqrt(x.size)).asscalar()) print_func = asum_stat self._print_func = print_func return self
Example #13
Source File: metric.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def matthewscc(self): """ Calculate the Matthew's Correlation Coefficent """ if not self.total_examples: return 0. true_pos = float(self.true_positives) false_pos = float(self.false_positives) false_neg = float(self.false_negatives) true_neg = float(self.true_negatives) terms = [(true_pos + false_pos), (true_pos + false_neg), (true_neg + false_pos), (true_neg + false_neg)] denom = 1. for t in filter(lambda t: t != 0., terms): denom *= t return ((true_pos * true_neg) - (false_pos * false_neg)) / math.sqrt(denom)
Example #14
Source File: monitor.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def __init__(self, interval, stat_func=None, pattern='.*', sort=False): if stat_func is None: def asum_stat(x): """returns |x|/size(x), async execution.""" return ndarray.norm(x)/sqrt(x.size) stat_func = asum_stat self.stat_func = stat_func self.interval = interval self.activated = False self.queue = [] self.step = 0 self.exes = [] self.re_prog = re.compile(pattern) self.sort = sort def stat_helper(name, array): """wrapper for executor callback""" array = ctypes.cast(array, NDArrayHandle) array = NDArray(array, writable=False) if not self.activated or not self.re_prog.match(py_str(name)): return self.queue.append((self.step, py_str(name), self.stat_func(array))) self.stat_helper = stat_helper
Example #15
Source File: albunet.py From neural-pipeline with MIT License | 6 votes |
def __init__(self, block, layers, in_channels=3): self.inplanes = 64 super(ResNet, self).__init__() self.conv1 = nn.Conv2d(in_channels, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = self._make_layer(block, 64, layers[0]) self.layer2 = self._make_layer(block, 128, layers[1], stride=2) self.layer3 = self._make_layer(block, 256, layers[2], stride=2) self.layer4 = self._make_layer(block, 512, layers[3], stride=2) for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1) m.bias.data.zero_()
Example #16
Source File: gpt.py From comet-commonsense with Apache License 2.0 | 6 votes |
def _attn(self, q, k, v, sequence_mask): w = torch.matmul(q, k) if self.scale: w = w / math.sqrt(v.size(-1)) b_subset = self.b[:, :, :w.size(-2), :w.size(-1)] if sequence_mask is not None: b_subset = b_subset * sequence_mask.view( sequence_mask.size(0), 1, -1) b_subset = b_subset.permute(1, 0, 2, 3) w = w * b_subset + -1e9 * (1 - b_subset) w = nn.Softmax(dim=-1)(w) w = self.attn_dropout(w) return torch.matmul(w, v)
Example #17
Source File: video_transforms.py From DDPAE-video-prediction with MIT License | 6 votes |
def __call__(self, video): for attempt in range(10): area = video.shape[-3]*video.shape[-2] target_area = random.uniform(0.08, 1.0)*area aspect_ratio = random.uniform(3./4, 4./3) w = int(round(math.sqrt(target_area*aspect_ratio))) h = int(round(math.sqrt(target_area/aspect_ratio))) if random.random() < 0.5: w, h = h, w if w <= video.shape[-2] and h <= video.shape[-3]: x1 = random.randint(0, video.shape[-2]-w) y1 = random.randint(0, video.shape[-3]-h) video = video[..., y1:y1+h, x1:x1+w, :] return resize(video, (self.size, self.size), self.interpolation) # Fallback scale = Scale(self.size, interpolation=self.interpolation) crop = CenterCrop(self.size) return crop(scale(video))
Example #18
Source File: bloom.py From BiblioPixelAnimations with MIT License | 6 votes |
def genCubeVector(x, y, z, x_mult=1, y_mult=1, z_mult=1): """Generates a map of vector lengths from the center point to each coordinate x - width of matrix to generate y - height of matrix to generate z - depth of matrix to generate x_mult - value to scale x-axis by y_mult - value to scale y-axis by z_mult - value to scale z-axis by """ cX = (x - 1) / 2.0 cY = (y - 1) / 2.0 cZ = (z - 1) / 2.0 def vect(_x, _y, _z): return int(math.sqrt(math.pow(_x - cX, 2 * x_mult) + math.pow(_y - cY, 2 * y_mult) + math.pow(_z - cZ, 2 * z_mult))) return [[[vect(_x, _y, _z) for _z in range(z)] for _y in range(y)] for _x in range(x)]
Example #19
Source File: resnet.py From Random-Erasing with Apache License 2.0 | 5 votes |
def __init__(self, depth, num_classes=1000): super(ResNet, self).__init__() # Model type specifies number of layers for CIFAR-10 model assert (depth - 2) % 6 == 0, 'depth should be 6n+2' n = (depth - 2) / 6 block = Bottleneck if depth >=44 else BasicBlock self.inplanes = 16 self.conv1 = nn.Conv2d(1, 16, kernel_size=3, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(16) self.relu = nn.ReLU(inplace=True) self.layer1 = self._make_layer(block, 16, n) self.layer2 = self._make_layer(block, 32, n, stride=2) self.layer3 = self._make_layer(block, 64, n, stride=2) self.avgpool = nn.AvgPool2d(7) self.fc = nn.Linear(64 * block.expansion, num_classes) for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1) m.bias.data.zero_()
Example #20
Source File: alexnet_benchmark.py From DOTA_models with Apache License 2.0 | 5 votes |
def time_tensorflow_run(session, target, info_string): """Run the computation to obtain the target tensor and print timing stats. Args: session: the TensorFlow session to run the computation under. target: the target Tensor that is passed to the session's run() function. info_string: a string summarizing this run, to be printed with the stats. Returns: None """ num_steps_burn_in = 10 total_duration = 0.0 total_duration_squared = 0.0 for i in xrange(FLAGS.num_batches + num_steps_burn_in): start_time = time.time() _ = session.run(target) duration = time.time() - start_time if i >= num_steps_burn_in: if not i % 10: print ('%s: step %d, duration = %.3f' % (datetime.now(), i - num_steps_burn_in, duration)) total_duration += duration total_duration_squared += duration * duration mn = total_duration / FLAGS.num_batches vr = total_duration_squared / FLAGS.num_batches - mn * mn sd = math.sqrt(vr) print ('%s: %s across %d steps, %.3f +/- %.3f sec / batch' % (datetime.now(), info_string, FLAGS.num_batches, mn, sd))
Example #21
Source File: resnet.py From Random-Erasing with Apache License 2.0 | 5 votes |
def __init__(self, depth, num_classes=1000): super(ResNet, self).__init__() # Model type specifies number of layers for CIFAR-10 model assert (depth - 2) % 6 == 0, 'depth should be 6n+2' n = (depth - 2) // 6 block = Bottleneck if depth >=44 else BasicBlock self.inplanes = 16 self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(16) self.relu = nn.ReLU(inplace=True) self.layer1 = self._make_layer(block, 16, n) self.layer2 = self._make_layer(block, 32, n, stride=2) self.layer3 = self._make_layer(block, 64, n, stride=2) self.avgpool = nn.AvgPool2d(8) self.fc = nn.Linear(64 * block.expansion, num_classes) for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1) m.bias.data.zero_()
Example #22
Source File: wrn.py From Random-Erasing with Apache License 2.0 | 5 votes |
def __init__(self, depth, num_classes, widen_factor=1, dropRate=0.0): super(WideResNet, self).__init__() nChannels = [16, 16*widen_factor, 32*widen_factor, 64*widen_factor] assert (depth - 4) % 6 == 0, 'depth should be 6n+4' n = (depth - 4) / 6 block = BasicBlock # 1st conv before any network block self.conv1 = nn.Conv2d(3, nChannels[0], kernel_size=3, stride=1, padding=1, bias=False) # 1st block self.block1 = NetworkBlock(n, nChannels[0], nChannels[1], block, 1, dropRate) # 2nd block self.block2 = NetworkBlock(n, nChannels[1], nChannels[2], block, 2, dropRate) # 3rd block self.block3 = NetworkBlock(n, nChannels[2], nChannels[3], block, 2, dropRate) # global average pooling and classifier self.bn1 = nn.BatchNorm2d(nChannels[3]) self.relu = nn.ReLU(inplace=True) self.fc = nn.Linear(nChannels[3], num_classes) self.nChannels = nChannels[3] for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1) m.bias.data.zero_() elif isinstance(m, nn.Linear): m.bias.data.zero_()
Example #23
Source File: demo.py From unicorn-hat-hd with MIT License | 5 votes |
def tunnel(x, y, step): speed = step / 100.0 x -= (u_width / 2) y -= (u_height / 2) xo = math.sin(step / 27.0) * 2 yo = math.cos(step / 18.0) * 2 x += xo y += yo if y == 0: if x < 0: angle = -(math.pi / 2) else: angle = (math.pi / 2) else: angle = math.atan(x / y) if y > 0: angle += math.pi angle /= 2 * math.pi # convert angle to 0...1 range hyp = math.sqrt(math.pow(x, 2) + math.pow(y, 2)) shade = hyp / 2.1 shade = 1 if shade > 1 else shade angle += speed depth = speed + (hyp / 10) col1 = hue_to_rgb[step % 255] col1 = (col1[0] * 0.8, col1[1] * 0.8, col1[2] * 0.8) col2 = hue_to_rgb[step % 255] col2 = (col2[0] * 0.3, col2[1] * 0.3, col2[2] * 0.3) col = col1 if int(abs(angle * 6.0)) % 2 == 0 else col2 td = .3 if int(abs(depth * 3.0)) % 2 == 0 else 0 col = (col[0] + td, col[1] + td, col[2] + td) col = (col[0] * shade, col[1] * shade, col[2] * shade) return (col[0] * 255, col[1] * 255, col[2] * 255)
Example #24
Source File: wrn.py From Random-Erasing with Apache License 2.0 | 5 votes |
def __init__(self, depth, num_classes, widen_factor=1, dropRate=0.0): super(WideResNet, self).__init__() nChannels = [16, 16*widen_factor, 32*widen_factor, 64*widen_factor] assert (depth - 4) % 6 == 0, 'depth should be 6n+4' n = (depth - 4) // 6 block = BasicBlock # 1st conv before any network block self.conv1 = nn.Conv2d(1, nChannels[0], kernel_size=3, stride=1, padding=1, bias=False) # 1st block self.block1 = NetworkBlock(n, nChannels[0], nChannels[1], block, 1, dropRate) # 2nd block self.block2 = NetworkBlock(n, nChannels[1], nChannels[2], block, 2, dropRate) # 3rd block self.block3 = NetworkBlock(n, nChannels[2], nChannels[3], block, 2, dropRate) # global average pooling and classifier self.bn1 = nn.BatchNorm2d(nChannels[3]) self.relu = nn.ReLU(inplace=True) self.fc = nn.Linear(nChannels[3], num_classes) self.nChannels = nChannels[3] for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1) m.bias.data.zero_() elif isinstance(m, nn.Linear): m.bias.data.zero_()
Example #25
Source File: distance.py From DensityPeakCluster with MIT License | 5 votes |
def distance(self, vec1, vec2): """ Compute distance of two vector by square distance """ super(SqrtDistance, self).distance(vec1, vec2) #super method vec=vec1-vec2 return sqrt(sum([pow(item, 2) for item in vec])) #end SqrtDistance
Example #26
Source File: 43_rmsprop.py From deep-learning-note with MIT License | 5 votes |
def rmsprop_2d(x1, x2, s1, s2): g1, g2, eps = 0.2 * x1, 4 * x2, 1e-6 s1 = gamma * s1 + (1 - gamma) * g1 ** 2 s2 = gamma * s2 + (1 - gamma) * g2 ** 2 x1 -= eta / math.sqrt(s1 + eps) * g1 x2 -= eta / math.sqrt(s2 + eps) * g2 return x1, x2, s1, s2
Example #27
Source File: 43_rmsprop.py From deep-learning-note with MIT License | 5 votes |
def rmsprop(params, states, hyperparams): eps = 1e-6 gamma = hyperparams['gamma'] for p, s in zip(params, states): s.data = gamma * s.data + (1-gamma) * (p.grad.data)**2 p.data -= hyperparams['lr'] * p.grad.data / torch.sqrt(s + eps)
Example #28
Source File: 42_adagrad.py From deep-learning-note with MIT License | 5 votes |
def adagrad_2d(x1, x2, s1, s2): g1, g2, eps = 0.2 * x1, 4 * x2, 1e-6 s1 += g1 ** 2 s2 += g2 ** 2 x1 -= eta / math.sqrt(s1 + eps) * g1 x2 -= eta / math.sqrt(s2 + eps) * g2 return x1, x2, s1, s2
Example #29
Source File: distance.py From DensityPeakCluster with MIT License | 5 votes |
def distance(self, vec1, vec2): """ Compute distance of two vector by pearson distance """ super(PearsonDistance, self).distance(vec1, vec2) #super method avg1, avg2 = (self._avg(vec1), self._avg(vec2)) v1, v2 = ([item - avg1 for item in vec1[0]], [item - avg1 for item in vec2[0]]) sqrt1, sqrt2 = (sqrt(sum([pow(item, 2) for item in v1])), sqrt(sum([pow(item, 2) for item in v2]))) if sqrt1*sqrt2 == 0: return 1 return - reduce(lambda n,m:n+m, [i*j for i,j in zip(v1, v2)]) \ / (sqrt1*sqrt2)
Example #30
Source File: 42_adagrad.py From deep-learning-note with MIT License | 5 votes |
def adagrad(params, states, hyperparams): eps = 1e-6 for p, s in zip(params, states): s.data += (p.grad.data ** 2) p.data -= hyperparams['lr'] * p.grad.data / torch.sqrt(s + eps)