def vis_hybrid_image(hybrid_image): """ %visualize a hybrid image by progressively downsampling the image and %concatenating all of the images together. """ scales = 5 #how many downsampled versions to create padding = 5 #how many pixels to pad. original_height = hybrid_image.shape[0] num_colors = hybrid_image.shape[2] #counting how many color channels the input has output = hybrid_image cur_image = hybrid_image for i in range(2, scales + 1): gap_array = np.ones((original_height, padding, num_colors)) output = cat((output, gap_array), axis=1) # wrongly done in the sample code cur_image = resize(cur_image, (cur_image.shape[0] // 2, cur_image.shape[1] // 2), anti_aliasing=True) vertical_gap = np.ones((original_height - cur_image.shape[0], cur_image.shape[1], num_colors)) tmp = cat((vertical_gap, cur_image), axis=0) output = cat((output, tmp), axis=1) return (output)
def concatenate(data, axis): """Concatenate multiple trials into one trials, according to any dimension. Parameters ---------- data : instance of DataTime, DataFreq, or DataTimeFreq axis : str axis that you want to concatenate (it can be 'trial') Returns ------- instace of same class as input the data will always have only one trial Notes ----- If axis is 'trial', it will add one more dimension, and concatenate based on it. It will then create a new axis, called 'trial_axis' (not 'trial' because that axis is hard-coded). If you want to concatenate across trials, you need: >>> expand_dims(data1.data[0], axis=1).shape """ output = data._copy(axis=False) for dataaxis in data.axis: output.axis[dataaxis] = empty(1, dtype='O') if dataaxis == axis: output.axis[dataaxis][0] = cat(data.axis[dataaxis]) else: output.axis[dataaxis][0] = data.axis[dataaxis][0] if len(unique(output.axis[dataaxis][0])) != len( output.axis[dataaxis][0]): lg.warning('Axis ' + dataaxis + ' does not have unique values') output.data = empty(1, dtype='O') if axis == 'trial': # create new axis new_axis = empty(1, dtype='O') n_trial = data.number_of('trial') trial_name = ['trial{0:06}'.format(x) for x in range(n_trial)] new_axis[0] = asarray(trial_name, dtype='U') output.axis['trial_axis'] = new_axis # concatenate along the extra dimension all_trial = [] for one_trial in data.data: all_trial.append(expand_dims(one_trial, -1)) output.data[0] = cat(all_trial, axis=-1) else: output.data[0] = cat(data.data, axis=output.index_of(axis)) return output
def pos_to_mat(pos, rot_mat=None): """ Given an (x, y, z) position, create a 4x4 homogeneous transformation matrix. """ mat = eye(3) if rot_mat is None else rot_mat mat = cat((mat, A(*(pos,)).T), axis=1) mat = cat((mat, A((0,0,0,1)))) return mat
def concatenate(data, axis): """Concatenate multiple trials into one trials, according to any dimension. Parameters ---------- data : instance of DataTime, DataFreq, or DataTimeFreq axis : str axis that you want to concatenate (it can be 'trial') Returns ------- instace of same class as input the data will always have only one trial Notes ----- If axis is 'trial', it will add one more dimension, and concatenate based on it. It will then create a new axis, called 'trial_axis' (not 'trial' because that axis is hard-coded). If you want to concatenate across trials, you need: >>> expand_dims(data1.data[0], axis=1).shape """ output = data._copy(axis=False) for dataaxis in data.axis: output.axis[dataaxis] = empty(1, dtype='O') if dataaxis == axis: output.axis[dataaxis][0] = cat(data.axis[dataaxis]) else: output.axis[dataaxis][0] = data.axis[dataaxis][0] if len(unique(output.axis[dataaxis][0])) != len(output.axis[dataaxis][0]): lg.warning('Axis ' + dataaxis + ' does not have unique values') output.data = empty(1, dtype='O') if axis == 'trial': # create new axis new_axis = empty(1, dtype='O') n_trial = data.number_of('trial') trial_name = ['trial{0:06}'.format(x) for x in range(n_trial)] new_axis[0] = asarray(trial_name, dtype='U') output.axis['trial_axis'] = new_axis # concatenate along the extra dimension all_trial = [] for one_trial in data.data: all_trial.append(expand_dims(one_trial, -1)) output.data[0] = cat(all_trial, axis=-1) else: output.data[0] = cat(data.data, axis=output.index_of(axis)) return output
def compute_target_part_scoremap_slices(self, joint_id, coords, data_item, size, scale): dist_thresh = self.cfg.pos_dist_thresh * scale dist_thresh_sq = dist_thresh ** 2 num_joints = self.cfg.num_joints # TODO: truncate size to agree with resnet depth size[0] = int(np.sqrt(size[0]))**2 # new scmap = np.zeros(cat([size, arr([num_joints])])) locref_size = cat([size, arr([num_joints * 2])]) locref_mask = np.zeros(locref_size) locref_map = np.zeros(locref_size) width = size[2] # new height = size[1] # new truncated_depth = size[0] - 1 # new for person_id in range(len(coords)): for k, j_id in enumerate(joint_id[person_id]): joint_pt = coords[person_id][k, :] # print("Joint {} ".format(k), joint_pt) j_x = np.asscalar(joint_pt[0]) j_y = np.asscalar(joint_pt[1]) # Note: the annotations are XYZ, but the masks are DHW=ZXY # TODO: for now, truncate to depth of resnet output j_z = min(int(joint_pt[2])-1, truncated_depth) # new; starts at 1; not affected by stride or distance # don't loop over entire heatmap, but just relevant locations j_x_sm = round((j_x - self.half_stride) / self.stride) j_y_sm = round((j_y - self.half_stride) / self.stride) min_x = round(max(j_x_sm - dist_thresh - 1, 0)) max_x = round(min(j_x_sm + dist_thresh + 1, width - 1)) min_y = round(max(j_y_sm - dist_thresh - 1, 0)) max_y = round(min(j_y_sm + dist_thresh + 1, height - 1)) for j in range(min_y, max_y + 1): # range(height): pt_y = j * self.stride + self.half_stride for i in range(min_x, max_x + 1): # range(width): # pt = arr([i*stride+half_stride, j*stride+half_stride]) # diff = joint_pt - pt # The code above is too slow in python pt_x = i * self.stride + self.half_stride dx = j_x - pt_x dy = j_y - pt_y dist = dx ** 2 + dy ** 2 # print(la.norm(diff)) if dist <= dist_thresh_sq: # New index: z, which is not iterated scmap[j_z, j, i, j_id] = 1 locref_mask[j_z, j, i, j_id * 2 + 0] = 1 locref_mask[j_z, j, i, j_id * 2 + 1] = 1 locref_map[j_z, j, i, j_id * 2 + 0] = dx * self.locref_scale locref_map[j_z, j, i, j_id * 2 + 1] = dy * self.locref_scale weights = self.compute_scmap_weights(scmap.shape, joint_id, data_item) return scmap, weights, locref_map, locref_mask
def compute_target_part_scoremap(self, joint_id, coords, data_item, size, scale): stride = self.cfg.stride dist_thresh = self.cfg.pos_dist_thresh * scale num_joints = self.cfg.num_joints half_stride = stride / 2 scmap = np.zeros(cat([size, arr([num_joints])])) locref_size = cat([size, arr([num_joints * 2])]) locref_mask = np.zeros(locref_size) locref_map = np.zeros(locref_size) locref_scale = 1.0 / self.cfg.locref_stdev dist_thresh_sq = dist_thresh**2 width = size[1] height = size[0] for person_id in range(len(coords)): for k, j_id in enumerate(joint_id[person_id]): joint_pt = coords[person_id][k, :] j_x = np.asscalar(joint_pt[0]) j_y = np.asscalar(joint_pt[1]) if np.isnan(j_x) or np.isnan(j_y): continue # don't loop over entire heatmap, but just relevant locations j_x_sm = round((j_x - half_stride) / stride) j_y_sm = round((j_y - half_stride) / stride) min_x = round(max(j_x_sm - dist_thresh - 1, 0)) max_x = round(min(j_x_sm + dist_thresh + 1, width - 1)) min_y = round(max(j_y_sm - dist_thresh - 1, 0)) max_y = round(min(j_y_sm + dist_thresh + 1, height - 1)) for j in range(int(min_y), int(max_y) + 1): # range(height): pt_y = j * stride + half_stride for i in range(int(min_x), int(max_x) + 1): # range(width): # pt = arr([i*stride+half_stride, j*stride+half_stride]) # diff = joint_pt - pt # The code above is too slow in python pt_x = i * stride + half_stride dx = j_x - pt_x dy = j_y - pt_y dist = dx**2 + dy**2 # print(la.norm(diff)) if dist <= dist_thresh_sq: scmap[j, i, j_id] = 1 locref_mask[j, i, j_id * 2 + 0] = 1 locref_mask[j, i, j_id * 2 + 1] = 1 locref_map[j, i, j_id * 2 + 0] = dx * locref_scale locref_map[j, i, j_id * 2 + 1] = dy * locref_scale weights = self.compute_scmap_weights(scmap.shape, joint_id, data_item) return scmap, weights, locref_map, locref_mask
def __generate_linear_row(T, depth, zeros, dim): """Generates linear state transition matrix rows""" core = np.eye(dim) if depth == 1: return cat((np.zeros((dim, dim * zeros)), core), axis=1) depth = depth - 1 return cat(( __generate_linear_row(T, depth, zeros, dim), T**depth / math.factorial(depth) * core, ), axis=1)
def cgpstudy(): """ Connecting the building blocks of a cGP study. This implements the simulation pipeline in Gjuvsland et al. (2011). """ from numpy import concatenate as cat gt = np.array(genotypes) par = cat([gt2par(list(g), hetpar, loc2par) for g in gt]) ph = cat([par2ph(p) for p in par]) return gt, par, ph
def subband_group_sum(self,s,group_type,average=True, energy=True): """ Computes the sum (or average) (energy) of one of two group types for subband s Group_type can be either 'parent_children' or 'children' or 'parent_child' """ if group_type != 'children': w_parent = self.get_upsampled_parent(s) #THIS BAD, we have two functions calling each other (potentially) if energy: w_parent = np.abs(w_parent)**2 w_child = self.get_subband(s) if energy: w_child = np.abs(w_child)**2 if group_type == 'parent_children' or group_type == 'children': w_child = np.sum(cat([w_child[self.ds_slices[i]][...,np.newaxis] for i in xrange(len(self.ds_slices))], axis=self.int_dimension),axis=self.int_dimension) w_child_us = np.zeros(2*np.asarray(w_child.shape)) for j in xrange(len(self.ds_slices)): w_child_us[self.ds_slices[j]] = w_child del w_child if group_type == 'parent_children': divisor = 2.0**self.int_dimension + 1 else: #children only w_parent = 0 divisor = 2.0**self.int_dimension elif group_type == 'parent_child': w_child_us = w_child divisor = 2.0 w_parent += w_child_us if average: w_parent /= divisor return w_parent
def __generate_linear_cols(T, depth, target, dim): """Carefully concatenates linear state transition matrix rows""" if depth == 1: return __generate_linear_row(T, depth, target, dim) return cat((__generate_linear_row(T, depth, target, dim), __generate_linear_cols(T, depth - 1, target + 1, dim)), axis=0)
def add_input_key(self, cfg: GenomeConfig, k: int): """Extend the input-key list with the given key, and expand the corresponding weights.""" # Update self.weight_xh_full if key never seen before if k not in self.input_keys_full: # Find the index to insert the key lst = [ i + 1 for i in range(len(self.input_keys_full)) if self.input_keys_full[i] < k ] # List of indices i = lst[-1] if lst else 0 # Index to insert key in # Save key to list self.input_keys_full.insert(i, k) # Update weight_xh_full correspondingly by inserting random initialized tensor in correct position new_tensor = rnn.init(cfg, hid_dim=self.hid_dim, input_size=1) assert new_tensor.shape == (self.hid_dim, 1) self.weight_xh_full = cat((self.weight_xh_full[:, :i], new_tensor, self.weight_xh_full[:, i:]), axis=1) # Update input_keys (current key-set) analogously if k not in self.input_keys: lst = [ i + 1 for i in range(len(self.input_keys)) if self.input_keys[i] < k ] # List of indices i = lst[-1] if lst else 0 self.input_keys.insert(i, k)
def cgpstudy(): """ Basic example of connecting the building blocks of a cGP study. This implements the simulation pipeline used in Gjuvsland et al. (2007) and Gjuvsland et al. (2011) :TODO: save and read into R :TODO: in R create classic lineplots for 3-locus GP mapping :TODO: in R use noia package to partition variance """ from numpy import concatenate as cat gt = np.array(genotypes) par = cat([gt2par(list(g), hetpar, absvar) for g in gt]) ph = cat([par2ph(p) for p in par])
def generate_scmap(cfg, joint_id, coords, size): dist_thresh = cfg.pos_dist_thresh * cfg.global_scale num_joints = cfg.num_joints scmap = np.zeros(cat([size, arr([num_joints])])) dist_thresh_sq = dist_thresh ** 2 width = size[1] height = size[0] for person_id in range(len(coords)): for k, j_id in enumerate(joint_id[person_id]): joint_pt = coords[person_id][k, :] j_x = np.asscalar(joint_pt[0]) j_y = np.asscalar(joint_pt[1]) # don't loop over entire heatmap, but just relevant locations min_x = int(round(max(j_x - dist_thresh - 1, 0))) max_x = int(round(min(j_x + dist_thresh + 1, width - 1))) min_y = int(round(max(j_y - dist_thresh - 1, 0))) max_y = int(round(min(j_y + dist_thresh + 1, height - 1))) for j in range(min_y, max_y + 1): # range(height): pt_y = j for i in range(min_x, max_x + 1): # range(width): pt_x = i dx = j_x - pt_x dy = j_y - pt_y dist = dx ** 2 + dy ** 2 if dist <= dist_thresh_sq: scmap[j, i, j_id] = 1 return scmap * 255
def update(self, fore, back): template = self.template[:back.shape[0], :back.shape[1], :] if self.reset: id=torch.reshape(torch.arange(1,template.shape[0]*template.shape[1]+1), \ (template.shape[0],template.shape[1])) self.slice.append(id) self.slice_volume = torch.stack(self.slice) self.max_id = torch.max(id) self.id_aligned = torch.cat([self.one.long(), id.view(-1)]) self.id_len = torch.ones_like(self.id_aligned) self.reset = False else: flow_check, fore_warp = self.check(fore, back) id = torch.zeros_like(self.slice[-1]) id[[fore_warp[:, :, 0], fore_warp[:, :, 1]]] = self.slice[-1] * flow_check.long() # self.id_len[id]+=1 new = torch.where(id > 0, self.zero, self.one).nonzero(as_tuple=True) id[new] = torch.arange(len(new[0])) + self.max_id + 1 # self.cut(flow_check) # self.id_aligned=torch.cat([self.id_aligned,id[new]]) # self.id_len=torch.cat([self.id_len,torch.ones_like(id[new])]) self.max_id = torch.max(id) self.slice.append(id)
def __init__(self, data, embedding, layers): self.data = data self.embedding = embedding self.layers = [] curr_length = data.shape[0] #Generate latent variables for i, (downsampling, latent_size, window, model, opt) in enumerate(layers): curr_length = curr_length // downsampling if (i < len(layers) - 1): next_window = layers[i + 1][2] offset = max(window // downsampling, next_window) padding = max(window // downsampling, next_window) latent_length = offset + curr_length + padding else: offset = window // downsampling padding = window // downsampling latent_length = offset + curr_length + padding if i == 0: pad = np.zeros((window, ), dtype=np.int32) self.data = np.cat((pad, data, pad)) latent_var = LatentVar((latent_length, latent_size), offset=window) self.layers.append((offset, curr_length, latent_var, downsampling, window, model, opt))
def batch_seq_pool(cls, seq_emb:Tensor, lengths=List[int]): """ Concatenate the mean, max and last hidden representations of a batch of sequences. Parameters ---------- seq_emb: Tensor Tensor of shape (bs, sequence length, dimension) This tensor reprsents the hidden states of final layer of the encoder from a language model. lengths: List list of integers indicating the sequence lengths Returns ------- Tensor Tensor of size (bs, 2400) """ assert seq_emb.shape[0] == len(lengths), 'Number of elements in lengths should match the first dimension of seq_emb' # ignore information beyond the sequence length, which is padding embs = [seq_emb[i, :x, :] for i, x in enumerate(lengths)] # calculate the pooled features ignoring the padding features = [cat([emb.mean(axis=0), emb.max(axis=0), emb[-1,:]], axis=-1) for emb in embs] combined_features = stack(features) # check that the dimensionality of the document embedding is 3x the dimensionality of the # final hidden states of the encoder. assert combined_features.shape[-1] == (seq_emb.shape[-1] * 3) return combined_features
def DWResidual(self): if 'matResidual' in locals(): matResidual.mesh = self.mesh else: matResidual = discretization(self.coeff, self.mesh, self.enrichOrder) matGroup = matResidual.matGroup() A, B, BonQ, C, D, E, F, G, H, L, R = matGroup LHS = np.bmat([[A, -B, C], [BonQ, D, E]]) RHS = cat((R, F)) residual = np.zeros(self.numEle) numEnrich = self.numBasisFuncs + self.enrichOrder adjointGradState, adjointStateFace = self.separateSoln( self.adjointSoln) for i in np.arange(self.numEle): primalResidual = (LHS.dot(self.primalSoln) - RHS).A1 uLength = self.numEle * numEnrich stepLength = i * numEnrich uDWR = primalResidual[stepLength:stepLength + numEnrich].dot( (1 - adjointGradState)[stepLength:stepLength + numEnrich]) qDWR = primalResidual[uLength + stepLength:uLength + stepLength + numEnrich]\ .dot((1 - adjointGradState)[uLength + stepLength:uLength + stepLength + numEnrich]) residual[i] = uDWR + qDWR # sort residual index residualIndex = np.argsort(np.abs(residual)) # select top \theta% elements with the largest error theta = 0.15 refineIndex = residualIndex[int(self.numEle * (1 - theta)):len(residual)] + 1 return np.abs(np.sum(residual)), refineIndex
def solveAdjoint(self): """Solve the adjoint problem""" # solve in the enriched space _coeff = copy(self.coeff) _coeff.pOrder = _coeff.pOrder + 1 if 'matAdjoint' in locals(): matAdjoint.mesh = self.mesh else: matAdjoint = discretization(_coeff, self.mesh) matGroup = matAdjoint.matGroup() A, B, _, C, D, E, F, G, H, L, R = matGroup # add adjoint LHS conditions F = np.zeros(len(F)) R[-1] = -boundaryCondition('adjoint')[1] # assemble global matrix LHS LHS = np.bmat([[A, -B, C], [B.T, D, E], [C.T, G, H]]) sLHS = csr_matrix(LHS) RHS = cat((R, F, L)) # solve in one shoot using GMRES def invRHS(vec): """Construct preconditioner""" matVec = spla.spsolve(sLHS, vec) return matVec n = len(RHS) preconditioner = spla.LinearOperator((n, n), invRHS) soln = spla.gmres(sLHS, RHS, M=preconditioner)[0] # soln = np.linalg.solve(LHS.T, RHS) self.adjointSoln = soln
def xy_to_cxcy(boxes): ''' 将(x_min, y_min, x_max, y_max)形式的anchor转换成(center_x, center_y, w, h)形式的 :param boxes: bounding boxes in boundary coordinates, a array of size (n_boxes, 4) :return: bounding boxes in center-size coordinates, a array of size (n_boxes, 4) ''' return np.cat([(boxes[:,2:]+boxes[:,:2])/2,boxes[:,2:]-boxes[:,:2]],axis=1)
def fit(self,train_x,train_y): self.train_y = train_y n,dim = train_x.shape self.w = np.zeros(dim+1) ones = np.ones(n,1) self.train_x = np.cat((train_x,ones),dim=-1) for i in range(self.max_iter): self._update_para()
def compute_target_part_scoremap_numpy( self, joint_id, coords, data_item, size, scale ): dist_thresh = float(self.cfg.pos_dist_thresh * scale) dist_thresh_sq = dist_thresh ** 2 num_joints = self.cfg.num_joints scmap = np.zeros(cat([size, arr([num_joints])])) locref_size = cat([size, arr([num_joints * 2])]) locref_mask = np.zeros(locref_size) locref_map = np.zeros(locref_size) width = size[1] height = size[0] grid = np.mgrid[:height, :width].transpose((1, 2, 0)) i=0 for person_id in range(len(coords)): for k, j_id in enumerate(joint_id[person_id]): joint_pt = coords[person_id][k, :] j_x = np.asscalar(joint_pt[0]) j_x_sm = round((j_x - self.half_stride) / self.stride) j_y = np.asscalar(joint_pt[1]) j_y_sm = round((j_y - self.half_stride) / self.stride) min_x = round(max(j_x_sm - dist_thresh - 1, 0)) max_x = round(min(j_x_sm + dist_thresh + 1, width - 1)) min_y = round(max(j_y_sm - dist_thresh - 1, 0)) max_y = round(min(j_y_sm + dist_thresh + 1, height - 1)) x = grid.copy()[:, :, 1] y = grid.copy()[:, :, 0] dx = j_x - x * self.stride - self.half_stride dy = j_y - y * self.stride - self.half_stride dist = dx ** 2 + dy ** 2 mask1 = dist <= dist_thresh_sq mask2 = (x >= min_x) & (x <= max_x) mask3 = (y >= min_y) & (y <= max_y) mask = mask1 & mask2 & mask3 scmap[mask, j_id] = 1 locref_mask[mask, j_id * 2 + 0] = 1 locref_mask[mask, j_id * 2 + 1] = 1 locref_map[mask, j_id * 2 + 0] = (dx * self.locref_scale)[mask] locref_map[mask, j_id * 2 + 1] = (dy * self.locref_scale)[mask] weights = scmap #weights = self.compute_scmap_weights(scmap.shape, joint_id, data_item) return scmap, weights, locref_map, locref_mask
def solvePrimal(self): """Solve the primal problem""" if 'matLocal' in locals(): # if matLocal exists, # only change the mesh instead of initializing again matLocal.mesh = self.mesh else: matLocal = discretization(self.coeff, self.mesh) matGroup = matLocal.matGroup() A, B, _, C, D, E, F, G, H, L, R = matGroup # solve by exploiting the local global separation K = -cat((C.T, G), axis=1)\ .dot(np.linalg.inv(np.bmat([[A, -B], [B.T, D]])) .dot(cat((C, E)))) + H sK = csr_matrix(K) F_hat = np.array([L]).T - cat((C.T, G), axis=1)\ .dot(np.linalg.inv(np.bmat([[A, -B], [B.T, D]])))\ .dot(np.array([cat((R, F))]).T) def invRHS(vec): """Construct preconditioner""" matVec = spla.spsolve(sK, vec) return matVec n = len(F_hat) preconditioner = spla.LinearOperator((n, n), invRHS) stateFace = spla.gmres(sK, F_hat, M=preconditioner)[0] # stateFace = np.linalg.solve(K, F_hat) gradState = np.linalg.inv(np.asarray(np.bmat( [[A, -B], [B.T, D]]))).dot(cat((R, F)) - cat((C, E)).dot(stateFace)) self.primalSoln = cat((gradState, stateFace))
def cgpstudy(): """ Basic example of connecting the building blocks of a cGP study. This top-level orchestration can be done in many different ways, depending on personal preference and on the need for features such as storage, caching, memory management or parallelization. Some examples are given in :mod:`cgp.examples.hpc`. """ from numpy import concatenate as cat gt = np.array(genotypes) par = cat([monogenicpar(g, hetpar=par0, absvar=absvar) for g in gt]) ph = cat([par2ph(p) for p in par]) agg = cat([ph2agg(p) for p in ph]) summarize(gt, agg) plt.show()
def __call__(self, other): assert isinstance(other, CSSCode) assert other.n * 2 == self.n Lx, Lz, Hx, Tz, Hz, Tx, Gx, Gz = (other.Lx, other.Lz, other.Hx, other.Tz, other.Hz, other.Tx, other.Gx, other.Gz) assert Gx is None assert Gz is None A = self.A.transpose() LxLz = dot2(cat((Lx, Lz), axis=1), A) HxTz = dot2(cat((Hx, Tz), axis=1), A) TxHz = dot2(cat((Tx, Hz), axis=1), A) n = self.n // 2 Lx, Lz = LxLz[:, :n], LxLz[:, n:] Hx, Tz = HxTz[:, :n], HxTz[:, n:] Tx, Hz = TxHz[:, :n], TxHz[:, n:] code = CSSCode(Lx=Lx, Lz=Lz, Hx=Hx, Tz=Tz, Hz=Hz, Tx=Tx) return code
def glue_logops(): m = argv.get("m", 4) n = argv.get("n", m + m + 1) dist = argv.get("dist", 3) N = argv.get("N", 2) M = argv.get("M", N) p = argv.get("p", 0.03) weight = argv.weight codes = [] code = None for i in range(N): Hx, Hz = make_quantum(n, m, dist, weight) #Hx, Hz = make_surface() print("Hx, Hz:") print(shortstrx(Hx, Hz)) c = CSSCode(Hx=Hx, Hz=Hz) codes.append(c) code = c if code is None else code + c A, B = codes code = A + B print(code) print("Lx, Lz:") print(shortstrx(code.Lx, code.Lz)) print("Hx, Hz:") print(shortstrx(code.Hx, code.Hz)) print() #Hx = cat((code.Lx, code.Hx)) Hx = code.Hx Hz = cat((code.Lz, code.Hz)) idxs = list(range(2 * n)) idxs.sort(key=lambda i: (-code.Lz[:, i].sum(), )) Hx = Hx[:, idxs] Hz = Hz[:, idxs] print(shortstrx(Hx, Hz)) i0 = argv.get("i0") i1 = argv.get("i1") if i0 is None: return # code = code.glue(0, n) # print(code) # print(shortstrx(code.Hx, code.Hz)) Hx, Hz = glue1_quantum(Hx, Hz, i0, i1) print("Hx, Hz:") print(shortstrx(Hx, Hz))
def fig3(): x = np.linspace(-4, 4, 50) y = np.linspace(-4, 4, 50) x, y = np.meshgrid(x, y) z = maximum(2 * x**2 + y**2 - x * y, abs(x) + 2 * abs(y)) levels = cat((arange(0, 4, 1), arange(4, 16, 2))) plt.contour(x, y, z, levels=levels, cmap='jet') txt = r'$max(2x^2 + y^2 - xy, |x| + 2|y|)$' return txt
def fig5(): x = np.linspace(0.001, 2, 50) y = np.linspace(0.001, 2, 50) x, y = np.meshgrid(x, y) z = x * log(x) + y * log(y) levels = cat((arange(-1, 0.2, 0.1), arange(0.2, 1, 0.2))) plt.contour(x, y, z, levels=levels, cmap='jet') txt = r'$xlog(x) + ylog(y)$' return txt
def fig2(): x = np.linspace(-1, 1, 50) y = np.linspace(-1, 1, 50) x, y = np.meshgrid(x, y) z = x**2 + y**2 levels = cat((arange(0, 0.1, 0.05), arange(0.1, 1, 0.15))) plt.contour(x, y, z, levels=levels, cmap='jet') txt = r'$x^2 + y^2$' return txt
def gaussian_scmap(self, joint_id, coords, data_item, size, scale): stride = self.cfg.stride #dist_thresh = float(self.cfg.pos_dist_thresh * scale) num_joints = self.cfg.num_joints half_stride = stride / 2 scmap = np.zeros(cat([size, arr([num_joints])])) locref_size = cat([size, arr([num_joints * 2])]) locref_mask = np.zeros(locref_size) locref_map = np.zeros(locref_size) width = size[1] height = size[0] dist_thresh = float((width + height) / 6) locref_scale = 1.0 / self.cfg.locref_stdev dist_thresh_sq = dist_thresh**2 std = dist_thresh / 4 # Grid of coordinates grid = np.mgrid[:height, :width].transpose((1, 2, 0)) grid = grid * stride + half_stride for person_id in range(len(coords)): for k, j_id in enumerate(joint_id[person_id]): joint_pt = coords[person_id][k, :] j_x = np.asscalar(joint_pt[0]) j_x_sm = round((j_x - half_stride) / stride) j_y = np.asscalar(joint_pt[1]) j_y_sm = round((j_y - half_stride) / stride) map_j = grid.copy() # Distance between the joint point and each coordinate dist = np.linalg.norm(grid - (j_y, j_x), axis=2)**2 scmap_j = np.exp(-dist / (2 * (std**2))) scmap[..., j_id] = scmap_j locref_mask[dist <= dist_thresh_sq, j_id * 2 + 0] = 1 locref_mask[dist <= dist_thresh_sq, j_id * 2 + 1] = 1 dx = j_x - grid.copy()[:, :, 1] dy = j_y - grid.copy()[:, :, 0] locref_map[..., j_id * 2 + 0] = dx * locref_scale locref_map[..., j_id * 2 + 1] = dy * locref_scale weights = self.compute_scmap_weights(scmap.shape, joint_id, data_item) return scmap, weights, locref_map, locref_mask
def preprocess( train_dir="data/in-hospital-mortality/train", test_dir="data/in-hospital-mortality/test", split=False, ): train_reader = InHospitalMortalityReader( dataset_dir=train_dir, listfile=f"{train_dir}/listfile.csv") test_reader = InHospitalMortalityReader( dataset_dir=test_dir, listfile=f"{test_dir}/listfile.csv") train_data = [] test_data = [] for i in range(train_reader.get_number_of_examples()): data = train_reader.read_example(i) index = np.array([[i] * data["X"].shape[0]]).T label = np.array([[data["y"]] * data["X"].shape[0]]).T tmp = np.concatenate((data["X"], label), axis=1) out = np.concatenate((index, tmp), axis=1) train_data.append(out) for j in range(test_reader.get_number_of_examples()): data = test_reader.read_example(j) index = np.array([[i + j] * data["X"].shape[0]]).T label = np.array([[data["y"]] * data["X"].shape[0]]).T tmp = np.concatenate((data["X"], label), axis=1) out = np.concatenate((index, tmp), axis=1) test_data.append(out) # Stack training data and testing data train_data = np.vstack(train_data) test_data = np.vstack(test_data) if split: # Create dataframe train_df = pd.DataFrame(train_data, index=None, columns=HEADERS) test_df = pd.DataFrame(test_data, index=None, columns=HEADERS) # Preprocess coma scales train_df = preprocess_coma_scales(train_df) test_df = preprocess_coma_scales(test_df) return train_df, test_df else: # Create dataframe all_data = np.cat(X) df = pd.DataFrame(all_data, index=None, columns=HEADERS) # Preprocess coma scales df = preprocess_coma_scales(df) return df
def bbox_transform_inv(cls, bbox, deltas): bbox_xywh = cls.xxyy2xywh(bbox) pred_ctr_x = deltas[:, 0] * bbox_xywh[:, 2] + bbox_xywh[:, 0] pred_ctr_y = deltas[:, 1] * bbox_xywh[:, 3] + bbox_xywh[:, 1] pred_w = np.exp(deltas[:, 2]) * bbox_xywh[:, 2] pred_h = np.exp(deltas[:, 3]) * bbox_xywh[:, 3] pred_ctr_x = pred_ctr_x.view(-1, 1) pred_ctr_y = pred_ctr_y.view(-1, 1) pred_w = pred_w.view(-1, 1) pred_h = pred_h.view(-1, 1) pred_box = np.cat([pred_ctr_x, pred_ctr_y, pred_w, pred_h], dim=1) return cls.xywh2xxyy(pred_box)
def step(self, agents): """ :param agents: :return: """ for device, agent in zip(self.devices, agents): stage_state = self.state() device_state, available_action = device.get_state() state = np.cat([stage_state, device_state]) action = agent.choose_action(state=state, available_action=available_action) device.act(action) reward = device.get_reward() # 可补充其他奖赏逻辑 agent.learn(state=state, available_action=available_action, action=action, reward=reward)
def get_density(mu, var, pi, N=50, X_range=(0, 5), Y_range=(0, 5)): """ Get the mesh to compute the density on. """ X = np.linspace(*X_range, N) Y = np.linspace(*Y_range, N) X, Y = np.meshgrid(X, Y) # get the design matrix points = np.cat([X.reshape(-1, 1), Y.reshape(-1, 1)], axis=1) points = Variable(torch.from_numpy(points).float()) # compute the densities under each mixture P = get_k_likelihoods(points, mu, var) # sum the densities to get mixture density Z = torch.sum(P, dim=0).data.numpy().reshape([N, N]) return X, Y, Z
def run(self): trajectory = self.trajectory_generator.trajectory observation = self.sensor.observe(trajectory) time = self.time estimation = np.zeros(shape=(4, len(time))) estimation[:, 0] = cat((observation[:, 0], np.zeros(2)), axis=0) self.filter.init(estimation[:, 0]) for k in range(1, len(time)): y = observation[:, k] self.filter.update(y) estimation[:, k] = self.filter.x self.estimation = estimation self.observation = observation
def feature_extraction(Z, N): # function Descriptors=feature_extraction(Z,N) # #% The features are the magnitude of the Zernike moments. #% Collect the moments into (2*l+1)-dimensional vectors #% and define the rotationally invariant 3D Zernike descriptors #% Fnl as norms of vectors Znl. # F = zeros((N + 1, N + 1)) + NaN # F=zeros(N+1,N+1)+NaN; #% Calcuate the magnitude for n in xrange(N + 1): # Warn: xrange #for n=0:N for l in xrange(n + 1): # Warn: xrange # for l=0:n if mod(n - l, 2) == 0: # if mod(n-l,2)==0 aux_1 = Z[ n, l, 0 : l + 1 ] # Warn: 0-1 # aux_1=Z(n+1,l+1,1:l+1); <----- need to keep the trailing l+1 for slicing # aux_1=aux_1(:)'; if l > 0: # if l>0 # % Taking the values for m<0 aux_2 = conj( aux_1[1 : l + 1] ) # Warn: 0-1 # aux_2=conj(aux_1(2:(l+1))); <---- Trailing +1 again for m in xrange(l): # for m=1:l aux_2[m] = aux_2[m] * power( -1, m + 1 ) # Warn: 0-1 # aux_2(m)=aux_2(m)*power(-1,m); # end # % Sorting the vector aux_2 = flipud(aux_2) # aux_2=rot90(aux_2,2); aux_1 = cat((aux_2, aux_1), axis=1) # Warn: 0-1 axis # aux_1=cat(2,aux_2,aux_1); # end F[n, l] = norm(aux_1, ord=2) # Warn: 0-1 axis # F(n+1,l+1)=norm(aux_1,2); # end # end # end #% Generate vector of Zernike descriptors #% Column vector that store the magnitude #% of the Zernike moments for n,l. F = transpose(F) # Warn: Matlab col-major idx = F >= 0 # idx=find(F>=0); return F[idx]
def compute_targets_and_weights(self, joint_id, coords, data_item, size, scale, batch): stride = self.cfg.stride dist_thresh = self.cfg.pos_dist_thresh * scale num_joints = self.cfg.num_joints half_stride = stride / 2 scmap = np.zeros(cat([size, arr([num_joints])])) locref_shape = cat([size, arr([num_joints * 2])]) locref_mask = np.zeros(locref_shape) locref_map = np.zeros(locref_shape) pairwise_shape = cat([size, arr([num_joints * (num_joints - 1) * 2])]) pairwise_mask = np.zeros(pairwise_shape) pairwise_map = np.zeros(pairwise_shape) dist_thresh_sq = dist_thresh ** 2 width = size[1] height = size[0] for person_id in range(len(coords)): for k, j_id in enumerate(joint_id[person_id]): joint_pt = coords[person_id][k, :] j_x = np.asscalar(joint_pt[0]) j_y = np.asscalar(joint_pt[1]) # don't loop over entire heatmap, but just relevant locations j_x_sm = round((j_x - half_stride) / stride) j_y_sm = round((j_y - half_stride) / stride) min_x = round(max(j_x_sm - dist_thresh - 1, 0)) max_x = round(min(j_x_sm + dist_thresh + 1, width - 1)) min_y = round(max(j_y_sm - dist_thresh - 1, 0)) max_y = round(min(j_y_sm + dist_thresh + 1, height - 1)) for j in range(min_y, max_y + 1): # range(height): pt_y = j * stride + half_stride for i in range(min_x, max_x + 1): # range(width): # pt = arr([i*stride+half_stride, j*stride+half_stride]) # diff = joint_pt - pt # The code above is too slow in python pt_x = i * stride + half_stride dx = j_x - pt_x dy = j_y - pt_y dist = dx ** 2 + dy ** 2 # print(la.norm(diff)) if dist <= dist_thresh_sq: dist = dx ** 2 + dy ** 2 locref_scale = 1.0 / self.cfg.locref_stdev current_normalized_dist = dist * locref_scale ** 2 prev_normalized_dist = locref_map[j, i, j_id * 2 + 0] ** 2 + \ locref_map[j, i, j_id * 2 + 1] ** 2 update_scores = (scmap[j, i, j_id] == 0) or prev_normalized_dist > current_normalized_dist if self.cfg.location_refinement and update_scores: self.set_locref(locref_map, locref_mask, locref_scale, i, j, j_id, dx, dy) if self.cfg.pairwise_predict and update_scores: for k_end, j_id_end in enumerate(joint_id[person_id]): if k != k_end: self.set_pairwise_map(pairwise_map, pairwise_mask, i, j, j_id, j_id_end, coords, pt_x, pt_y, person_id, k_end) scmap[j, i, j_id] = 1 scmap_weights = self.compute_scmap_weights(scmap.shape, joint_id, data_item) # Update batch batch.update({ Batch.part_score_targets: scmap, Batch.part_score_weights: scmap_weights }) if self.cfg.location_refinement: batch.update({ Batch.locref_targets: locref_map, Batch.locref_mask: locref_mask }) if self.cfg.pairwise_predict: batch.update({ Batch.pairwise_targets: pairwise_map, Batch.pairwise_mask: pairwise_mask }) return batch