def _sampleDistribution(params, numSamples, verbosity=0): """ Given the parameters of a distribution, generate numSamples points from it. This routine is mostly for testing. :returns: A numpy array of samples. """ if params.has_key("name"): if params["name"] == "normal": samples = numpy.random.normal(loc=params["mean"], scale=math.sqrt(params["variance"]), size=numSamples) elif params["name"] == "pareto": samples = numpy.random.pareto(params["alpha"], size=numSamples) elif params["name"] == "beta": samples = numpy.random.beta(a=params["alpha"], b=params["beta"], size=numSamples) else: raise ValueError("Undefined distribution: " + params["name"]) else: raise ValueError("Bad distribution params: " + str(params)) if verbosity > 0: print "\nSampling from distribution:", params print "After estimation, mean=", cupy.mean(samples), \ "var=", cupy.var(samples), "stdev=", math.sqrt(cupy.var(samples)) return samples
def _t_test(self, with_sample, without_sample): """ compute one-tailed two-sample t-test with a test statistics according to t_j: \frac{\mu_j - \bar{\mu_j}}{\sqrt{\frac{s^2_j}{\norm{I_j}} + \frac{\bar{s^2_j}}{\norm{\bar{I_j}}}}} """ return (cp.mean(with_sample) - cp.mean(without_sample)) /\ cp.sqrt(cp.var(with_sample)**2 / len(with_sample) + cp.var(without_sample)**2 / len(without_sample))
def save_mean_and_variance(self): subset_size = self.num_observations_per_file new_total_size = self.total_images + subset_size co1 = self.total_images / new_total_size co2 = subset_size / new_total_size images = cp.asarray(self.images) subset_mean = cp.mean(images, axis=(0, 1)) subset_var = cp.var(images, axis=(0, 1)) new_dataset_mean = subset_mean if self.dataset_mean is None else co1 * self.dataset_mean + co2 * subset_mean new_dataset_var = subset_var if self.dataset_var is None else co1 * ( self.dataset_var + self.dataset_mean**2) + co2 * ( subset_var + subset_mean**2) - new_dataset_mean**2 # avoid negative value new_dataset_var[new_dataset_var < 0] = 0 self.dataset_var = new_dataset_var self.dataset_mean = new_dataset_mean self.dataset_std = cp.sqrt(self.dataset_var) cp.save(os.path.join(self.path, "mean.npy"), self.dataset_mean) cp.save(os.path.join(self.path, "std.npy"), self.dataset_std)
def forward(self, is_training=True): inputs = self.input_tensor # self.input_shape =inputs.shape gamma, beta = self.variables N, C, H, W = inputs.shape self.shape_field = tuple([i for i in range(2, inputs.ndim)]) x_group = cp.reshape(inputs, (N, self.G, C // self.G, H, W)) mean = cp.mean(x_group, axis=self.shape_field, keepdims=True) var = cp.var(x_group, axis=self.shape_field, keepdims=True) xgmu = x_group - mean sqrtvar = cp.sqrt(var + self.epsilon) x_group_norm = xgmu / sqrtvar x_norm = cp.reshape(x_group_norm, (N, C, H, W)) outputs = gamma.output_tensor * x_norm + beta.output_tensor self.cache = (xgmu, sqrtvar, x_norm) self.output_tensor = outputs if self.require_grads: self.grads = cp.zeros_like(self.output_tensor) super().forward(is_training)
def forward(self,is_training=True): inputs=self.input_tensor gamma,beta=self.variables outputs = cp.zeros_like(inputs) if is_training: self.cache = [] for k in range(inputs.shape[self.axis]): #calc mean mean=cp.mean(inputs[:,k]) #calc var var=cp.var(inputs[:,k]) #x minus u xmu=inputs[:,k]-mean sqrtvar=cp.sqrt(var+self.epsilon) normalized_x=xmu/sqrtvar outputs[:,k]=gamma.output_tensor[k]*normalized_x+beta.output_tensor[k] self.cache.append((xmu,sqrtvar,normalized_x)) self.moving_mean[k]=self.momentum*self.moving_mean[k]+(1-self.momentum)*mean self.moving_variance[k] = self.momentum * self.moving_variance[k] + (1 - self.momentum) * var else: for k in range(inputs.shape[self.axis]): std=cp.sqrt(self.moving_variance[k]+self.epsilon) outputs[:,k]=(gamma.output_tensor[k]/std)*inputs[:,k]+(beta.output_tensor[k]-gamma.output_tensor[k]*self.moving_mean[k]/std) self.output_tensor=outputs if self.require_grads: self.grads = cp.zeros_like(self.output_tensor) super().forward(is_training)
def var(inp) -> 'Tensor': _check_tensors(inp) engine = _get_engine(inp) return _create_tensor( inp, data=engine.var(inp.data), func=wrapped_partial(var_backward, inp=inp) )
def boxcox_llf(lmb, data): """The boxcox log-likelihood function. Parameters ---------- lmb : scalar Parameter for Box-Cox transformation data : array-like Data to calculate Box-Cox log-likelihood for. If `data` is multi-dimensional, the log-likelihood is calculated along the first axis Returns ------- llf : float or cupy.ndarray Box-Cox log-likelihood of `data` given `lmb`. A float for 1-D `data`, an array otherwise See Also -------- scipy.stats.boxcox_llf """ if data.ndim == 1 and data.dtype == cupy.float16: data = data.astype(cupy.float64) if data.ndim == 1 and data.dtype == cupy.float32: data = data.astype(cupy.float64) if data.ndim == 1 and data.dtype == cupy.complex64: data = data.astype(cupy.complex128) N = data.shape[0] if N == 0: return cupy.array(cupy.nan) logdata = cupy.log(data) # Compute the variance of the transformed data if lmb == 0: variance = cupy.var(logdata, axis=0) else: variance = cupy.var(data**lmb / lmb, axis=0) return (lmb - 1) * cupy.sum(logdata, axis=0) - N / 2 * cupy.log(variance)
def forward(self, x): gamma = self.load('gamma') beta = self.load('beta') mu = cp.mean(x, axis=0) var = cp.var(x, axis=0) x_norm = (x - mu) / cp.sqrt(var + EPS) out = gamma * x_norm + beta self.save('input', x) self.save('mu', mu) self.save('var', var) return out
def forward(self, is_training=True): inputs = self.input_tensor self.input_shape = inputs.shape if self.input_tensor.ndim == 4: N, C, H, W = self.input_shape inputs = inputs.transpose(0, 3, 2, 1).reshape(N * H * W, C) gamma, beta = self.variables if is_training: #calc mean mean = cp.mean(inputs, axis=0) #calc var var = cp.var(inputs, axis=0) #x minus u xmu = inputs - mean sqrtvar = cp.sqrt(var + self.epsilon) normalized_x = xmu / sqrtvar outputs = gamma.output_tensor * normalized_x + beta.output_tensor self.cache = (xmu, sqrtvar, normalized_x) self.moving_mean = self.momentum * self.moving_mean + ( 1 - self.momentum) * mean self.moving_variance = self.momentum * self.moving_variance + ( 1 - self.momentum) * var else: scale = gamma.output_tensor / (cp.sqrt(self.moving_variance + self.epsilon)) outputs = inputs * scale + (beta.output_tensor - self.moving_mean * scale) if self.input_tensor.ndim == 4: N, C, H, W = self.input_shape outputs = outputs.reshape(N, W, H, C).transpose(0, 3, 2, 1) self.output_tensor = outputs if self.require_grads: self.grads = cp.zeros_like(self.output_tensor) super().forward(is_training)
def mdist(A, B): ret = cp.var(A - B) / (cp.var(A) + cp.var(B)) return 0.5 * ret
def chambolleProjectionGPU(f, f_ref, mi=100, tau=0.25, tol=1e-5): ''' The 2D case of Chambolle projection algorithm. This version uses reference image. Source ------- CywiĆska, Maria, Maciej Trusiak, and Krzysztof Patorski. "Automatized fringe pattern preprocessing using unsupervised variational image decomposition." Optics express 27.16 (2019): 22542-22562. Parameters ---------- f : cupy.ndarray image which is input for Chambolle f_ref : cupy.ndarray image og input but perfectly without background function mi : float regularization parameter that defines the separation of the energy between the fringes and noise components tau : float Chambolle projection step value tol : float error tolerance when algorithm should stop its work Returns ------- x_best : numpy.ndarray image with filtered background function it_min : int number of iterations that was needed to reach result image rms_min : float error of the result image ''' n = 1 xi = cp.array([cp.zeros(f.shape), cp.zeros(f.shape)]) x1 = cp.zeros(f.shape) x2 = cp.zeros(f.shape) x_best = cp.zeros(f.shape) rms_min_A = [] rms_min = 1.0 it_min = 0 for _ in iter(int, 1): gdv = cp.array(gradient2DGPU(divergence2DGPU(xi) - f / mi)) d = cp.sqrt(cp.power(gdv[0], 2) + cp.power(gdv[1], 2)) d = cp.tile(d, [2, 1, 1]) xi = cp.divide(xi + tau * gdv, 1 + tau * d) x2 = mi * divergence2DGPU(xi) diff = x2 - f_ref rms_n = cp.sqrt(cp.var(diff.flatten())) if len(rms_min_A) < 100: rms_min_A.append(rms_min) else: rms_min_A.pop(0) rms_min_A.append(rms_min) if rms_n < rms_min: rms_diff = rms_min_A[0] - rms_min_A[-1] rms_local_diff = rms_min - rms_n if (rms_diff < 10 * tol): if (rms_local_diff < tol): rms_min = rms_n it_min = n break rms_min = rms_n it_min = n x1 = x2 n = n + 1 if n - it_min >= 100: break pass x_best = x2 return [x_best, it_min, rms_min]
/, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, dtype: Optional[Dtype] = None, keepdims: bool = False, ) -> Array: if x.dtype not in _numeric_dtypes: raise TypeError("Only numeric dtypes are allowed in sum") # Note: sum() and prod() always upcast integers to (u)int64 and float32 to # float64 for dtype=None. `np.sum` does that too for integers, but not for # float32, so we need to special-case it here if dtype is None and x.dtype == float32: dtype = float64 return Array._new( np.sum(x._array, axis=axis, dtype=dtype, keepdims=keepdims)) def var( x: Array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, correction: Union[int, float] = 0.0, keepdims: bool = False, ) -> Array: # Note: the keyword argument correction is different here if x.dtype not in _floating_dtypes: raise TypeError("Only floating-point dtypes are allowed in var") return Array._new( np.var(x._array, axis=axis, ddof=correction, keepdims=keepdims))
def var(x): return cp.var(x, ddof=1) if x.size > 0 else cp.nan
def render(representation, camera_distance, start_t, end_t, gt_images, gt_viewpoints, animation_frame_array, rotate_camera=True): gt_images = np.squeeze(gt_images) gt_viewpoints = cp.reshape(cp.asarray(gt_viewpoints), (15, 1, 7)) idx = cp.argsort(cp.squeeze(gt_viewpoints)[:, 0]) gt_images = [ i for i, v in sorted(zip(gt_images, idx), key=operator.itemgetter(1)) ] gt_viewpoints = [ i for i, v in sorted(zip(gt_viewpoints, idx), key=operator.itemgetter(1)) ] count = 0 '''shows variance and mean images of 100 samples from the Gaussian.''' for t in range(start_t, end_t): artist_array = [ axis_observations.imshow(make_uint8(axis_observations_image), interpolation="none", animated=True) ] horizontal_angle_rad, vertical_angle_rad = compute_camera_angle_at_frame( t) if rotate_camera == False: horizontal_angle_rad, vertical_angle_rad = compute_camera_angle_at_frame( 0) query_viewpoints = rotate_query_viewpoint(horizontal_angle_rad, vertical_angle_rad, camera_distance) # shape 100x1x3x64x64, when Model is from model_testing.py generated_images = model.generate_image(query_viewpoints, representation, 100) # generate predicted from ground truth viewpoints predicted_images = model.generate_image(gt_viewpoints[count], representation, 1) # predicted_images = model.generate_image(query_viewpoints, representation,1) predicted_images = np.squeeze(predicted_images) image_mse = get_mse_image(gt_images[count], predicted_images) # when sampling with 100 cpu_generated_images = chainer.backends.cuda.to_cpu( generated_images) generated_images = np.squeeze(cpu_generated_images) # # cpu calculation # cpu_image_mean = np.mean(cpu_generated_images,axis=0) # cpu_image_std = np.std(cpu_generated_images,axis=0) # cpu_image_var = np.var(cpu_generated_images,axis=0) # image_mean = np.squeeze(chainer.backends.cuda.to_gpu(cpu_image_mean)) # image_std = chainer.backends.cuda.to_gpu(cpu_image_std) # image_var = np.squeeze(chainer.backends.cuda.to_gpu(cpu_image_var)) image_mean = cp.mean(cp.squeeze(generated_images), axis=0) image_var = cp.var(cp.squeeze(generated_images), axis=0) # convert to black and white. # grayscale r, g, b = image_var gray_image_var = 0.2989 * r + 0.5870 * g + 0.1140 * b # thresholding Otsu's method thresh = threshold_otsu(gray_image_var) var_binary = gray_image_var > thresh sample_image = np.squeeze(generated_images[0]) if count == 14: count = 0 elif (t - fps) % 10 == 0: count += 1 print("computed an image. Count =", count) artist_array.append( axis_generation_variance.imshow(var_binary, cmap=plt.cm.gray, interpolation="none", animated=True)) artist_array.append( axis_generation_mean.imshow(make_uint8(image_mean), interpolation="none", animated=True)) artist_array.append( axis_generation_sample.imshow(make_uint8(sample_image), interpolation="none", animated=True)) artist_array.append( axis_generation_mse.imshow(make_uint8(image_mse), cmap='gray', interpolation="none", animated=True)) animation_frame_array.append(artist_array)
def eegstats(signals, samples, statistic): import cupy as cp from scipy.stats import skew, kurtosis if statistic == 'mean': means = cp.zeros(samples) for i in range(len(signals)): means[i] = cp.mean(signals[i]) return means elif statistic == 'std': std = cp.zeros(samples) for i in range(len(signals)): std[i] = cp.std(signals[i]) return std elif statistic == 'skewness': skewness = cp.zeros(samples) for i in range(len(signals)): skewness[i] = skew(signals[i]) return skewness elif statistic == 'kurtosis': kurt = cp.zeros(samples) for i in range(len(signals)): kurt[i] = kurtosis(signals[i]) return kurt elif statistic == 'maximum': maxim = cp.zeros(samples) for i in range(len(signals)): maxim[i] = cp.amax(signals[i]) return maxim elif statistic == 'minimum': minim = cp.zeros(samples) for i in range(len(signals)): minim[i] = cp.amin(signals[i]) return minim ######## elif statistic == 'n5': n5 = cp.zeros(samples) for i in range(len(signals)): n5[i] = cp.percentile(cp.asarray(signals[i]), 5) return n5 elif statistic == 'n25': n25 = cp.zeros(samples) for i in range(len(signals)): n25[i] = cp.percentile(cp.asarray(signals[i]), 25) return n25 elif statistic == 'n75': n75 = cp.zeros(samples) for i in range(len(signals)): n75[i] = cp.percentile(cp.asarray(signals[i]), 75) return n75 elif statistic == 'n95': n95 = cp.zeros(samples) for i in range(len(signals)): n95[i] = cp.percentile(cp.asarray(signals[i]), 95) return n95 elif statistic == 'median': median = cp.zeros(samples) for i in range(len(signals)): median[i] = cp.percentile(cp.asarray(signals[i]), 50) return median elif statistic == 'variance': variance = cp.zeros(samples) for i in range(len(signals)): variance[i] = cp.var(cp.asarray(signals[i])) return variance elif statistic == 'rms': rms = cp.zeros(samples) for i in range(len(signals)): rms[i] = cp.mean(cp.sqrt(cp.asarray(signals[i])**2)) return rms
def render(representation, camera_distance, obs_viewpoint, start_t, end_t, animation_frame_array, savename=None, rotate_camera=True): all_var_bg = [] all_var = [] all_var_z = [] all_q_view = [] all_c = [] all_h = [] all_u = [] for t in range(start_t, end_t): artist_array = [ axis_observations.imshow(make_uint8(axis_observations_image), interpolation="none", animated=True) ] # convert x,y into radians?? # try reversing the camera direction calculation in rotate query viewpoint (impossible to reverse the linalg norm...) horizontal_angle_rad = np.arctan2(obs_viewpoint[0], obs_viewpoint[2]) vertical_angle_rad = np.arcsin(obs_viewpoint[1] / camera_distance) # xz_diagonal = np.sqrt(np.square(obs_viewpoint[0])+np.square(obs_viewpoint[2])) # vertical_angle_rad = np.arctan2(obs_viewpoint[1],xz_diagonal) # vertical_angle_rad = np.arcsin(obs_viewpoint[1]/camera_distance) # horizontal_angle_rad, vertical_angle_rad = 0,0 # ipdb.set_trace() horizontal_angle_rad, vertical_angle_rad = compute_vertical_rotation_at_frame( horizontal_angle_rad, vertical_angle_rad, t) if rotate_camera == False: horizontal_angle_rad, vertical_angle_rad = compute_camera_angle_at_frame( 0) query_viewpoints = rotate_query_viewpoint(horizontal_angle_rad, vertical_angle_rad, camera_distance) # obtain generated images, as well as mean and variance before gaussian generated_images, var_bg, latent_z, ct = model.generate_multi_image( query_viewpoints, representation, 100) logging.info("retrieved variables, time elapsed: " + str(time.time() - start_time)) # cpu_generated_images = chainer.backends.cuda.to_cpu(generated_images) generated_images = np.squeeze(generated_images) latent_z = np.squeeze(latent_z) # ipdb.set_trace() ct = np.squeeze(ct) # ht = np.squeeze(np.asarray(ht)) # ut = np.squeeze(np.asarray(ut)) # obtain data from Chainer Variable and obtain mean var_bg = cp.mean(var_bg, axis=0) logging.info("variance of bg, time elapsed: " + str(time.time() - start_time)) var_z = cp.var(latent_z, axis=0) logging.info("variance of z, time elapsed: " + str(time.time() - start_time)) # ipdb.set_trace() # print(ct.shape()) var_c = cp.var(ct, axis=0) logging.info("variance of c, time elapsed: " + str(time.time() - start_time)) # var_h = cp.var(ht,axis=0) # var_u = cp.var(ut,axis=0) # write viewpoint and image variance to file gen_img_var = np.var(generated_images, axis=0) logging.info("calculated variance of gen images, time elapsed: " + str(time.time() - start_time)) all_var_bg.append((var_bg)[None]) all_var.append((gen_img_var)[None]) all_var_z.append((var_z)[None]) all_q_view.append( chainer.backends.cuda.to_cpu(horizontal_angle_rad)[None] * 180 / math.pi) all_c.append((var_c)[None]) logging.info("appending, time elapsed: " + str(time.time() - start_time)) # all_h.append(chainer.backends.cuda.to_cpu(var_h)[None]) # all_u.append(chainer.backends.cuda.to_cpu(var_u)[None]) # sample = generated_images[0] pred_mean = cp.mean(generated_images, axis=0) # artist_array.append( # axis_generation.imshow( # make_uint8(pred_mean), # interpolation="none", # animated=True)) # animation_frame_array.append(artist_array) all_var_bg = np.concatenate(chainer.backends.cuda.to_cpu(all_var_bg), axis=0) all_var = np.concatenate(chainer.backends.cuda.to_cpu(all_var), axis=0) all_var_z = np.concatenate(chainer.backends.cuda.to_cpu(all_var_z), axis=0) all_c = np.concatenate(chainer.backends.cuda.to_cpu(all_c), axis=0) # all_h = np.concatenate(all_h,axis=0) # all_u = np.concatenate(all_u,axis=0) logging.info("concatenating, time elapsed: " + str(time.time() - start_time)) with h5py.File(savename, "a") as f: f.create_dataset("variance_all_viewpoints", data=all_var) f.create_dataset("query_viewpoints", data=np.squeeze(np.asarray(all_q_view))) f.create_dataset("variance_b4_gaussian", data=all_var_bg) f.create_dataset("variance_of_z", data=all_var_z) f.create_dataset("c", data=all_c) # f.create_dataset("h",data=all_h) # f.create_dataset("u",data=all_u) logging.info("saving, time elapsed: " + str(time.time() - start_time))
def render_wVar(representation, camera_distance, camera_position_y, total_frames, animation_frame_array, no_of_samples, rotate_camera=True, wVariance=True): # highest_var = 0.0 # with open("queries.txt",'w') as file_wviews, open("variance.txt",'w') as file_wvar: for t in range(0, total_frames): artist_array = [ axis_observations.imshow(cv2.cvtColor( make_uint8(axis_observations_image), cv2.COLOR_BGR2RGB), interpolation="none", animated=True) ] horizontal_angle_rad = compute_camera_angle_at_frame(t) if rotate_camera == False: horizontal_angle_rad = compute_camera_angle_at_frame(0) query_viewpoints = rotate_query_viewpoint(horizontal_angle_rad, camera_distance, camera_position_y) # q_x, q_y, q_z, _, _, _, _ = query_viewpoints[0] # file_wviews.writelines("".join(str(q_x))+", "+ # "".join(str(q_y))+", "+ # "".join(str(q_z))+"\n") generated_images = cp.squeeze( cp.array( model.generate_images(query_viewpoints, representation, no_of_samples))) # ipdb.set_trace() var_image = cp.var(generated_images, axis=0) mean_image = cp.mean(generated_images, axis=0) mean_image = make_uint8( np.squeeze(chainer.backends.cuda.to_cpu(mean_image))) mean_image_rgb = cv2.cvtColor(mean_image, cv2.COLOR_BGR2RGB) var_image = chainer.backends.cuda.to_cpu(var_image) # grayscale r, g, b = var_image gray_var_image = 0.2989 * r + 0.5870 * g + 0.1140 * b # thresholding Otsu's method # thresh = threshold_otsu(gray_var_image) # var_binary = gray_var_image > thresh ## hill climb algorthm for searching highest variance # cur_var = np.mean(gray_var_image) # if cur_var>highest_var: # highest_var = cur_var # if wVariance==True: # print('highest variance: '+str(highest_var)+', viewpoint: '+str(query_viewpoints[0])) # highest_var_vp = query_viewpoints[0] # file_wvar.writelines('highest variance: '+str(highest_var)+', viewpoint: '+str(highest_var_vp)+'\n') # else: # pass artist_array.append( axis_generation_var.imshow(gray_var_image, cmap=plt.cm.gray, interpolation="none", animated=True)) artist_array.append( axis_generation_mean.imshow(mean_image_rgb, interpolation="none", animated=True)) animation_frame_array.append(artist_array)
def sum( x: Array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, dtype: Optional[Dtype] = None, keepdims: bool = False, ) -> Array: if x.dtype not in _numeric_dtypes: raise TypeError("Only numeric dtypes are allowed in sum") # Note: sum() and prod() always upcast integers to (u)int64 and float32 to # float64 for dtype=None. `np.sum` does that too for integers, but not for # float32, so we need to special-case it here if dtype is None and x.dtype == float32: dtype = float64 return Array._new(np.sum(x._array, axis=axis, dtype=dtype, keepdims=keepdims)) def var( x: Array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, correction: Union[int, float] = 0.0, keepdims: bool = False, ) -> Array: # Note: the keyword argument correction is different here if x.dtype not in _floating_dtypes: raise TypeError("Only floating-point dtypes are allowed in var") return Array._new(np.var(x._array, axis=axis, ddof=correction, keepdims=keepdims))