def compute_trajectory_prediction_mse(args, ground_truth, predictions): """ inputs: args: model parameters ground_truth: list of groudn truth velocities in absolute frame predictions: list of predicted velocities """ avg_mse = 0 cnt = 0 mse_list = [] for pred, gt in zip(predictions, ground_truth): avg_mse = 0 cnt = 0 # compute average per trajectory # tbp_len # path from vel for vel for t in range(len(pred)): # real trajectory global frame real_vel_global_frame = gt.vel_vec[t + args.prev_horizon + 1:t + args.prediction_horizon + args.prev_horizon + 1, :2] real_traj_global_frame = sup.path_from_vel( initial_pos=np.array([0, 0]), pred_vel=real_vel_global_frame, dt=args.dt) # pred_horizon = 10 vel_pred = np.zeros((args.prediction_horizon, args.output_dim)) error = 0 # [1,144] pred_t = pred[t][0] min_error = np.zeros((pred_t.shape[0])) # 144 -> prediction_horizon*output_state_dim = 4*n_mixture for sample_id in range(pred_t.shape[0]): error = np.zeros((args.n_mixtures)) for mix_idx in range(args.n_mixtures): # plot predicted trajectory global frame for i in range(args.prediction_horizon): idx = i * args.output_pred_state_dim * args.n_mixtures + mix_idx idy = i * args.output_pred_state_dim * args.n_mixtures + mix_idx + args.n_mixtures if args.normalize_data: mu_x = pred_t[sample_id, idx] / args.sx_vel + args.min_vel_x mu_y = pred_t[sample_id, idy] / args.sy_vel + args.min_vel_y else: mu_x = pred_t[sample_id, idx] mu_y = pred_t[sample_id, idy] vel_pred[i, :] = [mu_x, mu_y] traj_pred = sup.path_from_vel(initial_pos=np.array([0, 0]), pred_vel=vel_pred, dt=args.dt) for pred_step in range(args.prediction_horizon): error[mix_idx] += np.linalg.norm( real_traj_global_frame[pred_step, :] - traj_pred[pred_step, :]) / args.prediction_horizon min_error[sample_id] = min(error) avg_mse = (avg_mse * cnt + min(min_error)) / (cnt + 1) cnt += 1 mse_list.append(avg_mse) return avg_mse, mse_list
def plot(self, ax, x_scale=1, y_scale=1): """ Plots the trajectories and the static occupancy grid of all agents in this container. """ colormap = pl.get_cmap('rainbow') c_norm = pl.matplotlib.colors.Normalize(vmin=0, vmax=len( self.agent_data.keys())) scalar_color_map = pl.cm.ScalarMappable(norm=c_norm, cmap=colormap) for cnt, id in enumerate(self.agent_data.keys()): color_value = scalar_color_map.to_rgba(cnt) self.agent_data[id].plot(ax, color=color_value, x_scale=1, y_scale=1) #sup.plot_grid(ax, np.array([self.occupancy_grid.center[0], self.occupancy_grid.center[1]]), self.occupancy_grid.gridmap, self.occupancy_grid.resolution, self.occupancy_grid.map_size) sup.plot_grid(ax, np.array([0, 0]), self.occupancy_grid.gridmap, self.occupancy_grid.resolution, self.occupancy_grid.map_size) ax.set_xlim( [-self.occupancy_grid.center[0], self.occupancy_grid.center[0]]) ax.set_ylim( [-self.occupancy_grid.center[1], self.occupancy_grid.center[1]]) ax.set_aspect('equal')
def delete(self, start, size, allele): if allele.lower() == "m": if start > self.maternalHaplotypeLength: raise ValueError( "The starting point of a mutation cannot be over maternal-haplotype-chromosome length!" ) else: startbin, endbin = Support.startendbins( bins=self.maternalHaplotype, start=start, size=size) self.maternalHaplotype = self.maternalHaplotype[ 0:startbin] + self.maternalHaplotype[endbin:] self.maternalHaplotypeLength = sum( seg[1] - seg[0] for seg in self.maternalHaplotype) elif allele.lower() == "p": if start > self.paternalHaplotypeLength: raise ValueError( "The starting point of a mutation cannot be over paternal-haplotype-chromosome length!" ) else: startbin, endbin = Support.startendbins( bins=self.paternalHaplotype, start=start, size=size) self.paternalHaplotype = self.paternalHaplotype[ 0:startbin] + self.paternalHaplotype[endbin:] self.paternalHaplotypeLength = sum( seg[1] - seg[0] for seg in self.paternalHaplotype) else: raise ValueError( "The specified allele should be equal to either M or P (non-case sensitive)!" )
def parse_data(path, verbose=1): first = True second = True k = 0 counter = 0 with open(path, "r") as inputFile: for line in inputFile: if first: first = False tokens = line.split(",") input_size = int(tokens[0]) output_size = int(tokens[1]) samples_size = int(tokens[2]) inputs = numpy.zeros((samples_size, input_size)) outputs = numpy.zeros((samples_size, output_size)) elif second: second = False if verbose: Support.colored_print("Parameters: ", "blue") Support.colored_print(line, "blue") else: counter += 1 if counter < samples_size: input, output = line.split('=') for i, e in enumerate(input.split()): inputs[k][i] = float(e.strip()) for i, e in enumerate(output.split()): outputs[k][i] = float(e.strip()) k += 1 else: break return inputs, outputs, input_size, output_size
def generateControl(self, gameData, playerId): act = Support.randomFromList(self.actionName) fr = Support.randomFromList(self.firstName) sc = Support.randomFromList(self.secondName) th = Support.randomFromList(self.thirdName) fullName = act + " " + fr + " " + sc + " " + th print "Generated control with name " + fullName return Control(playerId, fullName, str(gameData.getFreeControlId()))
def pipeline(img, isVideo=False): # Image Preprocessing undst, binary, binary_warped = PreProcessing.preprocess_image(img) # Lane Detection Code Start lanes, leftx, lefty, rightx, righty, ploty = LaneFinding.get_lane_lines( binary_warped, isVideo) lcurve, rcurve = Support.get_real_lanes_curvature(ploty, leftx, lefty, rightx, righty) output = draw_lane_area(undst, binary_warped, ploty, leftx, lefty, rightx, righty, isVideo) left_fit, right_fit, dummy = Support.fit_polylines(binary_warped.shape[0], leftx, lefty, rightx, righty, x_scale_factor=1, y_scale_factor=1) left_fitx, right_fitx = Support.get_polylines_points( ploty, left_fit, right_fit) if (isVideo is True): lcurve, rcurve = getSmoothedCurveData(lcurve, rcurve) left_fitx, right_fitx = getSmoothedLanesData(left_fitx, right_fitx) shiftFromLaneCenter_m, side = calculate_shift_from_lane_center( binary_warped, left_fitx, right_fitx) Font = cv2.FONT_HERSHEY_SIMPLEX color = (255, 255, 255) cv2.putText(output, 'curve = ' + str((lcurve + rcurve) / 2) + ' m', (10, 100), Font, 1, color, 2, cv2.LINE_AA) cv2.putText( output, 'Vehicle is ' + str(shiftFromLaneCenter_m) + ' (m) ' + side + ' of lane center', (10, 150), Font, 1, color, 2, cv2.LINE_AA) # Lane Detection Code End # Vehicle Detection Code Start cars_boxs = get_classified_cars_boxs(undst) classified_boxs = Visualisation.draw_boxes(undst, cars_boxs, color=(0, 0, 255), thick=6) filtered_boxs, heat_map = get_heat_map_boxs(cars_boxs, undst, isVideo) output = Visualisation.draw_boxes(output, filtered_boxs, color=(0, 0, 255), thick=6) # Vehicle Detection Code End return undst, classified_boxs, heat_map, output
async def search(message, args): """ Sending a git hub search result https://github.com/nosv1/jc/search?q=&type=wikis """ jc = Support.get_jc_from_channel(message.channel) query = " ".join(args[2:]).strip() results = None if query: results = Support.search_github(query) results_description = "" outputted = 0 for result in results: if len(results_description) < 1000: outputted += 1 # **title** - `command` title = result['title'].split("`") # title should be >> title `command` >> [title, command, ''] command = title[1] if len(title) > 1 else "" results_description += f"**{title[0]}** - `{command}`\n" # results_description += f"**[{title[0]}]({result['link']})**" + (f" - `{command}`\n" if command else "\n") # p = result['p'].split("\n") + [" "] # [@jc command help, snippet] # results_description += f"`{p[0].strip().replace('**', '')}`\n\n" # \/ old, used to be Title \n Command \n Body # results_description += f"`{p[0].strip().replace('**', '')}`\n{p[1].strip()}\n\n" if not results_description: # no results results_description += f"{jc} help\n" await Support.simple_bot_response(message.channel, title = f"{len(results)} Result{'s' if outputted != 1 else ''}", description=results_description ) Logger.log("search", results_description) else: description = f"`@{jc} ? <search_words>`\n" description += f"`@{jc} ? custom embeds`" await Support.simple_bot_response(message.channel, title="No Search Words Provided", description=description, reply_message=message ) Logger.log("Bot Reponse", "Simple Help Search")
def plot(self): #画两端结点 x=[self.a1,self.a2] y=[self.b1,self.b2] plt.scatter(x,y,c='w',marker='o', s=60,edgecolors=self.pc,linewidths=self.c1*self.l, zorder=100)#s是点大小 #画杆 plt.plot(x,y,c=self.tc,linewidth=self.c2*self.l,zorder=1) #画支座 sp1=Support.Support(self.sx1,self.sy1,self.a1,self.b1,self.l,self.sc) sp1.display() sp2=Support.Support(self.sx2,self.sy2,self.a2,self.b2,self.l,self.sc) sp2.display() plt.tight_layout()
def logArgs(args): Support.log('\n'.join(["Arguments:"] + [ '\t{}:\t{}'.format(arg, args[arg]) for arg in args if arg != 'mutations' ] + [""]), level="INFO") Support.log('\n'.join(["Mutations:"] + [ '\t{}:\t{}'.format(mut, args['mutations'][mut]) for mut in args['mutations'] if mut != 'clonalfocal' and mut != 'subclonalfocal' ] + [""]), level="INFO") if 'clonalfocal' in args['mutations']: Support.log('\n'.join(['Clonal focal CNAs:'] + [ '\tmean_len= {}, standard_deviation= {}, quantity= {}'.format( key[0], key[1], args['mutations']['clonalfocal'][key]) for key in args['mutations']['clonalfocal'] ] + [""]), level="INFO") if 'subclonalfocal' in args['mutations']: Support.log('\n'.join(['Subclonal focal CNAs:'] + [ '\tmean_len= {}, standard_deviation= {}, quantity= {}'.format( key[0], key[1], args['mutations']['subclonalfocal'][key]) for key in args['mutations']['subclonalfocal'] ] + [""]), level="INFO")
def draw_hangman(lives): if lives == 5: sup.draw("Lives 5.txt") if lives == 4: sup.draw("Lives 4.txt") if lives == 3: sup.draw("Lives 3.txt") if lives == 2: sup.draw("Lives 2.txt") if lives == 1: sup.draw("Lives 1.txt")
def DisplaySupportType(): """ Purpose: List all Support type for products. Argument(s): None Return: list of Suppport types. """ #SUPPORT MODULE FOR THE SUPPORT CLASS ( TABLE ) #---------------------------------------------- import Support #SUPPORT OBJECT #-------------- NewSupport = Support.Support() Supports = NewSupport.getAllSupport() count = 1 if (len(Supports) != 0): print "No. REFERENCE NO. START DATE END DATE SUPPORT LEVEL" print "--- ------------- ---------- -------- -------------" for support in Supports: print "{0} {1:15} {2:15} {3:15} {4}".format( count, support[1], support[2], support[3], support[4]) count = count + 1
def gradients(self, x, loss_function, y_target): ''' Inputs: x: network input loss_function: Since the gradients of the loss function need to be computed, this has to be provided. y_target: Target values for the network output. Return value: gradients: Gradients of the loss function w.r.t. all weights and biases of the network. Gradients have a weights and biases member, the indexing starts with 0 for the first hidden layer (W_1, b_1) and ends with the output layer (W_out, b_out) ''' gradients = sup.Variables() # Outputs of each layer (layer_evaluations[0] is input x) layer_evaluations = [] for layer_idx, layer in enumerate(self.layers): layer_evaluations.append(self.evaluateLayer(layer_idx, x)) # Output equals the evaluation of the last layer network_output = self.output(x) # Derivative of cost w.r.t. the network output dCost_dy = #TODO: implement cost function derivative w.r.t. output variables of network # Element-wise multiplication with sigmoid derivative (sigmoid is applied element-wise) delta_fused = #TODO: start backpropagating the error # Gradient backpropagation ## Start from last layer and propagate error gradient through until first layer ## Attention!!!: layer_evaluations[0] is the network input while self.layers[0] is the first hidden layer for layer_idx in np.arange(len(self.layers)-1, -1, -1): logger.debug('Computing the gradient for layer {}'.format(layer_idx)) # If layer is not last layer, update delta_fused (which is accumulating the back-propagated gradient) # TODO: implement backpropagation of gradient for arbitrary number of layers return gradients
def runL1000CDS2(infile, outfile): # Read infile cdDataframe = pd.read_table(infile, index_col='gene_symbol').fillna(0) # Initialize dataframes linkDataframe = pd.DataFrame() signatureDataframe = pd.DataFrame() # Loop through timepoints for comparison in cdDataframe.columns: # Run L1000CDS2 resultDict = S.getL1000CDS2Results(cdDataframe, comparison) # Add comparison labels resultDict['links']['comparison'] = comparison resultDict['signatures']['comparison'] = comparison # Append dataframes linkDataframe = pd.concat([linkDataframe, resultDict['links']]) signatureDataframe = pd.concat( [signatureDataframe, resultDict['signatures']]) # Write files linkDataframe.to_csv(outfile, sep='\t', index=False) signatureDataframe.to_csv(outfile.replace('links', 'signatures'), sep='\t', index=False)
def build_new(self): logger.info("Build New") self.allunits = [] self.factions = {} self.allreinforcements = {} self.prefabs = [] self.objective = None self.phase_music = None self.map = None self.game_constants = Counter() self.game_constants['level'] = 0 self.game_constants['money'] = 0 self.convoy = [] self.play_time = 0 self.support = Support.Support_Graph( 'Data/support_nodes.txt', 'Data/support_edges.txt') if cf.CONSTANTS['support'] else None self.unlocked_lore = [] self.statistics = [] self.market_items = set() self.sweep() self.generic() # Turn tutorial mode off if the difficulty does not start with a tutorial if not int(self.mode['tutorial']): cf.OPTIONS['Display Hints'] = 0
def plot(self): #画两端结点 x = [self.a1, self.a2] y = [self.b1, self.b2] plt.scatter(x, y, c='w', marker='o', s=self.c8 * self.l, edgecolors=self.pc, linewidths=self.c7 * self.l, zorder=100) #s是点大小 #画杆 plt.plot(x, y, c=self.tc, linewidth=self.c6 * self.l, zorder=1) #画支座 sp1 = Support.Support(self.sx1, self.sy1, self.a1, self.b1, self.l, self.sc) sp1.display() sp2 = Support.Support(self.sx2, self.sy2, self.a2, self.b2, self.l, self.sc) sp2.display() #画力 pass #标数据 l1 = np.array([self.a1, self.b1]) l2 = np.array([self.a2, self.b2]) #计算角度 if self.a1 == self.a2: if self.b1 > self.b2: angle = -90 else: angle = 90 else: angle = math.atan((self.b2 - self.b1) / (self.a2 - self.a1)) / (2 * math.pi) * 360 plt.text((l1[0] + l2[0]) / 2, (l1[1] + l2[1]) / 2, str(self.result), fontsize=self.c5 * self.l, rotation=angle, rotation_mode='anchor', zorder=1000) #画外力 f1 = Force.Force(self.a1, self.b1, self.fx1, self.fy1, self.l, self.ax) f1.ForcePlot() f2 = Force.Force(self.a2, self.b2, self.fx2, self.fy2, self.l, self.ax) f2.ForcePlot()
def getSendDataHandler(participant,topic): localInterface = Support.doSubnetTranslation(topic.localInterface) if topic.transport == TRANSPORT_MC: return McSendDataHandler(localInterface,topic,topic.timeToLive) if topic.transport == TRANSPORT_UDP: return UdpSendDataHandler(topic) return None
def __init__(self, name, length, binsize): self.name = name self.length = length self.binsize = binsize self.reference = Support.bins(size=self.length, step=self.binsize) self.maternalHaplotype = copy.deepcopy(self.reference) self.maternalHaplotypeLength = copy.deepcopy(self.length) self.paternalHaplotype = copy.deepcopy(self.reference) self.paternalHaplotypeLength = copy.deepcopy(self.length)
def draw_lane_area(undist, warped, ploty, leftx, lefty, rightx, righty, isVideo=False): left_fit, right_fit, dummy = Support.fit_polylines(warped.shape[0], leftx, lefty, rightx, righty, x_scale_factor=1, y_scale_factor=1) left_fitx, right_fitx = Support.get_polylines_points( ploty, left_fit, right_fit) if (isVideo is True): left_fitx, right_fitx = getSmoothedLanesData(left_fitx, right_fitx) # Create an image to draw the lines on warp_zero = np.zeros_like(warped).astype(np.uint8) color_warp = np.dstack((warp_zero, warp_zero, warp_zero)) # Recast the x and y points into usable format for cv2.fillPoly() pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))]) pts_right = np.array( [np.flipud(np.transpose(np.vstack([right_fitx, ploty])))]) pts = np.hstack((pts_left, pts_right)) # Draw the lane onto the warped blank image cv2.fillPoly(color_warp, np.int_([pts]), (0, 255, 0)) # Warp the blank back to original image space using inverse perspective matrix (Minv) newwarp = cv2.warpPerspective(color_warp, Minv, (undist.shape[1], undist.shape[0])) # Combine the result with the original image result = cv2.addWeighted(undist, 1, newwarp, 0.3, 0) return result
def __init__(self, reference, snplist, snpratio, HEHOratio, ignorelist): self.reference = reference self.snplist = Support.parseSNPList(snplist) self.snpratio = snpratio self.HEHOratio = HEHOratio self.ignorelist = ignorelist self.chromosomes = [] self.lengths = {} self.maternalfa = None self.paternalfa = None self.numsnps = 0 self.hetsnps = 0
def evaluate(path_network, input): Support.colored_print("Loading neural network...", "blue") neural_network = NeuralNetwork.NeuralNetwork() neural_network.load(path_network) Support.colored_print("Evaluating...", "blue") result = neural_network.evaluate(input) Support.colored_print(result, "pink")
def Find_Line(filtered_mask): im2, contours, hierarchy = cv2.findContours(filtered_mask, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) r, c = 400, 400 dp = cv2.cvtColor(filtered_mask, cv2.COLOR_GRAY2BGR) cv2.line(dp, (c // 2, 1), (c // 2, r), (255, 0, 0), 5) midPoint = c // 2 maxArea = 0 offset = 0.0 angle = 0.0 for cntrs in contours: mu = cv2.moments(cntrs, False) x, y, w, h = cv2.boundingRect(cntrs) #if mu['m00'] > 120.0: if True: cx = x + (w // 2) # centre point area = mu['m00'] if area > maxArea: maxArea = area offset = midPoint - cx #offset = cx angle = math.atan2(w if offset >= 0 else -w, h) cv2.rectangle(dp, (x, y), (x + w, y + h), (0, 255, 0), 2) else: cv2.rectangle(dp, (x, y), (x + w, y + h), (0, 0, 255), 2) #print(area, cx, maxArea) cv2.imshow("frame", dp) angle = int(Support.remap(angle, -math.pi / 2, math.pi / 2, 0, 255)) offset = int(127 - Support.remap(offset, 0, c, 0, 255)) return offset, angle
def is_lane_curvature_accepted(ploty, leftx, lefty, rightx, righty): left_curverad, right_curverad = Support.get_real_lanes_curvature( ploty, leftx, lefty, rightx, righty) print(left_curverad, right_curverad) if left_curverad > 2000 and right_curverad > 2000: return True # Almost straight lanes elif (left_curverad < 80 or right_curverad < 80): return False # elif (left_fit[0] > 0 and right_fit[0] < 0) or (right_fit[0] > 0 and left_fit[0] < 0): # return False # same curvature wit opposite direction else: return True
async def set_invite_link(message, args, author_perms): """ """ jc = Support.get_jc_from_channel(message.channel) guild = message.guild if message.guild else message.author jc_guild = get_jc_guild(guild.id) if not jc_guild: # if not in db, create new one jc_guild = Guild( guild.id, prefix=f"@{Support.get_jc_from_channel(message.channel)}") jc_guild.name = guild.name # set some attrs jc_guild.guild = guild if message.guild else None jc_guild.edit_guild() if validators.url(args[2]): # link provided if message.guild and not author_perms.create_instant_invite: # missing permission await Support.missing_permission("Create Invite", message) return jc_guild.invite_link = args[2] await simple_bot_response( message.channel, description= f"**{jc_guild.name}'s Default Event Invite Link:** {jc_guild.invite_link}" ) elif args[2]: # invalid link await simple_bot_response( message.channel, title="Invalid Link", description=f"`@{jc} {args[1]} <invite_link>`", reply_message=message) else: # no link provided description = f"**{jc_guild.name}'s Default Event Invite Link:** {jc_guild.invite_link if jc_guild.invite_link else '`None Provided`'}\n\n" description += f"`@{jc} {args[1]} <invite_link>`" await simple_bot_response(message.channel, description=description, reply_message=message) jc_guild.edit_guild()
def basesize(isize): size = 0 try: if isize[-2:] == "kb": size = int(isize[:-2]) * 1000 elif isize[-2:] == "Mb": size = int(isize[:-2]) * 1000000 else: size = int(isize) return size except: raise ValueError( sp.error( "Size must be a number, optionally ending with either \"kb\" or \"Mb\"!" ))
def guess_character(selected_word, guessed_chars): "Prompts the user to make a guess" indexes = [] char = input("Try and guess a character: ") char = char.lower() selected_word = selected_word.lower() if char in selected_word and not(char in guessed_chars): print("YOu guessed correctly!") indexes = sup.find_in_string(selected_word, char) return indexes, [char] elif char in guessed_chars: print("You already guessed that dummy") return [-2], [] else: print("You guessed incorrectly ;(") return [-1], [char]
def generateTasks (self , gameData, fixedTask=None, fixedTime=None): for (pid, pdata) in gameData.player.iteritems(): if not gameData.hasTasks (pid): print "Generating task for player " + pid acts = gameData.getPossibleActions() if len(acts) > 0: if fixedTask == None: ourAct = Support.randomFromList(acts) else: ourAct = acts[fixedTask] if fixedTime == None: runtime = random.randint(self.taskTime[0], self.taskTime[1]) else: runtime = fixedTime gameData.currentTasks += [ Task(ourAct[1], ourAct[0], pid, runtime) ] print "> Task added"
def testBatchGradient(self): # Manually build a gradient list gradient_list = [] n_layers = 2 batch_size = 3 w = np.ones([3, 5]) b = np.ones([1, 5]) grad = sup.Variables() for i in range(n_layers): grad.weights.append(w) grad.biases.append(b) for j in range(batch_size): gradient_list.append(grad) # Manually compute batch gradient batch_gradient_manual = grad * batch_size batch_gradient = self.optimizer.computeBatchGradient(gradient_list) self.assertTrue(batch_gradient_manual == batch_gradient)
def testVariables(self): var = sup.Variables() var.weights.append(np.ones([2, 2])) var.weights.append(np.ones([2, 2])) var.biases.append(np.ones([1, 2])) var.biases.append(np.ones([1, 2])) # Multiplication var_neg = var * (-1) for i in range(len(var)): self.assertTrue( np.all(var.weights[i] + var_neg.weights[i] == np.zeros_like(var.weights[i]))) self.assertTrue( np.all(var.biases[i] + var_neg.biases[i] == np.zeros_like(var.biases[i]))) # Addition var_add = var + var_neg for i in range(len(var_add)): self.assertTrue( np.all(var_add.weights[i] == np.zeros_like(var.weights[i]))) self.assertTrue( np.all(var_add.biases[i] == np.zeros_like(var.biases[i]))) # Subtraction var_sub = var - var for i in range(len(var_sub)): self.assertTrue( np.all(var_sub.weights[i] == np.zeros_like(var.weights[i]))) self.assertTrue( np.all(var_sub.biases[i] == np.zeros_like(var.biases[i]))) # Equality self.assertTrue(var == var) self.assertFalse(var == var_sub) # Inequality self.assertFalse(var != var) self.assertTrue(var != var_sub)
def submitEnrichrGenesets(infile, outfile): # Read infile cdDataframe = pd.read_table(infile, index_col='gene_symbol').fillna(0) # Initialize link dataframe resultDataframe = pd.DataFrame() # Loop through timepoints for comparison in cdDataframe.columns: # Get Enrichr links enrichrLinkDataframe = S.uploadToEnrichr(cdDataframe, comparison) # Add comparison label enrichrLinkDataframe['comparison'] = comparison # Concatenate resultDataframe = pd.concat([resultDataframe, enrichrLinkDataframe]) # Save data resultDataframe.to_csv(outfile, sep='\t', index=False)
def getReceiveDataHandler(participant,topic): key = __makeKey(topic) rdh = None if key in __ReceiveDataHandler: rdh = __ReceiveDataHandler[key] if max(rdh.topic.sampleMaxSize,topic.sampleMaxSize) > PACKET_MAX_SIZE: message = "Warning: " if topic.transport == TRANSPORT_UDP: message += "UDP Transport" else: message += "Same port (%s)" % topic.port message += " is used with Topics with 'sampleMaxSize' > %s" % PACKET_MAX_SIZE print message else: localInterface = Support.doSubnetTranslation(topic.localInterface) if topic.transport == TRANSPORT_MC: rdh = McReceiveDataHandler(localInterface,topic) if topic.transport == TRANSPORT_UDP: rdh = UdpReceiveDataHandler(localInterface,topic) rdh.start() __ReceiveDataHandler[key] = rdh return rdh
def build_new(self): logger.info("Build New") self.allunits = [] self.groups = {} self.allreinforcements = {} self.prefabs = [] self.objective = None self.map = None self.counters = {} self.counters['level'] = 0 self.convoy = [] self.counters['money'] = 0 self.play_time = 0 self.game_constants = [] self.support = Support.Support_Graph( 'Data/support_nodes.txt', 'Data/support_edges.txt') if cf.CONSTANTS['support'] else None self.modify_stats = cf.read_growths_file() self.unlocked_lore = [] self.statistics = [] self.market_items = set() self.sweep() self.generic()
def getEnrichrResults(infile, outfile): # Read infile enrichrLinkDataframe = pd.read_table(infile, index_col=['geneset', 'comparison']) # Initialize result dataframe resultDataframe = pd.DataFrame() # Set libraries libraries = [ 'ChEA_2016', 'KEGG_2016', 'GO_Biological_Process_2015', 'GO_Cellular_Component_2015', 'GO_Molecular_Function_2015', 'VirusMINT' ] # Loop through timepoints, genesets and libraries for geneset in enrichrLinkDataframe.index.levels[0]: for comparison in enrichrLinkDataframe.index.levels[1]: for library in libraries: # Get enrichment results enrichmentResultDataframe = S.getEnrichmentResults( enrichrLinkDataframe.loc[(geneset, comparison), 'userListId'], library) # Add labels enrichmentResultDataframe['comparison'] = comparison enrichmentResultDataframe['geneset'] = geneset enrichmentResultDataframe['library'] = library # Concatenate resultDataframe = pd.concat( [resultDataframe, enrichmentResultDataframe]) # Write file resultDataframe.to_csv(outfile, sep='\t', index=False)
def load(self, load_info): logger.info("Load") # Rebuild gameStateObj self.allunits = [ UnitObject.UnitObject(info) for info in load_info['allunits'] ] self.factions = load_info['factions'] if 'factions' in load_info else ( load_info['groups'] if 'groups' in load_info else {}) self.allreinforcements = load_info['allreinforcements'] self.prefabs = load_info['prefabs'] self.triggers = load_info.get('triggers', dict()) map_info = load_info['map'] self.playtime = load_info['playtime'] self.convoy = [ ItemMethods.deserialize(item_dict) for item_dict in load_info['convoy'] ] self.convoy = [item for item in self.convoy if item] self.turncount = load_info['turncount'] self.game_constants = load_info['game_constants'] self.level_constants = load_info['level_constants'] self.objective = CustomObjects.Objective.deserialize( load_info['objective']) if load_info['objective'] else None self.phase_music = CustomObjects.PhaseMusic.deserialize( load_info['phase_music']) if load_info['phase_music'] else None support_dict = load_info['support'] self.talk_options = load_info['talk_options'] self.base_conversations = load_info['base_conversations'] self.stateMachine = StateMachine.StateMachine( load_info['state_list'][0], load_info['state_list'][1]) self.statistics = load_info['statistics'] # self.message = [Dialogue.Dialogue_Scene(scene) for scene in load_info['message']] self.message = [] self.unlocked_lore = load_info['unlocked_lore'] self.market_items = load_info.get('market_items', set()) self.mode = load_info.get('mode', self.default_mode()) # Map self.map = SaveLoad.create_map('Data/Level' + str(self.game_constants['level'])) if map_info: self.map.replay_commands(map_info['command_list'], self.game_constants['level']) self.map.command_list = map_info['command_list'] for position, current_hp in map_info['HP']: self.map.tiles[position].set_hp(current_hp) # Statuses for index, info in enumerate(load_info['allunits']): for s_dict in info['status_effects']: if isinstance(s_dict, dict): StatusObject.deserialize(s_dict, self.allunits[index], self) else: self.allunits[index].status_effects.append(s_dict) # Support if cf.CONSTANTS['support']: self.support = Support.Support_Graph('Data/support_nodes.txt', 'Data/support_edges.txt') self.support.deserialize(support_dict) else: self.support = None # Set up blitting surface if self.map: mapSurfWidth = self.map.width * GC.TILEWIDTH mapSurfHeight = self.map.height * GC.TILEHEIGHT self.mapSurf = Engine.create_surface((mapSurfWidth, mapSurfHeight)) self.grid_manager = AStar.Grid_Manager(self.map) self.boundary_manager = CustomObjects.BoundaryManager(self.map) for unit in self.allunits: if unit.position: self.grid_manager.set_unit_node(unit.position, unit) self.generic() if 'phase_info' in load_info: self.phase.current, self.phase.previous = load_info['phase_info']
def gradient_descent(train_elements, alpha, numIterations, k, verbose=0, jump_enabled=0): inputs = [] outputs = [] for e in range(0, len(train_elements)): inputs.append(train_elements[e].input) outputs.append(train_elements[e].output) x = numpy.asarray(inputs) y = numpy.asarray(outputs) m, n = numpy.shape(x) theta = numpy.ones(n) x_trans = x.transpose() counter_for_jump = 0 previous_cost = 0 for i in range(0, numIterations): results = [] for j in range(len(train_elements)): results.append( knn.get_error_estimation_weighted_on_input( train_elements[j].input, theta, train_elements[j].neighbors_i, train_elements[j].neighbors_o, k, False)) hypothesis = numpy.asarray(results) loss = hypothesis - y cost = numpy.sum(loss**2) / (2 * m) if verbose: Support.colored_print("Iteration %d | Cost: %f" % (i, cost), "red") if jump_enabled: if previous_cost == cost: counter_for_jump += 1 if counter_for_jump > 10: counter_for_jump = 0 if cost > 10: # making jump # selecting random indexes to perturbate indexes_to_perturbate = numpy.random.choice( range(len(theta)), int(float(len(theta)) * 0.4), replace=False) for j in range(len(indexes_to_perturbate)): # selecting random percentage perturbation perturbation_value = random.randint(1, 6) * 0.1 perturbated = theta[ indexes_to_perturbate[j]] * perturbation_value if random.randint(0, 2) == 0: perturbated *= -1 theta[indexes_to_perturbate[j]] = perturbated i -= 1 continue else: previous_cost = cost # avg gradient per example gradient = numpy.dot(x_trans, loss) / m # update theta = theta - alpha * gradient cost = numpy.sum(loss**2) / (2 * m) return theta, cost
#!/usr/bin/python #coding=utf-8 #导入模块 import Support #引用模块里的函数 Support.print_func("Test module.")
''' Created on Mar 27, 2014 @author: Mark.E.Frymire ''' import Support Support.print_func("#1") from Support import print_func print_func("#2") Money = 2000 print Money def incrementMoney(): aLocalVar = "Hi, I'm a local string." print "Locals:", locals() print "Globals:", globals() # Python assumes any variable assigned a value in a function is local, so you can't do this... # Money = Money + 1 # We have to first specify that we're using the global version. global Money Money = Money + 1 incrementMoney() print Money # Use dir to get the names defined by a module import math
my_game_tree[curr_node_id].print_node_details() curr_gamestate = my_game_tree[curr_node_id].node_gamestate empty_found = False """Find index of first empty (i.e. 0) in the current gamestate""" for game_row_cntr in range(game_config.GAME_DIMENSION * game_config.GAME_DIMENSION): for game_column_cntr in range(game_config.GAME_DIMENSION * game_config.GAME_DIMENSION): if curr_gamestate[game_row_cntr][game_column_cntr] == 0: empty_found = True empty_row_idx = game_row_cntr empty_col_idx = game_column_cntr break if empty_found: break """get list of possible values for empty position""" possible_vals = Support.compute_choices(curr_gamestate, empty_row_idx, empty_col_idx) print(possible_vals) """check if any possible values returned""" if len(possible_vals) > 0: game_node_level = game_node_level + 1 print("New tree level:", game_node_level) """for each possible value , create a MCTS node with appropriate values""" for new_val in possible_vals: """tmp_MCTSnode.clear_node()""" print("New value:", new_val) tmp_gamestate = curr_gamestate tmp_gamestate[empty_row_idx][empty_col_idx] = new_val game_node_count = game_node_count + 1 my_game_tree[curr_node_id].node_children.append(game_node_count) my_game_tree.append( MCTS_node.MCTSnode(