len(back_LLRs):\n\t\t\tprint \"Warning: the FAR is too high for the given number of background events to correctly determine threshold log likelihood ratio, so using smallest found LLR.\"\n\t\t\tthreshold = back_LLRs[0]\n\t\telif num_back_above_thresh == 0.:\n\t\t\tprint \"Warning: the FAR is too low for the given number of background events to correctly determine threshold log likelihood ratio, so using the largest found LLR.\"\n\t\t\tthreshold = back_LLRs[-1]\n\t\telse:\n\t\t\tthreshold = back_LLRs[ len(back_LLRs) - num_back_above_thresh ]\n\t\t\n\t\treturn threshold","def ram_max(self):\n return max(self.ram_samples)","def _threshold_optimized_fbeta_score(self, y_true: np.ndarray, y_pred: np.ndarray, beta: float, return_threshold: bool=False) -> float:\n\n thresholds = np.arange(0,1.01,0.01)\n threshold_fbeta_scores = []\n\n # calculate fbeta score for all thresholds\n for threshold in thresholds:\n threshold_predictions = [1 if y > threshold else 0 for y in y_pred]\n fb_score = fbeta_score(y_true, threshold_predictions, beta=beta)\n threshold_fbeta_scores.append((fb_score, threshold))\n\n # return the maximal fbeta score\n if not return_threshold:\n max_score = max(threshold_fbeta_scores, key=itemgetter(0))[0] \n return max_score\n\n # return the threshold corresponding to the maximal fbeta score\n elif return_threshold:\n threshold_to_max_score = max(threshold_fbeta_scores, key=itemgetter(0))[1]\n return threshold_to_max_score","def find_max_f():\n fmax = fmin(g, 2)\n return fmax[0]","def personal_best(scores: list) -> int:\n return max(scores)","def __max_value(self, game, depth):\n self.__check_time()\n val = float('-inf')\n\n # check if out of moves or at depth limit\n if self.__is_terminal(game, depth):\n val = self.score(game, self)\n else:\n for move in game.get_legal_moves():\n # depth decremented by 1 on each call\n val = max(val, self.__min_value(game.forecast_move(move), depth - 1))\n\n return val","def steer_max(self):\n return self._steer_max","def _maximum(self) -> float:\n return self._config[CONF_MAX]","def personal_best(scores):\n return max(scores)","def negamax(self):\n if self.check_winner():\n return 1\n elif self.full():\n return 0\n else:\n bestScore = -10\n for r, c in self.empty_cells():\n self.grid[r][c] = self.player\n self.next_player() \n score = -self.negamax()\n if score > bestScore:\n bestScore = score\n self.grid[r][c] = GameModel.EMPTY\n self.next_player()\n return bestScore","def get_max_passes(example_height: int) -> int:\n return (example_height - 5) // 4","def maxOldQ(self,feat):\r\n maxQ = float('-inf')\r\n for a in self.actions:\r\n q = self.oldQ(feat,a)\r\n \r\n if q > maxQ:\r\n maxQ = q\r\n \r\n return(maxQ)","def _get_max_sampled_bandit(self)->Bandit:\n estimates = []\n for bandit in self.bandits:\n Qth = np.random.normal(loc =self.mu[bandit.id], scale = self.var[bandit.id])\n f_hat = self.mu[bandit.id]#computing moving_average here \n estimates.append(max(Qth, f_hat))\n return self.bandits[np.argmax(estimates)]","def _get_sep_extract_threshold_(self):\n #print \"_get_sep_extract_threshold_ called\"\n \n if not hasattr(self,\"_sepbackground\"):\n _ = self.get_sep_background(update_background=False)\n return self._sepbackground.globalrms*1.5","def above_threshold(self, value):\n # We use floating point number here so we have to take care\n return finf(value,self.min) or finf(self.max,value)","def worst_B(Ag):\n bottom = 0\n for i in range(len(Ag)):\n etop = np.max(cf.TD20[int(Ag[i]) - 1])\n bottom += etop\n return bottom","def max(self):\r\n\t\treturn max(self.sample)","def max_missed_fraud(prediction, label, amount):\n fn_vec = (prediction == 0) & (label > 0)\n fraud_loss_max = np.nan_to_num(amount[fn_vec].max())\n return fraud_loss_max","def max_e_score(self, entity):\n return float(entity['es_bb'][1])","def compute_max_separability_score(self) -> Dict:\n max_sep_score = {}\n for class_pair_key, class_pair_val in self.separability_scores.items():\n max_sep_score[class_pair_key] = max([val for _, val in class_pair_val.items()])\n max_sep_score['agg_with_risk'] = sum(\n np.array([val for _, val in max_sep_score.items()]) *\n RISK\n ) \n max_sep_score['agg'] = sum([val for key, val in max_sep_score.items() if type(key)==int]) \n return max_sep_score","def _find_cutoff(self):\n cutoff = 1\n while ((self.linear_rstar_unnorm(cutoff) -\n self.turing_rstar_unnorm(cutoff))**2\n > self.approx_turing_variance(cutoff)):\n cutoff += 1\n return cutoff","def find_max_gap(self, free_space_ranges):\n start = end = 200\n curr_start = 200\n #print(free_space_ranges)\n for i in range(201, 880):\n if free_space_ranges[i] != 0:\n if free_space_ranges[i-1] == 0:\n curr_start = i\n else:\n if (i-curr_start) > end-start:\n start = curr_start\n end = i\n return start, end","def max_value(self) -> float:\n return DEFAULT_MAX_VALUE","def calculate_FAR_of_thresh(self, threshold, livetime, groundtype):\n\t\t#Find FAR from number of events above a threshold\n\t\tFAR = float(np.sum(self.LLR_above_thresh(threshold=threshold, groundtype=groundtype)))/float(livetime)\n\t\t\n\t\t#If FAR is null, choose FAR to be that of the most extreme background event\n\t\tif FAR == 0.:\n\t\t\tFAR = 1./float(livetime)\n\t\t\n\t\treturn FAR","def _maximum(self) -> float:\n if self._type == \"power\":\n return 5.0\n elif self._type == \"setpoint\":\n return self._product.get_data_config_json()[\"_value_setpoint_max\"]\n elif self._type == \"fan1\":\n fan = 1\n return self._product.get_data_config_json()[\"_value_fan_limits\"][\n (((fan - 1) * 2) + 1)\n ]\n elif self._type == \"fan2\":\n fan = 2\n return self._product.get_data_config_json()[\"_value_fan_limits\"][\n (((fan - 1) * 2) + 1)\n ]\n elif self._type == \"fan3\":\n fan = 3\n return self._product.get_data_config_json()[\"_value_fan_limits\"][\n (((fan - 1) * 2) + 1)\n ]","def score_waypoint(distance):\n return max(0,\n float(settings.SATISFIED_WAYPOINT_DIST_MAX_FT - distance) /\n settings.SATISFIED_WAYPOINT_DIST_MAX_FT)","def _get_max_estimated_bandit(self)->Bandit:\n # print(\"mus - \", self.mu)\n # print(\"actions - \", np.argmax(self.mu))\n unique, counts = np.unique(self.mu, return_counts=True)\n lens = counts[np.argmax(unique)] \n if lens>1: # if two actions have same argmax\n # then return arbitrarily from those max ones\n maxs = list(np.array(self.bandits)[self.mu==unique[np.argmax(unique)]])\n return np.random.choice(maxs)\n # otherwise return the max one\n return self.bandits[np.argmax(self.mu)]","def getMinAbundanceOfClrSample(self):\n #try: minimum = min(self.clr_sample['abundance'])-0.001\n try: minimum = min(self.clr_sample)-0.01\n except: minimum = 0\n return minimum","def max_grade(self) -> float:\n return sum(self.test_weights.values())","def personal_best(scores):\n# return sorted(scores, reverse=True)[0]\n return max(scores)","def get_max_praises(self):\n char = self.caller.char_ob\n clout = char.social_clout\n s_rank = char.item_data.social_rank\n return clout + ((8 - s_rank) // 2)","def max_grains(self):\n index = self._ordered_input_names.index('max_grains')\n return self._inputs[index]","def max_error(self) -> float:\n return float(np.max(np.abs(self._flattened_errors())))","def max(self):\n\n maximum = -float('inf')\n\n for stack in self:\n stack_max = stack.max()\n if stack_max > maximum:\n maximum = stack_max\n\n return maximum","def adaptive_limit(self) -> int:\n return pulumi.get(self, \"adaptive_limit\")","def _calculate_score_with_threshold(self):\n\n clue_number = 0\n positive_score, negative_score = 0, 0\n negative_number = 0\n total_score = 0\n\n # find largest negative score\n largest_negative_score = -1.\n for ix, (card, score) in enumerate(self.sorted_card_score_pairs):\n # find maximum score of negative word\n if card.color not in [self.team, \"DOUBLE\"]:\n largest_negative_score = score\n break\n\n # add scores higher than threshold + largest negative score to positive_score\n for card, score in self.sorted_card_score_pairs:\n if (score > (self.delta+largest_negative_score)\n and card.color in [self.team, \"DOUBLE\"]):\n clue_number += 1\n positive_score += score\n elif card.color not in [self.team, \"DOUBLE\"]:\n negative_score += score\n negative_number += 1\n else:\n continue\n\n if not self.penalize_negative:\n self.logger.info(\"negative score set to 0.\")\n negative_score = 0\n\n # if threshold(delta) is large, there will be no clues.\n # try to give at least one clue\n # select the positive card with score larger than largest_negative_score.\n if clue_number == 0:\n self.logger.debug(\"clue number: 0.\")\n for card, score in self.sorted_card_score_pairs:\n if card.color in [self.team, \"DOUBLE\"]:\n positive_score = score\n clue_number += 1\n self.cropped_threshold = score - largest_negative_score\n else:\n positive_score = 0\n break\n\n if self.normalize_negative:\n total_score = (1-self.alpha) * positive_score - self.alpha * negative_score / negative_number\n else:\n total_score = (1-self.alpha) * positive_score - self.alpha * negative_score\n self.logger.debug(\"word: {}, positive_score: {}, negative_score: {}, total_score: {}\".format(self.clue, positive_score, negative_score, total_score))\n return total_score, clue_number","def find_best_threshold(y, y_hat, step_size, score_func, maximize=True):\n best_thres, best_score = 0.0, 0.0 if maximize else 1.0\n for thres in np.arange(0, 1, step_size):\n score = score_for_threshold(y, y_hat, score_func, thres)\n if (maximize and (score > best_score)) or (not maximize and (score < best_score)):\n best_score = score\n best_thres = thres\n\n return best_thres, best_score","def max_abs_error(self) -> float:\n return np.max(np.abs([self.error]))","def max_findings_per_request(self) -> float:\n return pulumi.get(self, \"max_findings_per_request\")","def image_gc_high_threshold(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"image_gc_high_threshold\")","def get_fitness(self):\n score = self.score - (abs(self.distance_to_pipe()[0])) * 0.3\n score = self.score + 1.5 * 1e-3 * self.birth_time - (abs(self.distance_to_pipe()[0])) * 0.001\n score = self.birth_time * 3 - \\\n (abs(Bird.lower_pipes[self.get_next_pipe_index()]['y'] - PIPE_GAP_SIZE // 2 - self.pos_y)) * 0.5\n pipe_width = IMAGES['pipe'][0].get_width()\n\n constants.debug_circle = Bird.lower_pipes[self.get_next_pipe_index()]['x'] + pipe_width // 1.2, \\\n Bird.lower_pipes[\n self.get_next_pipe_index()]['y'] - PIPE_GAP_SIZE // 10\n constants.debug_circle = tuple(map(int, constants.debug_circle))\n # score *= 1e-1\n # score = self.score\n # if self.score > 1:\n # print(score)\n\n score = self.birth_time * 3 - abs(constants.debug_circle[1] - self.pos_y) + 5 * self.score\n return score","def maximum_score(self):\n max_score = self.values('question').annotate(\n top_answer=Max('score')\n )\n max_score = sum(d['top_answer'] for d in max_score)\n return max_score","def native_max_value(self) -> float:\n return 9","def sharpness_penalty(self):\n # This polynomial function gives the gain for peaking filter which achieves 18 dB / octave max derivative\n # The polynomial estimate is accurate in the vicinity of 18 dB / octave\n gain_limit = -0.09503189270199464 + 20.575128011847003 * (1 / self.q)\n # Scaled sigmoid function as penalty coefficient\n x = self.gain / gain_limit - 1\n sharpness_penalty_coefficient = 1 / (1 + np.e ** (-x * 100))\n return np.mean(np.square(self.fr * sharpness_penalty_coefficient))","def get_highscore(self, score):\n scores = list(self.history_score.values())\n \n # Compare current score with the last placing in leaderboard.\n if score > max(scores):\n return 0\n else:\n if score < min(scores):\n return 2\n else:\n return 1","def find_B(self):\n max_lb = 0\n for arc in self.arcs():\n lb = self.arc_info[arc[0]]['lower_bound']\n max_lb = max(max_lb, lb)\n n = len(self)\n m = len(list(self.edges()))\n return((m - n + 2)*max_lb)","def worst(self) -> float:\n return float(self.tsdf.pct_change().min())","def threshold(self) -> Optional[pulumi.Input[float]]:\n return pulumi.get(self, \"threshold\")","def threshold(self) -> Optional[pulumi.Input[float]]:\n return pulumi.get(self, \"threshold\")","def threshold(self) -> Optional[pulumi.Input[float]]:\n return pulumi.get(self, \"threshold\")","def _get_maximum(self):\n return self._maximum"],"string":"[\n \"def max_gap(self):\\n return self._max_gap\",\n \"def max_score(self):\\n return self.raw_possible\",\n \"def max_score(self):\\r\\n max_score = None\\r\\n if self.check_if_done_and_scored():\\r\\n max_score = self._max_score\\r\\n return max_score\",\n \"def max_score(self):\\n return self.points\",\n \"def get_high_score(self) -> float:\\n return max(self._scores)\",\n \"def max_score(self):\\r\\n return self.lcp.get_max_score()\",\n \"def max_gain(self):\\n return np.max(self.fr)\",\n \"def pwm_max_score(self):\\n if self.max_score is None:\\n score = 0\\n for row in self.pwm:\\n score += log(max(row) / 0.25 + 0.01)\\n self.max_score = score\\n \\n return self.max_score\",\n \"def worst_score(self):\\r\\n pass\",\n \"def getMaxAlignmentScore(self):\\n # get max of each row\\n # max_scores = [max(i) for i in self.matrix]\\n\\n # return the max of the max vaules\\n return numpy.max(self.matrix)\",\n \"def max_score(self):\\n return max(self._extract_set('score') or [0])\",\n \"def getMaxAbundanceOfSample(self):\\n try: maximum = max(self.sample[self.sample['masked'] == False]['abundance'])+0.01\\n except: maximum = 0\\n return maximum\",\n \"def get_max_lb(self):\\n max_lb = 0\\n for arc in self.arc_info.keys():\\n if self.arc_info[arc][\\\"lower_bound\\\"] > max_lb:\\n max_lb = self.arc_info[arc][\\\"lower_bound\\\"]\\n return max_lb\",\n \"def max_findings(self) -> float:\\n return pulumi.get(self, \\\"max_findings\\\")\",\n \"def __find_max_distance(self):\\n return utils.find_max_distance(self.__game)\",\n \"def getMaxAbundanceOfClrSample(self):\\n #try: maximum = max(self.clr_sample['abundance'])+0.001\\n try: maximum = max(self.clr_sample)+0.01\\n except: maximum = 0\\n return maximum\",\n \"def highest_value():\\n maximum_number = 0\\n for i in xrange(length):\\n challenger = frames[i]\\n if abs(challenger) > maximum_number:\\n maximum_number = abs(challenger)\\n return maximum_number\",\n \"def get_max_score(self):\\r\\n return sum(self.maxpoints.values())\",\n \"def getHighScore(self):\\n return max(self.scores)\",\n \"def lmax(self):\\n cond = (self.transmit / self.transmit.max()) > 1./100\\n return max(self.wavelength[cond])\",\n \"def compute_optimal_block_maximum(block_counts) -> int:\\n q1, q3 = compute_quartiles(block_counts)\\n iqr = q3 - q1\\n high_threshold = q3 + 1.5 * iqr\\n return high_threshold\",\n \"def reward_threshold(self) -> Optional[float]:\",\n \"def maximumGap(self, nums: List[int]) -> int:\\r\\n n = len(nums)\\r\\n if n < 2: return 0 \\r\\n l, r = min(nums), max(nums)\\r\\n if r - l == 0: return 0 \\r\\n gap_instance = max(1, (r - l) // n)\\r\\n gapcnts = math.ceil((r - l + 1) / gap_instance)\\r\\n buckets = [[-1, -1] for _ in range(gapcnts)] \\r\\n calpos = lambda num: (num - l) // gap_instance\\r\\n\\r\\n for num in nums:\\r\\n pos = calpos(num)\\r\\n if num < buckets[pos][0] or buckets[pos][0] == -1:\\r\\n buckets[pos][0] = num \\r\\n if num > buckets[pos][1] or buckets[pos][1] == -1:\\r\\n buckets[pos][1] = num \\r\\n\\r\\n ans, pre = 0, l\\r\\n for small, large in buckets:\\r\\n if small == -1:\\r\\n continue \\r\\n else:\\r\\n ans = max(small - pre, ans)\\r\\n pre = large\\r\\n return ans\",\n \"def maxim(self) -> (int, float('inf')):\\n\\t\\treturn 2\",\n \"def calculate_indicator_score(self, risk_from_feed):\\n dbot_score = 0\\n risk_from_feed = int(risk_from_feed)\\n if risk_from_feed >= self.threshold or risk_from_feed >= 65:\\n dbot_score = 3\\n elif risk_from_feed >= 5:\\n dbot_score = 2\\n\\n return dbot_score\",\n \"def max_gain(self):\\n if self.val1:\\n val1_gain_tuple, val0_gain_tuple = self.val1.max_gain(), self.val0.max_gain()\\n if val1_gain_tuple.gain > val0_gain_tuple.gain:\\n return val1_gain_tuple\\n else:\\n return val0_gain_tuple\\n elif self.attributes:\\n filtered_data = filter_data(self.data,self.ancestors)\\n max_attribute, max_gain = max([(attribute,\\n self.heuristic(self,attribute)) for attribute in self.attributes],\\n key = lambda x: x[1])\\n return gain_tuple(self, max_attribute, max_gain)\\n return gain_tuple(None, '', 0)\",\n \"def max_score_test(self):\\n max_score_tuple = self.results.max_score(molecules=[\\\"DDSPDLPK\\\"])\\n assert max_score_tuple[0] == 1 # score\\n assert max_score_tuple[3].scaling_factor == 100 # intensity\\n\\n assert self.results.max_score(molecules=[\\\"_DDSPDLPK_\\\"]) == [0, None, None, None]\\n return\",\n \"def max_well(self):\\n maxVal = np.max(self.get_well_depth_image())\\n return maxVal\",\n \"def get_max_score(self):\\r\\n maxscore = 0\\r\\n for responder in self.responders.values():\\r\\n maxscore += responder.get_max_score()\\r\\n return maxscore\",\n \"def get_maximum_fitness(self) -> float:\\n anticipated_change_cls = [cl for cl in self\\n if cl.does_anticipate_change()]\\n\\n if len(anticipated_change_cls) > 0:\\n best_cl = max(anticipated_change_cls, key=lambda cl: cl.fitness)\\n return best_cl.fitness\\n\\n return 0.0\",\n \"def threshold(self) -> float:\\n return pulumi.get(self, \\\"threshold\\\")\",\n \"def get_greatest_probability(self):\\n greatest = -1\\n for i in range(self.dim):\\n for j in range(self.dim):\\n if self.kb[i][j] > greatest:\\n greatest = self.kb[i][j]\\n\\n return greatest\",\n \"def max(self) -> float:\\n return stats.max(self)\",\n \"def search_for_maximum(self):\\n return self.maximise_aquisition(self.expected_improvement)\",\n \"def gap_depth(self):\\n return self.container['gap_depth']\",\n \"def band_penalty(self):\\n fc_ix = np.argmin(np.abs(self.f - self.fc)) # Index to frequency array closes to center frequency\\n # Number of indexes on each side of center frequency, not extending outside, only up to 10 kHz\\n n = min(fc_ix, self.ix10k - fc_ix)\\n if n == 0:\\n return 0.0\\n return np.mean(np.square(self.fr[fc_ix - n:fc_ix] - (self.gain - self.fr[fc_ix + n - 1:fc_ix - 1:-1])))\",\n \"def _get_fairness_threshold(self):\\n if self.fairness_threshold == \\\"auto\\\":\\n if self._get_ml_task() in [\\n BINARY_CLASSIFICATION,\\n MULTICLASS_CLASSIFICATION,\\n ]:\\n thresholds = {\\n \\\"demographic_parity_difference\\\": 0.1,\\n \\\"demographic_parity_ratio\\\": 0.8,\\n \\\"equalized_odds_difference\\\": 0.1,\\n \\\"equalized_odds_ratio\\\": 0.8,\\n }\\n return thresholds.get(self._fairness_metric, 0.8)\\n elif self._get_ml_task() == REGRESSION:\\n thresholds = {\\n \\\"group_loss_ratio\\\": 0.8,\\n }\\n if self._fairness_metric == \\\"group_loss_difference\\\":\\n raise AutoMLException(\\n \\\"We can't set default fairness threshold value. Please set `fairness_threshold` value in AutoML constructor.\\\"\\n )\\n return thresholds.get(self._fairness_metric, 0.8)\\n else:\\n return deepcopy(self.fairness_threshold)\",\n \"def test_fix_fingers_clip_xmax(self):\\n\\t\\t\\n\\t\\t# CLIP_XMAX\\n\\t\\tdetails = self.watcher.analyze(layers=[self.second_layer], fix_fingers='clip_xmax', pl_package=WW_POWERLAW)\\n\\t\\tactual = details.alpha.to_numpy()[0]\\n\\t\\texpected = 1.72\\n\\t\\tself.assertAlmostEqual(actual,expected, places=2)\\n\\t\\t\\n\\t\\tnum_fingers = details.num_fingers.to_numpy()[0]\\n\\t\\tself.assertEqual(num_fingers,0)\",\n \"def f_max(cls):\\n return cls.params[\\\"f_max\\\"]\",\n \"def best_action(self):\\n child_score = self.child_Q() + self.mcts.c_puct * self.child_U()\\n masked_child_score = child_score\\n return np.argmax(masked_child_score)\",\n \"def max_surge(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"max_surge\\\")\",\n \"def max_in_gbps(self):\\n return self._max_in_gbps\",\n \"def band_penalty(self):\\n fc_ix = np.argmin(np.abs(self.f - self.fc)) # Index to frequency array closes to center frequency\\n # Number of indexes on each side of center frequency, not extending outside, only up to 10 kHz\\n n = min(fc_ix, self.ix10k - fc_ix)\\n if n == 0:\\n return 0.0\\n return np.mean(np.square(self.fr[fc_ix - n:fc_ix] - self.fr[fc_ix + n - 1:fc_ix - 1:-1]))\",\n \"def maximal_valance(self) -> int:\\n max_valances = {'H': 1, 'B': 4, 'C': 4, 'N': 4, 'O': 3, 'F': 1,\\n 'Si': 4, 'P': 6, 'S': 6, 'Cl': 4, 'Br': 4, 'I': 6}\\n\\n if self.label in max_valances:\\n return max_valances[self.label]\\n\\n else:\\n logger.warning(f'Could not find a valid valance for {self}. '\\n f'Guessing at 6')\\n return 6\",\n \"def get_worst_fitness(self):\\n f = min(self.characters, key=operator.attrgetter('fitness'))\\n self.worst_fitness = round(f.fitness, 3)\",\n \"def largest_background_LLR(self):\\n\\t\\treturn np.sort(self.log_likelihood_ratios(groundtype='Background'))[-1]\",\n \"def find_max_bin(self):\\n x = self.local['clip']\\n midrange = x[int(len(x)*0.2):int(len(x)*.2 + int(len(x)*.5))]\\n self.max_bin = max(midrange)\",\n \"def block7_threshold(self):\\n return self._safe_value(VAR_BLOCK7THRESHOLD, float)\",\n \"def calc_score(score):\\n if not score:\\n return 0\\n dbot_score = 1\\n if score >= 95:\\n dbot_score = 3\\n elif score >= 75:\\n dbot_score = 2\\n return dbot_score\",\n \"def calculate_threshold_from_background(self, FAR, livetime):\\n\\t\\t#Calculate the number of false alarms expected over a time interval at a given FAR\\n\\t\\tnum_back_above_thresh = int( FAR * livetime)\\n\\t\\t\\n\\t\\t#Sort the background LLRs from smallest to largest\\n\\t\\tback_LLRs = np.sort(self.log_likelihood_ratios(groundtype='Background'))\\n\\t\\t\\n\\t\\tif back_LLRs.size == 0:\\n\\t\\t\\traise ValueError, \\\"Error: no background events so cannot determine threshold log likelihood ratio.\\\"\\n\\t\\telif num_back_above_thresh > len(back_LLRs):\\n\\t\\t\\tprint \\\"Warning: the FAR is too high for the given number of background events to correctly determine threshold log likelihood ratio, so using smallest found LLR.\\\"\\n\\t\\t\\tthreshold = back_LLRs[0]\\n\\t\\telif num_back_above_thresh == 0.:\\n\\t\\t\\tprint \\\"Warning: the FAR is too low for the given number of background events to correctly determine threshold log likelihood ratio, so using the largest found LLR.\\\"\\n\\t\\t\\tthreshold = back_LLRs[-1]\\n\\t\\telse:\\n\\t\\t\\tthreshold = back_LLRs[ len(back_LLRs) - num_back_above_thresh ]\\n\\t\\t\\n\\t\\treturn threshold\",\n \"def ram_max(self):\\n return max(self.ram_samples)\",\n \"def _threshold_optimized_fbeta_score(self, y_true: np.ndarray, y_pred: np.ndarray, beta: float, return_threshold: bool=False) -> float:\\n\\n thresholds = np.arange(0,1.01,0.01)\\n threshold_fbeta_scores = []\\n\\n # calculate fbeta score for all thresholds\\n for threshold in thresholds:\\n threshold_predictions = [1 if y > threshold else 0 for y in y_pred]\\n fb_score = fbeta_score(y_true, threshold_predictions, beta=beta)\\n threshold_fbeta_scores.append((fb_score, threshold))\\n\\n # return the maximal fbeta score\\n if not return_threshold:\\n max_score = max(threshold_fbeta_scores, key=itemgetter(0))[0] \\n return max_score\\n\\n # return the threshold corresponding to the maximal fbeta score\\n elif return_threshold:\\n threshold_to_max_score = max(threshold_fbeta_scores, key=itemgetter(0))[1]\\n return threshold_to_max_score\",\n \"def find_max_f():\\n fmax = fmin(g, 2)\\n return fmax[0]\",\n \"def personal_best(scores: list) -> int:\\n return max(scores)\",\n \"def __max_value(self, game, depth):\\n self.__check_time()\\n val = float('-inf')\\n\\n # check if out of moves or at depth limit\\n if self.__is_terminal(game, depth):\\n val = self.score(game, self)\\n else:\\n for move in game.get_legal_moves():\\n # depth decremented by 1 on each call\\n val = max(val, self.__min_value(game.forecast_move(move), depth - 1))\\n\\n return val\",\n \"def steer_max(self):\\n return self._steer_max\",\n \"def _maximum(self) -> float:\\n return self._config[CONF_MAX]\",\n \"def personal_best(scores):\\n return max(scores)\",\n \"def negamax(self):\\n if self.check_winner():\\n return 1\\n elif self.full():\\n return 0\\n else:\\n bestScore = -10\\n for r, c in self.empty_cells():\\n self.grid[r][c] = self.player\\n self.next_player() \\n score = -self.negamax()\\n if score > bestScore:\\n bestScore = score\\n self.grid[r][c] = GameModel.EMPTY\\n self.next_player()\\n return bestScore\",\n \"def get_max_passes(example_height: int) -> int:\\n return (example_height - 5) // 4\",\n \"def maxOldQ(self,feat):\\r\\n maxQ = float('-inf')\\r\\n for a in self.actions:\\r\\n q = self.oldQ(feat,a)\\r\\n \\r\\n if q > maxQ:\\r\\n maxQ = q\\r\\n \\r\\n return(maxQ)\",\n \"def _get_max_sampled_bandit(self)->Bandit:\\n estimates = []\\n for bandit in self.bandits:\\n Qth = np.random.normal(loc =self.mu[bandit.id], scale = self.var[bandit.id])\\n f_hat = self.mu[bandit.id]#computing moving_average here \\n estimates.append(max(Qth, f_hat))\\n return self.bandits[np.argmax(estimates)]\",\n \"def _get_sep_extract_threshold_(self):\\n #print \\\"_get_sep_extract_threshold_ called\\\"\\n \\n if not hasattr(self,\\\"_sepbackground\\\"):\\n _ = self.get_sep_background(update_background=False)\\n return self._sepbackground.globalrms*1.5\",\n \"def above_threshold(self, value):\\n # We use floating point number here so we have to take care\\n return finf(value,self.min) or finf(self.max,value)\",\n \"def worst_B(Ag):\\n bottom = 0\\n for i in range(len(Ag)):\\n etop = np.max(cf.TD20[int(Ag[i]) - 1])\\n bottom += etop\\n return bottom\",\n \"def max(self):\\r\\n\\t\\treturn max(self.sample)\",\n \"def max_missed_fraud(prediction, label, amount):\\n fn_vec = (prediction == 0) & (label > 0)\\n fraud_loss_max = np.nan_to_num(amount[fn_vec].max())\\n return fraud_loss_max\",\n \"def max_e_score(self, entity):\\n return float(entity['es_bb'][1])\",\n \"def compute_max_separability_score(self) -> Dict:\\n max_sep_score = {}\\n for class_pair_key, class_pair_val in self.separability_scores.items():\\n max_sep_score[class_pair_key] = max([val for _, val in class_pair_val.items()])\\n max_sep_score['agg_with_risk'] = sum(\\n np.array([val for _, val in max_sep_score.items()]) *\\n RISK\\n ) \\n max_sep_score['agg'] = sum([val for key, val in max_sep_score.items() if type(key)==int]) \\n return max_sep_score\",\n \"def _find_cutoff(self):\\n cutoff = 1\\n while ((self.linear_rstar_unnorm(cutoff) -\\n self.turing_rstar_unnorm(cutoff))**2\\n > self.approx_turing_variance(cutoff)):\\n cutoff += 1\\n return cutoff\",\n \"def find_max_gap(self, free_space_ranges):\\n start = end = 200\\n curr_start = 200\\n #print(free_space_ranges)\\n for i in range(201, 880):\\n if free_space_ranges[i] != 0:\\n if free_space_ranges[i-1] == 0:\\n curr_start = i\\n else:\\n if (i-curr_start) > end-start:\\n start = curr_start\\n end = i\\n return start, end\",\n \"def max_value(self) -> float:\\n return DEFAULT_MAX_VALUE\",\n \"def calculate_FAR_of_thresh(self, threshold, livetime, groundtype):\\n\\t\\t#Find FAR from number of events above a threshold\\n\\t\\tFAR = float(np.sum(self.LLR_above_thresh(threshold=threshold, groundtype=groundtype)))/float(livetime)\\n\\t\\t\\n\\t\\t#If FAR is null, choose FAR to be that of the most extreme background event\\n\\t\\tif FAR == 0.:\\n\\t\\t\\tFAR = 1./float(livetime)\\n\\t\\t\\n\\t\\treturn FAR\",\n \"def _maximum(self) -> float:\\n if self._type == \\\"power\\\":\\n return 5.0\\n elif self._type == \\\"setpoint\\\":\\n return self._product.get_data_config_json()[\\\"_value_setpoint_max\\\"]\\n elif self._type == \\\"fan1\\\":\\n fan = 1\\n return self._product.get_data_config_json()[\\\"_value_fan_limits\\\"][\\n (((fan - 1) * 2) + 1)\\n ]\\n elif self._type == \\\"fan2\\\":\\n fan = 2\\n return self._product.get_data_config_json()[\\\"_value_fan_limits\\\"][\\n (((fan - 1) * 2) + 1)\\n ]\\n elif self._type == \\\"fan3\\\":\\n fan = 3\\n return self._product.get_data_config_json()[\\\"_value_fan_limits\\\"][\\n (((fan - 1) * 2) + 1)\\n ]\",\n \"def score_waypoint(distance):\\n return max(0,\\n float(settings.SATISFIED_WAYPOINT_DIST_MAX_FT - distance) /\\n settings.SATISFIED_WAYPOINT_DIST_MAX_FT)\",\n \"def _get_max_estimated_bandit(self)->Bandit:\\n # print(\\\"mus - \\\", self.mu)\\n # print(\\\"actions - \\\", np.argmax(self.mu))\\n unique, counts = np.unique(self.mu, return_counts=True)\\n lens = counts[np.argmax(unique)] \\n if lens>1: # if two actions have same argmax\\n # then return arbitrarily from those max ones\\n maxs = list(np.array(self.bandits)[self.mu==unique[np.argmax(unique)]])\\n return np.random.choice(maxs)\\n # otherwise return the max one\\n return self.bandits[np.argmax(self.mu)]\",\n \"def getMinAbundanceOfClrSample(self):\\n #try: minimum = min(self.clr_sample['abundance'])-0.001\\n try: minimum = min(self.clr_sample)-0.01\\n except: minimum = 0\\n return minimum\",\n \"def max_grade(self) -> float:\\n return sum(self.test_weights.values())\",\n \"def personal_best(scores):\\n# return sorted(scores, reverse=True)[0]\\n return max(scores)\",\n \"def get_max_praises(self):\\n char = self.caller.char_ob\\n clout = char.social_clout\\n s_rank = char.item_data.social_rank\\n return clout + ((8 - s_rank) // 2)\",\n \"def max_grains(self):\\n index = self._ordered_input_names.index('max_grains')\\n return self._inputs[index]\",\n \"def max_error(self) -> float:\\n return float(np.max(np.abs(self._flattened_errors())))\",\n \"def max(self):\\n\\n maximum = -float('inf')\\n\\n for stack in self:\\n stack_max = stack.max()\\n if stack_max > maximum:\\n maximum = stack_max\\n\\n return maximum\",\n \"def adaptive_limit(self) -> int:\\n return pulumi.get(self, \\\"adaptive_limit\\\")\",\n \"def _calculate_score_with_threshold(self):\\n\\n clue_number = 0\\n positive_score, negative_score = 0, 0\\n negative_number = 0\\n total_score = 0\\n\\n # find largest negative score\\n largest_negative_score = -1.\\n for ix, (card, score) in enumerate(self.sorted_card_score_pairs):\\n # find maximum score of negative word\\n if card.color not in [self.team, \\\"DOUBLE\\\"]:\\n largest_negative_score = score\\n break\\n\\n # add scores higher than threshold + largest negative score to positive_score\\n for card, score in self.sorted_card_score_pairs:\\n if (score > (self.delta+largest_negative_score)\\n and card.color in [self.team, \\\"DOUBLE\\\"]):\\n clue_number += 1\\n positive_score += score\\n elif card.color not in [self.team, \\\"DOUBLE\\\"]:\\n negative_score += score\\n negative_number += 1\\n else:\\n continue\\n\\n if not self.penalize_negative:\\n self.logger.info(\\\"negative score set to 0.\\\")\\n negative_score = 0\\n\\n # if threshold(delta) is large, there will be no clues.\\n # try to give at least one clue\\n # select the positive card with score larger than largest_negative_score.\\n if clue_number == 0:\\n self.logger.debug(\\\"clue number: 0.\\\")\\n for card, score in self.sorted_card_score_pairs:\\n if card.color in [self.team, \\\"DOUBLE\\\"]:\\n positive_score = score\\n clue_number += 1\\n self.cropped_threshold = score - largest_negative_score\\n else:\\n positive_score = 0\\n break\\n\\n if self.normalize_negative:\\n total_score = (1-self.alpha) * positive_score - self.alpha * negative_score / negative_number\\n else:\\n total_score = (1-self.alpha) * positive_score - self.alpha * negative_score\\n self.logger.debug(\\\"word: {}, positive_score: {}, negative_score: {}, total_score: {}\\\".format(self.clue, positive_score, negative_score, total_score))\\n return total_score, clue_number\",\n \"def find_best_threshold(y, y_hat, step_size, score_func, maximize=True):\\n best_thres, best_score = 0.0, 0.0 if maximize else 1.0\\n for thres in np.arange(0, 1, step_size):\\n score = score_for_threshold(y, y_hat, score_func, thres)\\n if (maximize and (score > best_score)) or (not maximize and (score < best_score)):\\n best_score = score\\n best_thres = thres\\n\\n return best_thres, best_score\",\n \"def max_abs_error(self) -> float:\\n return np.max(np.abs([self.error]))\",\n \"def max_findings_per_request(self) -> float:\\n return pulumi.get(self, \\\"max_findings_per_request\\\")\",\n \"def image_gc_high_threshold(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"image_gc_high_threshold\\\")\",\n \"def get_fitness(self):\\n score = self.score - (abs(self.distance_to_pipe()[0])) * 0.3\\n score = self.score + 1.5 * 1e-3 * self.birth_time - (abs(self.distance_to_pipe()[0])) * 0.001\\n score = self.birth_time * 3 - \\\\\\n (abs(Bird.lower_pipes[self.get_next_pipe_index()]['y'] - PIPE_GAP_SIZE // 2 - self.pos_y)) * 0.5\\n pipe_width = IMAGES['pipe'][0].get_width()\\n\\n constants.debug_circle = Bird.lower_pipes[self.get_next_pipe_index()]['x'] + pipe_width // 1.2, \\\\\\n Bird.lower_pipes[\\n self.get_next_pipe_index()]['y'] - PIPE_GAP_SIZE // 10\\n constants.debug_circle = tuple(map(int, constants.debug_circle))\\n # score *= 1e-1\\n # score = self.score\\n # if self.score > 1:\\n # print(score)\\n\\n score = self.birth_time * 3 - abs(constants.debug_circle[1] - self.pos_y) + 5 * self.score\\n return score\",\n \"def maximum_score(self):\\n max_score = self.values('question').annotate(\\n top_answer=Max('score')\\n )\\n max_score = sum(d['top_answer'] for d in max_score)\\n return max_score\",\n \"def native_max_value(self) -> float:\\n return 9\",\n \"def sharpness_penalty(self):\\n # This polynomial function gives the gain for peaking filter which achieves 18 dB / octave max derivative\\n # The polynomial estimate is accurate in the vicinity of 18 dB / octave\\n gain_limit = -0.09503189270199464 + 20.575128011847003 * (1 / self.q)\\n # Scaled sigmoid function as penalty coefficient\\n x = self.gain / gain_limit - 1\\n sharpness_penalty_coefficient = 1 / (1 + np.e ** (-x * 100))\\n return np.mean(np.square(self.fr * sharpness_penalty_coefficient))\",\n \"def get_highscore(self, score):\\n scores = list(self.history_score.values())\\n \\n # Compare current score with the last placing in leaderboard.\\n if score > max(scores):\\n return 0\\n else:\\n if score < min(scores):\\n return 2\\n else:\\n return 1\",\n \"def find_B(self):\\n max_lb = 0\\n for arc in self.arcs():\\n lb = self.arc_info[arc[0]]['lower_bound']\\n max_lb = max(max_lb, lb)\\n n = len(self)\\n m = len(list(self.edges()))\\n return((m - n + 2)*max_lb)\",\n \"def worst(self) -> float:\\n return float(self.tsdf.pct_change().min())\",\n \"def threshold(self) -> Optional[pulumi.Input[float]]:\\n return pulumi.get(self, \\\"threshold\\\")\",\n \"def threshold(self) -> Optional[pulumi.Input[float]]:\\n return pulumi.get(self, \\\"threshold\\\")\",\n \"def threshold(self) -> Optional[pulumi.Input[float]]:\\n return pulumi.get(self, \\\"threshold\\\")\",\n \"def _get_maximum(self):\\n return self._maximum\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65937996","0.6442271","0.6323267","0.6321066","0.62130624","0.6183801","0.6155798","0.6139358","0.61088455","0.60916436","0.60519683","0.6035053","0.6027988","0.5917933","0.59149694","0.5904565","0.5880489","0.5870277","0.586847","0.58620393","0.5844067","0.5830287","0.5808132","0.5805611","0.5786597","0.57627624","0.57370716","0.57263833","0.5723162","0.5719528","0.571849","0.5710636","0.5679729","0.56578356","0.56527436","0.56458807","0.5628634","0.56279993","0.5617198","0.5603878","0.55926317","0.55799085","0.55682135","0.556513","0.5560378","0.55578595","0.5545083","0.5543277","0.55424494","0.5539525","0.5539509","0.5537446","0.5534487","0.5533918","0.55275786","0.55214775","0.5519556","0.5509479","0.54997146","0.5485039","0.5483417","0.54824454","0.5478786","0.5468453","0.54663354","0.5465508","0.54638726","0.5462148","0.54534185","0.5451684","0.5434569","0.54270536","0.54262173","0.5425189","0.54197073","0.54195714","0.5419186","0.5406368","0.5401141","0.54008704","0.5397096","0.5386047","0.53843653","0.5379132","0.5375137","0.5372821","0.53691757","0.5368971","0.5367286","0.53628206","0.5361407","0.53590584","0.53569317","0.53523403","0.53494817","0.5349475","0.53452116","0.53452116","0.53452116","0.53380287"],"string":"[\n \"0.65937996\",\n \"0.6442271\",\n \"0.6323267\",\n \"0.6321066\",\n \"0.62130624\",\n \"0.6183801\",\n \"0.6155798\",\n \"0.6139358\",\n \"0.61088455\",\n \"0.60916436\",\n \"0.60519683\",\n \"0.6035053\",\n \"0.6027988\",\n \"0.5917933\",\n \"0.59149694\",\n \"0.5904565\",\n \"0.5880489\",\n \"0.5870277\",\n \"0.586847\",\n \"0.58620393\",\n \"0.5844067\",\n \"0.5830287\",\n \"0.5808132\",\n \"0.5805611\",\n \"0.5786597\",\n \"0.57627624\",\n \"0.57370716\",\n \"0.57263833\",\n \"0.5723162\",\n \"0.5719528\",\n \"0.571849\",\n \"0.5710636\",\n \"0.5679729\",\n \"0.56578356\",\n \"0.56527436\",\n \"0.56458807\",\n \"0.5628634\",\n \"0.56279993\",\n \"0.5617198\",\n \"0.5603878\",\n \"0.55926317\",\n \"0.55799085\",\n \"0.55682135\",\n \"0.556513\",\n \"0.5560378\",\n \"0.55578595\",\n \"0.5545083\",\n \"0.5543277\",\n \"0.55424494\",\n \"0.5539525\",\n \"0.5539509\",\n \"0.5537446\",\n \"0.5534487\",\n \"0.5533918\",\n \"0.55275786\",\n \"0.55214775\",\n \"0.5519556\",\n \"0.5509479\",\n \"0.54997146\",\n \"0.5485039\",\n \"0.5483417\",\n \"0.54824454\",\n \"0.5478786\",\n \"0.5468453\",\n \"0.54663354\",\n \"0.5465508\",\n \"0.54638726\",\n \"0.5462148\",\n \"0.54534185\",\n \"0.5451684\",\n \"0.5434569\",\n \"0.54270536\",\n \"0.54262173\",\n \"0.5425189\",\n \"0.54197073\",\n \"0.54195714\",\n \"0.5419186\",\n \"0.5406368\",\n \"0.5401141\",\n \"0.54008704\",\n \"0.5397096\",\n \"0.5386047\",\n \"0.53843653\",\n \"0.5379132\",\n \"0.5375137\",\n \"0.5372821\",\n \"0.53691757\",\n \"0.5368971\",\n \"0.5367286\",\n \"0.53628206\",\n \"0.5361407\",\n \"0.53590584\",\n \"0.53569317\",\n \"0.53523403\",\n \"0.53494817\",\n \"0.5349475\",\n \"0.53452116\",\n \"0.53452116\",\n \"0.53452116\",\n \"0.53380287\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6311884"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":14693,"cells":{"query":{"kind":"string","value":"runs a community detection algorithm on graph and returns a coloring of the nodes based on the found communities"},"document":{"kind":"string","value":"def node_community_colors(graph, communities):\n colors = nx_helpers.generate_colors(len(communities))\n\n def which_color(node):\n \"\"\"finds which community node is in and returns\n its corresponding color\n \"\"\"\n for i, com in enumerate(communities):\n if node in com:\n return colors[i]\n return nx_helpers.rgb_to_hex((0, 0, 0))\n\n node_colors = [which_color(node) for node in graph.nodes()]\n return node_colors"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def community_detection(net_G):\r\n if list(nx.isolates(net_G)) == []:\r\n part = community.best_partition(net_G)\r\n #values = [part.get(node) for node in net_G.nodes()]\r\n #nx.draw_spring(net_G, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=False)\r\n #plt.show()\r\n else:\r\n net_G = net_G.copy()\r\n net_G.remove_nodes_from(list(nx.isolates(net_G)))\r\n part = community.best_partition(net_G)\r\n list_nodes = []\r\n for com in set(part.values()):\r\n list_nodes.append([nodes for nodes in part.keys() if part[nodes] == com])\r\n num_of_communities = len(list_nodes)\r\n partition_performance = nx.algorithms.community.quality.performance(net_G, list_nodes)\r\n net_communities = [[\"Numbers of communities:\", num_of_communities], \\\r\n [\"Partition performance:\", partition_performance]]\r\n return net_communities","def _community_detection(self, kg: KG) -> None:\n nx_graph = nx.Graph()\n\n for vertex in kg._vertices:\n if not vertex.predicate:\n nx_graph.add_node(str(vertex), vertex=vertex)\n\n for vertex in kg._vertices:\n if not vertex.predicate:\n # Neighbors are predicates\n for pred in kg.get_neighbors(vertex):\n for obj in kg.get_neighbors(pred):\n nx_graph.add_edge(\n str(vertex), str(obj), name=str(pred)\n )\n\n # Create a dictionary that maps the URI on a community\n partition = community.best_partition(\n nx_graph, resolution=self.resolution\n )\n self.labels_per_community = defaultdict(list)\n\n self.communities = {}\n vertices = nx.get_node_attributes(nx_graph, \"vertex\")\n for node in partition:\n if node in vertices:\n self.communities[vertices[node]] = partition[node]\n\n for node in self.communities:\n self.labels_per_community[self.communities[node]].append(node)","def create_network(self, community_detection, wt_steps, n_clust, network_from, neighbors, top):\n \n if network_from == 'top_n':\n sort_by_scores = []\n\n for pair, score in scores_update.items():\n sort_by_scores.append([pair[0], pair[1], score[2]])\n top_n = sorted(sort_by_scores, reverse=False, key=lambda x: x[2])[:top]\n\n # Convert from distance to similarity for edge\n for score in top_n: \n c = 1/(1 + score[2])\n score[2] = c\n\n flat = [tuple(pair) for pair in top_n]\n\n elif network_from == 'knn': \n flat = []\n projection_knn = nearest_neighbors(neighbors=neighbors)\n\n for projection, knn in projection_knn.items():\n for n in knn:\n flat.append((projection, n[0], abs(n[3]))) # p1, p2, score\n\n clusters = {}\n g = Graph.TupleList(flat, weights=True)\n\n if community_detection == 'walktrap':\n try:\n wt = Graph.community_walktrap(g, weights='weight', steps=wt_steps)\n cluster_dendrogram = wt.as_clustering(n_clust)\n except:\n self.show_cluster_fail()\n elif community_detection == 'betweenness':\n try:\n ebs = Graph.community_edge_betweenness(g, weights='weight', directed=True)\n cluster_dendrogram = ebs.as_clustering(n_clust)\n except:\n self.show_cluster_fail()\n\n for community, projection in enumerate(cluster_dendrogram.subgraphs()):\n clusters[community] = projection.vs['name']\n\n #convert node IDs back to ints\n for cluster, nodes in clusters.items():\n clusters[cluster] = sorted([int(node) for node in nodes])\n \n remove_outliers(clusters)\n\n clustered = []\n for cluster, nodes in clusters.items():\n for n in nodes:\n clustered.append(n)\n\n clusters['singles'] = [] # Add singles to clusters if not in top n scores\n clusters['removed'] = []\n \n for node in projection_2D:\n if node not in clustered and node not in drop:\n clusters['singles'].append(node)\n elif node in drop:\n clusters['removed'].append(node)\n \n G = nx.Graph()\n\n for pair in flat:\n G.add_edge(int(pair[0]), int(pair[1]), weight=pair[2])\n\n #if you want to see directionality in the networkx plot\n #G = nx.MultiDiGraph(G)\n\n #adds singles if not in top n scores\n for node_key in projection_2D:\n if node_key not in G.nodes:\n G.add_node(node_key)\n\n return flat, clusters, G","def detection_algorithm(G, edge_weight):\n Gc = G.copy()\n set_node_attributes(Gc, attr_name='k-index')\n seed_node2communities = {}\n\n from operator import itemgetter\n while Gc.number_of_nodes() > 0:\n seed_node = max(list(Gc.nodes(data='k-index')), key=itemgetter(1))[0]\n nodes_in_community, modularity = find_local_community(Gc, seed_node=seed_node, weight=edge_weight)\n seed_node2communities[seed_node] = (nodes_in_community, modularity)\n Gc.remove_nodes_from(nodes_in_community)\n return seed_node2communities","def greedy_coloring(*args):\r\n # get arguments\r\n G = args[0]\r\n n = G.nodes()\r\n m = G.arcs()\r\n \r\n # check if it a valid Graph\r\n if not G.is_correct_type('u'):\r\n print \"ERROR: the graph is not in one of the valid formats for greedy_coloring()\"\r\n return [], []\r\n \r\n # calculate degrees of each node (set as rows per node)\r\n a_nodes = zeros((n,n), int)\r\n for arc in range(m):\r\n i = G.A[arc,0] # tail of the arc\r\n j = G.A[arc,1] # head of the arc\r\n a_nodes[i-1,j-1] = 1\r\n a_nodes[j-1,i-1] = 1\r\n # get degree and add the node number\r\n degree = sum(a_nodes,0)\r\n degree = vstack((degree, array(range(n), int) + 1))\r\n \r\n # initialize coloring vector\r\n coloring = zeros(n, int)\r\n color_step = 1\r\n \r\n # if there are any nodes of degree 0 color them first\r\n while min(degree[0,:]) == 0:\r\n n_i = argmin(degree[0,:]) # get node with zero\r\n i = degree[1,n_i]\r\n # eliminate the node column from the list and matrix\r\n degree = delete(degree, s_[n_i], axis=1)\r\n a_nodes = delete(a_nodes, s_[n_i], axis=1)\r\n # color it\r\n coloring[i-1] = color_step\r\n \r\n # iterate till all nodes have a color\r\n while size(degree) > 0:\r\n n_i = argmax(degree[0,:]) # get node with largest degree\r\n i = degree[1,n_i]\r\n # eliminate the node column from the list and matrix\r\n degree = delete(degree, s_[n_i], axis=1)\r\n a_nodes = delete(a_nodes, s_[n_i], axis=1)\r\n \r\n # color it\r\n coloring[i-1] = color_step\r\n \r\n # color the rest of the possible nodes\r\n possible = 1 - array(a_nodes[i-1,:]) # transforms 0 in 1, and 1 in 0\r\n # iterate while there are possible nodes available\r\n while sum(possible) > 0:\r\n # get the node with largest degree among possible ones\r\n n_j = argmax(degree[0,:] * possible)\r\n j = degree[1,n_j]\r\n # eliminate the node column from the list and matrix\r\n degree = delete(degree, s_[n_j], axis=1)\r\n a_nodes = delete(a_nodes, s_[n_j], axis=1)\r\n possible = delete(possible, n_j)\r\n \r\n # color it\r\n coloring[j-1] = color_step\r\n # eliminate adjacent nodes of j from possible nodes\r\n possible = possible * (1 - a_nodes[j-1,:])\r\n \r\n # update color\r\n color_step += 1\r\n \r\n col_number = max(coloring) # approx chromatic number\r\n \r\n return coloring, col_number","def find_local_community(G, seed_node, weight, debug_log=False):\n nodes_in_community = seed_node if isinstance(seed_node, list) else [seed_node]\n modularity = edge_modularity(G, nodes_in_community=nodes_in_community, weight=weight)\n neighbor_edges = get_neighbor_edges(G, nodes_in_community=nodes_in_community)\n if debug_log:\n print('==========\\nInitial community has nodes:', nodes_in_community)\n print('Neighbor edges:', neighbor_edges)\n print('Modularity = %f' % modularity)\n while neighbor_edges:\n # Compute the edge_modularity for each neighbor edge,\n # suppose the neighbor edge is added to the community\n mod_max, c_max, e_max = 0, None, None\n for e in neighbor_edges:\n # edges in the current community\n edges_in_temp_community = list(G.subgraph(nodes_in_community).edges)\n # append the candidate edge\n edges_in_temp_community.append(e)\n nodes_in_temp_community = list(G.edge_subgraph(edges_in_temp_community).nodes)\n mod_temp = edge_modularity(G, nodes_in_community=nodes_in_temp_community, weight=weight)\n if mod_temp > mod_max:\n mod_max, c_max, e_max = mod_temp, nodes_in_temp_community, e\n if mod_max > modularity:\n if debug_log:\n print('==========\\nEdge', e_max, 'and node', set(e_max).difference(nodes_in_community), 'are added to the community')\n\n # Update the community and the corresponding neighbor edges\n nodes_in_community = c_max\n modularity = mod_max\n neighbor_edges = get_neighbor_edges(G, nodes_in_community=nodes_in_community)\n\n if debug_log:\n print('The community has nodes:', nodes_in_community)\n print('Modularity = %f' % mod_max)\n print('Neighbor edges:', neighbor_edges)\n else:\n break\n return nodes_in_community, modularity","def communityGraph(graph):\n\n lapgr = nx.laplacian_matrix(graph)\n\n # Get the eigenvalues and eigenvectors of the Laplacian matrix\n evals, evec = np.linalg.eigh(lapgr.todense())\n\n fiedler = evec[1]\n results = []\n ## \"Fiedler\", fiedler\n median = np.median(fiedler, axis=1) # median of the second eigenvalue\n for i in range(0, fiedler.size): # divide the graph nodes into two\n if(fiedler[0, i] < median):\n results.append(0)\n else:\n results.append(1)\n return results, evals, evec","def _generate_graph(self) -> None:\n self.g_ = nx.random_partition_graph(list(self._community_sizes),\n p_in=self.community_p_in,\n p_out=self.community_p_out,\n seed=self.seed)\n\n for _, nv in self.g_.nodes.data():\n nv[\"infected\"] = 0\n nv[\"immune\"] = False\n nv[\"alive\"] = True\n nv[\"_edges\"] = []\n nv[\"isolated\"] = False\n nv[\"mask\"] = 0.0","def assign_communities(graph):\n communities = nx.algorithms.community\\\n .greedy_modularity_communities(nx.Graph(graph))\n for node in graph.nodes:\n graph.nodes[node]['community'] = [i for i,c in enumerate(communities)\n if node in c][0]\n graph.graph['modularity'] = nx.algorithms.community.quality\\\n .modularity(nx.Graph(graph),\n communities)","def which_color(node):\n for i, com in enumerate(communities):\n if node in com:\n return colors[i]\n return nx_helpers.rgb_to_hex((0, 0, 0))","def neato_graph_from_corpus( corpus, max_nodes ) :\n\n O, row_dois, column_dois = cites_matrix( corpus )\n neato_cooccurrence_graph( O, column_dois )\n return None\n\n \n v = total_occurrences( O ) \n nv = v.astype( float32 ) / v.max()\n C = cooccurrence_matrix ( O )\n nC = normalized_cooccurrence_matrix( O )\n\n # now find our cutoff!\n # find the max number of cocites and start there\n cocite_cutoff = C.max()\n num_nodes = nodes_from_c( C[C >= cocite_cutoff] )\n # then reduce the number until we exceed max_nodes\n while num_nodes < max_nodes :\n cocite_cutoff = cocite_cutoff - 1\n num_nodes = nodes_from_c( C[C >= cocite_cutoff] )\n\n if num_nodes > max_nodes :\n cocite_cutoff = cocite_cutoff + 1\n \n C = C.copy()\n C[ C < cocite_cutoff ]= 0\n\n graph = pydot.Dot( graph_type = 'graph' )\n graph.set_overlap(\"false\")\n coords = zip(*(C >= cocite_cutoff).nonzero())\n\n # make a dict of all nodes which are mentioned in the coords\n nodes = {}\n index = 1\n for coord in set(chain.from_iterable(coords)) :\n if not nodes.has_key( coord ) :\n node = pydot.Node( str(coord) )\n if v != None :\n doi = column_dois[coord]\n node.set_label( str(index) )\n node.set_penwidth( nv[ coord ] )\n node.set_fixedsize(\"true\")\n node.set_width( 1.0 *nv[ coord ] )\n #node.set_shape(\"circle\")\n nodes[ coord ] = node\n graph.add_node( node )\n index = index + 1\n\n for coord in coords :\n \n edge = pydot.Edge( nodes[coord[0]], nodes[coord[1]] )\n edge.set_weight( nC[coord] )\n edge.set_penwidth( nC[coord]*5 )\n #edge.set_label( str(int(m[coord]) ))\n graph.add_edge(edge)\n\n \n legend = pydot.Node( \"legend\" )\n nodelist = nodes.items()\n nodelist.sort( lambda a,b : cmp(node_index(a[1].get_label()),node_index(b[1].get_label())) )\n legend.set_label( \"\\l\".join([x[1].get_label()+\":\"+column_dois[x[0]] for x in nodelist])+\"\\l\" )\n legend.set_shape(\"box\")\n graph.add_node(legend)\n\n print graph.to_string()\n #graph.write_dot('test.dot', prog='neato' )\n #graph.write_png('test.png', prog='neato' )\n #graph.write_pdf('test.pdf', prog='neato' )","def cluster_connectivity(G, weight='weight'):\n\t# 1) indexing the edges by community\n\tsum_edges_dic = { com : {} for com in range(G.nb_communities)}\n\tfor node1, node2 in G.edges():\n\t\tcomm1 = G.nodes[node1]['community']\n\t\tcomm2 = G.nodes[node2]['community']\n\t\tif comm2 not in sum_edges_dic[comm1]:\n\t\t\tsum_edges_dic[comm1][comm2] = 0\n\t\t\tsum_edges_dic[comm2][comm1] = 0\n\t\telse:\n\t\t\tif weight is None:\n\t\t\t\tsum_edges_dic[comm1][comm2] += 1\n\t\t\t\tsum_edges_dic[comm2][comm1] += 1\n\t\t\telse:\t\n\t\t\t\tsum_edges_dic[comm1][comm2] += G.edges[node1, node2][weight]\n\t\t\t\tsum_edges_dic[comm2][comm1] += G.edges[node1, node2][weight]\n\tc_connectivity = {}\n\t# 2) computing the connectivity\n\tfor com in sum_edges_dic:\n\t\tin_out_edges = sum(sum_edges_dic[com].values())\n\t\tc_connectivity[com] = round(- np.log2(sum_edges_dic[com][com] / in_out_edges),3) \n\treturn c_connectivity","def detect_community(network_path, network_name, output_path):\n net = network.network()\n net.from_file(network_path)\n output_prefix = output_path + '/{}_recursive_Louvain_{}_{}'.format(network_name, len(net.nodes), len(net.edges))\n logging.info('{} network: {} nodes and {} edges were loaded.'.format(network_name, len(net.nodes), len(net.edges)))\n if os.path.isfile(output_prefix + '.gmt'):\n logging.info('Communities have been detected.')\n else:\n rl = RecursiveLouvain()\n rl.fit(net)\n comms = rl.community\n hierarchy = rl.hierarchy\n os.makedirs(output_path, exist_ok=True)\n commToGmt(comms, output_prefix)\n output_hierarchy(hierarchy, output_prefix)\n logging.info('{} communities were detected.'.format(len(comms)))\n logging.info('Community file was saved as {}.gmt'.format(output_prefix))\n return '{}.gmt'.format(output_prefix)","def find_and_print_network_communities(G, code_dict=None):\n\n comm_dict = partition(G)\n\n comm_members = {}\n for comm in set(comm_dict.values()):\n countries = [node for node in comm_dict if comm_dict[node] == comm]\n if code_dict is not None:\n countries = [code_dict[code] for code in countries]\n\n comm_members[comm] = countries\n\n return comm_members, get_modularity(G, comm_dict)","def run_connected_components(img, viz=False):\n\n fg = img.foreground_mask(cfg.COLOR_TOL, ignore_black=True)\n if viz:\n cv2.imwrite(\"debug_imgs/mask.png\", fg.data)\n\n groups = get_cluster_info(fg)\n\n if viz:\n display_grasps(img, groups)\n\n return groups","def network_topology(voxels, clusters, primaries, edges, mode='sphere'):\n # Define the arrays of node positions (barycenter of voxels in the cluster)\n pos = np.array([voxels[c].cpu().numpy().mean(0) for c in clusters])\n\n # Define the node features (label, color)\n n = len(clusters)\n node_labels = ['%d (%0.1f, %0.1f, %0.1f)' % (i, pos[i,0], pos[i,1], pos[i,2]) for i in range(n)]\n \n node_colors = ['#ff7f0e' if i in primaries else '#1f77b4' for i in range(n)]\n\n # Define the nodes and their connections\n graph_data = []\n edge_vertices = []\n if mode == 'sphere':\n # Define the node size\n logn = np.array([np.log(len(c)) for c in clusters])\n node_sizes = np.interp(logn, (logn.min(), logn.max()), (5, 50))\n \n # Define the nodes as sphere of radius proportional to the log of the cluster voxel content\n graph_data.append(go.Scatter3d(x = pos[:,0], y = pos[:,1], z = pos[:,2],\n name = 'clusters',\n mode = 'markers',\n marker = dict(\n symbol = 'circle',\n size = node_sizes,\n color = node_colors,\n colorscale = 'Viridis',\n line = dict(color='rgb(50,50,50)', width=0.5)\n ),\n text = node_labels,\n hoverinfo = 'text'\n ))\n\n # Define the edges center to center\n edge_vertices = np.concatenate([[pos[i], pos[j], [None, None, None]] for i, j in zip(edges[0], edges[1])])\n\n elif mode == 'hull':\n # For each cluster, add the convex hull of all its voxels\n graph_data += [go.Mesh3d(alphahull =10.0,\n name = '',\n x = voxels[c][:,0],\n y = voxels[c][:,1],\n z = voxels[c][:,2],\n color = node_colors[i],\n opacity = 0.3,\n text = node_labels[i],\n hoverinfo = 'text'\n ) for i, c in enumerate(clusters)]\n\n # Define the edges closest pixel to closest pixel\n import scipy as sp\n edge_vertices = []\n for i, j in zip(edges[0], edges[1]):\n vi, vj = voxels[clusters[i]], voxels[clusters[j]]\n d12 = sp.spatial.distance.cdist(vi, vj, 'euclidean')\n i1, i2 = np.unravel_index(np.argmin(d12), d12.shape)\n edge_vertices.append([vi[i1].cpu().numpy(), vj[i2].cpu().numpy(), [None, None, None]])\n \n edge_vertices = np.concatenate(edge_vertices)\n \n else:\n raise ValueError\n \n # Initialize a graph that contains the edges\n graph_data.append(go.Scatter3d(x = edge_vertices[:,0], y = edge_vertices[:,1], z = edge_vertices[:,2],\n mode = 'lines',\n name = 'edges',\n line = dict(\n color = 'rgba(50, 50, 50, 0.5)',\n width = 1\n ),\n hoverinfo = 'none'\n ))\n\n # Return\n return graph_data","def make_graph(imageAnnotated, imageGaussian):\n nodeNumber = imageAnnotated.max() - 1\n distanceDiagonalPixels, distanceDiagonalPixelsCubic = np.sqrt(2.0), np.sqrt(3.0)\n distanceMatrix = np.array([[distanceDiagonalPixelsCubic, distanceDiagonalPixels, distanceDiagonalPixelsCubic], [distanceDiagonalPixels, 1, distanceDiagonalPixels],\n [distanceDiagonalPixelsCubic, distanceDiagonalPixels, distanceDiagonalPixelsCubic]])\n nodePositions = np.transpose(np.where(imageAnnotated > 1))[:, ::-1]\n imagePropagatedNodes = imageAnnotated.copy()\n imageFilamentLength = 1.0 * (imageAnnotated.copy() > 0)\n imageFilamentIntensity = 1.0 * (imageAnnotated.copy() > 0)\n dimensionY, dimensionX = imageAnnotated.shape\n filament = (imagePropagatedNodes == 1).sum()\n while (filament > 0):\n nodePixel = np.transpose(np.where(imagePropagatedNodes > 1))\n for posY, posX in nodePixel:\n xMin, xMax, yMin, yMax = bounds(posX - 1, 0, dimensionX), bounds(posX + 2, 0, dimensionX), bounds(posY - 1, 0, dimensionY), bounds(posY + 2, 0, dimensionY)\n nodeNeighborhood = imagePropagatedNodes[yMin:yMax, xMin:xMax]\n nodeFilamentLength = imageFilamentLength[yMin:yMax, xMin:xMax]\n nodeFilamentIntensity = imageFilamentIntensity[yMin:yMax, xMin:xMax]\n imagePropagatedNodes[yMin:yMax, xMin:xMax] = np.where(nodeNeighborhood == 1, imagePropagatedNodes[posY, posX], nodeNeighborhood)\n imageFilamentLength[yMin:yMax, xMin:xMax] = np.where(nodeFilamentLength == 1, distanceMatrix[0:yMax - yMin, 0:xMax - xMin] + imageFilamentLength[posY, posX], nodeFilamentLength)\n imageFilamentIntensity[yMin:yMax, xMin:xMax] = np.where(nodeFilamentIntensity == 1, imageGaussian[posY, posX] + imageFilamentIntensity[posY, posX], nodeFilamentIntensity)\n filament = (imagePropagatedNodes == 1).sum()\n graph = nx.empty_graph(nodeNumber, nx.MultiGraph())\n filamentY, filamentX = np.where(imagePropagatedNodes > 1)\n for posY, posX in zip(filamentY, filamentX):\n nodeIndex = imagePropagatedNodes[posY, posX]\n xMin, xMax, yMin, yMax = bounds(posX - 1, 0, dimensionX), bounds(posX + 2, 0, dimensionX), bounds(posY - 1, 0, dimensionY), bounds(posY + 2, 0, dimensionY)\n filamentNeighborhood = imagePropagatedNodes[yMin:yMax, xMin:xMax].flatten()\n filamentLength = imageFilamentLength[yMin:yMax, xMin:xMax].flatten()\n filamentIntensity = imageFilamentIntensity[yMin:yMax, xMin:xMax].flatten()\n for index, pixel in enumerate(filamentNeighborhood):\n if (pixel != nodeIndex and pixel > 1):\n node1, node2 = np.sort([nodeIndex - 2, pixel - 2])\n nodeDistance = sp.linalg.norm(nodePositions[node1] - nodePositions[node2])\n filamentLengthSum = imageFilamentLength[posY, posX] + filamentLength[index]\n filamentIntensitySum = imageFilamentIntensity[posY, posX] + filamentIntensity[index]\n minimumEdgeWeight = max(1e-9, filamentIntensitySum)\n edgeCapacity = 1.0 * minimumEdgeWeight / filamentLengthSum\n edgeLength = 1.0 * filamentLengthSum / minimumEdgeWeight\n edgeConnectivity = 0\n edgeJump = 0\n graph.add_edge(node1, node2, edist=nodeDistance, fdist=filamentLengthSum, weight=minimumEdgeWeight, capa=edgeCapacity, lgth=edgeLength, conn=edgeConnectivity, jump=edgeJump)\n return(graph, nodePositions)","def run(self, infected_graph):\n pos = nx.spring_layout(infected_graph)\n points = np.zeros((len(pos), 2))\n i = 0\n for p in pos:\n points[i] = pos[p]\n i += 1\n \n hull = ConvexHull(points)\n nodes = list(pos)\n return [nodes[p] for p in hull.vertices]","def find_communities(graph):\n visited = set()\n communities = []\n for node in graph:\n if node not in visited:\n community = _find_community(node, graph, visited)\n communities.append(community)\n\n return communities","def cfdProcessNodeTopology(self):\r\n self.nodeElements = self.cfdInvertConnectivity(self.elementNodes)\r\n self.nodeFaces = self.cfdInvertConnectivity(self.faceNodes)","def create_graph(self):\n robot_pix = int(math.ceil(self.robot.size / self.resolution))\n ii = 0\n jj = 0\n for i in range(0, self.height, robot_pix):\n jj = 0\n for j in range(0, self.width, robot_pix):\n block = self.occ_grid[i:i+robot_pix, j:j+robot_pix].flatten()\n avg = np.mean(block)\n robot_block = self.tesselation_image[i:i+robot_pix, j:j+robot_pix].flatten()\n n_occur = np.bincount(robot_block)\n block_id = np.argmax(n_occur)\n \n p = Pose()\n p.position.x = self.resolution * j + self.resolution / 2.0 + self.origin.position.x\n p.position.y = self.height * self.resolution - (self.resolution * i + self.resolution / 2.0) + self.origin.position.y\n node = Node(ii, jj, p)\n idx = np.where(block > 20)\n if block_id == self.robot.robot_id:\n if 0 <= avg <= 20:\n print(\"Node in path\", node)\n node.valid = True\n else:\n node.valid = False\n elif block_id == 0:\n node.valid = False\n else:\n node.belongs = False\n self.nodes[ii,jj] = node\n jj += 1\n ii += 1\n\n\n height, width = self.nodes.shape\n print(\"Node shape: \", self.nodes.shape)\n for i in range(height):\n for j in range(width):\n min_i = max(0, i-1)\n max_i = min(height - 1, i+1) + 1\n min_j = max(0, j-1)\n max_j = min(width - 1, j+1) + 1\n\n node = self.nodes[i,j]\n neighbors = self.nodes[min_i:max_i, min_j:max_j].flatten()\n for n in neighbors:\n if not n or not node:\n print(\"None %d-%d\"%(i,j))\n continue\n if n != node:\n if n.valid:\n print(\"Neighbor appended\")\n self.nodes[i,j].neighbors.append(n)\n else:\n self.nodes[i,j].obstacle_neighbors.append(n)\n print(\"Graph is created!\")","def GraphToCommunities(Network):\n comm=community.best_partition(Network)\n clusters={}\n for k in comm.keys():\n if clusters.has_key(comm[k])==False:\n clusters[comm[k]]=[]\n clusters[comm[k]].append(k)\n return (clusters)","def brute_force_coloring(*args):\r\n # get arguments\r\n G = args[0]\r\n n = G.nodes()\r\n m = G.arcs()\r\n \r\n # check if it a valid Graph\r\n if not G.is_correct_type('u'):\r\n print \"ERROR: the graph is not in one of the valid formats for brute_force_coloring()\"\r\n return [], []\r\n \r\n coloring = ones(n, int) # initialize with just one color\r\n chrom_n = inf # initialize chromatic number\r\n min_coloring = [] # initialize minimum coloring\r\n \r\n # iterate till you get a coloring (really stupid way)\r\n terminal = array(range(n), int) + 1\r\n while sum(coloring != terminal) > 0:\r\n #print coloring\r\n coloring[n-1] += 1\r\n # correct if some achieve n\r\n for node in range(n-1):\r\n # if one get above n\r\n if coloring[n-1-node] > max(coloring[0:n-1-node]) + 1:\r\n coloring[n-1-node] = 1 # take one and...\r\n coloring[n-2-node] += 1 # ... add it to the previous one\r\n \r\n # if it is a coloring check it\r\n if G.is_coloring(coloring):\r\n col_number = max(coloring) # number of colors\r\n # if it is better, update\r\n if col_number < chrom_n:\r\n chrom_n = col_number\r\n min_coloring = coloring.copy()\r\n print \"current minimum: \", min_coloring, \"with %d colors\" %(chrom_n)\r\n \r\n return min_coloring, chrom_n","def node_condense(imageNodes, imageGrayscale, ones):\n imageLabeled, labels = sp.ndimage.label(imageNodes, structure=ones)\n sizes = sp.ndimage.sum(imageLabeled > 0, imageLabeled, range(1, labels + 1))\n centerOfMass = sp.ndimage.center_of_mass(imageGrayscale, imageLabeled, range(1, labels + 1))\n for label in range(labels):\n if (sizes[label] > 1):\n idx = (imageLabeled == label + 1)\n idm = tuple(np.add(centerOfMass[label], 0.5).astype('int'))\n imageLabeled[idx] = 0\n imageLabeled[idm] = label + 1\n imageLabeledNodes, _ = sp.ndimage.label(imageLabeled > 0, structure=ones)\n imageLabeledNodes = imageLabeledNodes.astype('int')\n return(imageLabeledNodes)","def _connect_components_analysis(image):\n if len(image.shape) == 3:\n gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n else:\n gray_image = image\n\n return cv2.connectedComponentsWithStats(gray_image, connectivity=8, ltype=cv2.CV_32S)","def _find_community(root, graph, visited):\n community = [root]\n visited.add(root)\n next_queue = [root]\n while next_queue:\n node = next_queue.pop(0)\n for child in graph[node]:\n if child not in visited:\n next_queue.append(child)\n community.append(child)\n visited.add(child)\n\n return community","def neato_cooccurrence_graph( nC, v, labels, max_nodes = 10, fnam_stem = \"test\", label_nodes_directly = False, scale=1.0, min_node_size = 0.1 ):\n \n nv = v.astype( float32 ) / v.max()\n\n cutoff = cooccur_cutoff( nC, max_nodes );\n\n graph = pydot.Dot( graph_type = 'graph' )\n graph.set_overlap(\"false\")\n coords = zip(*(nC >= cutoff).nonzero())\n\n # make a dict of all nodes which are mentioned in the coords\n nodes = {}\n index = 1\n for coord in set(chain.from_iterable(coords)) :\n if not nodes.has_key( coord ) :\n node = pydot.Node( str(coord) )\n if v != None :\n #print coord\n label = labels[coord]\n if label_nodes_directly :\n node.set_label( label )\n else :\n node.set_label( str(index) )\n #node.set_penwidth( nv[ coord ] )\n node.set_fixedsize(\"true\")\n node.set_width( max(min_node_size,scale *nv[ coord ]) )\n node.set_shape(\"circle\")\n nodes[ coord ] = node\n graph.add_node( node )\n index = index + 1\n\n for coord in coords :\n \n edge = pydot.Edge( nodes[coord[0]], nodes[coord[1]] )\n edge.set_weight( nC[coord] )\n edge.set_penwidth( nC[coord]*5 )\n #edge.set_label( str(int(m[coord]) ))\n graph.add_edge(edge)\n\n if not label_nodes_directly : \n legend = pydot.Node( \"legend\" )\n nodelist = nodes.items()\n nodelist.sort( lambda a,b : cmp(node_index(a[1].get_label()),node_index(b[1].get_label())) )\n legend.set_label( \"\\l\".join([x[1].get_label()+\":\"+labels[x[0]] for x in nodelist])+\"\\l\" )\n legend.set_shape(\"box\")\n graph.add_node(legend)\n\n #print graph.to_string()\n graph.write_dot(fnam_stem+'.dot', prog='neato' )\n graph.write_png(fnam_stem+'.png', prog='neato' )\n #graph.write_pdf(fnam_stem+'.pdf', prog='neato' )","def non_pol_neighbours_graph():\n data = pd.read_csv(\"/Users/emg/GitHub/thesis/output/2019_01/1000_residuals_output_utf8.csv\", index_col=0)\n\n labelled = label_subs(data)\n labelled['resid_rank'] = labelled.resid.rank(pct=True)\n top = subset_df(labelled, 'resid', q=0.95)\n\n edges = top.copy()[['source','target','resid']]\n edges_rev = edges.copy()\n edges_rev.columns = ['target','source','resid']\n directed_edges = pd.concat([edges,edges_rev], sort=True)\n directed_edges['resid_rank'] = directed_edges['resid'].rank(pct=True)\n\n df = label_subs(directed_edges)\n\n pol_subs = load_pol_subs()\n pol_names = pol_subs.subreddit.str.replace('\\\\','')\n pol_subs.subreddit=pol_subs.subreddit.str.replace('\\\\','')\n\n pol_neighbours = df[df['source'].isin(pol_names)].sort_values('resid', ascending=False)\n\n top_pol_neigh = pol_neighbours.groupby('source').head(10).sort_values(['source','resid'], ascending=[True,False])\n \n x = top_pol_neigh[~top_pol_neigh.target.isin(pol_names)][['source','target']]\n\n col_dict = pol_subs.set_index('subreddit').col.to_dict()\n for sub in x.target.unique():\n col_dict[sub] = 'gray'\n\n G = nx.from_pandas_edgelist(x)\n nx.set_node_attributes(G, col_dict, 'col')\n\n f = plt.figure(1)\n ax = f.add_subplot(1,1,1)\n\n colors = dict(G.nodes(data='col')).values()\n\n pos = nx.spring_layout(G, k=0.2)\n nx.draw_networkx(G, pos=pos, with_labels=False, node_color=colors, alpha=0.3)\n #nx.draw_networkx_labels(G, pos=pos, with_labels=True)\n\n plt.axis('off')\n f.set_facecolor('w')\n \n f.tight_layout()\n plt.savefig(figures_path(f\"{date}/non_pol_neighbours_graph.png\"))\n plt.close()","def FindClumps_graph(self):\n # IMPORT STUFF\n import string\n # END IMPORT\n \n maxima = self['CL_LOC'].copy()\n maxima = num.where(maxima)\n maxima = (maxima[1],maxima[0])\n detectimg = self['STAMP'].copy()\n \n id = self._getGraphId()\n root = 'FindClumps_%s' % (id,)\n pngname = root + '.png' ; epsname = root + '.eps'\n jpgname = root + '.jpg'\n\n doStamp(detectimg,pngname,format='PNG')\n Convert(pngname,jpgname)\n \n Painted = Paint(jpgname)\n Painted.load()\n Painted.DrawCross(maxima,length=7,color='green')\n \n strpeaks = string.strip('%i'% (self['M_NUM_CL']))\n text = 'NC=%s' % strpeaks \n \n # Painted.Graffiti(text,commtextpos)\n \n Painted.save(jpgname)\n Painted.release()\n \n Convert(jpgname,epsname)\n os.system('rm %s %s' % (pngname,jpgname))\n self['figures']['FindClumps'] = epsname\n self['figcomms']['FindClumps'] = text","def get_communities(num_of_neighbors, is_self_loops, relevant_period_groups, full_confusion_csv, classes_csv_file, priod_group_column, similarty_csv = ''):\n\n # generate class_names dict\n cnt = 0\n class_name_dict = {}\n with open(classes_csv_file, 'r') as f:\n reader = csv.reader(f)\n for row in reader:\n if cnt > 0:\n class_name_dict[int(row[8])] = row[1]\n cnt = cnt + 1\n\n\n full_conf = np.genfromtxt(full_confusion_csv, delimiter=',')\n relevant_conf = full_conf[:,:num_of_neighbors+1]\n flatten_conf = np.zeros((relevant_conf.shape[0]*num_of_neighbors,2), dtype=np.int32)\n if similarty_csv != '':\n similarity_mat = np.genfromtxt(similarty_csv, delimiter=',')\n similarity_conf_mat = np.zeros((200, 200), dtype=np.float32)\n print(similarity_mat.shape)\n\n\n row = 0\n for k in range(relevant_conf.shape[0]):\n for m in range(num_of_neighbors):\n flatten_conf[row, 0] = relevant_conf[k,0]\n flatten_conf[row,1] = relevant_conf[k,m+1]\n if similarty_csv != '':\n similarity_conf_mat[int(relevant_conf[k,0]), int(relevant_conf[k,m+1]) ] += similarity_mat[k, m]\n\n row = row + 1\n\n confusion_mat = confusion_matrix(flatten_conf[:,0], flatten_conf[:,1])\n if similarty_csv != '':\n confusion_mat = similarity_conf_mat\n\n confusion_mat = confusion_mat.astype('float') / confusion_mat.sum(axis=1)[:, np.newaxis]\n symmetric_confusion = (confusion_mat + np.transpose(confusion_mat)) / 2\n if not is_self_loops:\n np.fill_diagonal(symmetric_confusion, 0)\n\n # taking only the relevant classes\n if relevant_period_groups != -1:\n df = pd.read_csv(classes_csv_file)\n period_groups = df[priod_group_column]\n relevant_classes = []\n for group in relevant_period_groups:\n group_slice = df[period_groups == group]\n relevant_classes.extend(group_slice['id_period_sorted'].values)\n\n L = len(relevant_classes)\n relevant_confusion = np.zeros((L,L), dtype=np.float32)\n class_node_dict = {}\n for m,cls_i in enumerate(relevant_classes):\n class_node_dict[m] = cls_i\n for n,cls_j in enumerate(relevant_classes):\n relevant_confusion[m,n] = symmetric_confusion[cls_i,cls_j]\n else:\n relevant_confusion = symmetric_confusion\n\n G = nx.from_numpy_matrix(relevant_confusion)\n\n # find best communities based on modularity grade\n resolution_vec = np.linspace(0.0,2,50)\n mod_vec = np.zeros_like(resolution_vec)\n best_modularity = -1\n best_communities = -1\n best_res = -1\n for k in range(resolution_vec.size):\n partition = community.best_partition(G, weight='weight', resolution=resolution_vec[k])\n modularity = community.modularity(partition, G, weight='weight')\n mod_vec[k] = modularity\n if (modularity > best_modularity):\n best_modularity = modularity\n best_communities = partition\n best_res = resolution_vec[k]\n\n summary_str = 'best resolution: %.3f\\nbest modularity: %.3f\\nnumber of communities: %d' % (best_res,best_modularity,len(set(best_communities.values())))\n\n #plt.plot(resolution_vec,mod_vec)\n #plt.show()\n\n # generate community summary file\n count = 0\n strr = ''\n summary_file_name = 'community_summary.csv'\n for com in set(best_communities.values()):\n count += 1.\n list_nodes = [nodes for nodes in best_communities.keys() if best_communities[nodes] == com]\n strr += 'community,' + str(com) + '\\n'\n for nd in list_nodes:\n if relevant_period_groups == -1:\n strr += class_name_dict[nd] + ',id,' + str(nd) + '\\n'\n else:\n strr += class_name_dict[class_node_dict[nd]] + ',id,' + str(class_node_dict[nd]) + '\\n'\n strr += '\\n'\n with open(summary_file_name, \"w\") as text_file:\n text_file.write(strr)\n\n print(strr)\n # summary for map visualization tool\n strr = ''\n for k in range(relevant_confusion.shape[0]):\n comm = partition[k]\n comm_members = [nodes for nodes in partition.keys() if partition[nodes] == comm]\n if relevant_period_groups == -1:\n strr += 'id,' + str(k) + ',community,' + str(comm) + ',community_members,'\n else:\n strr += 'id,' + str(class_node_dict[k]) + ',community,' + str(comm) + ',community_members,'\n for member in comm_members:\n if relevant_period_groups == -1:\n strr += str(member) + ','\n else:\n strr += str(class_node_dict[member]) + ','\n strr += '\\n'\n with open('nodes_communities.csv', \"w\") as text_file:\n text_file.write(strr)\n\n\n\n return summary_str","def bgll(self, graph, node_count, min_mod, max_pass):\n\n #the belonging of the node\n bl = [i for i in range(node_count)]\n #the node's weight in community\n _in = [0.0] * node_count\n #the node's weight in graph\n _tot = []\n #total weight of a node, just a copy of _tot\n k = []\n #the total weight of the graph\n m = []\n\n #inital the in-param\n network = [[0.0] * node_count for n in range(node_count)]\n for node, tag, weight in graph:\n network[node][tag] = weight\n for node in network:\n k.append(sum(node))\n _tot = k[:]\n m = sum(k)\n #inital the in-param\n\n def modularity():\n \"\"\"\n This function mainly computes the modularity of the network\n Return:\n mod->the modularity value\n \"\"\"\n\n q = 0.0\n for idx in range(0, node_count):\n if _tot[idx] > 0.0:\n q += (_in[idx] / m - math.pow(_tot[idx] / m, 2))\n return q\n\n def modularity_gain(n, c, dnodecomm):\n \"\"\"\n This function mainly computes the modularity gain of a node moving\n Param:\n n->node id\n c->community id\n dnodecomm->the weight between the node and the community\n Return:\n gain->modularity gain\n \"\"\"\n\n totc = _tot[c]\n degc = k[n]\n return dnodecomm - (totc * degc) / m\n\n def neigh_comm(n):\n \"\"\"\n This function mainly computes the weight between the node and it's neighbour community\n Param:\n n->node id\n Return:\n nc->the map of the weight between the node and it's neighbour community\n nc=>{cid,weight}\n \"\"\"\n\n nc = {bl[n]: 0.0}\n for idx in range(0, node_count):\n neigh = idx\n ncomm = bl[neigh]\n nei_weight = network[n][idx]\n if (neigh != n) & (nei_weight > 0.0):\n if ncomm in nc:\n nc[ncomm] += nei_weight\n else:\n nc[ncomm] = nei_weight\n return nc\n\n def insert(n, c, dnodecomm):\n \"\"\"\n This function mainly get the effect of insert the node into community\n Param:\n n->node id\n c->community id\n dnodecomm->the weight between the node and the community\n \"\"\"\n\n _tot[c] += k[n]\n _in[c] += 2 * dnodecomm + network[n][n]\n bl[n] = c\n\n def remove(n, c, dnodecomm):\n \"\"\"\n This function mainly get the effect of remove the node off community\n Param:\n n->node id\n c->community id\n dnodecomm->the weight between the node and the community\n \"\"\"\n\n _tot[c] -= k[n]\n _in[c] -= 2 * dnodecomm + network[n][n]\n bl[n] = -1\n\n def detect():\n \"\"\"\n This function mainly detect the community of the graph.\n \"\"\"\n\n _pass_done = 0\n _improve = True\n new_mod = modularity()\n cur_mod = -999999999.0\n rl = random.sample(range(0, node_count), node_count)\n while _improve & (_pass_done < max_pass) & (new_mod - cur_mod > min_mod):\n cur_mod = new_mod\n _improve = False\n _pass_done += 1\n for node_tmp in rl:\n n = node_tmp\n nc = bl[n]\n ncomm = neigh_comm(n)\n remove(n, nc, ncomm[nc])\n best_c = nc\n best_l = 0.0\n best_incre = 0.0\n for c in ncomm:\n incre = modularity_gain(n, c, ncomm[c])\n if incre > best_incre:\n best_incre = incre\n best_c = c\n best_l = ncomm[c]\n insert(n, best_c, best_l)\n if best_c != nc:\n _improve = True\n new_mod = modularity()\n print new_mod\n\n detect()\n return bl","def make_communities(community_side, communities_per_side):\n community_size = community_side * community_side\n communities = []\n seed_node = 0\n for i in range(communities_per_side):\n for j in range(communities_per_side):\n community = []\n for k in range(community_side):\n for z in range(community_side):\n _id = (\n communities_per_side * community_size * i\n + community_side * j\n + z\n + k * (communities_per_side * community_side)\n )\n # print(f\"{_id} \", end=\"\")\n community.append(_id)\n # print(\"- \", end=\"\")\n communities.append(community)\n #print()\n return communities","def construct_network_from_neighbours_list(related_characters: list):\n graph = nx.Graph()\n for edge in related_characters:\n sentiment = edge[1]\n color = ''\n if sentiment == 'Positive':\n color = 'g'\n elif sentiment == 'Negative':\n color = 'r'\n elif sentiment == 'Neutral':\n color = 'k'\n # graph.add_node(edge[0][0], popularity=\n graph.add_edge(edge[0][0], edge[0][1], color=color, weight=edge[2])\n\n return graph","def network(self, max_clusters=20, max_members=10, max_nodes=300, l_go_selective=False):\n if len(self.data)==0:\n return None\n if self.DM is None:\n util.error_msg('Please run cluster first!')\n S_node=GO_Cluster.sample_rows(self.t_go, max_clusters=max_clusters, max_members=max_members, max_nodes=max_nodes, l_go_selective=l_go_selective)\n T_node=self.t_go[self.t_go.GO.apply(lambda x: x in S_node)].copy()\n S_go=self.data.header()\n M=self.data.values\n n,m=M.shape\n S_node=set(T_node.GO)\n S_idx=[i for i,x in enumerate(S_go) if x in S_node ]\n S_name=[ S_go[i] for i in S_idx]\n T_node.rename2({'GO':'Gene'})\n s_name='GOCluster'\n if 'Name' in T_node.header():\n s_name=list(T_node.Name)[0]\n T_node.drop('Name', axis=1, inplace=True)\n if 'URL' in T_node.header():\n T_node.drop('URL', axis=1, inplace=True)\n\n c_has_neighbor={}\n data=[]\n c_cluster={ T_node.ix[i,'Gene']:T_node.ix[i,'GROUP_ID'] for i in T_node.index}\n n2=len(S_idx)\n for _i in range(n2):\n i=S_idx[_i]\n for _j in range(_i+1, n2):\n j=S_idx[_j]\n idx=i*(2*m-i-1)//2+(j-i)-1\n #print (_i, _j, n2, m, i, j, idx, S_name[_i], c_cluster[S_name[_i]], S_name[_j], c_cluster[S_name[_j]], K[idx])\n if self.DM[idx]>=self.similarity:\n data.append({'Gene_A':S_go[i], 'Gene_B':S_go[j], 'TYPE':'Direct', 'SCORE':self.DM[idx]})\n c_has_neighbor[S_go[i]]=True\n c_has_neighbor[S_go[j]]=True\n # keep singletons\n for i in S_idx:\n if S_go[i] not in c_has_neighbor:\n data.append({'Gene_A':S_go[i], 'Gene_B':S_go[i], 'TYPE':'Direct', 'SCORE':1.0})\n if len(data):\n T_edge=pd.DataFrame(data)\n T_node.index=list(range(len(T_node)))\n net=xgmml.Network(T_edge, T_node=T_node, name=s_name)\n return net","def calc_coloring(graph_rdd):\n graph_rdd = graph_rdd \\\n .map(swap) \\\n .union(graph_rdd)\n nodes = graph_rdd.keys().distinct()\n\n color = nodes.map(lambda x: (x, 1))\n color_num = 1\n\n while True:\n graph_join_color = graph_rdd.join(color)\n neighbour = graph_join_color \\\n .map(lambda (x, (a, bx)): (a, (x, bx))) \\\n .groupByKey() \\\n .map(lambda (x, y): (x, [n[1] for n in y]))\n color = neighbour.map(lambda (x, y): (x, hash(str(sorted(y)))))\n color_new = color \\\n .map(swap) \\\n .reduceByKey(add, numPartitions=40) \\\n .map(lambda x: 1) \\\n .reduce(add)\n if color_num != color_new:\n break\n color_num = color_new\n return color","def clusters_connected( self):\n def check_connected( k, vertices, edges):\n dads = {}\n for p in vertices:\n dads[p] = p\n\n def Find( c):\n while c != dads[c]:\n c = dads[c]\n return c\n\n def Union( p, q):\n dads[Find(p)] = Find(q)\n\n for p,q in edges:\n Union( p, q)\n\n stuff = set([ Find(p) for (k,p) in dads.items()])\n assert len(stuff) == 1, \"More than one partition\"\n\n vertices = collections.defaultdict( list)\n for p in itertools.product( range(self.n), repeat=2):\n vertices[self.raster[p]].append( p)\n\n def X():\n for x in range(self.n-1):\n for y in range(self.n):\n yield (x,y),(x+1,y)\n\n def Y():\n for x in range(self.n):\n for y in range(self.n-1):\n yield (x,y),(x,y+1)\n\n connections = collections.defaultdict( list)\n for (p,q) in itertools.chain( X(), Y()):\n if self.raster[p] == self.raster[q]:\n connections[self.raster[p]].append( ( p, q))\n\n for (k,v) in vertices.items():\n check_connected( k, v, connections[k])","def _community(G, u, community):\n node_u = G.node[u]\n try:\n return node_u[community]\n except KeyError:\n raise nx.NetworkXAlgorithmError('No community information')","def color_chosen_nodes(network, chosen_node, color):\n\n # Color the node selected randomly by RWR\n network.nodes[chosen_node]['color'] = color\n # Create a list with color for each node\n color_nodes = [network.nodes[node]['color'] for node in network.nodes]\n return color_nodes","def add_communites(self):\n\n query = '''\n MATCH (c1:)-[r:INTERACTS]->(c2:)\n RETURN c1.name, c2.name, r.weight AS weight\n '''\n ig = IGraph.TupleList(self.graph.run(query), weights=True)\n\n clusters = IGraph.community_walktrap(ig, weights=\"weight\").as_clustering()\n\n nodes = [{\"name\": node[\"name\"]} for node in ig.vs]\n for node in nodes:\n idx = ig.vs.find(name=node[\"name\"]).index\n node[\"community\"] = clusters.membership[idx]\n\n write_clusters_query = '''\n UNWIND {nodes} AS n\n MATCH (c:) WHERE c.name = n.name\n SET c.community = toInt(n.community)\n '''\n\n self.graph.run(write_clusters_query, nodes=nodes)","def make_connected(self):\r\n if nx.is_connected(self.g): return\r\n import random\r\n cc = list( nx.connected_components(self.g) )\r\n nodes = [random.sample(cluster,1)[0] for cluster in cc]\r\n for n1,n2 in zip(nodes[:-1],nodes[1:]):\r\n self.factors.append(factor(var=[n1,n2],card=self.cardVec[[n1,n2]],val=scipy.ones(4)))\r\n self.update()","def vertex_coloring(self, display = False):\r\n stack = self.SL_algorithm()\r\n color_of_vertex = self.greedily_coloring(stack)\r\n if(display):\r\n self.display_graph(color_of_vertex)\r\n return color_of_vertex\r\n else: \r\n return color_of_vertex","def get_classification_site(self, image):\n #TODO implement light color prediction\n \n\timg=cv2.resize(image,(224,224))\n\timg=img/255.0\n\timg = np.expand_dims(img, axis=0)\n with self.graph.as_default():\n\t pred=self.model.predict(img)\n\tpclass=np.argmax(pred)\n\n \ttf_color=TrafficLight.UNKNOWN\n if (pclass==1):\n\t tf_color=TrafficLight.RED\n elif (pclass==2):\n\t tf_color=TrafficLight.GREEN\n\n return tf_color","def get_classification(self, image):\n run_network = True # flag to disable running network if desired\n if run_network is True:\n image_np_expanded = np.expand_dims(image, axis=0)\n\n time0 = time.time()\n\n # Actual detection.\n with self.detection_graph.as_default():\n (boxes, scores, classes, num) = self.sess.run(\n [self.detection_boxes, self.detection_scores,\n self.detection_classes, self.num_detections],\n feed_dict={self.image_tensor: image_np_expanded})\n\n time1 = time.time()\n\n #print(\"Time in milliseconds\", (time1 - time0) * 1000)\n\n boxes = np.squeeze(boxes)\n scores = np.squeeze(scores)\n classes = np.squeeze(classes).astype(np.int32)\n \n #Add extra stuff here\n self.current_light = TrafficLight.UNKNOWN\n min_score_thresh = .50\n for i in range(boxes.shape[0]):\n if scores is None or scores[i] > min_score_thresh:\n\n class_name = self.category_index[classes[i]]['name']\n # class_id = self.category_index[classes[i]]['id'] # if needed\n\n #print('{}'.format(class_name))\n\n # Traffic light thing\n self.current_light = TrafficLight.UNKNOWN\n\n if class_name == 'Red':\n self.current_light = TrafficLight.RED\n elif class_name == 'Green':\n self.current_light = TrafficLight.GREEN\n elif class_name == 'Yellow':\n self.current_light = TrafficLight.YELLOW\n \n '''if self.current_light == TrafficLight.RED:\n print('RED')\n elif self.current_light == TrafficLight.GREEN:\n print('GREEN')\n elif self.current_light == TrafficLight.YELLOW:\n print('YELLOW')\n else:\n print('NO_LIGHT')'''\n\n return self.current_light","def greedy_modularity_communities(G, weight=None):\n\n # Count nodes and edges\n N = len(G.nodes())\n m = sum([d.get('weight', 1) for u, v, d in G.edges(data=True)])\n q0 = 1.0 / (2.0*m)\n\n # Map node labels to contiguous integers\n label_for_node = dict((i, v) for i, v in enumerate(G.nodes()))\n node_for_label = dict((label_for_node[i], i) for i in range(N))\n\n # Calculate degrees\n k_for_label = G.degree(G.nodes(), weight=weight)\n k = [k_for_label[label_for_node[i]] for i in range(N)]\n\n # Initialize community and merge lists\n communities = dict((i, frozenset([i])) for i in range(N))\n merges = []\n\n # Initial modularity\n partition = [[label_for_node[x] for x in c] for c in communities.values()]\n q_cnm = modularity(G, partition)\n\n # Initialize data structures\n # CNM Eq 8-9 (Eq 8 was missing a factor of 2 (from A_ij + A_ji)\n # a[i]: fraction of edges within community i\n # dq_dict[i][j]: dQ for merging community i, j\n # dq_heap[i][n] : (-dq, i, j) for communitiy i nth largest dQ\n # H[n]: (-dq, i, j) for community with nth largest max_j(dQ_ij)\n a = [k[i]*q0 for i in range(N)]\n dq_dict = dict(\n (i, dict(\n (j, 2*q0 - 2*k[i]*k[j]*q0*q0)\n for j in [\n node_for_label[u]\n for u in G.neighbors(label_for_node[i])]\n if j != i))\n for i in range(N))\n dq_heap = [\n MappedQueue([\n (-dq, i, j)\n for j, dq in dq_dict[i].items()])\n for i in range(N)]\n H = MappedQueue([\n dq_heap[i].h[0]\n for i in range(N)\n if len(dq_heap[i]) > 0])\n\n # Merge communities until we can't improve modularity\n while len(H) > 1:\n # Find best merge\n # Remove from heap of row maxes\n # Ties will be broken by choosing the pair with lowest min community id\n try:\n dq, i, j = H.pop()\n except IndexError:\n break\n dq = -dq\n # Remove best merge from row i heap\n dq_heap[i].pop()\n # Push new row max onto H\n if len(dq_heap[i]) > 0:\n H.push(dq_heap[i].h[0])\n # If this element was also at the root of row j, we need to remove the\n # duplicate entry from H\n if dq_heap[j].h[0] == (-dq, j, i):\n H.remove((-dq, j, i))\n # Remove best merge from row j heap\n dq_heap[j].remove((-dq, j, i))\n # Push new row max onto H\n if len(dq_heap[j]) > 0:\n H.push(dq_heap[j].h[0])\n else:\n # Duplicate wasn't in H, just remove from row j heap\n dq_heap[j].remove((-dq, j, i))\n # Stop when change is non-positive\n if dq <= 0:\n break\n\n # Perform merge\n communities[j] = frozenset(communities[i] | communities[j])\n del communities[i]\n merges.append((i, j, dq))\n # New modularity\n q_cnm += dq\n # Get list of communities connected to merged communities\n i_set = set(dq_dict[i].keys())\n j_set = set(dq_dict[j].keys())\n all_set = (i_set | j_set) - set([i, j])\n both_set = i_set & j_set\n # Merge i into j and update dQ\n for k in all_set:\n # Calculate new dq value\n if k in both_set:\n dq_jk = dq_dict[j][k] + dq_dict[i][k]\n elif k in j_set:\n dq_jk = dq_dict[j][k] - 2.0*a[i]*a[k]\n else:\n # k in i_set\n dq_jk = dq_dict[i][k] - 2.0*a[j]*a[k]\n # Update rows j and k\n for row, col in [(j, k), (k, j)]:\n # Save old value for finding heap index\n if k in j_set:\n d_old = (-dq_dict[row][col], row, col)\n else:\n d_old = None\n # Update dict for j,k only (i is removed below)\n dq_dict[row][col] = dq_jk\n # Save old max of per-row heap\n if len(dq_heap[row]) > 0:\n d_oldmax = dq_heap[row].h[0]\n else:\n d_oldmax = None\n # Add/update heaps\n d = (-dq_jk, row, col)\n if d_old is None:\n # We're creating a new nonzero element, add to heap\n dq_heap[row].push(d)\n else:\n # Update existing element in per-row heap\n dq_heap[row].update(d_old, d)\n # Update heap of row maxes if necessary\n if d_oldmax is None:\n # No entries previously in this row, push new max\n H.push(d)\n else:\n # We've updated an entry in this row, has the max changed?\n if dq_heap[row].h[0] != d_oldmax:\n H.update(d_oldmax, dq_heap[row].h[0])\n\n # Remove row/col i from matrix\n i_neighbors = dq_dict[i].keys()\n for k in i_neighbors:\n # Remove from dict\n dq_old = dq_dict[k][i]\n del dq_dict[k][i]\n # Remove from heaps if we haven't already\n if k != j:\n # Remove both row and column\n for row, col in [(k, i), (i, k)]:\n # Check if replaced dq is row max\n d_old = (-dq_old, row, col)\n if dq_heap[row].h[0] == d_old:\n # Update per-row heap and heap of row maxes\n dq_heap[row].remove(d_old)\n H.remove(d_old)\n # Update row max\n if len(dq_heap[row]) > 0:\n H.push(dq_heap[row].h[0])\n else:\n # Only update per-row heap\n dq_heap[row].remove(d_old)\n\n del dq_dict[i]\n # Mark row i as deleted, but keep placeholder\n dq_heap[i] = MappedQueue()\n # Merge i into j and update a\n a[j] += a[i]\n a[i] = 0\n\n communities = [\n frozenset([label_for_node[i] for i in c])\n for c in communities.values()]\n return sorted(communities, key=len, reverse=True)","def detect():\n\n _pass_done = 0\n _improve = True\n new_mod = modularity()\n cur_mod = -999999999.0\n rl = random.sample(range(0, node_count), node_count)\n while _improve & (_pass_done < max_pass) & (new_mod - cur_mod > min_mod):\n cur_mod = new_mod\n _improve = False\n _pass_done += 1\n for node_tmp in rl:\n n = node_tmp\n nc = bl[n]\n ncomm = neigh_comm(n)\n remove(n, nc, ncomm[nc])\n best_c = nc\n best_l = 0.0\n best_incre = 0.0\n for c in ncomm:\n incre = modularity_gain(n, c, ncomm[c])\n if incre > best_incre:\n best_incre = incre\n best_c = c\n best_l = ncomm[c]\n insert(n, best_c, best_l)\n if best_c != nc:\n _improve = True\n new_mod = modularity()\n print new_mod","def assign_louvain_communities(\n reddit_graph: nx.Graph,\n wiki_graph: nx.Graph = None,\n reddit_edge_weight: str = \"count\",\n others_threshold: int = 2,\n louvain_resolution_reddit: float = 1,\n) -> Union[nx.Graph, Tuple[nx.Graph, nx.Graph]]:\n reddit_dendrogram = community.generate_dendrogram(\n reddit_graph, weight=reddit_edge_weight, resolution=louvain_resolution_reddit\n )\n if wiki_graph:\n wiki_dendrogram = community.generate_dendrogram(\n wiki_graph,\n )\n\n # Iterate over reddit nodes to assign communities\n for node in reddit_graph:\n # Iterate over all levels of the dendrogram\n for level in range(len(reddit_dendrogram) - 1):\n actual_level = len(reddit_dendrogram) - 2 - level\n\n partition = community.partition_at_level(reddit_dendrogram, level)\n\n node_community = partition[node]\n counts = Counter(partition.values())\n if counts[node_community] < others_threshold:\n node_community = -1\n reddit_graph.nodes[node][\n f\"louvain_community_reddit_R{louvain_resolution_reddit:.2f}_L{actual_level}\"\n ] = f\"L{actual_level}-{node_community:03}\"\n if wiki_graph:\n # Also add the community from the other graph to allow comparing\n # Again, iterate over all levels in the dendrogram\n for level in range(len(wiki_dendrogram) - 1):\n actual_level = len(wiki_dendrogram) - 2 - level\n\n partition = community.partition_at_level(wiki_dendrogram, level)\n\n try:\n node_community = partition[node]\n counts = Counter(partition.values())\n if counts[node_community] < others_threshold:\n node_community = -1\n\n reddit_graph.nodes[node][\n f\"louvain_community_wiki_L{actual_level}\"\n ] = f\"L{actual_level}-{node_community:03}\"\n\n except:\n reddit_graph.nodes[node][\n f\"louvain_community_wiki_L{level}\"\n ] = f\"L{level}-NONE\"\n if wiki_graph:\n for node in wiki_graph:\n for level in range(\n len(wiki_dendrogram) - 1,\n ):\n actual_level = len(wiki_dendrogram) - 2 - level\n\n partition = community.partition_at_level(wiki_dendrogram, level)\n node_community = partition[node]\n\n counts = Counter(partition.values())\n if counts[node_community] < others_threshold:\n node_community = -1\n\n wiki_graph.nodes[node][\n f\"louvain_community_wiki_L{actual_level}\"\n ] = f\"L{actual_level}-{node_community:03}\"\n # Also add the community from the other graph to allow comparing\n\n for level in range(len(reddit_dendrogram) - 1):\n actual_level = len(reddit_dendrogram) - 2 - level\n\n partition = community.partition_at_level(reddit_dendrogram, level)\n\n try:\n node_community = partition[node]\n\n counts = Counter(partition.values())\n if counts[node_community] < others_threshold:\n node_community = -1\n wiki_graph.nodes[node][\n f\"louvain_community_reddit_R{louvain_resolution_reddit:.2f}_L{actual_level}\"\n ] = f\"L{actual_level}-{node_community:03}\"\n except:\n wiki_graph.nodes[node][\n f\"louvain_community_reddit_R{louvain_resolution_reddit:.2f}_L{level}\"\n ] = f\"L{level}-NONE\"\n\n return (\n (reddit_graph, reddit_dendrogram, wiki_graph, wiki_dendrogram)\n if wiki_graph\n else (reddit_graph, reddit_dendrogram)\n )","def connected_component(self):\n t1 = datetime.datetime.now()\n nodes = set(x.hex for x in self.agents)\n result = []\n while nodes:\n node = nodes.pop()\n # This set will contain the next group of nodes connected to each other.\n group = {node}\n # Build a queue with this node in it.\n queue = [node]\n # Iterate the queue.\n # When it's empty, we finished visiting a group of connected nodes.\n while queue:\n # Consume the next item from the queue.\n node = queue.pop(0)\n # Fetch the neighbors.\n neighbors = set(x for x in node.fon if x.is_occupied == 1)\n # Remove the neighbors we already visited.\n neighbors.difference_update(group)\n # Remove the remaining nodes from the global set.\n nodes.difference_update(neighbors)\n # Add them to the group of connected nodes.\n group.update(neighbors)\n # Add them to the queue, so we visit them in the next iterations.\n queue.extend(neighbors)\n\n # Add the group to the list of groups.\n result.append(len(group))\n td = datetime.datetime.now() - t1\n print(\"calculated {} connected components in {} seconds\".format(len(result),td.total_seconds()))\n return len(result), np.histogram(result, self.cluster_hist_breaks)[0]","def node_graph(imageSkeleton, imageGaussian):\n ones = np.ones((3, 3))\n imageFiltered = sp.ndimage.generic_filter(imageSkeleton, node_find, footprint=ones, mode='constant', cval=0)\n imageNodeCondense = node_condense(imageFiltered, imageGaussian, ones)\n imageLabeledNodes = skimage.segmentation.relabel_sequential(imageNodeCondense)[0]\n imageLabeledSkeleton, labels = sp.ndimage.label(imageSkeleton, structure=ones)\n for label in range(1, labels + 1):\n detectedNodes = np.max((imageLabeledSkeleton == label) * (imageLabeledNodes > 0))\n if (detectedNodes == 0):\n imageSkeleton[imageLabeledSkeleton == label] = 0\n imageAnnotated = 1 * ((imageSkeleton + imageLabeledNodes) > 0) + imageLabeledNodes\n return(imageAnnotated)","def estimate_community(X, Y, true_labels, method, n_communities):\n stacked = np.vstack([X, Y])\n\n if method == \"mase\":\n embedder = MultipleASE(2)\n embeddings = embedder.fit_transform(stacked)\n elif method == \"omni\":\n embedder = OmnibusEmbed(2)\n embeddings = embedder.fit_transform(stacked).mean(axis=0)\n else:\n assert ValueError(\"Invalid embedding method\")\n\n predicted_labels = GaussianCluster(n_communities, n_communities, \"all\").fit_predict(\n embeddings\n )\n\n # Label flipping\n idx = true_labels == 0\n if np.mean(predicted_labels[idx]) < 0.5:\n return predicted_labels\n else:\n # This is bitwise flipping. Turns all 0s to 1s and 1s to 0s.\n # Reason is to make labels consistent across repetitions\n predicted_labels = predicted_labels ^ (predicted_labels & 1 == predicted_labels)\n return predicted_labels","def get_classification(self, cv2_image):\n def get_green_mask(img_hsv):\n lower_green = np.array([40, 10, 10])\n upper_green = np.array([90, 255, 255])\n mask = cv2.inRange(img_hsv, lower_green, upper_green)\n return mask\n\n def get_red_mask(img_hsv):\n # red lower mask (0-10)\n lower_red = np.array([20, 1, 150])\n upper_red = np.array([30, 120, 255])\n mask0 = cv2.inRange(img_hsv, lower_red, upper_red)\n\n # Red upper mask\n lower_red = np.array([170, 50, 50])\n upper_red = np.array([180, 255, 255])\n mask1 = cv2.inRange(img_hsv, lower_red, upper_red)\n\n # join my masks\n mask = mask0 + mask1\n return mask\n\n def get_traffic_light_color(cv2_image):\n # Convert BGR to HSV\n img_hsv = cv2.cvtColor(cv2_image, cv2.COLOR_BGR2HSV)\n height, width, _ = img_hsv.shape\n\n green_mask = get_green_mask(img_hsv)\n red_mask = get_red_mask(img_hsv)\n\n dico = {\n TrafficLight.RED: np.count_nonzero(red_mask[0:int(height / 3), :]),\n TrafficLight.YELLOW: np.count_nonzero(red_mask[int(height / 3):int(height * 2 / 3), :]),\n TrafficLight.GREEN: np.count_nonzero(green_mask[int(height * 2 / 3):height, :])\n }\n\n v = list(dico.values())\n k = list(dico.keys())\n return k[v.index(max(v))]\n\n output_dict = self.run_inference_for_single_image(cv2_image)\n traffic_light_image = self.get_traffic_light(cv2_image, output_dict)\n\n # no traffic light found\n if traffic_light_image is None:\n return TrafficLight.UNKNOWN\n\n return get_traffic_light_color(traffic_light_image)","def complex_network_mapping(graph):\n vect = []\n\n n = nx.number_of_nodes(graph)\n e = nx.number_of_edges(graph)\n print n, e\n\n# adj = nx.adjacency_matrix(graph).toarray()\n# adj_bin = np.where(adj > 0, 1., 0.)\n# adj_conn = 1 - adj\n adj_bin = nx.adjacency_matrix(graph).toarray()\n adj_bin = np.array(adj_bin, dtype=np.float)\n\n # Node Betweenness binary\n bt_bin = nx.betweenness_centrality(graph).values()\n avg_btb = np.mean(bt_bin)\n vect.append(avg_btb)\n\n # Edge betweenness\n ebt = np.array(nx.edge_betweenness_centrality(graph).values())\n vect.append(np.mean(ebt))\n\n # Eigen vector centrality binary\n evc_bin = eigenvector_centrality_und(adj_bin)\n avg_evcb = np.mean(evc_bin)\n vect.append(avg_evcb)\n\n # Flow coefficient\n _, flow_bin, _ = flow_coef_bd(adj_bin)\n avg_flow = np.mean(flow_bin)\n vect.append(avg_flow)\n\n # Kcoreness centrality\n kcor_bin, _ = kcoreness_centrality_bu(adj_bin)\n avg_kcor = np.mean(kcor_bin)\n vect.append(avg_kcor)\n\n # Degree assortivity\n dac = nx.degree_assortativity_coefficient(graph)\n vect.append(dac)\n\n # Page rank centrality\n# pgr_wei = pagerank_centrality(adj_bin, d=0.85)\n# avg_pgr = np.mean(pgr_wei)\n# vect.append(avg_pgr)\n\n # Rich club coefficient\n# rcc = nx.rich_club_coefficient(graph).values()\n# avg_rcc = np.mean(rcc)\n# vect.append(avg_rcc)\n\n # Transitivity\n tr = nx.transitivity(graph)\n vect.append(tr)\n\n # average clustering\n avg_clst = nx.average_clustering(graph)\n vect.append(avg_clst)\n\n glb_ef = efficiency_bin(adj_bin)\n vect.append(glb_ef)\n\n return vect","def main():\n G = nx.gnp_random_graph(100, 0.5)\n centrality = nx.eigenvector_centrality(G)\n avg_centrality = sum(centrality.values()) / len(G)\n\n def has_high_centrality(v):\n return centrality[v] >= avg_centrality\n\n source = 0\n value = centrality.get\n condition = has_high_centrality\n\n found_node = progressive_widening_search(G, source, value, condition)\n c = centrality[found_node]\n print('found node {0} with centrality {1}'.format(found_node, c))","def vis_detections(color_image, depth_colormap, class_col, dets_col, thresh=0.5):\n\n for cls_ind, class_name in enumerate(class_col):\n dets = dets_col[cls_ind]\n\n inds = np.where(dets[:, -1] >= thresh)[0]\n if len(inds) == 0:\n continue\n\n for i in inds:\n bbox = [int(e) for e in dets[i, :4]]\n score = dets[i, -1]\n \n cv2.rectangle(color_image, (bbox[0], bbox[1]),\n (bbox[2], bbox[3]), (0, 0, 255), 3)\n cv2.rectangle(depth_colormap, (bbox[0], bbox[1]),\n (bbox[2], bbox[3]), (0, 0, 255), 3)\n\n font = cv2.FONT_HERSHEY_SIMPLEX\n color_image = cv2.putText(color_image, '{:s} {:.3f}'.format(class_name, score),\n (bbox[0], max(bbox[1] - 2, 1)), font, 0.5, (255, 255, 255), 2)\n depth_colormap = cv2.putText(depth_colormap, '{:s} {:.3f}'.format(class_name, score),\n (bbox[0], max(bbox[1] - 2, 1)), font, 0.5, (255, 255, 255), 2)\n \n # Stack both images horizontally\n images = np.hstack((color_image, depth_colormap))\n\n # Show images\n cv2.imshow('RealSense', images)","def get_classification_simulator(self, image):\n\n r_channel = image[:,:,2]\n g_channel = image[:,:,1]\n\n\n\n # Threshold color channel\n s_rgy_min = 50\n s_thresh_min = 245\n s_thresh_max = 255\n \n #s_binary = np.zeros_like(r_channel)\n r_binary = np.zeros_like(r_channel)\n g_binary = np.zeros_like(r_channel)\n y_binary = np.zeros_like(r_channel)\n \n #s_binary[((r_channel >= s_thresh_min) & (r_channel <= s_thresh_max)) | ((g_channel >= s_thresh_min) & (g_channel <= s_thresh_max))] = 1\n \n \n r_binary[((r_channel >= s_thresh_min) & (r_channel <= s_thresh_max)) & (g_channel <= s_rgy_min)] = 1\n g_binary[((g_channel >= s_thresh_min) & (g_channel <= s_thresh_max)) & (r_channel <= s_rgy_min)] = 1\n y_binary[((r_channel >= s_thresh_min) & (r_channel <= s_thresh_max)) & ((g_channel >= s_thresh_min) & (g_channel <= s_thresh_max))] = 1\n \n\n #res = cv2.bitwise_and(img,img,mask = s_binary)\n \n #maxx=image.shape[1]\n maxy=image.shape[0]\n \n y_top=0\n window_size_y=50\n y_bottom=y_top+window_size_y\n \n max_color=0\n tf_color=TrafficLight.UNKNOWN\n \n while (y_bottom< maxy):\n #print(img[y_top:y_bottom,:,:])\n rs= r_binary[y_top:y_bottom,:].sum()\n gs= g_binary[y_top:y_bottom,:].sum()\n ys= y_binary[y_top:y_bottom,:].sum()\n if (rs>max_color):\n max_color=rs\n tf_color=TrafficLight.RED\n if (gs>max_color):\n max_color=gs\n tf_color=TrafficLight.GREEN\n if (ys>max_color):\n max_color=ys\n tf_color=TrafficLight.YELLOW\n y_top+=window_size_y\n y_bottom+=window_size_y\n \n if (max_color<100):\n tf_color=TrafficLight.UNKNOWN\n \n\n\n return tf_color","def attack_surface_coloring(graph, attack_surface):\n color = []\n\n # takes a two-dimensional list\n # and produces a one-dimensional list\n # so we can check if each node is\n # in the attack surface\n flatten = lambda l: [item for sublist in l for item in sublist]\n flat_attack_surface = flatten(attack_surface)\n\n for node in graph:\n if node in flat_attack_surface:\n color.append('red')\n else:\n color.append('grey')\n return color","def _naive_greedy_modularity_communities(G):\n # First create one community for each node\n communities = list([frozenset([u]) for u in G.nodes()])\n # Track merges\n merges = []\n # Greedily merge communities until no improvement is possible\n old_modularity = None\n new_modularity = modularity(G, communities)\n while old_modularity is None or new_modularity > old_modularity:\n # Save modularity for comparison\n old_modularity = new_modularity\n # Find best pair to merge\n trial_communities = list(communities)\n to_merge = None\n for i, u in enumerate(communities):\n for j, v in enumerate(communities):\n # Skip i=j and empty communities\n if j <= i or len(u) == 0 or len(v) == 0:\n continue\n # Merge communities u and v\n trial_communities[j] = u | v\n trial_communities[i] = frozenset([])\n trial_modularity = modularity(G, trial_communities)\n if trial_modularity >= new_modularity:\n # Check if strictly better or tie\n if trial_modularity > new_modularity:\n # Found new best, save modularity and group indexes\n new_modularity = trial_modularity\n to_merge = (i, j, new_modularity - old_modularity)\n elif (\n to_merge and\n min(i, j) < min(to_merge[0], to_merge[1])\n ):\n # Break ties by choosing pair with lowest min id\n new_modularity = trial_modularity\n to_merge = (i, j, new_modularity - old_modularity)\n # Un-merge\n trial_communities[i] = u\n trial_communities[j] = v\n if to_merge is not None:\n # If the best merge improves modularity, use it\n merges.append(to_merge)\n i, j, dq = to_merge\n u, v = communities[i], communities[j]\n communities[j] = u | v\n communities[i] = frozenset([])\n # Remove empty communities and sort\n communities = [c for c in communities if len(c) > 0]\n for com in sorted(communities, key=lambda x: len(x), reverse=True):\n yield com","def newCluster(color_cluster):\n r = 0\n g = 0\n b = 0\n count = 0\n for cc in color_cluster:\n count += cc[0]\n r += cc[1][0] * cc[0]\n g += cc[1][1] * cc[0]\n b += cc[1][2] * cc[0]\n\n # print(\"r: \" + str(r))\n # print(\"g: \" + str(g))\n # print(\"b: \" + str(b))\n # print(\"count: \" + str(count))\n r_mean = int(r / count)\n g_mean = int(g / count)\n b_mean = int(b / count)\n cluster = (r_mean, g_mean, b_mean)\n # print(cluster)\n return cluster","def network_schematic(clusters, primaries, edges):\n # Define the node positions (primaries on the left, secondaries on the right)\n n = len(clusters)\n pos = np.array([[1.-float(i in primaries), i] for i in range(n)])\n\n # Define the node features (label, size, color)\n node_labels = [str(i) for i in range(n)]\n \n logn = np.array([np.log(len(c)) for c in clusters])\n node_sizes = np.interp(logn, (logn.min(), logn.max()), (5, 50))\n \n node_colors = ['#ff7f0e' if i in primaries else '#1f77b4' for i in range(n)]\n\n # Define the nodes as sphere of radius proportional to the log of the cluster voxel content\n graph_data = []\n graph_data.append(go.Scatter(\n x = pos[:,0],\n y = pos[:,1],\n mode = 'markers',\n name = 'clusters',\n marker = dict(\n color = node_colors,\n size = node_sizes,\n ),\n text = node_labels,\n hoverinfo = 'text'\n ))\n\n # Initialize the edges\n edge_vertices = np.concatenate([[pos[i], pos[j], [None, None]] for i, j in zip(edges[0], edges[1])])\n graph_data.append(go.Scatter(x = edge_vertices[:,0], y = edge_vertices[:,1],\n mode = 'lines',\n name = 'edges',\n line = dict(\n color = 'rgba(50, 50, 50, 0.5)',\n width = 1\n ),\n hoverinfo = 'none'\n ))\n\n return graph_data","def _build_graph_general(self): \n\n #Find a canonical coloring scheme\n #Each node has a color that is determined by the non-mapped aspects\n nodecolors=set()\n for nl in self.net.iter_node_layers():\n nodecolors.add(self._slice_node_layer_not_allowed(nl))\n nodecolors_sorted=sorted(list(nodecolors))\n del nodecolors\n self._assert_full_order(nodecolors_sorted)\n self.colormap=dict( ((color,colorid) for colorid,color in enumerate(nodecolors_sorted) ))\n\n #each aux node has a color that is determined by the aspect\n self.auxcolormap=dict( ((auxcolor, auxcolorid+len(self.colormap)) for auxcolorid,auxcolor in enumerate(sorted(self.asp)) ) )\n\n\n #Add the underlying network\n #node-layers:\n for nl in self.net.iter_node_layers():\n nlid=self._get_node_id(nl)\n color=self._slice_node_layer_not_allowed(nl)\n colorid=self.colormap[color]\n self.add_node(nlid,colorid)\n\n #edges between node-layers:\n for nl1 in self.net.iter_node_layers():\n for nl2 in self.net[nl1]:\n nl1id=self._get_node_id(nl1)\n nl2id=self._get_node_id(nl2)\n self.add_link(nl1id,nl2id)\n\n\n #Add the auxiliary nodes and edges\n #add the aux nodes\n for a in self.asp:\n for elayer in self.net.slices[a]:\n auxid=self._get_auxnode_id( (a,elayer) )\n auxcolorid=self.auxcolormap[a]\n self.add_node(auxid,auxcolorid)\n \n #add the aux edges\n for nl in self.net.iter_node_layers():\n for a in self.asp:\n nlid=self._get_node_id(nl)\n auxid=self._get_auxnode_id( (a,nl[a]) )\n self.add_link(nlid,auxid)","def _naive_greedy_modularity_communities(G):\r\n # First create one community for each node\r\n communities = list([frozenset([u]) for u in G.nodes()])\r\n # Track merges\r\n merges = []\r\n # Greedily merge communities until no improvement is possible\r\n old_modularity = None\r\n new_modularity = modularity(G, communities)\r\n while old_modularity is None or new_modularity > old_modularity:\r\n # Save modularity for comparison\r\n old_modularity = new_modularity\r\n # Find best pair to merge\r\n trial_communities = list(communities)\r\n to_merge = None\r\n for i, u in enumerate(communities):\r\n for j, v in enumerate(communities):\r\n # Skip i=j and empty communities\r\n if j <= i or len(u) == 0 or len(v) == 0:\r\n continue\r\n # Merge communities u and v\r\n trial_communities[j] = u | v\r\n trial_communities[i] = frozenset([])\r\n trial_modularity = modularity(G, trial_communities)\r\n if trial_modularity >= new_modularity:\r\n # Check if strictly better or tie\r\n if trial_modularity > new_modularity:\r\n # Found new best, save modularity and group indexes\r\n new_modularity = trial_modularity\r\n to_merge = (i, j, new_modularity - old_modularity)\r\n elif (\r\n to_merge and\r\n min(i, j) < min(to_merge[0], to_merge[1])\r\n ):\r\n # Break ties by choosing pair with lowest min id\r\n new_modularity = trial_modularity\r\n to_merge = (i, j, new_modularity - old_modularity)\r\n # Un-merge\r\n trial_communities[i] = u\r\n trial_communities[j] = v\r\n if to_merge is not None:\r\n # If the best merge improves modularity, use it\r\n merges.append(to_merge)\r\n i, j, dq = to_merge\r\n u, v = communities[i], communities[j]\r\n communities[j] = u | v\r\n communities[i] = frozenset([])\r\n # Remove empty communities and sort\r\n communities = [c for c in communities if len(c) > 0]\r\n for com in sorted(communities, key=lambda x: len(x), reverse=True):\r\n yield com","def colour_node(instance, reaction_colour='darkgrey', Xc_colour='orange', waste_colour='red', res_colour='limegreen', InPr_colour='lightblue'):\n G, mapping = instance.network()\n\n # relabel\n G = nx.relabel_nodes(G, mapping)\n\n node_dict_mapped = nodes_mapped(instance)\n\n waste, resources, intmed_products = instance.amenities()\n\n colour_map = []\n\n for nd in G:\n # print(\"nd\",nd)\n for nd_label, ammentity in node_dict_mapped.items():\n # print(\"nd_label\",nd_label)\n if nd_label == nd:\n # print(nd, nd_label)\n\n if ammentity == \"r\":\n colour_map.append(reaction_colour)\n\n elif ammentity == \"Xc\":\n colour_map.append(Xc_colour)\n\n elif ammentity == \"w\":\n colour_map.append(waste_colour)\n\n elif ammentity == \"Xr\":\n colour_map.append(res_colour)\n\n elif ammentity == \"InPr\":\n colour_map.append(InPr_colour)\n return colour_map","def demo(sess, net, color_image, depth_colormap):\n\n # Detect all object classes and regress object bounds\n timer = Timer()\n timer.tic()\n scores, boxes = im_detect(sess, net, color_image)\n timer.toc()\n print('Detection took {:.3f}s for {:d} object proposals'.format(timer.total_time, boxes.shape[0]))\n\n # Visualize detections for each class\n CONF_THRESH = 0.7\n NMS_THRESH = 0.3\n dets_col = []\n cls_col = []\n for cls_ind, cls in enumerate(CLASSES[1:]):\n cls_ind += 1 # because we skipped background\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\n cls_scores = scores[:, cls_ind]\n dets = np.hstack((cls_boxes,\n cls_scores[:, np.newaxis])).astype(np.float32)\n keep = nms(dets, NMS_THRESH)\n dets = dets[keep, :]\n dets_col.append(dets)\n cls_col.append(cls)\n\n vis_detections(color_image, depth_colormap, cls_col, dets_col, thresh=CONF_THRESH)\n\n depth_col, bbox_col = calc_histogram(depth_image, cls_col, dets_col, thresh=CONF_THRESH)\n print(\"box depth:\", depth_col[0], \"sucker depth:\", depth_col[1])\n print(\"box bbox:\", bbox_col[0], \"sucker bbox\", bbox_col[1])","def set_colors(graph):\n colors = []\n for n in graph.nodes():\n node = graph.node[n]\n if node['adopter'] == 1:\n colors.append('b')\n else:\n colors.append('r')\n \n return colors","def find_gate_posts(img, display_results=False):\n\n greyscale_image = cv2.cvtColor(img.astype(np.uint8), cv2.COLOR_GRAY2BGR)\n cm_image = cv2.applyColorMap(greyscale_image, cv2.COLORMAP_VIRIDIS)\n\n kernel = np.ones((5, 5), np.uint8)\n\n # cm_image = cv2.erode(cm_image, kernel, iterations=1)\n kernel = np.ones((5, 5), np.uint8)\n cm_image = cv2.dilate(cm_image, kernel, iterations=3)\n kernel = np.ones((4, 4), np.uint8)\n cm_image = cv2.erode(cm_image, kernel, iterations=1)\n\n cm_image = cv2.medianBlur(cm_image, 5) # Removes salt and pepper noise\n\n cm_copy_image = cm_image\n cv2.copyTo(cm_image, cm_copy_image)\n\n mask = mask_sonar_image(cm_image, display_results)\n\n cm_circles = cv2.findContours(mask, cv2.RETR_LIST,\n cv2.CHAIN_APPROX_SIMPLE)[-2]\n\n cm_circles = list(filter(lambda x: (cv2.contourArea(x) > 200\n and cv2.contourArea(x) < 5000),\n cm_circles))\n cm_circles = sorted(cm_circles,\n key=lambda x: (arc_circ(x)),\n reverse=False)\n\n cm_circles = list(filter(lambda x: (cv2.arcLength(x, True)**2/(4\n * math.pi*cv2.contourArea(x)) > 2.5), cm_circles))\n\n if len(cm_circles) < 1:\n print(\"Not enough circles found\")\n return None\n\n filtered_circles = cm_circles[0:1]\n\n circle_positions = []\n for circle in filtered_circles: # find center of circle code\n M = cv2.moments(circle)\n cX = int(M[\"m10\"] / M[\"m00\"])\n cY = int(M[\"m01\"] / M[\"m00\"])\n circle_positions.append((cX, cY, arc_circ(circle), cv2.arcLength(\n circle, True)**2/(4*math.pi*cv2.contourArea(circle))))\n\n if display_results:\n cv2.drawContours(cm_copy_image, filtered_circles, -1, (0, 255, 0), 2)\n cv2.imshow(\"found_gate_posts\", cm_copy_image)\n cv2.waitKey(0)\n\n return circle_positions","def display_in_cytoscape(graph, network_name: str):\n try:\n cy = CyRestClient()\n cytoscape_network = cy.network.create_from_networkx(network=graph, name=network_name, collection=\"Cluster comparison\")\n\n # add the layout\n cy.layout.apply(name='force-directed', network=cytoscape_network)\n\n # add the style\n # Step 6: Create Visual Style as code (or by hand if you prefer)\n comparison_style = cy.style.create('Cluster Comparison')\n\n basic_settings = {\n # You can set default values as key-value pairs.\n 'NODE_FILL_COLOR': '#6AACB8',\n 'NODE_SIZE': 55,\n 'NODE_BORDER_WIDTH': 0,\n 'NODE_LABEL_COLOR': '#555555',\n\n 'EDGE_WIDTH': 2,\n 'EDGE_TRANSPARENCY': 100,\n 'EDGE_STROKE_UNSELECTED_PAINT': '#333333',\n\n 'NETWORK_BACKGROUND_PAINT': '#FFFFFF'\n }\n\n comparison_style.update_defaults(basic_settings)\n\n # Create some mappings\n min_cluster_size = min([graph.node[c][\"size\"] for c in graph.nodes])\n max_cluster_size = max([graph.node[c][\"size\"] for c in graph.nodes])\n cluster_size_to_node_size = StyleUtil.create_slope(min=min_cluster_size, max=max_cluster_size, values=(30, 100))\n comparison_style.create_continuous_mapping(column='size', vp='NODE_SIZE', col_type='Double',\n points=cluster_size_to_node_size)\n\n comparison_style.create_discrete_mapping(column='source', vp=\"NODE_FILL_COLOR\", col_type=\"String\",\n mappings={\"source1\": \"#FC8D62\", \"source2\": \"#A6D854\"})\n comparison_style.create_passthrough_mapping(column='weight', vp=\"EDGE_WIDTH\", col_type=\"Integer\")\n\n # apply the style\n cy.style.apply(style=comparison_style, network=cytoscape_network)\n\n except Exception as e:\n print(\"Please open Cytoscape to display the graph: \" + str(e))","def demo(net, image_name, classes):\n\n # Load pre-computed Selected Search object proposals\n # box_file = os.path.join(cfg.ROOT_DIR, 'data', 'demo',image_name + '_boxes.mat')\n test_mats_path = '/home/tanshen/fast-rcnn/data/kaggle/test_bbox'\n box_file = os.path.join(test_mats_path ,image_name + '_boxes.mat')\n obj_proposals = sio.loadmat(box_file)['boxes']\n\n # Load the demo image\n test_images_path = '/home/tanshen/fast-rcnn/data/kaggle/ImagesTest'\n # im_file = os.path.join(cfg.ROOT_DIR, 'data', 'demo', image_name + '.jpg')\n im_file = os.path.join(test_images_path, image_name + '.jpg')\n im = cv2.imread(im_file)\n\n # Detect all object classes and regress object bounds\n timer = Timer()\n timer.tic()\n scores, boxes = im_detect(net, im, obj_proposals)\n timer.toc()\n # print ('Detection took {:.3f}s for '\n # '{:d} object proposals').format(timer.total_time, boxes.shape[0])\n\n # Visualize detections for each class\n CONF_THRESH = 0\n NMS_THRESH = 0.3\n max_inds = 0\n max_score = 0.0\n for cls in classes:\n cls_ind = CLASSES.index(cls)\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\n cls_scores = scores[:, cls_ind]\n keep = np.where(cls_scores >= CONF_THRESH)[0]\n cls_boxes = cls_boxes[keep, :]\n cls_scores = cls_scores[keep]\n dets = np.hstack((cls_boxes,\n cls_scores[:, np.newaxis])).astype(np.float32)\n keep = nms(dets, NMS_THRESH)\n dets = dets[keep, :]\n # print 'All {} detections with p({} | box) >= {:.1f} in {}'.format(cls, cls,\n # CONF_THRESH, image_name)\n #if get_max!=[]: \n\n [ind,tmp]=get_max(im, cls, dets, thresh=CONF_THRESH)\n #print image_name,cls,tmp\n\n #vis_detections(im, cls, dets, image_name, thresh=CONF_THRESH)\n #print dets[:,-1]\n #print image_name,max_score\n file.writelines([image_name,'\\t',cls,'\\t',str(tmp),'\\n'])\n if(max_score<tmp):\n max_score=tmp\n cls_max=cls\n print image_name,cls_max,max_score","def conservedMetabolismNeofunctionalisedECs(self, majorityPercentageCoreMetabolism = defaultMajorityPercentageCoreMetabolism, majorityPercentageNeofunctionalisation = defaultMajorityPercentageNeofunctionalisation, colour = False):\n conservedMetabolism = self.conservedMetabolism(majorityPercentageCoreMetabolism)\n \n parentNeofunctionalised= self.parentClade.neofunctionalisedECs(majorityPercentageCoreMetabolism, majorityPercentageNeofunctionalisation, colour = False)\n childNeofunctionalised = self.childClade.neofunctionalisedECs(majorityPercentageCoreMetabolism, majorityPercentageNeofunctionalisation, colour = False)\n \n if colour is True:\n parentEdges = parentNeofunctionalised.getEdges()\n childEdges = childNeofunctionalised.getEdges()\n \n graph = conservedMetabolism\n \n Export.addColourAttribute(graph, colour = Export.Colour.GREEN, nodes = False, edges = parentEdges)\n Export.addColourAttribute(graph, colour = Export.Colour.YELLOW, nodes = False, edges = childEdges)\n \n graph.name = 'Conserved metabolism neofunctionalised ECs ' + ' '.join(self.parentNCBInames) + ' -> ' + ' '.join(self.childNCBInames)\n \n return graph\n else:\n parentGraph = conservedMetabolism[0].removeAllECsExcept(parentNeofunctionalised.getECs())\n childGraph = conservedMetabolism[1].removeAllECsExcept(childNeofunctionalised.getECs())\n \n parentGraph.name = 'Conserved metabolism neofunctionalised ECs *' + ' '.join(self.parentNCBInames) + '* -> ' + ' '.join(self.childNCBInames)\n childGraph.name = 'Conserved metabolism neofunctionalised ECs ' + ' '.join(self.parentNCBInames) + ' -> *' + ' '.join(self.childNCBInames) + '*'\n \n return (parentGraph, childGraph)","def get_classification(self, image):\n start_time = time.time()\n # Runs inference on one image on the loaded graph\n with self.inference_graph.as_default():\n # Image is expanded to 4 dims - 1st dim batch size (=1)\n image_4d = np.expand_dims(image, axis=0)\n (boxes, scores, classes, num_det) = self.sess.run([self.d_boxes, self.d_scores, self.d_classes, self.num_d], feed_dict = {self.image_tensor: image_4d})\n\n end_time = time.time()\n\n rospy.logdebug(\"Time for classification: {0}s\".format(end_time - start_time))\n\n # Inference returns a (fixed) total of self.num_d detections - even those with low probabilities\n r_boxes = []\n r_scores = []\n r_classes = []\n idx = 0\n\n # If the highest score is below detection probability, there is no traffic light visible or not clear enough, return unknown\n if scores[0][0] < DETECTION_LIMIT:\n rospy.logdebug(\"No traffic light detected: UNKNOWN\")\n return TrafficLight.UNKNOWN\n\n # Keep all results above probability of DETECTION_LIMIT\n while (scores[0][idx] > DETECTION_LIMIT):\n r_scores.append(scores[0][idx])\n r_boxes.append(boxes[0][idx])\n r_classes.append(classes[0][idx])\n idx+=1\n\n # Classes for red, yellow and green lights\n red = 1\n yellow = 2\n green = 3\n yellow_or_not = False\n\n img_shape = image.shape\n height = img_shape[0]\n width = img_shape[1]\n\n # In simulator mode, feed each detection box to a color detector\n # and return the classification result\n if SIMULATOR_MODE:\n \n rectangles = [] # List of rectangles to cut out regions\n\n # Loops through all boundary boxes with found traffic lights and expands them to full image size (0..1 to 0..image_height and width)\n for idx, box in enumerate(r_boxes):\n box_norm = [int(box[0]*height), int(box[1]*width), int(box[2]*height), int(box[3]*width)]\n rectangles.append(box_norm)\n\n # Loops through all the boundary boxes and detects their dominant light color\n for rect in rectangles:\n crop_image = image[rect[0]:rect[2], rect[1]:rect[3]]\n classification = detect_color(crop_image)\n if classification == red:\n rospy.logdebug(\"Red traffic light detected\")\n return TrafficLight.RED\n elif classification == yellow:\n yellow_or_not = True\n\n if yellow_or_not:\n rospy.logdebug(\"Yellow traffic light detected\")\n return TrafficLight.YELLOW\n else:\n rospy.logdebug(\"Green traffic light detected\")\n return TrafficLight.GREEN\n\n # If not in simulator mode, use the detection result from the FRCNN classifier directly\n else:\n for classification in r_classes:\n if classification == red:\n rospy.logdebug(\"Red traffic light detected\")\n return TrafficLight.RED\n elif classification == yellow:\n yellow_or_not = True\n if yellow_or_not:\n rospy.logdebug(\"Yellow traffic light detected\")\n return TrafficLight.YELLOW\n else:\n rospy.logdebug(\"Green traffic light detected\")\n return TrafficLight.GREEN","def bipartite_color(G):\n color={}\n for n in G: # handle disconnected graphs\n if n in color: continue\n queue=[n] \n color[n]=1 # nodes seen with color (1 or 0)\n while queue:\n v=queue.pop()\n c=1-color[v] # opposite color of node v\n for w in G[v]: \n if w in color: \n if color[w]==color[v]:\n raise networkx.NetworkXError(\"Graph is not bipartite.\")\n else:\n color[w]=c\n queue.append(w)\n return color","def DFS(adj): # adj is the list of vertices in graph G\n\n global cc\n global visited\n\n for v in range(len(adj)): # adjacency list has length == number of nodes\n visited[v] = False\n cc = 1\n\n for v in range(len(adj)):\n if not visited[v]:\n explore(v)\n # increment connected component count after each return from explore()\n cc = cc + 1 # only increment for each unvisited node explored here\n return cc","def get_classification(self, image):\n hsv_image = cv2.cvtColor(image,cv2.COLOR_BGR2HSV)\n red_low = np.array([0, 100, 100],np.uint8)\n red_high = np.array([10, 255, 255],np.uint8) \n red1_low = np.array([160, 100, 100],np.uint8)\n red1_high = np.array([179, 255, 255],np.uint8)\n \n if cv2.countNonZero(cv2.inRange(hsv_image,red_low,red_high))+cv2.countNonZero(cv2.inRange(hsv_image,red1_low,red1_high))>45:\n return TrafficLight.RED\n \n yel_low = np.array([28, 100, 100],np.uint8)\n yel_high = np.array([48, 255, 255],np.uint8)\n if cv2.countNonZero(cv2.inRange(hsv_image, yel_low, yel_high)) > 45:\n return TrafficLight.YELLOW\n \n gr_low = np.array([64, 100, 100],np.uint8)\n gr_high = np.array([100, 255, 255],np.uint8)\n if cv2.countNonZero(cv2.inRange(hsv_image, gr_low, gr_high)) > 45:\n return TrafficLight.GREEN\n \n return TrafficLight.UNKNOWN","def main(G): \n try:\n val_map = {'A': 1.0,\n 'D': 0.5714285714285714,\n 'H': 0.0}\n values = [val_map.get(node, 0.45) for node in G.nodes()]\n edge_colors = 'k'\n \n edge_labels=dict([((u,v,),d['weight'])\n for u,v,d in G.edges(data=True)])\n pos=nx.spring_layout(G) # positions for all nodes \n nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels)\n nx.draw(G,pos, node_color = values, node_size=15,edge_color=edge_colors,edge_cmap=plt.cm.Reds)\n pylab.show()\n\n for ite in range(len(G.nodes())):\n \n Iterations = ite \n SL = SIG.Single_linkage(G, Iterations)\n pos=nx.spring_layout(G) # positions for all nodes\n node_colors = ['b','g','r','y','c','k','m','w']\n for i in range(len(G)):\n node_colors.append('w')\n \n # nodes\n C_list = SL.fit_predict(G)[-1,:]\n for Clust in range(C_list.shape[1]):\n nx.draw_networkx_nodes(G,pos,\n nodelist = list(C_list[0,Clust]),\n node_color=node_colors[Clust],\n node_size=80,\n alpha=0.8)\n \n # edges\n nx.draw_networkx_edges(G,pos,width=1.0,alpha=0.5)\n nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels)\n \n plt.axis('off')\n plt.savefig(\"labels_and_colors.png\") # save as png\n plt.show() # display\n print \"in level :\",ite \n print SL.__str__()\n\n\n except SIG.Single_linkage_Error:\n \n print( \"Got an imput error, please change the input and try it again.\" )","def get_classification(self, image):\n #TODO implement light color prediction\n \n with self.graph.as_default():\n img_expand = np.expand_dims(image, axis=0)\n start = datetime.now() #start = datetime.datetime.now() if import datetime\n (boxes, scores, classes, num_detections) = self.sess.run(\n [self.boxes, self.scores, self.classes, self.num_detections],\n feed_dict={self.image_tensor: img_expand}) \n end = datetime.now() #end = datetime.datetime.now()\n c = end - start\n #rospy.logwarn(\"tl_classifier - Image predicted in: {0} seconds\".format(c.total_seconds()))\n #print(c.total_seconds())\n\n boxes = np.squeeze(boxes)\n scores = np.squeeze(scores)\n classes = np.squeeze(classes).astype(np.int32)\n\n print('tl_classifier - CLASSES: 1=Green, 2=Red, 3=Yellow, 4=Unknown: ', classes[0])\n #print('tl_classifier - SCORES: ', scores[0])\n #print('tl_classifier - TrafficLight.GREEN: ', TrafficLight.GREEN) = 2 CLASSES: 1\n #print('tl_classifier - TrafficLight.RED: ', TrafficLight.RED) = 0 CLASSES: 2\n #print('tl_classifier - TrafficLight.YELLOW: ', TrafficLight.YELLOW) = 1 CLASSES: 3\n #print('tl_classifier - TrafficLight.UNKNOWN: ', TrafficLight.UNKNOWN) = 4 CLASSES: 4\n\n if scores[0] > self.threshold:\n if classes[0] == 1:\n print('GREEN')\n return TrafficLight.GREEN\n elif classes[0] == 2:\n print('RED')\n return TrafficLight.RED\n elif classes[0] == 3:\n print('YELLOW')\n return TrafficLight.YELLOW\n else:\n rospy.logwarn(\"Light: UNKNOWN\")\n\n \n return TrafficLight.UNKNOWN","def nodes(self, irc, msg, args, channel):\n pie = self.instances[irc.network]\n irc.reply([str(x) for x in pie.graphs[channel].nodes.values()])","def neofunctionalisedECs(self, majorityPercentageCoreMetabolism = defaultMajorityPercentageCoreMetabolism, majorityPercentageNeofunctionalisation = defaultMajorityPercentageNeofunctionalisation, colour = False, eValue = defaultEValue, considerOnlyECs = None) -> SubstanceEcGraph:\n # get neofunctionalisations \n neofunctionalisedECs = NeofunctionalisedECs(self._neofunctionalisedEnzymes(majorityPercentageCoreMetabolism, eValue, considerOnlyECs))\n \n # filter core metabolism EC graph\n coreMetabolism = self.coreMetabolism(majorityPercentageCoreMetabolism)\n minimumOrganismsCount = math.ceil(self.organismsCount * (majorityPercentageNeofunctionalisation / 100))\n \n neofunctionalisedMetabolism = neofunctionalisedECs.filterGraph(coreMetabolism, minimumEcDifference = None, minimumOrganismsCount = minimumOrganismsCount)\n \n # colour core metabolism\n if colour is not False:\n \n if colour is True:\n colourToUse = Export.Colour.GREEN\n else:\n colourToUse = colour\n \n neofunctionalisedMetabolismOnly = neofunctionalisedMetabolism\n neofunctionalisedMetabolism = coreMetabolism\n Export.addColourAttribute(neofunctionalisedMetabolism, colourToUse, nodes = False, edges = neofunctionalisedMetabolismOnly.getEdges())\n \n neofunctionalisedMetabolism.name = 'Neofunctionalised core metabolism ' + ' '.join(self.ncbiNames)\n \n return neofunctionalisedMetabolism","def process_graph(self, threshold=None):\r\n\r\n def find_head_end(head_name, descendant, end_op):\r\n # This helper function finds ends of Class Net and Box Net, based on a model type. \r\n # :param head_name: This is a common name that nodes in either Class or Box Nets start with.\r\n # :param descendant: Descendant of head_name, identified by operation (Transpose, MatMul, etc.).\r\n # :param end_op: Operation of a node you would like to get in the end of each Net.\r\n # These end_op nodes bring together prediction data based on type of model.\r\n # The Class Net end node will have shape [batch_size, num_anchors, num_classes],\r\n # and the Box Net end node has the shape [batch_size, num_anchors, 4].\r\n # These end nodes can be be found by searching for all end_op's operation nodes and checking if the node two\r\n # steps above in the graph has a name that begins with one of head_names for Class Net and Box Net respectively.\r\n for node in [node for node in self.graph.nodes if node.op == descendant and head_name in node.name]:\r\n target_node = self.graph.find_descendant_by_op(node, end_op)\r\n log.info(\"Found {} node '{}' as the tip of {}\".format(target_node.op, target_node.name, head_name))\r\n return target_node\r\n\r\n def extract_anchors_tensor(split):\r\n # This will find the anchors that have been hardcoded somewhere within the ONNX graph.\r\n # The function will return a gs.Constant that can be directly used as an input to the NMS plugin.\r\n # The anchor tensor shape will be [1, num_anchors, 4]. Note that '1' is kept as first dim, regardless of\r\n # batch size, as it's not necessary to replicate the anchors for all images in the batch.\r\n\r\n # The anchors are available (one per coordinate) hardcoded as constants within certain box decoder nodes.\r\n # Each of these four constants have shape [1, num_anchors], so some numpy operations are used to expand the\r\n # dims and concatenate them as needed.\r\n\r\n # These constants can be found by starting from the Box Net's split operation , and for each coordinate,\r\n # walking down in the graph until either an Add or specific Mul node is found. The second input on this nodes will\r\n # be the anchor data required.\r\n\r\n # Get Add anchor nodes\r\n def get_anchor_add(output_idx, op):\r\n node = self.graph.find_descendant_by_op(split.o(0, output_idx), op)\r\n assert node\r\n val = np.squeeze(node.inputs[1].values)\r\n return np.expand_dims(val.flatten(), axis=(0, 2))\r\n\r\n # Get Mul anchor nodes\r\n def get_anchor_mul(name, op):\r\n node = [node for node in self.graph.nodes if node.op == op and name == node.name][0]\r\n assert node\r\n val = np.squeeze(node.inputs[1].values)\r\n return np.expand_dims(val.flatten(), axis=(0, 2))\r\n\r\n \r\n anchors_y = get_anchor_add(0, \"Add\")\r\n anchors_x = get_anchor_add(1, \"Add\")\r\n anchors_h = None\r\n anchors_w = None\r\n\r\n # Based on a model type, naming of Mul nodes is slightly different, this will be improved in future to exclude branching.\r\n if \"ssd\" in self.model:\r\n anchors_h = get_anchor_mul(\"StatefulPartitionedCall/Postprocessor/Decode/mul_1\",\"Mul\")\r\n anchors_w = get_anchor_mul(\"StatefulPartitionedCall/Postprocessor/Decode/mul\",\"Mul\")\r\n elif \"faster_rcnn\" in self.model:\r\n anchors_h = get_anchor_mul(\"StatefulPartitionedCall/Decode/mul_1\",\"Mul\")\r\n anchors_w = get_anchor_mul(\"StatefulPartitionedCall/Decode/mul\",\"Mul\") \r\n\r\n batched_anchors = np.concatenate([anchors_y, anchors_x, anchors_h, anchors_w], axis=2)\r\n # Identify num of anchors without repetitions.\r\n num_anchors = int(batched_anchors.shape[1]/self.batch_size)\r\n # Trim total number of anchors in order to not have copies introduced by growing number of batch_size.\r\n anchors = batched_anchors[0:num_anchors,0:num_anchors]\r\n return gs.Constant(name=\"nms/anchors:0\", values=anchors)\r\n\r\n self.infer()\r\n\r\n def first_nms(background_class, score_activation, threshold):\r\n \"\"\"\r\n Updates the graph to replace the NMS op by BatchedNMS_TRT TensorRT plugin node.\r\n :param background_class: Set EfficientNMS_TRT's background_class atribute. \r\n :param score_activation: Set EfficientNMS_TRT's score_activation atribute. \r\n \"\"\"\r\n # Identify Class Net and Box Net head names based on model type.\r\n if self.model == 'ssd_mobilenet_v2_keras':\r\n head_names = ['StatefulPartitionedCall/BoxPredictor/ConvolutionalClassHead_', \r\n 'StatefulPartitionedCall/BoxPredictor/ConvolutionalBoxHead_']\r\n elif (self.model == 'ssd_mobilenet_v1_fpn_keras' or self.model == 'ssd_mobilenet_v2_fpn_keras' or \r\n self.model == 'ssd_resnet50_v1_fpn_keras' or self.model == 'ssd_resnet101_v1_fpn_keras' or \r\n self.model == 'ssd_resnet152_v1_fpn_keras'):\r\n head_names = ['StatefulPartitionedCall/WeightSharedConvolutionalBoxPredictor/WeightSharedConvolutionalClassHead',\r\n 'StatefulPartitionedCall/WeightSharedConvolutionalBoxPredictor/WeightSharedConvolutionalBoxHead']\r\n elif (self.model == 'faster_rcnn_resnet50_keras' or self.model == 'faster_rcnn_resnet101_keras' or \r\n self.model == 'faster_rcnn_resnet152_keras' or self.model == \"faster_rcnn_inception_resnet_v2_keras\"):\r\n head_names = ['StatefulPartitionedCall/FirstStageBoxPredictor/ConvolutionalClassHead_0/ClassPredictor',\r\n 'StatefulPartitionedCall/FirstStageBoxPredictor/ConvolutionalBoxHead_0/BoxEncodingPredictor']\r\n\r\n class_net = None\r\n box_net = None\r\n\r\n # Getting SSD's Class and Box Nets final tensors.\r\n if \"ssd\" in self.model:\r\n # Find the concat node at the end of the class net (multi-scale class predictor).\r\n class_net = find_head_end(head_names[0], \"Transpose\", \"Concat\")\r\n\r\n # SSD's slice operation to adjust third dimension of Class Net's last node tensor (adjusting class values).\r\n slice_start = np.asarray([1], dtype=np.int64)\r\n slice_end = np.asarray([91], dtype=np.int64)\r\n # Second list element but third tensor dimension.\r\n slice_axes = np.asarray([2], dtype=np.int64)\r\n slice_out = self.graph.elt_const_slice(\"Slice\", head_names[0]+\"/slicer\", class_net.outputs[0], slice_start, slice_end, slice_axes)\r\n\r\n # Final Class Net tensor.\r\n class_net_tensor = slice_out[0]\r\n\r\n if self.model == 'ssd_mobilenet_v2_keras':\r\n # Find the squeeze node at the end of the box net (multi-scale localization predictor).\r\n box_net = find_head_end(head_names[1], \"Transpose\", \"Concat\")\r\n box_net_squeeze = self.graph.find_descendant_by_op(box_net, \"Squeeze\")\r\n box_net_output = box_net_squeeze.outputs[0]\r\n\r\n elif (self.model == 'ssd_mobilenet_v1_fpn_keras' or self.model == 'ssd_mobilenet_v2_fpn_keras' or \r\n self.model == 'ssd_resnet50_v1_fpn_keras' or self.model == 'ssd_resnet101_v1_fpn_keras' or \r\n self.model == 'ssd_resnet152_v1_fpn_keras'):\r\n # Find the concat node at the end of the box net (multi-scale localization predictor).\r\n box_net = find_head_end(head_names[1], \"Transpose\", \"Concat\")\r\n box_net_output = box_net.outputs[0]\r\n\r\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale box_net_output in order to get accurate coordinates.\r\n scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\r\n scale_out = self.graph.elt_const(\"Mul\", head_names[1]+\"/scale\", box_net_output, scale_adj)\r\n\r\n # Final Box Net tensor.\r\n box_net_tensor = scale_out[0]\r\n \r\n # Getting Faster R-CNN's 1st Class and Box Nets tensors.\r\n elif \"faster_rcnn\" in self.model:\r\n if (self.model == 'faster_rcnn_resnet50_keras' or self.model == 'faster_rcnn_resnet101_keras' or \r\n self.model == 'faster_rcnn_resnet152_keras' or self.model == \"faster_rcnn_inception_resnet_v2_keras\"):\r\n # Find the softmax node at the end of the class net (multi-scale class predictor).\r\n class_net = find_head_end(head_names[0], \"Transpose\", \"Softmax\")\r\n\r\n # Final Class Net tensor\r\n class_net_tensor = class_net.outputs[0] \r\n\r\n # Find the reshape node at the end of the box net (multi-scale localization predictor).\r\n box_net = find_head_end(head_names[1], \"Transpose\", \"Reshape\")\r\n # Final Box Net tensor.\r\n box_net_output = box_net.outputs[0]\r\n\r\n #Insert a squeeze node\r\n squeeze_node = self.graph.squeeze(head_names[1]+\"/squeeze\", box_net_output)\r\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale box_net_output, in order to get accurate coordinates.\r\n scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\r\n scale_out = self.graph.elt_const(\"Mul\", head_names[1]+\"/scale\", squeeze_node, scale_adj)\r\n\r\n # Final Box Net tensor.\r\n box_net_tensor = scale_out[0]\r\n\r\n\r\n # 3. Find the split node that separates the box net coordinates and feeds them into the box decoder.\r\n box_net_split = self.graph.find_descendant_by_op(box_net, \"Split\")\r\n assert box_net_split and len(box_net_split.outputs) == 4\r\n\r\n # Set score threshold\r\n score_threshold = self.first_stage_nms_score_threshold if threshold is None else threshold\r\n\r\n # NMS Inputs and Attributes\r\n # NMS expects these shapes for its input tensors:\r\n # box_net: [batch_size, number_boxes, 4]\r\n # class_net: [batch_size, number_boxes, number_classes]\r\n # anchors: [1, number_boxes, 4] (if used)\r\n nms_op = None\r\n nms_attrs = None\r\n nms_inputs = None\r\n\r\n # EfficientNMS TensorRT Plugin is suitable for our use case.\r\n # Fusing the decoder will always be faster, so this is the default NMS method supported. In this case,\r\n # three inputs are given to the NMS TensorRT node:\r\n # - The box predictions (from the Box Net node found above)\r\n # - The class predictions (from the Class Net node found above)\r\n # - The default anchor coordinates (from the extracted anchor constants)\r\n # As the original tensors from given model will be used, the NMS code type is set to 1 (Center+Size),\r\n # because this is the internal box coding format used by the network.\r\n anchors_tensor = extract_anchors_tensor(box_net_split)\r\n nms_inputs = [box_net_tensor, class_net_tensor, anchors_tensor]\r\n nms_op = \"EfficientNMS_TRT\"\r\n nms_attrs = {\r\n 'plugin_version': \"1\",\r\n 'background_class': background_class,\r\n 'max_output_boxes': self.first_stage_max_proposals,\r\n 'score_threshold': max(0.01, score_threshold),\r\n 'iou_threshold': self.first_stage_nms_iou_threshold,\r\n 'score_activation': score_activation,\r\n 'box_coding': 1,\r\n }\r\n nms_output_classes_dtype = np.int32\r\n\r\n # NMS Outputs.\r\n nms_output_num_detections = gs.Variable(name=\"num_detections\", dtype=np.int32, shape=[self.batch_size, 1])\r\n nms_output_boxes = gs.Variable(name=\"detection_boxes\", dtype=np.float32,\r\n shape=[self.batch_size, self.first_stage_max_proposals, 4])\r\n nms_output_scores = gs.Variable(name=\"detection_scores\", dtype=np.float32,\r\n shape=[self.batch_size, self.first_stage_max_proposals])\r\n nms_output_classes = gs.Variable(name=\"detection_classes\", dtype=nms_output_classes_dtype,\r\n shape=[self.batch_size, self.first_stage_max_proposals])\r\n\r\n nms_outputs = [nms_output_num_detections, nms_output_boxes, nms_output_scores, nms_output_classes]\r\n\r\n # Create the NMS Plugin node with the selected inputs. \r\n self.graph.plugin(\r\n op=nms_op,\r\n name=\"nms/non_maximum_suppression_first\",\r\n inputs=nms_inputs,\r\n outputs=nms_outputs,\r\n attrs=nms_attrs)\r\n log.info(\"Created NMS plugin '{}' with attributes: {}\".format(nms_op, nms_attrs))\r\n\r\n # If model type is SSD, then you are done with conversion and optimizations.\r\n if \"ssd\" in self.model:\r\n self.graph.outputs = nms_outputs\r\n self.infer()\r\n return None\r\n # If model is Faster R-CNN, then you continue with conversion and optimizations,\r\n # next step is CropAndResize. \r\n elif \"faster_rcnn\" in self.model:\r\n return nms_outputs[1]\r\n\r\n def crop_and_resize(input):\r\n \"\"\"\r\n Updates the graph to replace the cropAndResize op by CropAndResize TensorRT plugin node.\r\n :param input: Input tensor is the output from previous first_nms() step. \r\n \"\"\"\r\n\r\n # Locate the last Relu node of the first backbone (pre 1st NMS). Relu node contains feature maps\r\n # necessary for CropAndResize plugin.\r\n relu_name = \"StatefulPartitionedCall/model/\"\r\n relu_node = [node for node in self.graph.nodes if node.op == \"Relu\" and relu_name in node.name][-1]\r\n\r\n # Before passing 1st NMS's detection boxes (rois) to CropAndResize, we need to clip and normalize them.\r\n # Clipping happens for coordinates that are less than 0 and more than self.height.\r\n # Normalization is just divison of every coordinate by self.height.\r\n clip_min = np.asarray([0], dtype=np.float32)\r\n clip_max = np.asarray([self.height], dtype=np.float32)\r\n clip_out = self.graph.elt_const_clip(\"Clip\", \"FirstNMS/detection_boxes_clipper\", input, clip_min, clip_max)\r\n div_const = np.expand_dims(np.asarray([self.height, self.height, self.height, self.height], dtype=np.float32), axis=(0, 1))\r\n div_out = self.graph.elt_const(\"Div\", \"FirstNMS/detection_boxes_normalizer\", clip_out[0], div_const)\r\n\r\n # Linear transformation to convert box coordinates from (TopLeft, BottomRight) Corner encoding\r\n # to CenterSize encoding.\r\n matmul_const = np.matrix('0.5 0 -1 0; 0 0.5 0 -1; 0.5 0 1 0; 0 0.5 0 1', dtype=np.float32)\r\n matmul_out = self.graph.elt_const(\"MatMul\", \"FirstNMS/detection_boxes_conversion\", div_out[0], matmul_const)\r\n\r\n # Additionally CropAndResizePlugin requires 4th dimension of 1: [N, B, 4, 1], so\r\n # we need to add unsqeeze node to make tensor 4 dimensional. \r\n unsqueeze_node = self.graph.unsqueeze( \"FirstNMS/detection_boxes_unsqueeze\", div_out)\r\n\r\n # CropAndResizePlugin's inputs \r\n feature_maps = relu_node.outputs[0]\r\n rois = unsqueeze_node[0]\r\n\r\n # CropAndResize TensorRT Plugin.\r\n # Two inputs are given to the CropAndResize TensorRT node:\r\n # - The feature_maps (from the Relu node found above): [batch_size, channel_num, height, width]\r\n # - The rois (in other words clipped and normalized detection boxes resulting fromm 1st NMS): [batch_size, featuremap, 4, 1]\r\n cnr_inputs = [feature_maps, rois]\r\n cnr_op = \"CropAndResize\"\r\n cnr_attrs = {\r\n 'crop_width': self.initial_crop_size,\r\n 'crop_height': self.initial_crop_size,\r\n }\r\n\r\n # CropAndResize Outputs.\r\n cnr_pfmap = gs.Variable(name=\"pfmap\", dtype=np.float32,\r\n shape=[self.batch_size, self.first_stage_max_proposals, feature_maps.shape[1], self.initial_crop_size, self.initial_crop_size])\r\n cnr_outputs = [cnr_pfmap]\r\n\r\n # Create the CropandResize Plugin node with the selected inputs. \r\n self.graph.plugin(\r\n op=cnr_op,\r\n name=\"cnr/crop_and_resize\",\r\n inputs=cnr_inputs,\r\n outputs=cnr_outputs,\r\n attrs=cnr_attrs)\r\n log.info(\"Created CropAndResize plugin '{}' with attributes: {}\".format(cnr_op, cnr_attrs))\r\n\r\n # Reshape node that is preparing CropAndResize's pfmap output shape for MaxPool node that comes next,\r\n # after that is 2nd backbone that leads us to final 2nd NMS.\r\n reshape_shape = np.asarray([self.first_stage_max_proposals*self.batch_size, feature_maps.shape[1], self.initial_crop_size, self.initial_crop_size], dtype=np.int64)\r\n reshape_node = self.graph.elt_const(\"Reshape\", \"StatefulPartitionedCall/CropandResize/reshape\", cnr_outputs[0], reshape_shape)\r\n maxpl_name = \"StatefulPartitionedCall/MaxPool2D/MaxPool\"\r\n maxpool_node = [node for node in self.graph.nodes if node.op == \"MaxPool\" and maxpl_name == node.name][0]\r\n maxpool_node.inputs[0] = reshape_node[0]\r\n\r\n # Return linear transformation node, it will be located between 1st and 2nd NMS, \r\n # so we need to pass and connect it to 2nd NMS.\r\n return matmul_out[0]\r\n\r\n def second_nms(input, threshold):\r\n \"\"\"\r\n Updates the graph to replace the 2nd NMS op by BatchedNMS_TRT TensorRT plugin node.\r\n :param input: MatMul node that sits between 1st and 2nd NMS nodes.\r\n \"\"\"\r\n\r\n # Identify Class Net and Box Net head names.\r\n second_head_names = ['StatefulPartitionedCall/mask_rcnn_keras_box_predictor/mask_rcnn_class_head/ClassPredictor_dense',\r\n 'StatefulPartitionedCall/mask_rcnn_keras_box_predictor/mask_rcnn_box_head/BoxEncodingPredictor_dense']\r\n\r\n # Find the softmax node at the end of the 2nd class net (multi-scale class predictor).\r\n second_class_net = find_head_end(second_head_names[0], \"MatMul\", \"Softmax\")\r\n\r\n # Faster R-CNN's slice operation to adjust third dimension of Class Net's last node tensor (adjusting class values).\r\n slice_start = np.asarray([1], dtype=np.int64)\r\n slice_end = np.asarray([91], dtype=np.int64)\r\n # Second list element but third tensor dimension.\r\n slice_axes = np.asarray([2], dtype=np.int64)\r\n slice_out = self.graph.elt_const_slice(\"Slice\", second_head_names[0]+\"/slicer\", second_class_net.outputs[0], slice_start, slice_end, slice_axes)\r\n\r\n # Final Class Net tensor.\r\n second_class_net_tensor = slice_out[0]\r\n \r\n # Find the add node at the end of the box net (multi-scale localization predictor).\r\n second_box_net = find_head_end(second_head_names[1], \"MatMul\", \"Add\")\r\n # Final Box Net tensor.\r\n second_box_net_output = second_box_net.outputs[0]\r\n\r\n # Reshape node that is preparing second_box_net_output's output shape for Mul scaling node that comes next.\r\n reshape_shape_second = np.asarray([self.batch_size, self.first_stage_max_proposals, second_box_net.outputs[0].shape[1]], dtype=np.int64)\r\n reshape_node_second = self.graph.elt_const(\"Reshape\", second_head_names[1]+\"/reshape\", second_box_net_output, reshape_shape_second)\r\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale second_box_net_output, in order to get accurate coordinates.\r\n second_scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\r\n second_scale_out = self.graph.elt_const(\"Mul\", second_head_names[1]+\"/scale_second\", reshape_node_second[0], second_scale_adj)\r\n\r\n # Final Box Net tensor.\r\n second_box_net_tensor = second_scale_out[0]\r\n\r\n # Set score threshold\r\n score_threshold = self.second_score_threshold if threshold is None else threshold\r\n\r\n # NMS Inputs and Attributes\r\n # NMS expects these shapes for its input tensors:\r\n # box_net: [batch_size, number_boxes, 4]\r\n # class_net: [batch_size, number_boxes, number_classes]\r\n # anchors: [1, number_boxes, 4] (if used)\r\n second_nms_op = None\r\n second_nms_attrs = None\r\n second_nms_inputs = None\r\n\r\n # EfficientNMS TensorRT Plugin is suitable for our use case.\r\n # Fusing the decoder will always be faster, so this is the default NMS method supported. In this case,\r\n # three inputs are given to the NMS TensorRT node:\r\n # - The box predictions (from the Box Net node found above)\r\n # - The class predictions (from the Class Net node found above)\r\n # - The default anchor coordinates (from the extracted anchor constants)\r\n # As the original tensors from given model will be used, the NMS code type is set to 1 (Center+Size),\r\n # because this is the internal box coding format used by the network.\r\n second_nms_inputs = [second_box_net_tensor, second_class_net_tensor, input]\r\n second_nms_op = \"EfficientNMS_TRT\"\r\n second_nms_attrs = {\r\n 'plugin_version': \"1\",\r\n 'background_class': -1,\r\n 'max_output_boxes': self.first_stage_max_proposals,\r\n 'score_threshold': max(0.01, score_threshold),\r\n 'iou_threshold': self.second_iou_threshold,\r\n 'score_activation': False,\r\n 'box_coding': 1,\r\n }\r\n second_nms_output_classes_dtype = np.int32\r\n\r\n # NMS Outputs.\r\n second_nms_output_num_detections = gs.Variable(name=\"second_num_detections\", dtype=np.int32, shape=[self.batch_size, 1])\r\n second_nms_output_boxes = gs.Variable(name=\"second_detection_boxes\", dtype=np.float32,\r\n shape=[self.batch_size, self.first_stage_max_proposals, 4])\r\n second_nms_output_scores = gs.Variable(name=\"second_detection_scores\", dtype=np.float32,\r\n shape=[self.batch_size, self.first_stage_max_proposals])\r\n second_nms_output_classes = gs.Variable(name=\"second_detection_classes\", dtype=second_nms_output_classes_dtype,\r\n shape=[self.batch_size, self.first_stage_max_proposals])\r\n\r\n second_nms_outputs = [second_nms_output_num_detections, second_nms_output_boxes, second_nms_output_scores, second_nms_output_classes]\r\n\r\n # Create the NMS Plugin node with the selected inputs. \r\n self.graph.plugin(\r\n op=second_nms_op,\r\n name=\"nms/non_maximum_suppression_second\",\r\n inputs=second_nms_inputs,\r\n outputs=second_nms_outputs,\r\n attrs=second_nms_attrs)\r\n log.info(\"Created NMS plugin '{}' with attributes: {}\".format(second_nms_op, second_nms_attrs))\r\n \r\n # Set graph outputs.\r\n self.graph.outputs = second_nms_outputs\r\n\r\n self.infer()\r\n\r\n # If you model is SSD, you need only one NMS and nothin else.\r\n if \"ssd\" in self.model:\r\n first_nms_output = first_nms(-1, True, threshold)\r\n # If your model is Faster R-CNN, you will need 2 NMS nodes with CropAndResize in between.\r\n elif \"faster_rcnn\" in self.model:\r\n first_nms_output = first_nms(0, False, threshold)\r\n cnr_output = crop_and_resize(first_nms_output)\r\n second_nms(cnr_output, threshold)","def slicem_cluster(self, community_detection, network_from, wt_steps, n_clust, neighbors, top, drop_nodes):\n #TODO: change to prevent cluster on exception\n global scores_update, drop, flat, clusters, G, colors \n \n if len(n_clust) == 0:\n n_clust = None # Cluster at optimum modularity\n else:\n n_clust = int(n_clust)\n \n if len(drop_nodes) > 0:\n try:\n drop = [int(n) for n in drop_nodes.split(',')]\n print('dropping nodes:', drop)\n scores_update = {}\n for pair, score in complete_scores.items():\n if pair[0] in drop or pair[1] in drop:\n next\n else:\n scores_update[pair] = score\n except:\n self.show_drop_list_msg()\n else:\n drop = []\n scores_update = complete_scores\n\n flat, clusters, G = self.create_network(\n community_detection=community_detection, \n wt_steps=wt_steps,\n n_clust=n_clust,\n network_from=network_from, \n neighbors=neighbors, \n top=top\n )\n colors = get_plot_colors(clusters, G)\n print('clusters computed!')","def _extract_codes_on_node(self, layout_info):\n\n codes_on_node = set()\n\n # 1. Set the no. of nodes required for this Run\n # Get the ranks per node for each run\n num_ranks_per_run = {}\n for rank_info in layout_info['cpu']:\n if rank_info is not None:\n run_name = rank_info.split(':')[0]\n rank_id = int(rank_info.split(':')[1])\n if run_name not in list(num_ranks_per_run.keys()):\n num_ranks_per_run[run_name] = set()\n num_ranks_per_run[run_name].add(rank_id)\n\n # set the no. of nodes for the codes on this node\n for code in num_ranks_per_run:\n run = self._get_run_by_name(code)\n run.nodes = math.ceil(run.nprocs/len(num_ranks_per_run[code]))\n\n # 2. Create the node config for each Run\n # Add run to codes_on_node and create nodeconfig for each run\n for run_name in num_ranks_per_run.keys():\n num_ranks_per_node = len(num_ranks_per_run[run_name])\n run = self._get_run_by_name(run_name)\n codes_on_node.add(run)\n run.node_config = NodeConfig()\n run.node_config.num_ranks_per_node = num_ranks_per_node\n for i in range(num_ranks_per_node):\n # Every rank for this run has a list of cpu and gpu cores\n run.node_config.cpu.append([])\n run.node_config.gpu.append([])\n\n # #--------------------------------------------------------------------#\n # # 241. Disable node sharing for Summit due to ERF issue.\n # if self.machine_name.lower() == 'summit':\n # if len(codes_on_node) > 1:\n # raise Exception(\"Node-sharing on Summit temporarily disabled \"\\\n # \"due to a jsrun issue.\")\n # # --------------------------------------------------------------------#\n\n # Loop over the cpu core mapping\n for i in range(len(layout_info['cpu'])):\n rank_info = layout_info['cpu'][i]\n\n # if the core is not mapped, go to the next one\n if rank_info is None:\n continue\n\n run_name = rank_info.split(':')[0]\n rank_id = rank_info.split(':')[1]\n run = self._get_run_by_name(run_name)\n\n # append core id to the rank id of this run\n run.node_config.cpu[int(rank_id)].append(i)\n\n # Loop over the gpu mapping\n for i in range(len(layout_info['gpu'])):\n rank_list = layout_info['gpu'][i]\n if rank_list is not None:\n for rank_info in rank_list:\n run_name = rank_info.split(':')[0]\n rank_id = rank_info.split(':')[1]\n run = self._get_run_by_name(run_name)\n run.node_config.gpu[int(rank_id)].append(i)\n\n return list(codes_on_node)","def findCluster(path, bound_img_path):\r\n image = cv2.imread(path, cv2.IMREAD_COLOR)\r\n img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\r\n blur = cv2.medianBlur(img, 3)\r\n thresh = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]\r\n\r\n # Creating a structuring element to perform morphological operations\r\n k_size = (3, 3)\r\n kernelMorph = cv2.getStructuringElement(cv2.MORPH_RECT, k_size)\r\n\r\n # Performing opening on the image\r\n morph = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernelMorph, iterations=1)\r\n\r\n # Performing dilation on the image\r\n ksizeKernelDilate = (50, 1)\r\n dilated = cv2.dilate(morph, ksizeKernelDilate, iterations= 5)\r\n\r\n # Identifying contours in the image\r\n cnts = cv2.findContours(dilated, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\r\n cnts = cnts[0] if len(cnts) == 2 else cnts[1]\r\n clr1, clr2, clr3 = 225, 255, 0,\r\n b = 10\r\n\r\n bounding_box_created = False\r\n if len(cnts) != 0:\r\n contour_rect_box = []\r\n conimage = []\r\n for c in cnts:\r\n # Identifying bounding box dimensions for each contour\r\n x, y, w, h = cv2.boundingRect(c)\r\n # Enclosing the contours in a rectangle\r\n if (w > 10 and h > 10 and w < img.shape[0] and h < img.shape[1]):\r\n conimage = cv2.rectangle(image, (x - b, y - b), (x - b + w + 2 * b, y - b + h + 2 * b),\r\n (clr1, clr2, clr3), -1)\r\n contour_rect_box.append((x, y, x + w, y + h, w, h))\r\n\r\n # Check whether the bounding box is created or not\r\n # If bounding box is created, then update the image with the identified bounding box,\r\n # Else print no clusters have been identified\r\n if len(conimage) > 0:\r\n cv2.imwrite(bound_img_path, conimage)\r\n bounding_box_created = True\r\n else:\r\n print(\"No clusters identified\")\r\n return cnts, bounding_box_created","def compute_node_dissociation_index(community_vect, sparse_mat):\n dense_mat = sparse_mat.todense()\n undir_dense_mat = dense_mat + np.transpose(dense_mat)\n bin_dense_mat = np.array(undir_dense_mat != 0, dtype=int)\n\n degree_vect = np.array(np.sum(bin_dense_mat != 0, axis=1), dtype='float')\n community_indexes = np.unique(community_vect)\n\n ndi_values = np.ones(\n shape=(community_vect.shape[0]), dtype='float')\n\n for i in range(ndi_values.shape[0]):\n\n \"\"\"\n same_com = np.where(\n np.array([community_vect[i] == community_vect[j] for j in\n range(ndi_values.shape[0])],dtype = \"bool\") == True)\n\n print (same_com[0])\n\n val = 1.0-(np.sum(bin_dense_mat[i,\n same_com[0]])/float(degree_vect[i]))\n \"\"\"\n\n val2 = 0.0\n\n for j in community_indexes:\n if j != -1 and j != community_vect[i]:\n val2 += np.sum(bin_dense_mat[i, community_vect == j])\n\n if degree_vect[i]:\n ndi_values[i] = val2/float(degree_vect[i])\n\n else:\n print(\"Warning, degree is null for node {}\".format(i))\n print(bin_dense_mat)\n\n ndi_values[i] = 0.0\n\n return ndi_values","def get_classification(self, image):\n if self.correct_gamma:\n if self.gamma == 1.0:\n self.gamma = 0.6\n elif self.gamma == 0.6:\n self.gamma = 1.0\n image = self.adjust_gamma(image, self.gamma)\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n image_np = np.asarray(image, dtype=\"uint8\")\n image_np_expanded = np.expand_dims(image_np, axis=0)\n\n detected = False\n\n with self.detection_graph.as_default():\n (boxes, scores, classes, num) = self.sess.run(\n [self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections],\n feed_dict={self.image_tensor: image_np_expanded})\n boxes = np.squeeze(boxes)\n classes = np.squeeze(classes).astype(np.int32)\n scores = np.squeeze(scores)\n best_scores = []\n\n for idx, classID in enumerate(classes):\n if self.MODEL_NAME == 'ssdlite_mobilenet_v2_coco_2018_05_09':\n if classID == 10: # 10 is traffic light\n if scores[idx] > 0.10: #confidence level\n best_scores.append([scores[idx], idx, classID])\n detected = True\n else: # we tuned the model to classify only traffic lights\n if scores[idx] > 0.10: # confidence level\n best_scores.append([scores[idx], idx, classID])\n detected = True\n\n tl_index = TrafficLight.UNKNOWN\n if detected:\n best_scores.sort(key=lambda tup: tup[0], reverse=True)\n\n best_score = best_scores[0]\n rospy.logdebug(\"number of TL found %d, best score: %f, color: %f\", len(best_scores), best_score[0], best_score[2])\n nbox = boxes[best_score[1]]\n\n height = image.shape[0]\n width = image.shape[1]\n\n box = np.array([nbox[0]*height, nbox[1]*width, nbox[2]*height, nbox[3]*width]).astype(int)\n box_height = box[2] - box[0]\n box_width = box[3] - box[1]\n ratio = float(box_height)/float(box_width)\n rospy.logdebug(\"ratio: %f\", ratio)\n if ratio >= 2.0 and ratio < 3.0: #started from 2.4\n tl_cropped = image[box[0]:box[2], box[1]:box[3]]\n tl_color, tl_index = self.get_color(tl_cropped)\n #color = ['RED', 'YELLOW', 'GREEN', 'UNKNOWN']\n #tl_index = best_score[2]\n #tl_color = color[tl_index]\n #augment image with detected TLs\n cv2.rectangle(image, (box[1], box[0]), (box[3], box[2]), (0, 255, 0), 2)\n font = cv2.FONT_HERSHEY_SIMPLEX\n font_color = (255, 255, 255)\n cv2.putText(image, tl_color, (box[1], box[0]), font, 2.0, font_color, lineType=cv2.LINE_AA)\n return image, tl_index","def get_bipartition(g):\n # Write your code here.\n colorArr = [-1] * (len(g.nodes()) + 1)\n for node in g.nodes():\n start = g.neighbors(node)\n if len(start)>0:\n src = start.pop()\n break\n colorArr[src] = 1\n queue = []\n queue.append(src)\n while (queue):\n u = queue.pop()\n for v in g.nodes():\n if g.has_edge(u, v) and colorArr[v] == -1:\n colorArr[v] = 1 - colorArr[u]\n queue.append(v)\n elif g.has_edge(u, v) and colorArr[u] == colorArr[v]:\n return None\n\n red = set()\n for i in range(1, len(colorArr)):\n if colorArr[i] == 1:\n red.add(i)\n return list(red)\n\n\n\n # Hint! If you'd like to test out these commands without\n # writing a full-fledged program, you might want to familiarise\n # yourself with the Python interactive shell or IPython (available\n # on at least some Aalto IT computers)\n\n # Create a simple line graph g: \"(1)->(2)->(3)\"\n # (The creation parameter is a dict of {node: list_of_neighbors},\n # but this is not something you will be needing in your code.)\n # >>> from networkx import Graph \n # >>> g = Graph({1: [2], 2: [3]})\n # >>> g.number_of_nodes()\n # 3\n\n # Example. Iterate over the nodes and mark them as visited\n # >>> visited = set()\n # >>> for node in g.nodes_iter(): # There is also g.nodes(), which returns a list\n # ... # do some work here\n # ... visited.add(node)\n \n # Example. Given a Node v, get all nodes s.t. there is an edge between\n # v and that node\n # >>> g.neighbors(1)\n # [2]\n\n # Example. Get the edges of the graph:\n # >>> e.edges() # as with nodes, there is also g.edges_iter()\n # [(1, 2), (2, 3)]\n\n # For more information, consult the NetworkX documentation:\n # https://networkx.github.io/documentation/networkx-1.10/tutorial/tutorial.html","def get_neighbouring_nodes(node) :\r\n\r\n connected_nodes = [] #A list of the connected nodes\r\n\r\n #Checking if the node belongs to the 1st row\r\n if(node.coords[0] != 0) :\r\n connected_node = Node((node.coords[0] - 1, node.coords[1]), goal_pos, node.gn_value - 1)\r\n #Checking if the node is an obstacle\r\n if(not connected_node.coords in obstacle_coords) :\r\n connected_nodes.append(connected_node)\r\n\r\n #Checking if the node belongs to the last row\r\n if(node.coords[0] != grid_dims[0] - 1) :\r\n connected_node = Node((node.coords[0] + 1, node.coords[1]), goal_pos, node.gn_value - 1)\r\n #Checking if the node is an obstacle\r\n if(not connected_node.coords in obstacle_coords) :\r\n connected_nodes.append(connected_node)\r\n\r\n #Checking if the node belongs to the 1st column\r\n if(node.coords[1] != 0) :\r\n connected_node = Node((node.coords[0], node.coords[1] - 1), goal_pos, node.gn_value - 1)\r\n #Checking if the node is an obstacle\r\n if(not connected_node.coords in obstacle_coords) :\r\n connected_nodes.append(connected_node)\r\n\r\n #Checking if the node belongs to the 1st column\r\n if(node.coords[1] != grid_dims[1] - 1) :\r\n connected_node = Node((node.coords[0], node.coords[1] + 1), goal_pos, node.gn_value - 1)\r\n #Checking if the node is an obstacle\r\n if(not connected_node.coords in obstacle_coords) :\r\n connected_nodes.append(connected_node)\r\n\r\n return connected_nodes","def classifier():\n\tprint(\"Classifying\")\n\t#initialize important variables\n\tminConfidence = 0.5\n\tthresholdValue = 0.3\n\t\n\t\"\"\"\n\tfile = request.files#['image']\n\tfile.save(\"./classifier_image.jpg\")\n\tframe = cv2.imread(\"./classifier_image.jpg\")\n\t\"\"\"\n\tfile = request.json\n\tframe = np.array(file[\"Frame\"], dtype = \"uint8\") \n\n\t#file = request.files['image']\n\t#file.save(\"./classifier_image.jpg\")\n\t#frame = cv2.imread(\"./classifier_image.jpg\")\n\t#file = request.json\n\t#frame = np.array(file[\"contour\"], dtype=\"uint8\")\n\t\n\t#Get Image dimensions\n\timage = cv2.copyMakeBorder(frame, 30, 30, 30, 30, cv2.BORDER_CONSTANT, value=255)\n\t(H, W) = image.shape[:2]\n\t\n\t#Get the output layers parameters\n\tln = net.getLayerNames()\n\tln = [ln[i[0] - 1] for i in net.getUnconnectedOutLayers()]\n\t\n\t#Create a blob to do a forward pass\n\tblob = cv2.dnn.blobFromImage(image, 1 / 255.0, (416, 416), swapRB=True, crop=False)\n\tnet.setInput(blob)\n\t#print(H, W)\n\tlayerOutputs = net.forward(ln)\n\tprint(type(net))\n\tboxes = []\n\tconfidences = []\n\tclassIDs = []\n\tfor output in layerOutputs:\n\t\tprint(\"detecting\")\n\t\t#loop over each detection\n\t\tfor detection in output:\n\t\t\t# extract the class ID and confidence (i.e., probability) of\n\t\t\t# the current object detection\n\t\t\tscores = detection[5:]\n\t\t\tclassID = np.argmax(scores)\n\t\t\tconfidence = scores[classID]\n\n\t\t\t# filter out weak predictions by ensuring the detected\n\t\t\t# probability is greater than the minimum probability\n\t\t\tif confidence > minConfidence:\n\t\t\t\t# scale the bounding box coordinates back relative to the\n\t\t\t\t# size of the image, keeping in mind that YOLO actually\n\t\t\t\t# returns the center (x, y)-coordinates of the bounding\n\t\t\t\t# box followed by the boxes' width and height\n\t\t\t\tbox = detection[0:4] * np.array([W, H, W, H])\n\t\t\t\t(centerX, centerY, width, height) = box.astype(\"int\")\n\n\t\t\t\t# use the center (x, y)-coordinates to derive the top and\n\t\t\t\t# and left corner of the bounding box\n\t\t\t\tx = int(centerX - (width / 2))\n\t\t\t\ty = int(centerY - (height / 2))\n\n\t\t\t\t# update our list of bounding box coordinates, confidences,\n\t\t\t\t# and class IDs\n\t\t\t\tboxes.append([x, y, int(width), int(height)])\n\t\t\t\tconfidences.append(float(confidence))\n\t\t\t\tclassIDs.append(classID)\n\n\t# apply non-maxima suppression to suppress weak, overlapping bounding\n\t# boxes\n\tidxs = cv2.dnn.NMSBoxes(boxes, confidences, minConfidence, thresholdValue)\n\n\t# ensure at least one detection exists\n\tif len(idxs) > 0:\n\t\toutput = json.load(open(outputFile))\n\t\t# loop over the indexes we are keeping\n\t\tfor i in idxs.flatten():\n\t\t\t# extract the bounding box coordinates\n\t\t\t(x, y) = (boxes[i][0], boxes[i][1])\n\t\t\t(w, h) = (boxes[i][2], boxes[i][3])\n\n\t\t\tprint(LABELS[classIDs[i]], output[LABELS[classIDs[i]]]+1, confidences[i])\n\t\t\toutput[LABELS[classIDs[i]]]+=1\n\t\t\n\t\tjson.dump(output, open(outputFile, \"w\"))\n\t\treturn LABELS[classIDs[i]]\n\telse:\n\t\treturn Response(status=200)","def get_shapes(self):\n colours = [[None for j in range(self.cellcounts[0])] for i in range(self.cellcounts[1])]\n X = []\n backmap = {}\n rad = 3\n for k,((i,y),(j,x)) in enumerate(self.mids):\n chunk = self.img[y-rad:y+rad, x-rad:x+rad,:]\n m = np.mean(np.mean(chunk, axis=0), axis=0).astype(np.uint16)\n colours[i][j] = m\n X.append(m)\n backmap[k] = (i,j)\n print(np.shape(X))\n Z = linkage(X, 'ward')\n Q = fcluster(Z, self.thresh, criterion='distance')\n\n closenesses = []\n for k,cls in enumerate(Q):\n i,j = backmap[k]\n closenesses.append( np.sqrt(np.sum( (colours[i][j] - self.ideal_bg)**2) ) )\n minidx = np.argmin(closenesses)\n bgcls = Q[minidx]\n\n blibs = [(255,0,0), (0,255,0), (0,0,255), (255,255,0), (0,255,255), (255,0,255)]\n img4 = self.img2.copy()\n for k,((i,y),(j,x)) in enumerate(self.mids):\n cls = Q[k]\n if cls == bgcls:\n continue\n col = blibs[(cls-1)]\n img4 = cv2.circle(img4, (x,y), 5, col, 2)\n\n write_img(\"./out/test_classes.png\", img4)\n self.classimg = img4\n\n A = np.zeros(shape=self.cellcounts, dtype=np.uint8)\n mx = np.max(Q)\n for k,cls in enumerate(Q):\n if cls == bgcls:\n continue\n\n if cls == mx:\n plotcls = bgcls\n else:\n plotcls = cls\n i,j = backmap[k]\n A[i][j] = plotcls\n\n self.res = A","def get_classification(self, image):\n #TODO implement light color prediction\n max_idx = 4\n with self.detection_graph.as_default():\n with tf.Session(graph=self.detection_graph) as sess:\n # Definite input and output Tensors for detection_graph\n image_tensor = self.detection_graph.get_tensor_by_name('image_tensor:0')\n \n # Each box represents a part of the image where a particular object was detected.\n detection_boxes = self.detection_graph.get_tensor_by_name('detection_boxes:0')\n \n # Each score represent how level of confidence for each of the objects.\n # Score is shown on the result image, together with the class label.\n detection_scores = self.detection_graph.get_tensor_by_name('detection_scores:0')\n detection_classes = self.detection_graph.get_tensor_by_name('detection_classes:0')\n num_detections = self.detection_graph.get_tensor_by_name('num_detections:0')\n # Expand dimensions since the model expects images to have shape: [1, None, None, 3]\n image_np_expanded = np.expand_dims(image, axis=0)\n # Actual detection.\n (boxes, scores, classes, num) = sess.run(\n [detection_boxes, detection_scores, detection_classes, num_detections],\n feed_dict={image_tensor: image_np_expanded})\n\n boxes = np.squeeze(boxes)\n scores = np.squeeze(scores)\n classes = np.squeeze(classes).astype(np.int32)\n min_score_thresh = .50\n # find majority light state\n counter = [0, 0, 0, 0, 0]\n for i in range(boxes.shape[0]):\n if scores is None or scores[i] > min_score_thresh:\n counter[classes[i]] += 1\n for i in range(1, 5):\n if counter[i] > counter[max_idx]:\n max_idx = i\n return self.classmap[max_idx]","def get_classification(self, image):\n #TODO implement light color prediction\n \"\"\" example code\n if result == 0:\n state = TrafficLight.GREEN\n else\n state = TrafficLight.RED\n \"\"\"\n with self.detection_graph.as_default():\n boxes, scores, classes, num_detections = self.sess.run([self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections], feed_dict={self.image_tensor: np.expand_dims(image, axis=0)})\n boxes = np.squeeze(boxes)\n scores = np.squeeze(scores)\n classes = np.squeeze(classes)\n max_score_idx = np.argmax(scores)\n result = classes[max_score_idx]\n if result == 1:\n print('RED Light')\n return TrafficLight.RED\n elif result == 2:\n print('Yellow Light')\n return TrafficLight.YELLOW\n elif result == 3:\n print('Green Light')\n return TrafficLight.GREEN\n return TrafficLight.UNKNOWN","def conservedMetabolismNeofunctionalisedEnzymes(self, majorityPercentageCoreMetabolism = defaultMajorityPercentageCoreMetabolism, colour = False):\n conservedMetabolismEnzymes = self.conservedMetabolismEnzymes(majorityPercentageCoreMetabolism, colour = colour)\n \n parentNeofunctionalised= self.parentClade.neofunctionalisedEnzymes(majorityPercentageCoreMetabolism, colour = False)\n childNeofunctionalised = self.childClade.neofunctionalisedEnzymes(majorityPercentageCoreMetabolism, colour = False)\n \n if colour is True:\n parentEdges = parentNeofunctionalised.getEdges()\n childEdges = childNeofunctionalised.getEdges()\n \n graph = conservedMetabolismEnzymes\n \n Export.addColourAttribute(graph, colour = Export.Colour.GREEN, nodes = False, edges = parentEdges)\n Export.addColourAttribute(graph, colour = Export.Colour.YELLOW, nodes = False, edges = childEdges)\n \n graph.name = 'Conserved metabolism neofunctionalised enzymes ' + ' '.join(self.parentNCBInames) + ' -> ' + ' '.join(self.childNCBInames)\n \n return graph\n else:\n parentGraph = conservedMetabolismEnzymes[0].removeAllEnzymesExcept(parentNeofunctionalised.getEnzymes())\n childGraph = conservedMetabolismEnzymes[1].removeAllEnzymesExcept(childNeofunctionalised.getEnzymes())\n \n parentGraph.name = 'Conserved metabolism neofunctionalised enzymes *' + ' '.join(self.parentNCBInames) + '* -> ' + ' '.join(self.childNCBInames)\n childGraph.name = 'Conserved metabolism neofunctionalised enzymes ' + ' '.join(self.parentNCBInames) + ' -> *' + ' '.join(self.childNCBInames) + '*'\n \n return (parentGraph, childGraph)","def _chinese_whispers(encoding_list, threshold=0.92, iterations=20):\n\n #from face_recognition.api import _face_distance\n from random import shuffle\n import networkx as nx\n # Create graph\n nodes = []\n edges = []\n\n image_paths, encodings = zip(*encoding_list)\n\n if len(encodings) <= 1:\n print (\"No enough encodings to cluster!\")\n return []\n\n for idx, face_encoding_to_check in enumerate(encodings):\n # Adding node of facial encoding\n node_id = idx+1\n\n # Initialize 'cluster' to unique value (cluster of itself)\n node = (node_id, {'cluster': image_paths[idx], 'path': image_paths[idx]})\n nodes.append(node)\n\n # Facial encodings to compare\n if (idx+1) >= len(encodings):\n # Node is last element, don't create edge\n break\n\n compare_encodings = encodings[idx+1:]\n distances = face_distance(compare_encodings, face_encoding_to_check)\n encoding_edges = []\n for i, distance in enumerate(distances):\n if distance > threshold:\n # Add edge if facial match\n edge_id = idx+i+2\n encoding_edges.append((node_id, edge_id, {'weight': distance}))\n\n edges = edges + encoding_edges\n\n G = nx.Graph()\n G.add_nodes_from(nodes)\n G.add_edges_from(edges)\n\n # Iterate\n for _ in range(0, iterations):\n cluster_nodes = G.nodes()\n shuffle(list(cluster_nodes))\n for node in cluster_nodes:\n neighbors = G[node]\n clusters = {}\n\n for ne in neighbors:\n if isinstance(ne, int):\n if G.node[ne]['cluster'] in clusters:\n clusters[G.node[ne]['cluster']] += G[node][ne]['weight']\n else:\n clusters[G.node[ne]['cluster']] = G[node][ne]['weight']\n\n # find the class with the highest edge weight sum\n edge_weight_sum = 0\n max_cluster = 0\n #use the max sum of neighbor weights class as current node's class\n for cluster in clusters:\n if clusters[cluster] > edge_weight_sum:\n edge_weight_sum = clusters[cluster]\n max_cluster = cluster\n\n # set the class of target node to the winning local class\n G.node[node]['cluster'] = max_cluster\n\n clusters = {}\n\n # Prepare cluster output\n for (_, data) in G.node.items():\n cluster = data['cluster']\n path = data['path']\n\n if cluster:\n if cluster not in clusters:\n clusters[cluster] = []\n clusters[cluster].append(path)\n\n # Sort cluster output\n sorted_clusters = sorted(clusters.values(), key=len, reverse=True)\n\n return sorted_clusters","def get_classification(self, image):\n time = 0\n with self.graph.as_default(): \n img_expand = np.expand_dims(image, axis=0)\n start = datetime.datetime.now()\n (boxes, scores, classes, num_detections) = self.sess.run(\n [self.boxes, self.scores, self.classes, self.num_detections],\n feed_dict={self.image_tensor: img_expand})\n end = datetime.datetime.now()\n time = end - start\n\n boxes = np.squeeze(boxes)\n scores = np.squeeze(scores)\n classes = np.squeeze(classes).astype(np.int32)\n\n #print('SCORES: ', scores[0])\n #print('CLASSES: ', classes[0])\n\n if scores[0] > self.threshold:\n if classes[0] == 1:\n print('Traffic Light: *** GREEN ***, Detection Speed: ', time.total_seconds())\n return TrafficLight.GREEN\n elif classes[0] == 2:\n print('Traffic Light: *** RED ***, Detection Speed: ', time.total_seconds())\n return TrafficLight.RED\n elif classes[0] == 3:\n print('Traffic Light: *** YELLOW ***, Detection Speed: ', time.total_seconds())\n return TrafficLight.YELLOW\n\n return TrafficLight.UNKNOWN","def node_colors(self, nodes):\n zmin, zmax = nodes[:, 2].min(), nodes[:, 2].max()\n start_color = np.array(self.background) + 5\n end_color = np.array(self.nodeColor)\n z = (nodes[:, 2] - zmin) / (zmax - zmin)\n # indexing [:, None] is used to explicitly state second axis\n c = (1 - z)[:, None] @ start_color[:, None].T + z[:, None] @ end_color[:, None].T\n self.wireframe_col = c\n # return c","def detect_ground_truth_communities(self, G):\n print(\"Detecting Ground - Truth communities\")\n gt_communities = {frozenset(G.nodes[v]['community']) for v in G}\n return [list(fs) for fs in gt_communities]","def get_graph_attributes(net_G):\r\n # number of nodes\r\n num_of_nodes = net_G.number_of_nodes()\r\n # number of nodes\r\n num_of_edges = net_G.number_of_edges()\r\n # density of net\r\n net_density = nx.density(net_G)\r\n # maximum degree and average degree\r\n nodes_degree = nx.degree(net_G)\r\n maximum_degree = max(nodes_degree, key=itemgetter(1))[0]\r\n average_degree = sum([node[1] for node in nodes_degree])/num_of_nodes\r\n # global clustering coefficient: n - count numbers of paths of length two\r\n nodes_triangles = nx.triangles(net_G)\r\n num_of_triangles = sum(nodes_triangles.values())\r\n pairs_path_length = dict(nx.all_pairs_shortest_path_length(net_G))\r\n n = 0 \r\n for node in pairs_path_length.keys(): \r\n for item in pairs_path_length[node].values():\r\n if item == 2:\r\n n = n + 1\r\n global_clustering_coefficient = (num_of_triangles * 6) / n\r\n # size of giant component\r\n giant_component = max(nx.connected_component_subgraphs(net_G),key=len)\r\n # return number of edges in graph=graph size\r\n size_of_giant = nx.Graph.size(giant_component)\r\n # calculate the average path length of giant component\r\n average_shortest_path_length = nx.average_shortest_path_length(giant_component)\r\n # maximum centrality and average centrality\r\n nodes_centrality = nx.degree_centrality(net_G)\r\n maximum_of_centrality = max(nodes_centrality.values())\r\n average_of_centrality = sum(nodes_centrality.values())/num_of_nodes\r\n # maximum betweenness centrality\r\n nodes_betweenness_centrality = nx.betweenness_centrality(net_G)\r\n maximum_betweenness_centrality = max(nodes_betweenness_centrality.values())\r\n # maximum closeness centrality\r\n nodes_closeness_centrality = nx.closeness_centrality(net_G)\r\n maximum_closeness_centrality = max(nodes_closeness_centrality.values())\r\n average_closeness_centrality = sum(nodes_closeness_centrality.values())/num_of_nodes\r\n # summarize graph attributes\r\n graph_attributes = [[\"Number of nodes:\", num_of_nodes], \\\r\n [\"Number of edges:\", num_of_edges], \\\r\n [\"Global clustering coefficient:\", global_clustering_coefficient], \\\r\n [\"Maximum degree:\", maximum_degree], \\\r\n [\"Average degree:\", average_degree], \\\r\n [\"Size of giant component:\", size_of_giant], \\\r\n [\"Average path length:\", average_shortest_path_length],\\\r\n [\"Maximum centrality:\", maximum_of_centrality], \\\r\n [\"Average centrality:\", average_of_centrality],\\\r\n [\"Maximum betweenness centrality:\", maximum_betweenness_centrality],\\\r\n [\"Maximum closeness centrality:\", maximum_closeness_centrality], \\\r\n [\"Average closeness centrality:\", average_closeness_centrality], \\\r\n [\"Net density:\", net_density]]\r\n return graph_attributes","def _greedy_color(self, source):\n for target in self.graph.iteradjacent(source):\n if self.color[target] is not None:\n self._color_list[self.color[target]] = True\n for c in xrange(self.graph.v()): # check colors\n if not self._color_list[c]:\n self.color[source] = c\n break\n for target in self.graph.iteradjacent(source):\n if self.color[target] is not None:\n self._color_list[self.color[target]] = False\n return c","def get_communities(browser: RoboBrowser, desired_communities: list):\n browser.open(URL_BASE + '/info/profil/meinetipprunden')\n content = get_kicktipp_content(browser)\n links = content.find_all('a')\n def gethreftext(link): return link.get('href').replace(\"/\", \"\")\n\n def is_community(link):\n hreftext = gethreftext(link)\n if hreftext == link.get_text():\n return True\n else:\n linkdiv = link.find('div', {'class': \"menu-title-mit-tippglocke\"})\n return linkdiv and linkdiv.get_text() == hreftext\n community_list = [gethreftext(link)\n for link in links if is_community(link)]\n if len(desired_communities) > 0:\n return intersection(community_list, desired_communities)\n return community_list","def infomap_communities(G):\n name_map = {}\n name_map_inverted = {}\n for n in G.nodes():\n id_ = hash(n) % 100000\n name_map_inverted[id_] = n\n name_map[n] = id_\n \n infomapSimple = infomap.Infomap(\"--two-level\")\n network = infomapSimple.network()\n \n for n1, n2, data in G.edges(data=True):\n network.addLink(name_map[n1], name_map[n2], data['weight'] if 'weight' in data else 1)\n\n infomapSimple.run()\n\n return dict(\n (name_map_inverted[node.physicalId], node.moduleIndex())\n for node in infomapSimple.iterTree()\n if node.isLeaf()\n )","def sixteen_graphs(the_dir):\n # TODO change to deprecation warning\n warnings.warn(\"Does not call sv_pipeline functoins correctly\", DeprecationWarning)\n\n plb.rcParams['figure.figsize'] = 30, 30\n plt.clf()\n plt.figure(1)\n\n # should look like: read_data/all_files/chr4_124,017,492_124,029,032_merged.txt\n merged_files = glob.glob(the_dir + '*merged.txt')\n print(\"Running for {} regions\".format(len(merged_files)))\n for merged_filename in merged_files:\n # get filenames\n prefix = merged_filename[len(the_dir):-11]\n fasta_filename = the_dir + prefix + \".fa\"\n bed_filename = the_dir + prefix + \"-refcoords.bed\"\n print('Using ' + prefix)\n\n for min_matching_length in range(100, 1700, 100):\n print(min_matching_length)\n # used for ground truth\n preset, postset, spanset, gapset = get_read_classifications(prefix,\\\n bed_filename, merged_filename=merged_filename)\n # Generate and prune graph\n graph = generate_graph(prefix, fasta_filename, min_matching_length)\n graph = nx_helpers.remove_nodes(graph, preset)\n graph = nx_helpers.remove_nodes(graph, postset)\n\n # Plot the graph\n plt.subplot(4, 4, min_matching_length/100)\n communities = nx_helpers.get_communities(graph)\n graph, communities = drop_small_communities(graph, communities)\n node_colors = node_community_colors(graph, communities)\n pos = nx.spring_layout(graph)\n title = \"Chr {0};\\n L={1}; NumCom={2}\\nComQual = {3}, MapQual={4}\"\\\n .format(prefix, min_matching_length, len(communities),\\\n community_quality(communities, spanset, gapset),\\\n mapping_quality(graph, spanset, gapset))\n nx.draw(graph, node_color=node_colors, node_size=100, pos=pos)\n plt.title(title)\n plt.savefig(\"figs/\" + prefix + '-16-communities.pdf')\n plt.clf()","def find_colours(self, img, colour, num_objects=1, ab_dist_thresh=50):\n img_lab = cv2.cvtColor(img,cv2.COLOR_BGR2LAB) #convert to LAB colour space \n img_a = img_lab[:,:,1] #A compononent of image\n img_b = img_lab[:,:,2] #B compononent of image \n des_a = colour[1] #A component of desired colour\n des_b = colour[2] #B component of desired colour\n \n #Compute difference between desired components and actual components\n d_a = img_a - des_a\n d_b = img_b - des_b\n dist_squared = d_a**2 + d_b**2\n \n #Apply threshold\n img_bin = np.uint8(dist_squared<ab_dist_thresh)*255\n \n #do connected components analysis to find centroids of large connected objects\n conn_comp = cv2.connectedComponentsWithStats(img_bin, 8, cv2.CV_32S)\n\n #sort by area, from largest to smallest\n areas = np.int_(conn_comp[2][:,4])\n idx = areas.argsort()\n idx = idx[::-1]\n centroids = np.int_(conn_comp[3])\n centroids = centroids[idx[1:num_objects+1]]\n \n #if more than one object returned, order from left to right\n idx = centroids[:,0].argsort() #sort by x value\n centroids = list(centroids[idx])\n \n #return centroid position and binary image of detected objects\n if len(centroids) == 1:\n return centroids[0], img_bin\n else:\n return centroids, img_bin","def yolo_detection(raw_image):\n class_ids = []\n confidences = []\n boxes = []\n height , width ,c= raw_image.shape\n blob = cv2.dnn.blobFromImage(raw_image, 0.00392, (416,416), (0,0,0), True, crop=False)\n net.setInput(blob)\n outs = net.forward(output_layers)\n\n for out in outs:\n for detection in out:\n scores = detection[5:]\n class_id = np.argmax(scores)\n confidence = scores[class_id]\n if confidence > 0.4:\n center_x = int(detection[0]*width)\n center_y = int(detection[1]*height)\n w = int(detection[2]*width)\n h = int(detection[3]*height)\n ##Rectangle Draw\n topleft_x = int(center_x-(w/2))\n topleft_y = int(center_y-(h/2))\n\n boxes.append([topleft_x,topleft_y,w,h])\n confidences.append(float(confidence))\n class_ids.append(class_id)\n indexes = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)\n #DISPLAY DETECTION\n total_detections = len(boxes)\n for i in range(total_detections):\n if i in indexes:\n topleft_x, topleft_y, w,h = boxes[i]\n label = detection_classes[class_ids[i]]\n cv2.rectangle(raw_image, (topleft_x,topleft_y), (topleft_x+w,topleft_y+h), (0,100,255), 1)\n cv2.putText(raw_image, label, (topleft_x, topleft_y),cv2.FONT_HERSHEY_COMPLEX,1,(0,165,255))\n\n\n return raw_image","def community_layout(g, partition):\n\n pos_communities = _position_communities(g, partition, scale=3.)\n\n pos_nodes = _position_nodes(g, partition, scale=1.)\n\n # combine positions\n pos = dict()\n for node in g.nodes():\n pos[node] = pos_communities[node] + pos_nodes[node]\n\n return pos"],"string":"[\n \"def community_detection(net_G):\\r\\n if list(nx.isolates(net_G)) == []:\\r\\n part = community.best_partition(net_G)\\r\\n #values = [part.get(node) for node in net_G.nodes()]\\r\\n #nx.draw_spring(net_G, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=False)\\r\\n #plt.show()\\r\\n else:\\r\\n net_G = net_G.copy()\\r\\n net_G.remove_nodes_from(list(nx.isolates(net_G)))\\r\\n part = community.best_partition(net_G)\\r\\n list_nodes = []\\r\\n for com in set(part.values()):\\r\\n list_nodes.append([nodes for nodes in part.keys() if part[nodes] == com])\\r\\n num_of_communities = len(list_nodes)\\r\\n partition_performance = nx.algorithms.community.quality.performance(net_G, list_nodes)\\r\\n net_communities = [[\\\"Numbers of communities:\\\", num_of_communities], \\\\\\r\\n [\\\"Partition performance:\\\", partition_performance]]\\r\\n return net_communities\",\n \"def _community_detection(self, kg: KG) -> None:\\n nx_graph = nx.Graph()\\n\\n for vertex in kg._vertices:\\n if not vertex.predicate:\\n nx_graph.add_node(str(vertex), vertex=vertex)\\n\\n for vertex in kg._vertices:\\n if not vertex.predicate:\\n # Neighbors are predicates\\n for pred in kg.get_neighbors(vertex):\\n for obj in kg.get_neighbors(pred):\\n nx_graph.add_edge(\\n str(vertex), str(obj), name=str(pred)\\n )\\n\\n # Create a dictionary that maps the URI on a community\\n partition = community.best_partition(\\n nx_graph, resolution=self.resolution\\n )\\n self.labels_per_community = defaultdict(list)\\n\\n self.communities = {}\\n vertices = nx.get_node_attributes(nx_graph, \\\"vertex\\\")\\n for node in partition:\\n if node in vertices:\\n self.communities[vertices[node]] = partition[node]\\n\\n for node in self.communities:\\n self.labels_per_community[self.communities[node]].append(node)\",\n \"def create_network(self, community_detection, wt_steps, n_clust, network_from, neighbors, top):\\n \\n if network_from == 'top_n':\\n sort_by_scores = []\\n\\n for pair, score in scores_update.items():\\n sort_by_scores.append([pair[0], pair[1], score[2]])\\n top_n = sorted(sort_by_scores, reverse=False, key=lambda x: x[2])[:top]\\n\\n # Convert from distance to similarity for edge\\n for score in top_n: \\n c = 1/(1 + score[2])\\n score[2] = c\\n\\n flat = [tuple(pair) for pair in top_n]\\n\\n elif network_from == 'knn': \\n flat = []\\n projection_knn = nearest_neighbors(neighbors=neighbors)\\n\\n for projection, knn in projection_knn.items():\\n for n in knn:\\n flat.append((projection, n[0], abs(n[3]))) # p1, p2, score\\n\\n clusters = {}\\n g = Graph.TupleList(flat, weights=True)\\n\\n if community_detection == 'walktrap':\\n try:\\n wt = Graph.community_walktrap(g, weights='weight', steps=wt_steps)\\n cluster_dendrogram = wt.as_clustering(n_clust)\\n except:\\n self.show_cluster_fail()\\n elif community_detection == 'betweenness':\\n try:\\n ebs = Graph.community_edge_betweenness(g, weights='weight', directed=True)\\n cluster_dendrogram = ebs.as_clustering(n_clust)\\n except:\\n self.show_cluster_fail()\\n\\n for community, projection in enumerate(cluster_dendrogram.subgraphs()):\\n clusters[community] = projection.vs['name']\\n\\n #convert node IDs back to ints\\n for cluster, nodes in clusters.items():\\n clusters[cluster] = sorted([int(node) for node in nodes])\\n \\n remove_outliers(clusters)\\n\\n clustered = []\\n for cluster, nodes in clusters.items():\\n for n in nodes:\\n clustered.append(n)\\n\\n clusters['singles'] = [] # Add singles to clusters if not in top n scores\\n clusters['removed'] = []\\n \\n for node in projection_2D:\\n if node not in clustered and node not in drop:\\n clusters['singles'].append(node)\\n elif node in drop:\\n clusters['removed'].append(node)\\n \\n G = nx.Graph()\\n\\n for pair in flat:\\n G.add_edge(int(pair[0]), int(pair[1]), weight=pair[2])\\n\\n #if you want to see directionality in the networkx plot\\n #G = nx.MultiDiGraph(G)\\n\\n #adds singles if not in top n scores\\n for node_key in projection_2D:\\n if node_key not in G.nodes:\\n G.add_node(node_key)\\n\\n return flat, clusters, G\",\n \"def detection_algorithm(G, edge_weight):\\n Gc = G.copy()\\n set_node_attributes(Gc, attr_name='k-index')\\n seed_node2communities = {}\\n\\n from operator import itemgetter\\n while Gc.number_of_nodes() > 0:\\n seed_node = max(list(Gc.nodes(data='k-index')), key=itemgetter(1))[0]\\n nodes_in_community, modularity = find_local_community(Gc, seed_node=seed_node, weight=edge_weight)\\n seed_node2communities[seed_node] = (nodes_in_community, modularity)\\n Gc.remove_nodes_from(nodes_in_community)\\n return seed_node2communities\",\n \"def greedy_coloring(*args):\\r\\n # get arguments\\r\\n G = args[0]\\r\\n n = G.nodes()\\r\\n m = G.arcs()\\r\\n \\r\\n # check if it a valid Graph\\r\\n if not G.is_correct_type('u'):\\r\\n print \\\"ERROR: the graph is not in one of the valid formats for greedy_coloring()\\\"\\r\\n return [], []\\r\\n \\r\\n # calculate degrees of each node (set as rows per node)\\r\\n a_nodes = zeros((n,n), int)\\r\\n for arc in range(m):\\r\\n i = G.A[arc,0] # tail of the arc\\r\\n j = G.A[arc,1] # head of the arc\\r\\n a_nodes[i-1,j-1] = 1\\r\\n a_nodes[j-1,i-1] = 1\\r\\n # get degree and add the node number\\r\\n degree = sum(a_nodes,0)\\r\\n degree = vstack((degree, array(range(n), int) + 1))\\r\\n \\r\\n # initialize coloring vector\\r\\n coloring = zeros(n, int)\\r\\n color_step = 1\\r\\n \\r\\n # if there are any nodes of degree 0 color them first\\r\\n while min(degree[0,:]) == 0:\\r\\n n_i = argmin(degree[0,:]) # get node with zero\\r\\n i = degree[1,n_i]\\r\\n # eliminate the node column from the list and matrix\\r\\n degree = delete(degree, s_[n_i], axis=1)\\r\\n a_nodes = delete(a_nodes, s_[n_i], axis=1)\\r\\n # color it\\r\\n coloring[i-1] = color_step\\r\\n \\r\\n # iterate till all nodes have a color\\r\\n while size(degree) > 0:\\r\\n n_i = argmax(degree[0,:]) # get node with largest degree\\r\\n i = degree[1,n_i]\\r\\n # eliminate the node column from the list and matrix\\r\\n degree = delete(degree, s_[n_i], axis=1)\\r\\n a_nodes = delete(a_nodes, s_[n_i], axis=1)\\r\\n \\r\\n # color it\\r\\n coloring[i-1] = color_step\\r\\n \\r\\n # color the rest of the possible nodes\\r\\n possible = 1 - array(a_nodes[i-1,:]) # transforms 0 in 1, and 1 in 0\\r\\n # iterate while there are possible nodes available\\r\\n while sum(possible) > 0:\\r\\n # get the node with largest degree among possible ones\\r\\n n_j = argmax(degree[0,:] * possible)\\r\\n j = degree[1,n_j]\\r\\n # eliminate the node column from the list and matrix\\r\\n degree = delete(degree, s_[n_j], axis=1)\\r\\n a_nodes = delete(a_nodes, s_[n_j], axis=1)\\r\\n possible = delete(possible, n_j)\\r\\n \\r\\n # color it\\r\\n coloring[j-1] = color_step\\r\\n # eliminate adjacent nodes of j from possible nodes\\r\\n possible = possible * (1 - a_nodes[j-1,:])\\r\\n \\r\\n # update color\\r\\n color_step += 1\\r\\n \\r\\n col_number = max(coloring) # approx chromatic number\\r\\n \\r\\n return coloring, col_number\",\n \"def find_local_community(G, seed_node, weight, debug_log=False):\\n nodes_in_community = seed_node if isinstance(seed_node, list) else [seed_node]\\n modularity = edge_modularity(G, nodes_in_community=nodes_in_community, weight=weight)\\n neighbor_edges = get_neighbor_edges(G, nodes_in_community=nodes_in_community)\\n if debug_log:\\n print('==========\\\\nInitial community has nodes:', nodes_in_community)\\n print('Neighbor edges:', neighbor_edges)\\n print('Modularity = %f' % modularity)\\n while neighbor_edges:\\n # Compute the edge_modularity for each neighbor edge,\\n # suppose the neighbor edge is added to the community\\n mod_max, c_max, e_max = 0, None, None\\n for e in neighbor_edges:\\n # edges in the current community\\n edges_in_temp_community = list(G.subgraph(nodes_in_community).edges)\\n # append the candidate edge\\n edges_in_temp_community.append(e)\\n nodes_in_temp_community = list(G.edge_subgraph(edges_in_temp_community).nodes)\\n mod_temp = edge_modularity(G, nodes_in_community=nodes_in_temp_community, weight=weight)\\n if mod_temp > mod_max:\\n mod_max, c_max, e_max = mod_temp, nodes_in_temp_community, e\\n if mod_max > modularity:\\n if debug_log:\\n print('==========\\\\nEdge', e_max, 'and node', set(e_max).difference(nodes_in_community), 'are added to the community')\\n\\n # Update the community and the corresponding neighbor edges\\n nodes_in_community = c_max\\n modularity = mod_max\\n neighbor_edges = get_neighbor_edges(G, nodes_in_community=nodes_in_community)\\n\\n if debug_log:\\n print('The community has nodes:', nodes_in_community)\\n print('Modularity = %f' % mod_max)\\n print('Neighbor edges:', neighbor_edges)\\n else:\\n break\\n return nodes_in_community, modularity\",\n \"def communityGraph(graph):\\n\\n lapgr = nx.laplacian_matrix(graph)\\n\\n # Get the eigenvalues and eigenvectors of the Laplacian matrix\\n evals, evec = np.linalg.eigh(lapgr.todense())\\n\\n fiedler = evec[1]\\n results = []\\n ## \\\"Fiedler\\\", fiedler\\n median = np.median(fiedler, axis=1) # median of the second eigenvalue\\n for i in range(0, fiedler.size): # divide the graph nodes into two\\n if(fiedler[0, i] < median):\\n results.append(0)\\n else:\\n results.append(1)\\n return results, evals, evec\",\n \"def _generate_graph(self) -> None:\\n self.g_ = nx.random_partition_graph(list(self._community_sizes),\\n p_in=self.community_p_in,\\n p_out=self.community_p_out,\\n seed=self.seed)\\n\\n for _, nv in self.g_.nodes.data():\\n nv[\\\"infected\\\"] = 0\\n nv[\\\"immune\\\"] = False\\n nv[\\\"alive\\\"] = True\\n nv[\\\"_edges\\\"] = []\\n nv[\\\"isolated\\\"] = False\\n nv[\\\"mask\\\"] = 0.0\",\n \"def assign_communities(graph):\\n communities = nx.algorithms.community\\\\\\n .greedy_modularity_communities(nx.Graph(graph))\\n for node in graph.nodes:\\n graph.nodes[node]['community'] = [i for i,c in enumerate(communities)\\n if node in c][0]\\n graph.graph['modularity'] = nx.algorithms.community.quality\\\\\\n .modularity(nx.Graph(graph),\\n communities)\",\n \"def which_color(node):\\n for i, com in enumerate(communities):\\n if node in com:\\n return colors[i]\\n return nx_helpers.rgb_to_hex((0, 0, 0))\",\n \"def neato_graph_from_corpus( corpus, max_nodes ) :\\n\\n O, row_dois, column_dois = cites_matrix( corpus )\\n neato_cooccurrence_graph( O, column_dois )\\n return None\\n\\n \\n v = total_occurrences( O ) \\n nv = v.astype( float32 ) / v.max()\\n C = cooccurrence_matrix ( O )\\n nC = normalized_cooccurrence_matrix( O )\\n\\n # now find our cutoff!\\n # find the max number of cocites and start there\\n cocite_cutoff = C.max()\\n num_nodes = nodes_from_c( C[C >= cocite_cutoff] )\\n # then reduce the number until we exceed max_nodes\\n while num_nodes < max_nodes :\\n cocite_cutoff = cocite_cutoff - 1\\n num_nodes = nodes_from_c( C[C >= cocite_cutoff] )\\n\\n if num_nodes > max_nodes :\\n cocite_cutoff = cocite_cutoff + 1\\n \\n C = C.copy()\\n C[ C < cocite_cutoff ]= 0\\n\\n graph = pydot.Dot( graph_type = 'graph' )\\n graph.set_overlap(\\\"false\\\")\\n coords = zip(*(C >= cocite_cutoff).nonzero())\\n\\n # make a dict of all nodes which are mentioned in the coords\\n nodes = {}\\n index = 1\\n for coord in set(chain.from_iterable(coords)) :\\n if not nodes.has_key( coord ) :\\n node = pydot.Node( str(coord) )\\n if v != None :\\n doi = column_dois[coord]\\n node.set_label( str(index) )\\n node.set_penwidth( nv[ coord ] )\\n node.set_fixedsize(\\\"true\\\")\\n node.set_width( 1.0 *nv[ coord ] )\\n #node.set_shape(\\\"circle\\\")\\n nodes[ coord ] = node\\n graph.add_node( node )\\n index = index + 1\\n\\n for coord in coords :\\n \\n edge = pydot.Edge( nodes[coord[0]], nodes[coord[1]] )\\n edge.set_weight( nC[coord] )\\n edge.set_penwidth( nC[coord]*5 )\\n #edge.set_label( str(int(m[coord]) ))\\n graph.add_edge(edge)\\n\\n \\n legend = pydot.Node( \\\"legend\\\" )\\n nodelist = nodes.items()\\n nodelist.sort( lambda a,b : cmp(node_index(a[1].get_label()),node_index(b[1].get_label())) )\\n legend.set_label( \\\"\\\\l\\\".join([x[1].get_label()+\\\":\\\"+column_dois[x[0]] for x in nodelist])+\\\"\\\\l\\\" )\\n legend.set_shape(\\\"box\\\")\\n graph.add_node(legend)\\n\\n print graph.to_string()\\n #graph.write_dot('test.dot', prog='neato' )\\n #graph.write_png('test.png', prog='neato' )\\n #graph.write_pdf('test.pdf', prog='neato' )\",\n \"def cluster_connectivity(G, weight='weight'):\\n\\t# 1) indexing the edges by community\\n\\tsum_edges_dic = { com : {} for com in range(G.nb_communities)}\\n\\tfor node1, node2 in G.edges():\\n\\t\\tcomm1 = G.nodes[node1]['community']\\n\\t\\tcomm2 = G.nodes[node2]['community']\\n\\t\\tif comm2 not in sum_edges_dic[comm1]:\\n\\t\\t\\tsum_edges_dic[comm1][comm2] = 0\\n\\t\\t\\tsum_edges_dic[comm2][comm1] = 0\\n\\t\\telse:\\n\\t\\t\\tif weight is None:\\n\\t\\t\\t\\tsum_edges_dic[comm1][comm2] += 1\\n\\t\\t\\t\\tsum_edges_dic[comm2][comm1] += 1\\n\\t\\t\\telse:\\t\\n\\t\\t\\t\\tsum_edges_dic[comm1][comm2] += G.edges[node1, node2][weight]\\n\\t\\t\\t\\tsum_edges_dic[comm2][comm1] += G.edges[node1, node2][weight]\\n\\tc_connectivity = {}\\n\\t# 2) computing the connectivity\\n\\tfor com in sum_edges_dic:\\n\\t\\tin_out_edges = sum(sum_edges_dic[com].values())\\n\\t\\tc_connectivity[com] = round(- np.log2(sum_edges_dic[com][com] / in_out_edges),3) \\n\\treturn c_connectivity\",\n \"def detect_community(network_path, network_name, output_path):\\n net = network.network()\\n net.from_file(network_path)\\n output_prefix = output_path + '/{}_recursive_Louvain_{}_{}'.format(network_name, len(net.nodes), len(net.edges))\\n logging.info('{} network: {} nodes and {} edges were loaded.'.format(network_name, len(net.nodes), len(net.edges)))\\n if os.path.isfile(output_prefix + '.gmt'):\\n logging.info('Communities have been detected.')\\n else:\\n rl = RecursiveLouvain()\\n rl.fit(net)\\n comms = rl.community\\n hierarchy = rl.hierarchy\\n os.makedirs(output_path, exist_ok=True)\\n commToGmt(comms, output_prefix)\\n output_hierarchy(hierarchy, output_prefix)\\n logging.info('{} communities were detected.'.format(len(comms)))\\n logging.info('Community file was saved as {}.gmt'.format(output_prefix))\\n return '{}.gmt'.format(output_prefix)\",\n \"def find_and_print_network_communities(G, code_dict=None):\\n\\n comm_dict = partition(G)\\n\\n comm_members = {}\\n for comm in set(comm_dict.values()):\\n countries = [node for node in comm_dict if comm_dict[node] == comm]\\n if code_dict is not None:\\n countries = [code_dict[code] for code in countries]\\n\\n comm_members[comm] = countries\\n\\n return comm_members, get_modularity(G, comm_dict)\",\n \"def run_connected_components(img, viz=False):\\n\\n fg = img.foreground_mask(cfg.COLOR_TOL, ignore_black=True)\\n if viz:\\n cv2.imwrite(\\\"debug_imgs/mask.png\\\", fg.data)\\n\\n groups = get_cluster_info(fg)\\n\\n if viz:\\n display_grasps(img, groups)\\n\\n return groups\",\n \"def network_topology(voxels, clusters, primaries, edges, mode='sphere'):\\n # Define the arrays of node positions (barycenter of voxels in the cluster)\\n pos = np.array([voxels[c].cpu().numpy().mean(0) for c in clusters])\\n\\n # Define the node features (label, color)\\n n = len(clusters)\\n node_labels = ['%d (%0.1f, %0.1f, %0.1f)' % (i, pos[i,0], pos[i,1], pos[i,2]) for i in range(n)]\\n \\n node_colors = ['#ff7f0e' if i in primaries else '#1f77b4' for i in range(n)]\\n\\n # Define the nodes and their connections\\n graph_data = []\\n edge_vertices = []\\n if mode == 'sphere':\\n # Define the node size\\n logn = np.array([np.log(len(c)) for c in clusters])\\n node_sizes = np.interp(logn, (logn.min(), logn.max()), (5, 50))\\n \\n # Define the nodes as sphere of radius proportional to the log of the cluster voxel content\\n graph_data.append(go.Scatter3d(x = pos[:,0], y = pos[:,1], z = pos[:,2],\\n name = 'clusters',\\n mode = 'markers',\\n marker = dict(\\n symbol = 'circle',\\n size = node_sizes,\\n color = node_colors,\\n colorscale = 'Viridis',\\n line = dict(color='rgb(50,50,50)', width=0.5)\\n ),\\n text = node_labels,\\n hoverinfo = 'text'\\n ))\\n\\n # Define the edges center to center\\n edge_vertices = np.concatenate([[pos[i], pos[j], [None, None, None]] for i, j in zip(edges[0], edges[1])])\\n\\n elif mode == 'hull':\\n # For each cluster, add the convex hull of all its voxels\\n graph_data += [go.Mesh3d(alphahull =10.0,\\n name = '',\\n x = voxels[c][:,0],\\n y = voxels[c][:,1],\\n z = voxels[c][:,2],\\n color = node_colors[i],\\n opacity = 0.3,\\n text = node_labels[i],\\n hoverinfo = 'text'\\n ) for i, c in enumerate(clusters)]\\n\\n # Define the edges closest pixel to closest pixel\\n import scipy as sp\\n edge_vertices = []\\n for i, j in zip(edges[0], edges[1]):\\n vi, vj = voxels[clusters[i]], voxels[clusters[j]]\\n d12 = sp.spatial.distance.cdist(vi, vj, 'euclidean')\\n i1, i2 = np.unravel_index(np.argmin(d12), d12.shape)\\n edge_vertices.append([vi[i1].cpu().numpy(), vj[i2].cpu().numpy(), [None, None, None]])\\n \\n edge_vertices = np.concatenate(edge_vertices)\\n \\n else:\\n raise ValueError\\n \\n # Initialize a graph that contains the edges\\n graph_data.append(go.Scatter3d(x = edge_vertices[:,0], y = edge_vertices[:,1], z = edge_vertices[:,2],\\n mode = 'lines',\\n name = 'edges',\\n line = dict(\\n color = 'rgba(50, 50, 50, 0.5)',\\n width = 1\\n ),\\n hoverinfo = 'none'\\n ))\\n\\n # Return\\n return graph_data\",\n \"def make_graph(imageAnnotated, imageGaussian):\\n nodeNumber = imageAnnotated.max() - 1\\n distanceDiagonalPixels, distanceDiagonalPixelsCubic = np.sqrt(2.0), np.sqrt(3.0)\\n distanceMatrix = np.array([[distanceDiagonalPixelsCubic, distanceDiagonalPixels, distanceDiagonalPixelsCubic], [distanceDiagonalPixels, 1, distanceDiagonalPixels],\\n [distanceDiagonalPixelsCubic, distanceDiagonalPixels, distanceDiagonalPixelsCubic]])\\n nodePositions = np.transpose(np.where(imageAnnotated > 1))[:, ::-1]\\n imagePropagatedNodes = imageAnnotated.copy()\\n imageFilamentLength = 1.0 * (imageAnnotated.copy() > 0)\\n imageFilamentIntensity = 1.0 * (imageAnnotated.copy() > 0)\\n dimensionY, dimensionX = imageAnnotated.shape\\n filament = (imagePropagatedNodes == 1).sum()\\n while (filament > 0):\\n nodePixel = np.transpose(np.where(imagePropagatedNodes > 1))\\n for posY, posX in nodePixel:\\n xMin, xMax, yMin, yMax = bounds(posX - 1, 0, dimensionX), bounds(posX + 2, 0, dimensionX), bounds(posY - 1, 0, dimensionY), bounds(posY + 2, 0, dimensionY)\\n nodeNeighborhood = imagePropagatedNodes[yMin:yMax, xMin:xMax]\\n nodeFilamentLength = imageFilamentLength[yMin:yMax, xMin:xMax]\\n nodeFilamentIntensity = imageFilamentIntensity[yMin:yMax, xMin:xMax]\\n imagePropagatedNodes[yMin:yMax, xMin:xMax] = np.where(nodeNeighborhood == 1, imagePropagatedNodes[posY, posX], nodeNeighborhood)\\n imageFilamentLength[yMin:yMax, xMin:xMax] = np.where(nodeFilamentLength == 1, distanceMatrix[0:yMax - yMin, 0:xMax - xMin] + imageFilamentLength[posY, posX], nodeFilamentLength)\\n imageFilamentIntensity[yMin:yMax, xMin:xMax] = np.where(nodeFilamentIntensity == 1, imageGaussian[posY, posX] + imageFilamentIntensity[posY, posX], nodeFilamentIntensity)\\n filament = (imagePropagatedNodes == 1).sum()\\n graph = nx.empty_graph(nodeNumber, nx.MultiGraph())\\n filamentY, filamentX = np.where(imagePropagatedNodes > 1)\\n for posY, posX in zip(filamentY, filamentX):\\n nodeIndex = imagePropagatedNodes[posY, posX]\\n xMin, xMax, yMin, yMax = bounds(posX - 1, 0, dimensionX), bounds(posX + 2, 0, dimensionX), bounds(posY - 1, 0, dimensionY), bounds(posY + 2, 0, dimensionY)\\n filamentNeighborhood = imagePropagatedNodes[yMin:yMax, xMin:xMax].flatten()\\n filamentLength = imageFilamentLength[yMin:yMax, xMin:xMax].flatten()\\n filamentIntensity = imageFilamentIntensity[yMin:yMax, xMin:xMax].flatten()\\n for index, pixel in enumerate(filamentNeighborhood):\\n if (pixel != nodeIndex and pixel > 1):\\n node1, node2 = np.sort([nodeIndex - 2, pixel - 2])\\n nodeDistance = sp.linalg.norm(nodePositions[node1] - nodePositions[node2])\\n filamentLengthSum = imageFilamentLength[posY, posX] + filamentLength[index]\\n filamentIntensitySum = imageFilamentIntensity[posY, posX] + filamentIntensity[index]\\n minimumEdgeWeight = max(1e-9, filamentIntensitySum)\\n edgeCapacity = 1.0 * minimumEdgeWeight / filamentLengthSum\\n edgeLength = 1.0 * filamentLengthSum / minimumEdgeWeight\\n edgeConnectivity = 0\\n edgeJump = 0\\n graph.add_edge(node1, node2, edist=nodeDistance, fdist=filamentLengthSum, weight=minimumEdgeWeight, capa=edgeCapacity, lgth=edgeLength, conn=edgeConnectivity, jump=edgeJump)\\n return(graph, nodePositions)\",\n \"def run(self, infected_graph):\\n pos = nx.spring_layout(infected_graph)\\n points = np.zeros((len(pos), 2))\\n i = 0\\n for p in pos:\\n points[i] = pos[p]\\n i += 1\\n \\n hull = ConvexHull(points)\\n nodes = list(pos)\\n return [nodes[p] for p in hull.vertices]\",\n \"def find_communities(graph):\\n visited = set()\\n communities = []\\n for node in graph:\\n if node not in visited:\\n community = _find_community(node, graph, visited)\\n communities.append(community)\\n\\n return communities\",\n \"def cfdProcessNodeTopology(self):\\r\\n self.nodeElements = self.cfdInvertConnectivity(self.elementNodes)\\r\\n self.nodeFaces = self.cfdInvertConnectivity(self.faceNodes)\",\n \"def create_graph(self):\\n robot_pix = int(math.ceil(self.robot.size / self.resolution))\\n ii = 0\\n jj = 0\\n for i in range(0, self.height, robot_pix):\\n jj = 0\\n for j in range(0, self.width, robot_pix):\\n block = self.occ_grid[i:i+robot_pix, j:j+robot_pix].flatten()\\n avg = np.mean(block)\\n robot_block = self.tesselation_image[i:i+robot_pix, j:j+robot_pix].flatten()\\n n_occur = np.bincount(robot_block)\\n block_id = np.argmax(n_occur)\\n \\n p = Pose()\\n p.position.x = self.resolution * j + self.resolution / 2.0 + self.origin.position.x\\n p.position.y = self.height * self.resolution - (self.resolution * i + self.resolution / 2.0) + self.origin.position.y\\n node = Node(ii, jj, p)\\n idx = np.where(block > 20)\\n if block_id == self.robot.robot_id:\\n if 0 <= avg <= 20:\\n print(\\\"Node in path\\\", node)\\n node.valid = True\\n else:\\n node.valid = False\\n elif block_id == 0:\\n node.valid = False\\n else:\\n node.belongs = False\\n self.nodes[ii,jj] = node\\n jj += 1\\n ii += 1\\n\\n\\n height, width = self.nodes.shape\\n print(\\\"Node shape: \\\", self.nodes.shape)\\n for i in range(height):\\n for j in range(width):\\n min_i = max(0, i-1)\\n max_i = min(height - 1, i+1) + 1\\n min_j = max(0, j-1)\\n max_j = min(width - 1, j+1) + 1\\n\\n node = self.nodes[i,j]\\n neighbors = self.nodes[min_i:max_i, min_j:max_j].flatten()\\n for n in neighbors:\\n if not n or not node:\\n print(\\\"None %d-%d\\\"%(i,j))\\n continue\\n if n != node:\\n if n.valid:\\n print(\\\"Neighbor appended\\\")\\n self.nodes[i,j].neighbors.append(n)\\n else:\\n self.nodes[i,j].obstacle_neighbors.append(n)\\n print(\\\"Graph is created!\\\")\",\n \"def GraphToCommunities(Network):\\n comm=community.best_partition(Network)\\n clusters={}\\n for k in comm.keys():\\n if clusters.has_key(comm[k])==False:\\n clusters[comm[k]]=[]\\n clusters[comm[k]].append(k)\\n return (clusters)\",\n \"def brute_force_coloring(*args):\\r\\n # get arguments\\r\\n G = args[0]\\r\\n n = G.nodes()\\r\\n m = G.arcs()\\r\\n \\r\\n # check if it a valid Graph\\r\\n if not G.is_correct_type('u'):\\r\\n print \\\"ERROR: the graph is not in one of the valid formats for brute_force_coloring()\\\"\\r\\n return [], []\\r\\n \\r\\n coloring = ones(n, int) # initialize with just one color\\r\\n chrom_n = inf # initialize chromatic number\\r\\n min_coloring = [] # initialize minimum coloring\\r\\n \\r\\n # iterate till you get a coloring (really stupid way)\\r\\n terminal = array(range(n), int) + 1\\r\\n while sum(coloring != terminal) > 0:\\r\\n #print coloring\\r\\n coloring[n-1] += 1\\r\\n # correct if some achieve n\\r\\n for node in range(n-1):\\r\\n # if one get above n\\r\\n if coloring[n-1-node] > max(coloring[0:n-1-node]) + 1:\\r\\n coloring[n-1-node] = 1 # take one and...\\r\\n coloring[n-2-node] += 1 # ... add it to the previous one\\r\\n \\r\\n # if it is a coloring check it\\r\\n if G.is_coloring(coloring):\\r\\n col_number = max(coloring) # number of colors\\r\\n # if it is better, update\\r\\n if col_number < chrom_n:\\r\\n chrom_n = col_number\\r\\n min_coloring = coloring.copy()\\r\\n print \\\"current minimum: \\\", min_coloring, \\\"with %d colors\\\" %(chrom_n)\\r\\n \\r\\n return min_coloring, chrom_n\",\n \"def node_condense(imageNodes, imageGrayscale, ones):\\n imageLabeled, labels = sp.ndimage.label(imageNodes, structure=ones)\\n sizes = sp.ndimage.sum(imageLabeled > 0, imageLabeled, range(1, labels + 1))\\n centerOfMass = sp.ndimage.center_of_mass(imageGrayscale, imageLabeled, range(1, labels + 1))\\n for label in range(labels):\\n if (sizes[label] > 1):\\n idx = (imageLabeled == label + 1)\\n idm = tuple(np.add(centerOfMass[label], 0.5).astype('int'))\\n imageLabeled[idx] = 0\\n imageLabeled[idm] = label + 1\\n imageLabeledNodes, _ = sp.ndimage.label(imageLabeled > 0, structure=ones)\\n imageLabeledNodes = imageLabeledNodes.astype('int')\\n return(imageLabeledNodes)\",\n \"def _connect_components_analysis(image):\\n if len(image.shape) == 3:\\n gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\\n else:\\n gray_image = image\\n\\n return cv2.connectedComponentsWithStats(gray_image, connectivity=8, ltype=cv2.CV_32S)\",\n \"def _find_community(root, graph, visited):\\n community = [root]\\n visited.add(root)\\n next_queue = [root]\\n while next_queue:\\n node = next_queue.pop(0)\\n for child in graph[node]:\\n if child not in visited:\\n next_queue.append(child)\\n community.append(child)\\n visited.add(child)\\n\\n return community\",\n \"def neato_cooccurrence_graph( nC, v, labels, max_nodes = 10, fnam_stem = \\\"test\\\", label_nodes_directly = False, scale=1.0, min_node_size = 0.1 ):\\n \\n nv = v.astype( float32 ) / v.max()\\n\\n cutoff = cooccur_cutoff( nC, max_nodes );\\n\\n graph = pydot.Dot( graph_type = 'graph' )\\n graph.set_overlap(\\\"false\\\")\\n coords = zip(*(nC >= cutoff).nonzero())\\n\\n # make a dict of all nodes which are mentioned in the coords\\n nodes = {}\\n index = 1\\n for coord in set(chain.from_iterable(coords)) :\\n if not nodes.has_key( coord ) :\\n node = pydot.Node( str(coord) )\\n if v != None :\\n #print coord\\n label = labels[coord]\\n if label_nodes_directly :\\n node.set_label( label )\\n else :\\n node.set_label( str(index) )\\n #node.set_penwidth( nv[ coord ] )\\n node.set_fixedsize(\\\"true\\\")\\n node.set_width( max(min_node_size,scale *nv[ coord ]) )\\n node.set_shape(\\\"circle\\\")\\n nodes[ coord ] = node\\n graph.add_node( node )\\n index = index + 1\\n\\n for coord in coords :\\n \\n edge = pydot.Edge( nodes[coord[0]], nodes[coord[1]] )\\n edge.set_weight( nC[coord] )\\n edge.set_penwidth( nC[coord]*5 )\\n #edge.set_label( str(int(m[coord]) ))\\n graph.add_edge(edge)\\n\\n if not label_nodes_directly : \\n legend = pydot.Node( \\\"legend\\\" )\\n nodelist = nodes.items()\\n nodelist.sort( lambda a,b : cmp(node_index(a[1].get_label()),node_index(b[1].get_label())) )\\n legend.set_label( \\\"\\\\l\\\".join([x[1].get_label()+\\\":\\\"+labels[x[0]] for x in nodelist])+\\\"\\\\l\\\" )\\n legend.set_shape(\\\"box\\\")\\n graph.add_node(legend)\\n\\n #print graph.to_string()\\n graph.write_dot(fnam_stem+'.dot', prog='neato' )\\n graph.write_png(fnam_stem+'.png', prog='neato' )\\n #graph.write_pdf(fnam_stem+'.pdf', prog='neato' )\",\n \"def non_pol_neighbours_graph():\\n data = pd.read_csv(\\\"/Users/emg/GitHub/thesis/output/2019_01/1000_residuals_output_utf8.csv\\\", index_col=0)\\n\\n labelled = label_subs(data)\\n labelled['resid_rank'] = labelled.resid.rank(pct=True)\\n top = subset_df(labelled, 'resid', q=0.95)\\n\\n edges = top.copy()[['source','target','resid']]\\n edges_rev = edges.copy()\\n edges_rev.columns = ['target','source','resid']\\n directed_edges = pd.concat([edges,edges_rev], sort=True)\\n directed_edges['resid_rank'] = directed_edges['resid'].rank(pct=True)\\n\\n df = label_subs(directed_edges)\\n\\n pol_subs = load_pol_subs()\\n pol_names = pol_subs.subreddit.str.replace('\\\\\\\\','')\\n pol_subs.subreddit=pol_subs.subreddit.str.replace('\\\\\\\\','')\\n\\n pol_neighbours = df[df['source'].isin(pol_names)].sort_values('resid', ascending=False)\\n\\n top_pol_neigh = pol_neighbours.groupby('source').head(10).sort_values(['source','resid'], ascending=[True,False])\\n \\n x = top_pol_neigh[~top_pol_neigh.target.isin(pol_names)][['source','target']]\\n\\n col_dict = pol_subs.set_index('subreddit').col.to_dict()\\n for sub in x.target.unique():\\n col_dict[sub] = 'gray'\\n\\n G = nx.from_pandas_edgelist(x)\\n nx.set_node_attributes(G, col_dict, 'col')\\n\\n f = plt.figure(1)\\n ax = f.add_subplot(1,1,1)\\n\\n colors = dict(G.nodes(data='col')).values()\\n\\n pos = nx.spring_layout(G, k=0.2)\\n nx.draw_networkx(G, pos=pos, with_labels=False, node_color=colors, alpha=0.3)\\n #nx.draw_networkx_labels(G, pos=pos, with_labels=True)\\n\\n plt.axis('off')\\n f.set_facecolor('w')\\n \\n f.tight_layout()\\n plt.savefig(figures_path(f\\\"{date}/non_pol_neighbours_graph.png\\\"))\\n plt.close()\",\n \"def FindClumps_graph(self):\\n # IMPORT STUFF\\n import string\\n # END IMPORT\\n \\n maxima = self['CL_LOC'].copy()\\n maxima = num.where(maxima)\\n maxima = (maxima[1],maxima[0])\\n detectimg = self['STAMP'].copy()\\n \\n id = self._getGraphId()\\n root = 'FindClumps_%s' % (id,)\\n pngname = root + '.png' ; epsname = root + '.eps'\\n jpgname = root + '.jpg'\\n\\n doStamp(detectimg,pngname,format='PNG')\\n Convert(pngname,jpgname)\\n \\n Painted = Paint(jpgname)\\n Painted.load()\\n Painted.DrawCross(maxima,length=7,color='green')\\n \\n strpeaks = string.strip('%i'% (self['M_NUM_CL']))\\n text = 'NC=%s' % strpeaks \\n \\n # Painted.Graffiti(text,commtextpos)\\n \\n Painted.save(jpgname)\\n Painted.release()\\n \\n Convert(jpgname,epsname)\\n os.system('rm %s %s' % (pngname,jpgname))\\n self['figures']['FindClumps'] = epsname\\n self['figcomms']['FindClumps'] = text\",\n \"def get_communities(num_of_neighbors, is_self_loops, relevant_period_groups, full_confusion_csv, classes_csv_file, priod_group_column, similarty_csv = ''):\\n\\n # generate class_names dict\\n cnt = 0\\n class_name_dict = {}\\n with open(classes_csv_file, 'r') as f:\\n reader = csv.reader(f)\\n for row in reader:\\n if cnt > 0:\\n class_name_dict[int(row[8])] = row[1]\\n cnt = cnt + 1\\n\\n\\n full_conf = np.genfromtxt(full_confusion_csv, delimiter=',')\\n relevant_conf = full_conf[:,:num_of_neighbors+1]\\n flatten_conf = np.zeros((relevant_conf.shape[0]*num_of_neighbors,2), dtype=np.int32)\\n if similarty_csv != '':\\n similarity_mat = np.genfromtxt(similarty_csv, delimiter=',')\\n similarity_conf_mat = np.zeros((200, 200), dtype=np.float32)\\n print(similarity_mat.shape)\\n\\n\\n row = 0\\n for k in range(relevant_conf.shape[0]):\\n for m in range(num_of_neighbors):\\n flatten_conf[row, 0] = relevant_conf[k,0]\\n flatten_conf[row,1] = relevant_conf[k,m+1]\\n if similarty_csv != '':\\n similarity_conf_mat[int(relevant_conf[k,0]), int(relevant_conf[k,m+1]) ] += similarity_mat[k, m]\\n\\n row = row + 1\\n\\n confusion_mat = confusion_matrix(flatten_conf[:,0], flatten_conf[:,1])\\n if similarty_csv != '':\\n confusion_mat = similarity_conf_mat\\n\\n confusion_mat = confusion_mat.astype('float') / confusion_mat.sum(axis=1)[:, np.newaxis]\\n symmetric_confusion = (confusion_mat + np.transpose(confusion_mat)) / 2\\n if not is_self_loops:\\n np.fill_diagonal(symmetric_confusion, 0)\\n\\n # taking only the relevant classes\\n if relevant_period_groups != -1:\\n df = pd.read_csv(classes_csv_file)\\n period_groups = df[priod_group_column]\\n relevant_classes = []\\n for group in relevant_period_groups:\\n group_slice = df[period_groups == group]\\n relevant_classes.extend(group_slice['id_period_sorted'].values)\\n\\n L = len(relevant_classes)\\n relevant_confusion = np.zeros((L,L), dtype=np.float32)\\n class_node_dict = {}\\n for m,cls_i in enumerate(relevant_classes):\\n class_node_dict[m] = cls_i\\n for n,cls_j in enumerate(relevant_classes):\\n relevant_confusion[m,n] = symmetric_confusion[cls_i,cls_j]\\n else:\\n relevant_confusion = symmetric_confusion\\n\\n G = nx.from_numpy_matrix(relevant_confusion)\\n\\n # find best communities based on modularity grade\\n resolution_vec = np.linspace(0.0,2,50)\\n mod_vec = np.zeros_like(resolution_vec)\\n best_modularity = -1\\n best_communities = -1\\n best_res = -1\\n for k in range(resolution_vec.size):\\n partition = community.best_partition(G, weight='weight', resolution=resolution_vec[k])\\n modularity = community.modularity(partition, G, weight='weight')\\n mod_vec[k] = modularity\\n if (modularity > best_modularity):\\n best_modularity = modularity\\n best_communities = partition\\n best_res = resolution_vec[k]\\n\\n summary_str = 'best resolution: %.3f\\\\nbest modularity: %.3f\\\\nnumber of communities: %d' % (best_res,best_modularity,len(set(best_communities.values())))\\n\\n #plt.plot(resolution_vec,mod_vec)\\n #plt.show()\\n\\n # generate community summary file\\n count = 0\\n strr = ''\\n summary_file_name = 'community_summary.csv'\\n for com in set(best_communities.values()):\\n count += 1.\\n list_nodes = [nodes for nodes in best_communities.keys() if best_communities[nodes] == com]\\n strr += 'community,' + str(com) + '\\\\n'\\n for nd in list_nodes:\\n if relevant_period_groups == -1:\\n strr += class_name_dict[nd] + ',id,' + str(nd) + '\\\\n'\\n else:\\n strr += class_name_dict[class_node_dict[nd]] + ',id,' + str(class_node_dict[nd]) + '\\\\n'\\n strr += '\\\\n'\\n with open(summary_file_name, \\\"w\\\") as text_file:\\n text_file.write(strr)\\n\\n print(strr)\\n # summary for map visualization tool\\n strr = ''\\n for k in range(relevant_confusion.shape[0]):\\n comm = partition[k]\\n comm_members = [nodes for nodes in partition.keys() if partition[nodes] == comm]\\n if relevant_period_groups == -1:\\n strr += 'id,' + str(k) + ',community,' + str(comm) + ',community_members,'\\n else:\\n strr += 'id,' + str(class_node_dict[k]) + ',community,' + str(comm) + ',community_members,'\\n for member in comm_members:\\n if relevant_period_groups == -1:\\n strr += str(member) + ','\\n else:\\n strr += str(class_node_dict[member]) + ','\\n strr += '\\\\n'\\n with open('nodes_communities.csv', \\\"w\\\") as text_file:\\n text_file.write(strr)\\n\\n\\n\\n return summary_str\",\n \"def bgll(self, graph, node_count, min_mod, max_pass):\\n\\n #the belonging of the node\\n bl = [i for i in range(node_count)]\\n #the node's weight in community\\n _in = [0.0] * node_count\\n #the node's weight in graph\\n _tot = []\\n #total weight of a node, just a copy of _tot\\n k = []\\n #the total weight of the graph\\n m = []\\n\\n #inital the in-param\\n network = [[0.0] * node_count for n in range(node_count)]\\n for node, tag, weight in graph:\\n network[node][tag] = weight\\n for node in network:\\n k.append(sum(node))\\n _tot = k[:]\\n m = sum(k)\\n #inital the in-param\\n\\n def modularity():\\n \\\"\\\"\\\"\\n This function mainly computes the modularity of the network\\n Return:\\n mod->the modularity value\\n \\\"\\\"\\\"\\n\\n q = 0.0\\n for idx in range(0, node_count):\\n if _tot[idx] > 0.0:\\n q += (_in[idx] / m - math.pow(_tot[idx] / m, 2))\\n return q\\n\\n def modularity_gain(n, c, dnodecomm):\\n \\\"\\\"\\\"\\n This function mainly computes the modularity gain of a node moving\\n Param:\\n n->node id\\n c->community id\\n dnodecomm->the weight between the node and the community\\n Return:\\n gain->modularity gain\\n \\\"\\\"\\\"\\n\\n totc = _tot[c]\\n degc = k[n]\\n return dnodecomm - (totc * degc) / m\\n\\n def neigh_comm(n):\\n \\\"\\\"\\\"\\n This function mainly computes the weight between the node and it's neighbour community\\n Param:\\n n->node id\\n Return:\\n nc->the map of the weight between the node and it's neighbour community\\n nc=>{cid,weight}\\n \\\"\\\"\\\"\\n\\n nc = {bl[n]: 0.0}\\n for idx in range(0, node_count):\\n neigh = idx\\n ncomm = bl[neigh]\\n nei_weight = network[n][idx]\\n if (neigh != n) & (nei_weight > 0.0):\\n if ncomm in nc:\\n nc[ncomm] += nei_weight\\n else:\\n nc[ncomm] = nei_weight\\n return nc\\n\\n def insert(n, c, dnodecomm):\\n \\\"\\\"\\\"\\n This function mainly get the effect of insert the node into community\\n Param:\\n n->node id\\n c->community id\\n dnodecomm->the weight between the node and the community\\n \\\"\\\"\\\"\\n\\n _tot[c] += k[n]\\n _in[c] += 2 * dnodecomm + network[n][n]\\n bl[n] = c\\n\\n def remove(n, c, dnodecomm):\\n \\\"\\\"\\\"\\n This function mainly get the effect of remove the node off community\\n Param:\\n n->node id\\n c->community id\\n dnodecomm->the weight between the node and the community\\n \\\"\\\"\\\"\\n\\n _tot[c] -= k[n]\\n _in[c] -= 2 * dnodecomm + network[n][n]\\n bl[n] = -1\\n\\n def detect():\\n \\\"\\\"\\\"\\n This function mainly detect the community of the graph.\\n \\\"\\\"\\\"\\n\\n _pass_done = 0\\n _improve = True\\n new_mod = modularity()\\n cur_mod = -999999999.0\\n rl = random.sample(range(0, node_count), node_count)\\n while _improve & (_pass_done < max_pass) & (new_mod - cur_mod > min_mod):\\n cur_mod = new_mod\\n _improve = False\\n _pass_done += 1\\n for node_tmp in rl:\\n n = node_tmp\\n nc = bl[n]\\n ncomm = neigh_comm(n)\\n remove(n, nc, ncomm[nc])\\n best_c = nc\\n best_l = 0.0\\n best_incre = 0.0\\n for c in ncomm:\\n incre = modularity_gain(n, c, ncomm[c])\\n if incre > best_incre:\\n best_incre = incre\\n best_c = c\\n best_l = ncomm[c]\\n insert(n, best_c, best_l)\\n if best_c != nc:\\n _improve = True\\n new_mod = modularity()\\n print new_mod\\n\\n detect()\\n return bl\",\n \"def make_communities(community_side, communities_per_side):\\n community_size = community_side * community_side\\n communities = []\\n seed_node = 0\\n for i in range(communities_per_side):\\n for j in range(communities_per_side):\\n community = []\\n for k in range(community_side):\\n for z in range(community_side):\\n _id = (\\n communities_per_side * community_size * i\\n + community_side * j\\n + z\\n + k * (communities_per_side * community_side)\\n )\\n # print(f\\\"{_id} \\\", end=\\\"\\\")\\n community.append(_id)\\n # print(\\\"- \\\", end=\\\"\\\")\\n communities.append(community)\\n #print()\\n return communities\",\n \"def construct_network_from_neighbours_list(related_characters: list):\\n graph = nx.Graph()\\n for edge in related_characters:\\n sentiment = edge[1]\\n color = ''\\n if sentiment == 'Positive':\\n color = 'g'\\n elif sentiment == 'Negative':\\n color = 'r'\\n elif sentiment == 'Neutral':\\n color = 'k'\\n # graph.add_node(edge[0][0], popularity=\\n graph.add_edge(edge[0][0], edge[0][1], color=color, weight=edge[2])\\n\\n return graph\",\n \"def network(self, max_clusters=20, max_members=10, max_nodes=300, l_go_selective=False):\\n if len(self.data)==0:\\n return None\\n if self.DM is None:\\n util.error_msg('Please run cluster first!')\\n S_node=GO_Cluster.sample_rows(self.t_go, max_clusters=max_clusters, max_members=max_members, max_nodes=max_nodes, l_go_selective=l_go_selective)\\n T_node=self.t_go[self.t_go.GO.apply(lambda x: x in S_node)].copy()\\n S_go=self.data.header()\\n M=self.data.values\\n n,m=M.shape\\n S_node=set(T_node.GO)\\n S_idx=[i for i,x in enumerate(S_go) if x in S_node ]\\n S_name=[ S_go[i] for i in S_idx]\\n T_node.rename2({'GO':'Gene'})\\n s_name='GOCluster'\\n if 'Name' in T_node.header():\\n s_name=list(T_node.Name)[0]\\n T_node.drop('Name', axis=1, inplace=True)\\n if 'URL' in T_node.header():\\n T_node.drop('URL', axis=1, inplace=True)\\n\\n c_has_neighbor={}\\n data=[]\\n c_cluster={ T_node.ix[i,'Gene']:T_node.ix[i,'GROUP_ID'] for i in T_node.index}\\n n2=len(S_idx)\\n for _i in range(n2):\\n i=S_idx[_i]\\n for _j in range(_i+1, n2):\\n j=S_idx[_j]\\n idx=i*(2*m-i-1)//2+(j-i)-1\\n #print (_i, _j, n2, m, i, j, idx, S_name[_i], c_cluster[S_name[_i]], S_name[_j], c_cluster[S_name[_j]], K[idx])\\n if self.DM[idx]>=self.similarity:\\n data.append({'Gene_A':S_go[i], 'Gene_B':S_go[j], 'TYPE':'Direct', 'SCORE':self.DM[idx]})\\n c_has_neighbor[S_go[i]]=True\\n c_has_neighbor[S_go[j]]=True\\n # keep singletons\\n for i in S_idx:\\n if S_go[i] not in c_has_neighbor:\\n data.append({'Gene_A':S_go[i], 'Gene_B':S_go[i], 'TYPE':'Direct', 'SCORE':1.0})\\n if len(data):\\n T_edge=pd.DataFrame(data)\\n T_node.index=list(range(len(T_node)))\\n net=xgmml.Network(T_edge, T_node=T_node, name=s_name)\\n return net\",\n \"def calc_coloring(graph_rdd):\\n graph_rdd = graph_rdd \\\\\\n .map(swap) \\\\\\n .union(graph_rdd)\\n nodes = graph_rdd.keys().distinct()\\n\\n color = nodes.map(lambda x: (x, 1))\\n color_num = 1\\n\\n while True:\\n graph_join_color = graph_rdd.join(color)\\n neighbour = graph_join_color \\\\\\n .map(lambda (x, (a, bx)): (a, (x, bx))) \\\\\\n .groupByKey() \\\\\\n .map(lambda (x, y): (x, [n[1] for n in y]))\\n color = neighbour.map(lambda (x, y): (x, hash(str(sorted(y)))))\\n color_new = color \\\\\\n .map(swap) \\\\\\n .reduceByKey(add, numPartitions=40) \\\\\\n .map(lambda x: 1) \\\\\\n .reduce(add)\\n if color_num != color_new:\\n break\\n color_num = color_new\\n return color\",\n \"def clusters_connected( self):\\n def check_connected( k, vertices, edges):\\n dads = {}\\n for p in vertices:\\n dads[p] = p\\n\\n def Find( c):\\n while c != dads[c]:\\n c = dads[c]\\n return c\\n\\n def Union( p, q):\\n dads[Find(p)] = Find(q)\\n\\n for p,q in edges:\\n Union( p, q)\\n\\n stuff = set([ Find(p) for (k,p) in dads.items()])\\n assert len(stuff) == 1, \\\"More than one partition\\\"\\n\\n vertices = collections.defaultdict( list)\\n for p in itertools.product( range(self.n), repeat=2):\\n vertices[self.raster[p]].append( p)\\n\\n def X():\\n for x in range(self.n-1):\\n for y in range(self.n):\\n yield (x,y),(x+1,y)\\n\\n def Y():\\n for x in range(self.n):\\n for y in range(self.n-1):\\n yield (x,y),(x,y+1)\\n\\n connections = collections.defaultdict( list)\\n for (p,q) in itertools.chain( X(), Y()):\\n if self.raster[p] == self.raster[q]:\\n connections[self.raster[p]].append( ( p, q))\\n\\n for (k,v) in vertices.items():\\n check_connected( k, v, connections[k])\",\n \"def _community(G, u, community):\\n node_u = G.node[u]\\n try:\\n return node_u[community]\\n except KeyError:\\n raise nx.NetworkXAlgorithmError('No community information')\",\n \"def color_chosen_nodes(network, chosen_node, color):\\n\\n # Color the node selected randomly by RWR\\n network.nodes[chosen_node]['color'] = color\\n # Create a list with color for each node\\n color_nodes = [network.nodes[node]['color'] for node in network.nodes]\\n return color_nodes\",\n \"def add_communites(self):\\n\\n query = '''\\n MATCH (c1:)-[r:INTERACTS]->(c2:)\\n RETURN c1.name, c2.name, r.weight AS weight\\n '''\\n ig = IGraph.TupleList(self.graph.run(query), weights=True)\\n\\n clusters = IGraph.community_walktrap(ig, weights=\\\"weight\\\").as_clustering()\\n\\n nodes = [{\\\"name\\\": node[\\\"name\\\"]} for node in ig.vs]\\n for node in nodes:\\n idx = ig.vs.find(name=node[\\\"name\\\"]).index\\n node[\\\"community\\\"] = clusters.membership[idx]\\n\\n write_clusters_query = '''\\n UNWIND {nodes} AS n\\n MATCH (c:) WHERE c.name = n.name\\n SET c.community = toInt(n.community)\\n '''\\n\\n self.graph.run(write_clusters_query, nodes=nodes)\",\n \"def make_connected(self):\\r\\n if nx.is_connected(self.g): return\\r\\n import random\\r\\n cc = list( nx.connected_components(self.g) )\\r\\n nodes = [random.sample(cluster,1)[0] for cluster in cc]\\r\\n for n1,n2 in zip(nodes[:-1],nodes[1:]):\\r\\n self.factors.append(factor(var=[n1,n2],card=self.cardVec[[n1,n2]],val=scipy.ones(4)))\\r\\n self.update()\",\n \"def vertex_coloring(self, display = False):\\r\\n stack = self.SL_algorithm()\\r\\n color_of_vertex = self.greedily_coloring(stack)\\r\\n if(display):\\r\\n self.display_graph(color_of_vertex)\\r\\n return color_of_vertex\\r\\n else: \\r\\n return color_of_vertex\",\n \"def get_classification_site(self, image):\\n #TODO implement light color prediction\\n \\n\\timg=cv2.resize(image,(224,224))\\n\\timg=img/255.0\\n\\timg = np.expand_dims(img, axis=0)\\n with self.graph.as_default():\\n\\t pred=self.model.predict(img)\\n\\tpclass=np.argmax(pred)\\n\\n \\ttf_color=TrafficLight.UNKNOWN\\n if (pclass==1):\\n\\t tf_color=TrafficLight.RED\\n elif (pclass==2):\\n\\t tf_color=TrafficLight.GREEN\\n\\n return tf_color\",\n \"def get_classification(self, image):\\n run_network = True # flag to disable running network if desired\\n if run_network is True:\\n image_np_expanded = np.expand_dims(image, axis=0)\\n\\n time0 = time.time()\\n\\n # Actual detection.\\n with self.detection_graph.as_default():\\n (boxes, scores, classes, num) = self.sess.run(\\n [self.detection_boxes, self.detection_scores,\\n self.detection_classes, self.num_detections],\\n feed_dict={self.image_tensor: image_np_expanded})\\n\\n time1 = time.time()\\n\\n #print(\\\"Time in milliseconds\\\", (time1 - time0) * 1000)\\n\\n boxes = np.squeeze(boxes)\\n scores = np.squeeze(scores)\\n classes = np.squeeze(classes).astype(np.int32)\\n \\n #Add extra stuff here\\n self.current_light = TrafficLight.UNKNOWN\\n min_score_thresh = .50\\n for i in range(boxes.shape[0]):\\n if scores is None or scores[i] > min_score_thresh:\\n\\n class_name = self.category_index[classes[i]]['name']\\n # class_id = self.category_index[classes[i]]['id'] # if needed\\n\\n #print('{}'.format(class_name))\\n\\n # Traffic light thing\\n self.current_light = TrafficLight.UNKNOWN\\n\\n if class_name == 'Red':\\n self.current_light = TrafficLight.RED\\n elif class_name == 'Green':\\n self.current_light = TrafficLight.GREEN\\n elif class_name == 'Yellow':\\n self.current_light = TrafficLight.YELLOW\\n \\n '''if self.current_light == TrafficLight.RED:\\n print('RED')\\n elif self.current_light == TrafficLight.GREEN:\\n print('GREEN')\\n elif self.current_light == TrafficLight.YELLOW:\\n print('YELLOW')\\n else:\\n print('NO_LIGHT')'''\\n\\n return self.current_light\",\n \"def greedy_modularity_communities(G, weight=None):\\n\\n # Count nodes and edges\\n N = len(G.nodes())\\n m = sum([d.get('weight', 1) for u, v, d in G.edges(data=True)])\\n q0 = 1.0 / (2.0*m)\\n\\n # Map node labels to contiguous integers\\n label_for_node = dict((i, v) for i, v in enumerate(G.nodes()))\\n node_for_label = dict((label_for_node[i], i) for i in range(N))\\n\\n # Calculate degrees\\n k_for_label = G.degree(G.nodes(), weight=weight)\\n k = [k_for_label[label_for_node[i]] for i in range(N)]\\n\\n # Initialize community and merge lists\\n communities = dict((i, frozenset([i])) for i in range(N))\\n merges = []\\n\\n # Initial modularity\\n partition = [[label_for_node[x] for x in c] for c in communities.values()]\\n q_cnm = modularity(G, partition)\\n\\n # Initialize data structures\\n # CNM Eq 8-9 (Eq 8 was missing a factor of 2 (from A_ij + A_ji)\\n # a[i]: fraction of edges within community i\\n # dq_dict[i][j]: dQ for merging community i, j\\n # dq_heap[i][n] : (-dq, i, j) for communitiy i nth largest dQ\\n # H[n]: (-dq, i, j) for community with nth largest max_j(dQ_ij)\\n a = [k[i]*q0 for i in range(N)]\\n dq_dict = dict(\\n (i, dict(\\n (j, 2*q0 - 2*k[i]*k[j]*q0*q0)\\n for j in [\\n node_for_label[u]\\n for u in G.neighbors(label_for_node[i])]\\n if j != i))\\n for i in range(N))\\n dq_heap = [\\n MappedQueue([\\n (-dq, i, j)\\n for j, dq in dq_dict[i].items()])\\n for i in range(N)]\\n H = MappedQueue([\\n dq_heap[i].h[0]\\n for i in range(N)\\n if len(dq_heap[i]) > 0])\\n\\n # Merge communities until we can't improve modularity\\n while len(H) > 1:\\n # Find best merge\\n # Remove from heap of row maxes\\n # Ties will be broken by choosing the pair with lowest min community id\\n try:\\n dq, i, j = H.pop()\\n except IndexError:\\n break\\n dq = -dq\\n # Remove best merge from row i heap\\n dq_heap[i].pop()\\n # Push new row max onto H\\n if len(dq_heap[i]) > 0:\\n H.push(dq_heap[i].h[0])\\n # If this element was also at the root of row j, we need to remove the\\n # duplicate entry from H\\n if dq_heap[j].h[0] == (-dq, j, i):\\n H.remove((-dq, j, i))\\n # Remove best merge from row j heap\\n dq_heap[j].remove((-dq, j, i))\\n # Push new row max onto H\\n if len(dq_heap[j]) > 0:\\n H.push(dq_heap[j].h[0])\\n else:\\n # Duplicate wasn't in H, just remove from row j heap\\n dq_heap[j].remove((-dq, j, i))\\n # Stop when change is non-positive\\n if dq <= 0:\\n break\\n\\n # Perform merge\\n communities[j] = frozenset(communities[i] | communities[j])\\n del communities[i]\\n merges.append((i, j, dq))\\n # New modularity\\n q_cnm += dq\\n # Get list of communities connected to merged communities\\n i_set = set(dq_dict[i].keys())\\n j_set = set(dq_dict[j].keys())\\n all_set = (i_set | j_set) - set([i, j])\\n both_set = i_set & j_set\\n # Merge i into j and update dQ\\n for k in all_set:\\n # Calculate new dq value\\n if k in both_set:\\n dq_jk = dq_dict[j][k] + dq_dict[i][k]\\n elif k in j_set:\\n dq_jk = dq_dict[j][k] - 2.0*a[i]*a[k]\\n else:\\n # k in i_set\\n dq_jk = dq_dict[i][k] - 2.0*a[j]*a[k]\\n # Update rows j and k\\n for row, col in [(j, k), (k, j)]:\\n # Save old value for finding heap index\\n if k in j_set:\\n d_old = (-dq_dict[row][col], row, col)\\n else:\\n d_old = None\\n # Update dict for j,k only (i is removed below)\\n dq_dict[row][col] = dq_jk\\n # Save old max of per-row heap\\n if len(dq_heap[row]) > 0:\\n d_oldmax = dq_heap[row].h[0]\\n else:\\n d_oldmax = None\\n # Add/update heaps\\n d = (-dq_jk, row, col)\\n if d_old is None:\\n # We're creating a new nonzero element, add to heap\\n dq_heap[row].push(d)\\n else:\\n # Update existing element in per-row heap\\n dq_heap[row].update(d_old, d)\\n # Update heap of row maxes if necessary\\n if d_oldmax is None:\\n # No entries previously in this row, push new max\\n H.push(d)\\n else:\\n # We've updated an entry in this row, has the max changed?\\n if dq_heap[row].h[0] != d_oldmax:\\n H.update(d_oldmax, dq_heap[row].h[0])\\n\\n # Remove row/col i from matrix\\n i_neighbors = dq_dict[i].keys()\\n for k in i_neighbors:\\n # Remove from dict\\n dq_old = dq_dict[k][i]\\n del dq_dict[k][i]\\n # Remove from heaps if we haven't already\\n if k != j:\\n # Remove both row and column\\n for row, col in [(k, i), (i, k)]:\\n # Check if replaced dq is row max\\n d_old = (-dq_old, row, col)\\n if dq_heap[row].h[0] == d_old:\\n # Update per-row heap and heap of row maxes\\n dq_heap[row].remove(d_old)\\n H.remove(d_old)\\n # Update row max\\n if len(dq_heap[row]) > 0:\\n H.push(dq_heap[row].h[0])\\n else:\\n # Only update per-row heap\\n dq_heap[row].remove(d_old)\\n\\n del dq_dict[i]\\n # Mark row i as deleted, but keep placeholder\\n dq_heap[i] = MappedQueue()\\n # Merge i into j and update a\\n a[j] += a[i]\\n a[i] = 0\\n\\n communities = [\\n frozenset([label_for_node[i] for i in c])\\n for c in communities.values()]\\n return sorted(communities, key=len, reverse=True)\",\n \"def detect():\\n\\n _pass_done = 0\\n _improve = True\\n new_mod = modularity()\\n cur_mod = -999999999.0\\n rl = random.sample(range(0, node_count), node_count)\\n while _improve & (_pass_done < max_pass) & (new_mod - cur_mod > min_mod):\\n cur_mod = new_mod\\n _improve = False\\n _pass_done += 1\\n for node_tmp in rl:\\n n = node_tmp\\n nc = bl[n]\\n ncomm = neigh_comm(n)\\n remove(n, nc, ncomm[nc])\\n best_c = nc\\n best_l = 0.0\\n best_incre = 0.0\\n for c in ncomm:\\n incre = modularity_gain(n, c, ncomm[c])\\n if incre > best_incre:\\n best_incre = incre\\n best_c = c\\n best_l = ncomm[c]\\n insert(n, best_c, best_l)\\n if best_c != nc:\\n _improve = True\\n new_mod = modularity()\\n print new_mod\",\n \"def assign_louvain_communities(\\n reddit_graph: nx.Graph,\\n wiki_graph: nx.Graph = None,\\n reddit_edge_weight: str = \\\"count\\\",\\n others_threshold: int = 2,\\n louvain_resolution_reddit: float = 1,\\n) -> Union[nx.Graph, Tuple[nx.Graph, nx.Graph]]:\\n reddit_dendrogram = community.generate_dendrogram(\\n reddit_graph, weight=reddit_edge_weight, resolution=louvain_resolution_reddit\\n )\\n if wiki_graph:\\n wiki_dendrogram = community.generate_dendrogram(\\n wiki_graph,\\n )\\n\\n # Iterate over reddit nodes to assign communities\\n for node in reddit_graph:\\n # Iterate over all levels of the dendrogram\\n for level in range(len(reddit_dendrogram) - 1):\\n actual_level = len(reddit_dendrogram) - 2 - level\\n\\n partition = community.partition_at_level(reddit_dendrogram, level)\\n\\n node_community = partition[node]\\n counts = Counter(partition.values())\\n if counts[node_community] < others_threshold:\\n node_community = -1\\n reddit_graph.nodes[node][\\n f\\\"louvain_community_reddit_R{louvain_resolution_reddit:.2f}_L{actual_level}\\\"\\n ] = f\\\"L{actual_level}-{node_community:03}\\\"\\n if wiki_graph:\\n # Also add the community from the other graph to allow comparing\\n # Again, iterate over all levels in the dendrogram\\n for level in range(len(wiki_dendrogram) - 1):\\n actual_level = len(wiki_dendrogram) - 2 - level\\n\\n partition = community.partition_at_level(wiki_dendrogram, level)\\n\\n try:\\n node_community = partition[node]\\n counts = Counter(partition.values())\\n if counts[node_community] < others_threshold:\\n node_community = -1\\n\\n reddit_graph.nodes[node][\\n f\\\"louvain_community_wiki_L{actual_level}\\\"\\n ] = f\\\"L{actual_level}-{node_community:03}\\\"\\n\\n except:\\n reddit_graph.nodes[node][\\n f\\\"louvain_community_wiki_L{level}\\\"\\n ] = f\\\"L{level}-NONE\\\"\\n if wiki_graph:\\n for node in wiki_graph:\\n for level in range(\\n len(wiki_dendrogram) - 1,\\n ):\\n actual_level = len(wiki_dendrogram) - 2 - level\\n\\n partition = community.partition_at_level(wiki_dendrogram, level)\\n node_community = partition[node]\\n\\n counts = Counter(partition.values())\\n if counts[node_community] < others_threshold:\\n node_community = -1\\n\\n wiki_graph.nodes[node][\\n f\\\"louvain_community_wiki_L{actual_level}\\\"\\n ] = f\\\"L{actual_level}-{node_community:03}\\\"\\n # Also add the community from the other graph to allow comparing\\n\\n for level in range(len(reddit_dendrogram) - 1):\\n actual_level = len(reddit_dendrogram) - 2 - level\\n\\n partition = community.partition_at_level(reddit_dendrogram, level)\\n\\n try:\\n node_community = partition[node]\\n\\n counts = Counter(partition.values())\\n if counts[node_community] < others_threshold:\\n node_community = -1\\n wiki_graph.nodes[node][\\n f\\\"louvain_community_reddit_R{louvain_resolution_reddit:.2f}_L{actual_level}\\\"\\n ] = f\\\"L{actual_level}-{node_community:03}\\\"\\n except:\\n wiki_graph.nodes[node][\\n f\\\"louvain_community_reddit_R{louvain_resolution_reddit:.2f}_L{level}\\\"\\n ] = f\\\"L{level}-NONE\\\"\\n\\n return (\\n (reddit_graph, reddit_dendrogram, wiki_graph, wiki_dendrogram)\\n if wiki_graph\\n else (reddit_graph, reddit_dendrogram)\\n )\",\n \"def connected_component(self):\\n t1 = datetime.datetime.now()\\n nodes = set(x.hex for x in self.agents)\\n result = []\\n while nodes:\\n node = nodes.pop()\\n # This set will contain the next group of nodes connected to each other.\\n group = {node}\\n # Build a queue with this node in it.\\n queue = [node]\\n # Iterate the queue.\\n # When it's empty, we finished visiting a group of connected nodes.\\n while queue:\\n # Consume the next item from the queue.\\n node = queue.pop(0)\\n # Fetch the neighbors.\\n neighbors = set(x for x in node.fon if x.is_occupied == 1)\\n # Remove the neighbors we already visited.\\n neighbors.difference_update(group)\\n # Remove the remaining nodes from the global set.\\n nodes.difference_update(neighbors)\\n # Add them to the group of connected nodes.\\n group.update(neighbors)\\n # Add them to the queue, so we visit them in the next iterations.\\n queue.extend(neighbors)\\n\\n # Add the group to the list of groups.\\n result.append(len(group))\\n td = datetime.datetime.now() - t1\\n print(\\\"calculated {} connected components in {} seconds\\\".format(len(result),td.total_seconds()))\\n return len(result), np.histogram(result, self.cluster_hist_breaks)[0]\",\n \"def node_graph(imageSkeleton, imageGaussian):\\n ones = np.ones((3, 3))\\n imageFiltered = sp.ndimage.generic_filter(imageSkeleton, node_find, footprint=ones, mode='constant', cval=0)\\n imageNodeCondense = node_condense(imageFiltered, imageGaussian, ones)\\n imageLabeledNodes = skimage.segmentation.relabel_sequential(imageNodeCondense)[0]\\n imageLabeledSkeleton, labels = sp.ndimage.label(imageSkeleton, structure=ones)\\n for label in range(1, labels + 1):\\n detectedNodes = np.max((imageLabeledSkeleton == label) * (imageLabeledNodes > 0))\\n if (detectedNodes == 0):\\n imageSkeleton[imageLabeledSkeleton == label] = 0\\n imageAnnotated = 1 * ((imageSkeleton + imageLabeledNodes) > 0) + imageLabeledNodes\\n return(imageAnnotated)\",\n \"def estimate_community(X, Y, true_labels, method, n_communities):\\n stacked = np.vstack([X, Y])\\n\\n if method == \\\"mase\\\":\\n embedder = MultipleASE(2)\\n embeddings = embedder.fit_transform(stacked)\\n elif method == \\\"omni\\\":\\n embedder = OmnibusEmbed(2)\\n embeddings = embedder.fit_transform(stacked).mean(axis=0)\\n else:\\n assert ValueError(\\\"Invalid embedding method\\\")\\n\\n predicted_labels = GaussianCluster(n_communities, n_communities, \\\"all\\\").fit_predict(\\n embeddings\\n )\\n\\n # Label flipping\\n idx = true_labels == 0\\n if np.mean(predicted_labels[idx]) < 0.5:\\n return predicted_labels\\n else:\\n # This is bitwise flipping. Turns all 0s to 1s and 1s to 0s.\\n # Reason is to make labels consistent across repetitions\\n predicted_labels = predicted_labels ^ (predicted_labels & 1 == predicted_labels)\\n return predicted_labels\",\n \"def get_classification(self, cv2_image):\\n def get_green_mask(img_hsv):\\n lower_green = np.array([40, 10, 10])\\n upper_green = np.array([90, 255, 255])\\n mask = cv2.inRange(img_hsv, lower_green, upper_green)\\n return mask\\n\\n def get_red_mask(img_hsv):\\n # red lower mask (0-10)\\n lower_red = np.array([20, 1, 150])\\n upper_red = np.array([30, 120, 255])\\n mask0 = cv2.inRange(img_hsv, lower_red, upper_red)\\n\\n # Red upper mask\\n lower_red = np.array([170, 50, 50])\\n upper_red = np.array([180, 255, 255])\\n mask1 = cv2.inRange(img_hsv, lower_red, upper_red)\\n\\n # join my masks\\n mask = mask0 + mask1\\n return mask\\n\\n def get_traffic_light_color(cv2_image):\\n # Convert BGR to HSV\\n img_hsv = cv2.cvtColor(cv2_image, cv2.COLOR_BGR2HSV)\\n height, width, _ = img_hsv.shape\\n\\n green_mask = get_green_mask(img_hsv)\\n red_mask = get_red_mask(img_hsv)\\n\\n dico = {\\n TrafficLight.RED: np.count_nonzero(red_mask[0:int(height / 3), :]),\\n TrafficLight.YELLOW: np.count_nonzero(red_mask[int(height / 3):int(height * 2 / 3), :]),\\n TrafficLight.GREEN: np.count_nonzero(green_mask[int(height * 2 / 3):height, :])\\n }\\n\\n v = list(dico.values())\\n k = list(dico.keys())\\n return k[v.index(max(v))]\\n\\n output_dict = self.run_inference_for_single_image(cv2_image)\\n traffic_light_image = self.get_traffic_light(cv2_image, output_dict)\\n\\n # no traffic light found\\n if traffic_light_image is None:\\n return TrafficLight.UNKNOWN\\n\\n return get_traffic_light_color(traffic_light_image)\",\n \"def complex_network_mapping(graph):\\n vect = []\\n\\n n = nx.number_of_nodes(graph)\\n e = nx.number_of_edges(graph)\\n print n, e\\n\\n# adj = nx.adjacency_matrix(graph).toarray()\\n# adj_bin = np.where(adj > 0, 1., 0.)\\n# adj_conn = 1 - adj\\n adj_bin = nx.adjacency_matrix(graph).toarray()\\n adj_bin = np.array(adj_bin, dtype=np.float)\\n\\n # Node Betweenness binary\\n bt_bin = nx.betweenness_centrality(graph).values()\\n avg_btb = np.mean(bt_bin)\\n vect.append(avg_btb)\\n\\n # Edge betweenness\\n ebt = np.array(nx.edge_betweenness_centrality(graph).values())\\n vect.append(np.mean(ebt))\\n\\n # Eigen vector centrality binary\\n evc_bin = eigenvector_centrality_und(adj_bin)\\n avg_evcb = np.mean(evc_bin)\\n vect.append(avg_evcb)\\n\\n # Flow coefficient\\n _, flow_bin, _ = flow_coef_bd(adj_bin)\\n avg_flow = np.mean(flow_bin)\\n vect.append(avg_flow)\\n\\n # Kcoreness centrality\\n kcor_bin, _ = kcoreness_centrality_bu(adj_bin)\\n avg_kcor = np.mean(kcor_bin)\\n vect.append(avg_kcor)\\n\\n # Degree assortivity\\n dac = nx.degree_assortativity_coefficient(graph)\\n vect.append(dac)\\n\\n # Page rank centrality\\n# pgr_wei = pagerank_centrality(adj_bin, d=0.85)\\n# avg_pgr = np.mean(pgr_wei)\\n# vect.append(avg_pgr)\\n\\n # Rich club coefficient\\n# rcc = nx.rich_club_coefficient(graph).values()\\n# avg_rcc = np.mean(rcc)\\n# vect.append(avg_rcc)\\n\\n # Transitivity\\n tr = nx.transitivity(graph)\\n vect.append(tr)\\n\\n # average clustering\\n avg_clst = nx.average_clustering(graph)\\n vect.append(avg_clst)\\n\\n glb_ef = efficiency_bin(adj_bin)\\n vect.append(glb_ef)\\n\\n return vect\",\n \"def main():\\n G = nx.gnp_random_graph(100, 0.5)\\n centrality = nx.eigenvector_centrality(G)\\n avg_centrality = sum(centrality.values()) / len(G)\\n\\n def has_high_centrality(v):\\n return centrality[v] >= avg_centrality\\n\\n source = 0\\n value = centrality.get\\n condition = has_high_centrality\\n\\n found_node = progressive_widening_search(G, source, value, condition)\\n c = centrality[found_node]\\n print('found node {0} with centrality {1}'.format(found_node, c))\",\n \"def vis_detections(color_image, depth_colormap, class_col, dets_col, thresh=0.5):\\n\\n for cls_ind, class_name in enumerate(class_col):\\n dets = dets_col[cls_ind]\\n\\n inds = np.where(dets[:, -1] >= thresh)[0]\\n if len(inds) == 0:\\n continue\\n\\n for i in inds:\\n bbox = [int(e) for e in dets[i, :4]]\\n score = dets[i, -1]\\n \\n cv2.rectangle(color_image, (bbox[0], bbox[1]),\\n (bbox[2], bbox[3]), (0, 0, 255), 3)\\n cv2.rectangle(depth_colormap, (bbox[0], bbox[1]),\\n (bbox[2], bbox[3]), (0, 0, 255), 3)\\n\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n color_image = cv2.putText(color_image, '{:s} {:.3f}'.format(class_name, score),\\n (bbox[0], max(bbox[1] - 2, 1)), font, 0.5, (255, 255, 255), 2)\\n depth_colormap = cv2.putText(depth_colormap, '{:s} {:.3f}'.format(class_name, score),\\n (bbox[0], max(bbox[1] - 2, 1)), font, 0.5, (255, 255, 255), 2)\\n \\n # Stack both images horizontally\\n images = np.hstack((color_image, depth_colormap))\\n\\n # Show images\\n cv2.imshow('RealSense', images)\",\n \"def get_classification_simulator(self, image):\\n\\n r_channel = image[:,:,2]\\n g_channel = image[:,:,1]\\n\\n\\n\\n # Threshold color channel\\n s_rgy_min = 50\\n s_thresh_min = 245\\n s_thresh_max = 255\\n \\n #s_binary = np.zeros_like(r_channel)\\n r_binary = np.zeros_like(r_channel)\\n g_binary = np.zeros_like(r_channel)\\n y_binary = np.zeros_like(r_channel)\\n \\n #s_binary[((r_channel >= s_thresh_min) & (r_channel <= s_thresh_max)) | ((g_channel >= s_thresh_min) & (g_channel <= s_thresh_max))] = 1\\n \\n \\n r_binary[((r_channel >= s_thresh_min) & (r_channel <= s_thresh_max)) & (g_channel <= s_rgy_min)] = 1\\n g_binary[((g_channel >= s_thresh_min) & (g_channel <= s_thresh_max)) & (r_channel <= s_rgy_min)] = 1\\n y_binary[((r_channel >= s_thresh_min) & (r_channel <= s_thresh_max)) & ((g_channel >= s_thresh_min) & (g_channel <= s_thresh_max))] = 1\\n \\n\\n #res = cv2.bitwise_and(img,img,mask = s_binary)\\n \\n #maxx=image.shape[1]\\n maxy=image.shape[0]\\n \\n y_top=0\\n window_size_y=50\\n y_bottom=y_top+window_size_y\\n \\n max_color=0\\n tf_color=TrafficLight.UNKNOWN\\n \\n while (y_bottom< maxy):\\n #print(img[y_top:y_bottom,:,:])\\n rs= r_binary[y_top:y_bottom,:].sum()\\n gs= g_binary[y_top:y_bottom,:].sum()\\n ys= y_binary[y_top:y_bottom,:].sum()\\n if (rs>max_color):\\n max_color=rs\\n tf_color=TrafficLight.RED\\n if (gs>max_color):\\n max_color=gs\\n tf_color=TrafficLight.GREEN\\n if (ys>max_color):\\n max_color=ys\\n tf_color=TrafficLight.YELLOW\\n y_top+=window_size_y\\n y_bottom+=window_size_y\\n \\n if (max_color<100):\\n tf_color=TrafficLight.UNKNOWN\\n \\n\\n\\n return tf_color\",\n \"def attack_surface_coloring(graph, attack_surface):\\n color = []\\n\\n # takes a two-dimensional list\\n # and produces a one-dimensional list\\n # so we can check if each node is\\n # in the attack surface\\n flatten = lambda l: [item for sublist in l for item in sublist]\\n flat_attack_surface = flatten(attack_surface)\\n\\n for node in graph:\\n if node in flat_attack_surface:\\n color.append('red')\\n else:\\n color.append('grey')\\n return color\",\n \"def _naive_greedy_modularity_communities(G):\\n # First create one community for each node\\n communities = list([frozenset([u]) for u in G.nodes()])\\n # Track merges\\n merges = []\\n # Greedily merge communities until no improvement is possible\\n old_modularity = None\\n new_modularity = modularity(G, communities)\\n while old_modularity is None or new_modularity > old_modularity:\\n # Save modularity for comparison\\n old_modularity = new_modularity\\n # Find best pair to merge\\n trial_communities = list(communities)\\n to_merge = None\\n for i, u in enumerate(communities):\\n for j, v in enumerate(communities):\\n # Skip i=j and empty communities\\n if j <= i or len(u) == 0 or len(v) == 0:\\n continue\\n # Merge communities u and v\\n trial_communities[j] = u | v\\n trial_communities[i] = frozenset([])\\n trial_modularity = modularity(G, trial_communities)\\n if trial_modularity >= new_modularity:\\n # Check if strictly better or tie\\n if trial_modularity > new_modularity:\\n # Found new best, save modularity and group indexes\\n new_modularity = trial_modularity\\n to_merge = (i, j, new_modularity - old_modularity)\\n elif (\\n to_merge and\\n min(i, j) < min(to_merge[0], to_merge[1])\\n ):\\n # Break ties by choosing pair with lowest min id\\n new_modularity = trial_modularity\\n to_merge = (i, j, new_modularity - old_modularity)\\n # Un-merge\\n trial_communities[i] = u\\n trial_communities[j] = v\\n if to_merge is not None:\\n # If the best merge improves modularity, use it\\n merges.append(to_merge)\\n i, j, dq = to_merge\\n u, v = communities[i], communities[j]\\n communities[j] = u | v\\n communities[i] = frozenset([])\\n # Remove empty communities and sort\\n communities = [c for c in communities if len(c) > 0]\\n for com in sorted(communities, key=lambda x: len(x), reverse=True):\\n yield com\",\n \"def newCluster(color_cluster):\\n r = 0\\n g = 0\\n b = 0\\n count = 0\\n for cc in color_cluster:\\n count += cc[0]\\n r += cc[1][0] * cc[0]\\n g += cc[1][1] * cc[0]\\n b += cc[1][2] * cc[0]\\n\\n # print(\\\"r: \\\" + str(r))\\n # print(\\\"g: \\\" + str(g))\\n # print(\\\"b: \\\" + str(b))\\n # print(\\\"count: \\\" + str(count))\\n r_mean = int(r / count)\\n g_mean = int(g / count)\\n b_mean = int(b / count)\\n cluster = (r_mean, g_mean, b_mean)\\n # print(cluster)\\n return cluster\",\n \"def network_schematic(clusters, primaries, edges):\\n # Define the node positions (primaries on the left, secondaries on the right)\\n n = len(clusters)\\n pos = np.array([[1.-float(i in primaries), i] for i in range(n)])\\n\\n # Define the node features (label, size, color)\\n node_labels = [str(i) for i in range(n)]\\n \\n logn = np.array([np.log(len(c)) for c in clusters])\\n node_sizes = np.interp(logn, (logn.min(), logn.max()), (5, 50))\\n \\n node_colors = ['#ff7f0e' if i in primaries else '#1f77b4' for i in range(n)]\\n\\n # Define the nodes as sphere of radius proportional to the log of the cluster voxel content\\n graph_data = []\\n graph_data.append(go.Scatter(\\n x = pos[:,0],\\n y = pos[:,1],\\n mode = 'markers',\\n name = 'clusters',\\n marker = dict(\\n color = node_colors,\\n size = node_sizes,\\n ),\\n text = node_labels,\\n hoverinfo = 'text'\\n ))\\n\\n # Initialize the edges\\n edge_vertices = np.concatenate([[pos[i], pos[j], [None, None]] for i, j in zip(edges[0], edges[1])])\\n graph_data.append(go.Scatter(x = edge_vertices[:,0], y = edge_vertices[:,1],\\n mode = 'lines',\\n name = 'edges',\\n line = dict(\\n color = 'rgba(50, 50, 50, 0.5)',\\n width = 1\\n ),\\n hoverinfo = 'none'\\n ))\\n\\n return graph_data\",\n \"def _build_graph_general(self): \\n\\n #Find a canonical coloring scheme\\n #Each node has a color that is determined by the non-mapped aspects\\n nodecolors=set()\\n for nl in self.net.iter_node_layers():\\n nodecolors.add(self._slice_node_layer_not_allowed(nl))\\n nodecolors_sorted=sorted(list(nodecolors))\\n del nodecolors\\n self._assert_full_order(nodecolors_sorted)\\n self.colormap=dict( ((color,colorid) for colorid,color in enumerate(nodecolors_sorted) ))\\n\\n #each aux node has a color that is determined by the aspect\\n self.auxcolormap=dict( ((auxcolor, auxcolorid+len(self.colormap)) for auxcolorid,auxcolor in enumerate(sorted(self.asp)) ) )\\n\\n\\n #Add the underlying network\\n #node-layers:\\n for nl in self.net.iter_node_layers():\\n nlid=self._get_node_id(nl)\\n color=self._slice_node_layer_not_allowed(nl)\\n colorid=self.colormap[color]\\n self.add_node(nlid,colorid)\\n\\n #edges between node-layers:\\n for nl1 in self.net.iter_node_layers():\\n for nl2 in self.net[nl1]:\\n nl1id=self._get_node_id(nl1)\\n nl2id=self._get_node_id(nl2)\\n self.add_link(nl1id,nl2id)\\n\\n\\n #Add the auxiliary nodes and edges\\n #add the aux nodes\\n for a in self.asp:\\n for elayer in self.net.slices[a]:\\n auxid=self._get_auxnode_id( (a,elayer) )\\n auxcolorid=self.auxcolormap[a]\\n self.add_node(auxid,auxcolorid)\\n \\n #add the aux edges\\n for nl in self.net.iter_node_layers():\\n for a in self.asp:\\n nlid=self._get_node_id(nl)\\n auxid=self._get_auxnode_id( (a,nl[a]) )\\n self.add_link(nlid,auxid)\",\n \"def _naive_greedy_modularity_communities(G):\\r\\n # First create one community for each node\\r\\n communities = list([frozenset([u]) for u in G.nodes()])\\r\\n # Track merges\\r\\n merges = []\\r\\n # Greedily merge communities until no improvement is possible\\r\\n old_modularity = None\\r\\n new_modularity = modularity(G, communities)\\r\\n while old_modularity is None or new_modularity > old_modularity:\\r\\n # Save modularity for comparison\\r\\n old_modularity = new_modularity\\r\\n # Find best pair to merge\\r\\n trial_communities = list(communities)\\r\\n to_merge = None\\r\\n for i, u in enumerate(communities):\\r\\n for j, v in enumerate(communities):\\r\\n # Skip i=j and empty communities\\r\\n if j <= i or len(u) == 0 or len(v) == 0:\\r\\n continue\\r\\n # Merge communities u and v\\r\\n trial_communities[j] = u | v\\r\\n trial_communities[i] = frozenset([])\\r\\n trial_modularity = modularity(G, trial_communities)\\r\\n if trial_modularity >= new_modularity:\\r\\n # Check if strictly better or tie\\r\\n if trial_modularity > new_modularity:\\r\\n # Found new best, save modularity and group indexes\\r\\n new_modularity = trial_modularity\\r\\n to_merge = (i, j, new_modularity - old_modularity)\\r\\n elif (\\r\\n to_merge and\\r\\n min(i, j) < min(to_merge[0], to_merge[1])\\r\\n ):\\r\\n # Break ties by choosing pair with lowest min id\\r\\n new_modularity = trial_modularity\\r\\n to_merge = (i, j, new_modularity - old_modularity)\\r\\n # Un-merge\\r\\n trial_communities[i] = u\\r\\n trial_communities[j] = v\\r\\n if to_merge is not None:\\r\\n # If the best merge improves modularity, use it\\r\\n merges.append(to_merge)\\r\\n i, j, dq = to_merge\\r\\n u, v = communities[i], communities[j]\\r\\n communities[j] = u | v\\r\\n communities[i] = frozenset([])\\r\\n # Remove empty communities and sort\\r\\n communities = [c for c in communities if len(c) > 0]\\r\\n for com in sorted(communities, key=lambda x: len(x), reverse=True):\\r\\n yield com\",\n \"def colour_node(instance, reaction_colour='darkgrey', Xc_colour='orange', waste_colour='red', res_colour='limegreen', InPr_colour='lightblue'):\\n G, mapping = instance.network()\\n\\n # relabel\\n G = nx.relabel_nodes(G, mapping)\\n\\n node_dict_mapped = nodes_mapped(instance)\\n\\n waste, resources, intmed_products = instance.amenities()\\n\\n colour_map = []\\n\\n for nd in G:\\n # print(\\\"nd\\\",nd)\\n for nd_label, ammentity in node_dict_mapped.items():\\n # print(\\\"nd_label\\\",nd_label)\\n if nd_label == nd:\\n # print(nd, nd_label)\\n\\n if ammentity == \\\"r\\\":\\n colour_map.append(reaction_colour)\\n\\n elif ammentity == \\\"Xc\\\":\\n colour_map.append(Xc_colour)\\n\\n elif ammentity == \\\"w\\\":\\n colour_map.append(waste_colour)\\n\\n elif ammentity == \\\"Xr\\\":\\n colour_map.append(res_colour)\\n\\n elif ammentity == \\\"InPr\\\":\\n colour_map.append(InPr_colour)\\n return colour_map\",\n \"def demo(sess, net, color_image, depth_colormap):\\n\\n # Detect all object classes and regress object bounds\\n timer = Timer()\\n timer.tic()\\n scores, boxes = im_detect(sess, net, color_image)\\n timer.toc()\\n print('Detection took {:.3f}s for {:d} object proposals'.format(timer.total_time, boxes.shape[0]))\\n\\n # Visualize detections for each class\\n CONF_THRESH = 0.7\\n NMS_THRESH = 0.3\\n dets_col = []\\n cls_col = []\\n for cls_ind, cls in enumerate(CLASSES[1:]):\\n cls_ind += 1 # because we skipped background\\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n dets = np.hstack((cls_boxes,\\n cls_scores[:, np.newaxis])).astype(np.float32)\\n keep = nms(dets, NMS_THRESH)\\n dets = dets[keep, :]\\n dets_col.append(dets)\\n cls_col.append(cls)\\n\\n vis_detections(color_image, depth_colormap, cls_col, dets_col, thresh=CONF_THRESH)\\n\\n depth_col, bbox_col = calc_histogram(depth_image, cls_col, dets_col, thresh=CONF_THRESH)\\n print(\\\"box depth:\\\", depth_col[0], \\\"sucker depth:\\\", depth_col[1])\\n print(\\\"box bbox:\\\", bbox_col[0], \\\"sucker bbox\\\", bbox_col[1])\",\n \"def set_colors(graph):\\n colors = []\\n for n in graph.nodes():\\n node = graph.node[n]\\n if node['adopter'] == 1:\\n colors.append('b')\\n else:\\n colors.append('r')\\n \\n return colors\",\n \"def find_gate_posts(img, display_results=False):\\n\\n greyscale_image = cv2.cvtColor(img.astype(np.uint8), cv2.COLOR_GRAY2BGR)\\n cm_image = cv2.applyColorMap(greyscale_image, cv2.COLORMAP_VIRIDIS)\\n\\n kernel = np.ones((5, 5), np.uint8)\\n\\n # cm_image = cv2.erode(cm_image, kernel, iterations=1)\\n kernel = np.ones((5, 5), np.uint8)\\n cm_image = cv2.dilate(cm_image, kernel, iterations=3)\\n kernel = np.ones((4, 4), np.uint8)\\n cm_image = cv2.erode(cm_image, kernel, iterations=1)\\n\\n cm_image = cv2.medianBlur(cm_image, 5) # Removes salt and pepper noise\\n\\n cm_copy_image = cm_image\\n cv2.copyTo(cm_image, cm_copy_image)\\n\\n mask = mask_sonar_image(cm_image, display_results)\\n\\n cm_circles = cv2.findContours(mask, cv2.RETR_LIST,\\n cv2.CHAIN_APPROX_SIMPLE)[-2]\\n\\n cm_circles = list(filter(lambda x: (cv2.contourArea(x) > 200\\n and cv2.contourArea(x) < 5000),\\n cm_circles))\\n cm_circles = sorted(cm_circles,\\n key=lambda x: (arc_circ(x)),\\n reverse=False)\\n\\n cm_circles = list(filter(lambda x: (cv2.arcLength(x, True)**2/(4\\n * math.pi*cv2.contourArea(x)) > 2.5), cm_circles))\\n\\n if len(cm_circles) < 1:\\n print(\\\"Not enough circles found\\\")\\n return None\\n\\n filtered_circles = cm_circles[0:1]\\n\\n circle_positions = []\\n for circle in filtered_circles: # find center of circle code\\n M = cv2.moments(circle)\\n cX = int(M[\\\"m10\\\"] / M[\\\"m00\\\"])\\n cY = int(M[\\\"m01\\\"] / M[\\\"m00\\\"])\\n circle_positions.append((cX, cY, arc_circ(circle), cv2.arcLength(\\n circle, True)**2/(4*math.pi*cv2.contourArea(circle))))\\n\\n if display_results:\\n cv2.drawContours(cm_copy_image, filtered_circles, -1, (0, 255, 0), 2)\\n cv2.imshow(\\\"found_gate_posts\\\", cm_copy_image)\\n cv2.waitKey(0)\\n\\n return circle_positions\",\n \"def display_in_cytoscape(graph, network_name: str):\\n try:\\n cy = CyRestClient()\\n cytoscape_network = cy.network.create_from_networkx(network=graph, name=network_name, collection=\\\"Cluster comparison\\\")\\n\\n # add the layout\\n cy.layout.apply(name='force-directed', network=cytoscape_network)\\n\\n # add the style\\n # Step 6: Create Visual Style as code (or by hand if you prefer)\\n comparison_style = cy.style.create('Cluster Comparison')\\n\\n basic_settings = {\\n # You can set default values as key-value pairs.\\n 'NODE_FILL_COLOR': '#6AACB8',\\n 'NODE_SIZE': 55,\\n 'NODE_BORDER_WIDTH': 0,\\n 'NODE_LABEL_COLOR': '#555555',\\n\\n 'EDGE_WIDTH': 2,\\n 'EDGE_TRANSPARENCY': 100,\\n 'EDGE_STROKE_UNSELECTED_PAINT': '#333333',\\n\\n 'NETWORK_BACKGROUND_PAINT': '#FFFFFF'\\n }\\n\\n comparison_style.update_defaults(basic_settings)\\n\\n # Create some mappings\\n min_cluster_size = min([graph.node[c][\\\"size\\\"] for c in graph.nodes])\\n max_cluster_size = max([graph.node[c][\\\"size\\\"] for c in graph.nodes])\\n cluster_size_to_node_size = StyleUtil.create_slope(min=min_cluster_size, max=max_cluster_size, values=(30, 100))\\n comparison_style.create_continuous_mapping(column='size', vp='NODE_SIZE', col_type='Double',\\n points=cluster_size_to_node_size)\\n\\n comparison_style.create_discrete_mapping(column='source', vp=\\\"NODE_FILL_COLOR\\\", col_type=\\\"String\\\",\\n mappings={\\\"source1\\\": \\\"#FC8D62\\\", \\\"source2\\\": \\\"#A6D854\\\"})\\n comparison_style.create_passthrough_mapping(column='weight', vp=\\\"EDGE_WIDTH\\\", col_type=\\\"Integer\\\")\\n\\n # apply the style\\n cy.style.apply(style=comparison_style, network=cytoscape_network)\\n\\n except Exception as e:\\n print(\\\"Please open Cytoscape to display the graph: \\\" + str(e))\",\n \"def demo(net, image_name, classes):\\n\\n # Load pre-computed Selected Search object proposals\\n # box_file = os.path.join(cfg.ROOT_DIR, 'data', 'demo',image_name + '_boxes.mat')\\n test_mats_path = '/home/tanshen/fast-rcnn/data/kaggle/test_bbox'\\n box_file = os.path.join(test_mats_path ,image_name + '_boxes.mat')\\n obj_proposals = sio.loadmat(box_file)['boxes']\\n\\n # Load the demo image\\n test_images_path = '/home/tanshen/fast-rcnn/data/kaggle/ImagesTest'\\n # im_file = os.path.join(cfg.ROOT_DIR, 'data', 'demo', image_name + '.jpg')\\n im_file = os.path.join(test_images_path, image_name + '.jpg')\\n im = cv2.imread(im_file)\\n\\n # Detect all object classes and regress object bounds\\n timer = Timer()\\n timer.tic()\\n scores, boxes = im_detect(net, im, obj_proposals)\\n timer.toc()\\n # print ('Detection took {:.3f}s for '\\n # '{:d} object proposals').format(timer.total_time, boxes.shape[0])\\n\\n # Visualize detections for each class\\n CONF_THRESH = 0\\n NMS_THRESH = 0.3\\n max_inds = 0\\n max_score = 0.0\\n for cls in classes:\\n cls_ind = CLASSES.index(cls)\\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n keep = np.where(cls_scores >= CONF_THRESH)[0]\\n cls_boxes = cls_boxes[keep, :]\\n cls_scores = cls_scores[keep]\\n dets = np.hstack((cls_boxes,\\n cls_scores[:, np.newaxis])).astype(np.float32)\\n keep = nms(dets, NMS_THRESH)\\n dets = dets[keep, :]\\n # print 'All {} detections with p({} | box) >= {:.1f} in {}'.format(cls, cls,\\n # CONF_THRESH, image_name)\\n #if get_max!=[]: \\n\\n [ind,tmp]=get_max(im, cls, dets, thresh=CONF_THRESH)\\n #print image_name,cls,tmp\\n\\n #vis_detections(im, cls, dets, image_name, thresh=CONF_THRESH)\\n #print dets[:,-1]\\n #print image_name,max_score\\n file.writelines([image_name,'\\\\t',cls,'\\\\t',str(tmp),'\\\\n'])\\n if(max_score<tmp):\\n max_score=tmp\\n cls_max=cls\\n print image_name,cls_max,max_score\",\n \"def conservedMetabolismNeofunctionalisedECs(self, majorityPercentageCoreMetabolism = defaultMajorityPercentageCoreMetabolism, majorityPercentageNeofunctionalisation = defaultMajorityPercentageNeofunctionalisation, colour = False):\\n conservedMetabolism = self.conservedMetabolism(majorityPercentageCoreMetabolism)\\n \\n parentNeofunctionalised= self.parentClade.neofunctionalisedECs(majorityPercentageCoreMetabolism, majorityPercentageNeofunctionalisation, colour = False)\\n childNeofunctionalised = self.childClade.neofunctionalisedECs(majorityPercentageCoreMetabolism, majorityPercentageNeofunctionalisation, colour = False)\\n \\n if colour is True:\\n parentEdges = parentNeofunctionalised.getEdges()\\n childEdges = childNeofunctionalised.getEdges()\\n \\n graph = conservedMetabolism\\n \\n Export.addColourAttribute(graph, colour = Export.Colour.GREEN, nodes = False, edges = parentEdges)\\n Export.addColourAttribute(graph, colour = Export.Colour.YELLOW, nodes = False, edges = childEdges)\\n \\n graph.name = 'Conserved metabolism neofunctionalised ECs ' + ' '.join(self.parentNCBInames) + ' -> ' + ' '.join(self.childNCBInames)\\n \\n return graph\\n else:\\n parentGraph = conservedMetabolism[0].removeAllECsExcept(parentNeofunctionalised.getECs())\\n childGraph = conservedMetabolism[1].removeAllECsExcept(childNeofunctionalised.getECs())\\n \\n parentGraph.name = 'Conserved metabolism neofunctionalised ECs *' + ' '.join(self.parentNCBInames) + '* -> ' + ' '.join(self.childNCBInames)\\n childGraph.name = 'Conserved metabolism neofunctionalised ECs ' + ' '.join(self.parentNCBInames) + ' -> *' + ' '.join(self.childNCBInames) + '*'\\n \\n return (parentGraph, childGraph)\",\n \"def get_classification(self, image):\\n start_time = time.time()\\n # Runs inference on one image on the loaded graph\\n with self.inference_graph.as_default():\\n # Image is expanded to 4 dims - 1st dim batch size (=1)\\n image_4d = np.expand_dims(image, axis=0)\\n (boxes, scores, classes, num_det) = self.sess.run([self.d_boxes, self.d_scores, self.d_classes, self.num_d], feed_dict = {self.image_tensor: image_4d})\\n\\n end_time = time.time()\\n\\n rospy.logdebug(\\\"Time for classification: {0}s\\\".format(end_time - start_time))\\n\\n # Inference returns a (fixed) total of self.num_d detections - even those with low probabilities\\n r_boxes = []\\n r_scores = []\\n r_classes = []\\n idx = 0\\n\\n # If the highest score is below detection probability, there is no traffic light visible or not clear enough, return unknown\\n if scores[0][0] < DETECTION_LIMIT:\\n rospy.logdebug(\\\"No traffic light detected: UNKNOWN\\\")\\n return TrafficLight.UNKNOWN\\n\\n # Keep all results above probability of DETECTION_LIMIT\\n while (scores[0][idx] > DETECTION_LIMIT):\\n r_scores.append(scores[0][idx])\\n r_boxes.append(boxes[0][idx])\\n r_classes.append(classes[0][idx])\\n idx+=1\\n\\n # Classes for red, yellow and green lights\\n red = 1\\n yellow = 2\\n green = 3\\n yellow_or_not = False\\n\\n img_shape = image.shape\\n height = img_shape[0]\\n width = img_shape[1]\\n\\n # In simulator mode, feed each detection box to a color detector\\n # and return the classification result\\n if SIMULATOR_MODE:\\n \\n rectangles = [] # List of rectangles to cut out regions\\n\\n # Loops through all boundary boxes with found traffic lights and expands them to full image size (0..1 to 0..image_height and width)\\n for idx, box in enumerate(r_boxes):\\n box_norm = [int(box[0]*height), int(box[1]*width), int(box[2]*height), int(box[3]*width)]\\n rectangles.append(box_norm)\\n\\n # Loops through all the boundary boxes and detects their dominant light color\\n for rect in rectangles:\\n crop_image = image[rect[0]:rect[2], rect[1]:rect[3]]\\n classification = detect_color(crop_image)\\n if classification == red:\\n rospy.logdebug(\\\"Red traffic light detected\\\")\\n return TrafficLight.RED\\n elif classification == yellow:\\n yellow_or_not = True\\n\\n if yellow_or_not:\\n rospy.logdebug(\\\"Yellow traffic light detected\\\")\\n return TrafficLight.YELLOW\\n else:\\n rospy.logdebug(\\\"Green traffic light detected\\\")\\n return TrafficLight.GREEN\\n\\n # If not in simulator mode, use the detection result from the FRCNN classifier directly\\n else:\\n for classification in r_classes:\\n if classification == red:\\n rospy.logdebug(\\\"Red traffic light detected\\\")\\n return TrafficLight.RED\\n elif classification == yellow:\\n yellow_or_not = True\\n if yellow_or_not:\\n rospy.logdebug(\\\"Yellow traffic light detected\\\")\\n return TrafficLight.YELLOW\\n else:\\n rospy.logdebug(\\\"Green traffic light detected\\\")\\n return TrafficLight.GREEN\",\n \"def bipartite_color(G):\\n color={}\\n for n in G: # handle disconnected graphs\\n if n in color: continue\\n queue=[n] \\n color[n]=1 # nodes seen with color (1 or 0)\\n while queue:\\n v=queue.pop()\\n c=1-color[v] # opposite color of node v\\n for w in G[v]: \\n if w in color: \\n if color[w]==color[v]:\\n raise networkx.NetworkXError(\\\"Graph is not bipartite.\\\")\\n else:\\n color[w]=c\\n queue.append(w)\\n return color\",\n \"def DFS(adj): # adj is the list of vertices in graph G\\n\\n global cc\\n global visited\\n\\n for v in range(len(adj)): # adjacency list has length == number of nodes\\n visited[v] = False\\n cc = 1\\n\\n for v in range(len(adj)):\\n if not visited[v]:\\n explore(v)\\n # increment connected component count after each return from explore()\\n cc = cc + 1 # only increment for each unvisited node explored here\\n return cc\",\n \"def get_classification(self, image):\\n hsv_image = cv2.cvtColor(image,cv2.COLOR_BGR2HSV)\\n red_low = np.array([0, 100, 100],np.uint8)\\n red_high = np.array([10, 255, 255],np.uint8) \\n red1_low = np.array([160, 100, 100],np.uint8)\\n red1_high = np.array([179, 255, 255],np.uint8)\\n \\n if cv2.countNonZero(cv2.inRange(hsv_image,red_low,red_high))+cv2.countNonZero(cv2.inRange(hsv_image,red1_low,red1_high))>45:\\n return TrafficLight.RED\\n \\n yel_low = np.array([28, 100, 100],np.uint8)\\n yel_high = np.array([48, 255, 255],np.uint8)\\n if cv2.countNonZero(cv2.inRange(hsv_image, yel_low, yel_high)) > 45:\\n return TrafficLight.YELLOW\\n \\n gr_low = np.array([64, 100, 100],np.uint8)\\n gr_high = np.array([100, 255, 255],np.uint8)\\n if cv2.countNonZero(cv2.inRange(hsv_image, gr_low, gr_high)) > 45:\\n return TrafficLight.GREEN\\n \\n return TrafficLight.UNKNOWN\",\n \"def main(G): \\n try:\\n val_map = {'A': 1.0,\\n 'D': 0.5714285714285714,\\n 'H': 0.0}\\n values = [val_map.get(node, 0.45) for node in G.nodes()]\\n edge_colors = 'k'\\n \\n edge_labels=dict([((u,v,),d['weight'])\\n for u,v,d in G.edges(data=True)])\\n pos=nx.spring_layout(G) # positions for all nodes \\n nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels)\\n nx.draw(G,pos, node_color = values, node_size=15,edge_color=edge_colors,edge_cmap=plt.cm.Reds)\\n pylab.show()\\n\\n for ite in range(len(G.nodes())):\\n \\n Iterations = ite \\n SL = SIG.Single_linkage(G, Iterations)\\n pos=nx.spring_layout(G) # positions for all nodes\\n node_colors = ['b','g','r','y','c','k','m','w']\\n for i in range(len(G)):\\n node_colors.append('w')\\n \\n # nodes\\n C_list = SL.fit_predict(G)[-1,:]\\n for Clust in range(C_list.shape[1]):\\n nx.draw_networkx_nodes(G,pos,\\n nodelist = list(C_list[0,Clust]),\\n node_color=node_colors[Clust],\\n node_size=80,\\n alpha=0.8)\\n \\n # edges\\n nx.draw_networkx_edges(G,pos,width=1.0,alpha=0.5)\\n nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels)\\n \\n plt.axis('off')\\n plt.savefig(\\\"labels_and_colors.png\\\") # save as png\\n plt.show() # display\\n print \\\"in level :\\\",ite \\n print SL.__str__()\\n\\n\\n except SIG.Single_linkage_Error:\\n \\n print( \\\"Got an imput error, please change the input and try it again.\\\" )\",\n \"def get_classification(self, image):\\n #TODO implement light color prediction\\n \\n with self.graph.as_default():\\n img_expand = np.expand_dims(image, axis=0)\\n start = datetime.now() #start = datetime.datetime.now() if import datetime\\n (boxes, scores, classes, num_detections) = self.sess.run(\\n [self.boxes, self.scores, self.classes, self.num_detections],\\n feed_dict={self.image_tensor: img_expand}) \\n end = datetime.now() #end = datetime.datetime.now()\\n c = end - start\\n #rospy.logwarn(\\\"tl_classifier - Image predicted in: {0} seconds\\\".format(c.total_seconds()))\\n #print(c.total_seconds())\\n\\n boxes = np.squeeze(boxes)\\n scores = np.squeeze(scores)\\n classes = np.squeeze(classes).astype(np.int32)\\n\\n print('tl_classifier - CLASSES: 1=Green, 2=Red, 3=Yellow, 4=Unknown: ', classes[0])\\n #print('tl_classifier - SCORES: ', scores[0])\\n #print('tl_classifier - TrafficLight.GREEN: ', TrafficLight.GREEN) = 2 CLASSES: 1\\n #print('tl_classifier - TrafficLight.RED: ', TrafficLight.RED) = 0 CLASSES: 2\\n #print('tl_classifier - TrafficLight.YELLOW: ', TrafficLight.YELLOW) = 1 CLASSES: 3\\n #print('tl_classifier - TrafficLight.UNKNOWN: ', TrafficLight.UNKNOWN) = 4 CLASSES: 4\\n\\n if scores[0] > self.threshold:\\n if classes[0] == 1:\\n print('GREEN')\\n return TrafficLight.GREEN\\n elif classes[0] == 2:\\n print('RED')\\n return TrafficLight.RED\\n elif classes[0] == 3:\\n print('YELLOW')\\n return TrafficLight.YELLOW\\n else:\\n rospy.logwarn(\\\"Light: UNKNOWN\\\")\\n\\n \\n return TrafficLight.UNKNOWN\",\n \"def nodes(self, irc, msg, args, channel):\\n pie = self.instances[irc.network]\\n irc.reply([str(x) for x in pie.graphs[channel].nodes.values()])\",\n \"def neofunctionalisedECs(self, majorityPercentageCoreMetabolism = defaultMajorityPercentageCoreMetabolism, majorityPercentageNeofunctionalisation = defaultMajorityPercentageNeofunctionalisation, colour = False, eValue = defaultEValue, considerOnlyECs = None) -> SubstanceEcGraph:\\n # get neofunctionalisations \\n neofunctionalisedECs = NeofunctionalisedECs(self._neofunctionalisedEnzymes(majorityPercentageCoreMetabolism, eValue, considerOnlyECs))\\n \\n # filter core metabolism EC graph\\n coreMetabolism = self.coreMetabolism(majorityPercentageCoreMetabolism)\\n minimumOrganismsCount = math.ceil(self.organismsCount * (majorityPercentageNeofunctionalisation / 100))\\n \\n neofunctionalisedMetabolism = neofunctionalisedECs.filterGraph(coreMetabolism, minimumEcDifference = None, minimumOrganismsCount = minimumOrganismsCount)\\n \\n # colour core metabolism\\n if colour is not False:\\n \\n if colour is True:\\n colourToUse = Export.Colour.GREEN\\n else:\\n colourToUse = colour\\n \\n neofunctionalisedMetabolismOnly = neofunctionalisedMetabolism\\n neofunctionalisedMetabolism = coreMetabolism\\n Export.addColourAttribute(neofunctionalisedMetabolism, colourToUse, nodes = False, edges = neofunctionalisedMetabolismOnly.getEdges())\\n \\n neofunctionalisedMetabolism.name = 'Neofunctionalised core metabolism ' + ' '.join(self.ncbiNames)\\n \\n return neofunctionalisedMetabolism\",\n \"def process_graph(self, threshold=None):\\r\\n\\r\\n def find_head_end(head_name, descendant, end_op):\\r\\n # This helper function finds ends of Class Net and Box Net, based on a model type. \\r\\n # :param head_name: This is a common name that nodes in either Class or Box Nets start with.\\r\\n # :param descendant: Descendant of head_name, identified by operation (Transpose, MatMul, etc.).\\r\\n # :param end_op: Operation of a node you would like to get in the end of each Net.\\r\\n # These end_op nodes bring together prediction data based on type of model.\\r\\n # The Class Net end node will have shape [batch_size, num_anchors, num_classes],\\r\\n # and the Box Net end node has the shape [batch_size, num_anchors, 4].\\r\\n # These end nodes can be be found by searching for all end_op's operation nodes and checking if the node two\\r\\n # steps above in the graph has a name that begins with one of head_names for Class Net and Box Net respectively.\\r\\n for node in [node for node in self.graph.nodes if node.op == descendant and head_name in node.name]:\\r\\n target_node = self.graph.find_descendant_by_op(node, end_op)\\r\\n log.info(\\\"Found {} node '{}' as the tip of {}\\\".format(target_node.op, target_node.name, head_name))\\r\\n return target_node\\r\\n\\r\\n def extract_anchors_tensor(split):\\r\\n # This will find the anchors that have been hardcoded somewhere within the ONNX graph.\\r\\n # The function will return a gs.Constant that can be directly used as an input to the NMS plugin.\\r\\n # The anchor tensor shape will be [1, num_anchors, 4]. Note that '1' is kept as first dim, regardless of\\r\\n # batch size, as it's not necessary to replicate the anchors for all images in the batch.\\r\\n\\r\\n # The anchors are available (one per coordinate) hardcoded as constants within certain box decoder nodes.\\r\\n # Each of these four constants have shape [1, num_anchors], so some numpy operations are used to expand the\\r\\n # dims and concatenate them as needed.\\r\\n\\r\\n # These constants can be found by starting from the Box Net's split operation , and for each coordinate,\\r\\n # walking down in the graph until either an Add or specific Mul node is found. The second input on this nodes will\\r\\n # be the anchor data required.\\r\\n\\r\\n # Get Add anchor nodes\\r\\n def get_anchor_add(output_idx, op):\\r\\n node = self.graph.find_descendant_by_op(split.o(0, output_idx), op)\\r\\n assert node\\r\\n val = np.squeeze(node.inputs[1].values)\\r\\n return np.expand_dims(val.flatten(), axis=(0, 2))\\r\\n\\r\\n # Get Mul anchor nodes\\r\\n def get_anchor_mul(name, op):\\r\\n node = [node for node in self.graph.nodes if node.op == op and name == node.name][0]\\r\\n assert node\\r\\n val = np.squeeze(node.inputs[1].values)\\r\\n return np.expand_dims(val.flatten(), axis=(0, 2))\\r\\n\\r\\n \\r\\n anchors_y = get_anchor_add(0, \\\"Add\\\")\\r\\n anchors_x = get_anchor_add(1, \\\"Add\\\")\\r\\n anchors_h = None\\r\\n anchors_w = None\\r\\n\\r\\n # Based on a model type, naming of Mul nodes is slightly different, this will be improved in future to exclude branching.\\r\\n if \\\"ssd\\\" in self.model:\\r\\n anchors_h = get_anchor_mul(\\\"StatefulPartitionedCall/Postprocessor/Decode/mul_1\\\",\\\"Mul\\\")\\r\\n anchors_w = get_anchor_mul(\\\"StatefulPartitionedCall/Postprocessor/Decode/mul\\\",\\\"Mul\\\")\\r\\n elif \\\"faster_rcnn\\\" in self.model:\\r\\n anchors_h = get_anchor_mul(\\\"StatefulPartitionedCall/Decode/mul_1\\\",\\\"Mul\\\")\\r\\n anchors_w = get_anchor_mul(\\\"StatefulPartitionedCall/Decode/mul\\\",\\\"Mul\\\") \\r\\n\\r\\n batched_anchors = np.concatenate([anchors_y, anchors_x, anchors_h, anchors_w], axis=2)\\r\\n # Identify num of anchors without repetitions.\\r\\n num_anchors = int(batched_anchors.shape[1]/self.batch_size)\\r\\n # Trim total number of anchors in order to not have copies introduced by growing number of batch_size.\\r\\n anchors = batched_anchors[0:num_anchors,0:num_anchors]\\r\\n return gs.Constant(name=\\\"nms/anchors:0\\\", values=anchors)\\r\\n\\r\\n self.infer()\\r\\n\\r\\n def first_nms(background_class, score_activation, threshold):\\r\\n \\\"\\\"\\\"\\r\\n Updates the graph to replace the NMS op by BatchedNMS_TRT TensorRT plugin node.\\r\\n :param background_class: Set EfficientNMS_TRT's background_class atribute. \\r\\n :param score_activation: Set EfficientNMS_TRT's score_activation atribute. \\r\\n \\\"\\\"\\\"\\r\\n # Identify Class Net and Box Net head names based on model type.\\r\\n if self.model == 'ssd_mobilenet_v2_keras':\\r\\n head_names = ['StatefulPartitionedCall/BoxPredictor/ConvolutionalClassHead_', \\r\\n 'StatefulPartitionedCall/BoxPredictor/ConvolutionalBoxHead_']\\r\\n elif (self.model == 'ssd_mobilenet_v1_fpn_keras' or self.model == 'ssd_mobilenet_v2_fpn_keras' or \\r\\n self.model == 'ssd_resnet50_v1_fpn_keras' or self.model == 'ssd_resnet101_v1_fpn_keras' or \\r\\n self.model == 'ssd_resnet152_v1_fpn_keras'):\\r\\n head_names = ['StatefulPartitionedCall/WeightSharedConvolutionalBoxPredictor/WeightSharedConvolutionalClassHead',\\r\\n 'StatefulPartitionedCall/WeightSharedConvolutionalBoxPredictor/WeightSharedConvolutionalBoxHead']\\r\\n elif (self.model == 'faster_rcnn_resnet50_keras' or self.model == 'faster_rcnn_resnet101_keras' or \\r\\n self.model == 'faster_rcnn_resnet152_keras' or self.model == \\\"faster_rcnn_inception_resnet_v2_keras\\\"):\\r\\n head_names = ['StatefulPartitionedCall/FirstStageBoxPredictor/ConvolutionalClassHead_0/ClassPredictor',\\r\\n 'StatefulPartitionedCall/FirstStageBoxPredictor/ConvolutionalBoxHead_0/BoxEncodingPredictor']\\r\\n\\r\\n class_net = None\\r\\n box_net = None\\r\\n\\r\\n # Getting SSD's Class and Box Nets final tensors.\\r\\n if \\\"ssd\\\" in self.model:\\r\\n # Find the concat node at the end of the class net (multi-scale class predictor).\\r\\n class_net = find_head_end(head_names[0], \\\"Transpose\\\", \\\"Concat\\\")\\r\\n\\r\\n # SSD's slice operation to adjust third dimension of Class Net's last node tensor (adjusting class values).\\r\\n slice_start = np.asarray([1], dtype=np.int64)\\r\\n slice_end = np.asarray([91], dtype=np.int64)\\r\\n # Second list element but third tensor dimension.\\r\\n slice_axes = np.asarray([2], dtype=np.int64)\\r\\n slice_out = self.graph.elt_const_slice(\\\"Slice\\\", head_names[0]+\\\"/slicer\\\", class_net.outputs[0], slice_start, slice_end, slice_axes)\\r\\n\\r\\n # Final Class Net tensor.\\r\\n class_net_tensor = slice_out[0]\\r\\n\\r\\n if self.model == 'ssd_mobilenet_v2_keras':\\r\\n # Find the squeeze node at the end of the box net (multi-scale localization predictor).\\r\\n box_net = find_head_end(head_names[1], \\\"Transpose\\\", \\\"Concat\\\")\\r\\n box_net_squeeze = self.graph.find_descendant_by_op(box_net, \\\"Squeeze\\\")\\r\\n box_net_output = box_net_squeeze.outputs[0]\\r\\n\\r\\n elif (self.model == 'ssd_mobilenet_v1_fpn_keras' or self.model == 'ssd_mobilenet_v2_fpn_keras' or \\r\\n self.model == 'ssd_resnet50_v1_fpn_keras' or self.model == 'ssd_resnet101_v1_fpn_keras' or \\r\\n self.model == 'ssd_resnet152_v1_fpn_keras'):\\r\\n # Find the concat node at the end of the box net (multi-scale localization predictor).\\r\\n box_net = find_head_end(head_names[1], \\\"Transpose\\\", \\\"Concat\\\")\\r\\n box_net_output = box_net.outputs[0]\\r\\n\\r\\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale box_net_output in order to get accurate coordinates.\\r\\n scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\\r\\n scale_out = self.graph.elt_const(\\\"Mul\\\", head_names[1]+\\\"/scale\\\", box_net_output, scale_adj)\\r\\n\\r\\n # Final Box Net tensor.\\r\\n box_net_tensor = scale_out[0]\\r\\n \\r\\n # Getting Faster R-CNN's 1st Class and Box Nets tensors.\\r\\n elif \\\"faster_rcnn\\\" in self.model:\\r\\n if (self.model == 'faster_rcnn_resnet50_keras' or self.model == 'faster_rcnn_resnet101_keras' or \\r\\n self.model == 'faster_rcnn_resnet152_keras' or self.model == \\\"faster_rcnn_inception_resnet_v2_keras\\\"):\\r\\n # Find the softmax node at the end of the class net (multi-scale class predictor).\\r\\n class_net = find_head_end(head_names[0], \\\"Transpose\\\", \\\"Softmax\\\")\\r\\n\\r\\n # Final Class Net tensor\\r\\n class_net_tensor = class_net.outputs[0] \\r\\n\\r\\n # Find the reshape node at the end of the box net (multi-scale localization predictor).\\r\\n box_net = find_head_end(head_names[1], \\\"Transpose\\\", \\\"Reshape\\\")\\r\\n # Final Box Net tensor.\\r\\n box_net_output = box_net.outputs[0]\\r\\n\\r\\n #Insert a squeeze node\\r\\n squeeze_node = self.graph.squeeze(head_names[1]+\\\"/squeeze\\\", box_net_output)\\r\\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale box_net_output, in order to get accurate coordinates.\\r\\n scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\\r\\n scale_out = self.graph.elt_const(\\\"Mul\\\", head_names[1]+\\\"/scale\\\", squeeze_node, scale_adj)\\r\\n\\r\\n # Final Box Net tensor.\\r\\n box_net_tensor = scale_out[0]\\r\\n\\r\\n\\r\\n # 3. Find the split node that separates the box net coordinates and feeds them into the box decoder.\\r\\n box_net_split = self.graph.find_descendant_by_op(box_net, \\\"Split\\\")\\r\\n assert box_net_split and len(box_net_split.outputs) == 4\\r\\n\\r\\n # Set score threshold\\r\\n score_threshold = self.first_stage_nms_score_threshold if threshold is None else threshold\\r\\n\\r\\n # NMS Inputs and Attributes\\r\\n # NMS expects these shapes for its input tensors:\\r\\n # box_net: [batch_size, number_boxes, 4]\\r\\n # class_net: [batch_size, number_boxes, number_classes]\\r\\n # anchors: [1, number_boxes, 4] (if used)\\r\\n nms_op = None\\r\\n nms_attrs = None\\r\\n nms_inputs = None\\r\\n\\r\\n # EfficientNMS TensorRT Plugin is suitable for our use case.\\r\\n # Fusing the decoder will always be faster, so this is the default NMS method supported. In this case,\\r\\n # three inputs are given to the NMS TensorRT node:\\r\\n # - The box predictions (from the Box Net node found above)\\r\\n # - The class predictions (from the Class Net node found above)\\r\\n # - The default anchor coordinates (from the extracted anchor constants)\\r\\n # As the original tensors from given model will be used, the NMS code type is set to 1 (Center+Size),\\r\\n # because this is the internal box coding format used by the network.\\r\\n anchors_tensor = extract_anchors_tensor(box_net_split)\\r\\n nms_inputs = [box_net_tensor, class_net_tensor, anchors_tensor]\\r\\n nms_op = \\\"EfficientNMS_TRT\\\"\\r\\n nms_attrs = {\\r\\n 'plugin_version': \\\"1\\\",\\r\\n 'background_class': background_class,\\r\\n 'max_output_boxes': self.first_stage_max_proposals,\\r\\n 'score_threshold': max(0.01, score_threshold),\\r\\n 'iou_threshold': self.first_stage_nms_iou_threshold,\\r\\n 'score_activation': score_activation,\\r\\n 'box_coding': 1,\\r\\n }\\r\\n nms_output_classes_dtype = np.int32\\r\\n\\r\\n # NMS Outputs.\\r\\n nms_output_num_detections = gs.Variable(name=\\\"num_detections\\\", dtype=np.int32, shape=[self.batch_size, 1])\\r\\n nms_output_boxes = gs.Variable(name=\\\"detection_boxes\\\", dtype=np.float32,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals, 4])\\r\\n nms_output_scores = gs.Variable(name=\\\"detection_scores\\\", dtype=np.float32,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals])\\r\\n nms_output_classes = gs.Variable(name=\\\"detection_classes\\\", dtype=nms_output_classes_dtype,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals])\\r\\n\\r\\n nms_outputs = [nms_output_num_detections, nms_output_boxes, nms_output_scores, nms_output_classes]\\r\\n\\r\\n # Create the NMS Plugin node with the selected inputs. \\r\\n self.graph.plugin(\\r\\n op=nms_op,\\r\\n name=\\\"nms/non_maximum_suppression_first\\\",\\r\\n inputs=nms_inputs,\\r\\n outputs=nms_outputs,\\r\\n attrs=nms_attrs)\\r\\n log.info(\\\"Created NMS plugin '{}' with attributes: {}\\\".format(nms_op, nms_attrs))\\r\\n\\r\\n # If model type is SSD, then you are done with conversion and optimizations.\\r\\n if \\\"ssd\\\" in self.model:\\r\\n self.graph.outputs = nms_outputs\\r\\n self.infer()\\r\\n return None\\r\\n # If model is Faster R-CNN, then you continue with conversion and optimizations,\\r\\n # next step is CropAndResize. \\r\\n elif \\\"faster_rcnn\\\" in self.model:\\r\\n return nms_outputs[1]\\r\\n\\r\\n def crop_and_resize(input):\\r\\n \\\"\\\"\\\"\\r\\n Updates the graph to replace the cropAndResize op by CropAndResize TensorRT plugin node.\\r\\n :param input: Input tensor is the output from previous first_nms() step. \\r\\n \\\"\\\"\\\"\\r\\n\\r\\n # Locate the last Relu node of the first backbone (pre 1st NMS). Relu node contains feature maps\\r\\n # necessary for CropAndResize plugin.\\r\\n relu_name = \\\"StatefulPartitionedCall/model/\\\"\\r\\n relu_node = [node for node in self.graph.nodes if node.op == \\\"Relu\\\" and relu_name in node.name][-1]\\r\\n\\r\\n # Before passing 1st NMS's detection boxes (rois) to CropAndResize, we need to clip and normalize them.\\r\\n # Clipping happens for coordinates that are less than 0 and more than self.height.\\r\\n # Normalization is just divison of every coordinate by self.height.\\r\\n clip_min = np.asarray([0], dtype=np.float32)\\r\\n clip_max = np.asarray([self.height], dtype=np.float32)\\r\\n clip_out = self.graph.elt_const_clip(\\\"Clip\\\", \\\"FirstNMS/detection_boxes_clipper\\\", input, clip_min, clip_max)\\r\\n div_const = np.expand_dims(np.asarray([self.height, self.height, self.height, self.height], dtype=np.float32), axis=(0, 1))\\r\\n div_out = self.graph.elt_const(\\\"Div\\\", \\\"FirstNMS/detection_boxes_normalizer\\\", clip_out[0], div_const)\\r\\n\\r\\n # Linear transformation to convert box coordinates from (TopLeft, BottomRight) Corner encoding\\r\\n # to CenterSize encoding.\\r\\n matmul_const = np.matrix('0.5 0 -1 0; 0 0.5 0 -1; 0.5 0 1 0; 0 0.5 0 1', dtype=np.float32)\\r\\n matmul_out = self.graph.elt_const(\\\"MatMul\\\", \\\"FirstNMS/detection_boxes_conversion\\\", div_out[0], matmul_const)\\r\\n\\r\\n # Additionally CropAndResizePlugin requires 4th dimension of 1: [N, B, 4, 1], so\\r\\n # we need to add unsqeeze node to make tensor 4 dimensional. \\r\\n unsqueeze_node = self.graph.unsqueeze( \\\"FirstNMS/detection_boxes_unsqueeze\\\", div_out)\\r\\n\\r\\n # CropAndResizePlugin's inputs \\r\\n feature_maps = relu_node.outputs[0]\\r\\n rois = unsqueeze_node[0]\\r\\n\\r\\n # CropAndResize TensorRT Plugin.\\r\\n # Two inputs are given to the CropAndResize TensorRT node:\\r\\n # - The feature_maps (from the Relu node found above): [batch_size, channel_num, height, width]\\r\\n # - The rois (in other words clipped and normalized detection boxes resulting fromm 1st NMS): [batch_size, featuremap, 4, 1]\\r\\n cnr_inputs = [feature_maps, rois]\\r\\n cnr_op = \\\"CropAndResize\\\"\\r\\n cnr_attrs = {\\r\\n 'crop_width': self.initial_crop_size,\\r\\n 'crop_height': self.initial_crop_size,\\r\\n }\\r\\n\\r\\n # CropAndResize Outputs.\\r\\n cnr_pfmap = gs.Variable(name=\\\"pfmap\\\", dtype=np.float32,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals, feature_maps.shape[1], self.initial_crop_size, self.initial_crop_size])\\r\\n cnr_outputs = [cnr_pfmap]\\r\\n\\r\\n # Create the CropandResize Plugin node with the selected inputs. \\r\\n self.graph.plugin(\\r\\n op=cnr_op,\\r\\n name=\\\"cnr/crop_and_resize\\\",\\r\\n inputs=cnr_inputs,\\r\\n outputs=cnr_outputs,\\r\\n attrs=cnr_attrs)\\r\\n log.info(\\\"Created CropAndResize plugin '{}' with attributes: {}\\\".format(cnr_op, cnr_attrs))\\r\\n\\r\\n # Reshape node that is preparing CropAndResize's pfmap output shape for MaxPool node that comes next,\\r\\n # after that is 2nd backbone that leads us to final 2nd NMS.\\r\\n reshape_shape = np.asarray([self.first_stage_max_proposals*self.batch_size, feature_maps.shape[1], self.initial_crop_size, self.initial_crop_size], dtype=np.int64)\\r\\n reshape_node = self.graph.elt_const(\\\"Reshape\\\", \\\"StatefulPartitionedCall/CropandResize/reshape\\\", cnr_outputs[0], reshape_shape)\\r\\n maxpl_name = \\\"StatefulPartitionedCall/MaxPool2D/MaxPool\\\"\\r\\n maxpool_node = [node for node in self.graph.nodes if node.op == \\\"MaxPool\\\" and maxpl_name == node.name][0]\\r\\n maxpool_node.inputs[0] = reshape_node[0]\\r\\n\\r\\n # Return linear transformation node, it will be located between 1st and 2nd NMS, \\r\\n # so we need to pass and connect it to 2nd NMS.\\r\\n return matmul_out[0]\\r\\n\\r\\n def second_nms(input, threshold):\\r\\n \\\"\\\"\\\"\\r\\n Updates the graph to replace the 2nd NMS op by BatchedNMS_TRT TensorRT plugin node.\\r\\n :param input: MatMul node that sits between 1st and 2nd NMS nodes.\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n # Identify Class Net and Box Net head names.\\r\\n second_head_names = ['StatefulPartitionedCall/mask_rcnn_keras_box_predictor/mask_rcnn_class_head/ClassPredictor_dense',\\r\\n 'StatefulPartitionedCall/mask_rcnn_keras_box_predictor/mask_rcnn_box_head/BoxEncodingPredictor_dense']\\r\\n\\r\\n # Find the softmax node at the end of the 2nd class net (multi-scale class predictor).\\r\\n second_class_net = find_head_end(second_head_names[0], \\\"MatMul\\\", \\\"Softmax\\\")\\r\\n\\r\\n # Faster R-CNN's slice operation to adjust third dimension of Class Net's last node tensor (adjusting class values).\\r\\n slice_start = np.asarray([1], dtype=np.int64)\\r\\n slice_end = np.asarray([91], dtype=np.int64)\\r\\n # Second list element but third tensor dimension.\\r\\n slice_axes = np.asarray([2], dtype=np.int64)\\r\\n slice_out = self.graph.elt_const_slice(\\\"Slice\\\", second_head_names[0]+\\\"/slicer\\\", second_class_net.outputs[0], slice_start, slice_end, slice_axes)\\r\\n\\r\\n # Final Class Net tensor.\\r\\n second_class_net_tensor = slice_out[0]\\r\\n \\r\\n # Find the add node at the end of the box net (multi-scale localization predictor).\\r\\n second_box_net = find_head_end(second_head_names[1], \\\"MatMul\\\", \\\"Add\\\")\\r\\n # Final Box Net tensor.\\r\\n second_box_net_output = second_box_net.outputs[0]\\r\\n\\r\\n # Reshape node that is preparing second_box_net_output's output shape for Mul scaling node that comes next.\\r\\n reshape_shape_second = np.asarray([self.batch_size, self.first_stage_max_proposals, second_box_net.outputs[0].shape[1]], dtype=np.int64)\\r\\n reshape_node_second = self.graph.elt_const(\\\"Reshape\\\", second_head_names[1]+\\\"/reshape\\\", second_box_net_output, reshape_shape_second)\\r\\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale second_box_net_output, in order to get accurate coordinates.\\r\\n second_scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\\r\\n second_scale_out = self.graph.elt_const(\\\"Mul\\\", second_head_names[1]+\\\"/scale_second\\\", reshape_node_second[0], second_scale_adj)\\r\\n\\r\\n # Final Box Net tensor.\\r\\n second_box_net_tensor = second_scale_out[0]\\r\\n\\r\\n # Set score threshold\\r\\n score_threshold = self.second_score_threshold if threshold is None else threshold\\r\\n\\r\\n # NMS Inputs and Attributes\\r\\n # NMS expects these shapes for its input tensors:\\r\\n # box_net: [batch_size, number_boxes, 4]\\r\\n # class_net: [batch_size, number_boxes, number_classes]\\r\\n # anchors: [1, number_boxes, 4] (if used)\\r\\n second_nms_op = None\\r\\n second_nms_attrs = None\\r\\n second_nms_inputs = None\\r\\n\\r\\n # EfficientNMS TensorRT Plugin is suitable for our use case.\\r\\n # Fusing the decoder will always be faster, so this is the default NMS method supported. In this case,\\r\\n # three inputs are given to the NMS TensorRT node:\\r\\n # - The box predictions (from the Box Net node found above)\\r\\n # - The class predictions (from the Class Net node found above)\\r\\n # - The default anchor coordinates (from the extracted anchor constants)\\r\\n # As the original tensors from given model will be used, the NMS code type is set to 1 (Center+Size),\\r\\n # because this is the internal box coding format used by the network.\\r\\n second_nms_inputs = [second_box_net_tensor, second_class_net_tensor, input]\\r\\n second_nms_op = \\\"EfficientNMS_TRT\\\"\\r\\n second_nms_attrs = {\\r\\n 'plugin_version': \\\"1\\\",\\r\\n 'background_class': -1,\\r\\n 'max_output_boxes': self.first_stage_max_proposals,\\r\\n 'score_threshold': max(0.01, score_threshold),\\r\\n 'iou_threshold': self.second_iou_threshold,\\r\\n 'score_activation': False,\\r\\n 'box_coding': 1,\\r\\n }\\r\\n second_nms_output_classes_dtype = np.int32\\r\\n\\r\\n # NMS Outputs.\\r\\n second_nms_output_num_detections = gs.Variable(name=\\\"second_num_detections\\\", dtype=np.int32, shape=[self.batch_size, 1])\\r\\n second_nms_output_boxes = gs.Variable(name=\\\"second_detection_boxes\\\", dtype=np.float32,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals, 4])\\r\\n second_nms_output_scores = gs.Variable(name=\\\"second_detection_scores\\\", dtype=np.float32,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals])\\r\\n second_nms_output_classes = gs.Variable(name=\\\"second_detection_classes\\\", dtype=second_nms_output_classes_dtype,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals])\\r\\n\\r\\n second_nms_outputs = [second_nms_output_num_detections, second_nms_output_boxes, second_nms_output_scores, second_nms_output_classes]\\r\\n\\r\\n # Create the NMS Plugin node with the selected inputs. \\r\\n self.graph.plugin(\\r\\n op=second_nms_op,\\r\\n name=\\\"nms/non_maximum_suppression_second\\\",\\r\\n inputs=second_nms_inputs,\\r\\n outputs=second_nms_outputs,\\r\\n attrs=second_nms_attrs)\\r\\n log.info(\\\"Created NMS plugin '{}' with attributes: {}\\\".format(second_nms_op, second_nms_attrs))\\r\\n \\r\\n # Set graph outputs.\\r\\n self.graph.outputs = second_nms_outputs\\r\\n\\r\\n self.infer()\\r\\n\\r\\n # If you model is SSD, you need only one NMS and nothin else.\\r\\n if \\\"ssd\\\" in self.model:\\r\\n first_nms_output = first_nms(-1, True, threshold)\\r\\n # If your model is Faster R-CNN, you will need 2 NMS nodes with CropAndResize in between.\\r\\n elif \\\"faster_rcnn\\\" in self.model:\\r\\n first_nms_output = first_nms(0, False, threshold)\\r\\n cnr_output = crop_and_resize(first_nms_output)\\r\\n second_nms(cnr_output, threshold)\",\n \"def slicem_cluster(self, community_detection, network_from, wt_steps, n_clust, neighbors, top, drop_nodes):\\n #TODO: change to prevent cluster on exception\\n global scores_update, drop, flat, clusters, G, colors \\n \\n if len(n_clust) == 0:\\n n_clust = None # Cluster at optimum modularity\\n else:\\n n_clust = int(n_clust)\\n \\n if len(drop_nodes) > 0:\\n try:\\n drop = [int(n) for n in drop_nodes.split(',')]\\n print('dropping nodes:', drop)\\n scores_update = {}\\n for pair, score in complete_scores.items():\\n if pair[0] in drop or pair[1] in drop:\\n next\\n else:\\n scores_update[pair] = score\\n except:\\n self.show_drop_list_msg()\\n else:\\n drop = []\\n scores_update = complete_scores\\n\\n flat, clusters, G = self.create_network(\\n community_detection=community_detection, \\n wt_steps=wt_steps,\\n n_clust=n_clust,\\n network_from=network_from, \\n neighbors=neighbors, \\n top=top\\n )\\n colors = get_plot_colors(clusters, G)\\n print('clusters computed!')\",\n \"def _extract_codes_on_node(self, layout_info):\\n\\n codes_on_node = set()\\n\\n # 1. Set the no. of nodes required for this Run\\n # Get the ranks per node for each run\\n num_ranks_per_run = {}\\n for rank_info in layout_info['cpu']:\\n if rank_info is not None:\\n run_name = rank_info.split(':')[0]\\n rank_id = int(rank_info.split(':')[1])\\n if run_name not in list(num_ranks_per_run.keys()):\\n num_ranks_per_run[run_name] = set()\\n num_ranks_per_run[run_name].add(rank_id)\\n\\n # set the no. of nodes for the codes on this node\\n for code in num_ranks_per_run:\\n run = self._get_run_by_name(code)\\n run.nodes = math.ceil(run.nprocs/len(num_ranks_per_run[code]))\\n\\n # 2. Create the node config for each Run\\n # Add run to codes_on_node and create nodeconfig for each run\\n for run_name in num_ranks_per_run.keys():\\n num_ranks_per_node = len(num_ranks_per_run[run_name])\\n run = self._get_run_by_name(run_name)\\n codes_on_node.add(run)\\n run.node_config = NodeConfig()\\n run.node_config.num_ranks_per_node = num_ranks_per_node\\n for i in range(num_ranks_per_node):\\n # Every rank for this run has a list of cpu and gpu cores\\n run.node_config.cpu.append([])\\n run.node_config.gpu.append([])\\n\\n # #--------------------------------------------------------------------#\\n # # 241. Disable node sharing for Summit due to ERF issue.\\n # if self.machine_name.lower() == 'summit':\\n # if len(codes_on_node) > 1:\\n # raise Exception(\\\"Node-sharing on Summit temporarily disabled \\\"\\\\\\n # \\\"due to a jsrun issue.\\\")\\n # # --------------------------------------------------------------------#\\n\\n # Loop over the cpu core mapping\\n for i in range(len(layout_info['cpu'])):\\n rank_info = layout_info['cpu'][i]\\n\\n # if the core is not mapped, go to the next one\\n if rank_info is None:\\n continue\\n\\n run_name = rank_info.split(':')[0]\\n rank_id = rank_info.split(':')[1]\\n run = self._get_run_by_name(run_name)\\n\\n # append core id to the rank id of this run\\n run.node_config.cpu[int(rank_id)].append(i)\\n\\n # Loop over the gpu mapping\\n for i in range(len(layout_info['gpu'])):\\n rank_list = layout_info['gpu'][i]\\n if rank_list is not None:\\n for rank_info in rank_list:\\n run_name = rank_info.split(':')[0]\\n rank_id = rank_info.split(':')[1]\\n run = self._get_run_by_name(run_name)\\n run.node_config.gpu[int(rank_id)].append(i)\\n\\n return list(codes_on_node)\",\n \"def findCluster(path, bound_img_path):\\r\\n image = cv2.imread(path, cv2.IMREAD_COLOR)\\r\\n img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\\r\\n blur = cv2.medianBlur(img, 3)\\r\\n thresh = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]\\r\\n\\r\\n # Creating a structuring element to perform morphological operations\\r\\n k_size = (3, 3)\\r\\n kernelMorph = cv2.getStructuringElement(cv2.MORPH_RECT, k_size)\\r\\n\\r\\n # Performing opening on the image\\r\\n morph = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernelMorph, iterations=1)\\r\\n\\r\\n # Performing dilation on the image\\r\\n ksizeKernelDilate = (50, 1)\\r\\n dilated = cv2.dilate(morph, ksizeKernelDilate, iterations= 5)\\r\\n\\r\\n # Identifying contours in the image\\r\\n cnts = cv2.findContours(dilated, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\r\\n cnts = cnts[0] if len(cnts) == 2 else cnts[1]\\r\\n clr1, clr2, clr3 = 225, 255, 0,\\r\\n b = 10\\r\\n\\r\\n bounding_box_created = False\\r\\n if len(cnts) != 0:\\r\\n contour_rect_box = []\\r\\n conimage = []\\r\\n for c in cnts:\\r\\n # Identifying bounding box dimensions for each contour\\r\\n x, y, w, h = cv2.boundingRect(c)\\r\\n # Enclosing the contours in a rectangle\\r\\n if (w > 10 and h > 10 and w < img.shape[0] and h < img.shape[1]):\\r\\n conimage = cv2.rectangle(image, (x - b, y - b), (x - b + w + 2 * b, y - b + h + 2 * b),\\r\\n (clr1, clr2, clr3), -1)\\r\\n contour_rect_box.append((x, y, x + w, y + h, w, h))\\r\\n\\r\\n # Check whether the bounding box is created or not\\r\\n # If bounding box is created, then update the image with the identified bounding box,\\r\\n # Else print no clusters have been identified\\r\\n if len(conimage) > 0:\\r\\n cv2.imwrite(bound_img_path, conimage)\\r\\n bounding_box_created = True\\r\\n else:\\r\\n print(\\\"No clusters identified\\\")\\r\\n return cnts, bounding_box_created\",\n \"def compute_node_dissociation_index(community_vect, sparse_mat):\\n dense_mat = sparse_mat.todense()\\n undir_dense_mat = dense_mat + np.transpose(dense_mat)\\n bin_dense_mat = np.array(undir_dense_mat != 0, dtype=int)\\n\\n degree_vect = np.array(np.sum(bin_dense_mat != 0, axis=1), dtype='float')\\n community_indexes = np.unique(community_vect)\\n\\n ndi_values = np.ones(\\n shape=(community_vect.shape[0]), dtype='float')\\n\\n for i in range(ndi_values.shape[0]):\\n\\n \\\"\\\"\\\"\\n same_com = np.where(\\n np.array([community_vect[i] == community_vect[j] for j in\\n range(ndi_values.shape[0])],dtype = \\\"bool\\\") == True)\\n\\n print (same_com[0])\\n\\n val = 1.0-(np.sum(bin_dense_mat[i,\\n same_com[0]])/float(degree_vect[i]))\\n \\\"\\\"\\\"\\n\\n val2 = 0.0\\n\\n for j in community_indexes:\\n if j != -1 and j != community_vect[i]:\\n val2 += np.sum(bin_dense_mat[i, community_vect == j])\\n\\n if degree_vect[i]:\\n ndi_values[i] = val2/float(degree_vect[i])\\n\\n else:\\n print(\\\"Warning, degree is null for node {}\\\".format(i))\\n print(bin_dense_mat)\\n\\n ndi_values[i] = 0.0\\n\\n return ndi_values\",\n \"def get_classification(self, image):\\n if self.correct_gamma:\\n if self.gamma == 1.0:\\n self.gamma = 0.6\\n elif self.gamma == 0.6:\\n self.gamma = 1.0\\n image = self.adjust_gamma(image, self.gamma)\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n image_np = np.asarray(image, dtype=\\\"uint8\\\")\\n image_np_expanded = np.expand_dims(image_np, axis=0)\\n\\n detected = False\\n\\n with self.detection_graph.as_default():\\n (boxes, scores, classes, num) = self.sess.run(\\n [self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections],\\n feed_dict={self.image_tensor: image_np_expanded})\\n boxes = np.squeeze(boxes)\\n classes = np.squeeze(classes).astype(np.int32)\\n scores = np.squeeze(scores)\\n best_scores = []\\n\\n for idx, classID in enumerate(classes):\\n if self.MODEL_NAME == 'ssdlite_mobilenet_v2_coco_2018_05_09':\\n if classID == 10: # 10 is traffic light\\n if scores[idx] > 0.10: #confidence level\\n best_scores.append([scores[idx], idx, classID])\\n detected = True\\n else: # we tuned the model to classify only traffic lights\\n if scores[idx] > 0.10: # confidence level\\n best_scores.append([scores[idx], idx, classID])\\n detected = True\\n\\n tl_index = TrafficLight.UNKNOWN\\n if detected:\\n best_scores.sort(key=lambda tup: tup[0], reverse=True)\\n\\n best_score = best_scores[0]\\n rospy.logdebug(\\\"number of TL found %d, best score: %f, color: %f\\\", len(best_scores), best_score[0], best_score[2])\\n nbox = boxes[best_score[1]]\\n\\n height = image.shape[0]\\n width = image.shape[1]\\n\\n box = np.array([nbox[0]*height, nbox[1]*width, nbox[2]*height, nbox[3]*width]).astype(int)\\n box_height = box[2] - box[0]\\n box_width = box[3] - box[1]\\n ratio = float(box_height)/float(box_width)\\n rospy.logdebug(\\\"ratio: %f\\\", ratio)\\n if ratio >= 2.0 and ratio < 3.0: #started from 2.4\\n tl_cropped = image[box[0]:box[2], box[1]:box[3]]\\n tl_color, tl_index = self.get_color(tl_cropped)\\n #color = ['RED', 'YELLOW', 'GREEN', 'UNKNOWN']\\n #tl_index = best_score[2]\\n #tl_color = color[tl_index]\\n #augment image with detected TLs\\n cv2.rectangle(image, (box[1], box[0]), (box[3], box[2]), (0, 255, 0), 2)\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n font_color = (255, 255, 255)\\n cv2.putText(image, tl_color, (box[1], box[0]), font, 2.0, font_color, lineType=cv2.LINE_AA)\\n return image, tl_index\",\n \"def get_bipartition(g):\\n # Write your code here.\\n colorArr = [-1] * (len(g.nodes()) + 1)\\n for node in g.nodes():\\n start = g.neighbors(node)\\n if len(start)>0:\\n src = start.pop()\\n break\\n colorArr[src] = 1\\n queue = []\\n queue.append(src)\\n while (queue):\\n u = queue.pop()\\n for v in g.nodes():\\n if g.has_edge(u, v) and colorArr[v] == -1:\\n colorArr[v] = 1 - colorArr[u]\\n queue.append(v)\\n elif g.has_edge(u, v) and colorArr[u] == colorArr[v]:\\n return None\\n\\n red = set()\\n for i in range(1, len(colorArr)):\\n if colorArr[i] == 1:\\n red.add(i)\\n return list(red)\\n\\n\\n\\n # Hint! If you'd like to test out these commands without\\n # writing a full-fledged program, you might want to familiarise\\n # yourself with the Python interactive shell or IPython (available\\n # on at least some Aalto IT computers)\\n\\n # Create a simple line graph g: \\\"(1)->(2)->(3)\\\"\\n # (The creation parameter is a dict of {node: list_of_neighbors},\\n # but this is not something you will be needing in your code.)\\n # >>> from networkx import Graph \\n # >>> g = Graph({1: [2], 2: [3]})\\n # >>> g.number_of_nodes()\\n # 3\\n\\n # Example. Iterate over the nodes and mark them as visited\\n # >>> visited = set()\\n # >>> for node in g.nodes_iter(): # There is also g.nodes(), which returns a list\\n # ... # do some work here\\n # ... visited.add(node)\\n \\n # Example. Given a Node v, get all nodes s.t. there is an edge between\\n # v and that node\\n # >>> g.neighbors(1)\\n # [2]\\n\\n # Example. Get the edges of the graph:\\n # >>> e.edges() # as with nodes, there is also g.edges_iter()\\n # [(1, 2), (2, 3)]\\n\\n # For more information, consult the NetworkX documentation:\\n # https://networkx.github.io/documentation/networkx-1.10/tutorial/tutorial.html\",\n \"def get_neighbouring_nodes(node) :\\r\\n\\r\\n connected_nodes = [] #A list of the connected nodes\\r\\n\\r\\n #Checking if the node belongs to the 1st row\\r\\n if(node.coords[0] != 0) :\\r\\n connected_node = Node((node.coords[0] - 1, node.coords[1]), goal_pos, node.gn_value - 1)\\r\\n #Checking if the node is an obstacle\\r\\n if(not connected_node.coords in obstacle_coords) :\\r\\n connected_nodes.append(connected_node)\\r\\n\\r\\n #Checking if the node belongs to the last row\\r\\n if(node.coords[0] != grid_dims[0] - 1) :\\r\\n connected_node = Node((node.coords[0] + 1, node.coords[1]), goal_pos, node.gn_value - 1)\\r\\n #Checking if the node is an obstacle\\r\\n if(not connected_node.coords in obstacle_coords) :\\r\\n connected_nodes.append(connected_node)\\r\\n\\r\\n #Checking if the node belongs to the 1st column\\r\\n if(node.coords[1] != 0) :\\r\\n connected_node = Node((node.coords[0], node.coords[1] - 1), goal_pos, node.gn_value - 1)\\r\\n #Checking if the node is an obstacle\\r\\n if(not connected_node.coords in obstacle_coords) :\\r\\n connected_nodes.append(connected_node)\\r\\n\\r\\n #Checking if the node belongs to the 1st column\\r\\n if(node.coords[1] != grid_dims[1] - 1) :\\r\\n connected_node = Node((node.coords[0], node.coords[1] + 1), goal_pos, node.gn_value - 1)\\r\\n #Checking if the node is an obstacle\\r\\n if(not connected_node.coords in obstacle_coords) :\\r\\n connected_nodes.append(connected_node)\\r\\n\\r\\n return connected_nodes\",\n \"def classifier():\\n\\tprint(\\\"Classifying\\\")\\n\\t#initialize important variables\\n\\tminConfidence = 0.5\\n\\tthresholdValue = 0.3\\n\\t\\n\\t\\\"\\\"\\\"\\n\\tfile = request.files#['image']\\n\\tfile.save(\\\"./classifier_image.jpg\\\")\\n\\tframe = cv2.imread(\\\"./classifier_image.jpg\\\")\\n\\t\\\"\\\"\\\"\\n\\tfile = request.json\\n\\tframe = np.array(file[\\\"Frame\\\"], dtype = \\\"uint8\\\") \\n\\n\\t#file = request.files['image']\\n\\t#file.save(\\\"./classifier_image.jpg\\\")\\n\\t#frame = cv2.imread(\\\"./classifier_image.jpg\\\")\\n\\t#file = request.json\\n\\t#frame = np.array(file[\\\"contour\\\"], dtype=\\\"uint8\\\")\\n\\t\\n\\t#Get Image dimensions\\n\\timage = cv2.copyMakeBorder(frame, 30, 30, 30, 30, cv2.BORDER_CONSTANT, value=255)\\n\\t(H, W) = image.shape[:2]\\n\\t\\n\\t#Get the output layers parameters\\n\\tln = net.getLayerNames()\\n\\tln = [ln[i[0] - 1] for i in net.getUnconnectedOutLayers()]\\n\\t\\n\\t#Create a blob to do a forward pass\\n\\tblob = cv2.dnn.blobFromImage(image, 1 / 255.0, (416, 416), swapRB=True, crop=False)\\n\\tnet.setInput(blob)\\n\\t#print(H, W)\\n\\tlayerOutputs = net.forward(ln)\\n\\tprint(type(net))\\n\\tboxes = []\\n\\tconfidences = []\\n\\tclassIDs = []\\n\\tfor output in layerOutputs:\\n\\t\\tprint(\\\"detecting\\\")\\n\\t\\t#loop over each detection\\n\\t\\tfor detection in output:\\n\\t\\t\\t# extract the class ID and confidence (i.e., probability) of\\n\\t\\t\\t# the current object detection\\n\\t\\t\\tscores = detection[5:]\\n\\t\\t\\tclassID = np.argmax(scores)\\n\\t\\t\\tconfidence = scores[classID]\\n\\n\\t\\t\\t# filter out weak predictions by ensuring the detected\\n\\t\\t\\t# probability is greater than the minimum probability\\n\\t\\t\\tif confidence > minConfidence:\\n\\t\\t\\t\\t# scale the bounding box coordinates back relative to the\\n\\t\\t\\t\\t# size of the image, keeping in mind that YOLO actually\\n\\t\\t\\t\\t# returns the center (x, y)-coordinates of the bounding\\n\\t\\t\\t\\t# box followed by the boxes' width and height\\n\\t\\t\\t\\tbox = detection[0:4] * np.array([W, H, W, H])\\n\\t\\t\\t\\t(centerX, centerY, width, height) = box.astype(\\\"int\\\")\\n\\n\\t\\t\\t\\t# use the center (x, y)-coordinates to derive the top and\\n\\t\\t\\t\\t# and left corner of the bounding box\\n\\t\\t\\t\\tx = int(centerX - (width / 2))\\n\\t\\t\\t\\ty = int(centerY - (height / 2))\\n\\n\\t\\t\\t\\t# update our list of bounding box coordinates, confidences,\\n\\t\\t\\t\\t# and class IDs\\n\\t\\t\\t\\tboxes.append([x, y, int(width), int(height)])\\n\\t\\t\\t\\tconfidences.append(float(confidence))\\n\\t\\t\\t\\tclassIDs.append(classID)\\n\\n\\t# apply non-maxima suppression to suppress weak, overlapping bounding\\n\\t# boxes\\n\\tidxs = cv2.dnn.NMSBoxes(boxes, confidences, minConfidence, thresholdValue)\\n\\n\\t# ensure at least one detection exists\\n\\tif len(idxs) > 0:\\n\\t\\toutput = json.load(open(outputFile))\\n\\t\\t# loop over the indexes we are keeping\\n\\t\\tfor i in idxs.flatten():\\n\\t\\t\\t# extract the bounding box coordinates\\n\\t\\t\\t(x, y) = (boxes[i][0], boxes[i][1])\\n\\t\\t\\t(w, h) = (boxes[i][2], boxes[i][3])\\n\\n\\t\\t\\tprint(LABELS[classIDs[i]], output[LABELS[classIDs[i]]]+1, confidences[i])\\n\\t\\t\\toutput[LABELS[classIDs[i]]]+=1\\n\\t\\t\\n\\t\\tjson.dump(output, open(outputFile, \\\"w\\\"))\\n\\t\\treturn LABELS[classIDs[i]]\\n\\telse:\\n\\t\\treturn Response(status=200)\",\n \"def get_shapes(self):\\n colours = [[None for j in range(self.cellcounts[0])] for i in range(self.cellcounts[1])]\\n X = []\\n backmap = {}\\n rad = 3\\n for k,((i,y),(j,x)) in enumerate(self.mids):\\n chunk = self.img[y-rad:y+rad, x-rad:x+rad,:]\\n m = np.mean(np.mean(chunk, axis=0), axis=0).astype(np.uint16)\\n colours[i][j] = m\\n X.append(m)\\n backmap[k] = (i,j)\\n print(np.shape(X))\\n Z = linkage(X, 'ward')\\n Q = fcluster(Z, self.thresh, criterion='distance')\\n\\n closenesses = []\\n for k,cls in enumerate(Q):\\n i,j = backmap[k]\\n closenesses.append( np.sqrt(np.sum( (colours[i][j] - self.ideal_bg)**2) ) )\\n minidx = np.argmin(closenesses)\\n bgcls = Q[minidx]\\n\\n blibs = [(255,0,0), (0,255,0), (0,0,255), (255,255,0), (0,255,255), (255,0,255)]\\n img4 = self.img2.copy()\\n for k,((i,y),(j,x)) in enumerate(self.mids):\\n cls = Q[k]\\n if cls == bgcls:\\n continue\\n col = blibs[(cls-1)]\\n img4 = cv2.circle(img4, (x,y), 5, col, 2)\\n\\n write_img(\\\"./out/test_classes.png\\\", img4)\\n self.classimg = img4\\n\\n A = np.zeros(shape=self.cellcounts, dtype=np.uint8)\\n mx = np.max(Q)\\n for k,cls in enumerate(Q):\\n if cls == bgcls:\\n continue\\n\\n if cls == mx:\\n plotcls = bgcls\\n else:\\n plotcls = cls\\n i,j = backmap[k]\\n A[i][j] = plotcls\\n\\n self.res = A\",\n \"def get_classification(self, image):\\n #TODO implement light color prediction\\n max_idx = 4\\n with self.detection_graph.as_default():\\n with tf.Session(graph=self.detection_graph) as sess:\\n # Definite input and output Tensors for detection_graph\\n image_tensor = self.detection_graph.get_tensor_by_name('image_tensor:0')\\n \\n # Each box represents a part of the image where a particular object was detected.\\n detection_boxes = self.detection_graph.get_tensor_by_name('detection_boxes:0')\\n \\n # Each score represent how level of confidence for each of the objects.\\n # Score is shown on the result image, together with the class label.\\n detection_scores = self.detection_graph.get_tensor_by_name('detection_scores:0')\\n detection_classes = self.detection_graph.get_tensor_by_name('detection_classes:0')\\n num_detections = self.detection_graph.get_tensor_by_name('num_detections:0')\\n # Expand dimensions since the model expects images to have shape: [1, None, None, 3]\\n image_np_expanded = np.expand_dims(image, axis=0)\\n # Actual detection.\\n (boxes, scores, classes, num) = sess.run(\\n [detection_boxes, detection_scores, detection_classes, num_detections],\\n feed_dict={image_tensor: image_np_expanded})\\n\\n boxes = np.squeeze(boxes)\\n scores = np.squeeze(scores)\\n classes = np.squeeze(classes).astype(np.int32)\\n min_score_thresh = .50\\n # find majority light state\\n counter = [0, 0, 0, 0, 0]\\n for i in range(boxes.shape[0]):\\n if scores is None or scores[i] > min_score_thresh:\\n counter[classes[i]] += 1\\n for i in range(1, 5):\\n if counter[i] > counter[max_idx]:\\n max_idx = i\\n return self.classmap[max_idx]\",\n \"def get_classification(self, image):\\n #TODO implement light color prediction\\n \\\"\\\"\\\" example code\\n if result == 0:\\n state = TrafficLight.GREEN\\n else\\n state = TrafficLight.RED\\n \\\"\\\"\\\"\\n with self.detection_graph.as_default():\\n boxes, scores, classes, num_detections = self.sess.run([self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections], feed_dict={self.image_tensor: np.expand_dims(image, axis=0)})\\n boxes = np.squeeze(boxes)\\n scores = np.squeeze(scores)\\n classes = np.squeeze(classes)\\n max_score_idx = np.argmax(scores)\\n result = classes[max_score_idx]\\n if result == 1:\\n print('RED Light')\\n return TrafficLight.RED\\n elif result == 2:\\n print('Yellow Light')\\n return TrafficLight.YELLOW\\n elif result == 3:\\n print('Green Light')\\n return TrafficLight.GREEN\\n return TrafficLight.UNKNOWN\",\n \"def conservedMetabolismNeofunctionalisedEnzymes(self, majorityPercentageCoreMetabolism = defaultMajorityPercentageCoreMetabolism, colour = False):\\n conservedMetabolismEnzymes = self.conservedMetabolismEnzymes(majorityPercentageCoreMetabolism, colour = colour)\\n \\n parentNeofunctionalised= self.parentClade.neofunctionalisedEnzymes(majorityPercentageCoreMetabolism, colour = False)\\n childNeofunctionalised = self.childClade.neofunctionalisedEnzymes(majorityPercentageCoreMetabolism, colour = False)\\n \\n if colour is True:\\n parentEdges = parentNeofunctionalised.getEdges()\\n childEdges = childNeofunctionalised.getEdges()\\n \\n graph = conservedMetabolismEnzymes\\n \\n Export.addColourAttribute(graph, colour = Export.Colour.GREEN, nodes = False, edges = parentEdges)\\n Export.addColourAttribute(graph, colour = Export.Colour.YELLOW, nodes = False, edges = childEdges)\\n \\n graph.name = 'Conserved metabolism neofunctionalised enzymes ' + ' '.join(self.parentNCBInames) + ' -> ' + ' '.join(self.childNCBInames)\\n \\n return graph\\n else:\\n parentGraph = conservedMetabolismEnzymes[0].removeAllEnzymesExcept(parentNeofunctionalised.getEnzymes())\\n childGraph = conservedMetabolismEnzymes[1].removeAllEnzymesExcept(childNeofunctionalised.getEnzymes())\\n \\n parentGraph.name = 'Conserved metabolism neofunctionalised enzymes *' + ' '.join(self.parentNCBInames) + '* -> ' + ' '.join(self.childNCBInames)\\n childGraph.name = 'Conserved metabolism neofunctionalised enzymes ' + ' '.join(self.parentNCBInames) + ' -> *' + ' '.join(self.childNCBInames) + '*'\\n \\n return (parentGraph, childGraph)\",\n \"def _chinese_whispers(encoding_list, threshold=0.92, iterations=20):\\n\\n #from face_recognition.api import _face_distance\\n from random import shuffle\\n import networkx as nx\\n # Create graph\\n nodes = []\\n edges = []\\n\\n image_paths, encodings = zip(*encoding_list)\\n\\n if len(encodings) <= 1:\\n print (\\\"No enough encodings to cluster!\\\")\\n return []\\n\\n for idx, face_encoding_to_check in enumerate(encodings):\\n # Adding node of facial encoding\\n node_id = idx+1\\n\\n # Initialize 'cluster' to unique value (cluster of itself)\\n node = (node_id, {'cluster': image_paths[idx], 'path': image_paths[idx]})\\n nodes.append(node)\\n\\n # Facial encodings to compare\\n if (idx+1) >= len(encodings):\\n # Node is last element, don't create edge\\n break\\n\\n compare_encodings = encodings[idx+1:]\\n distances = face_distance(compare_encodings, face_encoding_to_check)\\n encoding_edges = []\\n for i, distance in enumerate(distances):\\n if distance > threshold:\\n # Add edge if facial match\\n edge_id = idx+i+2\\n encoding_edges.append((node_id, edge_id, {'weight': distance}))\\n\\n edges = edges + encoding_edges\\n\\n G = nx.Graph()\\n G.add_nodes_from(nodes)\\n G.add_edges_from(edges)\\n\\n # Iterate\\n for _ in range(0, iterations):\\n cluster_nodes = G.nodes()\\n shuffle(list(cluster_nodes))\\n for node in cluster_nodes:\\n neighbors = G[node]\\n clusters = {}\\n\\n for ne in neighbors:\\n if isinstance(ne, int):\\n if G.node[ne]['cluster'] in clusters:\\n clusters[G.node[ne]['cluster']] += G[node][ne]['weight']\\n else:\\n clusters[G.node[ne]['cluster']] = G[node][ne]['weight']\\n\\n # find the class with the highest edge weight sum\\n edge_weight_sum = 0\\n max_cluster = 0\\n #use the max sum of neighbor weights class as current node's class\\n for cluster in clusters:\\n if clusters[cluster] > edge_weight_sum:\\n edge_weight_sum = clusters[cluster]\\n max_cluster = cluster\\n\\n # set the class of target node to the winning local class\\n G.node[node]['cluster'] = max_cluster\\n\\n clusters = {}\\n\\n # Prepare cluster output\\n for (_, data) in G.node.items():\\n cluster = data['cluster']\\n path = data['path']\\n\\n if cluster:\\n if cluster not in clusters:\\n clusters[cluster] = []\\n clusters[cluster].append(path)\\n\\n # Sort cluster output\\n sorted_clusters = sorted(clusters.values(), key=len, reverse=True)\\n\\n return sorted_clusters\",\n \"def get_classification(self, image):\\n time = 0\\n with self.graph.as_default(): \\n img_expand = np.expand_dims(image, axis=0)\\n start = datetime.datetime.now()\\n (boxes, scores, classes, num_detections) = self.sess.run(\\n [self.boxes, self.scores, self.classes, self.num_detections],\\n feed_dict={self.image_tensor: img_expand})\\n end = datetime.datetime.now()\\n time = end - start\\n\\n boxes = np.squeeze(boxes)\\n scores = np.squeeze(scores)\\n classes = np.squeeze(classes).astype(np.int32)\\n\\n #print('SCORES: ', scores[0])\\n #print('CLASSES: ', classes[0])\\n\\n if scores[0] > self.threshold:\\n if classes[0] == 1:\\n print('Traffic Light: *** GREEN ***, Detection Speed: ', time.total_seconds())\\n return TrafficLight.GREEN\\n elif classes[0] == 2:\\n print('Traffic Light: *** RED ***, Detection Speed: ', time.total_seconds())\\n return TrafficLight.RED\\n elif classes[0] == 3:\\n print('Traffic Light: *** YELLOW ***, Detection Speed: ', time.total_seconds())\\n return TrafficLight.YELLOW\\n\\n return TrafficLight.UNKNOWN\",\n \"def node_colors(self, nodes):\\n zmin, zmax = nodes[:, 2].min(), nodes[:, 2].max()\\n start_color = np.array(self.background) + 5\\n end_color = np.array(self.nodeColor)\\n z = (nodes[:, 2] - zmin) / (zmax - zmin)\\n # indexing [:, None] is used to explicitly state second axis\\n c = (1 - z)[:, None] @ start_color[:, None].T + z[:, None] @ end_color[:, None].T\\n self.wireframe_col = c\\n # return c\",\n \"def detect_ground_truth_communities(self, G):\\n print(\\\"Detecting Ground - Truth communities\\\")\\n gt_communities = {frozenset(G.nodes[v]['community']) for v in G}\\n return [list(fs) for fs in gt_communities]\",\n \"def get_graph_attributes(net_G):\\r\\n # number of nodes\\r\\n num_of_nodes = net_G.number_of_nodes()\\r\\n # number of nodes\\r\\n num_of_edges = net_G.number_of_edges()\\r\\n # density of net\\r\\n net_density = nx.density(net_G)\\r\\n # maximum degree and average degree\\r\\n nodes_degree = nx.degree(net_G)\\r\\n maximum_degree = max(nodes_degree, key=itemgetter(1))[0]\\r\\n average_degree = sum([node[1] for node in nodes_degree])/num_of_nodes\\r\\n # global clustering coefficient: n - count numbers of paths of length two\\r\\n nodes_triangles = nx.triangles(net_G)\\r\\n num_of_triangles = sum(nodes_triangles.values())\\r\\n pairs_path_length = dict(nx.all_pairs_shortest_path_length(net_G))\\r\\n n = 0 \\r\\n for node in pairs_path_length.keys(): \\r\\n for item in pairs_path_length[node].values():\\r\\n if item == 2:\\r\\n n = n + 1\\r\\n global_clustering_coefficient = (num_of_triangles * 6) / n\\r\\n # size of giant component\\r\\n giant_component = max(nx.connected_component_subgraphs(net_G),key=len)\\r\\n # return number of edges in graph=graph size\\r\\n size_of_giant = nx.Graph.size(giant_component)\\r\\n # calculate the average path length of giant component\\r\\n average_shortest_path_length = nx.average_shortest_path_length(giant_component)\\r\\n # maximum centrality and average centrality\\r\\n nodes_centrality = nx.degree_centrality(net_G)\\r\\n maximum_of_centrality = max(nodes_centrality.values())\\r\\n average_of_centrality = sum(nodes_centrality.values())/num_of_nodes\\r\\n # maximum betweenness centrality\\r\\n nodes_betweenness_centrality = nx.betweenness_centrality(net_G)\\r\\n maximum_betweenness_centrality = max(nodes_betweenness_centrality.values())\\r\\n # maximum closeness centrality\\r\\n nodes_closeness_centrality = nx.closeness_centrality(net_G)\\r\\n maximum_closeness_centrality = max(nodes_closeness_centrality.values())\\r\\n average_closeness_centrality = sum(nodes_closeness_centrality.values())/num_of_nodes\\r\\n # summarize graph attributes\\r\\n graph_attributes = [[\\\"Number of nodes:\\\", num_of_nodes], \\\\\\r\\n [\\\"Number of edges:\\\", num_of_edges], \\\\\\r\\n [\\\"Global clustering coefficient:\\\", global_clustering_coefficient], \\\\\\r\\n [\\\"Maximum degree:\\\", maximum_degree], \\\\\\r\\n [\\\"Average degree:\\\", average_degree], \\\\\\r\\n [\\\"Size of giant component:\\\", size_of_giant], \\\\\\r\\n [\\\"Average path length:\\\", average_shortest_path_length],\\\\\\r\\n [\\\"Maximum centrality:\\\", maximum_of_centrality], \\\\\\r\\n [\\\"Average centrality:\\\", average_of_centrality],\\\\\\r\\n [\\\"Maximum betweenness centrality:\\\", maximum_betweenness_centrality],\\\\\\r\\n [\\\"Maximum closeness centrality:\\\", maximum_closeness_centrality], \\\\\\r\\n [\\\"Average closeness centrality:\\\", average_closeness_centrality], \\\\\\r\\n [\\\"Net density:\\\", net_density]]\\r\\n return graph_attributes\",\n \"def _greedy_color(self, source):\\n for target in self.graph.iteradjacent(source):\\n if self.color[target] is not None:\\n self._color_list[self.color[target]] = True\\n for c in xrange(self.graph.v()): # check colors\\n if not self._color_list[c]:\\n self.color[source] = c\\n break\\n for target in self.graph.iteradjacent(source):\\n if self.color[target] is not None:\\n self._color_list[self.color[target]] = False\\n return c\",\n \"def get_communities(browser: RoboBrowser, desired_communities: list):\\n browser.open(URL_BASE + '/info/profil/meinetipprunden')\\n content = get_kicktipp_content(browser)\\n links = content.find_all('a')\\n def gethreftext(link): return link.get('href').replace(\\\"/\\\", \\\"\\\")\\n\\n def is_community(link):\\n hreftext = gethreftext(link)\\n if hreftext == link.get_text():\\n return True\\n else:\\n linkdiv = link.find('div', {'class': \\\"menu-title-mit-tippglocke\\\"})\\n return linkdiv and linkdiv.get_text() == hreftext\\n community_list = [gethreftext(link)\\n for link in links if is_community(link)]\\n if len(desired_communities) > 0:\\n return intersection(community_list, desired_communities)\\n return community_list\",\n \"def infomap_communities(G):\\n name_map = {}\\n name_map_inverted = {}\\n for n in G.nodes():\\n id_ = hash(n) % 100000\\n name_map_inverted[id_] = n\\n name_map[n] = id_\\n \\n infomapSimple = infomap.Infomap(\\\"--two-level\\\")\\n network = infomapSimple.network()\\n \\n for n1, n2, data in G.edges(data=True):\\n network.addLink(name_map[n1], name_map[n2], data['weight'] if 'weight' in data else 1)\\n\\n infomapSimple.run()\\n\\n return dict(\\n (name_map_inverted[node.physicalId], node.moduleIndex())\\n for node in infomapSimple.iterTree()\\n if node.isLeaf()\\n )\",\n \"def sixteen_graphs(the_dir):\\n # TODO change to deprecation warning\\n warnings.warn(\\\"Does not call sv_pipeline functoins correctly\\\", DeprecationWarning)\\n\\n plb.rcParams['figure.figsize'] = 30, 30\\n plt.clf()\\n plt.figure(1)\\n\\n # should look like: read_data/all_files/chr4_124,017,492_124,029,032_merged.txt\\n merged_files = glob.glob(the_dir + '*merged.txt')\\n print(\\\"Running for {} regions\\\".format(len(merged_files)))\\n for merged_filename in merged_files:\\n # get filenames\\n prefix = merged_filename[len(the_dir):-11]\\n fasta_filename = the_dir + prefix + \\\".fa\\\"\\n bed_filename = the_dir + prefix + \\\"-refcoords.bed\\\"\\n print('Using ' + prefix)\\n\\n for min_matching_length in range(100, 1700, 100):\\n print(min_matching_length)\\n # used for ground truth\\n preset, postset, spanset, gapset = get_read_classifications(prefix,\\\\\\n bed_filename, merged_filename=merged_filename)\\n # Generate and prune graph\\n graph = generate_graph(prefix, fasta_filename, min_matching_length)\\n graph = nx_helpers.remove_nodes(graph, preset)\\n graph = nx_helpers.remove_nodes(graph, postset)\\n\\n # Plot the graph\\n plt.subplot(4, 4, min_matching_length/100)\\n communities = nx_helpers.get_communities(graph)\\n graph, communities = drop_small_communities(graph, communities)\\n node_colors = node_community_colors(graph, communities)\\n pos = nx.spring_layout(graph)\\n title = \\\"Chr {0};\\\\n L={1}; NumCom={2}\\\\nComQual = {3}, MapQual={4}\\\"\\\\\\n .format(prefix, min_matching_length, len(communities),\\\\\\n community_quality(communities, spanset, gapset),\\\\\\n mapping_quality(graph, spanset, gapset))\\n nx.draw(graph, node_color=node_colors, node_size=100, pos=pos)\\n plt.title(title)\\n plt.savefig(\\\"figs/\\\" + prefix + '-16-communities.pdf')\\n plt.clf()\",\n \"def find_colours(self, img, colour, num_objects=1, ab_dist_thresh=50):\\n img_lab = cv2.cvtColor(img,cv2.COLOR_BGR2LAB) #convert to LAB colour space \\n img_a = img_lab[:,:,1] #A compononent of image\\n img_b = img_lab[:,:,2] #B compononent of image \\n des_a = colour[1] #A component of desired colour\\n des_b = colour[2] #B component of desired colour\\n \\n #Compute difference between desired components and actual components\\n d_a = img_a - des_a\\n d_b = img_b - des_b\\n dist_squared = d_a**2 + d_b**2\\n \\n #Apply threshold\\n img_bin = np.uint8(dist_squared<ab_dist_thresh)*255\\n \\n #do connected components analysis to find centroids of large connected objects\\n conn_comp = cv2.connectedComponentsWithStats(img_bin, 8, cv2.CV_32S)\\n\\n #sort by area, from largest to smallest\\n areas = np.int_(conn_comp[2][:,4])\\n idx = areas.argsort()\\n idx = idx[::-1]\\n centroids = np.int_(conn_comp[3])\\n centroids = centroids[idx[1:num_objects+1]]\\n \\n #if more than one object returned, order from left to right\\n idx = centroids[:,0].argsort() #sort by x value\\n centroids = list(centroids[idx])\\n \\n #return centroid position and binary image of detected objects\\n if len(centroids) == 1:\\n return centroids[0], img_bin\\n else:\\n return centroids, img_bin\",\n \"def yolo_detection(raw_image):\\n class_ids = []\\n confidences = []\\n boxes = []\\n height , width ,c= raw_image.shape\\n blob = cv2.dnn.blobFromImage(raw_image, 0.00392, (416,416), (0,0,0), True, crop=False)\\n net.setInput(blob)\\n outs = net.forward(output_layers)\\n\\n for out in outs:\\n for detection in out:\\n scores = detection[5:]\\n class_id = np.argmax(scores)\\n confidence = scores[class_id]\\n if confidence > 0.4:\\n center_x = int(detection[0]*width)\\n center_y = int(detection[1]*height)\\n w = int(detection[2]*width)\\n h = int(detection[3]*height)\\n ##Rectangle Draw\\n topleft_x = int(center_x-(w/2))\\n topleft_y = int(center_y-(h/2))\\n\\n boxes.append([topleft_x,topleft_y,w,h])\\n confidences.append(float(confidence))\\n class_ids.append(class_id)\\n indexes = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)\\n #DISPLAY DETECTION\\n total_detections = len(boxes)\\n for i in range(total_detections):\\n if i in indexes:\\n topleft_x, topleft_y, w,h = boxes[i]\\n label = detection_classes[class_ids[i]]\\n cv2.rectangle(raw_image, (topleft_x,topleft_y), (topleft_x+w,topleft_y+h), (0,100,255), 1)\\n cv2.putText(raw_image, label, (topleft_x, topleft_y),cv2.FONT_HERSHEY_COMPLEX,1,(0,165,255))\\n\\n\\n return raw_image\",\n \"def community_layout(g, partition):\\n\\n pos_communities = _position_communities(g, partition, scale=3.)\\n\\n pos_nodes = _position_nodes(g, partition, scale=1.)\\n\\n # combine positions\\n pos = dict()\\n for node in g.nodes():\\n pos[node] = pos_communities[node] + pos_nodes[node]\\n\\n return pos\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7544369","0.67278713","0.67230785","0.6600129","0.6450803","0.62319934","0.62119263","0.6207066","0.62020797","0.61163753","0.61084396","0.6086533","0.5949669","0.591313","0.59082705","0.5903655","0.58992743","0.58878565","0.5877019","0.58694255","0.5868911","0.5826663","0.5795262","0.5783291","0.57811725","0.5725391","0.5702787","0.5699948","0.56912565","0.5661789","0.5659319","0.56372726","0.561563","0.5594661","0.5563149","0.5537157","0.5536518","0.5533082","0.55319226","0.55012155","0.5501039","0.54983795","0.5476527","0.54655075","0.5463741","0.54452676","0.5428597","0.54248065","0.540133","0.53967005","0.5383922","0.5380007","0.53588814","0.53562504","0.53520477","0.5351445","0.5323951","0.532138","0.5317512","0.5308425","0.53053397","0.53003514","0.5296445","0.5293904","0.5283794","0.5280738","0.5274667","0.52740526","0.5259916","0.5257934","0.52549493","0.5252249","0.52384573","0.52357537","0.5233126","0.5223091","0.5222961","0.5221089","0.5219827","0.5218794","0.5216744","0.5206975","0.52017695","0.5201752","0.51969045","0.51926965","0.51896745","0.5189011","0.5181282","0.5180102","0.51793563","0.51770455","0.5176105","0.51672864","0.5165887","0.5150635","0.5149455","0.51437324","0.51389337","0.51361376"],"string":"[\n \"0.7544369\",\n \"0.67278713\",\n \"0.67230785\",\n \"0.6600129\",\n \"0.6450803\",\n \"0.62319934\",\n \"0.62119263\",\n \"0.6207066\",\n \"0.62020797\",\n \"0.61163753\",\n \"0.61084396\",\n \"0.6086533\",\n \"0.5949669\",\n \"0.591313\",\n \"0.59082705\",\n \"0.5903655\",\n \"0.58992743\",\n \"0.58878565\",\n \"0.5877019\",\n \"0.58694255\",\n \"0.5868911\",\n \"0.5826663\",\n \"0.5795262\",\n \"0.5783291\",\n \"0.57811725\",\n \"0.5725391\",\n \"0.5702787\",\n \"0.5699948\",\n \"0.56912565\",\n \"0.5661789\",\n \"0.5659319\",\n \"0.56372726\",\n \"0.561563\",\n \"0.5594661\",\n \"0.5563149\",\n \"0.5537157\",\n \"0.5536518\",\n \"0.5533082\",\n \"0.55319226\",\n \"0.55012155\",\n \"0.5501039\",\n \"0.54983795\",\n \"0.5476527\",\n \"0.54655075\",\n \"0.5463741\",\n \"0.54452676\",\n \"0.5428597\",\n \"0.54248065\",\n \"0.540133\",\n \"0.53967005\",\n \"0.5383922\",\n \"0.5380007\",\n \"0.53588814\",\n \"0.53562504\",\n \"0.53520477\",\n \"0.5351445\",\n \"0.5323951\",\n \"0.532138\",\n \"0.5317512\",\n \"0.5308425\",\n \"0.53053397\",\n \"0.53003514\",\n \"0.5296445\",\n \"0.5293904\",\n \"0.5283794\",\n \"0.5280738\",\n \"0.5274667\",\n \"0.52740526\",\n \"0.5259916\",\n \"0.5257934\",\n \"0.52549493\",\n \"0.5252249\",\n \"0.52384573\",\n \"0.52357537\",\n \"0.5233126\",\n \"0.5223091\",\n \"0.5222961\",\n \"0.5221089\",\n \"0.5219827\",\n \"0.5218794\",\n \"0.5216744\",\n \"0.5206975\",\n \"0.52017695\",\n \"0.5201752\",\n \"0.51969045\",\n \"0.51926965\",\n \"0.51896745\",\n \"0.5189011\",\n \"0.5181282\",\n \"0.5180102\",\n \"0.51793563\",\n \"0.51770455\",\n \"0.5176105\",\n \"0.51672864\",\n \"0.5165887\",\n \"0.5150635\",\n \"0.5149455\",\n \"0.51437324\",\n \"0.51389337\",\n \"0.51361376\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7250731"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":14694,"cells":{"query":{"kind":"string","value":"finds which community node is in and returns its corresponding color"},"document":{"kind":"string","value":"def which_color(node):\n for i, com in enumerate(communities):\n if node in com:\n return colors[i]\n return nx_helpers.rgb_to_hex((0, 0, 0))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def node_community_colors(graph, communities):\n colors = nx_helpers.generate_colors(len(communities))\n\n def which_color(node):\n \"\"\"finds which community node is in and returns\n its corresponding color\n \"\"\"\n for i, com in enumerate(communities):\n if node in com:\n return colors[i]\n return nx_helpers.rgb_to_hex((0, 0, 0))\n\n node_colors = [which_color(node) for node in graph.nodes()]\n return node_colors","def get_color(node, color_map):\r\n if node in color_map:\r\n return color_map[node]\r\n return \"black\"","def get_color(self, node: Node) -> str:\n\n idx = hash(node.get_kind_name()) % len(self.colors_)\n return self.colors_[idx]","def get_node_color(node_label):\n for NODE_KEY in list(NODE_TYPES.keys()):\n if node_label in NODE_TYPES[NODE_KEY]:\n return NODE_COLOR_DICT[NODE_KEY]\n try:\n x = int(node_label)\n return NODE_COLOR_DICT['Terminals']\n except:\n try:\n x = float(node_label)\n return NODE_COLOR_DICT['Terminals']\n except:\n try:\n node_label = node_label.replace(\"\\'\", \"\\\"\")\n tree = json.loads(node_label)\n for key in tree.keys():\n if key not in NODE_TYPES['Learner Params']:\n return NODE_COLOR_DICT['Uncategorized']\n else:\n try:\n x = int(tree[key])\n except:\n try:\n x = float(tree[key])\n except:\n return NODE_COLOR_DICT['Uncategorized']\n return NODE_COLOR_DICT['Learner Params']\n except:\n return NODE_COLOR_DICT['Uncategorized']\n return NODE_COLOR_DICT['Uncategorized']","def get_node_color(self, origin_node_id):\n origin_node_id %= 11\n if origin_node_id == 9:\n return 0.753, 0.753, 0.753, 1.\n if origin_node_id == 8:\n return 0.824, 0.412, 0.118, 1.\n if origin_node_id == 7:\n return 1.000, 0.000, 1.000, 1.\n if origin_node_id == 6:\n return 1.000, 1.000, 0.000, 1.\n if origin_node_id == 5:\n return 1.000, 0.627, 0.478, 1.\n if origin_node_id == 4:\n return 0.498, 1.000, 0.000, 1.\n if origin_node_id == 3:\n return 0.000, 1.000, 1.000, 1.\n if origin_node_id == 2:\n return 1.000, 0.922, 0.804, 1.\n if origin_node_id == 1:\n return 0.871, 0.722, 0.529, 1.\n if origin_node_id == 0:\n return 0.000, 0.749, 1.000, 1.\n if origin_node_id == 0:\n return 0.500, 0.549, 1.000, 1.\n\n return 0.8, 0.8, 0.8, 1.0","def color_chosen_nodes(network, chosen_node, color):\n\n # Color the node selected randomly by RWR\n network.nodes[chosen_node]['color'] = color\n # Create a list with color for each node\n color_nodes = [network.nodes[node]['color'] for node in network.nodes]\n return color_nodes","def get_graph_color ( self, object ):\n return self.graph_color_","def getCurrentColor(self):\n if self.__currentnode__ is None:\n return None\n else:\n return self.__currentnode__.getPlayer().getColor()","def maximal_color(graph, node):\n return max(get_node_colors(graph, node))","def colorNode(node):\n # Try to find the session color manager.\n manager = _findSessionColorManager()\n\n # If one exists, use it to try to color the node.\n if manager is not None:\n manager.colorNode(node)","def colorNodeByName(node):\n # Try to find the session color manager.\n manager = _findSessionColorManager()\n\n # If one exists, use it to try to color the node.\n if manager is not None:\n manager.colorNodeByName(node)","def _community(G, u, community):\n node_u = G.node[u]\n try:\n return node_u[community]\n except KeyError:\n raise nx.NetworkXAlgorithmError('No community information')","def find_local_community(G, seed_node, weight, debug_log=False):\n nodes_in_community = seed_node if isinstance(seed_node, list) else [seed_node]\n modularity = edge_modularity(G, nodes_in_community=nodes_in_community, weight=weight)\n neighbor_edges = get_neighbor_edges(G, nodes_in_community=nodes_in_community)\n if debug_log:\n print('==========\\nInitial community has nodes:', nodes_in_community)\n print('Neighbor edges:', neighbor_edges)\n print('Modularity = %f' % modularity)\n while neighbor_edges:\n # Compute the edge_modularity for each neighbor edge,\n # suppose the neighbor edge is added to the community\n mod_max, c_max, e_max = 0, None, None\n for e in neighbor_edges:\n # edges in the current community\n edges_in_temp_community = list(G.subgraph(nodes_in_community).edges)\n # append the candidate edge\n edges_in_temp_community.append(e)\n nodes_in_temp_community = list(G.edge_subgraph(edges_in_temp_community).nodes)\n mod_temp = edge_modularity(G, nodes_in_community=nodes_in_temp_community, weight=weight)\n if mod_temp > mod_max:\n mod_max, c_max, e_max = mod_temp, nodes_in_temp_community, e\n if mod_max > modularity:\n if debug_log:\n print('==========\\nEdge', e_max, 'and node', set(e_max).difference(nodes_in_community), 'are added to the community')\n\n # Update the community and the corresponding neighbor edges\n nodes_in_community = c_max\n modularity = mod_max\n neighbor_edges = get_neighbor_edges(G, nodes_in_community=nodes_in_community)\n\n if debug_log:\n print('The community has nodes:', nodes_in_community)\n print('Modularity = %f' % mod_max)\n print('Neighbor edges:', neighbor_edges)\n else:\n break\n return nodes_in_community, modularity","def node_colors(self, nodes):\n zmin, zmax = nodes[:, 2].min(), nodes[:, 2].max()\n start_color = np.array(self.background) + 5\n end_color = np.array(self.nodeColor)\n z = (nodes[:, 2] - zmin) / (zmax - zmin)\n # indexing [:, None] is used to explicitly state second axis\n c = (1 - z)[:, None] @ start_color[:, None].T + z[:, None] @ end_color[:, None].T\n self.wireframe_col = c\n # return c","def colour_node(instance, reaction_colour='darkgrey', Xc_colour='orange', waste_colour='red', res_colour='limegreen', InPr_colour='lightblue'):\n G, mapping = instance.network()\n\n # relabel\n G = nx.relabel_nodes(G, mapping)\n\n node_dict_mapped = nodes_mapped(instance)\n\n waste, resources, intmed_products = instance.amenities()\n\n colour_map = []\n\n for nd in G:\n # print(\"nd\",nd)\n for nd_label, ammentity in node_dict_mapped.items():\n # print(\"nd_label\",nd_label)\n if nd_label == nd:\n # print(nd, nd_label)\n\n if ammentity == \"r\":\n colour_map.append(reaction_colour)\n\n elif ammentity == \"Xc\":\n colour_map.append(Xc_colour)\n\n elif ammentity == \"w\":\n colour_map.append(waste_colour)\n\n elif ammentity == \"Xr\":\n colour_map.append(res_colour)\n\n elif ammentity == \"InPr\":\n colour_map.append(InPr_colour)\n return colour_map","def get_edge_color( row ):\n\n rgb = 0.5 * (\n node_color_dict[ row[ 'source' ] ] + \\\n node_color_dict[ row[ 'target' ] ] )\n\n return rgb2hex( rgb )","def get_color(edge, nR):\n R_color, E_color = 'C0', 'C1'\n edge = sorted(edge)\n if edge[0] < nR:\n if edge[1] > nR:\n comp_color = 'gray'\n zorder = 10\n else:\n comp_color = R_color\n zorder = 5\n else:\n comp_color = E_color\n zorder = 5\n return comp_color, zorder","def vertex_coloring(self, display = False):\r\n stack = self.SL_algorithm()\r\n color_of_vertex = self.greedily_coloring(stack)\r\n if(display):\r\n self.display_graph(color_of_vertex)\r\n return color_of_vertex\r\n else: \r\n return color_of_vertex","def nextColorLedCluster(self):\n hwidRef = YRefParam()\n if YAPI.YISERR(self._nextFunction(hwidRef)):\n return None\n if hwidRef.value == \"\":\n return None\n return YColorLedCluster.FindColorLedCluster(hwidRef.value)","def get_color(rank):\n if rank == 1:\n color = int(0xffd700)\n elif rank == 2:\n color = int(0xc0c0c0)\n elif rank == 3:\n color = int(0xcd7f32)\n else:\n color = random.randint(1, 16777215)\n\n return discord.Color(color)","def FirstColorLedCluster():\n devRef = YRefParam()\n neededsizeRef = YRefParam()\n serialRef = YRefParam()\n funcIdRef = YRefParam()\n funcNameRef = YRefParam()\n funcValRef = YRefParam()\n errmsgRef = YRefParam()\n size = YAPI.C_INTSIZE\n #noinspection PyTypeChecker,PyCallingNonCallable\n p = (ctypes.c_int * 1)()\n err = YAPI.apiGetFunctionsByClass(\"ColorLedCluster\", 0, p, size, neededsizeRef, errmsgRef)\n\n if YAPI.YISERR(err) or not neededsizeRef.value:\n return None\n\n if YAPI.YISERR(\n YAPI.yapiGetFunctionInfo(p[0], devRef, serialRef, funcIdRef, funcNameRef, funcValRef, errmsgRef)):\n return None\n\n return YColorLedCluster.FindColorLedCluster(serialRef.value + \".\" + funcIdRef.value)","def community_detection(net_G):\r\n if list(nx.isolates(net_G)) == []:\r\n part = community.best_partition(net_G)\r\n #values = [part.get(node) for node in net_G.nodes()]\r\n #nx.draw_spring(net_G, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=False)\r\n #plt.show()\r\n else:\r\n net_G = net_G.copy()\r\n net_G.remove_nodes_from(list(nx.isolates(net_G)))\r\n part = community.best_partition(net_G)\r\n list_nodes = []\r\n for com in set(part.values()):\r\n list_nodes.append([nodes for nodes in part.keys() if part[nodes] == com])\r\n num_of_communities = len(list_nodes)\r\n partition_performance = nx.algorithms.community.quality.performance(net_G, list_nodes)\r\n net_communities = [[\"Numbers of communities:\", num_of_communities], \\\r\n [\"Partition performance:\", partition_performance]]\r\n return net_communities","def _greedy_color(self, source):\n for target in self.graph.iteradjacent(source):\n if self.color[target] is not None:\n self._color_list[self.color[target]] = True\n for c in xrange(self.graph.v()): # check colors\n if not self._color_list[c]:\n self.color[source] = c\n break\n for target in self.graph.iteradjacent(source):\n if self.color[target] is not None:\n self._color_list[self.color[target]] = False\n return c","def FindColorLedCluster(func):\n # obj\n obj = YFunction._FindFromCache(\"ColorLedCluster\", func)\n if obj is None:\n obj = YColorLedCluster(func)\n YFunction._AddToCache(\"ColorLedCluster\", func, obj)\n return obj","def is_red(node):\n if node is None:\n return False\n return node.colour is True","def edge_colors(\n et: pd.DataFrame,\n nt: pd.DataFrame,\n color_by: Hashable,\n node_color_by: Hashable,\n):\n if color_by in (\"source_node_color\", \"target_node_color\"):\n edge_select_by = color_by.split(\"_\")[0]\n return encodings.data_color(\n et[edge_select_by].apply(nt[node_color_by].get),\n nt[node_color_by],\n )\n elif color_by:\n return encodings.data_color(et[color_by], et[color_by])\n return pd.Series([\"black\"] * len(et), name=\"color_by\")","def set_colors(graph):\n colors = []\n for n in graph.nodes():\n node = graph.node[n]\n if node['adopter'] == 1:\n colors.append('b')\n else:\n colors.append('r')\n \n return colors","def color(self):\n return self.container['color']","def get_color(self, coord):\n return self.board[coord[0], coord[1]]","def FindColor(self, *args):\n return _XCAFDoc.XCAFDoc_ColorTool_FindColor(self, *args)","def identify_color(animal):\n min_dist = None\n identified_color = None\n for color in animal.colors:\n color_rgb = color_rgbs[color]\n dist = ((animal.get_red() - color_rgb[0]) ** 2) + (\n (animal.get_green() - color_rgb[1]) ** 2) + ((animal.get_blue() - color_rgb[2]) ** 2)\n if (min_dist is None) or (dist < min_dist):\n min_dist = dist\n identified_color = color\n return identified_color","def get_color(self):\n return self._io.last_state['color']['front-center']","def get_color(self):\r\n if self.color:\r\n return \"RED\"\r\n else:\r\n return \"BLACK\"","def get_color(self):\n return \"yellow\"","def color(self):\n return self['color']","def node_set_colors(nodes, spanset, gapset, preset, postset):\n\n node_colors = []\n for n in nodes:\n if n in preset:\n node_colors.append(nx_helpers.rgb_to_hex((255, 0, 0)))\n elif n in postset:\n node_colors.append(nx_helpers.rgb_to_hex((255, 255, 0)))\n ## reads now may be missing the last set of numbers. Account for this in the node naming.\n elif n in gapset or any([g for g in gapset if n in g]):\n node_colors.append(nx_helpers.rgb_to_hex((0, 10, 250)))\n elif n in spanset or any([s for s in spanset if n in s]):\n node_colors.append(nx_helpers.rgb_to_hex((0, 250, 10)))\n else:\n # uncategorized\n node_colors.append(nx_helpers.rgb_to_hex((0, 0, 0)))\n return node_colors","def greedy_coloring(*args):\r\n # get arguments\r\n G = args[0]\r\n n = G.nodes()\r\n m = G.arcs()\r\n \r\n # check if it a valid Graph\r\n if not G.is_correct_type('u'):\r\n print \"ERROR: the graph is not in one of the valid formats for greedy_coloring()\"\r\n return [], []\r\n \r\n # calculate degrees of each node (set as rows per node)\r\n a_nodes = zeros((n,n), int)\r\n for arc in range(m):\r\n i = G.A[arc,0] # tail of the arc\r\n j = G.A[arc,1] # head of the arc\r\n a_nodes[i-1,j-1] = 1\r\n a_nodes[j-1,i-1] = 1\r\n # get degree and add the node number\r\n degree = sum(a_nodes,0)\r\n degree = vstack((degree, array(range(n), int) + 1))\r\n \r\n # initialize coloring vector\r\n coloring = zeros(n, int)\r\n color_step = 1\r\n \r\n # if there are any nodes of degree 0 color them first\r\n while min(degree[0,:]) == 0:\r\n n_i = argmin(degree[0,:]) # get node with zero\r\n i = degree[1,n_i]\r\n # eliminate the node column from the list and matrix\r\n degree = delete(degree, s_[n_i], axis=1)\r\n a_nodes = delete(a_nodes, s_[n_i], axis=1)\r\n # color it\r\n coloring[i-1] = color_step\r\n \r\n # iterate till all nodes have a color\r\n while size(degree) > 0:\r\n n_i = argmax(degree[0,:]) # get node with largest degree\r\n i = degree[1,n_i]\r\n # eliminate the node column from the list and matrix\r\n degree = delete(degree, s_[n_i], axis=1)\r\n a_nodes = delete(a_nodes, s_[n_i], axis=1)\r\n \r\n # color it\r\n coloring[i-1] = color_step\r\n \r\n # color the rest of the possible nodes\r\n possible = 1 - array(a_nodes[i-1,:]) # transforms 0 in 1, and 1 in 0\r\n # iterate while there are possible nodes available\r\n while sum(possible) > 0:\r\n # get the node with largest degree among possible ones\r\n n_j = argmax(degree[0,:] * possible)\r\n j = degree[1,n_j]\r\n # eliminate the node column from the list and matrix\r\n degree = delete(degree, s_[n_j], axis=1)\r\n a_nodes = delete(a_nodes, s_[n_j], axis=1)\r\n possible = delete(possible, n_j)\r\n \r\n # color it\r\n coloring[j-1] = color_step\r\n # eliminate adjacent nodes of j from possible nodes\r\n possible = possible * (1 - a_nodes[j-1,:])\r\n \r\n # update color\r\n color_step += 1\r\n \r\n col_number = max(coloring) # approx chromatic number\r\n \r\n return coloring, col_number","def getColor(self):\n return self._l[2]","def get_color(self):\n return self.color","def attack_surface_coloring(graph, attack_surface):\n color = []\n\n # takes a two-dimensional list\n # and produces a one-dimensional list\n # so we can check if each node is\n # in the attack surface\n flatten = lambda l: [item for sublist in l for item in sublist]\n flat_attack_surface = flatten(attack_surface)\n\n for node in graph:\n if node in flat_attack_surface:\n color.append('red')\n else:\n color.append('grey')\n return color","def color(self):\n if self._simplecell:\n self.fetch()\n return self._color","def _find_community(root, graph, visited):\n community = [root]\n visited.add(root)\n next_queue = [root]\n while next_queue:\n node = next_queue.pop(0)\n for child in graph[node]:\n if child not in visited:\n next_queue.append(child)\n community.append(child)\n visited.add(child)\n\n return community","def getSquareColor(file: int, rank: int) -> str:\r\n if (rank % 2 == file % 2):\r\n return 'light'\r\n else:\r\n return 'dark'","def _get_color(self):\n return self.__color","def _get_color(self):\n return self.__color","def _get_color(self):\n return self.__color","def _get_color(self):\n return self.__color","def getnextcolor(self):\n self.usedcc = [line.get_c() for line in self.axes.lines]\n for c in self.cc:\n if c not in self.usedcc:\n return c\n\n # Only gets here if all colors already used...\n i = len(self.axes.lines)\n numc = len(self.cc)\n i = i % numc\n return self.cc[i]","def get_opponent_color(self, self_color):\r\n return abs(self_color - 1)","def get_neighbors(self, node):\r\n neighbors = set()\r\n for neighbor in ORTHOGONAL_POSITIONS[(node.pos[0], node.pos[1])]:\r\n if self.board[neighbor[0]][neighbor[1]].color == node.color:\r\n neighbors.add(neighbor)\r\n else:\r\n continue\r\n return neighbors","def getColor(self):\r\n return self.color","def get_color(self):\n return COLOR_DICT[self.element]","def find_unused_connection(self, node):\r\n value = None\r\n for index, c in enumerate(node.connections):\r\n if not c.visited:\r\n if value is None:\r\n value = index\r\n if c.value == 'RUNG':\r\n return index\r\n return value","def color(self):\n role_ids = self.role_ids\n if (role_ids is not None):\n for role in sorted((create_partial_role_from_id(role_id) for role_id in self.role_ids), reverse=True):\n color = role.color\n if color:\n return color\n \n return Color()","def _get_color(self, r, g, b):\n clr = (r, g, b)\n return clr","def get_classification_site(self, image):\n #TODO implement light color prediction\n \n\timg=cv2.resize(image,(224,224))\n\timg=img/255.0\n\timg = np.expand_dims(img, axis=0)\n with self.graph.as_default():\n\t pred=self.model.predict(img)\n\tpclass=np.argmax(pred)\n\n \ttf_color=TrafficLight.UNKNOWN\n if (pclass==1):\n\t tf_color=TrafficLight.RED\n elif (pclass==2):\n\t tf_color=TrafficLight.GREEN\n\n return tf_color","def get(self, point):\n string = self.__grid.get(point)\n if string is None:\n return None\n return string.color","def getColor(self):\n return self.side_color","def calc_coloring(graph_rdd):\n graph_rdd = graph_rdd \\\n .map(swap) \\\n .union(graph_rdd)\n nodes = graph_rdd.keys().distinct()\n\n color = nodes.map(lambda x: (x, 1))\n color_num = 1\n\n while True:\n graph_join_color = graph_rdd.join(color)\n neighbour = graph_join_color \\\n .map(lambda (x, (a, bx)): (a, (x, bx))) \\\n .groupByKey() \\\n .map(lambda (x, y): (x, [n[1] for n in y]))\n color = neighbour.map(lambda (x, y): (x, hash(str(sorted(y)))))\n color_new = color \\\n .map(swap) \\\n .reduceByKey(add, numPartitions=40) \\\n .map(lambda x: 1) \\\n .reduce(add)\n if color_num != color_new:\n break\n color_num = color_new\n return color","def get_color(self):\n\n return self.color","def _get_connected(edge, idx):\n if str(edge[0]) == str(idx) and A.lookup[int(edge[1])][\"word\"] != Num:\n return edge[1]\n elif str(edge[1]) == str(idx) and A.lookup[int(edge[0])][\"word\"] != Num:\n return edge[0]","def get_ref_obj_color(ref_obj):\n ref_obj_color = (\n ref_obj[\"color\"] if ref_obj[\"color\"] in utils.TRAIN_COLORS else \"unknown\")\n return ref_obj_color","def get_groups(nodes):\n return list(set([node.color for node in nodes]))","def brute_force_coloring(*args):\r\n # get arguments\r\n G = args[0]\r\n n = G.nodes()\r\n m = G.arcs()\r\n \r\n # check if it a valid Graph\r\n if not G.is_correct_type('u'):\r\n print \"ERROR: the graph is not in one of the valid formats for brute_force_coloring()\"\r\n return [], []\r\n \r\n coloring = ones(n, int) # initialize with just one color\r\n chrom_n = inf # initialize chromatic number\r\n min_coloring = [] # initialize minimum coloring\r\n \r\n # iterate till you get a coloring (really stupid way)\r\n terminal = array(range(n), int) + 1\r\n while sum(coloring != terminal) > 0:\r\n #print coloring\r\n coloring[n-1] += 1\r\n # correct if some achieve n\r\n for node in range(n-1):\r\n # if one get above n\r\n if coloring[n-1-node] > max(coloring[0:n-1-node]) + 1:\r\n coloring[n-1-node] = 1 # take one and...\r\n coloring[n-2-node] += 1 # ... add it to the previous one\r\n \r\n # if it is a coloring check it\r\n if G.is_coloring(coloring):\r\n col_number = max(coloring) # number of colors\r\n # if it is better, update\r\n if col_number < chrom_n:\r\n chrom_n = col_number\r\n min_coloring = coloring.copy()\r\n print \"current minimum: \", min_coloring, \"with %d colors\" %(chrom_n)\r\n \r\n return min_coloring, chrom_n","def match(self, color: Color) -> ColorPoint:\n results = self.tree.search_nn(color.hsl)\n if not results:\n raise KeyError('No match found for color: {}'.format(color))\n return results[0].data","def color(self):\n if \"color\" in self._prop_dict:\n return self._prop_dict[\"color\"]\n else:\n return None","def get_color(self) -> Optional[str]:\n return self.color","def get_skincluster_node(input_object):\n history_list = input_object.listHistory(pruneDagObjects = True, interestLevel = True)\n skin_node = None\n for o in history_list:\n if o.nodeType() == 'skinCluster':\n skin_node = o\n\n return skin_node","def get_color(self):\r\n return self._color","def get_color(self) -> str:\r\n return self.color","def getColor(self):\n return self.color","def getColor(self, visited):\r\n if visited == \"n\":\r\n button_color = [0.4, 0.6, 0, 1]\r\n else:\r\n button_color = [0.4, 0.7, 0.9, 1]\r\n return button_color","def community(self):\n return self._community","def random_color(search=None): \r\n if search: c = choice(search_color(search))\r\n else: c = choice(THECOLORS.values())\r\n \r\n #debug: print type(c), c # returns Color()\r\n return c \r\n #todo: exception on color search fail? OR just default to white.\r","def get_color(self):\r\n return self.__color","def piece_color(self, piece):\n if piece == None:\n return None\n if ord(ChessPiece.W_KING) <= ord(piece) <= ord(ChessPiece.W_PAWN):\n return \"white\"\n return \"black\"","def get_colors(self):\n colors = [\"#244486\", \"#A6A6A6\", \"#B12122\"]\n cmap = LinearSegmentedColormap.from_list(\"mycmap\", colors)\n\n color_palette=[cmap(i) for i in np.linspace(0, 1, len(set(self.nodes_list)))]\n return dict(zip(list(set(self.nodes_list)), color_palette))","def what_node(instance, node):\n map_dict = nodes_mapped(instance)\n\n for nd, ammentity in map_dict.items():\n if nd == node:\n return ammentity","def getPixelColor(self, n):\n\t\treturn self.leds[n]","def get_color(self) -> str:\n return self.color","def conseguir_color(self):\n return self.pluma.conseguir_color()","def get_color(self, item_to_color):\r\n\r\n color = (255, 255, 255)\r\n for item in self.data.items():\r\n if item[0] == item_to_color:\r\n existing_color = [i for i, v in enumerate(self.color_map) if v[0] == item[0]]\r\n if existing_color is not None and existing_color:\r\n return self.color_map[existing_color[0]][1]\r\n else:\r\n r = random.randint(0, 255)\r\n g = random.randint(0, 255)\r\n b = random.randint(0, 255)\r\n color = (r, g, b)\r\n self.color_map.append((item[0], color))\r\n return color\r\n self.color_map.append((item_to_color, color))\r\n return color","def color(self, label):\n if self.grayscale:\n return (\"#ffffff\", \"#555555\", \"#888888\", \"#bbbbbb\", \"#222222\")[label]\n # COC WL WR SL SR\n return (\"#4e73b0\", \"#fdb863\", \"#b2abd2\", \"#e66101\", \"#5e3c99\")[label]","def _get_colour(block: Block, position: Tuple[int, int], unit_size: int) \\\r\n -> Tuple[int, int, int]:\r\n if len(block.children) == 0:\r\n return block.colour\r\n x_pos = position[0] * unit_size + (unit_size / 100)\r\n y_pos = position[1] * unit_size + (unit_size / 100)\r\n for child in block.children:\r\n child_left = child.position[0]\r\n child_top = child.position[1]\r\n child_right = child_left + child.size\r\n child_bott = child_top + child.size\r\n if child_left <= x_pos < child_right and \\\r\n child_top <= y_pos < child_bott:\r\n return _get_colour(child, position, unit_size)\r\n return None","def recognize_color(color, palette):\n min_distance = np.inf\n most_similar_color = None\n for cname, cvalue in palette.items():\n distance = np.sum(np.abs(np.array(color) - np.array(cvalue)))\n if distance < min_distance:\n min_distance = distance\n most_similar_color = cname\n return most_similar_color","def find_node(self, node_name):\n return self.labeled_nodes[node_name]","def get_color(self):\n return self._color","def get_color(self):\n return self._color","def pickColor(point):\n x = point[0]\n y = point[1]\n depth = 40\n if 0 < x <= 72 and 0 < y <= depth:\n return (255, 255, 255) # eraser\n if 72 < x <= 138 and 0 < y <= depth:\n return (0,0,0) # black\n if 138 < x <= 204 and 0 < y <= depth:\n return (122,78,32) # brown\n if 204 < x <= 270 and 0 < y <= depth:\n return (242,0,255) # purple\n if 270 < x <= 336 and 0 < y <= depth:\n return (0,0,255) # blue\n if 336 < x <= 402 and 0 < y <= depth:\n return (63,255,0) # green\n if 402 < x <= 468 and 0 < y <= depth:\n return (255,250,0) # yellow\n if 468 < x <= 534 and 0 < y <= depth:\n return (255,174,0) # orange\n if 534 < x <= 600 and 0 < y <= depth:\n return (255,0,0) # red","def bipartite_color(G):\n color={}\n for n in G: # handle disconnected graphs\n if n in color: continue\n queue=[n] \n color[n]=1 # nodes seen with color (1 or 0)\n while queue:\n v=queue.pop()\n c=1-color[v] # opposite color of node v\n for w in G[v]: \n if w in color: \n if color[w]==color[v]:\n raise networkx.NetworkXError(\"Graph is not bipartite.\")\n else:\n color[w]=c\n queue.append(w)\n return color","def get_color(db, recipient_id):\n query = db.execute(\n \"SELECT color FROM recipient_preferences WHERE recipient_ids=?\",\n (recipient_id,),\n )\n color = query.fetchone()[0]\n return color","def color(self):\n return self.settings['color']","def cluster_connectivity(G, weight='weight'):\n\t# 1) indexing the edges by community\n\tsum_edges_dic = { com : {} for com in range(G.nb_communities)}\n\tfor node1, node2 in G.edges():\n\t\tcomm1 = G.nodes[node1]['community']\n\t\tcomm2 = G.nodes[node2]['community']\n\t\tif comm2 not in sum_edges_dic[comm1]:\n\t\t\tsum_edges_dic[comm1][comm2] = 0\n\t\t\tsum_edges_dic[comm2][comm1] = 0\n\t\telse:\n\t\t\tif weight is None:\n\t\t\t\tsum_edges_dic[comm1][comm2] += 1\n\t\t\t\tsum_edges_dic[comm2][comm1] += 1\n\t\t\telse:\t\n\t\t\t\tsum_edges_dic[comm1][comm2] += G.edges[node1, node2][weight]\n\t\t\t\tsum_edges_dic[comm2][comm1] += G.edges[node1, node2][weight]\n\tc_connectivity = {}\n\t# 2) computing the connectivity\n\tfor com in sum_edges_dic:\n\t\tin_out_edges = sum(sum_edges_dic[com].values())\n\t\tc_connectivity[com] = round(- np.log2(sum_edges_dic[com][com] / in_out_edges),3) \n\treturn c_connectivity","def get_colour(self):\n return self.colour","def search_cluster_by_node(self, target):\n for i in range(len(self.result)):\n cluster = self.result[i]\n for node in cluster.get_nodes():\n if target == node:\n return i\n return None","def color_selector (el):\n\n if el < 1000:\n return 'green'\n elif 1000 < el < 2500:\n return 'orange'\n else:\n return 'red'","def get_node(self, n):\n return self.vert_dict.get(n)","def _get_color(self, color_name):\n if not color_name:\n return 0\n\n if color_name == 'ORANGE':\n color = self.COLOR_ORANGE\n else:\n color = getattr(curses, 'COLOR_' + color_name)\n return curses.color_pair(color)","def random_color():\n colormode(255)\n return randint(0, 255), randint(0, 255), randint(0, 255)","def whatsgreen2(image):\n green = image.hueDistance(color= Color('green'), minvalue=40).binarize()\n return green"],"string":"[\n \"def node_community_colors(graph, communities):\\n colors = nx_helpers.generate_colors(len(communities))\\n\\n def which_color(node):\\n \\\"\\\"\\\"finds which community node is in and returns\\n its corresponding color\\n \\\"\\\"\\\"\\n for i, com in enumerate(communities):\\n if node in com:\\n return colors[i]\\n return nx_helpers.rgb_to_hex((0, 0, 0))\\n\\n node_colors = [which_color(node) for node in graph.nodes()]\\n return node_colors\",\n \"def get_color(node, color_map):\\r\\n if node in color_map:\\r\\n return color_map[node]\\r\\n return \\\"black\\\"\",\n \"def get_color(self, node: Node) -> str:\\n\\n idx = hash(node.get_kind_name()) % len(self.colors_)\\n return self.colors_[idx]\",\n \"def get_node_color(node_label):\\n for NODE_KEY in list(NODE_TYPES.keys()):\\n if node_label in NODE_TYPES[NODE_KEY]:\\n return NODE_COLOR_DICT[NODE_KEY]\\n try:\\n x = int(node_label)\\n return NODE_COLOR_DICT['Terminals']\\n except:\\n try:\\n x = float(node_label)\\n return NODE_COLOR_DICT['Terminals']\\n except:\\n try:\\n node_label = node_label.replace(\\\"\\\\'\\\", \\\"\\\\\\\"\\\")\\n tree = json.loads(node_label)\\n for key in tree.keys():\\n if key not in NODE_TYPES['Learner Params']:\\n return NODE_COLOR_DICT['Uncategorized']\\n else:\\n try:\\n x = int(tree[key])\\n except:\\n try:\\n x = float(tree[key])\\n except:\\n return NODE_COLOR_DICT['Uncategorized']\\n return NODE_COLOR_DICT['Learner Params']\\n except:\\n return NODE_COLOR_DICT['Uncategorized']\\n return NODE_COLOR_DICT['Uncategorized']\",\n \"def get_node_color(self, origin_node_id):\\n origin_node_id %= 11\\n if origin_node_id == 9:\\n return 0.753, 0.753, 0.753, 1.\\n if origin_node_id == 8:\\n return 0.824, 0.412, 0.118, 1.\\n if origin_node_id == 7:\\n return 1.000, 0.000, 1.000, 1.\\n if origin_node_id == 6:\\n return 1.000, 1.000, 0.000, 1.\\n if origin_node_id == 5:\\n return 1.000, 0.627, 0.478, 1.\\n if origin_node_id == 4:\\n return 0.498, 1.000, 0.000, 1.\\n if origin_node_id == 3:\\n return 0.000, 1.000, 1.000, 1.\\n if origin_node_id == 2:\\n return 1.000, 0.922, 0.804, 1.\\n if origin_node_id == 1:\\n return 0.871, 0.722, 0.529, 1.\\n if origin_node_id == 0:\\n return 0.000, 0.749, 1.000, 1.\\n if origin_node_id == 0:\\n return 0.500, 0.549, 1.000, 1.\\n\\n return 0.8, 0.8, 0.8, 1.0\",\n \"def color_chosen_nodes(network, chosen_node, color):\\n\\n # Color the node selected randomly by RWR\\n network.nodes[chosen_node]['color'] = color\\n # Create a list with color for each node\\n color_nodes = [network.nodes[node]['color'] for node in network.nodes]\\n return color_nodes\",\n \"def get_graph_color ( self, object ):\\n return self.graph_color_\",\n \"def getCurrentColor(self):\\n if self.__currentnode__ is None:\\n return None\\n else:\\n return self.__currentnode__.getPlayer().getColor()\",\n \"def maximal_color(graph, node):\\n return max(get_node_colors(graph, node))\",\n \"def colorNode(node):\\n # Try to find the session color manager.\\n manager = _findSessionColorManager()\\n\\n # If one exists, use it to try to color the node.\\n if manager is not None:\\n manager.colorNode(node)\",\n \"def colorNodeByName(node):\\n # Try to find the session color manager.\\n manager = _findSessionColorManager()\\n\\n # If one exists, use it to try to color the node.\\n if manager is not None:\\n manager.colorNodeByName(node)\",\n \"def _community(G, u, community):\\n node_u = G.node[u]\\n try:\\n return node_u[community]\\n except KeyError:\\n raise nx.NetworkXAlgorithmError('No community information')\",\n \"def find_local_community(G, seed_node, weight, debug_log=False):\\n nodes_in_community = seed_node if isinstance(seed_node, list) else [seed_node]\\n modularity = edge_modularity(G, nodes_in_community=nodes_in_community, weight=weight)\\n neighbor_edges = get_neighbor_edges(G, nodes_in_community=nodes_in_community)\\n if debug_log:\\n print('==========\\\\nInitial community has nodes:', nodes_in_community)\\n print('Neighbor edges:', neighbor_edges)\\n print('Modularity = %f' % modularity)\\n while neighbor_edges:\\n # Compute the edge_modularity for each neighbor edge,\\n # suppose the neighbor edge is added to the community\\n mod_max, c_max, e_max = 0, None, None\\n for e in neighbor_edges:\\n # edges in the current community\\n edges_in_temp_community = list(G.subgraph(nodes_in_community).edges)\\n # append the candidate edge\\n edges_in_temp_community.append(e)\\n nodes_in_temp_community = list(G.edge_subgraph(edges_in_temp_community).nodes)\\n mod_temp = edge_modularity(G, nodes_in_community=nodes_in_temp_community, weight=weight)\\n if mod_temp > mod_max:\\n mod_max, c_max, e_max = mod_temp, nodes_in_temp_community, e\\n if mod_max > modularity:\\n if debug_log:\\n print('==========\\\\nEdge', e_max, 'and node', set(e_max).difference(nodes_in_community), 'are added to the community')\\n\\n # Update the community and the corresponding neighbor edges\\n nodes_in_community = c_max\\n modularity = mod_max\\n neighbor_edges = get_neighbor_edges(G, nodes_in_community=nodes_in_community)\\n\\n if debug_log:\\n print('The community has nodes:', nodes_in_community)\\n print('Modularity = %f' % mod_max)\\n print('Neighbor edges:', neighbor_edges)\\n else:\\n break\\n return nodes_in_community, modularity\",\n \"def node_colors(self, nodes):\\n zmin, zmax = nodes[:, 2].min(), nodes[:, 2].max()\\n start_color = np.array(self.background) + 5\\n end_color = np.array(self.nodeColor)\\n z = (nodes[:, 2] - zmin) / (zmax - zmin)\\n # indexing [:, None] is used to explicitly state second axis\\n c = (1 - z)[:, None] @ start_color[:, None].T + z[:, None] @ end_color[:, None].T\\n self.wireframe_col = c\\n # return c\",\n \"def colour_node(instance, reaction_colour='darkgrey', Xc_colour='orange', waste_colour='red', res_colour='limegreen', InPr_colour='lightblue'):\\n G, mapping = instance.network()\\n\\n # relabel\\n G = nx.relabel_nodes(G, mapping)\\n\\n node_dict_mapped = nodes_mapped(instance)\\n\\n waste, resources, intmed_products = instance.amenities()\\n\\n colour_map = []\\n\\n for nd in G:\\n # print(\\\"nd\\\",nd)\\n for nd_label, ammentity in node_dict_mapped.items():\\n # print(\\\"nd_label\\\",nd_label)\\n if nd_label == nd:\\n # print(nd, nd_label)\\n\\n if ammentity == \\\"r\\\":\\n colour_map.append(reaction_colour)\\n\\n elif ammentity == \\\"Xc\\\":\\n colour_map.append(Xc_colour)\\n\\n elif ammentity == \\\"w\\\":\\n colour_map.append(waste_colour)\\n\\n elif ammentity == \\\"Xr\\\":\\n colour_map.append(res_colour)\\n\\n elif ammentity == \\\"InPr\\\":\\n colour_map.append(InPr_colour)\\n return colour_map\",\n \"def get_edge_color( row ):\\n\\n rgb = 0.5 * (\\n node_color_dict[ row[ 'source' ] ] + \\\\\\n node_color_dict[ row[ 'target' ] ] )\\n\\n return rgb2hex( rgb )\",\n \"def get_color(edge, nR):\\n R_color, E_color = 'C0', 'C1'\\n edge = sorted(edge)\\n if edge[0] < nR:\\n if edge[1] > nR:\\n comp_color = 'gray'\\n zorder = 10\\n else:\\n comp_color = R_color\\n zorder = 5\\n else:\\n comp_color = E_color\\n zorder = 5\\n return comp_color, zorder\",\n \"def vertex_coloring(self, display = False):\\r\\n stack = self.SL_algorithm()\\r\\n color_of_vertex = self.greedily_coloring(stack)\\r\\n if(display):\\r\\n self.display_graph(color_of_vertex)\\r\\n return color_of_vertex\\r\\n else: \\r\\n return color_of_vertex\",\n \"def nextColorLedCluster(self):\\n hwidRef = YRefParam()\\n if YAPI.YISERR(self._nextFunction(hwidRef)):\\n return None\\n if hwidRef.value == \\\"\\\":\\n return None\\n return YColorLedCluster.FindColorLedCluster(hwidRef.value)\",\n \"def get_color(rank):\\n if rank == 1:\\n color = int(0xffd700)\\n elif rank == 2:\\n color = int(0xc0c0c0)\\n elif rank == 3:\\n color = int(0xcd7f32)\\n else:\\n color = random.randint(1, 16777215)\\n\\n return discord.Color(color)\",\n \"def FirstColorLedCluster():\\n devRef = YRefParam()\\n neededsizeRef = YRefParam()\\n serialRef = YRefParam()\\n funcIdRef = YRefParam()\\n funcNameRef = YRefParam()\\n funcValRef = YRefParam()\\n errmsgRef = YRefParam()\\n size = YAPI.C_INTSIZE\\n #noinspection PyTypeChecker,PyCallingNonCallable\\n p = (ctypes.c_int * 1)()\\n err = YAPI.apiGetFunctionsByClass(\\\"ColorLedCluster\\\", 0, p, size, neededsizeRef, errmsgRef)\\n\\n if YAPI.YISERR(err) or not neededsizeRef.value:\\n return None\\n\\n if YAPI.YISERR(\\n YAPI.yapiGetFunctionInfo(p[0], devRef, serialRef, funcIdRef, funcNameRef, funcValRef, errmsgRef)):\\n return None\\n\\n return YColorLedCluster.FindColorLedCluster(serialRef.value + \\\".\\\" + funcIdRef.value)\",\n \"def community_detection(net_G):\\r\\n if list(nx.isolates(net_G)) == []:\\r\\n part = community.best_partition(net_G)\\r\\n #values = [part.get(node) for node in net_G.nodes()]\\r\\n #nx.draw_spring(net_G, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=False)\\r\\n #plt.show()\\r\\n else:\\r\\n net_G = net_G.copy()\\r\\n net_G.remove_nodes_from(list(nx.isolates(net_G)))\\r\\n part = community.best_partition(net_G)\\r\\n list_nodes = []\\r\\n for com in set(part.values()):\\r\\n list_nodes.append([nodes for nodes in part.keys() if part[nodes] == com])\\r\\n num_of_communities = len(list_nodes)\\r\\n partition_performance = nx.algorithms.community.quality.performance(net_G, list_nodes)\\r\\n net_communities = [[\\\"Numbers of communities:\\\", num_of_communities], \\\\\\r\\n [\\\"Partition performance:\\\", partition_performance]]\\r\\n return net_communities\",\n \"def _greedy_color(self, source):\\n for target in self.graph.iteradjacent(source):\\n if self.color[target] is not None:\\n self._color_list[self.color[target]] = True\\n for c in xrange(self.graph.v()): # check colors\\n if not self._color_list[c]:\\n self.color[source] = c\\n break\\n for target in self.graph.iteradjacent(source):\\n if self.color[target] is not None:\\n self._color_list[self.color[target]] = False\\n return c\",\n \"def FindColorLedCluster(func):\\n # obj\\n obj = YFunction._FindFromCache(\\\"ColorLedCluster\\\", func)\\n if obj is None:\\n obj = YColorLedCluster(func)\\n YFunction._AddToCache(\\\"ColorLedCluster\\\", func, obj)\\n return obj\",\n \"def is_red(node):\\n if node is None:\\n return False\\n return node.colour is True\",\n \"def edge_colors(\\n et: pd.DataFrame,\\n nt: pd.DataFrame,\\n color_by: Hashable,\\n node_color_by: Hashable,\\n):\\n if color_by in (\\\"source_node_color\\\", \\\"target_node_color\\\"):\\n edge_select_by = color_by.split(\\\"_\\\")[0]\\n return encodings.data_color(\\n et[edge_select_by].apply(nt[node_color_by].get),\\n nt[node_color_by],\\n )\\n elif color_by:\\n return encodings.data_color(et[color_by], et[color_by])\\n return pd.Series([\\\"black\\\"] * len(et), name=\\\"color_by\\\")\",\n \"def set_colors(graph):\\n colors = []\\n for n in graph.nodes():\\n node = graph.node[n]\\n if node['adopter'] == 1:\\n colors.append('b')\\n else:\\n colors.append('r')\\n \\n return colors\",\n \"def color(self):\\n return self.container['color']\",\n \"def get_color(self, coord):\\n return self.board[coord[0], coord[1]]\",\n \"def FindColor(self, *args):\\n return _XCAFDoc.XCAFDoc_ColorTool_FindColor(self, *args)\",\n \"def identify_color(animal):\\n min_dist = None\\n identified_color = None\\n for color in animal.colors:\\n color_rgb = color_rgbs[color]\\n dist = ((animal.get_red() - color_rgb[0]) ** 2) + (\\n (animal.get_green() - color_rgb[1]) ** 2) + ((animal.get_blue() - color_rgb[2]) ** 2)\\n if (min_dist is None) or (dist < min_dist):\\n min_dist = dist\\n identified_color = color\\n return identified_color\",\n \"def get_color(self):\\n return self._io.last_state['color']['front-center']\",\n \"def get_color(self):\\r\\n if self.color:\\r\\n return \\\"RED\\\"\\r\\n else:\\r\\n return \\\"BLACK\\\"\",\n \"def get_color(self):\\n return \\\"yellow\\\"\",\n \"def color(self):\\n return self['color']\",\n \"def node_set_colors(nodes, spanset, gapset, preset, postset):\\n\\n node_colors = []\\n for n in nodes:\\n if n in preset:\\n node_colors.append(nx_helpers.rgb_to_hex((255, 0, 0)))\\n elif n in postset:\\n node_colors.append(nx_helpers.rgb_to_hex((255, 255, 0)))\\n ## reads now may be missing the last set of numbers. Account for this in the node naming.\\n elif n in gapset or any([g for g in gapset if n in g]):\\n node_colors.append(nx_helpers.rgb_to_hex((0, 10, 250)))\\n elif n in spanset or any([s for s in spanset if n in s]):\\n node_colors.append(nx_helpers.rgb_to_hex((0, 250, 10)))\\n else:\\n # uncategorized\\n node_colors.append(nx_helpers.rgb_to_hex((0, 0, 0)))\\n return node_colors\",\n \"def greedy_coloring(*args):\\r\\n # get arguments\\r\\n G = args[0]\\r\\n n = G.nodes()\\r\\n m = G.arcs()\\r\\n \\r\\n # check if it a valid Graph\\r\\n if not G.is_correct_type('u'):\\r\\n print \\\"ERROR: the graph is not in one of the valid formats for greedy_coloring()\\\"\\r\\n return [], []\\r\\n \\r\\n # calculate degrees of each node (set as rows per node)\\r\\n a_nodes = zeros((n,n), int)\\r\\n for arc in range(m):\\r\\n i = G.A[arc,0] # tail of the arc\\r\\n j = G.A[arc,1] # head of the arc\\r\\n a_nodes[i-1,j-1] = 1\\r\\n a_nodes[j-1,i-1] = 1\\r\\n # get degree and add the node number\\r\\n degree = sum(a_nodes,0)\\r\\n degree = vstack((degree, array(range(n), int) + 1))\\r\\n \\r\\n # initialize coloring vector\\r\\n coloring = zeros(n, int)\\r\\n color_step = 1\\r\\n \\r\\n # if there are any nodes of degree 0 color them first\\r\\n while min(degree[0,:]) == 0:\\r\\n n_i = argmin(degree[0,:]) # get node with zero\\r\\n i = degree[1,n_i]\\r\\n # eliminate the node column from the list and matrix\\r\\n degree = delete(degree, s_[n_i], axis=1)\\r\\n a_nodes = delete(a_nodes, s_[n_i], axis=1)\\r\\n # color it\\r\\n coloring[i-1] = color_step\\r\\n \\r\\n # iterate till all nodes have a color\\r\\n while size(degree) > 0:\\r\\n n_i = argmax(degree[0,:]) # get node with largest degree\\r\\n i = degree[1,n_i]\\r\\n # eliminate the node column from the list and matrix\\r\\n degree = delete(degree, s_[n_i], axis=1)\\r\\n a_nodes = delete(a_nodes, s_[n_i], axis=1)\\r\\n \\r\\n # color it\\r\\n coloring[i-1] = color_step\\r\\n \\r\\n # color the rest of the possible nodes\\r\\n possible = 1 - array(a_nodes[i-1,:]) # transforms 0 in 1, and 1 in 0\\r\\n # iterate while there are possible nodes available\\r\\n while sum(possible) > 0:\\r\\n # get the node with largest degree among possible ones\\r\\n n_j = argmax(degree[0,:] * possible)\\r\\n j = degree[1,n_j]\\r\\n # eliminate the node column from the list and matrix\\r\\n degree = delete(degree, s_[n_j], axis=1)\\r\\n a_nodes = delete(a_nodes, s_[n_j], axis=1)\\r\\n possible = delete(possible, n_j)\\r\\n \\r\\n # color it\\r\\n coloring[j-1] = color_step\\r\\n # eliminate adjacent nodes of j from possible nodes\\r\\n possible = possible * (1 - a_nodes[j-1,:])\\r\\n \\r\\n # update color\\r\\n color_step += 1\\r\\n \\r\\n col_number = max(coloring) # approx chromatic number\\r\\n \\r\\n return coloring, col_number\",\n \"def getColor(self):\\n return self._l[2]\",\n \"def get_color(self):\\n return self.color\",\n \"def attack_surface_coloring(graph, attack_surface):\\n color = []\\n\\n # takes a two-dimensional list\\n # and produces a one-dimensional list\\n # so we can check if each node is\\n # in the attack surface\\n flatten = lambda l: [item for sublist in l for item in sublist]\\n flat_attack_surface = flatten(attack_surface)\\n\\n for node in graph:\\n if node in flat_attack_surface:\\n color.append('red')\\n else:\\n color.append('grey')\\n return color\",\n \"def color(self):\\n if self._simplecell:\\n self.fetch()\\n return self._color\",\n \"def _find_community(root, graph, visited):\\n community = [root]\\n visited.add(root)\\n next_queue = [root]\\n while next_queue:\\n node = next_queue.pop(0)\\n for child in graph[node]:\\n if child not in visited:\\n next_queue.append(child)\\n community.append(child)\\n visited.add(child)\\n\\n return community\",\n \"def getSquareColor(file: int, rank: int) -> str:\\r\\n if (rank % 2 == file % 2):\\r\\n return 'light'\\r\\n else:\\r\\n return 'dark'\",\n \"def _get_color(self):\\n return self.__color\",\n \"def _get_color(self):\\n return self.__color\",\n \"def _get_color(self):\\n return self.__color\",\n \"def _get_color(self):\\n return self.__color\",\n \"def getnextcolor(self):\\n self.usedcc = [line.get_c() for line in self.axes.lines]\\n for c in self.cc:\\n if c not in self.usedcc:\\n return c\\n\\n # Only gets here if all colors already used...\\n i = len(self.axes.lines)\\n numc = len(self.cc)\\n i = i % numc\\n return self.cc[i]\",\n \"def get_opponent_color(self, self_color):\\r\\n return abs(self_color - 1)\",\n \"def get_neighbors(self, node):\\r\\n neighbors = set()\\r\\n for neighbor in ORTHOGONAL_POSITIONS[(node.pos[0], node.pos[1])]:\\r\\n if self.board[neighbor[0]][neighbor[1]].color == node.color:\\r\\n neighbors.add(neighbor)\\r\\n else:\\r\\n continue\\r\\n return neighbors\",\n \"def getColor(self):\\r\\n return self.color\",\n \"def get_color(self):\\n return COLOR_DICT[self.element]\",\n \"def find_unused_connection(self, node):\\r\\n value = None\\r\\n for index, c in enumerate(node.connections):\\r\\n if not c.visited:\\r\\n if value is None:\\r\\n value = index\\r\\n if c.value == 'RUNG':\\r\\n return index\\r\\n return value\",\n \"def color(self):\\n role_ids = self.role_ids\\n if (role_ids is not None):\\n for role in sorted((create_partial_role_from_id(role_id) for role_id in self.role_ids), reverse=True):\\n color = role.color\\n if color:\\n return color\\n \\n return Color()\",\n \"def _get_color(self, r, g, b):\\n clr = (r, g, b)\\n return clr\",\n \"def get_classification_site(self, image):\\n #TODO implement light color prediction\\n \\n\\timg=cv2.resize(image,(224,224))\\n\\timg=img/255.0\\n\\timg = np.expand_dims(img, axis=0)\\n with self.graph.as_default():\\n\\t pred=self.model.predict(img)\\n\\tpclass=np.argmax(pred)\\n\\n \\ttf_color=TrafficLight.UNKNOWN\\n if (pclass==1):\\n\\t tf_color=TrafficLight.RED\\n elif (pclass==2):\\n\\t tf_color=TrafficLight.GREEN\\n\\n return tf_color\",\n \"def get(self, point):\\n string = self.__grid.get(point)\\n if string is None:\\n return None\\n return string.color\",\n \"def getColor(self):\\n return self.side_color\",\n \"def calc_coloring(graph_rdd):\\n graph_rdd = graph_rdd \\\\\\n .map(swap) \\\\\\n .union(graph_rdd)\\n nodes = graph_rdd.keys().distinct()\\n\\n color = nodes.map(lambda x: (x, 1))\\n color_num = 1\\n\\n while True:\\n graph_join_color = graph_rdd.join(color)\\n neighbour = graph_join_color \\\\\\n .map(lambda (x, (a, bx)): (a, (x, bx))) \\\\\\n .groupByKey() \\\\\\n .map(lambda (x, y): (x, [n[1] for n in y]))\\n color = neighbour.map(lambda (x, y): (x, hash(str(sorted(y)))))\\n color_new = color \\\\\\n .map(swap) \\\\\\n .reduceByKey(add, numPartitions=40) \\\\\\n .map(lambda x: 1) \\\\\\n .reduce(add)\\n if color_num != color_new:\\n break\\n color_num = color_new\\n return color\",\n \"def get_color(self):\\n\\n return self.color\",\n \"def _get_connected(edge, idx):\\n if str(edge[0]) == str(idx) and A.lookup[int(edge[1])][\\\"word\\\"] != Num:\\n return edge[1]\\n elif str(edge[1]) == str(idx) and A.lookup[int(edge[0])][\\\"word\\\"] != Num:\\n return edge[0]\",\n \"def get_ref_obj_color(ref_obj):\\n ref_obj_color = (\\n ref_obj[\\\"color\\\"] if ref_obj[\\\"color\\\"] in utils.TRAIN_COLORS else \\\"unknown\\\")\\n return ref_obj_color\",\n \"def get_groups(nodes):\\n return list(set([node.color for node in nodes]))\",\n \"def brute_force_coloring(*args):\\r\\n # get arguments\\r\\n G = args[0]\\r\\n n = G.nodes()\\r\\n m = G.arcs()\\r\\n \\r\\n # check if it a valid Graph\\r\\n if not G.is_correct_type('u'):\\r\\n print \\\"ERROR: the graph is not in one of the valid formats for brute_force_coloring()\\\"\\r\\n return [], []\\r\\n \\r\\n coloring = ones(n, int) # initialize with just one color\\r\\n chrom_n = inf # initialize chromatic number\\r\\n min_coloring = [] # initialize minimum coloring\\r\\n \\r\\n # iterate till you get a coloring (really stupid way)\\r\\n terminal = array(range(n), int) + 1\\r\\n while sum(coloring != terminal) > 0:\\r\\n #print coloring\\r\\n coloring[n-1] += 1\\r\\n # correct if some achieve n\\r\\n for node in range(n-1):\\r\\n # if one get above n\\r\\n if coloring[n-1-node] > max(coloring[0:n-1-node]) + 1:\\r\\n coloring[n-1-node] = 1 # take one and...\\r\\n coloring[n-2-node] += 1 # ... add it to the previous one\\r\\n \\r\\n # if it is a coloring check it\\r\\n if G.is_coloring(coloring):\\r\\n col_number = max(coloring) # number of colors\\r\\n # if it is better, update\\r\\n if col_number < chrom_n:\\r\\n chrom_n = col_number\\r\\n min_coloring = coloring.copy()\\r\\n print \\\"current minimum: \\\", min_coloring, \\\"with %d colors\\\" %(chrom_n)\\r\\n \\r\\n return min_coloring, chrom_n\",\n \"def match(self, color: Color) -> ColorPoint:\\n results = self.tree.search_nn(color.hsl)\\n if not results:\\n raise KeyError('No match found for color: {}'.format(color))\\n return results[0].data\",\n \"def color(self):\\n if \\\"color\\\" in self._prop_dict:\\n return self._prop_dict[\\\"color\\\"]\\n else:\\n return None\",\n \"def get_color(self) -> Optional[str]:\\n return self.color\",\n \"def get_skincluster_node(input_object):\\n history_list = input_object.listHistory(pruneDagObjects = True, interestLevel = True)\\n skin_node = None\\n for o in history_list:\\n if o.nodeType() == 'skinCluster':\\n skin_node = o\\n\\n return skin_node\",\n \"def get_color(self):\\r\\n return self._color\",\n \"def get_color(self) -> str:\\r\\n return self.color\",\n \"def getColor(self):\\n return self.color\",\n \"def getColor(self, visited):\\r\\n if visited == \\\"n\\\":\\r\\n button_color = [0.4, 0.6, 0, 1]\\r\\n else:\\r\\n button_color = [0.4, 0.7, 0.9, 1]\\r\\n return button_color\",\n \"def community(self):\\n return self._community\",\n \"def random_color(search=None): \\r\\n if search: c = choice(search_color(search))\\r\\n else: c = choice(THECOLORS.values())\\r\\n \\r\\n #debug: print type(c), c # returns Color()\\r\\n return c \\r\\n #todo: exception on color search fail? OR just default to white.\\r\",\n \"def get_color(self):\\r\\n return self.__color\",\n \"def piece_color(self, piece):\\n if piece == None:\\n return None\\n if ord(ChessPiece.W_KING) <= ord(piece) <= ord(ChessPiece.W_PAWN):\\n return \\\"white\\\"\\n return \\\"black\\\"\",\n \"def get_colors(self):\\n colors = [\\\"#244486\\\", \\\"#A6A6A6\\\", \\\"#B12122\\\"]\\n cmap = LinearSegmentedColormap.from_list(\\\"mycmap\\\", colors)\\n\\n color_palette=[cmap(i) for i in np.linspace(0, 1, len(set(self.nodes_list)))]\\n return dict(zip(list(set(self.nodes_list)), color_palette))\",\n \"def what_node(instance, node):\\n map_dict = nodes_mapped(instance)\\n\\n for nd, ammentity in map_dict.items():\\n if nd == node:\\n return ammentity\",\n \"def getPixelColor(self, n):\\n\\t\\treturn self.leds[n]\",\n \"def get_color(self) -> str:\\n return self.color\",\n \"def conseguir_color(self):\\n return self.pluma.conseguir_color()\",\n \"def get_color(self, item_to_color):\\r\\n\\r\\n color = (255, 255, 255)\\r\\n for item in self.data.items():\\r\\n if item[0] == item_to_color:\\r\\n existing_color = [i for i, v in enumerate(self.color_map) if v[0] == item[0]]\\r\\n if existing_color is not None and existing_color:\\r\\n return self.color_map[existing_color[0]][1]\\r\\n else:\\r\\n r = random.randint(0, 255)\\r\\n g = random.randint(0, 255)\\r\\n b = random.randint(0, 255)\\r\\n color = (r, g, b)\\r\\n self.color_map.append((item[0], color))\\r\\n return color\\r\\n self.color_map.append((item_to_color, color))\\r\\n return color\",\n \"def color(self, label):\\n if self.grayscale:\\n return (\\\"#ffffff\\\", \\\"#555555\\\", \\\"#888888\\\", \\\"#bbbbbb\\\", \\\"#222222\\\")[label]\\n # COC WL WR SL SR\\n return (\\\"#4e73b0\\\", \\\"#fdb863\\\", \\\"#b2abd2\\\", \\\"#e66101\\\", \\\"#5e3c99\\\")[label]\",\n \"def _get_colour(block: Block, position: Tuple[int, int], unit_size: int) \\\\\\r\\n -> Tuple[int, int, int]:\\r\\n if len(block.children) == 0:\\r\\n return block.colour\\r\\n x_pos = position[0] * unit_size + (unit_size / 100)\\r\\n y_pos = position[1] * unit_size + (unit_size / 100)\\r\\n for child in block.children:\\r\\n child_left = child.position[0]\\r\\n child_top = child.position[1]\\r\\n child_right = child_left + child.size\\r\\n child_bott = child_top + child.size\\r\\n if child_left <= x_pos < child_right and \\\\\\r\\n child_top <= y_pos < child_bott:\\r\\n return _get_colour(child, position, unit_size)\\r\\n return None\",\n \"def recognize_color(color, palette):\\n min_distance = np.inf\\n most_similar_color = None\\n for cname, cvalue in palette.items():\\n distance = np.sum(np.abs(np.array(color) - np.array(cvalue)))\\n if distance < min_distance:\\n min_distance = distance\\n most_similar_color = cname\\n return most_similar_color\",\n \"def find_node(self, node_name):\\n return self.labeled_nodes[node_name]\",\n \"def get_color(self):\\n return self._color\",\n \"def get_color(self):\\n return self._color\",\n \"def pickColor(point):\\n x = point[0]\\n y = point[1]\\n depth = 40\\n if 0 < x <= 72 and 0 < y <= depth:\\n return (255, 255, 255) # eraser\\n if 72 < x <= 138 and 0 < y <= depth:\\n return (0,0,0) # black\\n if 138 < x <= 204 and 0 < y <= depth:\\n return (122,78,32) # brown\\n if 204 < x <= 270 and 0 < y <= depth:\\n return (242,0,255) # purple\\n if 270 < x <= 336 and 0 < y <= depth:\\n return (0,0,255) # blue\\n if 336 < x <= 402 and 0 < y <= depth:\\n return (63,255,0) # green\\n if 402 < x <= 468 and 0 < y <= depth:\\n return (255,250,0) # yellow\\n if 468 < x <= 534 and 0 < y <= depth:\\n return (255,174,0) # orange\\n if 534 < x <= 600 and 0 < y <= depth:\\n return (255,0,0) # red\",\n \"def bipartite_color(G):\\n color={}\\n for n in G: # handle disconnected graphs\\n if n in color: continue\\n queue=[n] \\n color[n]=1 # nodes seen with color (1 or 0)\\n while queue:\\n v=queue.pop()\\n c=1-color[v] # opposite color of node v\\n for w in G[v]: \\n if w in color: \\n if color[w]==color[v]:\\n raise networkx.NetworkXError(\\\"Graph is not bipartite.\\\")\\n else:\\n color[w]=c\\n queue.append(w)\\n return color\",\n \"def get_color(db, recipient_id):\\n query = db.execute(\\n \\\"SELECT color FROM recipient_preferences WHERE recipient_ids=?\\\",\\n (recipient_id,),\\n )\\n color = query.fetchone()[0]\\n return color\",\n \"def color(self):\\n return self.settings['color']\",\n \"def cluster_connectivity(G, weight='weight'):\\n\\t# 1) indexing the edges by community\\n\\tsum_edges_dic = { com : {} for com in range(G.nb_communities)}\\n\\tfor node1, node2 in G.edges():\\n\\t\\tcomm1 = G.nodes[node1]['community']\\n\\t\\tcomm2 = G.nodes[node2]['community']\\n\\t\\tif comm2 not in sum_edges_dic[comm1]:\\n\\t\\t\\tsum_edges_dic[comm1][comm2] = 0\\n\\t\\t\\tsum_edges_dic[comm2][comm1] = 0\\n\\t\\telse:\\n\\t\\t\\tif weight is None:\\n\\t\\t\\t\\tsum_edges_dic[comm1][comm2] += 1\\n\\t\\t\\t\\tsum_edges_dic[comm2][comm1] += 1\\n\\t\\t\\telse:\\t\\n\\t\\t\\t\\tsum_edges_dic[comm1][comm2] += G.edges[node1, node2][weight]\\n\\t\\t\\t\\tsum_edges_dic[comm2][comm1] += G.edges[node1, node2][weight]\\n\\tc_connectivity = {}\\n\\t# 2) computing the connectivity\\n\\tfor com in sum_edges_dic:\\n\\t\\tin_out_edges = sum(sum_edges_dic[com].values())\\n\\t\\tc_connectivity[com] = round(- np.log2(sum_edges_dic[com][com] / in_out_edges),3) \\n\\treturn c_connectivity\",\n \"def get_colour(self):\\n return self.colour\",\n \"def search_cluster_by_node(self, target):\\n for i in range(len(self.result)):\\n cluster = self.result[i]\\n for node in cluster.get_nodes():\\n if target == node:\\n return i\\n return None\",\n \"def color_selector (el):\\n\\n if el < 1000:\\n return 'green'\\n elif 1000 < el < 2500:\\n return 'orange'\\n else:\\n return 'red'\",\n \"def get_node(self, n):\\n return self.vert_dict.get(n)\",\n \"def _get_color(self, color_name):\\n if not color_name:\\n return 0\\n\\n if color_name == 'ORANGE':\\n color = self.COLOR_ORANGE\\n else:\\n color = getattr(curses, 'COLOR_' + color_name)\\n return curses.color_pair(color)\",\n \"def random_color():\\n colormode(255)\\n return randint(0, 255), randint(0, 255), randint(0, 255)\",\n \"def whatsgreen2(image):\\n green = image.hueDistance(color= Color('green'), minvalue=40).binarize()\\n return green\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75510806","0.69493985","0.66909236","0.66592944","0.6608618","0.64989406","0.6450056","0.64425915","0.64138216","0.6396164","0.6335987","0.6323094","0.62105125","0.6205423","0.61846185","0.617105","0.6087763","0.59781784","0.5975609","0.59191763","0.590046","0.5883436","0.58277667","0.58133215","0.57972234","0.5789967","0.57800215","0.577198","0.57589364","0.57484853","0.5693132","0.56747425","0.56610084","0.5653902","0.56497955","0.56087536","0.5603084","0.56027955","0.55723655","0.555901","0.5556998","0.554984","0.55457515","0.55416286","0.55416286","0.55416286","0.55416286","0.5536191","0.55315506","0.55097127","0.550429","0.5504233","0.54935014","0.5474432","0.5444826","0.5436035","0.5435701","0.5430476","0.54279697","0.5426478","0.54249585","0.5408057","0.540188","0.5398691","0.53941","0.53940636","0.53897053","0.5389264","0.538866","0.5387639","0.5369292","0.5362093","0.53601766","0.53594434","0.535909","0.53573054","0.5354674","0.5341052","0.5336561","0.53310156","0.5326568","0.5318661","0.5315958","0.5313776","0.5305811","0.5304648","0.53015274","0.53015274","0.5290074","0.5266578","0.52459705","0.5244946","0.52388847","0.5226204","0.5218888","0.5217054","0.5215104","0.5211401","0.52077556","0.5207725"],"string":"[\n \"0.75510806\",\n \"0.69493985\",\n \"0.66909236\",\n \"0.66592944\",\n \"0.6608618\",\n \"0.64989406\",\n \"0.6450056\",\n \"0.64425915\",\n \"0.64138216\",\n \"0.6396164\",\n \"0.6335987\",\n \"0.6323094\",\n \"0.62105125\",\n \"0.6205423\",\n \"0.61846185\",\n \"0.617105\",\n \"0.6087763\",\n \"0.59781784\",\n \"0.5975609\",\n \"0.59191763\",\n \"0.590046\",\n \"0.5883436\",\n \"0.58277667\",\n \"0.58133215\",\n \"0.57972234\",\n \"0.5789967\",\n \"0.57800215\",\n \"0.577198\",\n \"0.57589364\",\n \"0.57484853\",\n \"0.5693132\",\n \"0.56747425\",\n \"0.56610084\",\n \"0.5653902\",\n \"0.56497955\",\n \"0.56087536\",\n \"0.5603084\",\n \"0.56027955\",\n \"0.55723655\",\n \"0.555901\",\n \"0.5556998\",\n \"0.554984\",\n \"0.55457515\",\n \"0.55416286\",\n \"0.55416286\",\n \"0.55416286\",\n \"0.55416286\",\n \"0.5536191\",\n \"0.55315506\",\n \"0.55097127\",\n \"0.550429\",\n \"0.5504233\",\n \"0.54935014\",\n \"0.5474432\",\n \"0.5444826\",\n \"0.5436035\",\n \"0.5435701\",\n \"0.5430476\",\n \"0.54279697\",\n \"0.5426478\",\n \"0.54249585\",\n \"0.5408057\",\n \"0.540188\",\n \"0.5398691\",\n \"0.53941\",\n \"0.53940636\",\n \"0.53897053\",\n \"0.5389264\",\n \"0.538866\",\n \"0.5387639\",\n \"0.5369292\",\n \"0.5362093\",\n \"0.53601766\",\n \"0.53594434\",\n \"0.535909\",\n \"0.53573054\",\n \"0.5354674\",\n \"0.5341052\",\n \"0.5336561\",\n \"0.53310156\",\n \"0.5326568\",\n \"0.5318661\",\n \"0.5315958\",\n \"0.5313776\",\n \"0.5305811\",\n \"0.5304648\",\n \"0.53015274\",\n \"0.53015274\",\n \"0.5290074\",\n \"0.5266578\",\n \"0.52459705\",\n \"0.5244946\",\n \"0.52388847\",\n \"0.5226204\",\n \"0.5218888\",\n \"0.5217054\",\n \"0.5215104\",\n \"0.5211401\",\n \"0.52077556\",\n \"0.5207725\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.83000135"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14695,"cells":{"query":{"kind":"string","value":"returns a list of colors for coloring nodes based on which set each node is in"},"document":{"kind":"string","value":"def node_set_colors(nodes, spanset, gapset, preset, postset):\n\n node_colors = []\n for n in nodes:\n if n in preset:\n node_colors.append(nx_helpers.rgb_to_hex((255, 0, 0)))\n elif n in postset:\n node_colors.append(nx_helpers.rgb_to_hex((255, 255, 0)))\n ## reads now may be missing the last set of numbers. Account for this in the node naming.\n elif n in gapset or any([g for g in gapset if n in g]):\n node_colors.append(nx_helpers.rgb_to_hex((0, 10, 250)))\n elif n in spanset or any([s for s in spanset if n in s]):\n node_colors.append(nx_helpers.rgb_to_hex((0, 250, 10)))\n else:\n # uncategorized\n node_colors.append(nx_helpers.rgb_to_hex((0, 0, 0)))\n return node_colors"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_groups(nodes):\n return list(set([node.color for node in nodes]))","def get_colors(self):\n colors = [\"#244486\", \"#A6A6A6\", \"#B12122\"]\n cmap = LinearSegmentedColormap.from_list(\"mycmap\", colors)\n\n color_palette=[cmap(i) for i in np.linspace(0, 1, len(set(self.nodes_list)))]\n return dict(zip(list(set(self.nodes_list)), color_palette))","def set_colors(graph):\n colors = []\n for n in graph.nodes():\n node = graph.node[n]\n if node['adopter'] == 1:\n colors.append('b')\n else:\n colors.append('r')\n \n return colors","def node_colors(self, nodes):\n zmin, zmax = nodes[:, 2].min(), nodes[:, 2].max()\n start_color = np.array(self.background) + 5\n end_color = np.array(self.nodeColor)\n z = (nodes[:, 2] - zmin) / (zmax - zmin)\n # indexing [:, None] is used to explicitly state second axis\n c = (1 - z)[:, None] @ start_color[:, None].T + z[:, None] @ end_color[:, None].T\n self.wireframe_col = c\n # return c","def color_chosen_nodes(network, chosen_node, color):\n\n # Color the node selected randomly by RWR\n network.nodes[chosen_node]['color'] = color\n # Create a list with color for each node\n color_nodes = [network.nodes[node]['color'] for node in network.nodes]\n return color_nodes","def colors(self):\n\t\treturn [(0, 30, 255),(0, 30, 120)]","def getColors():\n return ['#8c99fc', '#cacefd', '#fff1d7', '#feda98', '#fda85a', '#fc6647']","def get_colors():\n colors = {}\n for h in wn.synset('chromatic_color.n.01').hyponyms():\n colors[h.lemmas()[0].name()] = [l.name() for l in h.lemmas()]\n colors[h.lemmas()[0].name()].extend(all_hyponyms(h)) \n for h in wn.synset('achromatic_color.n.01').hyponyms():\n colors[h.lemmas()[0].name()] = [l.name() for l in h.lemmas()]\n colors[h.lemmas()[0].name()].extend(all_hyponyms(h)) \n return colors","def greedy_coloring(*args):\r\n # get arguments\r\n G = args[0]\r\n n = G.nodes()\r\n m = G.arcs()\r\n \r\n # check if it a valid Graph\r\n if not G.is_correct_type('u'):\r\n print \"ERROR: the graph is not in one of the valid formats for greedy_coloring()\"\r\n return [], []\r\n \r\n # calculate degrees of each node (set as rows per node)\r\n a_nodes = zeros((n,n), int)\r\n for arc in range(m):\r\n i = G.A[arc,0] # tail of the arc\r\n j = G.A[arc,1] # head of the arc\r\n a_nodes[i-1,j-1] = 1\r\n a_nodes[j-1,i-1] = 1\r\n # get degree and add the node number\r\n degree = sum(a_nodes,0)\r\n degree = vstack((degree, array(range(n), int) + 1))\r\n \r\n # initialize coloring vector\r\n coloring = zeros(n, int)\r\n color_step = 1\r\n \r\n # if there are any nodes of degree 0 color them first\r\n while min(degree[0,:]) == 0:\r\n n_i = argmin(degree[0,:]) # get node with zero\r\n i = degree[1,n_i]\r\n # eliminate the node column from the list and matrix\r\n degree = delete(degree, s_[n_i], axis=1)\r\n a_nodes = delete(a_nodes, s_[n_i], axis=1)\r\n # color it\r\n coloring[i-1] = color_step\r\n \r\n # iterate till all nodes have a color\r\n while size(degree) > 0:\r\n n_i = argmax(degree[0,:]) # get node with largest degree\r\n i = degree[1,n_i]\r\n # eliminate the node column from the list and matrix\r\n degree = delete(degree, s_[n_i], axis=1)\r\n a_nodes = delete(a_nodes, s_[n_i], axis=1)\r\n \r\n # color it\r\n coloring[i-1] = color_step\r\n \r\n # color the rest of the possible nodes\r\n possible = 1 - array(a_nodes[i-1,:]) # transforms 0 in 1, and 1 in 0\r\n # iterate while there are possible nodes available\r\n while sum(possible) > 0:\r\n # get the node with largest degree among possible ones\r\n n_j = argmax(degree[0,:] * possible)\r\n j = degree[1,n_j]\r\n # eliminate the node column from the list and matrix\r\n degree = delete(degree, s_[n_j], axis=1)\r\n a_nodes = delete(a_nodes, s_[n_j], axis=1)\r\n possible = delete(possible, n_j)\r\n \r\n # color it\r\n coloring[j-1] = color_step\r\n # eliminate adjacent nodes of j from possible nodes\r\n possible = possible * (1 - a_nodes[j-1,:])\r\n \r\n # update color\r\n color_step += 1\r\n \r\n col_number = max(coloring) # approx chromatic number\r\n \r\n return coloring, col_number","def __get_color_table(self):\n #Color: Green Yellow Orange Red Distance:\n return [[0.70, 0.15, 0.1, 0.05], # 0\n [0.17, 0.6, 0.17, 0.06], # 1\n [0.06, 0.17, 0.6, 0.17], # 2\n [0.05, 0.12, 0.23, 0.6], # 3\n [0.05, 0.1, 0.15, 0.8]] # >= 4 ","def edge_colors(\n et: pd.DataFrame,\n nt: pd.DataFrame,\n color_by: Hashable,\n node_color_by: Hashable,\n):\n if color_by in (\"source_node_color\", \"target_node_color\"):\n edge_select_by = color_by.split(\"_\")[0]\n return encodings.data_color(\n et[edge_select_by].apply(nt[node_color_by].get),\n nt[node_color_by],\n )\n elif color_by:\n return encodings.data_color(et[color_by], et[color_by])\n return pd.Series([\"black\"] * len(et), name=\"color_by\")","def which_color(node):\n for i, com in enumerate(communities):\n if node in com:\n return colors[i]\n return nx_helpers.rgb_to_hex((0, 0, 0))","def setColorConf(colors,ngroups)->list:\n if colors == \"hcl\":\n try:\n from colorspace import sequential_hcl\n color_repo = sequential_hcl(h=[15,375],l=65,c=70)\n colors_list = color_repo.colors(ngroups + 1)\n except ImportError:\n print('hcl colorspace package has not being installed.')\n print('please try the following command:')\n print('pip install git+https://github.com/retostauffer/python-colorspace')\n else:\n colors = list(plt.get_cmap(colors).colors)\n colors_list = [to_hex(color) for color in colors]\n colors_list = colors_list[:ngroups]\n\n return colors_list","def brute_force_coloring(*args):\r\n # get arguments\r\n G = args[0]\r\n n = G.nodes()\r\n m = G.arcs()\r\n \r\n # check if it a valid Graph\r\n if not G.is_correct_type('u'):\r\n print \"ERROR: the graph is not in one of the valid formats for brute_force_coloring()\"\r\n return [], []\r\n \r\n coloring = ones(n, int) # initialize with just one color\r\n chrom_n = inf # initialize chromatic number\r\n min_coloring = [] # initialize minimum coloring\r\n \r\n # iterate till you get a coloring (really stupid way)\r\n terminal = array(range(n), int) + 1\r\n while sum(coloring != terminal) > 0:\r\n #print coloring\r\n coloring[n-1] += 1\r\n # correct if some achieve n\r\n for node in range(n-1):\r\n # if one get above n\r\n if coloring[n-1-node] > max(coloring[0:n-1-node]) + 1:\r\n coloring[n-1-node] = 1 # take one and...\r\n coloring[n-2-node] += 1 # ... add it to the previous one\r\n \r\n # if it is a coloring check it\r\n if G.is_coloring(coloring):\r\n col_number = max(coloring) # number of colors\r\n # if it is better, update\r\n if col_number < chrom_n:\r\n chrom_n = col_number\r\n min_coloring = coloring.copy()\r\n print \"current minimum: \", min_coloring, \"with %d colors\" %(chrom_n)\r\n \r\n return min_coloring, chrom_n","def colors(self):\r\n\t\treturn self._colors","def color_label_generator(clusters):\n colors = ['green', 'red', 'blue']\n point_colors = [\"\" for i in range(12)]\n for i, cluster in enumerate(clusters):\n for point_num in cluster:\n point_colors[point_num] = colors[i]\n return point_colors","def colors(self):\n return self[\"colors\"]","def colors(self):\n return self[\"colors\"]","def get_node_color(self, origin_node_id):\n origin_node_id %= 11\n if origin_node_id == 9:\n return 0.753, 0.753, 0.753, 1.\n if origin_node_id == 8:\n return 0.824, 0.412, 0.118, 1.\n if origin_node_id == 7:\n return 1.000, 0.000, 1.000, 1.\n if origin_node_id == 6:\n return 1.000, 1.000, 0.000, 1.\n if origin_node_id == 5:\n return 1.000, 0.627, 0.478, 1.\n if origin_node_id == 4:\n return 0.498, 1.000, 0.000, 1.\n if origin_node_id == 3:\n return 0.000, 1.000, 1.000, 1.\n if origin_node_id == 2:\n return 1.000, 0.922, 0.804, 1.\n if origin_node_id == 1:\n return 0.871, 0.722, 0.529, 1.\n if origin_node_id == 0:\n return 0.000, 0.749, 1.000, 1.\n if origin_node_id == 0:\n return 0.500, 0.549, 1.000, 1.\n\n return 0.8, 0.8, 0.8, 1.0","def get_color_list(cluster_count):\n color_list = []\n for i in xrange(cluster_count):\n color_list.append(random_color_gen())\n return color_list","def colors(k): \n ret = []\n for i in range(k):\n ret.append((random.uniform(0, 1), random.uniform(0, 1), random.uniform(0, 1)))\n return ret","def node_community_colors(graph, communities):\n colors = nx_helpers.generate_colors(len(communities))\n\n def which_color(node):\n \"\"\"finds which community node is in and returns\n its corresponding color\n \"\"\"\n for i, com in enumerate(communities):\n if node in com:\n return colors[i]\n return nx_helpers.rgb_to_hex((0, 0, 0))\n\n node_colors = [which_color(node) for node in graph.nodes()]\n return node_colors","def ordered_colors():\n\n return [(\"yellow\",0.263) ,(\"orange\", 0.047), (\"red\",0.0),(\"green\", 0.444), (\"purple\", 0.972)]","def coloring(self):\n labeling = [0]*self.n\n for ik in range(self.loc.index(-1)): # Loop over colors to current depth\n # Find all slots in coloring that are still empty\n freeIndices = [ilc for ilc,jlc in enumerate(labeling) if jlc == 0]\n # Get the current index for ik-th color\n cIdx = self.loc[ik]\n # Get the coloring that corresponds to the current index so that we can add it to the labeling\n clabeling = integer2coloring(cIdx,len(freeIndices),self.colors[ik])\n # Load up labeling with the current color in the corrent slots\n for iIdx,jIdx in enumerate(freeIndices):\n if clabeling[iIdx] !=0:\n labeling[jIdx] = ik + 1\n self.labeling = labeling\n return self.labeling","def getColors():\n colors = ['#d53e4f',\n '#fc8d59',\n '#fee08b',\n '#ffffbf',\n '#e6f598',\n '#99d594',\n '#3288bd',\n ]\n return colors","def nodes(self):\n\n return list(set(self._graph.keys() + [x for x in itertools.chain.from_iterable(self._graph.values())]))","def colors(self):\n return self._colors","def addcolors(poptree):\r\n rgbset = ([[0.4,0.4,0.4],\r\n [0.650980392,0.462745098,0.11372549],\r\n [0.4,0.650980392,0.117647059],\r\n [0.121568627,0.470588235,0.705882353],\r\n [0.905882353,0.160784314,0.541176471],\r\n [0.458823529,0.439215686,0.701960784],\r\n [0.850980392,0.37254902,0.007843137],\r\n [0.105882353,0.619607843,0.466666667],\r\n [0.901960784,0.670588235,0.007843137],\r\n [0.984313725,0.603921569,0.6]])\r\n for i in range(numpops):\r\n poptree[i].append(rgbset[i])\r\n for i in range(numpops,2*numpops-1):\r\n poptree[i].append([])\r\n while True:\r\n notdone = False\r\n for i in range(numpops,2*numpops-1):\r\n if poptree[i][5] == []:\r\n ld = poptree[i][2]\r\n rd = poptree[i][3]\r\n if poptree[ld][5] != [] and poptree[rd][5] != []:\r\n acolor = [0,0,0]\r\n acolor = meanrgb(poptree[ld][5],poptree[rd][5])\r\n poptree[i][5] = acolor\r\n else:\r\n notdone = True\r\n if notdone == False:\r\n break\r\n return poptree","def generate_cluster_colors(num, grouping):\n\n\tif (grouping == 'dataset' or grouping == 'target_region') and num > 2 and num <= 9:\n\t\tc = cl.scales[str(num)]['qual']['Set1']\n\t\treturn c\n\n\tif num>18:\n\t\t# c = ['hsl('+str(round(h*1.8 % 360))+',50%,50%)' for h in linspace(0, 360, num)]\n\t\tc = ['rgb'+str(colorsys.hls_to_rgb((h*1.8/360), 0.5, 0.5)) for h in linspace(0, 360, num)]\n\telse:\n\t\t# c = ['hsl('+str(round(h*1.3 % 360))+',50%,50%)' for h in linspace(0, 360, num)]\n\t\tc = ['rgb'+str(colorsys.hls_to_rgb((h*1.3 / 360), 0.5, 0.5)) for h in linspace(0, 360, num)]\n\n\tc=c+c\n\treturn c","def exploit_chain_coloring(graph, exploit_chain):\n node_color = []\n edge_color = []\n\n for node in graph:\n if node in exploit_chain:\n node_color.append('red')\n else:\n node_color.append('grey')\n\n for edge in graph.edges:\n control = False\n # checks if in exploit chain or not\n for i in range(len(exploit_chain)-1):\n if edge[0]==exploit_chain[i] and edge[1]==exploit_chain[i+1]:\n edge_color.append('red')\n control = True\n elif edge[1]==exploit_chain[i] and edge[0]==exploit_chain[i+1]:\n edge_color.append('red')\n control = True\n\n if control == False:\n edge_color.append('grey')\n\n return node_color, edge_color","def colors_for_labels():\n colors = [(i * np.array([2 ** 25 - 1, 2 ** 15 - 1, 2 ** 21 - 1]) % 255).astype(np.uint8) for i in range(len(CATEGORY))]\n #colors = np.array(range(len(COCO_INSTANCE_CATEGORY_NAMES))) * np.array([2 ** 25 - 1, 2 ** 15 - 1, 2 ** 21 - 1])\n #colors = (colors % 255).numpy().astype(\"uint8\")\n return colors","def colored_edges(genome):\n edges = []\n for chromo in genome:\n nodes = [0] + chromosome_to_cycle(chromo)\n nodes.append(nodes[1])\n for j in range(1, len(chromo) + 1):\n edges.append((nodes[2 * j], nodes[2 * j + 1]))\n\n return edges","def get_color(self, node: Node) -> str:\n\n idx = hash(node.get_kind_name()) % len(self.colors_)\n return self.colors_[idx]","def setColors(self):\n #productive\n profprint()\n self.color= [[0,0,0] for i in range(205)]\n self.color255= self.setColors255()\n for i in range(205):\n for j in range(3):\n self.color[i][j] = self.color255[i][j]/float(255)\n\n return self.color","def attack_surface_coloring(graph, attack_surface):\n color = []\n\n # takes a two-dimensional list\n # and produces a one-dimensional list\n # so we can check if each node is\n # in the attack surface\n flatten = lambda l: [item for sublist in l for item in sublist]\n flat_attack_surface = flatten(attack_surface)\n\n for node in graph:\n if node in flat_attack_surface:\n color.append('red')\n else:\n color.append('grey')\n return color","def get_segment_colour_map(self, features):\n\n hashList = {'1' : 'Grey',\n '2':'Red',\n '3':'Green',\n '4':'greenyellow',\n '5':'Pink',\n '6':'Orange',\n '7':'goldenrod',\n '8':'indianred',\n '9':'peachpuff',\n '10':'deepskyblue',\n '11':'firebrick',\n '12':'orchid',\n '13': 'moccasin',\n '14':'slateblue',\n '15':'turquoise',\n '16':'tomato',\n '17':'darkmagenta',\n '18':'olivedrab'}\n return hashList","def setColors(self):\r\n # productive\r\n profprint()\r\n self.color = [[0, 0, 0] for i in range(MAXCOL)]\r\n self.color255 = self.setColors255()\r\n for i in range(MAXCOL):\r\n for j in range(3):\r\n self.color[i][j] = self.color255[i][j] / float(255)\r\n\r\n return self.color","def get_state_colors():\n state_colors = []\n state_cases = []\n state_active = []\n for i in get_covid_stats_for_all_states():\n state_colors.append(i.color)\n state_cases.append(i.cases)\n state_active.append(i.activeCases)\n socketio.emit(\n \"colors\", {\"colors\": state_colors, \"cases\": state_cases, \"active\": state_active}\n )","def nodes(self):\n return set(self.values())","def color(self, sids=None, sat=1):\n if sids == None: # init/overwrite self.colors\n nids = self.nids\n # uint8, single unit nids are 1-based:\n self.colors = CLUSTERCLRSRGB[nids % len(CLUSTERCLRSRGB) - 1] * sat\n # overwrite unclustered/multiunit points with GREYRGB\n self.colors[nids < 1] = GREYRGB * sat\n else: # assume self.colors exists\n sidis = self.sids.searchsorted(sids)\n nids = self.nids[sidis]\n self.colors[sidis] = CLUSTERCLRSRGB[nids % len(CLUSTERCLRSRGB) - 1] * sat\n self.colors[sidis[nids < 1]] = GREYRGB * sat","def color(self, sids=None, sat=1):\n if sids is None: # init/overwrite self.colors\n nids = self.nids\n # uint8, single unit nids are 1-based:\n self.colors = CLUSTERCLRSRGB[nids % len(CLUSTERCLRSRGB) - 1] * sat\n # overwrite unclustered/multiunit points with GREYRGB\n self.colors[nids < 1] = GREYRGB * sat\n else: # assume self.colors exists\n sidis = self.sids.searchsorted(sids)\n nids = self.nids[sidis]\n self.colors[sidis] = CLUSTERCLRSRGB[nids % len(CLUSTERCLRSRGB) - 1] * sat\n self.colors[sidis[nids < 1]] = GREYRGB * sat","def get_coloring(self):\n colors = dict()\n colors[-1] = 0\n if not self.sorting_active: # Don't want any normal colors on the last frame\n new_list = [int(i) for i in self.lst]\n if self.sorted_lst == new_list: # The list is sorted, color it green\n colors[-1] = 1\n return colors\n # Last read\n last_read_key = ThreadManagment.sort_data_by_thread[self.thread.ident].last_read_key\n if last_read_key >= 0:\n colors[last_read_key] = 2\n # Last write\n last_write_key = ThreadManagment.sort_data_by_thread[self.thread.ident].last_write_key\n if last_write_key >= 0:\n colors[last_write_key] = 2\n # Last lhs comparison\n last_cmp_left_value = ThreadManagment.sort_data_by_thread[self.thread.ident].last_cmp_left\n for i in range(len(self.lst)):\n if int(self.lst.getitem_no_count(i)) == int(last_cmp_left_value):\n colors[i] = 3\n break\n # Last rhs comparison\n last_cmp_right_value = ThreadManagment.sort_data_by_thread[self.thread.ident].last_cmp_right\n for i in range(len(self.lst)):\n if int(self.lst.getitem_no_count(i)) == int(last_cmp_right_value):\n colors[i] = 3\n break\n return colors","def differentNodesForNode(ntupleSet,nodeList,verbose=False):\n nodesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\n for ntuple in ntupleSet:\n for nodeInTuple in ntuple:\n nodesPerNode[nodeInTuple].extend(ntuple)\n \n for a,v in nodesPerNode.iteritems():\n nodesPerNode[a] = set(v)\n \n return nodesPerNode","def get_node_colors_by_attr(\n G, attr, num_bins=None, cmap=\"viridis\", start=0, stop=1, na_color=\"none\"\n):\n if num_bins is None:\n num_bins = len(G)\n bin_labels = range(num_bins)\n attr_values = pd.Series([data[attr] for node, data in G.nodes(data=True)])\n cats = pd.qcut(x=attr_values, q=num_bins, labels=bin_labels)\n colors = get_colors(num_bins, cmap, start, stop)\n node_colors = [colors[int(cat)] if pd.notnull(cat) else na_color for cat in cats]\n return node_colors","def get_colors(lines):\n\n patt = re.compile('\\#\\w+')\n\n return [\n patt.search(line).group(0)\n for line in lines\n if patt.search(line)\n ]","def bipartite_sets(G):\n color=bipartite_color(G)\n X=set(n for n in color if color[n]==1)\n Y=set(n for n in color if color[n]==0)\n return (X,Y)","def getColor(self, visited):\r\n if visited == \"n\":\r\n button_color = [0.4, 0.6, 0, 1]\r\n else:\r\n button_color = [0.4, 0.7, 0.9, 1]\r\n return button_color","def colour_node(instance, reaction_colour='darkgrey', Xc_colour='orange', waste_colour='red', res_colour='limegreen', InPr_colour='lightblue'):\n G, mapping = instance.network()\n\n # relabel\n G = nx.relabel_nodes(G, mapping)\n\n node_dict_mapped = nodes_mapped(instance)\n\n waste, resources, intmed_products = instance.amenities()\n\n colour_map = []\n\n for nd in G:\n # print(\"nd\",nd)\n for nd_label, ammentity in node_dict_mapped.items():\n # print(\"nd_label\",nd_label)\n if nd_label == nd:\n # print(nd, nd_label)\n\n if ammentity == \"r\":\n colour_map.append(reaction_colour)\n\n elif ammentity == \"Xc\":\n colour_map.append(Xc_colour)\n\n elif ammentity == \"w\":\n colour_map.append(waste_colour)\n\n elif ammentity == \"Xr\":\n colour_map.append(res_colour)\n\n elif ammentity == \"InPr\":\n colour_map.append(InPr_colour)\n return colour_map","def get_neighbors(self, node):\r\n neighbors = set()\r\n for neighbor in ORTHOGONAL_POSITIONS[(node.pos[0], node.pos[1])]:\r\n if self.board[neighbor[0]][neighbor[1]].color == node.color:\r\n neighbors.add(neighbor)\r\n else:\r\n continue\r\n return neighbors","def _build_color_table() -> list[tuple[int, int, int, int, int]]:\n FG = FOREGROUND_COLOR\n BG = BACKGROUND_COLOR\n\n return [\n (0x00, 0x00, 0x00, FG.BLACK, BG.BLACK),\n (0x00, 0x00, 0xAA, FG.BLUE, BG.BLUE),\n (0x00, 0xAA, 0x00, FG.GREEN, BG.GREEN),\n (0x00, 0xAA, 0xAA, FG.CYAN, BG.CYAN),\n (0xAA, 0x00, 0x00, FG.RED, BG.RED),\n (0xAA, 0x00, 0xAA, FG.MAGENTA, BG.MAGENTA),\n (0xAA, 0xAA, 0x00, FG.YELLOW, BG.YELLOW),\n (0x88, 0x88, 0x88, FG.GRAY, BG.GRAY),\n (0x44, 0x44, 0xFF, FG.BLUE | FG.INTENSITY, BG.BLUE | BG.INTENSITY),\n (0x44, 0xFF, 0x44, FG.GREEN | FG.INTENSITY, BG.GREEN | BG.INTENSITY),\n (0x44, 0xFF, 0xFF, FG.CYAN | FG.INTENSITY, BG.CYAN | BG.INTENSITY),\n (0xFF, 0x44, 0x44, FG.RED | FG.INTENSITY, BG.RED | BG.INTENSITY),\n (0xFF, 0x44, 0xFF, FG.MAGENTA | FG.INTENSITY, BG.MAGENTA | BG.INTENSITY),\n (0xFF, 0xFF, 0x44, FG.YELLOW | FG.INTENSITY, BG.YELLOW | BG.INTENSITY),\n (0x44, 0x44, 0x44, FG.BLACK | FG.INTENSITY, BG.BLACK | BG.INTENSITY),\n (0xFF, 0xFF, 0xFF, FG.GRAY | FG.INTENSITY, BG.GRAY | BG.INTENSITY),\n ]","def calc_coloring(graph_rdd):\n graph_rdd = graph_rdd \\\n .map(swap) \\\n .union(graph_rdd)\n nodes = graph_rdd.keys().distinct()\n\n color = nodes.map(lambda x: (x, 1))\n color_num = 1\n\n while True:\n graph_join_color = graph_rdd.join(color)\n neighbour = graph_join_color \\\n .map(lambda (x, (a, bx)): (a, (x, bx))) \\\n .groupByKey() \\\n .map(lambda (x, y): (x, [n[1] for n in y]))\n color = neighbour.map(lambda (x, y): (x, hash(str(sorted(y)))))\n color_new = color \\\n .map(swap) \\\n .reduceByKey(add, numPartitions=40) \\\n .map(lambda x: 1) \\\n .reduce(add)\n if color_num != color_new:\n break\n color_num = color_new\n return color","def _greedy_color(self, source):\n for target in self.graph.iteradjacent(source):\n if self.color[target] is not None:\n self._color_list[self.color[target]] = True\n for c in xrange(self.graph.v()): # check colors\n if not self._color_list[c]:\n self.color[source] = c\n break\n for target in self.graph.iteradjacent(source):\n if self.color[target] is not None:\n self._color_list[self.color[target]] = False\n return c","def extract_colors(self, palette, colors):\n return [palette[i:i + 3] for i in range(0, colors * 3, 3)]","def hashColors(colors):\n return sum(HASH_COLORS[col] for col in set(colors))","def _get_colors(num_colors):\n cmap = plt.get_cmap()\n return [cmap(1. * i / num_colors) for i in range(num_colors)]","def connected_components(nodes):\n\n # List of connected components found. The order is random.\n result = []\n\n # Make a copy of the set, so we can modify it.\n nodes = set(nodes)\n\n # Iterate while we still have nodes to process.\n while nodes:\n\n # Get a random node and remove it from the global set.\n n = nodes.pop()\n\n # This set will contain the next group of nodes\n # connected to each other.\n group = {n}\n\n # Build a queue with this node in it.\n queue = [n]\n\n # Iterate the queue.\n # When it's empty, we finished visiting a group of connected nodes.\n while queue:\n\n # Consume the next item from the queue.\n n = queue.pop(0)\n\n # Fetch the neighbors.\n neighbors = n.links\n\n # Remove the neighbors we already visited.\n neighbors.difference_update(group)\n\n # Remove the remaining nodes from the global set.\n nodes.difference_update(neighbors)\n\n # Add them to the group of connected nodes.\n group.update(neighbors)\n\n # Add them to the queue, so we visit them in the next iterations.\n queue.extend(neighbors)\n\n # Add the group to the list of groups.\n result.append(group)\n\n # Return the list of groups.\n return result","def bipartite_color(G):\n color={}\n for n in G: # handle disconnected graphs\n if n in color: continue\n queue=[n] \n color[n]=1 # nodes seen with color (1 or 0)\n while queue:\n v=queue.pop()\n c=1-color[v] # opposite color of node v\n for w in G[v]: \n if w in color: \n if color[w]==color[v]:\n raise networkx.NetworkXError(\"Graph is not bipartite.\")\n else:\n color[w]=c\n queue.append(w)\n return color","def branches(self):\n unique_nodes, unique_counts = np.unique(self.edges, return_counts=True)\n return unique_nodes[ unique_counts >= 3 ]","def node_ids(self):\n return [self.node_id]","def _generate_colors(\n self, x: NDArrayFloat\n ) -> Sequence[RGBHexColor | None]:\n x = np.asarray(x)\n idx = np.round((x * 255) + ROUNDING_JITTER).astype(int)\n arr = np.column_stack(\n [self._r_lookup[idx], self._g_lookup[idx], self._b_lookup[idx]]\n )\n return [rgb_to_hex(c) for c in arr]","def graph_nodes(dependencies):\n\n return set.union(set(dependencies), *list(dependencies.values()))","def colors(self):\n unique, counts = np.unique(self.arr, return_counts=True)\n return {k: v for (k, v) in zip(unique, counts)}","def get_shaders(self, nodes):\n shaders = []\n # Fill the assigned shader list\n for node in nodes:\n shader = mc.listConnections(\"{0}.instObjGroups[0]\".format(node))\n if shader is not None:\n shaders.append(shader)\n else:\n shaders.append([])\n return shaders","def __repr__(self):\r\n return \"Colored Set of {0}\".format(self.count)","def get_player_colors() -> List[Tuple[float, float, float]]:\n return PLAYER_COLORS","def iter_colors(self):\n return itervalues(self)","def construct_groups_string(nodes):\n groups = get_groups(nodes)\n if len(groups) <= 1:\n return \"\"\n else:\n result = []\n for color in groups:\n # +1 because .tsp nodes are indexed with 1\n group = [node.nid + 1 for node in nodes if node.color == color]\n result.append(group)\n return str(result)","def components(self):\n comps = 0\n unexplored = self.nodes()\n while unexplored:\n comps += 1\n queue = {unexplored.pop()}\n while queue:\n new = queue.pop()\n unexplored.remove(new)\n for adjacent in new.parents() | new.children():\n if adjacent in unexplored:\n queue.add(adjacent)\n return comps","def colors(self) -> dict:\n raise NotImplementedError","def color():\n\tcolors = ['b', 'r', 'g', 'k']\n\twhile True:\n\t\tfor c in colors:\n\t\t\tyield c","def testSetColorDecisionList(self):\n self.node.color_decisions = self.color_decisions\n\n # We need to convert self.color_decisions to a set then to a list\n # so the order matches\n self.assertEqual(\n list(set(self.color_decisions)),\n self.node.color_decisions\n )","def preset_colors( self, labels ):\n size_labels = len( labels )\n self.color_override = self.metadata.get('color_override', {})\n try:\n if self.color_override == {}:\n raise Exception('going to the default')\n colours = self.color_override\n size_colors = len ( colours )\n retval = []\n for label in labels:\n mycolour = colours[label]\n retval.append(mycolour)\n except:\n hex_colors = self.hex_colors\n size_colors = len( hex_colors )\n retval = [ hex_colors[ i % size_colors ] for i in range( size_labels ) ]\n\n retval.reverse()\n return retval","def _random_color() -> List[float]:\n return [np.random.uniform(), np.random.uniform(), np.random.uniform()]","def make_palette(self, color_count):\n palette = []\n palette_index = 0\n leaf_count = len(self.get_leaves())\n # reduce nodes\n # up to 8 leaves can be reduced here and the palette will have\n # only 248 colors (in worst case) instead of expected 256 colors\n for level in range(OctreeQuantizer.MAX_DEPTH - 1, -1, -1):\n if self.levels[level]:\n for node in self.levels[level]:\n leaf_count -= node.remove_leaves()\n if leaf_count <= color_count:\n break\n if leaf_count <= color_count:\n break\n self.levels[level] = []\n # build palette\n for node in self.get_leaves():\n if palette_index >= color_count:\n break\n if node.is_leaf():\n palette.append(node.get_color())\n node.palette_index = palette_index\n palette_index += 1\n return palette","def get_nodes(self):\n return_set = set()\n for value in self._name:\n return_set.add(value)\n return return_set","def nodes(self):\n return self._node_reg","def _tupleListToStrings(self):\n graphColorStrings = []\n previousSelection = self.colorlist.GetSelection()\n print(repr(self.graphColors))\n if isinstance(self.graphColors, str):\n self.graphColors = eval(self.graphColors)\n for col in self.graphColors:\n col1 = '%.2f' % float(col[0])\n col2 = '%.2f' % float(col[1])\n col3 = '%.2f' % float(col[2])\n graphColorStrings.append(', '.join([col1, col2, col3]))\n self.colorlist.SetItems(graphColorStrings)\n if 0 <= previousSelection < len(graphColorStrings):\n self.colorlist.SetSelection(previousSelection)\n return graphColorStrings","def get_nodes(self):\n try:\n return list(self._adjacency_list.keys())\n except Exception as error:\n print(f'An error occurred: {error}')","def GetColors(self, *args):\n return _XCAFDoc.XCAFDoc_ColorTool_GetColors(self, *args)","def nodes(self): \n return [n for n in self.iternodes()]","def getColor(k) :\n colors = [\"#862B59\",\"#A10000\",\"#0A6308\",\"#123677\",\"#ff8100\",\"#F28686\",\"#6adf4f\",\"#58ccdd\",\"#3a3536\",\"#00ab7c\"]\n return colors[k]","def _get_goal_colours() -> List[Tuple[int, int, int]]:\n colour_lst = COLOUR_LIST[:]\n random.shuffle(colour_lst)\n return colour_lst","def get_colors(n, cmap=\"viridis\", start=0.0, stop=1.0, alpha=1.0, return_hex=False):\n colors = [cm.get_cmap(cmap)(x) for x in np.linspace(start, stop, n)]\n colors = [(r, g, b, alpha) for r, g, b, _ in colors]\n if return_hex:\n colors = _rgb_color_list_to_hex(colors)\n return colors","def get_color(node, color_map):\r\n if node in color_map:\r\n return color_map[node]\r\n return \"black\"","def hex_colors(cls):\n return ['#{:02x}{:02x}{:02x}'.format(*cls._COLORS[s])\n for s in cls._STATES]","def get_color(self):\n colors = []\n color_specs = [self._red_spec, self._green_spec,\n self._blue_spec, self._white_spec]\n for spec in color_specs:\n driver = DRIVERS[spec.addr]\n colors.append(driver.get_duty_cycle(spec.pin))\n \n return colors","def set_node_color_bypass(node_names, new_colors, network=None, base_url=DEFAULT_BASE_URL):\n if isinstance(new_colors, str): new_colors = [\n new_colors] # TODO: It looks like this should be happening everywhere?\n for color in new_colors:\n if is_not_hex_color(color):\n return None # TODO: Shouldn't this be an exception?\n\n res = set_node_property_bypass(node_names, new_colors, 'NODE_FILL_COLOR', network=network, base_url=base_url)\n return res","def get_colors(self):\n df = self.reindexed_dataframe()\n\n colormap = cm.get_cmap(self.cmap)\n norm = Normalize(vmin=df.min(), vmax=df.max())\n\n sm = cm.ScalarMappable(norm=norm, cmap=colormap)\n\n return ['rgba' + str(sm.to_rgba(m, bytes = True, alpha = 0.8)) if not np.isnan(m) else 'rgba(128,128,128,1)' for m in df.values]","def get_node_names(self):\n return set({node.get_name() for node in self.get_nodeset()}) # return the set of names","def all_ids(self) -> Set[int]:\n return {node_id for _, (node_id, _) in self.nodes.items()}","def get_colors(n):\n color = cm.rainbow(np.linspace(0, 1, n))\n return color","def node_ids(self):\n # From: https://stackoverflow.com/questions/17415086/combine-consecutive-numbers-into-range-tuples\n groups = groupby(self.nodes.keys(), key=lambda item, c=count():item-next(c))\n temp = [list(g) for k, g in groups]\n return \"+\".join(\"{}-{}\".format(x[0], x[-1]) for x in temp)","def get_graph_color ( self, object ):\n return self.graph_color_","def clusterGen(k, colors):\n clusters = []\n # generate the clusters randomly\n # for i in range(k):\n # r = random.randint(0, 255)\n # g = random.randint(0, 255)\n # b = random.randint(0, 255)\n # clusters.append((r, g, b))\n\n # generate the clusters that exist in colors\n l = len(colors)\n for i in range(k):\n r = random.randint(0, l)\n cluster = colors[r][1]\n clusters.append(cluster)\n\n return clusters","def terminals(self):\n unique_nodes, unique_counts = np.unique(self.edges, return_counts=True)\n return unique_nodes[ unique_counts == 1 ]","def assign_entity_colors(pairs):\n groups = []\n for a, b in pairs:\n for grp in groups:\n if a in grp or b in grp:\n grp.add(a)\n grp.add(b)\n else:\n groups.append(set([a, b]))\n\n colors = {}\n for grp in groups:\n color = random.choice(config.COLORS)\n for id in grp:\n colors[id] = color\n return colors","def get_colors_with_tsne_3dof(data: ndarray, num_iterations: int = 300) -> ndarray:\n tsne = TSNE(n_components=3, perplexity=40, n_iter=num_iterations, random_state=0)\n tsne_results = tsne.fit_transform(data)\n tsne_min = np.min(tsne_results, axis=0, keepdims=True)\n tsne_max = np.max(tsne_results, axis=0, keepdims=True)\n colors = (tsne_results - tsne_min) / (tsne_max - tsne_min)\n return colors","def neighbors(node, test_set):\r\n result = set()\r\n for neighbor in node.neighbors:\r\n if neighbor in test_set:\r\n result.add(neighbor)\r\n return result","def nodes(self):\n for node_set in self.itervalues():\n for node in node_set:\n yield node","def color_validity(data: np.ndarray, valids: np.ndarray) -> list:\n\n def color_validity(v: int) -> str:\n return Fore.GREEN if v == 1 else Fore.RED\n\n return [color_validity(v) + str(ele) + Style.RESET_ALL for (ele, v) in zip(data, valids)]"],"string":"[\n \"def get_groups(nodes):\\n return list(set([node.color for node in nodes]))\",\n \"def get_colors(self):\\n colors = [\\\"#244486\\\", \\\"#A6A6A6\\\", \\\"#B12122\\\"]\\n cmap = LinearSegmentedColormap.from_list(\\\"mycmap\\\", colors)\\n\\n color_palette=[cmap(i) for i in np.linspace(0, 1, len(set(self.nodes_list)))]\\n return dict(zip(list(set(self.nodes_list)), color_palette))\",\n \"def set_colors(graph):\\n colors = []\\n for n in graph.nodes():\\n node = graph.node[n]\\n if node['adopter'] == 1:\\n colors.append('b')\\n else:\\n colors.append('r')\\n \\n return colors\",\n \"def node_colors(self, nodes):\\n zmin, zmax = nodes[:, 2].min(), nodes[:, 2].max()\\n start_color = np.array(self.background) + 5\\n end_color = np.array(self.nodeColor)\\n z = (nodes[:, 2] - zmin) / (zmax - zmin)\\n # indexing [:, None] is used to explicitly state second axis\\n c = (1 - z)[:, None] @ start_color[:, None].T + z[:, None] @ end_color[:, None].T\\n self.wireframe_col = c\\n # return c\",\n \"def color_chosen_nodes(network, chosen_node, color):\\n\\n # Color the node selected randomly by RWR\\n network.nodes[chosen_node]['color'] = color\\n # Create a list with color for each node\\n color_nodes = [network.nodes[node]['color'] for node in network.nodes]\\n return color_nodes\",\n \"def colors(self):\\n\\t\\treturn [(0, 30, 255),(0, 30, 120)]\",\n \"def getColors():\\n return ['#8c99fc', '#cacefd', '#fff1d7', '#feda98', '#fda85a', '#fc6647']\",\n \"def get_colors():\\n colors = {}\\n for h in wn.synset('chromatic_color.n.01').hyponyms():\\n colors[h.lemmas()[0].name()] = [l.name() for l in h.lemmas()]\\n colors[h.lemmas()[0].name()].extend(all_hyponyms(h)) \\n for h in wn.synset('achromatic_color.n.01').hyponyms():\\n colors[h.lemmas()[0].name()] = [l.name() for l in h.lemmas()]\\n colors[h.lemmas()[0].name()].extend(all_hyponyms(h)) \\n return colors\",\n \"def greedy_coloring(*args):\\r\\n # get arguments\\r\\n G = args[0]\\r\\n n = G.nodes()\\r\\n m = G.arcs()\\r\\n \\r\\n # check if it a valid Graph\\r\\n if not G.is_correct_type('u'):\\r\\n print \\\"ERROR: the graph is not in one of the valid formats for greedy_coloring()\\\"\\r\\n return [], []\\r\\n \\r\\n # calculate degrees of each node (set as rows per node)\\r\\n a_nodes = zeros((n,n), int)\\r\\n for arc in range(m):\\r\\n i = G.A[arc,0] # tail of the arc\\r\\n j = G.A[arc,1] # head of the arc\\r\\n a_nodes[i-1,j-1] = 1\\r\\n a_nodes[j-1,i-1] = 1\\r\\n # get degree and add the node number\\r\\n degree = sum(a_nodes,0)\\r\\n degree = vstack((degree, array(range(n), int) + 1))\\r\\n \\r\\n # initialize coloring vector\\r\\n coloring = zeros(n, int)\\r\\n color_step = 1\\r\\n \\r\\n # if there are any nodes of degree 0 color them first\\r\\n while min(degree[0,:]) == 0:\\r\\n n_i = argmin(degree[0,:]) # get node with zero\\r\\n i = degree[1,n_i]\\r\\n # eliminate the node column from the list and matrix\\r\\n degree = delete(degree, s_[n_i], axis=1)\\r\\n a_nodes = delete(a_nodes, s_[n_i], axis=1)\\r\\n # color it\\r\\n coloring[i-1] = color_step\\r\\n \\r\\n # iterate till all nodes have a color\\r\\n while size(degree) > 0:\\r\\n n_i = argmax(degree[0,:]) # get node with largest degree\\r\\n i = degree[1,n_i]\\r\\n # eliminate the node column from the list and matrix\\r\\n degree = delete(degree, s_[n_i], axis=1)\\r\\n a_nodes = delete(a_nodes, s_[n_i], axis=1)\\r\\n \\r\\n # color it\\r\\n coloring[i-1] = color_step\\r\\n \\r\\n # color the rest of the possible nodes\\r\\n possible = 1 - array(a_nodes[i-1,:]) # transforms 0 in 1, and 1 in 0\\r\\n # iterate while there are possible nodes available\\r\\n while sum(possible) > 0:\\r\\n # get the node with largest degree among possible ones\\r\\n n_j = argmax(degree[0,:] * possible)\\r\\n j = degree[1,n_j]\\r\\n # eliminate the node column from the list and matrix\\r\\n degree = delete(degree, s_[n_j], axis=1)\\r\\n a_nodes = delete(a_nodes, s_[n_j], axis=1)\\r\\n possible = delete(possible, n_j)\\r\\n \\r\\n # color it\\r\\n coloring[j-1] = color_step\\r\\n # eliminate adjacent nodes of j from possible nodes\\r\\n possible = possible * (1 - a_nodes[j-1,:])\\r\\n \\r\\n # update color\\r\\n color_step += 1\\r\\n \\r\\n col_number = max(coloring) # approx chromatic number\\r\\n \\r\\n return coloring, col_number\",\n \"def __get_color_table(self):\\n #Color: Green Yellow Orange Red Distance:\\n return [[0.70, 0.15, 0.1, 0.05], # 0\\n [0.17, 0.6, 0.17, 0.06], # 1\\n [0.06, 0.17, 0.6, 0.17], # 2\\n [0.05, 0.12, 0.23, 0.6], # 3\\n [0.05, 0.1, 0.15, 0.8]] # >= 4 \",\n \"def edge_colors(\\n et: pd.DataFrame,\\n nt: pd.DataFrame,\\n color_by: Hashable,\\n node_color_by: Hashable,\\n):\\n if color_by in (\\\"source_node_color\\\", \\\"target_node_color\\\"):\\n edge_select_by = color_by.split(\\\"_\\\")[0]\\n return encodings.data_color(\\n et[edge_select_by].apply(nt[node_color_by].get),\\n nt[node_color_by],\\n )\\n elif color_by:\\n return encodings.data_color(et[color_by], et[color_by])\\n return pd.Series([\\\"black\\\"] * len(et), name=\\\"color_by\\\")\",\n \"def which_color(node):\\n for i, com in enumerate(communities):\\n if node in com:\\n return colors[i]\\n return nx_helpers.rgb_to_hex((0, 0, 0))\",\n \"def setColorConf(colors,ngroups)->list:\\n if colors == \\\"hcl\\\":\\n try:\\n from colorspace import sequential_hcl\\n color_repo = sequential_hcl(h=[15,375],l=65,c=70)\\n colors_list = color_repo.colors(ngroups + 1)\\n except ImportError:\\n print('hcl colorspace package has not being installed.')\\n print('please try the following command:')\\n print('pip install git+https://github.com/retostauffer/python-colorspace')\\n else:\\n colors = list(plt.get_cmap(colors).colors)\\n colors_list = [to_hex(color) for color in colors]\\n colors_list = colors_list[:ngroups]\\n\\n return colors_list\",\n \"def brute_force_coloring(*args):\\r\\n # get arguments\\r\\n G = args[0]\\r\\n n = G.nodes()\\r\\n m = G.arcs()\\r\\n \\r\\n # check if it a valid Graph\\r\\n if not G.is_correct_type('u'):\\r\\n print \\\"ERROR: the graph is not in one of the valid formats for brute_force_coloring()\\\"\\r\\n return [], []\\r\\n \\r\\n coloring = ones(n, int) # initialize with just one color\\r\\n chrom_n = inf # initialize chromatic number\\r\\n min_coloring = [] # initialize minimum coloring\\r\\n \\r\\n # iterate till you get a coloring (really stupid way)\\r\\n terminal = array(range(n), int) + 1\\r\\n while sum(coloring != terminal) > 0:\\r\\n #print coloring\\r\\n coloring[n-1] += 1\\r\\n # correct if some achieve n\\r\\n for node in range(n-1):\\r\\n # if one get above n\\r\\n if coloring[n-1-node] > max(coloring[0:n-1-node]) + 1:\\r\\n coloring[n-1-node] = 1 # take one and...\\r\\n coloring[n-2-node] += 1 # ... add it to the previous one\\r\\n \\r\\n # if it is a coloring check it\\r\\n if G.is_coloring(coloring):\\r\\n col_number = max(coloring) # number of colors\\r\\n # if it is better, update\\r\\n if col_number < chrom_n:\\r\\n chrom_n = col_number\\r\\n min_coloring = coloring.copy()\\r\\n print \\\"current minimum: \\\", min_coloring, \\\"with %d colors\\\" %(chrom_n)\\r\\n \\r\\n return min_coloring, chrom_n\",\n \"def colors(self):\\r\\n\\t\\treturn self._colors\",\n \"def color_label_generator(clusters):\\n colors = ['green', 'red', 'blue']\\n point_colors = [\\\"\\\" for i in range(12)]\\n for i, cluster in enumerate(clusters):\\n for point_num in cluster:\\n point_colors[point_num] = colors[i]\\n return point_colors\",\n \"def colors(self):\\n return self[\\\"colors\\\"]\",\n \"def colors(self):\\n return self[\\\"colors\\\"]\",\n \"def get_node_color(self, origin_node_id):\\n origin_node_id %= 11\\n if origin_node_id == 9:\\n return 0.753, 0.753, 0.753, 1.\\n if origin_node_id == 8:\\n return 0.824, 0.412, 0.118, 1.\\n if origin_node_id == 7:\\n return 1.000, 0.000, 1.000, 1.\\n if origin_node_id == 6:\\n return 1.000, 1.000, 0.000, 1.\\n if origin_node_id == 5:\\n return 1.000, 0.627, 0.478, 1.\\n if origin_node_id == 4:\\n return 0.498, 1.000, 0.000, 1.\\n if origin_node_id == 3:\\n return 0.000, 1.000, 1.000, 1.\\n if origin_node_id == 2:\\n return 1.000, 0.922, 0.804, 1.\\n if origin_node_id == 1:\\n return 0.871, 0.722, 0.529, 1.\\n if origin_node_id == 0:\\n return 0.000, 0.749, 1.000, 1.\\n if origin_node_id == 0:\\n return 0.500, 0.549, 1.000, 1.\\n\\n return 0.8, 0.8, 0.8, 1.0\",\n \"def get_color_list(cluster_count):\\n color_list = []\\n for i in xrange(cluster_count):\\n color_list.append(random_color_gen())\\n return color_list\",\n \"def colors(k): \\n ret = []\\n for i in range(k):\\n ret.append((random.uniform(0, 1), random.uniform(0, 1), random.uniform(0, 1)))\\n return ret\",\n \"def node_community_colors(graph, communities):\\n colors = nx_helpers.generate_colors(len(communities))\\n\\n def which_color(node):\\n \\\"\\\"\\\"finds which community node is in and returns\\n its corresponding color\\n \\\"\\\"\\\"\\n for i, com in enumerate(communities):\\n if node in com:\\n return colors[i]\\n return nx_helpers.rgb_to_hex((0, 0, 0))\\n\\n node_colors = [which_color(node) for node in graph.nodes()]\\n return node_colors\",\n \"def ordered_colors():\\n\\n return [(\\\"yellow\\\",0.263) ,(\\\"orange\\\", 0.047), (\\\"red\\\",0.0),(\\\"green\\\", 0.444), (\\\"purple\\\", 0.972)]\",\n \"def coloring(self):\\n labeling = [0]*self.n\\n for ik in range(self.loc.index(-1)): # Loop over colors to current depth\\n # Find all slots in coloring that are still empty\\n freeIndices = [ilc for ilc,jlc in enumerate(labeling) if jlc == 0]\\n # Get the current index for ik-th color\\n cIdx = self.loc[ik]\\n # Get the coloring that corresponds to the current index so that we can add it to the labeling\\n clabeling = integer2coloring(cIdx,len(freeIndices),self.colors[ik])\\n # Load up labeling with the current color in the corrent slots\\n for iIdx,jIdx in enumerate(freeIndices):\\n if clabeling[iIdx] !=0:\\n labeling[jIdx] = ik + 1\\n self.labeling = labeling\\n return self.labeling\",\n \"def getColors():\\n colors = ['#d53e4f',\\n '#fc8d59',\\n '#fee08b',\\n '#ffffbf',\\n '#e6f598',\\n '#99d594',\\n '#3288bd',\\n ]\\n return colors\",\n \"def nodes(self):\\n\\n return list(set(self._graph.keys() + [x for x in itertools.chain.from_iterable(self._graph.values())]))\",\n \"def colors(self):\\n return self._colors\",\n \"def addcolors(poptree):\\r\\n rgbset = ([[0.4,0.4,0.4],\\r\\n [0.650980392,0.462745098,0.11372549],\\r\\n [0.4,0.650980392,0.117647059],\\r\\n [0.121568627,0.470588235,0.705882353],\\r\\n [0.905882353,0.160784314,0.541176471],\\r\\n [0.458823529,0.439215686,0.701960784],\\r\\n [0.850980392,0.37254902,0.007843137],\\r\\n [0.105882353,0.619607843,0.466666667],\\r\\n [0.901960784,0.670588235,0.007843137],\\r\\n [0.984313725,0.603921569,0.6]])\\r\\n for i in range(numpops):\\r\\n poptree[i].append(rgbset[i])\\r\\n for i in range(numpops,2*numpops-1):\\r\\n poptree[i].append([])\\r\\n while True:\\r\\n notdone = False\\r\\n for i in range(numpops,2*numpops-1):\\r\\n if poptree[i][5] == []:\\r\\n ld = poptree[i][2]\\r\\n rd = poptree[i][3]\\r\\n if poptree[ld][5] != [] and poptree[rd][5] != []:\\r\\n acolor = [0,0,0]\\r\\n acolor = meanrgb(poptree[ld][5],poptree[rd][5])\\r\\n poptree[i][5] = acolor\\r\\n else:\\r\\n notdone = True\\r\\n if notdone == False:\\r\\n break\\r\\n return poptree\",\n \"def generate_cluster_colors(num, grouping):\\n\\n\\tif (grouping == 'dataset' or grouping == 'target_region') and num > 2 and num <= 9:\\n\\t\\tc = cl.scales[str(num)]['qual']['Set1']\\n\\t\\treturn c\\n\\n\\tif num>18:\\n\\t\\t# c = ['hsl('+str(round(h*1.8 % 360))+',50%,50%)' for h in linspace(0, 360, num)]\\n\\t\\tc = ['rgb'+str(colorsys.hls_to_rgb((h*1.8/360), 0.5, 0.5)) for h in linspace(0, 360, num)]\\n\\telse:\\n\\t\\t# c = ['hsl('+str(round(h*1.3 % 360))+',50%,50%)' for h in linspace(0, 360, num)]\\n\\t\\tc = ['rgb'+str(colorsys.hls_to_rgb((h*1.3 / 360), 0.5, 0.5)) for h in linspace(0, 360, num)]\\n\\n\\tc=c+c\\n\\treturn c\",\n \"def exploit_chain_coloring(graph, exploit_chain):\\n node_color = []\\n edge_color = []\\n\\n for node in graph:\\n if node in exploit_chain:\\n node_color.append('red')\\n else:\\n node_color.append('grey')\\n\\n for edge in graph.edges:\\n control = False\\n # checks if in exploit chain or not\\n for i in range(len(exploit_chain)-1):\\n if edge[0]==exploit_chain[i] and edge[1]==exploit_chain[i+1]:\\n edge_color.append('red')\\n control = True\\n elif edge[1]==exploit_chain[i] and edge[0]==exploit_chain[i+1]:\\n edge_color.append('red')\\n control = True\\n\\n if control == False:\\n edge_color.append('grey')\\n\\n return node_color, edge_color\",\n \"def colors_for_labels():\\n colors = [(i * np.array([2 ** 25 - 1, 2 ** 15 - 1, 2 ** 21 - 1]) % 255).astype(np.uint8) for i in range(len(CATEGORY))]\\n #colors = np.array(range(len(COCO_INSTANCE_CATEGORY_NAMES))) * np.array([2 ** 25 - 1, 2 ** 15 - 1, 2 ** 21 - 1])\\n #colors = (colors % 255).numpy().astype(\\\"uint8\\\")\\n return colors\",\n \"def colored_edges(genome):\\n edges = []\\n for chromo in genome:\\n nodes = [0] + chromosome_to_cycle(chromo)\\n nodes.append(nodes[1])\\n for j in range(1, len(chromo) + 1):\\n edges.append((nodes[2 * j], nodes[2 * j + 1]))\\n\\n return edges\",\n \"def get_color(self, node: Node) -> str:\\n\\n idx = hash(node.get_kind_name()) % len(self.colors_)\\n return self.colors_[idx]\",\n \"def setColors(self):\\n #productive\\n profprint()\\n self.color= [[0,0,0] for i in range(205)]\\n self.color255= self.setColors255()\\n for i in range(205):\\n for j in range(3):\\n self.color[i][j] = self.color255[i][j]/float(255)\\n\\n return self.color\",\n \"def attack_surface_coloring(graph, attack_surface):\\n color = []\\n\\n # takes a two-dimensional list\\n # and produces a one-dimensional list\\n # so we can check if each node is\\n # in the attack surface\\n flatten = lambda l: [item for sublist in l for item in sublist]\\n flat_attack_surface = flatten(attack_surface)\\n\\n for node in graph:\\n if node in flat_attack_surface:\\n color.append('red')\\n else:\\n color.append('grey')\\n return color\",\n \"def get_segment_colour_map(self, features):\\n\\n hashList = {'1' : 'Grey',\\n '2':'Red',\\n '3':'Green',\\n '4':'greenyellow',\\n '5':'Pink',\\n '6':'Orange',\\n '7':'goldenrod',\\n '8':'indianred',\\n '9':'peachpuff',\\n '10':'deepskyblue',\\n '11':'firebrick',\\n '12':'orchid',\\n '13': 'moccasin',\\n '14':'slateblue',\\n '15':'turquoise',\\n '16':'tomato',\\n '17':'darkmagenta',\\n '18':'olivedrab'}\\n return hashList\",\n \"def setColors(self):\\r\\n # productive\\r\\n profprint()\\r\\n self.color = [[0, 0, 0] for i in range(MAXCOL)]\\r\\n self.color255 = self.setColors255()\\r\\n for i in range(MAXCOL):\\r\\n for j in range(3):\\r\\n self.color[i][j] = self.color255[i][j] / float(255)\\r\\n\\r\\n return self.color\",\n \"def get_state_colors():\\n state_colors = []\\n state_cases = []\\n state_active = []\\n for i in get_covid_stats_for_all_states():\\n state_colors.append(i.color)\\n state_cases.append(i.cases)\\n state_active.append(i.activeCases)\\n socketio.emit(\\n \\\"colors\\\", {\\\"colors\\\": state_colors, \\\"cases\\\": state_cases, \\\"active\\\": state_active}\\n )\",\n \"def nodes(self):\\n return set(self.values())\",\n \"def color(self, sids=None, sat=1):\\n if sids == None: # init/overwrite self.colors\\n nids = self.nids\\n # uint8, single unit nids are 1-based:\\n self.colors = CLUSTERCLRSRGB[nids % len(CLUSTERCLRSRGB) - 1] * sat\\n # overwrite unclustered/multiunit points with GREYRGB\\n self.colors[nids < 1] = GREYRGB * sat\\n else: # assume self.colors exists\\n sidis = self.sids.searchsorted(sids)\\n nids = self.nids[sidis]\\n self.colors[sidis] = CLUSTERCLRSRGB[nids % len(CLUSTERCLRSRGB) - 1] * sat\\n self.colors[sidis[nids < 1]] = GREYRGB * sat\",\n \"def color(self, sids=None, sat=1):\\n if sids is None: # init/overwrite self.colors\\n nids = self.nids\\n # uint8, single unit nids are 1-based:\\n self.colors = CLUSTERCLRSRGB[nids % len(CLUSTERCLRSRGB) - 1] * sat\\n # overwrite unclustered/multiunit points with GREYRGB\\n self.colors[nids < 1] = GREYRGB * sat\\n else: # assume self.colors exists\\n sidis = self.sids.searchsorted(sids)\\n nids = self.nids[sidis]\\n self.colors[sidis] = CLUSTERCLRSRGB[nids % len(CLUSTERCLRSRGB) - 1] * sat\\n self.colors[sidis[nids < 1]] = GREYRGB * sat\",\n \"def get_coloring(self):\\n colors = dict()\\n colors[-1] = 0\\n if not self.sorting_active: # Don't want any normal colors on the last frame\\n new_list = [int(i) for i in self.lst]\\n if self.sorted_lst == new_list: # The list is sorted, color it green\\n colors[-1] = 1\\n return colors\\n # Last read\\n last_read_key = ThreadManagment.sort_data_by_thread[self.thread.ident].last_read_key\\n if last_read_key >= 0:\\n colors[last_read_key] = 2\\n # Last write\\n last_write_key = ThreadManagment.sort_data_by_thread[self.thread.ident].last_write_key\\n if last_write_key >= 0:\\n colors[last_write_key] = 2\\n # Last lhs comparison\\n last_cmp_left_value = ThreadManagment.sort_data_by_thread[self.thread.ident].last_cmp_left\\n for i in range(len(self.lst)):\\n if int(self.lst.getitem_no_count(i)) == int(last_cmp_left_value):\\n colors[i] = 3\\n break\\n # Last rhs comparison\\n last_cmp_right_value = ThreadManagment.sort_data_by_thread[self.thread.ident].last_cmp_right\\n for i in range(len(self.lst)):\\n if int(self.lst.getitem_no_count(i)) == int(last_cmp_right_value):\\n colors[i] = 3\\n break\\n return colors\",\n \"def differentNodesForNode(ntupleSet,nodeList,verbose=False):\\n nodesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\\n for ntuple in ntupleSet:\\n for nodeInTuple in ntuple:\\n nodesPerNode[nodeInTuple].extend(ntuple)\\n \\n for a,v in nodesPerNode.iteritems():\\n nodesPerNode[a] = set(v)\\n \\n return nodesPerNode\",\n \"def get_node_colors_by_attr(\\n G, attr, num_bins=None, cmap=\\\"viridis\\\", start=0, stop=1, na_color=\\\"none\\\"\\n):\\n if num_bins is None:\\n num_bins = len(G)\\n bin_labels = range(num_bins)\\n attr_values = pd.Series([data[attr] for node, data in G.nodes(data=True)])\\n cats = pd.qcut(x=attr_values, q=num_bins, labels=bin_labels)\\n colors = get_colors(num_bins, cmap, start, stop)\\n node_colors = [colors[int(cat)] if pd.notnull(cat) else na_color for cat in cats]\\n return node_colors\",\n \"def get_colors(lines):\\n\\n patt = re.compile('\\\\#\\\\w+')\\n\\n return [\\n patt.search(line).group(0)\\n for line in lines\\n if patt.search(line)\\n ]\",\n \"def bipartite_sets(G):\\n color=bipartite_color(G)\\n X=set(n for n in color if color[n]==1)\\n Y=set(n for n in color if color[n]==0)\\n return (X,Y)\",\n \"def getColor(self, visited):\\r\\n if visited == \\\"n\\\":\\r\\n button_color = [0.4, 0.6, 0, 1]\\r\\n else:\\r\\n button_color = [0.4, 0.7, 0.9, 1]\\r\\n return button_color\",\n \"def colour_node(instance, reaction_colour='darkgrey', Xc_colour='orange', waste_colour='red', res_colour='limegreen', InPr_colour='lightblue'):\\n G, mapping = instance.network()\\n\\n # relabel\\n G = nx.relabel_nodes(G, mapping)\\n\\n node_dict_mapped = nodes_mapped(instance)\\n\\n waste, resources, intmed_products = instance.amenities()\\n\\n colour_map = []\\n\\n for nd in G:\\n # print(\\\"nd\\\",nd)\\n for nd_label, ammentity in node_dict_mapped.items():\\n # print(\\\"nd_label\\\",nd_label)\\n if nd_label == nd:\\n # print(nd, nd_label)\\n\\n if ammentity == \\\"r\\\":\\n colour_map.append(reaction_colour)\\n\\n elif ammentity == \\\"Xc\\\":\\n colour_map.append(Xc_colour)\\n\\n elif ammentity == \\\"w\\\":\\n colour_map.append(waste_colour)\\n\\n elif ammentity == \\\"Xr\\\":\\n colour_map.append(res_colour)\\n\\n elif ammentity == \\\"InPr\\\":\\n colour_map.append(InPr_colour)\\n return colour_map\",\n \"def get_neighbors(self, node):\\r\\n neighbors = set()\\r\\n for neighbor in ORTHOGONAL_POSITIONS[(node.pos[0], node.pos[1])]:\\r\\n if self.board[neighbor[0]][neighbor[1]].color == node.color:\\r\\n neighbors.add(neighbor)\\r\\n else:\\r\\n continue\\r\\n return neighbors\",\n \"def _build_color_table() -> list[tuple[int, int, int, int, int]]:\\n FG = FOREGROUND_COLOR\\n BG = BACKGROUND_COLOR\\n\\n return [\\n (0x00, 0x00, 0x00, FG.BLACK, BG.BLACK),\\n (0x00, 0x00, 0xAA, FG.BLUE, BG.BLUE),\\n (0x00, 0xAA, 0x00, FG.GREEN, BG.GREEN),\\n (0x00, 0xAA, 0xAA, FG.CYAN, BG.CYAN),\\n (0xAA, 0x00, 0x00, FG.RED, BG.RED),\\n (0xAA, 0x00, 0xAA, FG.MAGENTA, BG.MAGENTA),\\n (0xAA, 0xAA, 0x00, FG.YELLOW, BG.YELLOW),\\n (0x88, 0x88, 0x88, FG.GRAY, BG.GRAY),\\n (0x44, 0x44, 0xFF, FG.BLUE | FG.INTENSITY, BG.BLUE | BG.INTENSITY),\\n (0x44, 0xFF, 0x44, FG.GREEN | FG.INTENSITY, BG.GREEN | BG.INTENSITY),\\n (0x44, 0xFF, 0xFF, FG.CYAN | FG.INTENSITY, BG.CYAN | BG.INTENSITY),\\n (0xFF, 0x44, 0x44, FG.RED | FG.INTENSITY, BG.RED | BG.INTENSITY),\\n (0xFF, 0x44, 0xFF, FG.MAGENTA | FG.INTENSITY, BG.MAGENTA | BG.INTENSITY),\\n (0xFF, 0xFF, 0x44, FG.YELLOW | FG.INTENSITY, BG.YELLOW | BG.INTENSITY),\\n (0x44, 0x44, 0x44, FG.BLACK | FG.INTENSITY, BG.BLACK | BG.INTENSITY),\\n (0xFF, 0xFF, 0xFF, FG.GRAY | FG.INTENSITY, BG.GRAY | BG.INTENSITY),\\n ]\",\n \"def calc_coloring(graph_rdd):\\n graph_rdd = graph_rdd \\\\\\n .map(swap) \\\\\\n .union(graph_rdd)\\n nodes = graph_rdd.keys().distinct()\\n\\n color = nodes.map(lambda x: (x, 1))\\n color_num = 1\\n\\n while True:\\n graph_join_color = graph_rdd.join(color)\\n neighbour = graph_join_color \\\\\\n .map(lambda (x, (a, bx)): (a, (x, bx))) \\\\\\n .groupByKey() \\\\\\n .map(lambda (x, y): (x, [n[1] for n in y]))\\n color = neighbour.map(lambda (x, y): (x, hash(str(sorted(y)))))\\n color_new = color \\\\\\n .map(swap) \\\\\\n .reduceByKey(add, numPartitions=40) \\\\\\n .map(lambda x: 1) \\\\\\n .reduce(add)\\n if color_num != color_new:\\n break\\n color_num = color_new\\n return color\",\n \"def _greedy_color(self, source):\\n for target in self.graph.iteradjacent(source):\\n if self.color[target] is not None:\\n self._color_list[self.color[target]] = True\\n for c in xrange(self.graph.v()): # check colors\\n if not self._color_list[c]:\\n self.color[source] = c\\n break\\n for target in self.graph.iteradjacent(source):\\n if self.color[target] is not None:\\n self._color_list[self.color[target]] = False\\n return c\",\n \"def extract_colors(self, palette, colors):\\n return [palette[i:i + 3] for i in range(0, colors * 3, 3)]\",\n \"def hashColors(colors):\\n return sum(HASH_COLORS[col] for col in set(colors))\",\n \"def _get_colors(num_colors):\\n cmap = plt.get_cmap()\\n return [cmap(1. * i / num_colors) for i in range(num_colors)]\",\n \"def connected_components(nodes):\\n\\n # List of connected components found. The order is random.\\n result = []\\n\\n # Make a copy of the set, so we can modify it.\\n nodes = set(nodes)\\n\\n # Iterate while we still have nodes to process.\\n while nodes:\\n\\n # Get a random node and remove it from the global set.\\n n = nodes.pop()\\n\\n # This set will contain the next group of nodes\\n # connected to each other.\\n group = {n}\\n\\n # Build a queue with this node in it.\\n queue = [n]\\n\\n # Iterate the queue.\\n # When it's empty, we finished visiting a group of connected nodes.\\n while queue:\\n\\n # Consume the next item from the queue.\\n n = queue.pop(0)\\n\\n # Fetch the neighbors.\\n neighbors = n.links\\n\\n # Remove the neighbors we already visited.\\n neighbors.difference_update(group)\\n\\n # Remove the remaining nodes from the global set.\\n nodes.difference_update(neighbors)\\n\\n # Add them to the group of connected nodes.\\n group.update(neighbors)\\n\\n # Add them to the queue, so we visit them in the next iterations.\\n queue.extend(neighbors)\\n\\n # Add the group to the list of groups.\\n result.append(group)\\n\\n # Return the list of groups.\\n return result\",\n \"def bipartite_color(G):\\n color={}\\n for n in G: # handle disconnected graphs\\n if n in color: continue\\n queue=[n] \\n color[n]=1 # nodes seen with color (1 or 0)\\n while queue:\\n v=queue.pop()\\n c=1-color[v] # opposite color of node v\\n for w in G[v]: \\n if w in color: \\n if color[w]==color[v]:\\n raise networkx.NetworkXError(\\\"Graph is not bipartite.\\\")\\n else:\\n color[w]=c\\n queue.append(w)\\n return color\",\n \"def branches(self):\\n unique_nodes, unique_counts = np.unique(self.edges, return_counts=True)\\n return unique_nodes[ unique_counts >= 3 ]\",\n \"def node_ids(self):\\n return [self.node_id]\",\n \"def _generate_colors(\\n self, x: NDArrayFloat\\n ) -> Sequence[RGBHexColor | None]:\\n x = np.asarray(x)\\n idx = np.round((x * 255) + ROUNDING_JITTER).astype(int)\\n arr = np.column_stack(\\n [self._r_lookup[idx], self._g_lookup[idx], self._b_lookup[idx]]\\n )\\n return [rgb_to_hex(c) for c in arr]\",\n \"def graph_nodes(dependencies):\\n\\n return set.union(set(dependencies), *list(dependencies.values()))\",\n \"def colors(self):\\n unique, counts = np.unique(self.arr, return_counts=True)\\n return {k: v for (k, v) in zip(unique, counts)}\",\n \"def get_shaders(self, nodes):\\n shaders = []\\n # Fill the assigned shader list\\n for node in nodes:\\n shader = mc.listConnections(\\\"{0}.instObjGroups[0]\\\".format(node))\\n if shader is not None:\\n shaders.append(shader)\\n else:\\n shaders.append([])\\n return shaders\",\n \"def __repr__(self):\\r\\n return \\\"Colored Set of {0}\\\".format(self.count)\",\n \"def get_player_colors() -> List[Tuple[float, float, float]]:\\n return PLAYER_COLORS\",\n \"def iter_colors(self):\\n return itervalues(self)\",\n \"def construct_groups_string(nodes):\\n groups = get_groups(nodes)\\n if len(groups) <= 1:\\n return \\\"\\\"\\n else:\\n result = []\\n for color in groups:\\n # +1 because .tsp nodes are indexed with 1\\n group = [node.nid + 1 for node in nodes if node.color == color]\\n result.append(group)\\n return str(result)\",\n \"def components(self):\\n comps = 0\\n unexplored = self.nodes()\\n while unexplored:\\n comps += 1\\n queue = {unexplored.pop()}\\n while queue:\\n new = queue.pop()\\n unexplored.remove(new)\\n for adjacent in new.parents() | new.children():\\n if adjacent in unexplored:\\n queue.add(adjacent)\\n return comps\",\n \"def colors(self) -> dict:\\n raise NotImplementedError\",\n \"def color():\\n\\tcolors = ['b', 'r', 'g', 'k']\\n\\twhile True:\\n\\t\\tfor c in colors:\\n\\t\\t\\tyield c\",\n \"def testSetColorDecisionList(self):\\n self.node.color_decisions = self.color_decisions\\n\\n # We need to convert self.color_decisions to a set then to a list\\n # so the order matches\\n self.assertEqual(\\n list(set(self.color_decisions)),\\n self.node.color_decisions\\n )\",\n \"def preset_colors( self, labels ):\\n size_labels = len( labels )\\n self.color_override = self.metadata.get('color_override', {})\\n try:\\n if self.color_override == {}:\\n raise Exception('going to the default')\\n colours = self.color_override\\n size_colors = len ( colours )\\n retval = []\\n for label in labels:\\n mycolour = colours[label]\\n retval.append(mycolour)\\n except:\\n hex_colors = self.hex_colors\\n size_colors = len( hex_colors )\\n retval = [ hex_colors[ i % size_colors ] for i in range( size_labels ) ]\\n\\n retval.reverse()\\n return retval\",\n \"def _random_color() -> List[float]:\\n return [np.random.uniform(), np.random.uniform(), np.random.uniform()]\",\n \"def make_palette(self, color_count):\\n palette = []\\n palette_index = 0\\n leaf_count = len(self.get_leaves())\\n # reduce nodes\\n # up to 8 leaves can be reduced here and the palette will have\\n # only 248 colors (in worst case) instead of expected 256 colors\\n for level in range(OctreeQuantizer.MAX_DEPTH - 1, -1, -1):\\n if self.levels[level]:\\n for node in self.levels[level]:\\n leaf_count -= node.remove_leaves()\\n if leaf_count <= color_count:\\n break\\n if leaf_count <= color_count:\\n break\\n self.levels[level] = []\\n # build palette\\n for node in self.get_leaves():\\n if palette_index >= color_count:\\n break\\n if node.is_leaf():\\n palette.append(node.get_color())\\n node.palette_index = palette_index\\n palette_index += 1\\n return palette\",\n \"def get_nodes(self):\\n return_set = set()\\n for value in self._name:\\n return_set.add(value)\\n return return_set\",\n \"def nodes(self):\\n return self._node_reg\",\n \"def _tupleListToStrings(self):\\n graphColorStrings = []\\n previousSelection = self.colorlist.GetSelection()\\n print(repr(self.graphColors))\\n if isinstance(self.graphColors, str):\\n self.graphColors = eval(self.graphColors)\\n for col in self.graphColors:\\n col1 = '%.2f' % float(col[0])\\n col2 = '%.2f' % float(col[1])\\n col3 = '%.2f' % float(col[2])\\n graphColorStrings.append(', '.join([col1, col2, col3]))\\n self.colorlist.SetItems(graphColorStrings)\\n if 0 <= previousSelection < len(graphColorStrings):\\n self.colorlist.SetSelection(previousSelection)\\n return graphColorStrings\",\n \"def get_nodes(self):\\n try:\\n return list(self._adjacency_list.keys())\\n except Exception as error:\\n print(f'An error occurred: {error}')\",\n \"def GetColors(self, *args):\\n return _XCAFDoc.XCAFDoc_ColorTool_GetColors(self, *args)\",\n \"def nodes(self): \\n return [n for n in self.iternodes()]\",\n \"def getColor(k) :\\n colors = [\\\"#862B59\\\",\\\"#A10000\\\",\\\"#0A6308\\\",\\\"#123677\\\",\\\"#ff8100\\\",\\\"#F28686\\\",\\\"#6adf4f\\\",\\\"#58ccdd\\\",\\\"#3a3536\\\",\\\"#00ab7c\\\"]\\n return colors[k]\",\n \"def _get_goal_colours() -> List[Tuple[int, int, int]]:\\n colour_lst = COLOUR_LIST[:]\\n random.shuffle(colour_lst)\\n return colour_lst\",\n \"def get_colors(n, cmap=\\\"viridis\\\", start=0.0, stop=1.0, alpha=1.0, return_hex=False):\\n colors = [cm.get_cmap(cmap)(x) for x in np.linspace(start, stop, n)]\\n colors = [(r, g, b, alpha) for r, g, b, _ in colors]\\n if return_hex:\\n colors = _rgb_color_list_to_hex(colors)\\n return colors\",\n \"def get_color(node, color_map):\\r\\n if node in color_map:\\r\\n return color_map[node]\\r\\n return \\\"black\\\"\",\n \"def hex_colors(cls):\\n return ['#{:02x}{:02x}{:02x}'.format(*cls._COLORS[s])\\n for s in cls._STATES]\",\n \"def get_color(self):\\n colors = []\\n color_specs = [self._red_spec, self._green_spec,\\n self._blue_spec, self._white_spec]\\n for spec in color_specs:\\n driver = DRIVERS[spec.addr]\\n colors.append(driver.get_duty_cycle(spec.pin))\\n \\n return colors\",\n \"def set_node_color_bypass(node_names, new_colors, network=None, base_url=DEFAULT_BASE_URL):\\n if isinstance(new_colors, str): new_colors = [\\n new_colors] # TODO: It looks like this should be happening everywhere?\\n for color in new_colors:\\n if is_not_hex_color(color):\\n return None # TODO: Shouldn't this be an exception?\\n\\n res = set_node_property_bypass(node_names, new_colors, 'NODE_FILL_COLOR', network=network, base_url=base_url)\\n return res\",\n \"def get_colors(self):\\n df = self.reindexed_dataframe()\\n\\n colormap = cm.get_cmap(self.cmap)\\n norm = Normalize(vmin=df.min(), vmax=df.max())\\n\\n sm = cm.ScalarMappable(norm=norm, cmap=colormap)\\n\\n return ['rgba' + str(sm.to_rgba(m, bytes = True, alpha = 0.8)) if not np.isnan(m) else 'rgba(128,128,128,1)' for m in df.values]\",\n \"def get_node_names(self):\\n return set({node.get_name() for node in self.get_nodeset()}) # return the set of names\",\n \"def all_ids(self) -> Set[int]:\\n return {node_id for _, (node_id, _) in self.nodes.items()}\",\n \"def get_colors(n):\\n color = cm.rainbow(np.linspace(0, 1, n))\\n return color\",\n \"def node_ids(self):\\n # From: https://stackoverflow.com/questions/17415086/combine-consecutive-numbers-into-range-tuples\\n groups = groupby(self.nodes.keys(), key=lambda item, c=count():item-next(c))\\n temp = [list(g) for k, g in groups]\\n return \\\"+\\\".join(\\\"{}-{}\\\".format(x[0], x[-1]) for x in temp)\",\n \"def get_graph_color ( self, object ):\\n return self.graph_color_\",\n \"def clusterGen(k, colors):\\n clusters = []\\n # generate the clusters randomly\\n # for i in range(k):\\n # r = random.randint(0, 255)\\n # g = random.randint(0, 255)\\n # b = random.randint(0, 255)\\n # clusters.append((r, g, b))\\n\\n # generate the clusters that exist in colors\\n l = len(colors)\\n for i in range(k):\\n r = random.randint(0, l)\\n cluster = colors[r][1]\\n clusters.append(cluster)\\n\\n return clusters\",\n \"def terminals(self):\\n unique_nodes, unique_counts = np.unique(self.edges, return_counts=True)\\n return unique_nodes[ unique_counts == 1 ]\",\n \"def assign_entity_colors(pairs):\\n groups = []\\n for a, b in pairs:\\n for grp in groups:\\n if a in grp or b in grp:\\n grp.add(a)\\n grp.add(b)\\n else:\\n groups.append(set([a, b]))\\n\\n colors = {}\\n for grp in groups:\\n color = random.choice(config.COLORS)\\n for id in grp:\\n colors[id] = color\\n return colors\",\n \"def get_colors_with_tsne_3dof(data: ndarray, num_iterations: int = 300) -> ndarray:\\n tsne = TSNE(n_components=3, perplexity=40, n_iter=num_iterations, random_state=0)\\n tsne_results = tsne.fit_transform(data)\\n tsne_min = np.min(tsne_results, axis=0, keepdims=True)\\n tsne_max = np.max(tsne_results, axis=0, keepdims=True)\\n colors = (tsne_results - tsne_min) / (tsne_max - tsne_min)\\n return colors\",\n \"def neighbors(node, test_set):\\r\\n result = set()\\r\\n for neighbor in node.neighbors:\\r\\n if neighbor in test_set:\\r\\n result.add(neighbor)\\r\\n return result\",\n \"def nodes(self):\\n for node_set in self.itervalues():\\n for node in node_set:\\n yield node\",\n \"def color_validity(data: np.ndarray, valids: np.ndarray) -> list:\\n\\n def color_validity(v: int) -> str:\\n return Fore.GREEN if v == 1 else Fore.RED\\n\\n return [color_validity(v) + str(ele) + Style.RESET_ALL for (ele, v) in zip(data, valids)]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78957987","0.7514314","0.712716","0.69475394","0.6675967","0.66652167","0.66599905","0.66454685","0.64734924","0.6415016","0.64149046","0.6397059","0.63902277","0.63846207","0.63146603","0.6292402","0.627562","0.627562","0.62653184","0.62567157","0.62204975","0.6208494","0.62081605","0.6207174","0.61238325","0.6106372","0.60992575","0.60924006","0.6078123","0.607428","0.6063131","0.6049032","0.6020179","0.6003781","0.5949458","0.5946805","0.59394246","0.58776706","0.5859293","0.5858613","0.58501554","0.58251333","0.5790517","0.5775361","0.5770998","0.5767683","0.57641447","0.5762622","0.5753205","0.5751586","0.5750923","0.57448745","0.57122606","0.5710369","0.5699569","0.5698372","0.56971306","0.56927484","0.56872153","0.5682409","0.56730086","0.5666515","0.5660126","0.5649536","0.5644632","0.56407523","0.56391823","0.56383103","0.56317747","0.5621574","0.561474","0.56072694","0.55977196","0.5585443","0.5585049","0.55835485","0.5569137","0.55670345","0.5564038","0.5559556","0.5555387","0.555486","0.5550178","0.5548588","0.5546519","0.5544786","0.5540525","0.55382705","0.5533161","0.55328447","0.55304396","0.55271655","0.5525559","0.55203366","0.55163467","0.5515648","0.5511032","0.55049676","0.5501016","0.5500973"],"string":"[\n \"0.78957987\",\n \"0.7514314\",\n \"0.712716\",\n \"0.69475394\",\n \"0.6675967\",\n \"0.66652167\",\n \"0.66599905\",\n \"0.66454685\",\n \"0.64734924\",\n \"0.6415016\",\n \"0.64149046\",\n \"0.6397059\",\n \"0.63902277\",\n \"0.63846207\",\n \"0.63146603\",\n \"0.6292402\",\n \"0.627562\",\n \"0.627562\",\n \"0.62653184\",\n \"0.62567157\",\n \"0.62204975\",\n \"0.6208494\",\n \"0.62081605\",\n \"0.6207174\",\n \"0.61238325\",\n \"0.6106372\",\n \"0.60992575\",\n \"0.60924006\",\n \"0.6078123\",\n \"0.607428\",\n \"0.6063131\",\n \"0.6049032\",\n \"0.6020179\",\n \"0.6003781\",\n \"0.5949458\",\n \"0.5946805\",\n \"0.59394246\",\n \"0.58776706\",\n \"0.5859293\",\n \"0.5858613\",\n \"0.58501554\",\n \"0.58251333\",\n \"0.5790517\",\n \"0.5775361\",\n \"0.5770998\",\n \"0.5767683\",\n \"0.57641447\",\n \"0.5762622\",\n \"0.5753205\",\n \"0.5751586\",\n \"0.5750923\",\n \"0.57448745\",\n \"0.57122606\",\n \"0.5710369\",\n \"0.5699569\",\n \"0.5698372\",\n \"0.56971306\",\n \"0.56927484\",\n \"0.56872153\",\n \"0.5682409\",\n \"0.56730086\",\n \"0.5666515\",\n \"0.5660126\",\n \"0.5649536\",\n \"0.5644632\",\n \"0.56407523\",\n \"0.56391823\",\n \"0.56383103\",\n \"0.56317747\",\n \"0.5621574\",\n \"0.561474\",\n \"0.56072694\",\n \"0.55977196\",\n \"0.5585443\",\n \"0.5585049\",\n \"0.55835485\",\n \"0.5569137\",\n \"0.55670345\",\n \"0.5564038\",\n \"0.5559556\",\n \"0.5555387\",\n \"0.555486\",\n \"0.5550178\",\n \"0.5548588\",\n \"0.5546519\",\n \"0.5544786\",\n \"0.5540525\",\n \"0.55382705\",\n \"0.5533161\",\n \"0.55328447\",\n \"0.55304396\",\n \"0.55271655\",\n \"0.5525559\",\n \"0.55203366\",\n \"0.55163467\",\n \"0.5515648\",\n \"0.5511032\",\n \"0.55049676\",\n \"0.5501016\",\n \"0.5500973\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7795284"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":14696,"cells":{"query":{"kind":"string","value":"generates and returns overlap graph from .paf files"},"document":{"kind":"string","value":"def generate_graph(params):\n\n alignedreads = read_paf(params, should_filter_paf=True)\n\n aligned = [(t, h) for t, h, _ in alignedreads]\n graph = nx.Graph()\n graph.add_edges_from(aligned)\n return graph"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def overlap_graph(input, overlap):\n\n sequence_dict = {}\n seq_id_list = []\n\n for seq_record in SeqIO.parse(input, \"fasta\"): # change input variable.\n sequence_dict[seq_record.id] = seq_record.seq\n seq_id_list.append(seq_record.id)\n\n adjacency_list= []\n\n index = overlap\n\n for id in seq_id_list:\n neg_index = (index * -1)\n for k in sequence_dict:\n\n if id == k:\n pass\n\n elif id != k:\n if sequence_dict[id][neg_index:] == sequence_dict[k][0:index]:\n adjacency_list.append(f\"{id} {k}\".format(id=id, k=k))\n\n #print(\"\\nyes\")\n #print(id, sequence_dict[id][neg_index:], \"and\", k, sequence_dict[k][0:index], \"\\n\")\n else:\n pass\n\n #print(\"no\")\n #print(id, sequence_dict[id][neg_index:], \"and\", k, sequence_dict[k][0:index])\n open(\"output.txt\", \"w\")\n with open(\"output.txt\", \"a\") as out:\n for x in adjacency_list:\n out.write(f\"{x}\\n\".format(x=x))","def get_overlaps(file_name):\r\n\r\n place = {}\r\n size = {}\r\n sap = {}\r\n overlapping = []\r\n active_list = []\r\n max_width = 0\r\n\r\n with open(file_name + \".scl\") as f:\r\n for i, line in enumerate(f):\r\n\r\n line = line.strip()\r\n if line:\r\n if line.split()[0] == \"Sitespacing\":\r\n sitespacing = line.split()[2]\r\n if line.split()[0] == \"SubrowOrigin\":\r\n starting_x = line.split()[2]\r\n ending_x = int(starting_x) + int(sitespacing) * int(line.split()[5])\r\n if ending_x > max_width:\r\n max_width = ending_x\r\n\r\n divider = max_width // 10\r\n\r\n with open(file_name + \".nodes\") as f:\r\n for i, line in enumerate(f):\r\n\r\n line = line.strip()\r\n if line:\r\n if re.match(r'[a-z]{1}[0-9]+', line.split()[0]):\r\n if len(line.split()) == 3:\r\n size[line.split()[0]] = [line.split()[1], line.split()[2]]\r\n\r\n with open(file_name + \".pl\") as f:\r\n for i, line in enumerate(f):\r\n\r\n line = line.strip()\r\n if line:\r\n if re.match(r'[a-z]{1}[0-9]+', line.split()[0]):\r\n if line.split()[0] in size:\r\n place[line.split()[0]] = [line.split()[1], line.split()[2]]\r\n sap_num = int(line.split()[1]) // divider\r\n if sap_num not in sap.keys():\r\n sap[sap_num] = []\r\n sap[sap_num].append([line.split()[0], int(line.split()[1]),\r\n int(line.split()[1]) + int(size[line.split()[0]][0]), int(line.split()[2]),\r\n \"start\"])\r\n\r\n sap[sap_num].append([line.split()[0], int(line.split()[1]),\r\n int(line.split()[1]) + int(size[line.split()[0]][0]),\r\n int(line.split()[2]) + int(size[line.split()[0]][1]), \"end\"])\r\n\r\n for lista in sap.values():\r\n lista.sort(key=lambda x: x[3])\r\n lista.sort(key=lambda x: x[4], reverse=True)\r\n for element in lista:\r\n if element[4] == \"start\":\r\n if len(active_list) == 0:\r\n active_list.append(element[0])\r\n else:\r\n for node in active_list:\r\n if int(place[node][0]) < int(place[element[0]][0]) + int(size[element[0]][0]) \\\r\n and int(place[node][0]) + int(size[node][0]) > int(place[element[0]][0]) \\\r\n and int(place[node][1]) < int(place[element[0]][1]) + int(size[element[0]][1]) \\\r\n and int(place[node][1]) + int(size[node][1]) > int(place[element[0]][1]):\r\n overlap = (node, element[0])\r\n overlapping.append(overlap)\r\n active_list.append(element[0])\r\n else:\r\n active_list.remove(element[0])\r\n return overlapping","def check_overlap(gfa_, path, external_file):\n if external_file:\n fasta_dict = fasta_reader(path, external_file)\n if not fasta_dict:\n return None\n\n eid_dict = dict()\n node_dict = dict()\n\n count_consistency = 0\n count_no_defined = 0\n edges_no_consistency = []\n edges_no_calculate = []\n edge_no_text = 0\n\n data_edges = gfa_.edge()\n for node1 in data_edges:\n for node2 in data_edges[node1]:\n for eid in data_edges[node1][node2]:\n if not eid_dict.get(eid):\n eid_dict[eid] = True\n from_id = data_edges[node1][node2][eid]['from_node']\n try:\n node_dict[from_id] = gfa_.node()[from_id]['sequence']\n except KeyError:\n edge_no_text += 1\n break\n to_id = data_edges[node1][node2][eid]['to_node']\n try:\n node_dict[to_id] = gfa_.node()[to_id]['sequence']\n except KeyError:\n edge_no_text += 1\n break\n\n from_orn = data_edges[node1][node2][eid]['from_orn']\n to_orn = data_edges[node1][node2][eid]['to_orn']\n overlap = int(data_edges[node1][node2][eid]['alignment'].rstrip('M'))\n\n if node_dict[from_id] == '*' and external_file:\n node_dict[from_id] = fasta_dict.get(from_id, '*')\n if node_dict[from_id] == '*':\n GRAPH_LOGGER.debug('Node %s has sequence no specify!', from_id)\n if node_dict[to_id] == '*' and external_file:\n node_dict[to_id] = fasta_dict.get(to_id, '*')\n if node_dict[to_id] == '*':\n GRAPH_LOGGER.debug('Node %s has sequence no specify!', to_id)\n\n if not node_dict[from_id] == '*' and not node_dict[to_id] == '*':\n check = consistency((from_id, to_id), \\\n (node_dict[from_id], node_dict[to_id]), (from_orn, to_orn), overlap)\n if check:\n count_consistency += 1\n else:\n edges_no_consistency.append(eid)\n else:\n GRAPH_LOGGER.debug('Can\\'t check overlap consistency between \\\n node %s and %s', from_id, to_id)\n count_no_defined += 1\n edges_no_calculate.append(eid)\n\n GRAPH_LOGGER.debug('%s edge overlap are consistency of total amount of %s', \\\n count_consistency, len(eid_dict)-edge_no_text)\n\n return edges_no_consistency, edges_no_calculate","def overlap(fields) :\n\n r13=apload.ApLoad(apred='r13')\n f=[]\n a=[]\n for field in fields :\n f.append(fits.open(field+'/'+field+'_rv.fits'))\n a.append( r13.apFieldVisits(field))\n\n outdir=fields[0]+'_'+fields[1]\n try: os.makedirs(outdir)\n except: pass\n\n fp=open(outdir+'/'+outdir+'.html','w')\n fp.write('<HTML>\\n')\n fp.write('<HEAD><script type=text/javascript src=../html/sorttable.js></script></head>')\n fp.write('<BODY>\\n')\n fp.write('<TABLE BORDER=2>\\n')\n\n matplotlib.use('Agg')\n i1,i2=match.match(f[0][1].data['APOGEE_ID'],f[1][1].data['APOGEE_ID'])\n colors=['g','r','b','m']\n for star in f[0][1].data['APOGEE_ID'][i1] :\n print(star)\n fp.write('<TR><TD>{:s}<BR>\\n'.format(star))\n fp.write('<TABLE BORDER=2>\\n')\n fig,ax=plots.multi(1,1)\n for i,field in enumerate(f) :\n j=np.where(field[2].data['APOGEE_ID'] == star)[0]\n plots.plotp(ax,field[2].data['MJD'][j],field[2].data['VHELIO'][j],color=colors[i],size=10)\n j=np.where(field[1].data['APOGEE_ID'] == star)[0][0]\n fp.write('<TR><TD>Doppler<TD>{:8.2f}<TD>{:8.2f}<TD>{:8.0f}<TD>{:8.2f}<TD>{:8.2f}\\n'.format(\n field[1].data['VHELIO_AVG'][j],field[1].data['VSCATTER'][j],\n field[1].data['RV_TEFF'][j],field[1].data['RV_LOGG'][j],field[1].data['RV_FEH'][j]))\n for i,field in enumerate(a) :\n j=np.where(field[1].data['APOGEE_ID'] == star)[0]\n gd=np.where(np.abs(field[1].data['VHELIO'][j]) < 999)[0]\n plots.plotp(ax,field[1].data['MJD'][j[gd]],field[1].data['VHELIO'][j[gd]],color=colors[i+2],size=10)\n #fp.write('<TR><TD>IDL<TD>{:8.2f}<TD>{:8.2f}<TD>{:8.2f}<TD>{:8.0f}<TD>{:8.2f}<TD>{:8.2f}\\n'.format(\n # field[1].data['VHELIO_AVG'],field[1].data['VSCATTER'],\n # field[1].data['RV_TEFF'],field[1].data['RV_LOGG'],field[1].data['RV_FEH']))\n plt.draw()\n plt.close()\n fig.savefig(outdir+'/'+star+'.png')\n fp.write('</TABLE>\\n')\n fp.write('<TD><a HREF={:s}.png> <IMG SRC={:s}.png> </a>\\n'.format(star,star))\n fp.write('</TABLE>')\n fp.close()","def getConf(ppiFile):\n validpattern = re.compile('^[\\w _\\-.,\\t\"\\':;]+$')\n splitpattern = re.compile('[\\t ;,]+')\n numericpattern = re.compile('^[0-9. \\t,\\-]+')\n\t### collect node names ###\n finfile = open(ppiFile, 'r')\n names = {}\n index = 0\n for temp in finfile:\n temp = temp.strip('\\t \\n\\r')\n if temp == \"\" or (re.search(validpattern, temp) is None):\n continue\n allwords = re.split(splitpattern, temp)\n for i in xrange(0, 2):\n if re.match(numericpattern, allwords[i]) is not None:\n temp = \"Error: file inconsistent\"\n temp = temp + \"(possible node ID is numeric)\"\n temp = temp + \" \" + allwords[i]\n print >> sys.stderr, temp\n exit(1)\n if allwords[0] not in names:\n names[allwords[0]] = index\n index = index + 1\n if allwords[1] not in names:\n names[allwords[1]] = index\n index = index + 1\n finfile.close()\n names = collections.OrderedDict(sorted(names.items(), key=lambda x: x[1]))\n N = index\n ppbConf = np.zeros((N, N))\n\t### collect edges ###\n finfile = open(ppiFile, 'r')\n for temp in finfile:\n temp = temp.strip('\\t \\n\\r')\n if temp == \"\" or (re.search(validpattern, temp) is None):\n continue\n allwords = re.split(splitpattern, temp)\n i = names[allwords[0]]\n j = names[allwords[1]]\n templen = len(temp)\n # allow for tab or space delimiters\n temp = temp.split('\\t')\n if templen == len(temp):\n \ttemp = temp.split(' ')\n \t\n if len(temp) > 2:\n confidence = temp[2]\n else:\n confidence = 1\n if i != j:\n ppbConf[i, j] = confidence\n ppbConf[j, i] = confidence\n finfile.close()\n return (ppbConf, names)","def generatePhasingScore(options,phase,cycle):\n score,readcount,readseq=readDataForPhasingScoreComputation(options,phase)\n phased_loci_filename=options.output_directory_per_run+\"/\"+options.input_filename+\"_\"+str(phase)+\"_\"+str(cycle)+\".positive_phase_loci\"\n final_phase_loci=options.output_directory_per_run+\"/\"+options.input_filename+\"_\"+str(phase)+\"_\"+str(cycle)+\".phasing_score_phase_loci\"\n fhr=open(phased_loci_filename,\"r\")\n out4=open(final_phase_loci,\"w\")\n for line in fhr:\n chromosome,ss,ee=line.strip().split()\n ss=int(ss)\n ee=int(ee)\n #correct=list(range(ss,ee+1,phase))\n phasing_score_filename=options.output_directory_per_run+\"/\"+str(phase)+\"_\"+str(chromosome)+\"_\"+str(ss)+\"_\"+str(ee)+\".phasing_score\"\n abundance_score_filename=options.output_directory_per_run+\"/\"+str(phase)+\"_\"+str(chromosome)+\"_\"+str(ss)+\"_\"+str(ee)+\".abundance\"\n out=open(phasing_score_filename,\"w\")\n out2=open(abundance_score_filename,\"w\")\n score_count={}\n for site in range(ss,ee+1):\n start=site-(phase*4)\n end=site+(phase*5)-1\n max_within_site,max_within_count,all_scores=0,0,0\n for cor in range(start,end+1):\n if cor not in score[chromosome]:continue\n all_scores+=score[chromosome][cor]\n for i in readcount[chromosome][cor]:\n if max_within_count<readcount[chromosome][cor][i]:\n max_within_site=cor\n max_within_count=readcount[chromosome][cor][i]\n all_scores-=max_within_count\n P,k=0,0\n s=start\n while s<end:\n if s not in score[chromosome]:\n s+=phase\n continue\n if score[chromosome][s]!=0:\n P+=score[chromosome][s]\n k+=1\n if s == max_within_site:\n P-=max_within_count \n s+=phase\n U=all_scores-P\n \n #if U<0: continue\n if k>=3:\n #print(P,U,k)\n phas_score=math.log((1+(10*(P/(1+U))))**(k-2))\n \"\"\"if phas_score>max and site in correct:\n max=phas_score\"\"\"\n else:\n phas_score=0\n out.write(str(site)+\"\\t\"+str(phas_score)+\"\\n\")\n out4.write(chromosome+\"\\t\"+str(site)+\"\\t\"+str(phas_score)+\"\\n\")\n if chromosome not in score_count:\n score_count[chromosome]={}\n if site not in score_count[chromosome]:\n score_count[chromosome][site]=phas_score\n if site in readcount[chromosome] and '+' in readcount[chromosome][site] and readcount[chromosome][site]['+']!=0:\n out2.write(str(site)+\"\\t\"+str(readcount[chromosome][site]['+'])+\"\\n\")\n if site in readcount[chromosome] and '-' in readcount[chromosome][site] and readcount[chromosome][site]['-']!=0:\n out2.write(str(site)+\"\\t-\"+str(readcount[chromosome][site]['-'])+\"\\n\")\n out.close()\n out2.close()\n \n #out4.write(chromosome+\"\\t\"+str(ss)+\"\\t\"+str(ee)+\"\\t\"+str(phas_score)+\"\\n\")\n out4.close()","def acogps(f_path, min_supp=MIN_SUPPORT, evaporation_factor=EVAPORATION_FACTOR,\n max_iteration=MAX_ITERATIONS, return_gps=False):\n # 0. Initialize and prepare data set\n d_set = DataGP(f_path, min_supp)\n \"\"\":type d_set: DataGP\"\"\"\n d_set.init_attributes()\n # attr_index = d_set.attr_cols\n # e_factor = evaporation_factor\n d, attr_keys = gend(d_set.valid_bins) # distance matrix (d) & attributes corresponding to d\n\n a = d_set.attr_size\n winner_gps = list() # subsets\n loser_gps = list() # supersets\n str_winner_gps = list() # subsets\n repeated = 0\n it_count = 0\n counter = 0\n\n if d_set.no_bins:\n return []\n\n # 1. Remove d[i][j] < frequency-count of min_supp\n fr_count = ((min_supp * a * (a - 1)) / 2)\n d[d < fr_count] = 0\n\n # 3. Initialize pheromones (p_matrix)\n pheromones = np.ones(d.shape, dtype=float)\n\n invalid_count = 0\n # 4. Iterations for ACO\n # while repeated < 1:\n while counter < max_iteration:\n rand_gp, pheromones = genaco(attr_keys, d, pheromones, evaporation_factor)\n if len(rand_gp.gradual_items) > 1:\n # print(rand_gp.get_pattern())\n exits = isduplicate(rand_gp, winner_gps, loser_gps)\n if not exits:\n repeated = 0\n # check for anti-monotony\n is_super = amcheck(loser_gps, rand_gp, subset=False)\n is_sub = amcheck(winner_gps, rand_gp, subset=True)\n if is_super or is_sub:\n continue\n gen_gp = validategp(d_set, rand_gp)\n \"\"\":type gen_gp: GP\"\"\"\n is_present = isduplicate(gen_gp, winner_gps, loser_gps)\n is_sub = amcheck(winner_gps, gen_gp, subset=True)\n if is_present or is_sub:\n repeated += 1\n else:\n if gen_gp.support >= min_supp:\n pheromones = update_pheromones(attr_keys, gen_gp, pheromones)\n winner_gps.append(gen_gp)\n str_winner_gps.append(gen_gp.print(d_set.titles))\n else:\n loser_gps.append(gen_gp)\n invalid_count += 1\n if set(gen_gp.get_pattern()) != set(rand_gp.get_pattern()):\n loser_gps.append(rand_gp)\n else:\n repeated += 1\n else:\n invalid_count += 1\n it_count += 1\n if max_iteration == 1:\n counter = repeated\n else:\n counter = it_count\n # Output\n out = json.dumps({\"Algorithm\": \"ACO-GRAD\", \"Best Patterns\": str_winner_gps, \"Invalid Count\": invalid_count,\n \"Iterations\": it_count})\n \"\"\":type out: object\"\"\"\n if return_gps:\n return out, winner_gps\n else:\n return out","def main_load_nps(fileA, fileB):\n \n print \"- Loading the following non-dominated sets of two-dimensional\"\n print \" objective vectors and computing the joint-EAF:\"\n print \" * A:\", fileA\n print \" * B:\", fileB\n print\n \n npsetA = datasets.load_nps(fileA)\n npsetB = datasets.load_nps(fileB)\n assert len(npsetA) == len(npsetB), (\"The npsets must have the same length \"\n \"(i.e. same number of executions)\")\n\n point_ind = eafindicators(npsetA, npsetB)\n return point_ind","def constraint_test():\n import itertools, sys\n\n show_analysis = False\n #Generated via grammar\n gr = grammar.Grammar('grammars/test_constraints.bnf')\n inputs = ([1 for _ in range(100)], [ i%3 for i in range(100)])\n for _input in inputs: \n output = gr.generate(_input)\n azr = analyser.Analyser('test',output['phenotype'],True)\n try:\n azr.create_graph()\n except ValueError as e:\n print(__name__, \"ERROR\", _input, e)\n continue\n azr.parse_graph()\n azr.apply_stresses()\n azr.create_slf_file()\n azr.test_slf_file()\n azr.parse_results()\n azr.print_stresses()\n if show_analysis:\n azr.show_analysis()\n \n #Fixed generated\n lengths = (1000, 10000)\n levels = (5, 10)\n for length_idx, level_idx in itertools.permutations([0,1]):\n try:\n GRAPH = constrained_offset_graph(lengths[length_idx],\n levels[length_idx])\n except ValueError as e:\n print(__name__, \"ERROR\", lengths[length_idx], levels[length_idx], e)\n continue\n GRAPH.save_graph(\"pylon\")\n print \"nodes:\", GRAPH.number_of_nodes()\n print \"edges\", GRAPH.number_of_edges()\n #will it blend?\n azr = analyser.Analyser('test',\"moo\",True)\n azr.my_graph = GRAPH\n azr.parse_graph()\n azr.apply_stresses()\n azr.create_slf_file()\n azr.test_slf_file()\n azr.parse_results()\n azr.print_stresses()\n if show_analysis:\n azr.show_analysis()","def build_from_file(self, topology_file, topology_format):\n with open(topology_file) as infile:\n for line in infile:\n if line.startswith(\"#\"):\n continue\n else:\n if topology_format == 0:\n x = line.split(\"\\n\")[0].split(\"|\")\n as1 = int(x[0])\n as2 = int(x[1])\n relationship = int(x[2])\n else:\n x = line.split(\"\\n\")[0].split(\"\\t\")\n if x[2] == \"p2c\":\n as1 = int(x[0])\n as2 = int(x[1])\n relationship = -1\n elif x[2] == \"c2p\":\n as1 = int(x[1])\n as2 = int(x[0])\n relationship = -1\n elif x[2] == \"p2p\":\n as1 = int(x[1])\n as2 = int(x[0])\n relationship = 0\n else:\n continue\n\n if not self.has_edge(as1, as2):\n self.add_edge(as1, as2, relationship=relationship, as1=as1, as2=as2)","def read_ao_overlap(self, path_rwfdump, fn_rwf):\n os.system(path_rwfdump + f\" {fn_rwf} ao_overlap.dat 514R\")\n\n with open('ao_overlap.dat', \"r\") as f:\n log = f.read()\n\n tmp = re.findall('[-]?\\d+\\.\\d+D[+-]\\d\\d', log)\n tmp = [float(x.replace('D', 'e')) for x in tmp]\n \n tmp_ovr = np.zeros((self.nbasis * 2, self.nbasis * 2))\n \n cnt = 0\n for ibasis in range(self.nbasis * 2):\n for jbasis in range(ibasis + 1):\n tmp_ovr[ibasis, jbasis] = tmp[cnt]\n cnt += 1\n\n tmp_ovr += np.transpose(tmp_ovr) - np.diag(np.diag(tmp_ovr))\n\n # Slicing the components between t and t+dt\n return tmp_ovr[:self.nbasis, self.nbasis:]","def anchors_to_adjacency(set_path, n_proteomes, mailbox_reader):\n frame_list = []\n for idx in range(n_proteomes):\n with mailbox_reader(idx) as file_handle:\n frame_list.append(\n pd.read_csv(\n file_handle, sep=\"\\t\", index_col=0\n ).convert_dtypes()\n )\n nodes = pd.concat(\n frame_list,\n ignore_index=True,\n )\n del frame_list\n graph = nx.Graph()\n for unused_tuple, subframe in nodes.groupby(\n by=[\"syn.anchor.id\", \"syn.anchor.sub_id\"]\n ):\n ids = subframe[\"member_ids\"]\n n_ids = len(ids)\n graph.add_nodes_from(ids)\n if n_ids > 1:\n edges = combinations(ids, 2)\n graph.add_edges_from(edges, weight=n_ids)\n outpath = set_path / ANCHORS_FILE\n summarypath = outpath.parent / (\n outpath.name[: -len(outpath.suffix)] + \"_summary.tsv\"\n )\n histpath = outpath.parent / (\n outpath.name[: -len(outpath.suffix)] + \"_hist.tsv\"\n )\n components = [\n c\n for c in sorted(nx.connected_components(graph), key=len, reverse=True)\n if len(c) > 1\n ]\n fh = outpath.open(\"w\")\n fh.write(\"idx\\tcluster_id\\tsize\\tmembers\\n\")\n n_items = 0\n count_list = []\n hash_list = []\n id_list = []\n for i, comp in enumerate(components):\n component = np.sort(pd.Index(list(comp)).to_numpy())\n id_list.append(i)\n size = len(comp)\n count_list.append(size)\n hash_list.append(hash_array(component))\n for node in component:\n fh.write(f\"{n_items}\\t{i}\\t{size}\\t{node}\\n\")\n n_items += 1\n fh.close()\n n_clusts = len(count_list)\n del graph, components\n cluster_counts = pd.DataFrame({\"size\": count_list})\n largest_cluster = cluster_counts[\"size\"].max()\n cluster_hist = (\n pd.DataFrame(cluster_counts.value_counts()).sort_index().reset_index()\n )\n cluster_hist = cluster_hist.set_index(\"size\")\n cluster_hist = cluster_hist.rename(columns={0: \"n\"})\n cluster_hist[\"item_pct\"] = (\n cluster_hist[\"n\"] * cluster_hist.index * 100.0 / n_items\n )\n cluster_hist.to_csv(histpath, sep=\"\\t\", float_format=\"%5.2f\")\n cluster_hist[\"cluster_pct\"] = cluster_hist[\"n\"] * 100.0 / n_clusts\n cluster_hist.to_csv(histpath, sep=\"\\t\", float_format=\"%5.2f\")\n clusters = pd.DataFrame(\n {\"anchor.id\": id_list, \"count\": count_list, \"hash\": hash_list}\n )\n clusters.to_csv(summarypath, sep=\"\\t\")\n stats_dict = {\n \"in_anchor\": n_items,\n \"syn.anchors.n\": n_clusts,\n \"syn.anchors.largest\": largest_cluster,\n }\n return stats_dict","def parcel_overlap(parcellation1, parcellation2, outpath):\n p1_dat = nib.load(parcellation1).get_data()\n p2_dat = nib.load(parcellation2).get_data()\n p1regs = np.unique(p1_dat)\n p1regs = p1regs[p1regs > 0]\n p2regs = np.unique(p2_dat)\n\n p1n = get_filename(parcellation1)\n p2n = get_filename(parcellation2)\n\n overlapdat = lil_matrix((p1regs.shape[0], p2regs.shape[0]), dtype=np.float32)\n for p1idx, p1reg in enumerate(p1regs):\n p1seq = p1_dat == p1reg\n N = p1seq.sum()\n poss_regs = np.unique(p2_dat[p1seq])\n for p2idx, p2reg in enumerate(p2regs):\n if p2reg in poss_regs:\n # percent overlap is p1seq and'd with the anatomical region voxelspace, summed and normalized\n pover = np.logical_and(p1seq, p2_dat == p2reg).sum() / float(N)\n overlapdat[p1idx, p2idx] = pover\n\n outf = op.join(outpath, \"{}_{}.csv\".format(p1n, p2n))\n with open(outf, \"w\") as f:\n p2str = [\"%s\" % x for x in p2regs]\n f.write(\"p1reg,\" + \",\".join(p2str) + \"\\n\")\n for idx, p1reg in enumerate(p1regs):\n datstr = [\"%.4f\" % x for x in overlapdat[idx,].toarray()[0,]]\n f.write(str(p1reg) + \",\" + \",\".join(datstr) + \"\\n\")\n f.close()\n return","def fasta(args):\n from jcvi.formats.sizes import Sizes\n from jcvi.formats.agp import OO, build\n\n p = OptionParser(fasta.__doc__)\n opts, args = p.parse_args(args)\n\n if len(args) != 3:\n sys.exit(not p.print_help())\n\n bedfile, scffasta, pmolfasta = args\n pf = bedfile.rsplit(\".\", 1)[0]\n bed = Bed(bedfile)\n selected = select_bed(bed)\n oo = OO()\n seen = set()\n sizes = Sizes(scffasta).mapping\n agpfile = pf + \".agp\"\n agp = open(agpfile, \"w\")\n for b in selected:\n scf = range_parse(b.accn).seqid\n chr = b.seqid\n cs = (chr, scf)\n if cs not in seen:\n oo.add(chr, scf, sizes[scf], b.strand)\n seen.add(cs)\n else:\n logging.debug(\"Seen {0}, ignored.\".format(cs))\n\n oo.write_AGP(agp, gaptype=\"contig\")\n agp.close()\n build([agpfile, scffasta, pmolfasta])","def overlap(path1, path2):\n DataL1 = BedTool(path1).sort()\n DataL2 = BedTool(path2).sort()\n overlap = DataL1.intersect(DataL2, wao=True)\n Overlap_df = overlap.to_dataframe()\n Strand1 = list(Overlap_df.iloc[:, 5])\n Strand2 = list(Overlap_df.iloc[:, 11])\n p_p, m_m, p_m, m_p, same_strand, opposite_strand, convergent, divergent = orientation(Strand1, Strand2)\n return p_p, m_m, p_m, m_p, same_strand, opposite_strand, convergent, divergent","def loadFromFile():\n try:\n f1 = open( \"friendshipMap.p\", \"rb\" )\n friendship_map = pickle.load(f1)\n f1.close()\n f2 = open( \"businessReviews.p\", \"rb\" )\n business_reviews = pickle.load(f2)\n f2.close()\n f3 = open( \"degreeCentrality.p\", \"rb\" )\n degree_centrality_map = pickle.load(f3)\n f3.close()\n f4 = open( \"closenessCentrality.p\", \"rb\" )\n closeness_centrality_map = pickle.load(f4)\n f4.close()\n f5 = open( \"betweennessCentrality.p\", \"rb\" )\n betweenness_centrality_map = pickle.load(f5)\n f5.close()\n except IOError as e:\n sys.stderr.write(\"I/O error({0}): {1}\".format(e.errno, e.strerror)+'\\n')\n sys.stderr.write('Try running with -buildClean = clean!\\n')\n\n return (friendship_map, business_reviews, degree_centrality_map, closeness_centrality_map, betweenness_centrality_map, YGraph)","def _load_pascal_annotation(self, index):\n imagefile = os.path.join(self._data_path, 'Images', index + self._image_ext)\n labelfile = os.path.join(self._data_path, 'GroundTruth', index + '.txt')\n print 'Loading: image {} and label {}'.format(imagefile, labelfile)\n\n labels = np.loadtxt(labelfile) + 1\n image = cv2.imread(imagefile)\n\n gt_classes = []\n gt_boxes = []\n\n boxes, classes = self._get_boxes(image, labels)\n\n boxes = np.array(boxes)\n classes = np.array(classes)\n\n scores = np.ones(len(boxes), dtype=np.float32)\n dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32)\n\n # keep = nms(dets, 0.2)\n _, keep = non_max_suppression_fast(dets, 0.2)\n boxes = boxes[keep, :]\n classes = classes[keep]\n\n for n, (x, y, w, h) in enumerate(boxes):\n # gt_boxes.append([min(x, w), min(y, h), min(abs(w - x), w), min(abs(h - y), h)])\n gt_boxes.append([x, y, w - x, h - y])\n gt_classes.append(classes[n])\n\n overlaps = np.zeros((len(gt_boxes), len(self._classes)), dtype=np.float32)\n for n, obj in enumerate(gt_boxes):\n overlaps[n, gt_classes[n]] = 1.0\n\n overlaps = scipy.sparse.csr_matrix(overlaps)\n\n return {'boxes': np.array(gt_boxes),\n 'gt_classes': np.array(gt_classes, dtype=np.int32),\n 'gt_overlaps': overlaps,\n 'flipped': False}\n\n # def get_data_from_tag(node, tag):\n # return node.getElementsByTagName(tag)[0].childNodes[0].data\n\n # with open(filename) as f:\n # data = minidom.parseString(f.read())\n\n # objs = data.getElementsByTagName('object')\n # num_objs = len(objs)\n\n # boxes = np.zeros((num_objs, 4), dtype=np.uint16)\n # gt_classes = np.zeros((num_objs), dtype=np.int32)\n # overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32)\n\n # # Load object bounding boxes into a data frame.\n # for ix, obj in enumerate(objs):\n # # Make pixel indexes 0-based\n # x1 = float(get_data_from_tag(obj, 'xmin')) - 1\n # y1 = float(get_data_from_tag(obj, 'ymin')) - 1\n # x2 = float(get_data_from_tag(obj, 'xmax')) - 1\n # y2 = float(get_data_from_tag(obj, 'ymax')) - 1\n # cls = self._class_to_ind[str(get_data_from_tag(obj, \"name\")).lower().strip()]\n # boxes[ix, :] = [x1, y1, x2, y2]\n # gt_classes[ix] = cls\n # overlaps[ix, cls] = 1.0\n\n # overlaps = scipy.sparse.csr_matrix(overlaps)\n\n # return {'boxes': boxes,\n # 'gt_classes': gt_classes,\n # 'gt_overlaps': overlaps,\n # 'flipped': False}","def get_overlap():\n\n\tx = 382 * 2\n\ty = x\n\tz = 129 * 2 - 1\n\ttype_size = 8\n\ttab = np.empty(x * y * z)\n\tsize = 4096\n\ti = 0\n\tl = x * y * z * type_size\n\tn = 0\n\tfd = open('omeg5', 'rb')\n\twhile l - n > size:\n\t\ts = fd.read(size)\n\t\ttab[n / type_size : (n + size) / type_size] = np.fromstring(s, dtype = np.float64)\n\t\ti += 1\n\t\tn += size\n\ts = fd.read(l - n)\n\ttab[i * size / type_size:] = np.fromstring(s, dtype = np.float64)\n\tfd.close()\n\ttab = tab.reshape(x, y, z)\n\treturn (tab)","def _get_assembly_points(self, agp, weight):\n comps = set()\n prev_obj = \"\"\n seq1 = \"\"\n strand1 = \"\"\n\n # Gap info\n gap_count = 0\n prev_agp_known = None\n prev_gap_size = 0\n prev_gap_type = None\n prev_linkage = \"\"\n prev_evidence = \"\"\n\n # Iterate over the AGP file and yield assembly points\n agp_file = AGPFile(agp)\n for agp_line in agp_file.iterate_lines():\n if not agp_line.is_gap:\n # Add this component to our master list\n if agp_line.comp not in self.component_lens:\n raise RuntimeError(\"{} is in {} but not {}.\".format(agp_line.comp, agp, self.components_fasta_fname))\n comps.add(agp_line.comp)\n\n comp_len = agp_line.comp_end\n if comp_len < self.get_component_len(agp_line.comp):\n raise RuntimeError(\"only complete components can be added to the graph.\")\n\n if comp_len > self.get_component_len(agp_line.comp):\n raise RuntimeError(\"inconsistent component lengths: {} bp in {} and {} bp in {}\". format(comp_len, agp, self.get_component_len(agp_line.comp), self.components_fasta_fname))\n\n if agp_line.obj == prev_obj:\n # Check if these components are bookended (no gap in between)\n if not gap_count:\n prev_evidence = \"bookend\"\n\n # Check if two consecutive gaps preceded this component\n if gap_count > 1:\n raise ValueError(\"Consecutive gaps in the AGP file are not currently supported.\")\n\n yield AssemblyPoint(\n seq1,\n strand1,\n agp_line.comp,\n agp_line.orientation,\n weight,\n agp,\n prev_agp_known,\n prev_gap_size,\n prev_gap_type,\n prev_linkage,\n prev_evidence\n )\n\n # Set this component as the previous component\n seq1 = agp_line.comp\n strand1 = agp_line.orientation\n\n gap_count = 0\n prev_agp_known = None\n prev_gap_size = 0\n prev_gap_type = None\n prev_linkage = \"\"\n prev_evidence = \"\"\n\n else:\n seq1 = agp_line.comp\n strand1 = agp_line.orientation\n\n prev_obj = agp_line.obj\n gap_count = 0\n prev_agp_known = None\n prev_gap_size = 0\n prev_gap_type = None\n prev_linkage = \"\"\n prev_evidence = \"\"\n else:\n if agp_line.obj == prev_obj:\n gap_count += 1\n prev_agp_known = True if agp_line.comp_type == \"N\" else False\n prev_gap_size = agp_line.gap_len\n prev_gap_type = agp_line.gap_type\n prev_linkage = True if agp_line.linkage == \"yes\" else False\n prev_evidence = agp_line.linkage_evidence\n\n if comps != self.components:\n raise ValueError(\"Input AGPs do not have the same set of components.\")","def generate_gff( mapfile, funtax_orf_file ):\n annotation2assembly_map = pd.read_table(mapfile,\n names=['annotation','assembly','length'],\n index_col='annotation')\n funtax_gff = pd.read_table( funtax_orf_file.name, engine='python', encoding='ISO-8859-1', quoting=3)\n funtax_gff['seqid'] = funtax_gff.join(annotation2assembly_map, on='Contig_Name')['assembly']\n funtax_gff['source'] = 'Prodigal_v2.00'\n funtax_gff['type'] = 'CDS'\n funtax_gff['score'] = 100.0\n funtax_gff['phase'] = 0\n funtax_gff['attributes'] = funtax_gff['ORF_ID'].str.replace(r'(.*)', r'ID=\\1;')\n return funtax_gff[['seqid','source', 'type','start', 'end', 'score', 'strand','phase','attributes']]","def main():\n directed = True\n try:\n opts,args = getopt.getopt(sys.argv[1:], \"\")\n except:\n usage(sys.argv[0])\n for opt,arg in opts:\n usage(sys.argv[0])\n\n if len(args) != 5:\n usage(sys.argv[0])\n\n data_dir = args[0]\n num_samples = int(args[1])\n num_seeds = int(args[2])\n num_waves = int(args[3]) - 1 # -1 for consistency with SPNet\n outputdir = args[4]\n\n print \"directed:\", directed\n print \"number of samples:\", num_samples\n print \"number of seeds:\", num_seeds\n print \"number of waves:\", num_waves\n print \"output directory:\", outputdir\n \n if not os.path.exists(outputdir):\n os.mkdir(outputdir)\n\n sys.stdout.write('loading data from ' + data_dir + '...')\n start = time.time()\n (G, profile, colnames) = load_pokec_data(data_dir)\n print time.time() - start, 's'\n\n snap.PrintInfo(G)\n\n\n # We do not add attributes to nodes as SNAP node attribute as\n # these seem to get lost by varoius operations including subgraph\n # that we need to use, so instead maintain them just in the\n # dictionary mapping the original node ids to the attributes -\n # fortunately the original node ids are maintained by\n # GetSubGraph() so we can used these to index the profile\n # dictoinary in the subgraphs\n\n\n ## https://snap.stanford.edu/data/soc-pokec-readme.txt\n ## region:\n ## string, mostly regions in Slovakia (example: \"zilinsky kraj,\n ## kysucke nove mesto\" means county Zilina, town Kysucke Nove Mesto,\n ## Slovakia), some foreign countries (example: \"zahranicie, \n ## zahranicie - nemecko\" means foreign country Germany (nemecko)),\n ## some Czech regions (example: \"ceska republika, cz - ostravsky \n ## kraj\" means Czech Republic, county Ostrava (ostravsky kraj))\n ## We just make this a factor, looking at the output written by print\n ## below, it looks reasonable, but is is only a categorical variable\n ## allowing us to tell if two users are in the same region or not.\n ## TODO we could recode this so that we can have different variables\n ## for being in a different country, major city, etc.\n # Cannot do this:\n #profile[:][colnames['region']] = convert_to_int_cat(profile[:][colnames['region']]) # like factor in R\n # as get \"TypeError: unhashable type\" so have to do this instead:\n id_regions = [(k, p[colnames['region']]) for (k,p) in profile.iteritems()]\n id_regions_int = convert_to_int_cat([x[1] for x in id_regions])\n for i in xrange(len(id_regions)):\n profile[id_regions[i][0]][colnames['region']] = id_regions_int[i]\n\n for attr in ['region']:\n sys.stdout.write('There are %d NA for %s\\n' % ([p[colnames[attr]] for p in profile.itervalues()].count('NA'), attr))\n\n\n # get num_samples * num_seeds distinct random seed nodes (sample without replacement)\n # and convert to list of lists where each list is seed set for one sample\n allseeds = random.sample([node.GetId() for node in G.Nodes()], num_samples * num_seeds)\n seedsets = [allseeds[i:i+num_seeds] for i in range(0, len(allseeds), num_seeds)]\n\n sampledesc_filename = outputdir + os.path.sep + \"sampledesc\" + os.path.extsep + \"txt\"\n sampledesc_f = open(sampledesc_filename, 'w')\n\n for i in range(num_samples):\n sys.stdout.write( 'generating snowball sample ' + str(i+1) + '... ' )\n start = time.time()\n # have to convert seedset to TIntV for SNAP\n seedsVec = snap.TIntV()\n for nodeid in seedsets[i]:\n seedsVec.Add(nodeid)\n Gsample = snowball_sample(G, num_waves, seedsVec)\n nodelist = list() # keep this iteration in list so we always use same order in future\n zonedict = dict() # map nodeid : zone\n for node in Gsample.Nodes():\n nodelist.append(node.GetId())\n zonedict[node.GetId()] = Gsample.GetIntAttrDatN(node.GetId(), \"zone\")\n print time.time() - start, 's'\n \n snap.PrintInfo(Gsample)\n subgraph_filename = outputdir + os.path.sep + \"subgraph\" + str(i) + os.path.extsep + \"txt\"\n write_graph_file(subgraph_filename, Gsample, nodelist)\n subzone_filename = outputdir + os.path.sep + \"subzone\" + str(i) + os.path.extsep + \"txt\"\n write_zone_file(subzone_filename, Gsample, nodelist, zonedict)\n subactor_binary_filename = outputdir + os.path.sep + \"subactorbin\" + str(i) + os.path.extsep + \"txt\"\n subactor_categorical_filename = outputdir + os.path.sep + \"subactorcat\" + str(i) + os.path.extsep + \"txt\"\n subactor_continuous_filename = outputdir + os.path.sep + \"subactorcont\" + str(i) + os.path.extsep + \"txt\"\n\n write_subactors_file_binary(subactor_binary_filename, Gsample, nodelist, profile, colnames)\n write_subactors_file_categorical(subactor_categorical_filename, Gsample, nodelist, profile, colnames)\n write_subactors_file_continuous(subactor_continuous_filename, Gsample, nodelist, profile, colnames)\n\n nodeid_filename = outputdir + os.path.sep + \"subnodeid\" + str(i) + os.path.extsep + \"txt\"\n write_subgraph_nodeids(nodeid_filename, nodelist)\n \n # format of sampledesc file is:\n # N subzone_filename subgraph_filename binary_Filename cat_filename cont_filename\n sampledesc_filename = outputdir + os.path.sep + \"sampledesc\" + os.path.extsep + \"txt\"\n sampledesc_f.write(\"%d %s %s %s %s %s\\n\" % (Gsample.GetNodes(), subzone_filename,\n subgraph_filename, subactor_binary_filename,\n subactor_categorical_filename, subactor_continuous_filename))\n\n sampledesc_f.close()","def load_pfam():\n data = collections.defaultdict(list)\n ds_loader = specs.make_pfam34_loader(\n root_dir=FLAGS.data_dir, sub_dir='', extra_keys=KEYS, task=TASK)\n for split in SPLITS:\n logging.info('Loading %s Pfam-A seed 34.0 split...', split)\n split_data = collections.defaultdict(list)\n for ex in ds_loader.load(split).prefetch(tf.data.AUTOTUNE):\n split_data['id'].append(ex['id'].numpy().decode('utf-8'))\n split_data['start'].append(ex['start'].numpy())\n split_data['end'].append(ex['end'].numpy())\n split_data['seq'].append(\n vocabulary.alternative.decode(ex['sequence'].numpy()))\n for k, v in split_data.items():\n data[k].append(v)\n result = {k: sum(v, []) for k, v in data.items()}\n\n indices_from_pfam_id = collections.defaultdict(list)\n for i, pfam_id in enumerate(result['id']):\n indices_from_pfam_id[pfam_id].append(i)\n logging.info('Found %d unique IDs among %d Pfam-A seed sequences',\n len(indices_from_pfam_id), len(result['id']))\n return (result['start'], result['end'], result['seq']), indices_from_pfam_id","def main():\n filenames = sys.argv[1]\n fdir = sys.argv[2]\n filenames = filenames.split(',')\n\n # print (filenames)\n graph = PGraph(fdir, filenames, \"Multi-Source Foraging\")\n # graph = PGraph(fdir, filenames, \"Cooperative Transport\")\n # graph = PGraph(fdir, filenames, \"Nest Maintenance\")\n # graph = PGraph(\n # fdir, filenames, \"Nest Maintenance \\n with \\n Handcoded behaviors\")\n graph.gen_plot()\n\n # box = BoxGraph(fdir, filenames, \"Single-Source Foraging\")\n # box = BoxGraph(fdir, filenames, False, (-1, 100), \"Multi-Source Foraging\")\n box = BoxGraph(fdir, filenames, False, (-1, 120), \"Nest Maintenance with Handcoded behaviors\")\n # box = BoxGraph(\n # fdir, filenames, \"Nest Maintenance \\n with \\n Handcoded behaviors\")\n box.gen_plot()","def write_agp(self, agp_fn, ref_fn, add_suffix_to_unplaced=False):\n used_components = set()\n used_edges = set()\n obj_header_idx = -1\n\n agp = AGPFile(agp_fn, \"w\")\n agp.add_pragma()\n agp.add_comment(\"# AGP created by RagTag {}\".format(get_ragtag_version()))\n\n while True:\n # Find a starting node\n from_node = None\n to_node = None\n cur_ref = None\n for u, v in sorted(self.edges):\n if (u, v) not in used_edges:\n u_base = u[:-2]\n\n u_degree = 0\n if u_base + \"_b\" in self.nodes:\n u_degree += self.graph.degree[u_base + \"_b\"]\n if u_base + \"_e\" in self.nodes:\n u_degree += self.graph.degree[u_base + \"_e\"]\n\n assert u_degree in {2, 4}\n\n # Check if we have found a starting target sequence\n if u_degree == 2:\n cur_ref = u_base\n from_node = u\n to_node = v\n used_edges.add((u, v))\n used_edges.add((v, u))\n break\n\n # If we haven't found a new starting target sequence, we are done\n if from_node is None:\n break\n\n # Initialize this object\n obj_header_idx += 1\n obj_header = \"scf\" + \"{0:08}\".format(obj_header_idx)\n obj_pos = 0\n obj_pid = 1\n\n # Process the first target sequence\n cur_ref_len = self.component_lens[cur_ref]\n cur_ref_strand = \"+\"\n if from_node.endswith(\"_b\"):\n cur_ref_strand = \"-\"\n agp.add_seq_line(obj_header, obj_pos+1, obj_pos+cur_ref_len, obj_pid, \"W\", cur_ref, 1, cur_ref_len, cur_ref_strand)\n obj_pos += cur_ref_len\n obj_pid += 1\n used_components.add(cur_ref)\n\n # Process the remaining sequences.\n next_edge_exists = True\n while next_edge_exists:\n # Process the patch\n patch_aln = self.graph[from_node][to_node][\"alignment\"]\n patch_query = patch_aln.query\n patch_strand = \"+\"\n if patch_aln.strand:\n patch_strand = \"-\"\n\n patch_len = patch_aln.their_query_start - patch_aln.my_query_end\n if patch_len > 0:\n if patch_aln.is_gap:\n agp.add_gap_line(obj_header, obj_pos+1, obj_pos+patch_len, obj_pid, \"N\", patch_len, \"scaffold\", \"yes\", \"align_genus\")\n else:\n agp.add_seq_line(obj_header, obj_pos+1, obj_pos+patch_len, obj_pid, \"W\", patch_query, patch_aln.my_query_end+1, patch_aln.their_query_start, patch_strand)\n used_components.add(patch_query)\n obj_pos += patch_len\n obj_pid += 1\n\n # Next, process the reference sequence\n comp_start = min(0, patch_len)\n cur_ref = to_node[:-2]\n cur_ref_len = self.component_lens[cur_ref]\n cur_ref_strand = \"+\"\n if to_node.endswith(\"_e\"):\n cur_ref_strand = \"-\"\n agp.add_seq_line(obj_header, obj_pos+1, obj_pos+(cur_ref_len + comp_start), obj_pid, \"W\", cur_ref, 1+(-1*comp_start), cur_ref_len, cur_ref_strand)\n obj_pos += cur_ref_len + comp_start\n obj_pid += 1\n used_components.add(cur_ref)\n\n # Look for the next edge\n from_node = to_node[:-2] + \"_b\"\n if to_node.endswith(\"_b\"):\n from_node = to_node[:-2] + \"_e\"\n\n if from_node in self.graph.nodes:\n next_nodes = set(self.graph[from_node])\n assert len(next_nodes) == 1\n to_node = next_nodes.pop()\n used_edges.add((from_node, to_node))\n used_edges.add((to_node, from_node))\n else:\n next_edge_exists = False\n\n # Write unplaced reference sequences\n fai = pysam.FastaFile(ref_fn)\n all_ref_seqs = set(fai.references)\n fai.close()\n remaining_components = all_ref_seqs - used_components\n for c in sorted(remaining_components):\n agp.add_seq_line(\n c + \"_RagTag\" * add_suffix_to_unplaced,\n \"1\",\n str(self.component_lens[c]),\n \"1\",\n \"W\",\n c,\n \"1\",\n str(self.component_lens[c]),\n \"+\"\n )\n\n agp.write()","def g_n():\n for gname in os.listdir(sroot):\n if gname != 's1-league1-game1':\n continue\n if gname.startswith('s1'):\n p0 = os.path.join(sroot, gname)\n p1 = os.path.join(p0, 'commitment', 'jperret')\n p2 = os.path.join(p0, 'commitment', 'sa')\n if os.path.isdir(p1) and os.path.isdir(p2):\n for fname in os.listdir(p1):\n if fname.endswith('.aa'):\n bname = fname[:-3]\n #~ if bname == 's1-league1-game2_07':\n #~ continue\n a = ad.Annotations(os.path.join(p1, fname))\n a.load_text(os.path.join(p0, 'unannotated', bname+'.ac'))\n a.gen_full_struct()\n a.commitments = list(u for u in a.units if u.type == 'Commitment')\n a2 = ad.Annotations(os.path.join(p2, fname))\n a2.load_text(os.path.join(p0, 'unannotated', bname+'.ac'))\n a2.gen_full_struct()\n a2.commitments = list(u for u in a2.units if u.type == 'Commitment')\n yield bname, (a, a2)","def FindPeaks_graph(self):\n import string\n \n maxima = self['FP_LOC'].copy()\n maxima = num.where(maxima)\n maxima = (maxima[1],maxima[0])\n detectimg = self['FP_DETECT'].copy()\n \n id = self._getGraphId()\n root = 'FindPeaks_%s' % (id,)\n pngname = root + '.png' ; epsname = root + '.eps'\n jpgname = root + '.jpg'\n\n doStamp(detectimg,pngname,format='PNG')\n Convert(pngname,jpgname)\n \n Painted = Paint(jpgname)\n Painted.load()\n Painted.DrawCross(maxima,length=7,color='green')\n \n strpeaks = string.strip('%i'% (self['M_NPEAKS']))\n text = 'NP=%s' % strpeaks \n \n # Painted.Graffiti(text,commtextpos)\n \n Painted.save(jpgname)\n Painted.release()\n \n Convert(jpgname,epsname)\n os.system('rm %s %s' % (pngname,jpgname))\n self['figures']['FindPeaks'] = epsname\n self['figcomms']['FindPeaks'] = text","def merge_tables():\r\n filename = \"ppxf_results_best.dat\"\r\n s1 = np.genfromtxt(filename, usecols=(0,), dtype=None).tolist()\r\n sref = s1[:]\r\n sref.sort()\r\n x, y = get_positions(sref).T\r\n r = np.sqrt(x * x + y * y)\r\n pa = np.rad2deg(np.arctan2(x, y))\r\n pa[pa < 0.] += 360.\r\n data1 = np.loadtxt(filename, usecols=np.arange(1, 11))\r\n ##########################################################################\r\n # Account for difference in resolution\r\n # Not used anymore because the resolution is now matched in pPXF\r\n # fwhm_dif = (2.5 - 2.1) * c / 5500. / 2.3548\r\n # data1[:,2] = np.sqrt(data1[:,2]**2 - fwhm_dif**2)\r\n ##########################################################################\r\n data1 = match_data(s1, sref, data1)\r\n results = np.column_stack((sref, x, y, r, pa, data1))\r\n header = ['FILE', \"X[kpc]\", \"Y[kpc]\",\r\n \"R[kpc]\", \"PA\",\r\n 'V', 'dV', 'S', 'dS', 'h3', 'dh3',\r\n 'h4', 'dh4', 'chi/DOF', 'S/N']\r\n with open(outtable, \"w\") as f:\r\n for i, field in enumerate(header):\r\n print \"# {0} : {1}\\n\".format(i, field)\r\n f.write(\"# {0} : {1}\\n\".format(i, field))\r\n np.savetxt(f, results, fmt=\"%s\")\r\n return","def generate_graph_fca(organism):\n\twith open('./organisms/'+organism+'/'+'fcagraph.txt','r') as gfile:\n\t\trnamelst = [] \n\t\tenamelst = []\n\t\tclst = []\n\t\tfor line in gfile:\n\t\t\te = line.strip().split('\\t')\n\t\t\tfor rname in e[0:2]:\n\t\t\t\tif rname not in rnamelst:\n\t\t\t\t\trnamelst.append(rname)\n\t\t\tenamelst.append((e[0],e[1]))\n\t\t\tclst.append(e[2])\n\t\t\t\n\t\tG = igraph.Graph(0,directed=True)\n\t\tG.add_vertices(rnamelst)\n\t\tG.add_edges(enamelst)\n\t\tG.es['color'] = clst\n\t\n\treturn G","def write_output(pfam,\n indices_from_pfam_id,\n uniprot):\n pfam_starts, pfam_ends, pfam_sequences = pfam\n uniprot_ids, uniprot_sequences = uniprot\n\n logging.info('Writing output file %s...', FLAGS.output_file)\n\n n_pfam_entries_found = 0\n n_sequence_mismatches = 0\n n_repeats = 0\n n_start_mismatches = 0\n with tf.io.gfile.GFile(FLAGS.output_file, 'w') as f:\n f.write(','.join(OUTPUT_FIELDS) + '\\n')\n for uniprot_id, uniprot_sequence in zip(uniprot_ids, uniprot_sequences):\n for idx in indices_from_pfam_id[uniprot_id]:\n pfam_start, pfam_end = pfam_starts[idx], pfam_ends[idx]\n pfam_sequence = pfam_sequences[idx]\n\n uniprot_starts = find_all(uniprot_sequence, pfam_sequence)\n\n n_pfam_entries_found += 1\n if uniprot_starts:\n n_repeats += len(uniprot_starts) > 1\n n_start_mismatches += pfam_start not in uniprot_starts\n else:\n n_sequence_mismatches += 1\n\n pfam_id = f'{uniprot_id}/{pfam_start}-{pfam_end}'\n uniprot_starts = ';'.join([str(i) for i in uniprot_starts])\n fields = [pfam_id, uniprot_starts, uniprot_sequence]\n f.write(','.join(fields) + '\\n')\n\n logging.info('Finished writing %d entries to output file.',\n n_pfam_entries_found)\n\n logging.info('%d / %d Pfam-A seed entries have mismatching sequences.',\n n_sequence_mismatches, n_pfam_entries_found)\n logging.info('%d / %d Pfam-A seed entries have repeats.',\n n_repeats, n_pfam_entries_found)\n logging.info('%d / %d Pfam-A seed entries have mismatching starts.',\n n_start_mismatches, n_pfam_entries_found)","def overlap_generator(metric, graph):\n edges =[(edge[0], edge[1]) for edge in nx.edges(graph)]\n edges = edges + [(edge[1], edge[0]) for edge in nx.edges(graph)]\n return {edge: metric(graph, edge[0], edge[1]) for edge in tqdm(edges)}","def baselineSolutions(filename):\n \n def getOtherSaCurrentAnts( ):\n \"\"\" Retrieve ants in other science subarrays. \"\"\"\n if subarrayNo == 1:\n otherSa = Subarray.getSubarrayRef( 2 )\n otherSaAntAssignments = otherSa.getAntennaAssignments( )\n elif subarrayNo == 2:\n otherSa = Subarray.getSubarrayRef( 1 )\n otherSaAntAssignments = otherSa.getAntennaAssignments( )\n else:\n otherSa1Ants = Subarray.getSubarrayRef(1).getAntennaAssignments()\n otherSa2Ants = Subarray.getSubarrayRef(2).getAntennaAssignments()\n otherSaAntAssignments = otherSa1Ants + otherSa2Ants\n\n otherSaAnts = [ i.carmaAntennaNo for i in otherSaAntAssignments ]\n return otherSaAnts\n\n def toosmall( val ):\n if abs( val ) < 0.0001:\n return True\n else:\n return False\n\n import fileIOPython as fIOP\n\n # First determine which antennas will receive updates.\n antPosVals = fIOP.fileToTable( filename, ignoreEmpty=True, comment=\"#\" )\n antsInThisSa = currentAntennaNumbers()\n antsInOtherScienceSa = getOtherSaCurrentAnts()\n antNo = 0\n validAnts = []\n invalidAnts = []\n validAntsInOtherScienceSa = []\n validAntsNotInThisSa = []\n for pos in antPosVals:\n antNo += 1\n x,y,z = float(pos[0]), float(pos[1]), float(pos[2])\n if toosmall(x) and toosmall(y) and toosmall(z):\n invalidAnts.append( antNo )\n else:\n if antNo in antsInOtherScienceSa:\n validAntsInOtherScienceSa.append( antNo )\n if antNo not in antsInThisSa:\n validAntsNotInThisSa.append( antNo )\n validAnts.append( antNo )\n\n if len( validAntsInOtherScienceSa ) > 0:\n rfValidAntsInOtherScienceSa = helpers.formatAsRanges( validAntsInOtherScienceSa )\n error = \"\"\n if len(rfValidAntsInOtherScienceSa) > 1:\n error += \"Ants %s currently belong to other science subarrays. \"%(rfValidAntsInOtherScienceSa)\n error += \"Please remove them prior to rerunning this command.\"\n else:\n error += \"Ant %s currently belongs to another science subarray. \"%(rfValidAntsInOtherScienceSa)\n error += \"Please remove it prior to rerunning this command.\"\n printError( error )\n return\n\n \n antNo = 0\n for pos in antPosVals:\n antNo += 1\n if antNo in invalidAnts:\n continue\n x,y,z = float(pos[0]), float(pos[1]), float(pos[2])\n baseOff = s.convertBaseline( x, y, z, antNo )\n\n if ( baseOff.antNo != antNo ): # Sanity check\n raise Exception,\"Mismatched ant no.\"\n \n padOffset( round( baseOff.east, 2 ), \n round( baseOff.north, 2 ),\n round( baseOff.up, 2 ),\n antNo )\n\n s.setAntPosFilename( filename )\n\n rfValidAnts = helpers.formatAsRanges( validAnts )\n if ( rfValidAnts > 1 ):\n print \"Solutions applied for ants %s.\"%(rfValidAnts)\n else:\n print \"Solutions applied for ant %s.\"%(rfValidAnts)\n \n if len( invalidAnts ) > 0:\n rfInvalidAnts = helpers.formatAsRanges( invalidAnts )\n if ( len( rfInvalidAnts ) > 1 ):\n printWarning( \"Antpos does NOT contain solutions for ants %s.\"%(rfInvalidAnts) )\n else:\n printWarning( \"Antpos does NOT contain a solution for ant %s.\"%(rfInvalidAnts) )\n\n if len( validAntsNotInThisSa ) > 0:\n rfValidAntsNotInThisSa = helpers.formatAsRanges( validAntsNotInThisSa )\n warning = \"Solutions were applied for \"\n if len(rfValidAntsNotInThisSa) > 1:\n warning += \"ants %s which do \"%rfValidAntsNotInThisSa\n else:\n warning += \"ant %s which does \"%rfValidAntsNotInThisSa\n warning += \"not belong to this subarray. The new solutions \"\n warning += \"may not be reflected in the monitor system until these \"\n warning += \"ants are added back into a science subarray.\" \n printWarning( warning )","def getNetworksFromLoops(loops, genes, fout, pdis=2000, gap=1, cpu=1):\n ks = [key for key in loops.keys() if key in genes]\n print(\"Merging anchors and annotating loops through networks.\")\n ds = Parallel(n_jobs=cpu, backend=\"multiprocessing\")(delayed(getNet)(\n chrom,\n loops[chrom],\n genes[chrom],\n pdis=pdis,\n gap=gap,\n ) for chrom in tqdm(ks))\n anchors, anots, nets, targets = {}, {}, {}, {}\n for d in ds:\n for k, v in d[0].items():\n anchors[k] = v\n for k, v in d[1].items():\n anots[k] = v\n for k, v in d[2].items():\n nets[k] = v\n for k, v in d[3].items():\n targets[k] = v\n #output results\n #anchors\n anchors = pd.DataFrame(anchors).T\n anchors.to_csv(fout + \"_mergedAnchors.txt\", sep=\"\\t\", index_label=\"anchor\")\n with open(fout + \"_mergedAnchors.bed\", \"w\") as fo:\n for t in anchors.itertuples():\n line = [t[1], t[2], t[3], t[0]]\n fo.write(\"\\t\".join(list(map(str, line))) + \"\\n\")\n #annotations\n anots = pd.DataFrame(anots).T\n anots.to_csv(fout + \"_loop2anchors.txt\", sep=\"\\t\", index_label=\"loopId\")\n #networks\n with open(fout + \"_ep_net.sif\", \"w\") as fo:\n for s, es in nets.items():\n es = list(es)\n ta = s.split(\"|\")[-1]\n for e in es:\n tb = e.split(\"|\")[-1]\n t = [ta, tb]\n t.sort()\n t = \"-\".join(t)\n line = [s, t, e]\n fo.write(\"\\t\".join(line) + \"\\n\")\n with open(fout + \"_targets.txt\", \"w\") as fo:\n ks = list(targets.keys())\n ks.sort()\n line = [\n \"Promoter\", \"PromoterTarget\", \"directEnhancer\", \"indirectEnhancer\",\n \"directPromoter\", \"indirectPromoter\", \"directEnhancerHub\",\n \"indirectEnhancerHub\"\n ]\n fo.write(\"\\t\".join(line) + \"\\n\")\n for k in ks:\n line = [\n k, targets[k][\"targetGene\"],\n \",\".join(targets[k][\"directEnhancer\"]),\n \",\".join(targets[k][\"indirectEnhancer\"]),\n \",\".join(targets[k][\"directPromoter\"]),\n \",\".join(targets[k][\"indirectPromoter\"]),\n targets[k][\"directEnhancerHub\"],\n targets[k][\"indirectEnhancerHub\"]\n ]\n fo.write(\"\\t\".join(line) + \"\\n\")","def run(input_f, output_f):\n with open(input_f) as f:\n lines = f.readlines()\n\n # Collect the array dims\n PE_defs = []\n module_start = False\n is_PE = False \n PE_indices = []\n for line_id in range(len(lines)):\n line = lines[line_id]\n if line.find('Module Definition') != -1:\n module_start = not module_start\n if module_start:\n module_start_pos = line_id\n is_PE = False\n else:\n module_end_pos = line_id\n if is_PE:\n PE_defs.append({'def': lines[module_start_pos : module_end_pos + 1], \\\n 'pos': [module_start_pos, module_end_pos]})\n if module_start:\n #print(line_id)\n nxt_line_id = line_id + 1\n while nxt_line_id < len(lines): \n nxt_line = lines[nxt_line_id]\n if nxt_line.find('kernel void PE') != -1:\n is_PE = True\n m = re.search(r'void PE(.+?)\\(', nxt_line)\n #print(nxt_line)\n if m:\n PE_index = m.group(1).split('_')[1:]\n PE_indices.append(PE_index)\n if is_PE:\n break\n if nxt_line.find('Module Definition') != -1:\n break\n nxt_line_id += 1\n\n #print(PE_indices)\n PE_dims = [int(d) for d in PE_indices[0]]\n for ind in PE_indices:\n for dim in range(len(PE_dims)):\n PE_dims[dim] = max(PE_dims[dim], int(ind[dim]) + 1)\n #print(PE_dims)\n \n PE_lines = PE_defs[0]['def']\n # Parse the data transfer information\n data_trans_info = extract_data_trans_info(PE_lines, PE_dims) \n\n # Compose the new PE function\n PE_lines = compose_PE(data_trans_info, PE_dims, PE_defs)\n\n line_offset = 0\n for PE_def in PE_defs:\n lines = lines[:PE_def['pos'][0] - line_offset] + lines[PE_def['pos'][1] + 1 - line_offset:]\n line_offset += (PE_def['pos'][1] - PE_def['pos'][0] + 1)\n\n lines = lines + PE_lines\n\n # Modify the channels\n lines = modify_channels(lines, data_trans_info, PE_dims)\n\n with open(output_f, 'w') as f:\n for line in lines:\n f.write(line)\n # f.writelines(PE_lines)","def overlay_resources_score_motifs(motif_sites_input_file,\n motifs_overlapping_tracks_output_dir,\n chromatin_tracks_dir_path,\n chromatin_tracks_files):\n\n # for motif_sites_input_file in motif_sites_input_files:\n with open(motif_sites_input_file) as f:\n chr_n_file = f.readline().strip().split('\\t')[0].strip() + '.bed'\n # it is assumed for every motif file name there exists a matching file name in the chromatin_tracks_input_dir\n if chr_n_file in chromatin_tracks_files:\n motifs_overlapping_tracks_file = motifs_overlapping_tracks_output_dir + '/' + '.'.join(\n motif_sites_input_file.split('/')[-1].split('.')[0:-1]) + '_overlapping_tracks' + '.bed7'\n motifs_overlapping_tracks_file_tmp = motifs_overlapping_tracks_file + '_tmp'\n # create or overwrite output files\n if not os.path.exists(motifs_overlapping_tracks_file):\n \n motif_sites_input_file_sorted = motif_sites_input_file + '_sorted'\n chromatin_tracks_input_file = chromatin_tracks_dir_path +'/'+ chr_n_file\n chromatin_tracks_input_file_sorted = chromatin_tracks_input_file + '_sorted'\n \n print(\"intersecting: \" + motif_sites_input_file + ' and ' + chromatin_tracks_input_file)\n \n os.system(\"\"\"sort -k1,1 -k2,2n -k3,3n {} > {}\"\"\".format(motif_sites_input_file, motif_sites_input_file_sorted))\n os.system(\"\"\"sort -k1,1 -k2,2n -k3,3n {} > {}\"\"\".format(chromatin_tracks_input_file, chromatin_tracks_input_file_sorted))\n \n\n motif_sites_file_obj = BedTool(motif_sites_input_file_sorted)\n motif_sites_file_obj.map(BedTool(chromatin_tracks_input_file_sorted), c=4, o=['collapse']).saveas(motifs_overlapping_tracks_file_tmp)\n \n with open(motifs_overlapping_tracks_file_tmp, 'r') as infile, open(motifs_overlapping_tracks_file,\n 'w') as outfile:\n line = infile.readline()\n while line:\n\n sline = line.split('\\t')\n if len(sline) > 6:\n if sline[7] != '.' and sline[7] != \".\\n\":\n my_list = sline[7].split(',')\n cell_assay_values_dict_ChromHMM = {}\n cell_assay_values_dict_cCRE = {}\n cell_assay_values_dict_IndexDHS = {}\n cell_assay_values_dict_RegElem = {}\n cell_assay_values_dict_DNaseq = {}\n elem_list = []\n for elem in my_list:\n # TODO: check if statement below\n if elem.__contains__('#'):\n cell_value = elem.split('#')[0]\n assay_value = elem.split('#')[1]\n if len(elem.split('#')) > 2:\n state_value = elem.split('#')[2].rstrip(\"\\n\")\n\n if assay_value == \"ChromHMM\":\n if cell_value not in list(cell_assay_values_dict_ChromHMM.keys()):\n cell_assay_values_dict_ChromHMM[cell_value] = []\n cell_assay_values_dict_ChromHMM[cell_value].append(state_value)\n\n elif assay_value == \"cCRE\":\n if cell_value not in list(cell_assay_values_dict_cCRE.keys()):\n cell_assay_values_dict_cCRE[cell_value] = []\n cell_assay_values_dict_cCRE[cell_value].append(state_value)\n\n elif assay_value == \"IndexDHS\":\n if cell_value not in list(cell_assay_values_dict_IndexDHS.keys()):\n cell_assay_values_dict_IndexDHS[cell_value] = []\n cell_assay_values_dict_IndexDHS[cell_value].append(state_value)\n\n elif assay_value == \"RegElem\":\n if cell_value not in list(cell_assay_values_dict_RegElem.keys()):\n cell_assay_values_dict_RegElem[cell_value] = []\n cell_assay_values_dict_RegElem[cell_value].append(state_value)\n\n elif assay_value == \"DNase-seq\":\n if cell_value not in list(cell_assay_values_dict_DNaseq.keys()):\n cell_assay_values_dict_DNaseq[cell_value] = []\n cell_assay_values_dict_DNaseq[cell_value].append(float(state_value))\n\n else:\n elem_list.append(elem.rstrip(\"\\n\"))\n\n for cell in cell_assay_values_dict_ChromHMM:\n elem_list.append(cell + \"#ChromHMM#\" +\n Counter(cell_assay_values_dict_ChromHMM[cell]).most_common(1)[0][\n 0])\n\n for cell in list(cell_assay_values_dict_cCRE.keys()):\n elem_list.append(\n cell + \"#cCRE#\" + Counter(cell_assay_values_dict_cCRE[cell]).most_common(1)[0][\n 0])\n\n for cell in list(cell_assay_values_dict_IndexDHS.keys()):\n elem_list.append(cell + \"#IndexDHS#\" +\n Counter(cell_assay_values_dict_IndexDHS[cell]).most_common(1)[0][\n 0])\n\n for cell in list(cell_assay_values_dict_RegElem.keys()):\n elem_list.append(cell + \"#RegElem#\" +\n Counter(cell_assay_values_dict_RegElem[cell]).most_common(1)[0][0])\n\n for cell in list(cell_assay_values_dict_DNaseq.keys()):\n elem_list.append(\n cell + \"#DNase-seq#\" + str(max(cell_assay_values_dict_DNaseq[cell])))\n\n outfile.write('\\t'.join(sline[0:7]) + '\\t' + ','.join(elem_list) + '\\n')\n\n line = infile.readline()\n\n os.remove(motifs_overlapping_tracks_file_tmp)\n os.remove(motif_sites_input_file_sorted)\n os.remove(chromatin_tracks_input_file_sorted)\n\n print(\"Finished intersecting: \" + motif_sites_input_file + ' and ' + chromatin_tracks_input_file)\n else:\n print(\"Use existing data files in \" + motifs_overlapping_tracks_file)\n else:\n print(\"Specified chromatin track file \" + chr_n_file + \" cannot be found and will be ignored.\")\n return None\n cleanup()\n return motifs_overlapping_tracks_file","def dpf(self):\n inigen = IniGen()\n fields = algorithm_fields.algorithms['dpf']\n\n output_uuid_map = {}\n\n # set up global parameters\n algorithm_path = fields['path']\n enabled = \"True\"\n inigen.emit_global(algorithm_path, enabled)\n\n for i in xrange(1,4):\n label = \"DPF{0}\".format(str(i))\n lAng_label = 'L{0}ANG'.format(str(i))\n cAng_label = 'C{0}ANG'.format(str(i))\n distillate_label = get_distillate_label([lAng_label, cAng_label])\n\n # header\n inigen.emit_run_header(label, CHUNKING, MINTIME, MAXTIME)\n\n # body\n dep_lAng_label = lAng_label\n dep_lAng_name = fields['deps'][0]\n dep_lAng_uuid = self.uuid_map[lAng_label]\n dep_cAng_label = cAng_label\n dep_cAng_name = fields['deps'][1]\n dep_cAng_uuid = self.uuid_map[cAng_label]\n deps = [[dep_lAng_label, dep_lAng_name, dep_lAng_uuid],\n [dep_cAng_label, dep_cAng_name, dep_cAng_uuid]]\n\n param_section_name = fields['params'][0]\n param_section_value = \"Production/{0}/{1}/{2}\".format(self.location, self.name, distillate_label)\n param_name_name = fields['params'][1]\n param_name_value = \"DPF\"\n params = [[param_section_name, param_section_value], [param_name_name, param_name_value]]\n\n outputs = fields['outputs']\n\n emitted = inigen.emit_run_body(deps, params, outputs)\n\n output_uuid_map[label] = emitted[-2][-36:]\n\n filename = \"{0}/DPF_{1}.ini\".format(self.dirname, self.name)\n inigen.generate_file(filename)\n return output_uuid_map","def draw_graph(self, fpath):\n import networkx as nx\n G = self.to_networkx()\n A = nx.nx_agraph.to_agraph(G)\n\n for proc in self.procs.values():\n nbunch = [proc.name]\n nbunch += [iport.absname() for iport in proc.iports.values()]\n nbunch += [oport.absname() for oport in proc.oports.values()]\n A.add_subgraph(\n nbunch, name='cluster_' + proc.name,\n color='lightgray', style='filled', fillcolor='lightgray')\n # color=lightgray;style=filled;fillcolor=lightgray;\n A.layout(prog='dot')\n A.draw(fpath)","def parsing(pfam_file):\n pfam_file = open(pfam_file)\n outfile = open(\"parsed_out_pfam.txt\", \"w\")\n pfam_dict = {}\n counter_proteins = 0\n for line in pfam_file:\n if not line.startswith(\"#\"):\n columns = line.strip()\n columns = columns.split()\n if columns[2] not in pfam_dict:\n pfam_dict[columns[2]] = columns[2],columns[0], columns[4]\n counter_proteins += 1\n line = \"%-20s: %-20s %-20s \\n\" %(columns[2], columns[0], columns[4])\n outfile.write(line)\n pfam_file.close()\n print counter_proteins\n return None","def sixteen_graphs(the_dir):\n # TODO change to deprecation warning\n warnings.warn(\"Does not call sv_pipeline functoins correctly\", DeprecationWarning)\n\n plb.rcParams['figure.figsize'] = 30, 30\n plt.clf()\n plt.figure(1)\n\n # should look like: read_data/all_files/chr4_124,017,492_124,029,032_merged.txt\n merged_files = glob.glob(the_dir + '*merged.txt')\n print(\"Running for {} regions\".format(len(merged_files)))\n for merged_filename in merged_files:\n # get filenames\n prefix = merged_filename[len(the_dir):-11]\n fasta_filename = the_dir + prefix + \".fa\"\n bed_filename = the_dir + prefix + \"-refcoords.bed\"\n print('Using ' + prefix)\n\n for min_matching_length in range(100, 1700, 100):\n print(min_matching_length)\n # used for ground truth\n preset, postset, spanset, gapset = get_read_classifications(prefix,\\\n bed_filename, merged_filename=merged_filename)\n # Generate and prune graph\n graph = generate_graph(prefix, fasta_filename, min_matching_length)\n graph = nx_helpers.remove_nodes(graph, preset)\n graph = nx_helpers.remove_nodes(graph, postset)\n\n # Plot the graph\n plt.subplot(4, 4, min_matching_length/100)\n communities = nx_helpers.get_communities(graph)\n graph, communities = drop_small_communities(graph, communities)\n node_colors = node_community_colors(graph, communities)\n pos = nx.spring_layout(graph)\n title = \"Chr {0};\\n L={1}; NumCom={2}\\nComQual = {3}, MapQual={4}\"\\\n .format(prefix, min_matching_length, len(communities),\\\n community_quality(communities, spanset, gapset),\\\n mapping_quality(graph, spanset, gapset))\n nx.draw(graph, node_color=node_colors, node_size=100, pos=pos)\n plt.title(title)\n plt.savefig(\"figs/\" + prefix + '-16-communities.pdf')\n plt.clf()","def rpfp(self):\n inigen = IniGen()\n fields = algorithm_fields.algorithms['rpfp']\n\n output_uuid_map = {}\n\n # set up global parameters\n algorithm_path = fields['path']\n enabled = \"True\"\n inigen.emit_global(algorithm_path, enabled)\n\n for i in xrange(1,4):\n label = \"RPFP{0}\".format(str(i))\n distillate_label = \"L{0}-E_C{1}\".format(str(i),str(i))\n lAng_label = 'L{0}ANG'.format(str(i))\n cAng_label = 'C{0}ANG'.format(str(i))\n lMag_label = 'C{0}MAG'.format(str(i))\n cMag_label = 'C{0}MAG'.format(str(i))\n distillate_label = get_distillate_label([lAng_label, cAng_label, lMag_label, cMag_label])\n\n # header\n inigen.emit_run_header(label, CHUNKING, MINTIME, MAXTIME)\n\n # body\n dep_lAng_label = lAng_label\n dep_lAng_name = fields['deps'][0]\n dep_lAng_uuid = self.uuid_map[lAng_label]\n dep_cAng_label = cAng_label\n dep_cAng_name = fields['deps'][1]\n dep_cAng_uuid = self.uuid_map[cAng_label]\n dep_lMag_label = lMag_label\n dep_lMag_name = fields['deps'][2]\n dep_lMag_uuid = self.uuid_map[lMag_label]\n dep_cMag_label = cMag_label\n dep_cMag_name = fields['deps'][3]\n dep_cMag_uuid = self.uuid_map[cMag_label]\n \n deps = [[dep_lAng_label, dep_lAng_name, dep_lAng_uuid],\n [dep_lMag_label, dep_lMag_name, dep_lMag_uuid],\n [dep_cAng_label, dep_cAng_name, dep_cAng_uuid],\n [dep_cMag_label, dep_cMag_name, dep_cMag_uuid]]\n\n param_section_name = fields['params'][0]\n param_section_value = \"Production/{0}/{1}/{2}\".format(self.location, self.name, distillate_label)\n param_name_name = fields['params'][1]\n param_name_value = \"RPFP\"\n params = [[param_section_name, param_section_value], [param_name_name, param_name_value]]\n\n outputs = fields['outputs']\n\n emitted = inigen.emit_run_body(deps, params, outputs)\n\n output_uuid_map['REAC_PWR{0}'.format(i)] = emitted[-3][-36:]\n output_uuid_map['FUND_PWR{0}'.format(i)] = emitted[-2][-36:]\n\n filename = \"{0}/RPFP_{1}.ini\".format(self.dirname, self.name)\n inigen.generate_file(filename)\n return output_uuid_map","def load_pascal_annotation(filename):\n tree = ET.parse(filename)\n objs = tree.findall('object')[0]\n\n num_objs = len(objs)\n\n boxes = np.zeros((num_objs, 4), dtype=np.uint16)\n gt_classes = np.zeros((num_objs), dtype=np.int32)\n num_classes = 3\n classes = ('__background__', # always index 0\n 'mine',\n 'nonmine')\n class_to_ind = dict(zip(classes, range(num_classes)))\n\n overlaps = np.zeros((num_objs, num_classes), dtype=np.float32)\n # \"Seg\" area for pascal is just the box area\n seg_areas = np.zeros((num_objs), dtype=np.float32)\n ishards = np.zeros((num_objs), dtype=np.int32)\n\n # Load object bounding boxes into a data frame.\n for ix, obj in enumerate(objs):\n bbox = obj.find('bndbox')\n\n # Make pixel indexes 0-based\n x1 = float(bbox.find('xmin').text) - 1\n y1 = float(bbox.find('ymin').text) - 1\n x2 = float(bbox.find('xmax').text) - 1\n y2 = float(bbox.find('ymax').text) - 1\n\n diffc = obj.find('difficult')\n difficult = 0 if diffc == None else int(diffc.text)\n ishards[ix] = difficult\n\n cls = class_to_ind[obj.find('name').text.lower().strip()]\n boxes[ix, :] = [x1, y1, x2, y2]\n gt_classes[ix] = cls\n overlaps[ix, cls] = 1.0\n seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1)\n\n overlaps = scipy.sparse.csr_matrix(overlaps)\n\n return {'boxes': boxes,\n 'gt_classes': gt_classes,\n 'gt_ishard': ishards,\n 'gt_overlaps': overlaps,\n 'flipped': False,\n 'seg_areas': seg_areas}","def generatePositivePHASLoci(options,whole_mapped_data,phase,cycle):\n out_filename=options.output_directory_per_run+\"/\"+options.input_filename+\"_\"+str(phase)+\"_\"+str(cycle)+\".positive_phase_loci\"\n fhw=open(out_filename,\"w\")\n for chromosome in sorted(whole_mapped_data):\n filename=options.output_directory_per_run+\"/\"+options.input_filename+\"_\"+str(phase)+\"_\"+str(cycle)+\"_\"+chromosome+\".regionsOfInterest.concentrated\"\n try:\n fhr=open(filename,\"r\")\n except FileNotFoundError:\n continue\n flag_reg=1000\n window_start,window_end=0,0\n for line in fhr:\n \"\"\"pvalue=float(line.strip().split()[-1])\n if pvalue>=options.pvalue_cutoff:continue\"\"\"\n register,start,end=map(int,line.strip().split()[:3])\n if register==flag_reg:\n if window_end>start:\n window_end=end\n else:\n fhw.write(chromosome+\"\\t\"+str(window_start)+\"\\t\"+str(window_end)+\"\\n\")\n window_start=start\n window_end=end\n else:\n if flag_reg!=1000:\n fhw.write(chromosome+\"\\t\"+str(window_start)+\"\\t\"+str(window_end)+\"\\n\")\n window_start=start\n window_end=end\n flag_reg=register\n fhr.close()\n fhw.write(chromosome+\"\\t\"+str(window_start)+\"\\t\"+str(window_end)+\"\\n\")\n fhw.close()","def comparison():\n path = \"Data/data_fronts/\"\n path1 = \"Results/labelled_images1010/fronts/\"\n\n #computes the areas for the first frame in order to normalize the other areas\n pol0 = pd.DataFrame(pd.read_csv(path1 + \"fronts_labelled.m.0.png.txt\",sep =' '))\n #makes an object polygon in order to compute the area\n pol0 = np.array(pol0)\n pol0 = Polygon(pol0)\n\n polsx = pd.DataFrame(pd.read_csv(path + \"Sham_8-2-18_Field 5_1_sx.txt\",sep ='\\t'))\n polsx.columns = [\"y\",\"x\"]\n poldx = pd.DataFrame(pd.read_csv(path + \"Sham_8-2-18_Field 5_1_dx.txt\",sep ='\\t'))\n poldx.columns = [\"y\",\"x\"]\n #makes an object polygon in order to compute the area\n polsx = polsx.append(poldx)\n polsx = np.array(polsx)\n pol1 = Polygon(polsx)\n\n\n areas = []\n areas_hand = []\n #computes the areas for all the frames\n for i in range(42):\n pol = pd.DataFrame(pd.read_csv(path1 + \"fronts_labelled.m.\"+str(i)+\".png.txt\",sep =' '))\n pol = np.array(pol)\n pol = Polygon(pol)\n #normalize the areas with respect to the area of the first frame\n areas.append(pol.area/pol0.area)\n\n polsx = pd.DataFrame(pd.read_csv(path + \"Sham_8-2-18_Field 5_\"+str(i+1)+\"_sx.txt\",sep ='\\t'))\n polsx.columns = [\"y\",\"x\"]\n poldx = pd.DataFrame(pd.read_csv(path + \"Sham_8-2-18_Field 5_\"+str(i+1)+\"_dx.txt\",sep ='\\t'))\n poldx.columns = [\"y\",\"x\"]\n if poldx[\"x\"][0]>100:\n poldx = poldx.reindex(index=poldx.index[::-1])\n if polsx[\"x\"][0]<100:\n polsx = polsx.reindex(index=polsx.index[::-1])\n polsx = polsx.append(poldx)\n polsx = np.array(polsx)\n\n pol2 = Polygon(polsx)\n #normalize the areas with respect to the area of the first frame\n areas_hand.append(pol2.area/pol1.area)\n #returns the two arrays with the normalized areas\n return np.array(areas) , np.array(areas_hand)","def _parse_pbf(self):\n # todo pyrosm bounding_box is inefficient, first extract bbox from pbf using pyosmium\n osm = pyrosm.OSM(filepath=self._pbf, bounding_box=self._bbox)\n osm.keep_node_info = True\n logging.info(\"Parsing OSM ways and nodes from pbf file\")\n ways = osm.get_network(self._profile)\n\n all_nodes = osm._nodes_gdf # todo this has all the attributes but goes out of memory easily\n way_nodes_ids = ways.nodes.explode().unique().tolist()\n nodes = all_nodes.loc[all_nodes.id.isin(way_nodes_ids)]\n\n def clip_way(way):\n clipped_way = way.copy()\n clipped_way.nodes = clipped_way.nodes[:len(way.geometry.coords.xy[0])-1]\n return clipped_way\n\n broken_ways = ways.nodes.apply(lambda x: not all(n in nodes.id.to_list() for n in x))\n for ix, way in ways.loc[broken_ways].iterrows():\n ways.loc[ix] = clip_way(way)\n\n # all_nodes = osm._node_coordinates\n # way_nodes = {id: all_nodes[id] for id in way_nodes_ids if id in all_nodes.keys()}\n # nodes = pd.DataFrame.from_dict(way_nodes, orient='index', columns=['longitude', 'latitude'])\n # nodes['id'] = nodes.index\n\n # ways_nodes_found = ways.nodes.apply(lambda x: all(n in nodes.id.to_list() for n in x))\n # nodes = pd.DataFrame(columns=['id', 'latitude', 'longitude'])\n # for ix, way in ways.iterrows():\n # way_nodes = pd.DataFrame(columns=['id', 'latitude', 'longitude'])\n # try:\n # way_nodes.id = way.nodes\n # way_nodes.latitude = way.geometry.coords.xy[1]\n # way_nodes.longitude = way.geometry.coords.xy[0]\n # except:\n # pass\n # nodes = nodes.append(way_nodes, ignore_index=True)\n\n logging.info(\"Done parsing pbf file\")\n return nodes, ways","def gaps(args):\n from jcvi.formats.sizes import agp\n from jcvi.formats.agp import mask, build\n\n p = OptionParser(gaps.__doc__)\n p.add_option(\n \"--split\", default=False, action=\"store_true\", help=\"Generate .split.fasta\"\n )\n p.set_mingap(default=100)\n p.set_cpus()\n opts, args = p.parse_args(args)\n\n if len(args) != 1:\n sys.exit(not p.print_help())\n\n (inputfasta,) = args\n mingap = opts.mingap\n split = opts.split\n prefix = inputfasta.rsplit(\".\", 1)[0]\n bedfile = prefix + \".gaps.bed\"\n\n if need_update(inputfasta, bedfile):\n write_gaps_bed(inputfasta, prefix, mingap, opts.cpus)\n\n if split:\n splitfile = prefix + \".split.fasta\"\n oagpfile = prefix + \".splitobject.agp\"\n cagpfile = prefix + \".splitcomponent.agp\"\n\n if need_update((inputfasta, bedfile), splitfile):\n\n sizesagpfile = agp([inputfasta])\n\n maskedagpfile = mask([sizesagpfile, bedfile, \"--splitobject\"])\n shutil.move(maskedagpfile, oagpfile)\n logging.debug(\"AGP file written to `{0}`.\".format(oagpfile))\n\n maskedagpfile = mask([sizesagpfile, bedfile, \"--splitcomponent\"])\n shutil.move(maskedagpfile, cagpfile)\n logging.debug(\"AGP file written to `{0}`.\".format(cagpfile))\n\n build([oagpfile, inputfasta, splitfile])\n cleanup(sizesagpfile)\n\n return splitfile, oagpfile, cagpfile","def fetchGraph_adjList(fName):\n G = Graph()\n adjList = dict()\n myOpen = gzip.open if fName.split(\".\")[-1]==\"gz\" else open\n with myOpen(fName,'r') as f:\n for line in f:\n c = line.split()\n if c[0]=='p':\n G.v = int(c[2])\n G.e = int(c[3])\n eType = int(c[4])\n\n elif c[0]=='e':\n vi = int(c[1])\n vj = int(c[2])\n\n if vi not in adjList: adjList[vi]=[]\n adjList[vi].append(vj)\n\n if eType==0:\n if vj not in adjList: adjList[vj]=[]\n adjList[vj].append(vi)\n\n G.adjList = adjList\n return G","def load_pascal_annotation(index):\n filename = os.path.join(root_path, 'Annotations', index + '.xml')\n # print(filename)\n tree = ET.parse(filename)\n objs = tree.findall('object')\n num_objs = len(objs)\n\n boxes = np.zeros((num_objs, 4), dtype=np.uint16)\n rboxes = np.zeros((num_objs, 5), dtype=np.uint16)\n quadboxes = np.zeros((num_objs, 8), dtype=np.uint16)\n gt_classes = np.zeros((num_objs), dtype=np.int32)\n # regression for rotate box (x0,y0,x1,y1,h)\n gt_rbox = np.zeros((num_objs, 5), dtype=np.int32)\n overlaps = np.zeros((num_objs, num_classes), dtype=np.float32)\n # \"Seg\" area for pascal is just the box area\n seg_areas = np.zeros((num_objs), dtype=np.float32)\n\n # Load object bounding boxes into a data frame.\n for ix, obj in enumerate(objs):\n bbox = obj.find('bndbox')\n # Make pixel indexes 0-based\n x1 = float(bbox.find('xmin').text)\n y1 = float(bbox.find('ymin').text)\n x2 = float(bbox.find('xmax').text)\n y2 = float(bbox.find('ymax').text) \n \n class_to_ind = dict(list(zip(classes, list(range(num_classes)))))\n cls = class_to_ind[obj.find('name').text.lower().strip()]\n boxes[ix, :] = [x1, y1, x2, y2]\n \n # add quadbox object information\n quadbox = obj.find('quadbox')\n quadx0 = float(quadbox.find('quadx0').text)\n quady0 = float(quadbox.find('quady0').text)\n quadx1 = float(quadbox.find('quadx1').text)\n quady1 = float(quadbox.find('quady1').text)\n quadx2 = float(quadbox.find('quadx2').text)\n quady2 = float(quadbox.find('quady2').text)\n quadx3 = float(quadbox.find('quadx3').text)\n quady3 = float(quadbox.find('quady3').text)\n quadboxes[ix, :] = [quadx0,quady0,quadx1,quady1,quadx2,quady2,quadx3,quady3]\n\n # add rbox object information\n rbox = obj.find('rbox')\n rx0 = float(rbox.find('x0').text)\n ry0 = float(rbox.find('y0').text)\n rx1 = float(rbox.find('x1').text)\n ry1 = float(rbox.find('y1').text)\n rh = float(rbox.find('h').text)\n rboxes[ix, :] = [rx0,ry0,rx1,ry1,rh]\n \n gt_classes[ix] = cls\n overlaps[ix, cls] = 1.0\n seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1)\n overlaps = scipy.sparse.csr_matrix(overlaps)\n # return gt_roidb\n return {'boxes': boxes,\n 'rboxes': rboxes,\n 'quadboxes': quadboxes,\n 'gt_classes': gt_classes,\n 'gt_overlaps': overlaps,\n 'flipped': False,\n 'seg_areas': seg_areas}","def main():\r\n\timport sys\r\n\r\n\tlistofSequences = FastAreader(sys.stdin).readFasta() \r\n\tPAMSequences = PAMfinder(listofSequences).classController() # Calls on controller class to return desired models.\r\n\tf = open('Guide Sequences.txt','w') \r\n\tfor i in range(len(PAMSequences[0])):\r\n\t\tf.write(PAMSequences[0][i]) # Prints the header sequence into the file.\r\n\t\tf.write('\\n') \r\n\t\tprint(PAMSequences[0][i]) \r\n\t\tfor j in range(len(PAMSequences[1][i])): \r\n\t\t\tif j == 0: \r\n\t\t\t\tf.write(\"Forward Strand PAM Sites:\") \r\n\t\t\t\tf.write('\\n')\r\n\t\t\t\tprint(\"Forward Strand PAM Sites:\") \r\n\t\t\tprint(PAMSequences[1][i][j]) # Prints the forward sequences\r\n\t\t\ty = str(PAMSequences[1][i][j]) # Changes from int to string characters.\r\n\t\t\tx = ''.join(y) # Joining all the string values so we can print to file.\r\n\t\t\tf.write(x) # Write the joined forward sequences to the file.\r\n\t\t\tf.write('\\n')\r\n\t\tfor k in range(len(PAMSequences[2][i])): # For reverse sequences, and follows same logic as forward. \r\n\t\t\tif k == 0:\r\n\t\t\t\tf.write(\"Reverse Strand PAM Sites (in reference to the Top Strand Position):\")\r\n\t\t\t\tf.write('\\n')\r\n\t\t\t\tprint(\"Reverse Strand PAM Sites (in reference to the Top Strand Position):\")\r\n\t\t\tprint(PAMSequences[2][i][k]) # Prints the reverse sequences with the corresponding positions. \r\n\t\t\ta = str(PAMSequences[2][i][k]) # Changes the integer to string characters, allowing for the values to join.\r\n\t\t\tb = ''.join(a)\r\n\t\t\tf.write(b) # Write all of the reverse sequences onto the text file with their positions. \r\n\t\t\tf.write('\\n')\r\n\tf.close() # Close the file.\r","def get_ngram_overlap(ngram_file_a, ngram_file_b, freq_bound, corpus_name_a, corpus_name_b, target_dir):\n print('Comparing n-gram inventories ...')\n\n # Read in corpus files\n df_ngram_counts_a = pd.read_table(ngram_file_a, header=None, names=['Rank', 'Ngram', 'Counts'],\n skip_blank_lines=True)\n df_ngram_counts_b = pd.read_table(ngram_file_b, header=None, names=['Rank', 'Ngram', 'Counts'],\n skip_blank_lines=True)\n # Build n-gram inventories\n ngram_list_a = [df_ngram_counts_a.iloc[row_id, 1] for row_id in range(len(df_ngram_counts_a))]\n ngram_list_b = [df_ngram_counts_b.iloc[row_id, 1] for row_id in range(len(df_ngram_counts_b))]\n bound_list_a = [df_ngram_counts_a.iloc[row_id, 1] for row_id in range(len(df_ngram_counts_a))\n if int(df_ngram_counts_a.iloc[row_id, 2]) >= freq_bound]\n bound_list_b = [df_ngram_counts_b.iloc[row_id, 1] for row_id in range(len(df_ngram_counts_b))\n if int(df_ngram_counts_b.iloc[row_id, 2]) >= freq_bound]\n\n # Calculate total unique n-gram overlap\n total_shared_ngrams = [ngram for ngram in ngram_list_a if ngram in ngram_list_b]\n total_shared_count = len(total_shared_ngrams)\n total_unique_ngrams_a = len(ngram_list_a) - total_shared_count\n total_unique_ngrams_b = len(ngram_list_b) - total_shared_count\n\n # Calculate frequency-bounded unique ngram overlap\n bound_shared_ngrams = [ngram for ngram in bound_list_a if ngram in bound_list_b]\n bound_shared_count = len(bound_shared_ngrams)\n bound_unique_ngrams_a = len(bound_list_a) - bound_shared_count\n bound_unique_ngrams_b = len(bound_list_b) - bound_shared_count\n\n # Calculate overlap fractions\n total_overlap_fraction_a = total_shared_count / len(ngram_list_a)\n bound_overlap_fraction_a = bound_shared_count / len(bound_list_a)\n total_overlap_fraction_b = total_shared_count / len(ngram_list_b)\n bound_overlap_fraction_b = bound_shared_count / len(bound_list_b)\n\n # Write collected information to file\n gram_size = len(total_shared_ngrams[0].split())\n overlap_log_path = os.path.join(target_dir, '{:s}_{:s}_{:d}-gram_overlap.txt'\n .format(corpus_name_a, corpus_name_b, gram_size))\n with codecs.open(overlap_log_path, 'w', encoding='utf8') as overlap_file:\n overlap_file.write('Compared corpora: {:s} and {:s}\\n'.format(corpus_name_a, corpus_name_b))\n overlap_file.write('=' * 10 + '\\n')\n overlap_file.write('Total {:s} vocabulary size: {:d} entries\\n'.format(corpus_name_a, len(ngram_list_a)))\n overlap_file.write('Total {:s} vocabulary size: {:d} entries\\n'.format(corpus_name_b, len(ngram_list_b)))\n overlap_file.write('Bound {:s} vocabulary size for bound {:d}: {:d} entries\\n'\n .format(corpus_name_a, freq_bound, len(bound_list_a)))\n overlap_file.write('Bound fraction for {:s} corpus: {:.4f} entries\\n'\n .format(corpus_name_a, len(bound_list_a) / len(ngram_list_a)))\n overlap_file.write('Bound {:s} vocabulary for bound {:d} size: {:d} entries\\n'\n .format(corpus_name_b, freq_bound, len(bound_list_b)))\n overlap_file.write('Bound fraction for {:s} corpus: {:.4f} entries\\n'\n .format(corpus_name_b, len(bound_list_b) / len(ngram_list_b)))\n overlap_file.write('=' * 10 + '\\n')\n overlap_file.write('Total overlap size: {:d} entries\\n'.format(total_shared_count))\n overlap_file.write('Total unique {:d}-grams for corpus {:s}: {:d}\\n'\n .format(gram_size, corpus_name_a, total_unique_ngrams_a))\n overlap_file.write('Total unique {:d}-grams for corpus {:s}: {:d}\\n'\n .format(gram_size, corpus_name_b, total_unique_ngrams_b))\n overlap_file.write('Frequency-bound overlap size for bound {:d}: {:d} entries\\n'.\n format(freq_bound, bound_shared_count))\n overlap_file.write('Frequency-bound unique {:d}-grams for corpus {:s}: {:d}\\n'\n .format(gram_size, corpus_name_a, bound_unique_ngrams_a))\n overlap_file.write('Frequency-bound unique {:d}-grams for corpus {:s}: {:d}\\n'\n .format(gram_size, corpus_name_b, bound_unique_ngrams_b))\n overlap_file.write('=' * 10 + '\\n')\n overlap_file.write('Total overlap fraction for corpus {:s}: {:.4f}\\n'\n .format(corpus_name_a, total_overlap_fraction_a))\n overlap_file.write('Frequency-bound overlap fraction for corpus {:s} for bound {:d}: {:.4f}\\n'\n .format(corpus_name_a, freq_bound, bound_overlap_fraction_a))\n overlap_file.write('=' * 10 + '\\n')\n overlap_file.write('Total overlap fraction for corpus {:s}: {:.4f}\\n'\n .format(corpus_name_b, total_overlap_fraction_b))\n overlap_file.write('Frequency-bound overlap fraction for corpus {:s} for bound {:d}: {:.4f}\\n'\n .format(corpus_name_b, freq_bound, bound_overlap_fraction_b))\n print('Done.')","def Overtopping(self):\n\n #sort files\n leftOverTop = list()\n RightOverTop = list()\n # get names of files that has _left or _right at its end\n All1DFiles = os.listdir(self.OneDResultPath)\n for i in range(len(All1DFiles)) :\n if All1DFiles[i].endswith(self.leftOvertopping_Suffix):\n leftOverTop.append(All1DFiles[i])\n if All1DFiles[i].endswith(self.RightOvertopping_Suffix):\n RightOverTop.append(All1DFiles[i])\n\n # two dictionaries for overtopping left and right\n OverToppingSubsLeft = dict()\n OverToppingSubsRight = dict()\n # the _left and _right files has all the overtopping discharge\n # but sometimes the sum of all the overtopping is less than a threshold specified\n # and then the 2D algorithm does not run so these cross sections you will not find\n # any inundation beside it in the maps but you will find it in the _left or _right maps\n\n # for each sub-basin that has overtopping from the left dike\n for i in range(len(leftOverTop)):\n\n try:\n # open the file (if there is no column sthe file is empty)\n data = pd.read_csv(self.OneDResultPath + leftOverTop[i],header =None,delimiter = r'\\s+')\n # add the sub basin to the overtopping dictionary of sub-basins\n OverToppingSubsLeft[leftOverTop[i][:-len(self.leftOvertopping_Suffix)]] = dict()\n except:\n continue\n # get the XS that overtopping happened from\n XSs = list(set(data.loc[:,2]))\n # for each XS get the days\n for j in range(len(XSs)):\n OverToppingSubsLeft[leftOverTop[i][:-len(self.leftOvertopping_Suffix)]][XSs[j]] = list(set(data[0][data[2] == XSs[j]].tolist()))\n\n for i in range(len(RightOverTop)):\n\n try:\n # open the file\n data = pd.read_csv(self.OneDResultPath + RightOverTop[i],header =None,delimiter = r'\\s+')\n # add the sub basin to the overtopping dictionary of sub-basins\n OverToppingSubsRight[RightOverTop[i][:-len(self.RightOvertopping_Suffix)]] = dict()\n except :\n continue\n # get the XS that overtopping happened from\n XSs = list(set(data.loc[:,2]))\n # for each XS get the days\n for j in range(len(XSs)):\n OverToppingSubsRight[RightOverTop[i][:-len(self.RightOvertopping_Suffix)]][XSs[j]] = list(set(data[0][data[2] == XSs[j]].tolist()))\n\n self.OverToppingSubsLeft = OverToppingSubsLeft\n self.OverToppingSubsRight = OverToppingSubsRight","def _get_full_graph(self):","def create_all(graph,first_last_fn):\n trip_id = 1\n line_num = 0\n num_trips = 0\n trip_id2model = {}\n #paths = {}\n p = Path(trip_id,graph,line_num=line_num)\n trip_id2model[trip_id] = p.edges\n num_trips += 1\n #paths[trip_id] = p\n while p.next_line != len(graph.lines):#file_length:\n graph.trip_id2line_num[trip_id] = line_num\n line_num = p.next_line\n trip_id = normalize_simple(graph.lines[line_num])[0]\n #trip_id = dg.normalize(lines[line_num])[0]\n p = Path(trip_id,graph,line_num=line_num)\n trip_id2model[trip_id] = p.edges\n num_trips += 1\n # paths[trip_id] = p\n graph.trip_id2line_num[trip_id] = line_num\n graph.num_trips = num_trips\n\n\n with open(first_last_fn,'wb') as output:\n pickle.dump(graph.first_last2trip_ids,output)\n\n with open('pickles/trip_id2model.pickle','wb') as output:\n pickle.dump(trip_id2model,output)\n #return paths","def main():\n\n args = get_args()\n \n patient_years_dict = {}\n\n isolates_to_seq = []\n\n with open(args.input_file, \"r\") as infile1:\n for line in infile1:\n if not line.startswith(\"PID\"):\n line_elements = line.strip().split(\"\\t\")\n patient_anumber = line_elements[1].split(\"_\")[0]\n patient_year = line_elements[2].split(\"-\")[0]\n if patient_anumber not in patient_years_dict:\n patient_years_dict[patient_anumber] = {patient_year:[line]}\n else:\n if patient_year not in patient_years_dict[patient_anumber]:\n patient_years_dict[patient_anumber][patient_year] = [line]\n if line not in patient_years_dict[patient_anumber][patient_year]:\n patient_years_dict[patient_anumber][patient_year].append(line)\n \n for patient in patient_years_dict:\n for year in patient_years_dict[patient]:\n print(f\"Checking patient {patient} and year {year}...\")\n wgs_codes = []\n pfge_codes = []\n isolate_dates = []\n isolate_lines = []\n for isolate in patient_years_dict[patient][year]:\n isolate_elements = isolate.strip().split(\"\\t\")\n wgs_codes.append(int(isolate_elements[5]))\n pfge_codes.append(int(isolate_elements[4]))\n isolate_dates.append(isolate_elements[2])\n isolate_lines.append(isolate)\n \n if any(wgs_codes):\n print(f\"\\tWGS present, moving on to next year/patient.\")\n continue\n else:\n print(f\"\\tWGS missing, checking PFGE...\\n\\tPFGE presence/absence codes for {year} are: {pfge_codes}\")\n if any(pfge_codes):\n pfge_index = pfge_codes.index(1)\n isolate_to_seq = isolate_dates[pfge_index]\n isolate_line_to_seq = isolate_lines[pfge_index]\n print(f\"\\tPFGE present, selecting first isolate with PFGE to sequence...\\n\\tIsolate to sequence is ---> {isolate_to_seq} <--- out of possible isolates {isolate_dates}.\")\n isolates_to_seq.append(isolate_line_to_seq)\n else:\n print(f\"\\tPFGE missing...\\n\\tSelecting 1st available isolate for sequencing ---> {isolate_dates[0]} <--- out of available isolates {isolate_dates}.\")\n isolates_to_seq.append(isolate_lines[0])\n\n header = f\"PID\\tADATE\\tCULTDAT\\tvalues\\tPFGE_Isolates\\tSequenced_Isolates\\n\" \n to_write = \"\".join(isolates_to_seq)\n with open(args.output_file, \"w\") as outfile1:\n outfile1.write(header + to_write)","async def get_graph_for_file(\n file_name: str,\n score: int = 0,\n par_length: int = 0,\n co_occ: int = 0,\n target_collection: List[str] = Query([]),\n):\n database = get_db()\n query_graph_result = database.AQLQuery(\n query=main_queries.QUERY_GRAPH_VIEW,\n batchSize=15000,\n bindVars={\n \"filename\": file_name,\n \"score\": score,\n \"parlength\": par_length,\n \"coocc\": co_occ,\n \"targetcollection\": target_collection,\n },\n )\n collection_keys = []\n total_collection_dict = {}\n total_histogram_dict = {}\n\n # extract a dictionary of collection numbers and number of parallels for each\n for parallel in query_graph_result.result:\n count_this_parallel = parallel[\"parlength\"]\n target_filename = re.sub(\"_[0-9][0-9][0-9]\",\"\",parallel[\"textname\"])\n if target_filename in total_histogram_dict.keys():\n total_histogram_dict[target_filename] += count_this_parallel\n else:\n total_histogram_dict[target_filename] = count_this_parallel\n\n collection_key = re.search(COLLECTION_PATTERN, target_filename)\n\n if not collection_key:\n continue\n\n collection = collection_key.group()\n if collection not in total_collection_dict.keys():\n total_collection_dict[collection] = count_this_parallel\n else:\n total_collection_dict[collection] += count_this_parallel\n if collection not in collection_keys:\n collection_keys.append(collection)\n\n # find the proper full names vor each collection\n collections = database.AQLQuery(\n query=menu_queries.QUERY_COLLECTION_NAMES,\n bindVars={\n \"collections\": collection_keys,\n \"language\": get_language_from_filename(file_name),\n },\n )\n\n collections_with_full_name = {}\n for collection_result in collections.result[0]:\n collections_with_full_name.update(collection_result)\n\n parallel_graph_name_list = {}\n for key in total_collection_dict:\n parallel_graph_name_list.update(\n {key + \" \" + collections_with_full_name[key]: total_collection_dict[key]}\n )\n\n unsorted_graphdata_list = list(map(list, parallel_graph_name_list.items()))\n\n histogram_data = []\n for name, count in total_histogram_dict.items():\n displayname = name\n query_displayname = database.AQLQuery(\n query=main_queries.QUERY_DISPLAYNAME,\n bindVars={\n \"filename\": name\n },\n rawResults=True\n )\n displayname_results = query_displayname.result\n if displayname_results:\n displayname = displayname_results[0][0] + ' (' + displayname_results[0][1] + ')'\n\n histogram_data.append([displayname, count])\n\n # returns a list of the data as needed by Google Graphs\n return {\n \"piegraphdata\": sorted(\n unsorted_graphdata_list, reverse=True, key=lambda x: x[1]\n ),\n \"histogramgraphdata\": sorted(histogram_data, reverse=True, key=lambda x: x[1]),\n }","def createOutput():\n\n firstPeriod = True\n # get edge No\n edgesNo = 0\n edgesSet = set()\n for timestep, taxiList in vtypeDict.iteritems():\n for tup in taxiList:\n edgesSet.add(tup[1])\n edgesNo = len(edgesSet)\n\n outputFile = open(path.FQoutput, 'w')\n outputFile.write('<?xml version=\"1.0\"?>\\n')\n outputFile.write('<paramEffects aggregationInterval=\"%d\" vehicles=\"%d\" edges=\"%d\">\\n' % (\n aggInterval, vehSum, edgesNo))\n for period, quota, vtypeDictR, taxiSum in generatePeriodQuotaSets(True):\n if quota is None:\n if not firstPeriod:\n outputFile.write(\"\\t</periods>\\n\")\n else:\n firstPeriod = False\n outputFile.write('\\t<periods period=\"%d\">\\n' % (period))\n else:\n simpleTaxiMeanVList = [0, 1]\n simpleEdgeMeanVList = [0, 1]\n drivenEdgesSet = set()\n\n if len(vtypeDictR) == 0: # if the processed FCD returns no Values\n print(\"noData p\", period, \" q\", quota)\n drivenEdgesSet.add(0)\n else: # create mean from all taxi speed values\n for timestep, taxiList in vtypeDictR.iteritems():\n for tup in taxiList: # all elements in this timestep\n simpleTaxiMeanVList[0] += tup[2]\n simpleTaxiMeanVList[1] += 1\n drivenEdgesSet.add(tup[1])\n # create mean from all edge speed values which are driven by the\n # chosen taxis\n drivenEdgesList = list(drivenEdgesSet)\n drivenEdgesList.sort()\n # print \"dataSets \",simpleTaxiMeanVList[1]\n\n # --edgeDump-- #\n \"\"\"\n for i in edgeDumpDict.keys(): #all intervals\n for edge,v in edgeDumpDict[i]:\n if BinarySearch.isElmInList(drivenEdgesList,edge):\n simpleEdgeMeanVList[0]+=v\n simpleEdgeMeanVList[1]+=1\n \"\"\"\n # --vtype-- #\n\n for timestep, taxiList in vtypeDict.iteritems():\n for tup in taxiList:\n if BinarySearch.isElmInList(drivenEdgesList, tup[1]):\n simpleEdgeMeanVList[0] += tup[2]\n simpleEdgeMeanVList[1] += 1\n\n # calc values for output\n detectedEdges = len(drivenEdgesSet)\n relDetectedEdges = detectedEdges * 100.0 / edgesNo\n vSim = simpleEdgeMeanVList[0] / simpleEdgeMeanVList[1]\n vSimFCD = simpleTaxiMeanVList[0] / simpleTaxiMeanVList[1]\n vAbsDiff = vSimFCD - vSim\n if vSim != 0:\n vRelDiff = vAbsDiff / vSim * 100\n else:\n vRelDiff = 100\n if vRelDiff < -40:\n vRelDiff = -35\n\n outputFile.write('\\t\\t<values taxiQuota=\"%f\" taxis=\"%d\" simMeanSpeed=\"%f\" simFcdMeanSpeed=\"%f\" ' % (\n quota, taxiSum, vSim, vSimFCD,))\n outputFile.write('detectedEdges=\"%d\" notDetectedEdges=\"%d\" ' % (\n detectedEdges, edgesNo - detectedEdges))\n outputFile.write('absSpeedDiff=\"%f\" relSpeedDiff=\"%f\" relDetectedEdges=\"%f\" relNotDetectedEdges=\"%f\"/>\\n' %\n (vAbsDiff, vRelDiff, relDetectedEdges, 100 - relDetectedEdges))\n outputFile.write(\"\\t</periods>\\n</paramEffects>\")\n outputFile.close()","def load_pascal_annotation(index, pascal_root):\n classes = ('__background__', # always index 0\n 'aeroplane', 'bicycle', 'bird', 'boat',\n 'bottle', 'bus', 'car', 'cat', 'chair',\n 'cow', 'diningtable', 'dog', 'horse',\n 'motorbike', 'person', 'pottedplant',\n 'sheep', 'sofa', 'train', 'tvmonitor')\n class_to_ind = dict(zip(classes, xrange(21)))\n\n filename = osp.join(pascal_root, 'Annotations', index + '.xml')\n # print 'Loading: {}'.format(filename)\n\n def get_data_from_tag(node, tag):\n return node.getElementsByTagName(tag)[0].childNodes[0].data\n\n with open(filename) as f:\n data = minidom.parseString(f.read())\n\n objs = data.getElementsByTagName('object')\n num_objs = len(objs)\n\n boxes = np.zeros((num_objs, 4), dtype=np.uint16)\n gt_classes = np.zeros((num_objs), dtype=np.int32)\n overlaps = np.zeros((num_objs, 21), dtype=np.float32)\n\n # Load object bounding boxes into a data frame.\n for ix, obj in enumerate(objs):\n # Make pixel indexes 0-based\n x1 = float(get_data_from_tag(obj, 'xmin')) - 1\n y1 = float(get_data_from_tag(obj, 'ymin')) - 1\n x2 = float(get_data_from_tag(obj, 'xmax')) - 1\n y2 = float(get_data_from_tag(obj, 'ymax')) - 1\n cls = class_to_ind[\n str(get_data_from_tag(obj, \"name\")).lower().strip()]\n boxes[ix, :] = [x1, y1, x2, y2]\n gt_classes[ix] = cls\n overlaps[ix, cls] = 1.0\n\n overlaps = scipy.sparse.csr_matrix(overlaps)\n\n return {'boxes': boxes,\n 'gt_classes': gt_classes,\n 'gt_overlaps': overlaps,\n 'flipped': False,\n 'index': index}","def gen_graph(self):","def project(database, frequent_nodes, minsup, freq_labels, length, H, L, L_hat, n_graphs, n_pos, n_neg, pos_index, class_index, neg_index, graph_id_to_list_id, mapper, labels, model, constraints):\n\t# Declaring globals for recursive pattern mining\n\tglobal __subgraph_count\n\tglobal __positive_index\n\tglobal __n_pos\n\tglobal __n_graphs\n\tglobal __dataset\n\tglobal __pattern_set\n\tglobal __cl_constraints\n\tglobal __ml_constraints\n\tglobal __negative_index\n\tglobal __graph_id_to_list_id\n\tglobal __min_threshold\n\tglobal __min_index\n\n\t__graph_id_to_list_id = graph_id_to_list_id\n\t__ml_constraints = [c for c in constraints[0] if c[0] < n_graphs and c[1] < n_graphs]\n\t__cl_constraints = [c for c in constraints[1] if c[0] < n_graphs and c[1] < n_graphs]\n\t__positive_index = pos_index\n\t__negative_index = neg_index\n\t__n_pos = n_pos\n\t__n_graphs = n_graphs\n\t__H = H\n\t__L = L\n\t__L_hat = L_hat\n\t__dataset = []\n\t__pattern_set = []\n\t__subgraph_count = 0\n\t__min_threshold = sys.maxint\n\t__min_index = 0\n\tdfs_codes = []\n\tprojection_map = {}\n\tfeature_selection_model = None\n\n\tif model == \"top-k\":\n\t\tfeature_selection_model = TopKModel()\n\telif model == \"greedy\":\n\t\tfeature_selection_model = GreedyModel(__n_graphs, __positive_index)\n\telif model == \"gMGFL\":\n\t\tfeature_selection_model = GMGFLModel(__L, __L_hat)\n\telif model == \"gMLC\":\n\t\tfeature_selection_model = GMLCModel(__L, __H)\n\telse:\n\t\tlogging.log(logging.ERROR, \"Model %s not recognized\" %(model))\n\t\texit(0)\n\n\t# TODO: evaluate\n\t\"\"\"\n\tOnly constraints for current binary split\n\tfor con in __ml_constraints:\n\t\tif not labels[con[0]][class_index] == 1 and not labels[con[1]][class_index] == 1:\n\t\t\t__ml_constraints.remove((con[0], con[1]))\n\n\tfor con in __cl_constraints:\n\t\tif not labels[con[0]][class_index] == 1 and not labels[con[1]][class_index] == 1:\n\t\t\t__cl_constraints.remove((con[0], con[1]))\n\t\"\"\"\n\n\t# clean constraints from not applicable ones\n\tfor i, con in enumerate(__ml_constraints):\n\t\tif con[0] >= n_graphs or con[1] >= n_graphs:\n\t\t\t__ml_constraints.remove(con)\n\t\t\tcontinue\n\t\ttry:\n\t\t\tlist_id1 = __graph_id_to_list_id[con[0]]\n\t\t\tlist_id2 = __graph_id_to_list_id[con[1]]\n\t\t\t__ml_constraints[i] = (list_id1, list_id2)\n\t\texcept KeyError:\n\t\t\t__ml_constraints.remove(con)\n\n\tfor i, con in enumerate(__cl_constraints):\n\t\tif con[0] >= n_graphs or con[1] >= n_graphs:\n\t\t\t__cl_constraints.remove(con)\n\t\t\tcontinue\n\t\ttry:\n\t\t\tlist_id1 = __graph_id_to_list_id[con[0]]\n\t\t\tlist_id2 = __graph_id_to_list_id[con[1]]\n\t\t\t__cl_constraints[i] = (list_id1, list_id2)\n\t\texcept KeyError:\n\t\t\t__cl_constraints.remove(con)\n\n\t# TODO: Is this needed?\n\tfor l in frequent_nodes:\n\t\t__subgraph_count += 1\t\t\n\n\tfor g in database:\n\t\tfor n in g.nodes:\n\t\t\tedges = get_forward_init(n, g)\n\t\t\tif len(edges) > 0:\n\t\t\t\t for e in edges:\n\t\t\t\t\tnf = g.nodes[e.fromn]\n\t\t\t\t\tnt = g.nodes[e.to]\n\t\t\t\t\tdfsc = dfs_code(0,1,nf.label,e.label,nt.label)\n\t\t\t\t\tpdfs = pre_dfs(g.id,e,None)\n\t\t\t\t\t# because this is a root --> append the predecesspr dfs code (graph id, edge, None)\n\t\t\t\t\tif dfsc in projection_map:\n\t\t\t\t\t\tprojection_map[dfsc].append(pdfs)\n\t\t\t\t\telse:\n\t\t\t\t\t\tprojection_map[dfsc] = [pdfs,]\n\n\t# Start Subgraph Mining\n\tthreshold = 0 \t# initial threshold for first length 1 subgraph\n\tfor pm in reversed(sorted(projection_map, key=dfs_code_compare)):\t# sorted by highest fromnode label (order is important)\n\t\tif len(projection_map[pm]) < minsup: # number of graphs, this initial pattern occurs (root patterns)\n\t\t\tcontinue\n\t\tdfs_codes.append(dfs_code(0,1,pm[2],pm[3],pm[4]))\t# initial pattern for this projection is always local 0, 1)\n\t\tdfs_codes = mine_subgraph(database, projection_map[pm],\n\t\t\t\t\t\t\tdfs_codes, minsup, length, mapper, feature_selection_model)\n\t\tdfs_codes.pop()\t# dfs_codes is a list of all projections for this initial pattern\n\treturn __dataset, __pattern_set","def load_sequences_pynast(file_pynast_alignment, file_otumap,\n frg_start, frg_stop, frg_expected_length,\n verbose=True, out=sys.stdout, onlyrepr=False,\n nomerge=False):\n # load the full pynast GreenGenes alignment with\n # sequences=1261500 and position=7682\n # deprecation warning from skbio\n ali = TabularMSA.read(file_pynast_alignment,\n format='fasta', constructor=DNA)\n\n # set index of alignment to sequence IDs\n ali.index = [seq.metadata['id'] for seq in ali]\n\n if verbose:\n out.write(\"% 8i rows and %i cols in alignment '%s'\\n\" % (\n ali.shape[0],\n ali.shape[1],\n file_pynast_alignment.split('/')[-1]))\n\n # load OTU map\n (otumap, seqinfo) = read_otumap(file_otumap)\n # all representative seq IDs\n seqids_to_use = list(otumap.index)\n if onlyrepr is False:\n # all non-representative seq IDs\n seqids_to_use += [seqid for otu in otumap.values for seqid in otu]\n if verbose:\n out.write(\"% 8i sequences in OTU map '%s'\\n\" % (\n len(seqids_to_use),\n file_otumap.split('/')[-1]))\n\n # subset the alignment to those sequences that are selected from OTU map\n ali_otumap = ali.loc[set(seqids_to_use) & set(ali.index)]\n if verbose:\n out.write((\"% 8i sequences selected from OTU map and alignment. \"\n \"Surprise: %i sequences of OTU map are NOT in \"\n \"alignment!\\n\") % (\n ali_otumap.shape[0],\n len(seqids_to_use) - ali_otumap.shape[0]))\n # To my surprise, not all OTU-IDs of the SEPP reference tree\n # (same with the 99 tree of GreenGenes) are in the pynast alignment.\n # Daniel says: \"PyNAST fails on some sequences. The tree is constructed\n # from the ssu-align alignment (based on infernal), but that alignment\n # method is lossy so it is not suitable for extracting variable\n # regions\" Therefore, I exclude those 1031 OTU-IDs from further\n # investigation\n\n # trim alignment down to fragment columns\n ali_fragments = ali_otumap.iloc(axis='position')[frg_start:frg_stop]\n if verbose:\n out.write((\"%i -> %i cols: trimming alignment to fragment \"\n \"coordinates\\n\") % (\n ali_otumap.shape[1],\n ali_fragments.shape[1]))\n\n # ungap alignment rows\n fragments = []\n num_frags_toolong = 0\n for fragment_gapped in ali_fragments:\n fragment = fragment_gapped.degap()\n if len(fragment) >= frg_expected_length:\n if len(fragment) > frg_expected_length:\n num_frags_toolong += 1\n fragments.append({\n 'sequence': str(fragment)[:frg_expected_length],\n 'seqID': fragment_gapped.metadata['id'],\n 'otuID': seqinfo.loc[fragment_gapped.metadata['id']]})\n if verbose:\n out.write((\"% 8i fragments with ungapped length >= %int. \"\n \"Surprise: %i fragments are too short and %i fragments \"\n \"where too long (and have been trimmed)!\\n\") % (\n len(fragments),\n frg_expected_length,\n ali_fragments.shape[0] - len(fragments), num_frags_toolong))\n # Another surprise is that the trimmed, degapped sequences from pynast\n # alignment do NOT all have length 150nt. Following is a length\n # distribution plot. I checked with Daniel and we decided to omit\n # frgaments smaller than 150nt and timm all other to 150nt.\n\n # convert fragments into Pandas.DataFrame\n fragments = pd.DataFrame(fragments)\n if verbose:\n out.write('% 8i fragments remaining.\\n' % fragments.shape[0])\n if nomerge:\n return fragments\n # group fragments by sequence and list true OTUids\n unique_fragments = fragments.groupby('sequence').agg(lambda x:\n list(x.values))\n if verbose:\n out.write('% 8i unique fragments after collapsing by sequence.\\n' %\n unique_fragments.shape[0])\n\n frgs = []\n for i, (sequence, row) in enumerate(unique_fragments.iterrows()):\n frgs.append({'sequence': sequence,\n 'seqIDs': row['seqID'],\n 'otuIDs': sorted(list(set(row['otuID']))),\n 'num_non-representative-seqs':\n len(set(row['seqID']) - set(row['otuID'])),\n 'only_repr._sequences':\n len(set(row['seqID']) - set(row['otuID'])) == 0,\n 'num_pointmutations': 0})\n\n return frgs","def convert_pc2ply(anno_path, save_path):\n data_list = []\n\n for f in glob.glob(join(anno_path, '*.txt')):\n class_name = os.path.basename(f).split('_')[0]\n if class_name not in gt_class: # note: in some room there is 'staris' class..\n class_name = 'clutter'\n pc = pd.read_csv(f, header=None, delim_whitespace=True).values\n labels = np.ones((pc.shape[0], 1)) * gt_class2label[class_name]\n data_list.append(np.concatenate([pc, labels], 1)) # Nx7\n\n pc_label = np.concatenate(data_list, 0)\n xyz_min = np.amin(pc_label, axis=0)[0:3]\n pc_label[:, 0:3] -= xyz_min\n\n xyz = pc_label[:, :3].astype(np.float32)\n colors = pc_label[:, 3:6].astype(np.uint8)\n labels = pc_label[:, 6].astype(np.uint8)\n write_ply(save_path, (xyz, colors, labels), ['x', 'y', 'z', 'red', 'green', 'blue', 'class'])\n\n # save sub_cloud and KDTree file\n sub_xyz, sub_colors, sub_labels = DP.grid_sub_sampling(xyz, colors, labels, sub_grid_size)\n sub_colors = sub_colors / 255.0\n sub_ply_file = join(sub_pc_folder, save_path.split('/')[-1][:-4] + '.ply')\n write_ply(sub_ply_file, [sub_xyz, sub_colors, sub_labels], ['x', 'y', 'z', 'red', 'green', 'blue', 'class'])\n\n search_tree = KDTree(sub_xyz)\n kd_tree_file = join(sub_pc_folder, str(save_path.split('/')[-1][:-4]) + '_KDTree.pkl')\n with open(kd_tree_file, 'wb') as f:\n pickle.dump(search_tree, f)\n\n proj_idx = np.squeeze(search_tree.query(xyz, return_distance=False))\n proj_idx = proj_idx.astype(np.int32)\n proj_save = join(sub_pc_folder, str(save_path.split('/')[-1][:-4]) + '_proj.pkl')\n with open(proj_save, 'wb') as f:\n pickle.dump([proj_idx, labels], f)","def mergePed(bnlist=[],faff=[],ofaff=[],newbasename='newped',fo=0):\r\n lcdmap = getLCD(bnlist) # list of chr,offset,rs for all snp common to all files\r\n print 'got %d lcd snps-%s' % (len(lcdmap),lcdmap[:5])\r\n cfped = []\r\n coped = []\r\n cfgeno = []\r\n cogeno = []\r\n allrsa = {}\r\n ignorers = {}\r\n for i,basename in enumerate(bnlist):\r\n fped,oped,fgeno,ogeno,trsadict = subsetPed(basename,lcdmap,faff[i],ofaff[i])\r\n print '%s gave %d fgeno' % (basename,len(fgeno))\r\n for rs in trsadict.keys():\r\n tk = trsadict[rs].keys()\r\n if len(tk) > 2:\r\n print 'for %s, rs %s has alleles %s' % (basename, rs, trsadict[rs])\r\n if not allrsa.get(rs,None):\r\n allrsa[rs] = {}\r\n for a in tk:\r\n if not allrsa[rs].get(a,None):\r\n allrsa[rs][a] = trsadict[rs][a]\r\n else:\r\n allrsa[rs][a] += trsadict[rs][a]\r\n tk = allrsa[rs].keys()\r\n if len(tk) > 2 and not ignorers.get(rs,None): # new\r\n #print 'After merge basename %s, rs %s has alleles %s' % (basename, rs,allrsa[rs])\r\n ignorers[rs] = rs\r\n cfped += fped\r\n coped += oped\r\n cfgeno += fgeno\r\n cogeno += ogeno\r\n print 'after merge all have %d fgeno and %d ogeno' % (len(cfgeno),len(cogeno))\r\n # now have offspring and founder rows in lcdmap order\r\n # write map file\r\n print '### found %d markers > 2 alleles' % (len(ignorers.keys()))\r\n keepmarkers = [x for x in range(len(lcdmap)) if not ignorers.get(lcdmap[x][2],None)]\r\n newmap = ['\\t'.join((lcdmap[x][0],lcdmap[x][2],'0','%d' % lcdmap[x][1])) for x in keepmarkers] # chrom,offset,rs\r\n f = file('%s.map' % newbasename,'w')\r\n f.write('%s\\n' % '\\n'.join(newmap))\r\n f.close()\r\n for i,geno in enumerate(cfgeno): # convert each array into a list and keep the good markers\r\n gs = ''.join(['%s%s' % (geno[2*x],geno[2*x + 1]) for x in keepmarkers])\r\n g = array.array('c',gs) # good ones\r\n cfgeno[i] = g # replace\r\n print 'cfgeno converted'\r\n if not fo: # not founders only - note arrays are not lists!\r\n cfped += copy.copy(coped) #\r\n del coped\r\n for i,geno in enumerate(cogeno): # convert each array into a list and keep the good markers\r\n gs = ''.join(['%s%s' % (geno[2*x],geno[2*x + 1]) for x in keepmarkers])\r\n g = array.array('c',gs) # good ones\r\n cfgeno.append(g) # extend founders\r\n del cogeno\r\n print 'after if not fo now have %d cfgeno' % (len(cfgeno))\r\n f = file('%s.ped' % newbasename,'w')\r\n for n,ped in enumerate(cfped):\r\n l = ' '.join(ped + list(cfgeno[n]))\r\n if n % 100 == 0 and n > 0:\r\n print 'writing line %d' % n\r\n f.write(l)\r\n f.write('\\n')\r\n f.close()\r\n print 'wrote %d map rows and %d ped rows to %s' % (len(newmap),len(cfped),newbasename)","def ParseGraph(filename):\n vertices = []\n edges = set([])\n\n for l in open(filename):\n fields = [int(f) for f in l.split()]\n vertex = fields.pop(0)\n incident = [tuple(sorted([vertex, f])) for f in fields]\n vertices.append(vertex)\n edges.update(incident)\n\n return vertices, list(edges)","def _load_pascal_annotation(self, index):\n filename = os.path.join(self.cfg.file_path, 'Annotations', index + '.xml')\n if not os.path.exists(filename):\n print('Can not find annotations')\n return {'boxes' : np.zeros((1, 4), dtype=np.uint16),\n 'gt_classes': np.zeros(1, dtype=np.int32),\n 'gt_overlaps': scipy.sparse.csr_matrix(\n np.zeros((1, self.num_classes), dtype=np.float32)),\n 'flipped' : False,\n 'seg_areas' : None}\n tree = ET.parse(filename)\n objs = tree.findall('object')\n if not self.cfg.data_set_cfg['use_diff']:\n # Exclude the samples labeled as difficult\n non_diff_objs = [\n obj for obj in objs if int(obj.find('difficult').text) == 0]\n # if len(non_diff_objs) != len(objs):\n # print 'Removed {} difficult objects'.format(\n # len(objs) - len(non_diff_objs))\n objs = non_diff_objs\n num_objs = len(objs)\n\n boxes = np.zeros((num_objs, 4), dtype=np.uint16)\n gt_classes = np.zeros((num_objs), dtype=np.int32)\n overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32)\n # \"Seg\" area for pascal is just the box area\n seg_areas = np.zeros((num_objs), dtype=np.float32)\n\n # Load object bounding boxes into a data frame.\n for ix, obj in enumerate(objs):\n bbox = obj.find('bndbox')\n # Make pixel indexes 0-based\n x1 = float(bbox.find('xmin').text) - 1\n y1 = float(bbox.find('ymin').text) - 1\n x2 = float(bbox.find('xmax').text) - 1\n y2 = float(bbox.find('ymax').text) - 1\n cls = self._class_to_ind[obj.find('name').text.lower().strip()]\n boxes[ix, :] = [x1, y1, x2, y2]\n gt_classes[ix] = cls\n overlaps[ix, cls] = 1.0\n seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1)\n\n overlaps = scipy.sparse.csr_matrix(overlaps)\n\n return {'boxes' : boxes,\n 'gt_classes': gt_classes,\n 'gt_overlaps' : overlaps,\n 'flipped' : False,\n 'seg_areas' : seg_areas}","def agp_prune(self, from_file: str, to_file: str, used: set = None):\n # reomve used component\n # and GAPS as they are not used by 'ensembl-analysis/scripts/assembly_loading/load_agp.pl'\n os.makedirs(dirname(to_file), exist_ok=True)\n open_ = self.is_gz(from_file) and gzip.open or open\n if used is None:\n cmd = r'''{_cat} {_file} > {_out}'''.format(\n _cat = self.is_gz(from_file) and \"zcat\" or \"cat\",\n _file = from_file,\n _out = to_file\n )\n print(\"running %s\" % (cmd), file = sys.stderr)\n sp.run(cmd, shell=True, check=True)\n return 1\n writes = 0\n with open_(from_file, \"r\") as src:\n with open(to_file, \"w\") as dst:\n for line in src:\n fields = line.strip().split(\"\\t\")\n ( asm_id, asm_start, asm_end, asm_part,\n type_,\n cmp_id, cmp_start, cmp_end, cmp_strand\n ) = fields\n if type_ in \"NU\" or cmp_id in used:\n continue\n used.add(cmp_id)\n print(line.strip(), file = dst)\n writes += 1\n return writes","def extract_edges(file_name, file_name_out, nodes):\n with open(file_name, 'r') as file_in, open(file_name_out, 'w') as file_out:\n print('source,target,label', file=file_out)\n\n # init the previous entry for comparison\n last_player, last_team, last_league, last_season = (None, None,\n None, None)\n this_team = []\n for line in file_in:\n player, team, league, season = parse_line(line)\n player = format_name(player)\n if last_player is None or (team == last_team and\n league == last_league and season == last_season):\n this_team.append(player)\n else: # new player\n # process existing team\n process_team(this_team, nodes, file_out)\n\n # reset and add first player of new team\n this_team = []\n this_team.append(player)\n\n last_player, last_team, last_league, last_season = (player,\n team, league, season)\n\n # there is one last team to process\n process_team(this_team, nodes, file_out)","def load_graph(self, graph: nx.Graph) -> None:\n\n self.pos = dict()\n self.polygons = dict()\n districts = len(self.data[\"features\"])\n\n for i in range(districts):\n\n # Get shape information from file\n nodes = self.data[\"features\"][i][\"geometry\"][\"coordinates\"][0]\n area_id = self.data[\"features\"][i][\"properties\"][\"MOVEMENT_ID\"].zfill(4) \n\n # Convert list of lists to list of tuples (lng, lat)\n nodes = list(map(tuple, nodes)) \n\n # Prune nodes and remove last node (duplicate of first node)\n nodes = list(map(lambda x: (x[:2]), nodes)) \n nodes = nodes[:-1]\n\n # Add polygon with node-coordinates to dict\n self.polygons[area_id] = nodes\n\n for j,k in enumerate(nodes):\n self.pos[area_id+\"-\"+str(j)]=(k[0], k[1])\n\n for j in range(len(nodes)-1):\n graph.add_edge(\n u_of_edge=area_id+\"-\"+str(j), \n v_of_edge=area_id+\"-\"+str(j+1))\n\n graph.add_edge(\n u_of_edge=area_id+\"-\"+str(len(nodes)-1), \n v_of_edge=area_id+\"-\"+str(0))\n \n self.graph = graph","def subsetPed(basename=\"\",lcdmap = [],faff='1', ofaff='2'):\r\n mf = file('%s.map' % basename,'r').readlines()\r\n lmap = [x.strip().split() for x in mf]\r\n rscols = {} # lookup marker table\r\n colrs = [] # lookup rs from column\r\n for i,m in enumerate(lmap): # get columns to keep in the order we want them\r\n rscols[m[1]] = i # keep track of where each rs is in this map\r\n colrs.append(m[1]) # and keep the list of rs for tracking alleles\r\n wewant = [rscols[x[2]] for x in lcdmap] # columns we want to keep\r\n print '#Subsetped faff=%s ofaff=%s keeping %d (%s) of potential lcd %d for %s' % \\\r\n (faff,ofaff,len(wewant),wewant[:20],len(lcdmap),basename)\r\n pf = file('%s.ped' % basename,'r')\r\n ogeno = [] # offspring new lines\r\n fgeno = [] # founders\r\n oped = [] # for pedigrees\r\n fped = []\r\n rsadict = {} # keep a count of alleles - seems to be a problem\r\n for i,l in enumerate(pf):\r\n if (i+1) % 500 == 0:\r\n print '%s at line %d' % (basename,i+1)\r\n ll = l.strip().split()\r\n ped = ll[:6]\r\n founder = (ll[2] == '0' and ll[3] == '0') \r\n aff = faff\r\n if not founder:\r\n aff = ofaff\r\n ped[5] = aff # adjust as needed\r\n if founder:\r\n fped.append(ped)\r\n else:\r\n oped.append(ped)\r\n gt = ll[6:]\r\n geno = []\r\n for snp in wewant: # columns in order\r\n thisrs = colrs[snp]\r\n base = snp*2\r\n g1 = gt[base]\r\n g2 = gt[base+1]\r\n geno.append(g1)\r\n geno.append(g2)\r\n if not rsadict.get(thisrs,None):\r\n rsadict[thisrs] = {}\r\n if g1 <> '0':\r\n if not rsadict[thisrs].get(g1,None):\r\n rsadict[thisrs][g1] = 1\r\n else:\r\n rsadict[thisrs][g1] += 1 \r\n if g2 <> '0':\r\n if not rsadict[thisrs].get(g2,None):\r\n rsadict[thisrs][g2] = 1\r\n else:\r\n rsadict[thisrs][g2] += 1\r\n keepgt = array.array('c',geno)\r\n if founder:\r\n fgeno.append(keepgt)\r\n else:\r\n ogeno.append(keepgt)\r\n print '#Subsetped %s %d fgeno %d ogeno' % (basename,len(fgeno),len(ogeno))\r\n return fped,oped,fgeno,ogeno,rsadict","def load_all_graphs():\n all_graphs = []\n for i in range(7):\n with open(f'Full_Network_Book_{i+1}.gml', 'rb') as graph_file:\n all_graphs.append(nx.read_gml(graph_file))\n\n return all_graphs","def overlapPlot():\n fig, ax = plt.subplots()\n x = pickle.load(open(\"pickles/input_threshs_for_overlap.pkl\", \"rb\"))\n y = pickle.load(open(\"pickles/overlaps.pkl\", \"rb\"))\n x.reverse()\n y.reverse()\n ax.set_xlabel(\"Threshold of YFP-tau\", fontname=\"Times New Roman\", fontsize=12)\n ax.set_ylabel(\"Overlap of YFP-tau and AT8-pTau\", fontname=\"Times New Roman\", fontsize=12)\n ax.plot(x,y, '+-')\n ax.set_ylim((0,1))\n y_vals = ax.get_yticks()\n ax.set_yticklabels(['{:,.0%}'.format(y_val) for y_val in y_vals], fontname=\"Times New Roman\")\n for tick in ax.get_xticklabels():\n tick.set_fontname(\"Times New Roman\")\n plt.xticks(np.arange(min(x), max(x) + .25, .25))\n plt.savefig(\"matplotlib_figures/overlapPlot.png\", dpi=300)","def resolve(self):\n\n if not debug:\n print('##gff-version 3')\n print('##date %s' % date.today())\n\n data = self.read_input()\n # Find best overlap for each distinct chromosome, strand and type\n for rid in data.keys():\n # Holder for sequences\n sequences = list()\n # Top score so far\n top_weight = 0\n # Most far end so far\n most_far = 0\n count = 0\n\n # If input file was not sorted, we will sort it.\n # This will allow as to divide file into blocks.\n if not self.is_sorted:\n data[rid].sort(key=attrgetter('start'))\n\n for region in data[rid]:\n if len(sequences) > 0 and region.start > most_far:\n top_weight_tmp, tmp_count = self.get_partial(sequences)\n top_weight += top_weight_tmp\n count += tmp_count\n sequences.clear()\n\n most_far = max(region.finish, most_far)\n sequences.append(region)\n\n top_weight_tmp, tmp_count = self.get_partial(sequences)\n top_weight += top_weight_tmp\n count += tmp_count\n\n # Print score statistics\n if debug:\n print(\"# Type '{0}' scored: {1:10}\".format(rid, top_weight))\n print(count)","def processFiles(fileName):\n print fileName\n count_t1 = 0\n inFile=open(fileName,'r')\n all_angleList = Counter()\n rep_angleList = Counter()\n all_lengthsList = Counter()\n maxDist_List = Counter()\n global xCord, yCord, zCord\n aminoAcidName={}\n xCord={}\n yCord={}\n zCord={}\n seq_number={}\n counter=0\n for i in inFile:\n if (i[0:6].rstrip()==\"NUMMDL\"):\n numOfModels=i[10:14].rstrip()\n if ((i[0:6].rstrip()==\"ENDMDL\")or (i[0:6].rstrip()=='TER')):\n break\n if (i[0:6].rstrip()==\"MODEL\" and int(i[10:14].rstrip())>1):\n break\n \n if(i[0:4].rstrip())==\"ATOM\" and(i[13:15].rstrip())==\"CA\" and(i[16]=='A'or i[16]==' ')and i[17:20]!= \"UNK\" :\n aminoAcidName[counter]=int(aminoAcidLabel[i[17:20]])\n xCord[counter]=(float(i[30:38]))\n yCord[counter]=(float(i[38:46]))\n zCord[counter]=(float(i[46:54]))\n seq_number[counter]=str(i[22:27])\n counter+=1\n\n protLen=len(yCord)\n initialLabel=[]\n sortedLabel=[]\n sortedIndex=[]\n outDist={}\n for m in range(0,3):\n initialLabel.append(0)\n sortedLabel.append(0)\n sortedIndex.append(0)\n\n for i in range(0,protLen-2):\n for j in range(i+1,protLen-1):\n for k in range(j+1, protLen):\n global i1,j1,k1\n i1=i\n j1=j\n k1=k\n keepLabelIndex={}\n keepLabelIndex[aminoAcidName[i]]=i\n keepLabelIndex[aminoAcidName[j]]=j\n keepLabelIndex[aminoAcidName[k]]=k\n initialLabel[0]=aminoAcidName[i]\n initialLabel[1]=aminoAcidName[j]\n initialLabel[2]=aminoAcidName[k]\n sortedLabel=list(initialLabel)\n sortedLabel.sort(reverse=True)\n\n #Perform Rule- based labelling\n\n if (sortedLabel[0]==sortedLabel[1])and(sortedLabel[1]==sortedLabel[2]):\n dist1_2Temp=calcDist(i,j)\n dist1_3Temp=calcDist(i,k)\n dist2_3Temp=calcDist(j,k)\n if dist1_2Temp>=(max(dist1_2Temp,dist1_3Temp,dist2_3Temp)):\n indexOf0=i\n indexOf1=j\n indexOf2=k\n elif dist1_3Temp>=(max(dist1_2Temp,dist1_3Temp,dist2_3Temp)):\n indexOf0=i\n indexOf1=k\n indexOf2=j\n else:\n indexOf0=j\n indexOf1=k\n indexOf2=i\n elif(aminoAcidName[i]!=aminoAcidName[j])and(aminoAcidName[i]!=aminoAcidName[k]) and(aminoAcidName[j]!=aminoAcidName[k]): \n for index_ in range(0,3):\n sortedIndex[index_]=keepLabelIndex[sortedLabel[index_]]\n indexOf0=sortedIndex[0]\n indexOf1=sortedIndex[1]\n indexOf2=sortedIndex[2]\n elif(sortedLabel[0]==sortedLabel[1])and(sortedLabel[1]!=sortedLabel[2]):\n indexOf2=keepLabelIndex[sortedLabel[2]]\n indices=indexFind(indexOf2,i,j,k)\n a=indexOf2\n b=indices[0]\n c=indices[1]\n dist1_3Temp=calcDist(b,a)\n dist2_3Temp=calcDist(c,a)\n if dist1_3Temp>=dist2_3Temp:\n indexOf0=indices[0]\n indexOf1=indices[1] \n else:\n indexOf0=indices[1]\n indexOf1=indices[0]\n elif(sortedLabel[0]!=sortedLabel[1])and(sortedLabel[1]==sortedLabel[2]):\n indexOf0=keepLabelIndex[sortedLabel[0]]\n indices=indexFind(indexOf0,i,j,k)\n if calcDist(indexOf0,indices[0])>= calcDist(indexOf0,indices[1]):\n indexOf1=indices[0]\n indexOf2=indices[1] \n else:\n indexOf2=indices[0]\n indexOf1=indices[1]\n dist01=calcDist(indexOf0,indexOf1)\n s2=dist01/2\n dist02=calcDist(indexOf0,indexOf2)\n s1=dist02\n dist12=dist01\n dist03=calcDist(indexOf1,indexOf2)\n\n # All lengths calculation \n all_lengthsList[round(dist01,round_off_to)] += 1\n all_lengthsList[round(dist02,round_off_to)] += 1\n all_lengthsList[round(dist03,round_off_to)] += 1\n\n maxDist_List[round(max(dist01,dist02,dist03),round_off_to)] +=1\n\n s3=(((xCord[indexOf0]+xCord[indexOf1])/2-xCord[indexOf2])**2\n +((yCord[indexOf0]+yCord[indexOf1])/2-yCord[indexOf2])**2\n +((zCord[indexOf0]+zCord[indexOf1])/2-zCord[indexOf2])**2)**0.5\n \n \n Theta1=180*(math.acos((s1**2-s2**2-s3**2)/(2*s2*s3)))/3.14\n if Theta1<=90:\n all_angleList[round(Theta1,round_off_to)] +=1\n rep_angleList[round(Theta1,round_off_to)] +=1\n else:\n all_angleList[round(abs(180-Theta1),round_off_to)] +=1\n rep_angleList[round(abs(180-Theta1),round_off_to)] +=1\n \n #if Theta1>90: \n # Theta1=abs(180-Theta1)\n #print 'Second Theta1, ',Theta1\n #Theta 2\n dist02=calcDist(indexOf1,indexOf0)\n s1=dist02\n dist01=calcDist(indexOf1,indexOf2)\n s2=dist01/2\n s3=(((xCord[indexOf1]+xCord[indexOf2])/2-xCord[indexOf0])**2\n +((yCord[indexOf1]+yCord[indexOf2])/2-yCord[indexOf0])**2\n +((zCord[indexOf1]+zCord[indexOf2])/2-zCord[indexOf0])**2)**0.5\n \n Theta2=180*(math.acos((s1**2-s2**2-s3**2)/(2*s2*s3)))/3.14 \n #if Theta2 > 90:\n # Theta2 = abs(180-Theta2)\n if Theta2<=90:\n all_angleList[round(Theta2,round_off_to)] +=1\n else:\n all_angleList[round(abs(180-Theta2),round_off_to)] +=1\n\n #Theta 3\n dist02=calcDist(indexOf2,indexOf1)\n s1=dist02\n dist01=calcDist(indexOf2,indexOf0)\n s2=dist01/2\n s3=(((xCord[indexOf2]+xCord[indexOf0])/2-xCord[indexOf1])**2+\n ((yCord[indexOf2]+yCord[indexOf0])/2-yCord[indexOf1])**2+\n ((zCord[indexOf2]+zCord[indexOf0])/2-zCord[indexOf1])**2)**0.5\n \n Theta3=180*(math.acos((s1**2-s2**2-s3**2)/(2*s2*s3)))/3.14 \n #if Theta3 > 90:\n # Theta3 = abs(180-Theta3)\n if Theta3<=90:\n all_angleList[round(Theta3,round_off_to)] +=1\n else:\n all_angleList[round(abs(180-Theta3),round_off_to)] +=1\n # Either writting output to a file or using dictionary or \n # counter will save you from memory exceptions in this case.\n #all_angleList[round(Theta1,round_off_to)] +=1\n #all_angleList[round(Theta2,round_off_to)] +=1\n #all_angleList[round(Theta3,round_off_to)] +=1\n\n #rep_angleList[round(Theta1,round_off_to)] +=1\n\n count_t1 = count_t1+1\n\n print 'count_t1:',count_t1\n\n return [all_angleList,rep_angleList,all_lengthsList,maxDist_List]","def comb_fc(filepatt):\r\n\r\n\r\n files = glob.glob(os.path.join(savefolder, filepatt))\r\n print(filepatt)\r\n \r\n if files == []:\r\n imgs = []\r\n print('No files found for ' + filepatt)\r\n return\r\n\r\n\r\n imgs = np.empty((600, 600, 3))\r\n for fi, file in enumerate(files):\r\n img = cv2.imread(file)\r\n \r\n if fi == 0:\r\n imgs = img\r\n else:\r\n imgs = np.concatenate((imgs, img), axis = 2)\r\n\r\n idx = filepatt.find('freq')\r\n comb_fcGraph = os.path.join(savefolder, 'comb_' + filepatt[idx: -len('.mat')])\r\n cv2.imwrite(comb_fcGraph, imgs)\r\n print(comb_fcGraph)\r\n\r\n # find lowweight\r\n pvals_vec = []\r\n ciCOH_vec = []\r\n pvals = pvals_fc_overtime(ciCOH = ciCOH, ntrials = ntrials, ntemp = ntemp, f = f, t = t)\r\n\r\n reject, pval_corr = fdr_correction(pvals, alpha=0.05, method='indep')\r\n \r\n\r\n \r\n lowweight = min(ciCOH_vec[rejs])\r\n\r\n return lowweight","def pslMap( options ):\n\n if options.format == \"gtf\":\n use_copy = False\n else:\n use_copy = True\n\n ninput, noutput, ndiscarded, nskipped, nskipped_small_queries = 0, 0, 0, 0, 0\n\n min_length = options.min_aligned\n\n for match, qx, tx in iterator_psl_intervals( options ):\n\n map_query2target = match.getMapQuery2Target()\n\n ninput += 1\n\n ## if no filter on qx or tx, use full segment\n if qx == None:\n qx = [ (match.mQueryFrom,match.mQueryTo,0) ]\n elif tx == None:\n tx = [ (match.mSbjctFrom,match.mSbjctTo,0) ]\n\n ## if no overlap: return\n if not qx or not tx: \n nskipped += 1\n continue\n\n for query in qx:\n\n qstart, qend, qval = query\n\n # skip elements that are too small\n if qend - qstart < min_length: \n E.debug( \"query too small - skipped at %s:%i-%i\" % (match.mQueryId, qstart, qend) )\n nskipped_small_queries += 1\n continue\n\n E.debug( \"working on query %s:%i-%i\" % (match.mQueryId, qstart, qend) )\n\n mqstart, mqend = ( map_query2target.mapRowToCol(qstart, \n alignlib_lite.py_RIGHT), \n map_query2target.mapRowToCol(qend, \n alignlib_lite.py_LEFT) )\n \n \n if match.strand == \"-\":\n qstart, qend = match.mQueryLength - qend, match.mQueryLength - qstart\n\n for target in tx:\n\n tstart, tend, tval = target\n if tstart >= mqend or tend <= mqstart: continue\n if tend - tstart < min_length: continue\n\n new = alignlib_lite.py_makeAlignmentBlocks()\n \n if use_copy:\n # do copy with range filter\n if options.loglevel >= 3:\n\n mtstart, mtend = map_query2target.mapColToRow(tstart), map_query2target.mapColToRow(tend) \n E.debug( \"query: %i-%i (len=%i)-> %i-%i(len=%i); target: %i-%i (len=%i)-> %i-%i (len=%i)\" % \\\n (qstart, qend,\n qend - qstart,\n mqstart, mqend,\n mqend - mqstart,\n tstart, tend,\n tend - tstart,\n mtstart, mtend,\n mtend - mtstart ) )\n \n alignlib_lite.py_copyAlignment( \n new, \n map_query2target,\n qstart, qend,\n tstart, tend )\n else:\n # do copy with alignment filter\n map_query = qval\n if map_query:\n tmp = alignlib_lite.py_makeAlignmentBlocks() \n alignlib_lite.py_copyAlignment( tmp, map_query2target, map_query, alignlib_lite.py_RR )\n if options.loglevel >= 5:\n options.stdlog.write( \"######## mapping query ###########\\n\" )\n options.stdlog.write( \"# %s\\n\" % str(alignlib_lite.py_AlignmentFormatEmissions( map_query2target ) ))\n options.stdlog.write( \"# %s\\n\" % str(alignlib_lite.py_AlignmentFormatEmissions( map_query ) ))\n options.stdlog.write( \"# %s\\n\" % str(alignlib_lite.py_AlignmentFormatEmissions( tmp ) ))\n else:\n tmp = map_query2target\n \n map_target = tval\n if map_target:\n new = alignlib_lite.py_makeAlignmentBlocks()\n alignlib_lite.py_copyAlignment( new, tmp, map_target, alignlib_lite.py_CR ) \n if options.loglevel >= 5:\n options.stdlog.write( \"######## mapping target ###########\\n\" )\n options.stdlog.write( \"# before: %s\\n\" % str(alignlib_lite.py_AlignmentFormatEmissions( tmp ) ))\n options.stdlog.write( \"# map : %s\\n\" % str(alignlib_lite.py_AlignmentFormatEmissions( map_target ) ))\n options.stdlog.write( \"# after : %s\\n\" % str(alignlib_lite.py_AlignmentFormatEmissions( new ) ))\n else:\n new = tmp\n\n if options.loglevel >= 4:\n E.debug(\"putative match with intervals: %s and %s: %i-%i\" % \\\n (str(query), str(target), qstart, qend ))\n if options.loglevel >= 5:\n E.debug( \"input : %s\" % str(alignlib_lite.py_AlignmentFormatEmissions( map_query2target ) ))\n E.debug( \"final : %s\" % str(alignlib_lite.py_AlignmentFormatEmissions( new ) ) )\n\n if new.getLength() > 0:\n n = match.copy()\n n.fromMap( new, use_strand = True )\n E.info( \"match : %s\" % (str(n)))\n\n if new.getNumAligned() > options.min_aligned:\n n = match.copy()\n n.fromMap( new, use_strand = True )\n options.stdout.write( str(n) + \"\\n\" )\n noutput += 1\n else:\n ndiscarded += 1\n\n E.info( \"map: ninput=%i, noutput=%i, nskipped=%i, ndiscarded=%i, nsmall_queries=%i\" % \\\n (ninput, noutput, nskipped, ndiscarded, nskipped_small_queries) )","def build_graphs(df: pd.DataFrame, ir_dir: Path, graph_dir: Path):\n for _, row in df.iterrows():\n with open(ir_dir / f\"{row['name']}.ll\") as f:\n ir = f.read()\n graph = pg.from_llvm_ir(ir)\n graph.features.feature[\"devmap_label\"].int64_list.value[:] = [row[\"label\"]]\n graph.features.feature[\"wgsize\"].int64_list.value[:] = [row[\"wgsize\"]]\n graph.features.feature[\"transfer_bytes\"].int64_list.value[:] = [\n row[\"transfer_bytes\"]\n ]\n graph.features.feature[\"wgsize_log1p\"].float_list.value[:] = [\n row[\"wgsize_log1p\"]\n ]\n graph.features.feature[\"transfer_bytes_log1p\"].float_list.value[:] = [\n row[\"transfer_bytes_log1p\"]\n ]\n pbutil.ToFile(\n graph, graph_dir / f\"{row['name']}.ProgramGraph.pb\", exist_ok=False\n )","def test_convert_azfp_01a_different_ranges(azfp_path):\n azfp_01a_path = azfp_path / '17031001.01A'\n azfp_xml_path = azfp_path / '17030815.XML'\n\n # Convert file\n echodata = open_raw(\n raw_file=azfp_01a_path, sonar_model='AZFP', xml_path=azfp_xml_path\n )\n assert echodata[\"Sonar/Beam_group1\"].backscatter_r.sel(channel='55030-125-1').dropna(\n 'range_sample'\n ).shape == (360, 438)\n assert echodata[\"Sonar/Beam_group1\"].backscatter_r.sel(channel='55030-769-4').dropna(\n 'range_sample'\n ).shape == (360, 135)\n\n # check convention-required variables in the Platform group\n check_platform_required_scalar_vars(echodata)","def listOfOverlappingTTPairs():\n listOfHalfModules = listOfTTHalfModules()\n ttmap = TTModulesMap_instance\n pairs = []\n regions = {'A':1, 'B':2, 'C':3}\n print \"Overlapping TT half modules:\"\n for hm1 in listOfHalfModules:\n for hm2 in listOfHalfModules:\n # they must be different\n if hm1 == hm2: continue\n # they must be both on top or both on bottom\n if locateTTHalfModule(hm1)[3] != locateTTHalfModule(hm2)[3]: continue\n # they must be on the same layer\n if locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0]: continue\n # avoid duplicates\n if (hm1, hm2) in pairs: continue\n if (hm2, hm1) in pairs: continue\n # they must be contiguous:\n if (locateTTHalfModule(hm1)[1] == locateTTHalfModule(hm2)[1]):\n if (abs(locateTTHalfModule(hm1)[2] - locateTTHalfModule(hm2)[2]) == 1):\n pairs.append( (hm1, hm2) )\n else:\n num1 = locateTTHalfModule(hm1)[2]\n num2 = locateTTHalfModule(hm2)[2]\n max1 = ttmap.numberOfModules[locateTTHalfModule(hm1)[0]]['Region'+locateTTHalfModule(hm1)[1]] - 1\n max2 = ttmap.numberOfModules[locateTTHalfModule(hm2)[0]]['Region'+locateTTHalfModule(hm2)[1]] - 1\n nreg1 = regions[locateTTHalfModule(hm1)[1]]\n nreg2 = regions[locateTTHalfModule(hm2)[1]]\n if ( (num1==max1 and num2==0 and nreg2-nreg1==1) or (num2==max2 and num1==0 and nreg1-nreg2==1) ):\n pairs.append( (hm1, hm2) )\n print '\\t', hm1, hm2\n ## - same region\n #if ((abs(locateTTHalfModule(hm1)[2] - locateTTHalfModule(hm2)[2]) != 1)\n # and (locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0])): continue\n ## - or neighbouring region\n #elif not ((locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0])\n # and ( ( (ttmap.numberOfModules[locateTTHalfModule(hm1)[0]] == locateTTHalfModule(hm1)[2]+1 )\n # and (locateTTHalfModule(hm2)[2] == 0) )\n # or ( (ttmap.numberOfModules[locateTTHalfModule(hm2)[0]] == locateTTHalfModule(hm2)[2]+1 )\n # and (locateTTHalfModule(hm1)[2] == 0) ) ) ): continue\n ## append to list of pairs\n #pairs.append( (hm1, hm2) )\n print\n return pairs","def ggpl_bone_structure(file_name):\n def planeStructure(beamSection, pillarSection, distancePillars, intersectHeights):\n fStructs = []\n \n \"\"\" createFinalStruct\n \n Questo metodo crea una pilastro senza travi\n \n @param startPoint: Il punto di intersezione del pilastro con la base del piano di lavoro\n @param height: L'altezza del pilastro\n @returns: Il pilastro\n \"\"\"\n def createFinalStruct(startPoint, height):\n pillar = CUBOID([pillarSection[0], pillarSection[1], height])\n return STRUCT([T(2)(startPoint), pillar])\n\n \"\"\" createFStruct\n \n Questo metodo crea la struttura portante con il pilastro e le travi di riferimento\n \n @param startPoint: Il punto di intersezione del pilastro con la base del piano di lavoro\n @param height: L'altezza del pilastro\n @param lengthBeam: La lunghezza delle travi\n @returns: Il pilastro\n \"\"\"\n def createFStruct(startPoint, height, lengthBeam):\n fStruct = []\n\n fStruct.append(createFinalStruct(startPoint, height))\n hPillar = 0\n for i in range(len(intersectHeights)):\n beam = CUBOID([beamSection[1], lengthBeam, beamSection[0]])\n hPillar += intersectHeights[i]\n fStruct.append(STRUCT([\n T(3)(hPillar),\n T(2)(pillarSection[1] + startPoint),\n beam\n ]))\n return STRUCT(fStruct)\n\n height = SUM(intersectHeights) + beamSection[1]\n\n startDistance = 0\n for iterator in range(len(distancePillars)):\n fStructs.append(createFStruct(startDistance, height, distancePillars[iterator]))\n\n startDistance = startDistance + pillarSection[1] + distancePillars[iterator]\n\n fStructs.append(createFinalStruct(startDistance, height))\n\n return STRUCT(fStructs)\n \n \"\"\" createTrasversalBeam\n \n Questa funzione crea le travi di collegamento tra una parete e l'altra\n \n @param beanSection: una tupla (bx,bz) che contiene la dimensione delle travi\n @param pillarSection: una tupla (px,py) che contiene la dimensione dei pilastri\n @param distancePillars: una lista di distanze relative tra un pilastro e l'altro\n @param intersectHeights: una lista di altezze relative che indicano la distranza tra una trave e l'altra sull'asse x\n @returns: la struttura base, che corrisponde ad una parete dell'edificio\n \"\"\"\n def createTrasversalBeam(distance, beamSection, pillarSection, distancePillars, intersectHeights):\n y = []\n for index in range(len(distancePillars)):\n y.append(pillarSection[1])\n y.append(- distancePillars[index])\n y.append(pillarSection[1])\n\n x = [\n - pillarSection[0],\n distance\n ]\n\n z = []\n for i in range(len(intersectHeights)):\n if i == 0:\n z.append(-intersectHeights[i])\n else:\n z.append(-intersectHeights[i] + beamSection[1])\n z.append(beamSection[1])\n\n return PROD([\n PROD([QUOTE(x), QUOTE(y)]),\n QUOTE(z)\n ])\n \n \"\"\" parseCSV\n \n Questo metodo prende in input un file_name che indica il file csv da parsare per avere le informazioni della struttura\n \n Argomenti:\n file_name (string): il file name del file csv\n \n Yields:\n transaction: il vettore di traslazione tra una parete e l'altra\n beanSection: una tupla (bx,bz) che contiene la dimensione delle travi\n pillarSection: una tupla (px,py) che contiene la dimensione dei pilastri\n distancePillars: una lista di distanze relative tra un pilastro e l'altro\n intersectHeights: una lista di altezze relative che indicano la distranza tra una trave e l'altra sull'asse x\n \"\"\"\n def parseCSV(file_name):\n odd = True\n transaction = None\n with open(file_name, 'rb') as csvfile:\n builderreader = csv.reader(csvfile)\n\n for row in builderreader:\n if odd:\n odd = False\n transaction = [float(row[0]), float(row[1]), float(row[2])]\n else:\n odd = True\n beamSection = [float(row[0]), float(row[1])]\n pillarSection = [float(row[2]), float(row[3])]\n\n distancePillars = []\n start_point = 5\n finish_point = int(row[4]) + start_point\n for index in range(start_point, finish_point):\n distancePillars.append(int(row[index]))\n\n intersectHeights = []\n start_point = finish_point + 1\n finish_point = int(row[finish_point]) + start_point\n for index in range(start_point, finish_point):\n intersectHeights.append(int(row[index]))\n\n yield transaction, beamSection, pillarSection, distancePillars, intersectHeights\n\n frames = []\n for transaction, beamSection, pillarSection, distancePillars, intersectHeights in parseCSV(file_name):\n frames.append(T(2)(transaction[1]))\n\n if transaction[0] != 0:\n frames.append(\n createTrasversalBeam(\n transaction[0], beamSection, pillarSection, distancePillars,intersectHeights\n )\n )\n\n frames.append(T([1, 3])([transaction[0], transaction[2]]))\n frames.append(\n planeStructure(beamSection, pillarSection, distancePillars, intersectHeights)\n )\n\n return STRUCT(frames)","def iter_protenn_matches(file: str):\n with open(file, \"rt\") as fh:\n for line in fh:\n sequence_id, pfam_acc, start, end = line.rstrip().split(\"\\t\")\n if re.fullmatch(r\"PF\\d+\", pfam_acc):\n yield sequence_id, pfam_acc, int(start), int(end)","def test_documentation_popxl_create_multi_subgraph(self):\n filename = \"create_multi_graphs_from_same_func.py\"\n self.run_python(filename, file_dir=working_dir, working_dir=working_dir)","def readMAFOTLaminarOutput(self,PFC,file):\n print('Reading laminar output')\n log.info('Reading laminar output')\n data = np.genfromtxt(file,comments='#')\n use = np.where(PFC.shadowed_mask != 1)[0]\n xyz = PFC.centers[use]\n r,z,phi = tools.xyz2cyl(xyz[:,0],xyz[:,1],xyz[:,2])\n r = np.round(r,10) #number of decimal places in MAFOT output file\n\n #Sometimes the MAFOT calculation returns an error and it discards the\n #launch point instead of writing to the output file. This results\n #in less points coming out of MAFOT than we put in. So we amend this\n #by checking to make sure the points coming out are assigned to the correct\n #location in the mesh centers.\n #Could be parallelized in future\n\n #Create shared variables so that all multiprocessing cores can access\n #same variables without needless data transmission\n tools.lamData = data\n tools.lamR = r\n\n #Prepare intersectionTest across multiple cores\n t0 = time.time()\n Ncores = multiprocessing.cpu_count() -2 #reserve 2 cores for overhead\n print('Initializing parallel MAFOT laminar check across {:d} cores'.format(Ncores))\n log.info('Initializing parallel MAFOT laminar check across {:d} cores'.format(Ncores))\n print('Spawning tasks to workers')\n log.info('Spawning tasks to workers')\n pool = multiprocessing.Pool(Ncores)\n indexes = np.asarray(pool.map(tools.readLaminarParallel, np.arange(len(r))))\n pool.close()\n\n PFC.psimin = data[indexes,4]\n PFC.conLength = data[indexes,3]\n\n #R = data[:,0]\n #Z = data[:,1]\n #phi = np.radians(data[:,9])\n #x,y,z = tools.cyl2xyz(R,Z,phi)\n #PFC.centersLam = np.concatenate((x,y,z)).reshape((-1, 3), order='F')\n print('Laminar output read')\n print('Requested {:d} traces from MAFOT'.format(len(r)))\n print('MAFOT returned {:d} traces'.format(len(data[:,0])))\n log.info('Laminar output read')\n log.info('Requested {:d} traces from MAFOT'.format(len(r)))\n log.info('MAFOT returned {:d} traces'.format(len(data[:,0])))\n\n return","def write_target_regions(out_f, args, chrom_list, combined_files, snp_files):\n\n for chrom in chrom_list: \n node_name = \"/%s\" % chrom.name\n if node_name not in snp_files.snp_index_h5:\n continue\n if node_name not in snp_files.snp_tab_h5:\n continue\n \n sys.stderr.write(\" %s\\n\" % chrom.name)\n\n sys.stderr.write(\" getting genotype counts\\n\")\n ref_geno_count = combined_files.ref_count_h5.get_node(node_name)[:]\n het_geno_count = combined_files.het_count_h5.get_node(node_name)[:]\n\n ref_allele_count = ref_geno_count * 2 + het_geno_count\n # free memory as it is no longer needed\n del ref_geno_count\n\n alt_geno_count = combined_files.alt_count_h5.get_node(node_name)[:]\n alt_allele_count = alt_geno_count * 2 + het_geno_count\n\n del alt_geno_count\n\n sys.stderr.write(\" getting minor allele counts\\n\")\n\n minor_count = np.amin(np.vstack([ref_allele_count, alt_allele_count]),\n axis=0)\n \n idx = np.where((minor_count >= args.min_minor_allele_count) &\n (het_geno_count >= args.min_het_count))[0]\n\n del het_geno_count\n del minor_count\n \n sys.stderr.write(\" %d possible test SNPs\\n\" % idx.shape[0])\n\n read_counts = combined_files.read_count_h5.get_node(node_name)[:]\n as_read_counts = combined_files.as_count_h5.get_node(node_name)[:]\n\n snp_idx = snp_files.snp_index_h5.get_node(node_name)\n snp_tab = snp_files.snp_tab_h5.get_node(node_name)\n \n n_region = 0\n \n for i in idx:\n start = max(1, i+1 - args.target_region_size/2)\n end = min(chrom.length, i+1 + args.target_region_size/2)\n\n n_reads = np.sum(read_counts[start-1:end])\n n_as_reads = np.sum(as_read_counts[start-1:end])\n\n snp_row = snp_tab[snp_idx[i]]\n\n if (n_reads >= args.min_read_count) and (n_as_reads >= args.min_as_count):\n # keep this target region\n\n # NOTE: currently this filter just uses total count of AS reads in region.\n # Would be better to take into account genotypes of each individual, since AS reads\n # are only useful for test in individuals that are heterozygous for test SNP\n out_f.write(\"%s %d %d %s %s + %s.%d %d %d\\n\" % \n (chrom.name, i+1, i+2, snp_row['allele1'],\n snp_row['allele2'], chrom.name, start+1,\n start, end))\n\n n_region += 1\n\n sys.stderr.write(\" wrote %d test SNP / target region pairs\\n\" % n_region)","def _load_pascal_annotation(self, index):\n image = index\n im_path = self.image_path_from_index(image)\n im = cv2.imread(im_path)\n width = im.shape[1]\n height = im.shape[0]\n num_objs = 0\n for ix, obj in enumerate(image.objects):\n if image.objects[ix].x > width - 2 or image.objects[ix].y > height - 2:\n continue \n assert(image.objects[ix].width > 0)\n assert(image.objects[ix].height > 0)\n\n num_objs += 1\n\n boxes = np.zeros((num_objs, 4), dtype=np.float32)\n\n partial_entity_class = np.zeros((num_objs, 96), dtype=np.int32)\n partial_relation_class = np.zeros((num_objs, num_objs, 43), dtype=np.int32)\n gt_classes = np.zeros((0, num_objs, 1), dtype=np.int32)\n overlaps = np.zeros((0, num_objs, self.num_classes), dtype=np.int64)\n # \"Seg\" area for pascal is just the box area\n seg_areas = np.zeros((num_objs), dtype=np.float32)\n queries = np.zeros((0, 235), dtype=np.float32)\n # Load object bounding boxes into a data frame.\n index = 0\n \n for ix, obj in enumerate(image.objects):\n if image.objects[ix].x > width - 2 or image.objects[ix].y > height - 2:\n continue\n # Make pixel indexes 0-based\n x1_offset = 0.0#image.objects[ix].width * (-0.1)\n x2_offset = 0.0#image.objects[ix].width * 0.1\n y1_offset = 0.0#image.objects[ix].height * (-0.1)\n y2_offset = 0.0#image.objects[ix].height * 0.1\n boxes[index][0] = max((image.objects[ix].x + x1_offset), 0.0)\n boxes[index][1] = max((image.objects[ix].y + y1_offset), 0.0)\n boxes[index][2] = min((image.objects[ix].x + x2_offset + image.objects[ix].width), width - 1)\n boxes[index][3] = min((image.objects[ix].y + y2_offset + image.objects[ix].height), height - 1)\n seg_areas[index] = (boxes[index][2] - boxes[index][0] + 1.0) * (boxes[index][3] - boxes[index][1] + 1.0)\n index += 1\n assert (boxes[:, 2] > boxes[:, 0]).all()\n assert (boxes[:, 3]\t > boxes[:, 1]).all() \n #load gt classes\n \n i_index = 0\n for i in range(image.objects_labels.shape[0]):\n if image.objects[i].x > width - 2 or image.objects[i].y > height - 2:\n continue\n partial_entity_class[i_index] = image.objects_labels[i]\n \n j_index = 0\n for j in range(image.objects_labels.shape[0]):\n if image.objects[j].x > width - 2 or image.objects[j].y > height - 2:\n continue\n partial_relation_class[i_index, j_index] = image.predicates_labels[i, j]\n j_index += 1\n i_index += 1\n seen = []\n for query_index in range(image.queries_gt.shape[0]):\n query_gt_classes = np.zeros((1, num_objs, 1), dtype=np.int32)\n query_overlaps = np.zeros((1, num_objs, self.num_classes), dtype=np.int64)\n query_overlaps[0, :, 3] = 1\n query_gt_classes[0, :, 0] = 3\n if image.one_hot_relations_gt[query_index][-1] == 1:\n # print \"negative triplet\"\n continue\n\n sub = image.one_hot_relations_gt[query_index][:96]\n obj = image.one_hot_relations_gt[query_index][96:96 * 2]\n rel = image.one_hot_relations_gt[query_index][96 * 2:]\n key = str(np.argmax(sub)) + \"_\" + str(np.argmax(rel)) + \"_\" + str(np.argmax(obj))\n if key in seen:\n continue\n seen.append(key)\n\n found = False\n i_index = 0\n for i in range(image.objects_labels.shape[0]):\n if image.objects[i].x > width - 2 or image.objects[i].y > height - 2:\n continue\n if not np.array_equal(image.objects_labels[i], sub):\n i_index += 1\n continue\n j_index = 0\n for j in range(image.objects_labels.shape[0]):\n if image.objects[j].x > width - 2 or image.objects[j].y > height - 2:\n continue \n\n if not np.array_equal(image.objects_labels[j], obj):\n j_index += 1\n continue\n if np.array_equal(rel, image.predicates_labels[i, j]):\n query_gt_classes[0, i_index, 0] = 1\n query_overlaps[0, i_index, 1] = 1\n query_overlaps[0, i_index, 3] = 0\n query_gt_classes[0, j_index, 0] = 2\n query_overlaps[0, j_index, 2] = 1\n query_overlaps[0, j_index, 3] = 0\n \n #partial_entity_class[i_index] = sub\n #partial_entity_class[j_index] = obj\n #partial_relation_class[i_index, j_index] = rel\n \n found = True\n j_index += 1\n i_index += 1\n if not found:\n continue\n gt_classes = np.concatenate((gt_classes, query_gt_classes), axis=0)\n overlaps = np.concatenate((overlaps, query_overlaps), axis=0)\n queries = np.concatenate((queries, image.one_hot_relations_gt[query_index].reshape([1,-1])), axis=0)\n\n return {'boxes': boxes,\n 'gt_classes': gt_classes,\n 'gt_overlaps': overlaps,\n 'flipped': False,\n 'seg_areas': seg_areas,\n 'query' : queries,\n 'partial_entity_class' : partial_entity_class,\n 'partial_relation_class' : partial_relation_class,\n 'orig_image': None}","def prog(args):\r\n i_fname, o_fname, pedestal_params, split_list, Num_W = args\r\n mesh = stl.mesh.Mesh.from_file(i_fname)\r\n #rotate mesh since by default the rotation axis is along X\r\n mesh.rotate([0,1,0],np.pi/2)\r\n\r\n v_arr = np.round(np.vstack(mesh.vectors).astype(float), decimals=1)\r\n\r\n splt0_arr = np.array(split_list)\r\n splt1_arr = np.roll(splt0_arr,-1)\r\n\r\n pos = cf.cartesian2cylyndrical(v_arr, Num_W)\r\n\r\n #make splits\r\n pos_list=[]\r\n for splt0, splt1 in zip(splt0_arr[:-1], splt1_arr[:-1]):\r\n pos_idx = np.where((splt0<=pos[:,:,2]) & (splt1>pos[:,:,2]))[0]\r\n print(splt0, splt1)\r\n #pos = [r, th, z] sectionwise\r\n pos_list.append(pos[pos_idx])\r\n #add pedestal mesh\r\n\r\n for sect_num, pos in enumerate(pos_list):\r\n pos = cf.add_pedestal(pos, pedestal_params)\r\n profiles=np.zeros_like(pos)\r\n\r\n for i in np.arange(np.shape(pos)[0]):\r\n profiles[i] = cf.cylyndrical2cartesian(pos[i])\r\n\r\n strokes = np.flipud(np.rot90(profiles))\r\n #transform data from longeron nodes [xyz] to:\r\n #a_arr - rotation angle around the rotation axis\r\n #r_arr - length of a segment perpenticular to the rotation axis and corresponding lateral mesh edge\r\n #z_arr - corresponding z coordiantes\r\n #v_arr - direction vector of the coresponding lateral mesh edge\r\n a_arr, r_arr, z_arr, v_arr = cf.transform(strokes, add_pedestal_bottom=True,add_pedestal_top=True)\r\n\r\n #make a summary plots\r\n cf.plot_loft_paths(profiles)\r\n cf.plot_loft_paths(pos)\r\n cf.plot_surf(a_arr,z_arr,r_arr)\r\n\r\n #collect data to the dictionary longeron wise\r\n res_dict = {'a_arr':np.rot90(a_arr, k=-1),\r\n 'r_arr':np.rot90(r_arr, k=-1),\r\n 'z_arr':np.rot90(z_arr, k=-1),\r\n 'v_arr':np.rot90(v_arr, k=-1)}\r\n\r\n #save result dictionary\r\n if not o_fname:\r\n o_fname = i_fname\r\n\r\n fname='{}_{}.pickle'.format(o_fname, sect_num)\r\n with open(fname, 'wb') as f:\r\n # Pickle the 'data' dictionary using the highest protocol available.\r\n pickle.dump(res_dict, f, pickle.HIGHEST_PROTOCOL)\r\n\r\n print(fname, ' saved')","def file_parse():\n\n\tfilename = input(\"Enter the file path for your graph: \")\n\ttarget = open(filename, 'r')\n\n\ttarget_lines = [] \t# List of lines from target file\n\t\n\t# Grab the graph count and node/edge count for the first graph\n\ti = 0\n\tfor line in target:\n\t\tif i == 0:\n\t\t\tgraph_count = int(line)\n\t\telif i == 1:\n\t\t\tnode_count = int(line)\n\t\telif i == 2:\n\t\t\tedge_count = int(line)\n\t\telse:\t\n\t\t\ttarget_lines.append(line.strip('\\n'))\n\t\ti += 1\n\n\treturn graph_create(target_lines, graph_count, node_count, edge_count)","def mainFunction(f):\n\n #############################################################################\n \n \n # biomass hexagon\n predF = '/vol/v3/lt_stem_v3.1/models/biomassfiaald_20180708_0859/2000/biomassfiaald_20180708_0859_2000_mean.tif'\n trainF = '/vol/v2/datasets/biomass/nbcd/fia_ald/nbcd_fia_ald_biomass_clipped_to_conus.tif'\n shpF = '/vol/v1/general_files/datasets/spatial_data/hexagons/hexagons_conus_albers_30km_with_id.shp'\n trainND = -32768\n predND = -9999\n trgField = 'id'\n descrField = 'id'\n outDir = '/vol/v3/lt_stem_v3.1/evaluation/biomassfiaald_20180708_0859/hexagon_correlation'\n xyLim = (500, 500)\n xLab = 'Reference (tons/ha)'\n yLab = 'Prediction (tons/ha)'\n annoXY = (15,420)\n \n \n \"\"\"\n # cc\n predF = '/vol/v3/lt_stem_v3.1/models/canopy_20180915_1631/2001/canopy_20180915_1631_2001_mean.tif'\n trainF = '/vol/v2/stem/conus/reference_rasters/nlcd_2001_canopy_clipped_to_conus_train.tif'\n #shpF = '/vol/v2/datasets/Eco_Level_III_US/us_eco_l3_no_states_multipart.shp'\n shpF = '/vol/v1/general_files/datasets/spatial_data/hexagons/hexagons_conus_albers_30km_with_id.shp'\n trainND = 255\n predND = 255\n trgField = 'id'\n descrField = 'id'\n #trgField = 'US_L3CODE'\n #descrField = 'US_L3NAME'\n #outDir = '/vol/v3/lt_stem_v3.1/evaluation/canopy_20180915_1631/ecoregion_correlation'\n outDir = '/vol/v3/lt_stem_v3.1/evaluation/canopy_20180915_1631/hexagon_correlation'\n xyLim = (100, 100)\n xLab = 'Reference (%)'\n yLab = 'Prediction (%)'\n annoXY = (5,82)\n \"\"\"\n #############################################################################\n\n\n # get color setup\n norm = colors.Normalize(vmin=0, vmax=1)\n f2rgb = cm.ScalarMappable(norm=norm, cmap=cm.get_cmap('YlGnBu_r'))\n \n # open the shapefile\t\n vDriver = ogr.GetDriverByName(\"ESRI Shapefile\")\n vSrc = vDriver.Open(shpF, 0)\n vLayer = vSrc.GetLayer()\n \n commonBox = get_intersec([predF, trainF])\n\n#for f in range(vLayer.GetFeatureCount()):\n feature = vLayer[f]\n name = feature.GetField(trgField)\n print('f: '+str(f))\n outFig = os.path.join(outDir, (trgField.replace(' ','_').lower()+'_'+str(name)+'.png'))\n if os.path.exists(outFig):\n #break\n return\n \n descr = feature.GetField(descrField)\n \n predP, coords = get_zone_pixels(feature, shpF, predF, 1, [commonBox[0], commonBox[2], commonBox[3], commonBox[1]])#.compressed() [commonBox[0], commonBox[2], commonBox[3], commonBox[1]]\n trainP, coords = get_zone_pixels(feature, shpF, trainF, 1, [coords[0], coords[1], coords[2], coords[3]])#.compressed()\n \n predP = ma.masked_equal(predP, predND)\n trainP = ma.masked_equal(trainP, trainND)\n trainP = ma.masked_equal(trainP, 0)\n\n combMask = np.logical_not(np.logical_not(predP.mask) * np.logical_not(trainP.mask))\n predP[combMask] = ma.masked\n trainP[combMask] = ma.masked\n predP = predP.compressed()\n trainP = trainP.compressed()\n if (predP.shape[0] == 0) | (trainP.shape[0] == 0) | (predP==0).all() | (trainP==0).all():\n predP = np.array([0,0,1,1], dtype='float64')\n trainP = np.array([0,0,1,1], dtype='float64')\n mae = round(np.mean(np.absolute(np.subtract(predP, trainP))),1)\n rmse = round(np.sqrt(np.mean((predP-trainP)**2)),1)\n \n\n totPixs = trainP.shape[0]\n sampSize = round(totPixs*1)\n pickFrom = range(sampSize)\n #sampIndex = np.random.choice(pickFrom, size=sampSize)\n sampIndex = pickFrom\n\n r = round(np.corrcoef(trainP[sampIndex], predP[sampIndex])[0][1], 2)\n if (mae == 0) & (r == 1):\n r = 0.0\n rColor = f2hex(f2rgb, r)\n p = sns.jointplot(trainP[sampIndex], predP[sampIndex], kind=\"hex\", color='blue', xlim=(0,xyLim[0]), ylim=(0,xyLim[1]), size=5)\n p.ax_joint.set_xlabel(xLab)\n p.ax_joint.set_ylabel(yLab)\n p.ax_joint.annotate('r: '+str(r)+'\\nrmse: '+str(rmse)+'\\nmae: '+str(mae), annoXY)\n plt.tight_layout()\n outFig = os.path.join(outDir, (trgField.replace(' ','_').lower()+'_'+str(name)+'.png'))\n p.savefig(outFig)\n \n df = pd.DataFrame({'id':name, 'descr':descr, 'r':r, 'rmse':rmse, 'mae':mae, 'color':rColor, 'img':os.path.basename(outFig)}, index=[0])\n outCSV = outFig.replace('.png','.csv')\n df.to_csv(outCSV, ',', index=False)","def main():\n tot = []\n with open(intersect) as fil:\n for line in fil:\n data = []\n if len(line) > 1:\n rec = int_parse(line)\n win = find_winID(rec.wst, w)\n if int(rec.gst) != -1:\n imp = rec.info.rstrip().split(';')\n ID = imp[0].split('=')[1]\n Name = imp[1].split('=')[1]\n if imp[2].startswith('fullname'):\n fullname = imp[2].split('=')[1]\n if imp[3].startswith('Alias'):\n Alias = imp[3].split('=')[1]\n Ontology_term = imp[4].split('=')[1]\n Dbxref = imp[5].split('=')[1]\n GO, _ = split_ont(Ontology_term)\n _, SO = split_ont(Ontology_term)\n gst = rec.gst\n gen = rec.gen\n else:\n Alias = 'NA'\n Ontology_term = imp[3].split('=')[1]\n Dbxref = imp[4].split('=')[1]\n GO, _ = split_ont(Ontology_term)\n _, SO = split_ont(Ontology_term)\n gst = rec.gst\n gen = rec.gen\n else:\n fullname = 'NA'\n if imp[2].startswith('Alias'):\n Alias = imp[2].split('=')[1]\n Ontology_term = imp[3].split('=')[1]\n Dbxref = imp[4].split('=')[1]\n GO, _ = split_ont(Ontology_term)\n _, SO = split_ont(Ontology_term)\n gst = rec.gst\n gen = rec.gen\n else:\n Alias = 'NA'\n Ontology_term = imp[2].split('=')[1]\n Dbxref = imp[3].split('=')[1]\n GO, _ = split_ont(Ontology_term)\n _, SO = split_ont(Ontology_term)\n gst = rec.gst\n gen = rec.gen\n else:\n ID = 'NA'\n Name = 'NA'\n fullname = 'NA'\n gst = 'NA'\n gen = 'NA'\n Alias = 'NA'\n GO = 'NA'\n SO = 'NA'\n Dbxref = 'NA'\n data.append(ID)\n data.append(Name)\n data.append(fullname)\n data.append(gst)\n data.append(gen)\n data.append(Alias)\n data.append(GO)\n data.append(SO)\n data.append(Dbxref)\n data.append(rec.chrom)\n data.append(win)\n tot.append(tuple(data))\n writeTable(tot)","def p_and_l_from(files):\n if isinstance(files, str):\n files = [files]\n paths = []\n labels = []\n for file in files:\n print(f'read {file}')\n with open(file, 'r') as f:\n lines = f.readlines()\n for line in lines:\n line = line.split(' ')\n paths.append(line[0])\n labels.append(int(line[1]))\n return [paths, labels]","def make_libfile():\n # wfc3_obsmodes_uvis\n wfc3_uvis = [\n \"f218w\",\n \"f225w\",\n \"f275w\",\n \"f336w\",\n \"f390m\",\n \"f390w\",\n \"f410m\",\n \"f438w\",\n \"f467m\",\n \"f475w\",\n \"f547m\",\n \"f555w\",\n \"f606w\",\n \"f621m\",\n \"f625w\",\n \"f689m\",\n \"f763m\",\n \"f775w\",\n \"f814w\",\n \"f845m\",\n ]\n\n wfc3_ir = [\n \"f098m\",\n \"f105w\",\n \"f110w\",\n \"f125w\",\n \"f127m\",\n \"f139m\",\n \"f140w\",\n \"f153m\",\n \"f160w\",\n ]\n\n wfpc2 = [\n \"f122m\",\n \"f157w\",\n \"f336w\",\n \"f410m\",\n \"f467m\",\n \"f547m\",\n \"f439w\",\n \"f569w\",\n \"f675w\",\n \"f791w\",\n \"f170w\",\n \"f185w\",\n \"f218w\",\n \"f255w\",\n \"f300w\",\n \"f380w\",\n \"f555w\",\n \"f622w\",\n \"f450w\",\n \"f606w\",\n \"f702w\",\n \"f814w\",\n ]\n\n acs_wfc = [\n \"f435w\",\n \"f475w\",\n \"f550m\",\n \"f555w\",\n \"f606w\",\n \"f625w\",\n \"f775w\",\n \"f814w\",\n ]\n # galex\n galex = [\"fuv\", \"nuv\"]\n\n # Open hd5 file for writing\n hf = h5py.File(__ROOT__ + \"filters.hd5\", \"w\")\n\n # Create group for nice hierarchical structure\n f = hf.create_group(\"filters\")\n\n # Define arrays for \"contents\" / descriptive information\n tablenames = []\n observatories = []\n instruments = []\n names = []\n norms = []\n cwaves = []\n pwaves = []\n comments = []\n\n # Loop through WFC3_UVIS filters\n for filt in wfc3_uvis:\n\n # define uvis 1 and uvis2 modes\n mode_1 = \"wfc3, uvis1, \" + filt\n mode_2 = \"wfc3, uvis2, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp_1 = stsyn.band(mode_1)\n bp_2 = stsyn.band(mode_2)\n\n # extract the wavelength array\n wave = bp_1.waveset\n\n # compute the average bandpass between uvis1 and uvis2\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\n\n # define the filter name\n filter_name = \"HST_WFC3_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"WFC3\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"avg of uvis1 and uvis2\")\n\n # Loop through WFC3_IR filters\n for filt in wfc3_ir:\n\n # define ir mode\n mode = \"wfc3, ir, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp = stsyn.band(mode)\n\n # extract the wavelength array\n wave = bp.waveset\n\n # define the filter name\n filter_name = \"HST_WFC3_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"WFC3\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"\")\n\n # Loop through WFPC2 filters\n for filt in wfpc2:\n\n # define chips 1, 2, 3, 4 modes\n mode_1 = \"wfpc2, 1, \" + filt\n mode_2 = \"wfpc2, 2, \" + filt\n mode_3 = \"wfpc2, 3, \" + filt\n mode_4 = \"wfpc2, 4, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp_1 = stsyn.band(mode_1)\n bp_2 = stsyn.band(mode_2)\n bp_3 = stsyn.band(mode_3)\n bp_4 = stsyn.band(mode_4)\n\n # extract the wavelength array\n wave = bp_1.waveset\n\n # compute the average bandpass between uvis1 and uvis2\n bp_avg = np.average([bp_1(wave), bp_2(wave), bp_3(wave), bp_4(wave)], axis=0)\n\n # define the filter name\n filter_name = \"HST_WFPC2_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"WFPC2\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"avg of 1, 2, 3, 4\")\n\n # Loop through ACS filters\n for filt in acs_wfc:\n\n # define wfc1, wfc2 modes\n mode_1 = \"acs, wfc1, \" + filt\n mode_2 = \"acs, wfc2, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp_1 = stsyn.band(mode_1)\n bp_2 = stsyn.band(mode_2)\n\n # extract the wavelength array\n wave = bp_1.waveset\n\n # compute the average bandpass between uvis1 and uvis2\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\n\n # define the filter name\n filter_name = \"HST_ACS_WFC_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"ACS_WFC\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"avg of wfc1 and wfc2\")\n\n # Loop through GALEX filters:\n for filt in galex:\n # define ir mode\n mode = \"galex,\" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp = stsyn.band(mode)\n\n # extract the wavelength array\n wave = bp.waveset\n\n # define the filter name\n filter_name = \"GALEX_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"GALEX\")\n instruments.append(\"GALEX\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"\")\n\n # smash the contents arrays together\n contents = np.array(\n list(\n zip(\n tablenames,\n observatories,\n instruments,\n names,\n norms,\n cwaves,\n pwaves,\n comments,\n )\n ),\n dtype=[\n (\"TABLENAME\", \"S40\"),\n (\"OBSERVATORY\", \"S30\"),\n (\"INSTRUMENT\", \"S30\"),\n (\"NAME\", \"S10\"),\n (\"NORM\", \"<f8\"),\n (\"CWAVE\", \"<f8\"),\n (\"PWAVE\", \"<f8\"),\n (\"COMMENT\", \"S100\"),\n ],\n )\n\n # add the contents array as an hd5 dataset\n hf.create_dataset(\"content\", data=contents)\n\n # close the file\n hf.close()","def join(args):\n from jcvi.formats.agp import OO, Phases, build\n from jcvi.formats.sizes import Sizes\n\n p = OptionParser(join.__doc__)\n p.add_option(\"--newid\", default=None, help=\"New sequence ID\")\n p.add_option(\n \"--gapsize\",\n default=100,\n type=\"int\",\n help=\"Number of N's in between the sequences\",\n )\n p.add_option(\"--gaptype\", default=\"contig\", help=\"Gap type to use in the AGP file\")\n p.add_option(\n \"--evidence\", default=\"\", help=\"Linkage evidence to report in the AGP file\"\n )\n p.add_option(\"--oo\", help=\"Use .oo file generated by bambus\")\n opts, args = p.parse_args(args)\n\n nargs = len(args)\n if nargs not in (1, 2):\n sys.exit(not p.print_help())\n\n if nargs == 2:\n fastafile, phasefile = args\n phases = DictFile(phasefile)\n phases = dict((a, Phases[int(b)]) for a, b in phases.items())\n else:\n (fastafile,) = args\n phases = {}\n\n sizes = Sizes(fastafile)\n prefix = fastafile.rsplit(\".\", 1)[0]\n agpfile = prefix + \".agp\"\n newid = opts.newid\n oo = opts.oo\n\n o = OO(oo, sizes.mapping)\n\n if oo:\n seen = o.contigs\n # The leftover contigs not in the oo file\n logging.debug(\n \"A total of {0} contigs ({1} in `{2}`)\".format(len(sizes), len(seen), oo)\n )\n\n for ctg, size in sizes.iter_sizes():\n if ctg in seen:\n continue\n o.add(ctg, ctg, size)\n\n else:\n if newid:\n for ctg, size in sizes.iter_sizes():\n o.add(newid, ctg, size)\n else:\n for scaffold_number, (ctg, size) in enumerate(sizes.iter_sizes()):\n object_id = \"scaffold{0:03d}\".format(scaffold_number + 1)\n o.add(object_id, ctg, size)\n\n fw = open(agpfile, \"w\")\n o.write_AGP(\n fw,\n gapsize=opts.gapsize,\n gaptype=opts.gaptype,\n evidence=opts.evidence,\n phases=phases,\n )\n fw.close()\n\n joinedfastafile = prefix + \".joined.fasta\"\n build([agpfile, fastafile, joinedfastafile])\n\n return joinedfastafile","def sub_graph_merging(self):","def graph(automaton,graph_name=\"finite_state_machine\",file_name=\"finite_state_machine.gv\"):\n letter = next(iter(automaton.states))[0]\n grph = Digraph(graph_name,filename=file_name)\n grph.attr(rankdir=letter, size='8,5')\n #specifying final nodes \n grph.attr('node', shape='doublecircle')\n for state in automaton.final_states:\n grph.node(state)\n #creating edges\n \n grph.attr('node', shape='circle')\n if(isinstance(automaton,DFA)):\n grph =addEdgesDFA(grph,automaton)\n grph.edge(\"\",automaton.initial_state,\"\")\n grph.edge(\"\",automaton.initial_state,\"\")\n else:\n grph =addEdgesNFA(grph,automaton) \n return grph","def merge(self, g1, g2):\n logger = logging.getLogger(__name__)\n \n \n g = BaseGraph()\n g.copy_graph_from(g1)\n\n plwn2sumo_dict = defaultdict(set)\n plwn2sumo_dict = self.get_plwn2sumo_dict()\n\n synset_on_vertex_dict = {}\n for node in g.all_nodes():\n synset_id = node.synset.synset_id\n if synset_id in synset_on_vertex_dict:\n logger.warning(\"ID of some synset is not unique.\")\n continue\n synset_on_vertex_dict[synset_id] = node\n\n num_of_edge = 0\n for edge in g2.all_edges():\n num_of_edge += 1\n logger.info(\"%d/%d\", num_of_edge, g2.num_edges())\n\n parent_sumo_concept = edge.source().sumo\n child_sumo_concept = edge.target().sumo\n\n if parent_sumo_concept not in plwn2sumo_dict:\n logger.warning(\"The mapping file doesn't contain sumo concept '%s'.\", parent_sumo_concept)\n continue\n if child_sumo_concept not in plwn2sumo_dict:\n logger.warning(\"The mapping file doesn't contain sumo concept '%s'.\", child_sumo_concept)\n continue\n\n for parent_syn_id in plwn2sumo_dict[parent_sumo_concept]:\n if parent_syn_id not in synset_on_vertex_dict:\n logger.warning(\"The mapping file contains synset '%d' that is not in the graph.\", parent_syn_id)\n continue\n p_node = synset_on_vertex_dict[parent_syn_id]\n for child_syn_id in plwn2sumo_dict[child_sumo_concept]:\n if child_syn_id not in synset_on_vertex_dict:\n logger.warning(\"The mapping file contains synset '%d' that is not in the graph.\", child_syn_id)\n continue\n ch_node = synset_on_vertex_dict[child_syn_id]\n \n g.add_edge(p_node,\n ch_node,\n [(\"rel\", edge.rel)],\n simply=True)\n \n\n return g","def paesi_example():\n router = Router(building_file=PROJECT_PATH + \"geographycal_data/paesi_elev/paesi_elev\")\n router.clusters(router.graph)\n router.write2shp(router.acqueduct, \"acqueduct1\")","def calculateOverlap(mfaPairs, exons1, exons2):\n exonSize = 0\n noMatchToExons = 0\n noMatchToNonExons = 0\n noMatchToGapsInExons = 0\n noMatchToGapsNotInExons = 0\n \n p = -100000\n for i in exons1:\n exonSize += i[1] - i[0]\n for j in xrange(i[0], i[1]):\n k = mfaPairs[j]\n l = k\n if k == GAP:\n l = p \n for m in exons2:\n if(l >= m[0] and l < m[1]):\n if k == GAP:\n noMatchToGapsInExons += 1\n else:\n noMatchToExons += 1\n break\n else:\n if k == GAP:\n noMatchToGapsNotInExons += 1\n else:\n noMatchToNonExons += 1\n if k != GAP:\n p = k\n return (exonSize, noMatchToExons, noMatchToNonExons,\\\n noMatchToGapsInExons, noMatchToGapsNotInExons)","def assemble(filename):\n count = 0\n index = { } # Keys are names, values are graph indices.\n with open(filename, 'r') as f:\n size = int(f.readline().strip())\n G = Graph(size)\n for line in f:\n words = line.split()\n s = index.get(words[0], None)\n d = index.get(words[1], None)\n if s == None: # Here we are\n s = index[words[0]] = count # making sure\n count += 1 # we use index\n if d == None: # that is not\n d = index[words[1]] = count # yet in the\n count += 1 # graph.\n w = int(words[2])\n G.add(s,d,w)\n return G,index","def pattern_matching(pattern_base, cc_pattern_base):\n papers = [os.path.join(target_folder, paper) for paper in os.listdir(target_folder) if \".xml\" in paper]\n \n for paper in papers:\n paper_text = open(paper[:paper.index('.')]+\".txt\", 'r').read()\n \n annotator = detect_change_events(paper, pattern_base, paper_text) \n annotator = detect_cause_correlation(paper_text, cc_pattern_base, annotator)\n \n # Write the annotations to file\n with open(paper[:paper.index('.')]+\".ann\", 'w') as annfile:\n for annotation in annotator.annotations:\n annfile.write(annotation+\"\\n\")","def main():\n args = get_args()\n FILE = args.FILE\n annotations = args.annotations\n outfile = args.outfile\n \n \n if not os.path.isfile(FILE):\n die('\"{}\" is not a file'.format(FILE))\n if not os.path.isfile(annotations):\n die('\"{}\" is not a file'.format(annotations))\n if os.path.isfile(FILE) and os.path.isfile(annotations):\n reader = csv.DictReader(open(FILE), delimiter = '\\t', fieldnames = (\"qseqid\", \"sseqid\", \"pident\", \"length\", \"mismatch\", \"gapopen\", \"qstart\", \"qend\", \"sstart\", \"send\", \"evalue\", \"bitscore\"))\n reader_a = csv.DictReader(open(annotations), fieldnames = (\"centroid\", \"domain\", \"kingdom\", \"phylum\", \"class\", \"order\", \"genus\", \"species\"))\n reader_b = csv.reader(open(annotations, 'r'))\n anno_dict = {}\n for row in reader_b:\n key1 = row[0]\n anno_dict[key1] = row[1:]\n\n #print(anno_dict)\n \n \"\"\"for dct in map(dict, reader_a):\n genus = (f\"{dct['genus']}\")\n species = (f\"{dct['species']}\")\n if genus == \"\": \n print(\"NA\")\n else:\n print(genus)\n if species == \"\":\n print(\"NA\")\n else:\n print(species)\"\"\"\n for dct in map(dict, reader):\n seq_id = (f\"{dct['sseqid']}\") \n pident = (f\"{dct['pident']}\")\n #print(seq_id)\n for dct_a in map(dict, reader_a):\n genus = (f\"{dct_a['genus']}\")\n species = (f\"{dct_a['species']}\")\n if any(seq_id == key for key in anno_dict): \n \"\"\"print(seq_id)\n print(pident)\n print(genus)\n print(species)\n #find a way to print genus and species of seq_id\n \"\"\"\n \n else:\n warn('Cannot find seq \"{}\" in lookup'.format(seq_id))\n \"\"\"for line_a in reader_a:\n an_id = (line_a['centroid']) \n print('\"{}\" is an_id'.format(an_id)) \n for line in reader:\n seq_id = (line['sseqid'])\n print('\"{}\" is seq_id'.format(seq_id))\n if seq_id == an_id:\n print(\"hi\")\n else:\n warn('Cannot find seq \"{}\" in lookup'.format(seq_id))\n \"\"\"\n #pprint.pprint(dict_list)\n #pprint.pprint(dict_list_a)\n #for key, value in d1.items():\n #if key is 'sseqid':\n #print(value)\n #print(dict_list_a['centroid']) ","def create_pos_overlap_metric(anchor_boxes):\n y, x, h, w = np.transpose(anchor_boxes)\n y0 = y - h // 2\n x0 = x - w // 2\n y1 = y + h // 2\n x1 = x + w // 2\n\n def pos_overlap(gt_boxes):\n pos_overlaps = []\n for gt_box in gt_boxes:\n gt_y0, gt_x0, gt_y1, gt_x1 = gt_box\n gt_area = (gt_x1 - gt_x0) * (gt_y1 - gt_y0)\n int_y0 = np.maximum(gt_y0, y0)\n int_x0 = np.maximum(gt_x0, x0)\n int_y1 = np.minimum(gt_y1, y1)\n int_x1 = np.minimum(gt_x1, x1)\n int_area = np.maximum(0, int_x1 - int_x0) * np.maximum(0, int_y1 - int_y0)\n pos_overlaps.append(int_area / gt_area)\n # Group by anchor boxes\n pos_overlaps = np.transpose(pos_overlaps)\n # Get max metric index\n gt_indices = np.argmax(pos_overlaps, axis=1)\n # Choose max metric\n pos_overlaps = np.squeeze(np.take_along_axis(pos_overlaps, gt_indices[:, np.newaxis], axis=1))\n # Take respective ground-truth boxes. No reason to return indices, at least in RPN\n gt_boxes = np.take(gt_boxes, gt_indices, axis=0)\n return pos_overlaps, gt_boxes\n return pos_overlap","def parse(self):\n count = [] #count for trainset_size\n with open(self.file) as f:\n for line in f:\n data = line.split(\" \")[0]\n filename = data[:-1]\n id = data[-1:]\n if (filename not in count):\n count.append(filename)\n\n acid = \"\"\n structure = \"\"\n with open(self.directory+\"/\"+filename+\".dssp\") as dssp:\n for i in range(28): #skip lines we don't need\n next(dssp)\n for line in dssp:\n if (line[9] != \" \" and line[10] == \" \" and line[11] == id and line[13] not in (\"*\",\"!\",\"B\",\"Z\",\"X\")):\n #amino acid sequence\n if (line[13].islower()):\n acid += \"C\"\n else:\n acid += line[13]\n\n #sequence of the structure\n if (line[16] in (\"H\",\"G\",\"I\")):\n structure += \"H\"\n elif (line[16] in (\"E\",\"B\")):\n structure += \"E\"\n else:\n structure += \"C\"\n\n if (len(count) > self.trainset_size):\n self.testset.append((acid,structure))\n else:\n self.trainset.append((acid,structure))","def single_epoch(g,rows,cols,midpoint):\n\n num_top = 10 \n #3 for 8x8\n one_to_select = 0 \n top_nodes = g.top_n_nodes(num_top)\n '''\n for k in range(num_top):\n node_num = top_nodes[k]\n trip_list = g.node2trip_ids[node_num]\n print \"Next Midpoint: %d\" % k\n print node_num\n print g.node_to_coords(node_num)\n print \"Num trips: %d\" % len(trip_list)\n for i in range(len(trip_list)):\n trip_id = trip_list[i]\n line_num = g.trip_id2line_num[trip_id]\n p = Path(trip_id,g,line_num)\n \"\"\"\n print i\n print trip_id\n p.print_path()\n for i in range(p.graph.num_edges):\n if p.edges[i]:\n sys.stdout.write(\"%d, \" % (i + 1))\n sys.stdout.write(\"\\n\")\n sys.stdout.write(\"1s: \")\n for key in p.partials.keys():\n if p.partials[key]:\n sys.stdout.write(\"%d, \" % (key + 1))\n sys.stdout.write(\"\\n0s: \")\n for key in p.partials.keys():\n if not p.partials[key]:\n sys.stdout.write(\"%d, \" % (key + 1))\n sys.stdout.write(\"\\n\")\n #\"\"\"\n '''\n\n #trip_list = g.node2trip_ids[g.best_node]\n #midpoint = top_nodes[one_to_select]\n trip_list = g.node2trip_ids[midpoint]\n print \"Selected midpoint: %d\" % midpoint \n print g.node_to_coords(midpoint)\n out_file = open(\"datasets/full_data_%d_%d_%d.txt\" % (rows,cols,midpoint),'w')\n partial_file = open(\"datasets/partials_%d_%d_%d.txt\" % (rows,cols,midpoint), 'w')\n for i in range(len(trip_list)):\n trip_id = trip_list[i]\n line_num = g.trip_id2line_num[trip_id]\n p = Path(trip_id,g,line_num=line_num,midpoint=midpoint)\n \"\"\"\n print i\n print trip_id\n p.print_path()\n for i in range(p.graph.num_edges):\n if p.edges[i]:\n sys.stdout.write(\"%d, \" % (i + 1))\n sys.stdout.write(\"\\n\")\n sys.stdout.write(\"1s: \")\n for key in p.partials.keys():\n if p.partials[key]:\n sys.stdout.write(\"%d, \" % (key + 1))\n sys.stdout.write(\"\\n0s: \")\n for key in p.partials.keys():\n if not p.partials[key]:\n sys.stdout.write(\"%d, \" % (key + 1))\n sys.stdout.write(\"\\n\")\n \"\"\"\n out_string = str(p.edges)[1:-1]\n out_file.write(\"%s\\n\" % out_string)\n for i in range(p.graph.num_edges):\n if i in p.partials.keys():\n partial_file.write(\"%d\" % p.partials[i])\n else:\n partial_file.write(\"-1\")\n if i < p.graph.num_edges-1:\n partial_file.write(\",\")\n partial_file.write(\"\\n\")\n\n out_file.close()","def _CreateGraph(self):\n self.nodes = []\n self.edges = []\n for i, r in self.airports.set_index('airport_id').iterrows():\n self.nodes.append((i,r.to_dict()))\n for i, r in self.routes.set_index(['src_id','dst_id']).iterrows():\n self.edges.append((i[0],i[1],r.to_dict()))\n # print('node ex: {}'.format(self.nodes[0]))\n # print('edge ex: {}'.format(self.edges[0]))\n\n self.graph = self._CreateAdjacencyListGraph()"],"string":"[\n \"def overlap_graph(input, overlap):\\n\\n sequence_dict = {}\\n seq_id_list = []\\n\\n for seq_record in SeqIO.parse(input, \\\"fasta\\\"): # change input variable.\\n sequence_dict[seq_record.id] = seq_record.seq\\n seq_id_list.append(seq_record.id)\\n\\n adjacency_list= []\\n\\n index = overlap\\n\\n for id in seq_id_list:\\n neg_index = (index * -1)\\n for k in sequence_dict:\\n\\n if id == k:\\n pass\\n\\n elif id != k:\\n if sequence_dict[id][neg_index:] == sequence_dict[k][0:index]:\\n adjacency_list.append(f\\\"{id} {k}\\\".format(id=id, k=k))\\n\\n #print(\\\"\\\\nyes\\\")\\n #print(id, sequence_dict[id][neg_index:], \\\"and\\\", k, sequence_dict[k][0:index], \\\"\\\\n\\\")\\n else:\\n pass\\n\\n #print(\\\"no\\\")\\n #print(id, sequence_dict[id][neg_index:], \\\"and\\\", k, sequence_dict[k][0:index])\\n open(\\\"output.txt\\\", \\\"w\\\")\\n with open(\\\"output.txt\\\", \\\"a\\\") as out:\\n for x in adjacency_list:\\n out.write(f\\\"{x}\\\\n\\\".format(x=x))\",\n \"def get_overlaps(file_name):\\r\\n\\r\\n place = {}\\r\\n size = {}\\r\\n sap = {}\\r\\n overlapping = []\\r\\n active_list = []\\r\\n max_width = 0\\r\\n\\r\\n with open(file_name + \\\".scl\\\") as f:\\r\\n for i, line in enumerate(f):\\r\\n\\r\\n line = line.strip()\\r\\n if line:\\r\\n if line.split()[0] == \\\"Sitespacing\\\":\\r\\n sitespacing = line.split()[2]\\r\\n if line.split()[0] == \\\"SubrowOrigin\\\":\\r\\n starting_x = line.split()[2]\\r\\n ending_x = int(starting_x) + int(sitespacing) * int(line.split()[5])\\r\\n if ending_x > max_width:\\r\\n max_width = ending_x\\r\\n\\r\\n divider = max_width // 10\\r\\n\\r\\n with open(file_name + \\\".nodes\\\") as f:\\r\\n for i, line in enumerate(f):\\r\\n\\r\\n line = line.strip()\\r\\n if line:\\r\\n if re.match(r'[a-z]{1}[0-9]+', line.split()[0]):\\r\\n if len(line.split()) == 3:\\r\\n size[line.split()[0]] = [line.split()[1], line.split()[2]]\\r\\n\\r\\n with open(file_name + \\\".pl\\\") as f:\\r\\n for i, line in enumerate(f):\\r\\n\\r\\n line = line.strip()\\r\\n if line:\\r\\n if re.match(r'[a-z]{1}[0-9]+', line.split()[0]):\\r\\n if line.split()[0] in size:\\r\\n place[line.split()[0]] = [line.split()[1], line.split()[2]]\\r\\n sap_num = int(line.split()[1]) // divider\\r\\n if sap_num not in sap.keys():\\r\\n sap[sap_num] = []\\r\\n sap[sap_num].append([line.split()[0], int(line.split()[1]),\\r\\n int(line.split()[1]) + int(size[line.split()[0]][0]), int(line.split()[2]),\\r\\n \\\"start\\\"])\\r\\n\\r\\n sap[sap_num].append([line.split()[0], int(line.split()[1]),\\r\\n int(line.split()[1]) + int(size[line.split()[0]][0]),\\r\\n int(line.split()[2]) + int(size[line.split()[0]][1]), \\\"end\\\"])\\r\\n\\r\\n for lista in sap.values():\\r\\n lista.sort(key=lambda x: x[3])\\r\\n lista.sort(key=lambda x: x[4], reverse=True)\\r\\n for element in lista:\\r\\n if element[4] == \\\"start\\\":\\r\\n if len(active_list) == 0:\\r\\n active_list.append(element[0])\\r\\n else:\\r\\n for node in active_list:\\r\\n if int(place[node][0]) < int(place[element[0]][0]) + int(size[element[0]][0]) \\\\\\r\\n and int(place[node][0]) + int(size[node][0]) > int(place[element[0]][0]) \\\\\\r\\n and int(place[node][1]) < int(place[element[0]][1]) + int(size[element[0]][1]) \\\\\\r\\n and int(place[node][1]) + int(size[node][1]) > int(place[element[0]][1]):\\r\\n overlap = (node, element[0])\\r\\n overlapping.append(overlap)\\r\\n active_list.append(element[0])\\r\\n else:\\r\\n active_list.remove(element[0])\\r\\n return overlapping\",\n \"def check_overlap(gfa_, path, external_file):\\n if external_file:\\n fasta_dict = fasta_reader(path, external_file)\\n if not fasta_dict:\\n return None\\n\\n eid_dict = dict()\\n node_dict = dict()\\n\\n count_consistency = 0\\n count_no_defined = 0\\n edges_no_consistency = []\\n edges_no_calculate = []\\n edge_no_text = 0\\n\\n data_edges = gfa_.edge()\\n for node1 in data_edges:\\n for node2 in data_edges[node1]:\\n for eid in data_edges[node1][node2]:\\n if not eid_dict.get(eid):\\n eid_dict[eid] = True\\n from_id = data_edges[node1][node2][eid]['from_node']\\n try:\\n node_dict[from_id] = gfa_.node()[from_id]['sequence']\\n except KeyError:\\n edge_no_text += 1\\n break\\n to_id = data_edges[node1][node2][eid]['to_node']\\n try:\\n node_dict[to_id] = gfa_.node()[to_id]['sequence']\\n except KeyError:\\n edge_no_text += 1\\n break\\n\\n from_orn = data_edges[node1][node2][eid]['from_orn']\\n to_orn = data_edges[node1][node2][eid]['to_orn']\\n overlap = int(data_edges[node1][node2][eid]['alignment'].rstrip('M'))\\n\\n if node_dict[from_id] == '*' and external_file:\\n node_dict[from_id] = fasta_dict.get(from_id, '*')\\n if node_dict[from_id] == '*':\\n GRAPH_LOGGER.debug('Node %s has sequence no specify!', from_id)\\n if node_dict[to_id] == '*' and external_file:\\n node_dict[to_id] = fasta_dict.get(to_id, '*')\\n if node_dict[to_id] == '*':\\n GRAPH_LOGGER.debug('Node %s has sequence no specify!', to_id)\\n\\n if not node_dict[from_id] == '*' and not node_dict[to_id] == '*':\\n check = consistency((from_id, to_id), \\\\\\n (node_dict[from_id], node_dict[to_id]), (from_orn, to_orn), overlap)\\n if check:\\n count_consistency += 1\\n else:\\n edges_no_consistency.append(eid)\\n else:\\n GRAPH_LOGGER.debug('Can\\\\'t check overlap consistency between \\\\\\n node %s and %s', from_id, to_id)\\n count_no_defined += 1\\n edges_no_calculate.append(eid)\\n\\n GRAPH_LOGGER.debug('%s edge overlap are consistency of total amount of %s', \\\\\\n count_consistency, len(eid_dict)-edge_no_text)\\n\\n return edges_no_consistency, edges_no_calculate\",\n \"def overlap(fields) :\\n\\n r13=apload.ApLoad(apred='r13')\\n f=[]\\n a=[]\\n for field in fields :\\n f.append(fits.open(field+'/'+field+'_rv.fits'))\\n a.append( r13.apFieldVisits(field))\\n\\n outdir=fields[0]+'_'+fields[1]\\n try: os.makedirs(outdir)\\n except: pass\\n\\n fp=open(outdir+'/'+outdir+'.html','w')\\n fp.write('<HTML>\\\\n')\\n fp.write('<HEAD><script type=text/javascript src=../html/sorttable.js></script></head>')\\n fp.write('<BODY>\\\\n')\\n fp.write('<TABLE BORDER=2>\\\\n')\\n\\n matplotlib.use('Agg')\\n i1,i2=match.match(f[0][1].data['APOGEE_ID'],f[1][1].data['APOGEE_ID'])\\n colors=['g','r','b','m']\\n for star in f[0][1].data['APOGEE_ID'][i1] :\\n print(star)\\n fp.write('<TR><TD>{:s}<BR>\\\\n'.format(star))\\n fp.write('<TABLE BORDER=2>\\\\n')\\n fig,ax=plots.multi(1,1)\\n for i,field in enumerate(f) :\\n j=np.where(field[2].data['APOGEE_ID'] == star)[0]\\n plots.plotp(ax,field[2].data['MJD'][j],field[2].data['VHELIO'][j],color=colors[i],size=10)\\n j=np.where(field[1].data['APOGEE_ID'] == star)[0][0]\\n fp.write('<TR><TD>Doppler<TD>{:8.2f}<TD>{:8.2f}<TD>{:8.0f}<TD>{:8.2f}<TD>{:8.2f}\\\\n'.format(\\n field[1].data['VHELIO_AVG'][j],field[1].data['VSCATTER'][j],\\n field[1].data['RV_TEFF'][j],field[1].data['RV_LOGG'][j],field[1].data['RV_FEH'][j]))\\n for i,field in enumerate(a) :\\n j=np.where(field[1].data['APOGEE_ID'] == star)[0]\\n gd=np.where(np.abs(field[1].data['VHELIO'][j]) < 999)[0]\\n plots.plotp(ax,field[1].data['MJD'][j[gd]],field[1].data['VHELIO'][j[gd]],color=colors[i+2],size=10)\\n #fp.write('<TR><TD>IDL<TD>{:8.2f}<TD>{:8.2f}<TD>{:8.2f}<TD>{:8.0f}<TD>{:8.2f}<TD>{:8.2f}\\\\n'.format(\\n # field[1].data['VHELIO_AVG'],field[1].data['VSCATTER'],\\n # field[1].data['RV_TEFF'],field[1].data['RV_LOGG'],field[1].data['RV_FEH']))\\n plt.draw()\\n plt.close()\\n fig.savefig(outdir+'/'+star+'.png')\\n fp.write('</TABLE>\\\\n')\\n fp.write('<TD><a HREF={:s}.png> <IMG SRC={:s}.png> </a>\\\\n'.format(star,star))\\n fp.write('</TABLE>')\\n fp.close()\",\n \"def getConf(ppiFile):\\n validpattern = re.compile('^[\\\\w _\\\\-.,\\\\t\\\"\\\\':;]+$')\\n splitpattern = re.compile('[\\\\t ;,]+')\\n numericpattern = re.compile('^[0-9. \\\\t,\\\\-]+')\\n\\t### collect node names ###\\n finfile = open(ppiFile, 'r')\\n names = {}\\n index = 0\\n for temp in finfile:\\n temp = temp.strip('\\\\t \\\\n\\\\r')\\n if temp == \\\"\\\" or (re.search(validpattern, temp) is None):\\n continue\\n allwords = re.split(splitpattern, temp)\\n for i in xrange(0, 2):\\n if re.match(numericpattern, allwords[i]) is not None:\\n temp = \\\"Error: file inconsistent\\\"\\n temp = temp + \\\"(possible node ID is numeric)\\\"\\n temp = temp + \\\" \\\" + allwords[i]\\n print >> sys.stderr, temp\\n exit(1)\\n if allwords[0] not in names:\\n names[allwords[0]] = index\\n index = index + 1\\n if allwords[1] not in names:\\n names[allwords[1]] = index\\n index = index + 1\\n finfile.close()\\n names = collections.OrderedDict(sorted(names.items(), key=lambda x: x[1]))\\n N = index\\n ppbConf = np.zeros((N, N))\\n\\t### collect edges ###\\n finfile = open(ppiFile, 'r')\\n for temp in finfile:\\n temp = temp.strip('\\\\t \\\\n\\\\r')\\n if temp == \\\"\\\" or (re.search(validpattern, temp) is None):\\n continue\\n allwords = re.split(splitpattern, temp)\\n i = names[allwords[0]]\\n j = names[allwords[1]]\\n templen = len(temp)\\n # allow for tab or space delimiters\\n temp = temp.split('\\\\t')\\n if templen == len(temp):\\n \\ttemp = temp.split(' ')\\n \\t\\n if len(temp) > 2:\\n confidence = temp[2]\\n else:\\n confidence = 1\\n if i != j:\\n ppbConf[i, j] = confidence\\n ppbConf[j, i] = confidence\\n finfile.close()\\n return (ppbConf, names)\",\n \"def generatePhasingScore(options,phase,cycle):\\n score,readcount,readseq=readDataForPhasingScoreComputation(options,phase)\\n phased_loci_filename=options.output_directory_per_run+\\\"/\\\"+options.input_filename+\\\"_\\\"+str(phase)+\\\"_\\\"+str(cycle)+\\\".positive_phase_loci\\\"\\n final_phase_loci=options.output_directory_per_run+\\\"/\\\"+options.input_filename+\\\"_\\\"+str(phase)+\\\"_\\\"+str(cycle)+\\\".phasing_score_phase_loci\\\"\\n fhr=open(phased_loci_filename,\\\"r\\\")\\n out4=open(final_phase_loci,\\\"w\\\")\\n for line in fhr:\\n chromosome,ss,ee=line.strip().split()\\n ss=int(ss)\\n ee=int(ee)\\n #correct=list(range(ss,ee+1,phase))\\n phasing_score_filename=options.output_directory_per_run+\\\"/\\\"+str(phase)+\\\"_\\\"+str(chromosome)+\\\"_\\\"+str(ss)+\\\"_\\\"+str(ee)+\\\".phasing_score\\\"\\n abundance_score_filename=options.output_directory_per_run+\\\"/\\\"+str(phase)+\\\"_\\\"+str(chromosome)+\\\"_\\\"+str(ss)+\\\"_\\\"+str(ee)+\\\".abundance\\\"\\n out=open(phasing_score_filename,\\\"w\\\")\\n out2=open(abundance_score_filename,\\\"w\\\")\\n score_count={}\\n for site in range(ss,ee+1):\\n start=site-(phase*4)\\n end=site+(phase*5)-1\\n max_within_site,max_within_count,all_scores=0,0,0\\n for cor in range(start,end+1):\\n if cor not in score[chromosome]:continue\\n all_scores+=score[chromosome][cor]\\n for i in readcount[chromosome][cor]:\\n if max_within_count<readcount[chromosome][cor][i]:\\n max_within_site=cor\\n max_within_count=readcount[chromosome][cor][i]\\n all_scores-=max_within_count\\n P,k=0,0\\n s=start\\n while s<end:\\n if s not in score[chromosome]:\\n s+=phase\\n continue\\n if score[chromosome][s]!=0:\\n P+=score[chromosome][s]\\n k+=1\\n if s == max_within_site:\\n P-=max_within_count \\n s+=phase\\n U=all_scores-P\\n \\n #if U<0: continue\\n if k>=3:\\n #print(P,U,k)\\n phas_score=math.log((1+(10*(P/(1+U))))**(k-2))\\n \\\"\\\"\\\"if phas_score>max and site in correct:\\n max=phas_score\\\"\\\"\\\"\\n else:\\n phas_score=0\\n out.write(str(site)+\\\"\\\\t\\\"+str(phas_score)+\\\"\\\\n\\\")\\n out4.write(chromosome+\\\"\\\\t\\\"+str(site)+\\\"\\\\t\\\"+str(phas_score)+\\\"\\\\n\\\")\\n if chromosome not in score_count:\\n score_count[chromosome]={}\\n if site not in score_count[chromosome]:\\n score_count[chromosome][site]=phas_score\\n if site in readcount[chromosome] and '+' in readcount[chromosome][site] and readcount[chromosome][site]['+']!=0:\\n out2.write(str(site)+\\\"\\\\t\\\"+str(readcount[chromosome][site]['+'])+\\\"\\\\n\\\")\\n if site in readcount[chromosome] and '-' in readcount[chromosome][site] and readcount[chromosome][site]['-']!=0:\\n out2.write(str(site)+\\\"\\\\t-\\\"+str(readcount[chromosome][site]['-'])+\\\"\\\\n\\\")\\n out.close()\\n out2.close()\\n \\n #out4.write(chromosome+\\\"\\\\t\\\"+str(ss)+\\\"\\\\t\\\"+str(ee)+\\\"\\\\t\\\"+str(phas_score)+\\\"\\\\n\\\")\\n out4.close()\",\n \"def acogps(f_path, min_supp=MIN_SUPPORT, evaporation_factor=EVAPORATION_FACTOR,\\n max_iteration=MAX_ITERATIONS, return_gps=False):\\n # 0. Initialize and prepare data set\\n d_set = DataGP(f_path, min_supp)\\n \\\"\\\"\\\":type d_set: DataGP\\\"\\\"\\\"\\n d_set.init_attributes()\\n # attr_index = d_set.attr_cols\\n # e_factor = evaporation_factor\\n d, attr_keys = gend(d_set.valid_bins) # distance matrix (d) & attributes corresponding to d\\n\\n a = d_set.attr_size\\n winner_gps = list() # subsets\\n loser_gps = list() # supersets\\n str_winner_gps = list() # subsets\\n repeated = 0\\n it_count = 0\\n counter = 0\\n\\n if d_set.no_bins:\\n return []\\n\\n # 1. Remove d[i][j] < frequency-count of min_supp\\n fr_count = ((min_supp * a * (a - 1)) / 2)\\n d[d < fr_count] = 0\\n\\n # 3. Initialize pheromones (p_matrix)\\n pheromones = np.ones(d.shape, dtype=float)\\n\\n invalid_count = 0\\n # 4. Iterations for ACO\\n # while repeated < 1:\\n while counter < max_iteration:\\n rand_gp, pheromones = genaco(attr_keys, d, pheromones, evaporation_factor)\\n if len(rand_gp.gradual_items) > 1:\\n # print(rand_gp.get_pattern())\\n exits = isduplicate(rand_gp, winner_gps, loser_gps)\\n if not exits:\\n repeated = 0\\n # check for anti-monotony\\n is_super = amcheck(loser_gps, rand_gp, subset=False)\\n is_sub = amcheck(winner_gps, rand_gp, subset=True)\\n if is_super or is_sub:\\n continue\\n gen_gp = validategp(d_set, rand_gp)\\n \\\"\\\"\\\":type gen_gp: GP\\\"\\\"\\\"\\n is_present = isduplicate(gen_gp, winner_gps, loser_gps)\\n is_sub = amcheck(winner_gps, gen_gp, subset=True)\\n if is_present or is_sub:\\n repeated += 1\\n else:\\n if gen_gp.support >= min_supp:\\n pheromones = update_pheromones(attr_keys, gen_gp, pheromones)\\n winner_gps.append(gen_gp)\\n str_winner_gps.append(gen_gp.print(d_set.titles))\\n else:\\n loser_gps.append(gen_gp)\\n invalid_count += 1\\n if set(gen_gp.get_pattern()) != set(rand_gp.get_pattern()):\\n loser_gps.append(rand_gp)\\n else:\\n repeated += 1\\n else:\\n invalid_count += 1\\n it_count += 1\\n if max_iteration == 1:\\n counter = repeated\\n else:\\n counter = it_count\\n # Output\\n out = json.dumps({\\\"Algorithm\\\": \\\"ACO-GRAD\\\", \\\"Best Patterns\\\": str_winner_gps, \\\"Invalid Count\\\": invalid_count,\\n \\\"Iterations\\\": it_count})\\n \\\"\\\"\\\":type out: object\\\"\\\"\\\"\\n if return_gps:\\n return out, winner_gps\\n else:\\n return out\",\n \"def main_load_nps(fileA, fileB):\\n \\n print \\\"- Loading the following non-dominated sets of two-dimensional\\\"\\n print \\\" objective vectors and computing the joint-EAF:\\\"\\n print \\\" * A:\\\", fileA\\n print \\\" * B:\\\", fileB\\n print\\n \\n npsetA = datasets.load_nps(fileA)\\n npsetB = datasets.load_nps(fileB)\\n assert len(npsetA) == len(npsetB), (\\\"The npsets must have the same length \\\"\\n \\\"(i.e. same number of executions)\\\")\\n\\n point_ind = eafindicators(npsetA, npsetB)\\n return point_ind\",\n \"def constraint_test():\\n import itertools, sys\\n\\n show_analysis = False\\n #Generated via grammar\\n gr = grammar.Grammar('grammars/test_constraints.bnf')\\n inputs = ([1 for _ in range(100)], [ i%3 for i in range(100)])\\n for _input in inputs: \\n output = gr.generate(_input)\\n azr = analyser.Analyser('test',output['phenotype'],True)\\n try:\\n azr.create_graph()\\n except ValueError as e:\\n print(__name__, \\\"ERROR\\\", _input, e)\\n continue\\n azr.parse_graph()\\n azr.apply_stresses()\\n azr.create_slf_file()\\n azr.test_slf_file()\\n azr.parse_results()\\n azr.print_stresses()\\n if show_analysis:\\n azr.show_analysis()\\n \\n #Fixed generated\\n lengths = (1000, 10000)\\n levels = (5, 10)\\n for length_idx, level_idx in itertools.permutations([0,1]):\\n try:\\n GRAPH = constrained_offset_graph(lengths[length_idx],\\n levels[length_idx])\\n except ValueError as e:\\n print(__name__, \\\"ERROR\\\", lengths[length_idx], levels[length_idx], e)\\n continue\\n GRAPH.save_graph(\\\"pylon\\\")\\n print \\\"nodes:\\\", GRAPH.number_of_nodes()\\n print \\\"edges\\\", GRAPH.number_of_edges()\\n #will it blend?\\n azr = analyser.Analyser('test',\\\"moo\\\",True)\\n azr.my_graph = GRAPH\\n azr.parse_graph()\\n azr.apply_stresses()\\n azr.create_slf_file()\\n azr.test_slf_file()\\n azr.parse_results()\\n azr.print_stresses()\\n if show_analysis:\\n azr.show_analysis()\",\n \"def build_from_file(self, topology_file, topology_format):\\n with open(topology_file) as infile:\\n for line in infile:\\n if line.startswith(\\\"#\\\"):\\n continue\\n else:\\n if topology_format == 0:\\n x = line.split(\\\"\\\\n\\\")[0].split(\\\"|\\\")\\n as1 = int(x[0])\\n as2 = int(x[1])\\n relationship = int(x[2])\\n else:\\n x = line.split(\\\"\\\\n\\\")[0].split(\\\"\\\\t\\\")\\n if x[2] == \\\"p2c\\\":\\n as1 = int(x[0])\\n as2 = int(x[1])\\n relationship = -1\\n elif x[2] == \\\"c2p\\\":\\n as1 = int(x[1])\\n as2 = int(x[0])\\n relationship = -1\\n elif x[2] == \\\"p2p\\\":\\n as1 = int(x[1])\\n as2 = int(x[0])\\n relationship = 0\\n else:\\n continue\\n\\n if not self.has_edge(as1, as2):\\n self.add_edge(as1, as2, relationship=relationship, as1=as1, as2=as2)\",\n \"def read_ao_overlap(self, path_rwfdump, fn_rwf):\\n os.system(path_rwfdump + f\\\" {fn_rwf} ao_overlap.dat 514R\\\")\\n\\n with open('ao_overlap.dat', \\\"r\\\") as f:\\n log = f.read()\\n\\n tmp = re.findall('[-]?\\\\d+\\\\.\\\\d+D[+-]\\\\d\\\\d', log)\\n tmp = [float(x.replace('D', 'e')) for x in tmp]\\n \\n tmp_ovr = np.zeros((self.nbasis * 2, self.nbasis * 2))\\n \\n cnt = 0\\n for ibasis in range(self.nbasis * 2):\\n for jbasis in range(ibasis + 1):\\n tmp_ovr[ibasis, jbasis] = tmp[cnt]\\n cnt += 1\\n\\n tmp_ovr += np.transpose(tmp_ovr) - np.diag(np.diag(tmp_ovr))\\n\\n # Slicing the components between t and t+dt\\n return tmp_ovr[:self.nbasis, self.nbasis:]\",\n \"def anchors_to_adjacency(set_path, n_proteomes, mailbox_reader):\\n frame_list = []\\n for idx in range(n_proteomes):\\n with mailbox_reader(idx) as file_handle:\\n frame_list.append(\\n pd.read_csv(\\n file_handle, sep=\\\"\\\\t\\\", index_col=0\\n ).convert_dtypes()\\n )\\n nodes = pd.concat(\\n frame_list,\\n ignore_index=True,\\n )\\n del frame_list\\n graph = nx.Graph()\\n for unused_tuple, subframe in nodes.groupby(\\n by=[\\\"syn.anchor.id\\\", \\\"syn.anchor.sub_id\\\"]\\n ):\\n ids = subframe[\\\"member_ids\\\"]\\n n_ids = len(ids)\\n graph.add_nodes_from(ids)\\n if n_ids > 1:\\n edges = combinations(ids, 2)\\n graph.add_edges_from(edges, weight=n_ids)\\n outpath = set_path / ANCHORS_FILE\\n summarypath = outpath.parent / (\\n outpath.name[: -len(outpath.suffix)] + \\\"_summary.tsv\\\"\\n )\\n histpath = outpath.parent / (\\n outpath.name[: -len(outpath.suffix)] + \\\"_hist.tsv\\\"\\n )\\n components = [\\n c\\n for c in sorted(nx.connected_components(graph), key=len, reverse=True)\\n if len(c) > 1\\n ]\\n fh = outpath.open(\\\"w\\\")\\n fh.write(\\\"idx\\\\tcluster_id\\\\tsize\\\\tmembers\\\\n\\\")\\n n_items = 0\\n count_list = []\\n hash_list = []\\n id_list = []\\n for i, comp in enumerate(components):\\n component = np.sort(pd.Index(list(comp)).to_numpy())\\n id_list.append(i)\\n size = len(comp)\\n count_list.append(size)\\n hash_list.append(hash_array(component))\\n for node in component:\\n fh.write(f\\\"{n_items}\\\\t{i}\\\\t{size}\\\\t{node}\\\\n\\\")\\n n_items += 1\\n fh.close()\\n n_clusts = len(count_list)\\n del graph, components\\n cluster_counts = pd.DataFrame({\\\"size\\\": count_list})\\n largest_cluster = cluster_counts[\\\"size\\\"].max()\\n cluster_hist = (\\n pd.DataFrame(cluster_counts.value_counts()).sort_index().reset_index()\\n )\\n cluster_hist = cluster_hist.set_index(\\\"size\\\")\\n cluster_hist = cluster_hist.rename(columns={0: \\\"n\\\"})\\n cluster_hist[\\\"item_pct\\\"] = (\\n cluster_hist[\\\"n\\\"] * cluster_hist.index * 100.0 / n_items\\n )\\n cluster_hist.to_csv(histpath, sep=\\\"\\\\t\\\", float_format=\\\"%5.2f\\\")\\n cluster_hist[\\\"cluster_pct\\\"] = cluster_hist[\\\"n\\\"] * 100.0 / n_clusts\\n cluster_hist.to_csv(histpath, sep=\\\"\\\\t\\\", float_format=\\\"%5.2f\\\")\\n clusters = pd.DataFrame(\\n {\\\"anchor.id\\\": id_list, \\\"count\\\": count_list, \\\"hash\\\": hash_list}\\n )\\n clusters.to_csv(summarypath, sep=\\\"\\\\t\\\")\\n stats_dict = {\\n \\\"in_anchor\\\": n_items,\\n \\\"syn.anchors.n\\\": n_clusts,\\n \\\"syn.anchors.largest\\\": largest_cluster,\\n }\\n return stats_dict\",\n \"def parcel_overlap(parcellation1, parcellation2, outpath):\\n p1_dat = nib.load(parcellation1).get_data()\\n p2_dat = nib.load(parcellation2).get_data()\\n p1regs = np.unique(p1_dat)\\n p1regs = p1regs[p1regs > 0]\\n p2regs = np.unique(p2_dat)\\n\\n p1n = get_filename(parcellation1)\\n p2n = get_filename(parcellation2)\\n\\n overlapdat = lil_matrix((p1regs.shape[0], p2regs.shape[0]), dtype=np.float32)\\n for p1idx, p1reg in enumerate(p1regs):\\n p1seq = p1_dat == p1reg\\n N = p1seq.sum()\\n poss_regs = np.unique(p2_dat[p1seq])\\n for p2idx, p2reg in enumerate(p2regs):\\n if p2reg in poss_regs:\\n # percent overlap is p1seq and'd with the anatomical region voxelspace, summed and normalized\\n pover = np.logical_and(p1seq, p2_dat == p2reg).sum() / float(N)\\n overlapdat[p1idx, p2idx] = pover\\n\\n outf = op.join(outpath, \\\"{}_{}.csv\\\".format(p1n, p2n))\\n with open(outf, \\\"w\\\") as f:\\n p2str = [\\\"%s\\\" % x for x in p2regs]\\n f.write(\\\"p1reg,\\\" + \\\",\\\".join(p2str) + \\\"\\\\n\\\")\\n for idx, p1reg in enumerate(p1regs):\\n datstr = [\\\"%.4f\\\" % x for x in overlapdat[idx,].toarray()[0,]]\\n f.write(str(p1reg) + \\\",\\\" + \\\",\\\".join(datstr) + \\\"\\\\n\\\")\\n f.close()\\n return\",\n \"def fasta(args):\\n from jcvi.formats.sizes import Sizes\\n from jcvi.formats.agp import OO, build\\n\\n p = OptionParser(fasta.__doc__)\\n opts, args = p.parse_args(args)\\n\\n if len(args) != 3:\\n sys.exit(not p.print_help())\\n\\n bedfile, scffasta, pmolfasta = args\\n pf = bedfile.rsplit(\\\".\\\", 1)[0]\\n bed = Bed(bedfile)\\n selected = select_bed(bed)\\n oo = OO()\\n seen = set()\\n sizes = Sizes(scffasta).mapping\\n agpfile = pf + \\\".agp\\\"\\n agp = open(agpfile, \\\"w\\\")\\n for b in selected:\\n scf = range_parse(b.accn).seqid\\n chr = b.seqid\\n cs = (chr, scf)\\n if cs not in seen:\\n oo.add(chr, scf, sizes[scf], b.strand)\\n seen.add(cs)\\n else:\\n logging.debug(\\\"Seen {0}, ignored.\\\".format(cs))\\n\\n oo.write_AGP(agp, gaptype=\\\"contig\\\")\\n agp.close()\\n build([agpfile, scffasta, pmolfasta])\",\n \"def overlap(path1, path2):\\n DataL1 = BedTool(path1).sort()\\n DataL2 = BedTool(path2).sort()\\n overlap = DataL1.intersect(DataL2, wao=True)\\n Overlap_df = overlap.to_dataframe()\\n Strand1 = list(Overlap_df.iloc[:, 5])\\n Strand2 = list(Overlap_df.iloc[:, 11])\\n p_p, m_m, p_m, m_p, same_strand, opposite_strand, convergent, divergent = orientation(Strand1, Strand2)\\n return p_p, m_m, p_m, m_p, same_strand, opposite_strand, convergent, divergent\",\n \"def loadFromFile():\\n try:\\n f1 = open( \\\"friendshipMap.p\\\", \\\"rb\\\" )\\n friendship_map = pickle.load(f1)\\n f1.close()\\n f2 = open( \\\"businessReviews.p\\\", \\\"rb\\\" )\\n business_reviews = pickle.load(f2)\\n f2.close()\\n f3 = open( \\\"degreeCentrality.p\\\", \\\"rb\\\" )\\n degree_centrality_map = pickle.load(f3)\\n f3.close()\\n f4 = open( \\\"closenessCentrality.p\\\", \\\"rb\\\" )\\n closeness_centrality_map = pickle.load(f4)\\n f4.close()\\n f5 = open( \\\"betweennessCentrality.p\\\", \\\"rb\\\" )\\n betweenness_centrality_map = pickle.load(f5)\\n f5.close()\\n except IOError as e:\\n sys.stderr.write(\\\"I/O error({0}): {1}\\\".format(e.errno, e.strerror)+'\\\\n')\\n sys.stderr.write('Try running with -buildClean = clean!\\\\n')\\n\\n return (friendship_map, business_reviews, degree_centrality_map, closeness_centrality_map, betweenness_centrality_map, YGraph)\",\n \"def _load_pascal_annotation(self, index):\\n imagefile = os.path.join(self._data_path, 'Images', index + self._image_ext)\\n labelfile = os.path.join(self._data_path, 'GroundTruth', index + '.txt')\\n print 'Loading: image {} and label {}'.format(imagefile, labelfile)\\n\\n labels = np.loadtxt(labelfile) + 1\\n image = cv2.imread(imagefile)\\n\\n gt_classes = []\\n gt_boxes = []\\n\\n boxes, classes = self._get_boxes(image, labels)\\n\\n boxes = np.array(boxes)\\n classes = np.array(classes)\\n\\n scores = np.ones(len(boxes), dtype=np.float32)\\n dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32)\\n\\n # keep = nms(dets, 0.2)\\n _, keep = non_max_suppression_fast(dets, 0.2)\\n boxes = boxes[keep, :]\\n classes = classes[keep]\\n\\n for n, (x, y, w, h) in enumerate(boxes):\\n # gt_boxes.append([min(x, w), min(y, h), min(abs(w - x), w), min(abs(h - y), h)])\\n gt_boxes.append([x, y, w - x, h - y])\\n gt_classes.append(classes[n])\\n\\n overlaps = np.zeros((len(gt_boxes), len(self._classes)), dtype=np.float32)\\n for n, obj in enumerate(gt_boxes):\\n overlaps[n, gt_classes[n]] = 1.0\\n\\n overlaps = scipy.sparse.csr_matrix(overlaps)\\n\\n return {'boxes': np.array(gt_boxes),\\n 'gt_classes': np.array(gt_classes, dtype=np.int32),\\n 'gt_overlaps': overlaps,\\n 'flipped': False}\\n\\n # def get_data_from_tag(node, tag):\\n # return node.getElementsByTagName(tag)[0].childNodes[0].data\\n\\n # with open(filename) as f:\\n # data = minidom.parseString(f.read())\\n\\n # objs = data.getElementsByTagName('object')\\n # num_objs = len(objs)\\n\\n # boxes = np.zeros((num_objs, 4), dtype=np.uint16)\\n # gt_classes = np.zeros((num_objs), dtype=np.int32)\\n # overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32)\\n\\n # # Load object bounding boxes into a data frame.\\n # for ix, obj in enumerate(objs):\\n # # Make pixel indexes 0-based\\n # x1 = float(get_data_from_tag(obj, 'xmin')) - 1\\n # y1 = float(get_data_from_tag(obj, 'ymin')) - 1\\n # x2 = float(get_data_from_tag(obj, 'xmax')) - 1\\n # y2 = float(get_data_from_tag(obj, 'ymax')) - 1\\n # cls = self._class_to_ind[str(get_data_from_tag(obj, \\\"name\\\")).lower().strip()]\\n # boxes[ix, :] = [x1, y1, x2, y2]\\n # gt_classes[ix] = cls\\n # overlaps[ix, cls] = 1.0\\n\\n # overlaps = scipy.sparse.csr_matrix(overlaps)\\n\\n # return {'boxes': boxes,\\n # 'gt_classes': gt_classes,\\n # 'gt_overlaps': overlaps,\\n # 'flipped': False}\",\n \"def get_overlap():\\n\\n\\tx = 382 * 2\\n\\ty = x\\n\\tz = 129 * 2 - 1\\n\\ttype_size = 8\\n\\ttab = np.empty(x * y * z)\\n\\tsize = 4096\\n\\ti = 0\\n\\tl = x * y * z * type_size\\n\\tn = 0\\n\\tfd = open('omeg5', 'rb')\\n\\twhile l - n > size:\\n\\t\\ts = fd.read(size)\\n\\t\\ttab[n / type_size : (n + size) / type_size] = np.fromstring(s, dtype = np.float64)\\n\\t\\ti += 1\\n\\t\\tn += size\\n\\ts = fd.read(l - n)\\n\\ttab[i * size / type_size:] = np.fromstring(s, dtype = np.float64)\\n\\tfd.close()\\n\\ttab = tab.reshape(x, y, z)\\n\\treturn (tab)\",\n \"def _get_assembly_points(self, agp, weight):\\n comps = set()\\n prev_obj = \\\"\\\"\\n seq1 = \\\"\\\"\\n strand1 = \\\"\\\"\\n\\n # Gap info\\n gap_count = 0\\n prev_agp_known = None\\n prev_gap_size = 0\\n prev_gap_type = None\\n prev_linkage = \\\"\\\"\\n prev_evidence = \\\"\\\"\\n\\n # Iterate over the AGP file and yield assembly points\\n agp_file = AGPFile(agp)\\n for agp_line in agp_file.iterate_lines():\\n if not agp_line.is_gap:\\n # Add this component to our master list\\n if agp_line.comp not in self.component_lens:\\n raise RuntimeError(\\\"{} is in {} but not {}.\\\".format(agp_line.comp, agp, self.components_fasta_fname))\\n comps.add(agp_line.comp)\\n\\n comp_len = agp_line.comp_end\\n if comp_len < self.get_component_len(agp_line.comp):\\n raise RuntimeError(\\\"only complete components can be added to the graph.\\\")\\n\\n if comp_len > self.get_component_len(agp_line.comp):\\n raise RuntimeError(\\\"inconsistent component lengths: {} bp in {} and {} bp in {}\\\". format(comp_len, agp, self.get_component_len(agp_line.comp), self.components_fasta_fname))\\n\\n if agp_line.obj == prev_obj:\\n # Check if these components are bookended (no gap in between)\\n if not gap_count:\\n prev_evidence = \\\"bookend\\\"\\n\\n # Check if two consecutive gaps preceded this component\\n if gap_count > 1:\\n raise ValueError(\\\"Consecutive gaps in the AGP file are not currently supported.\\\")\\n\\n yield AssemblyPoint(\\n seq1,\\n strand1,\\n agp_line.comp,\\n agp_line.orientation,\\n weight,\\n agp,\\n prev_agp_known,\\n prev_gap_size,\\n prev_gap_type,\\n prev_linkage,\\n prev_evidence\\n )\\n\\n # Set this component as the previous component\\n seq1 = agp_line.comp\\n strand1 = agp_line.orientation\\n\\n gap_count = 0\\n prev_agp_known = None\\n prev_gap_size = 0\\n prev_gap_type = None\\n prev_linkage = \\\"\\\"\\n prev_evidence = \\\"\\\"\\n\\n else:\\n seq1 = agp_line.comp\\n strand1 = agp_line.orientation\\n\\n prev_obj = agp_line.obj\\n gap_count = 0\\n prev_agp_known = None\\n prev_gap_size = 0\\n prev_gap_type = None\\n prev_linkage = \\\"\\\"\\n prev_evidence = \\\"\\\"\\n else:\\n if agp_line.obj == prev_obj:\\n gap_count += 1\\n prev_agp_known = True if agp_line.comp_type == \\\"N\\\" else False\\n prev_gap_size = agp_line.gap_len\\n prev_gap_type = agp_line.gap_type\\n prev_linkage = True if agp_line.linkage == \\\"yes\\\" else False\\n prev_evidence = agp_line.linkage_evidence\\n\\n if comps != self.components:\\n raise ValueError(\\\"Input AGPs do not have the same set of components.\\\")\",\n \"def generate_gff( mapfile, funtax_orf_file ):\\n annotation2assembly_map = pd.read_table(mapfile,\\n names=['annotation','assembly','length'],\\n index_col='annotation')\\n funtax_gff = pd.read_table( funtax_orf_file.name, engine='python', encoding='ISO-8859-1', quoting=3)\\n funtax_gff['seqid'] = funtax_gff.join(annotation2assembly_map, on='Contig_Name')['assembly']\\n funtax_gff['source'] = 'Prodigal_v2.00'\\n funtax_gff['type'] = 'CDS'\\n funtax_gff['score'] = 100.0\\n funtax_gff['phase'] = 0\\n funtax_gff['attributes'] = funtax_gff['ORF_ID'].str.replace(r'(.*)', r'ID=\\\\1;')\\n return funtax_gff[['seqid','source', 'type','start', 'end', 'score', 'strand','phase','attributes']]\",\n \"def main():\\n directed = True\\n try:\\n opts,args = getopt.getopt(sys.argv[1:], \\\"\\\")\\n except:\\n usage(sys.argv[0])\\n for opt,arg in opts:\\n usage(sys.argv[0])\\n\\n if len(args) != 5:\\n usage(sys.argv[0])\\n\\n data_dir = args[0]\\n num_samples = int(args[1])\\n num_seeds = int(args[2])\\n num_waves = int(args[3]) - 1 # -1 for consistency with SPNet\\n outputdir = args[4]\\n\\n print \\\"directed:\\\", directed\\n print \\\"number of samples:\\\", num_samples\\n print \\\"number of seeds:\\\", num_seeds\\n print \\\"number of waves:\\\", num_waves\\n print \\\"output directory:\\\", outputdir\\n \\n if not os.path.exists(outputdir):\\n os.mkdir(outputdir)\\n\\n sys.stdout.write('loading data from ' + data_dir + '...')\\n start = time.time()\\n (G, profile, colnames) = load_pokec_data(data_dir)\\n print time.time() - start, 's'\\n\\n snap.PrintInfo(G)\\n\\n\\n # We do not add attributes to nodes as SNAP node attribute as\\n # these seem to get lost by varoius operations including subgraph\\n # that we need to use, so instead maintain them just in the\\n # dictionary mapping the original node ids to the attributes -\\n # fortunately the original node ids are maintained by\\n # GetSubGraph() so we can used these to index the profile\\n # dictoinary in the subgraphs\\n\\n\\n ## https://snap.stanford.edu/data/soc-pokec-readme.txt\\n ## region:\\n ## string, mostly regions in Slovakia (example: \\\"zilinsky kraj,\\n ## kysucke nove mesto\\\" means county Zilina, town Kysucke Nove Mesto,\\n ## Slovakia), some foreign countries (example: \\\"zahranicie, \\n ## zahranicie - nemecko\\\" means foreign country Germany (nemecko)),\\n ## some Czech regions (example: \\\"ceska republika, cz - ostravsky \\n ## kraj\\\" means Czech Republic, county Ostrava (ostravsky kraj))\\n ## We just make this a factor, looking at the output written by print\\n ## below, it looks reasonable, but is is only a categorical variable\\n ## allowing us to tell if two users are in the same region or not.\\n ## TODO we could recode this so that we can have different variables\\n ## for being in a different country, major city, etc.\\n # Cannot do this:\\n #profile[:][colnames['region']] = convert_to_int_cat(profile[:][colnames['region']]) # like factor in R\\n # as get \\\"TypeError: unhashable type\\\" so have to do this instead:\\n id_regions = [(k, p[colnames['region']]) for (k,p) in profile.iteritems()]\\n id_regions_int = convert_to_int_cat([x[1] for x in id_regions])\\n for i in xrange(len(id_regions)):\\n profile[id_regions[i][0]][colnames['region']] = id_regions_int[i]\\n\\n for attr in ['region']:\\n sys.stdout.write('There are %d NA for %s\\\\n' % ([p[colnames[attr]] for p in profile.itervalues()].count('NA'), attr))\\n\\n\\n # get num_samples * num_seeds distinct random seed nodes (sample without replacement)\\n # and convert to list of lists where each list is seed set for one sample\\n allseeds = random.sample([node.GetId() for node in G.Nodes()], num_samples * num_seeds)\\n seedsets = [allseeds[i:i+num_seeds] for i in range(0, len(allseeds), num_seeds)]\\n\\n sampledesc_filename = outputdir + os.path.sep + \\\"sampledesc\\\" + os.path.extsep + \\\"txt\\\"\\n sampledesc_f = open(sampledesc_filename, 'w')\\n\\n for i in range(num_samples):\\n sys.stdout.write( 'generating snowball sample ' + str(i+1) + '... ' )\\n start = time.time()\\n # have to convert seedset to TIntV for SNAP\\n seedsVec = snap.TIntV()\\n for nodeid in seedsets[i]:\\n seedsVec.Add(nodeid)\\n Gsample = snowball_sample(G, num_waves, seedsVec)\\n nodelist = list() # keep this iteration in list so we always use same order in future\\n zonedict = dict() # map nodeid : zone\\n for node in Gsample.Nodes():\\n nodelist.append(node.GetId())\\n zonedict[node.GetId()] = Gsample.GetIntAttrDatN(node.GetId(), \\\"zone\\\")\\n print time.time() - start, 's'\\n \\n snap.PrintInfo(Gsample)\\n subgraph_filename = outputdir + os.path.sep + \\\"subgraph\\\" + str(i) + os.path.extsep + \\\"txt\\\"\\n write_graph_file(subgraph_filename, Gsample, nodelist)\\n subzone_filename = outputdir + os.path.sep + \\\"subzone\\\" + str(i) + os.path.extsep + \\\"txt\\\"\\n write_zone_file(subzone_filename, Gsample, nodelist, zonedict)\\n subactor_binary_filename = outputdir + os.path.sep + \\\"subactorbin\\\" + str(i) + os.path.extsep + \\\"txt\\\"\\n subactor_categorical_filename = outputdir + os.path.sep + \\\"subactorcat\\\" + str(i) + os.path.extsep + \\\"txt\\\"\\n subactor_continuous_filename = outputdir + os.path.sep + \\\"subactorcont\\\" + str(i) + os.path.extsep + \\\"txt\\\"\\n\\n write_subactors_file_binary(subactor_binary_filename, Gsample, nodelist, profile, colnames)\\n write_subactors_file_categorical(subactor_categorical_filename, Gsample, nodelist, profile, colnames)\\n write_subactors_file_continuous(subactor_continuous_filename, Gsample, nodelist, profile, colnames)\\n\\n nodeid_filename = outputdir + os.path.sep + \\\"subnodeid\\\" + str(i) + os.path.extsep + \\\"txt\\\"\\n write_subgraph_nodeids(nodeid_filename, nodelist)\\n \\n # format of sampledesc file is:\\n # N subzone_filename subgraph_filename binary_Filename cat_filename cont_filename\\n sampledesc_filename = outputdir + os.path.sep + \\\"sampledesc\\\" + os.path.extsep + \\\"txt\\\"\\n sampledesc_f.write(\\\"%d %s %s %s %s %s\\\\n\\\" % (Gsample.GetNodes(), subzone_filename,\\n subgraph_filename, subactor_binary_filename,\\n subactor_categorical_filename, subactor_continuous_filename))\\n\\n sampledesc_f.close()\",\n \"def load_pfam():\\n data = collections.defaultdict(list)\\n ds_loader = specs.make_pfam34_loader(\\n root_dir=FLAGS.data_dir, sub_dir='', extra_keys=KEYS, task=TASK)\\n for split in SPLITS:\\n logging.info('Loading %s Pfam-A seed 34.0 split...', split)\\n split_data = collections.defaultdict(list)\\n for ex in ds_loader.load(split).prefetch(tf.data.AUTOTUNE):\\n split_data['id'].append(ex['id'].numpy().decode('utf-8'))\\n split_data['start'].append(ex['start'].numpy())\\n split_data['end'].append(ex['end'].numpy())\\n split_data['seq'].append(\\n vocabulary.alternative.decode(ex['sequence'].numpy()))\\n for k, v in split_data.items():\\n data[k].append(v)\\n result = {k: sum(v, []) for k, v in data.items()}\\n\\n indices_from_pfam_id = collections.defaultdict(list)\\n for i, pfam_id in enumerate(result['id']):\\n indices_from_pfam_id[pfam_id].append(i)\\n logging.info('Found %d unique IDs among %d Pfam-A seed sequences',\\n len(indices_from_pfam_id), len(result['id']))\\n return (result['start'], result['end'], result['seq']), indices_from_pfam_id\",\n \"def main():\\n filenames = sys.argv[1]\\n fdir = sys.argv[2]\\n filenames = filenames.split(',')\\n\\n # print (filenames)\\n graph = PGraph(fdir, filenames, \\\"Multi-Source Foraging\\\")\\n # graph = PGraph(fdir, filenames, \\\"Cooperative Transport\\\")\\n # graph = PGraph(fdir, filenames, \\\"Nest Maintenance\\\")\\n # graph = PGraph(\\n # fdir, filenames, \\\"Nest Maintenance \\\\n with \\\\n Handcoded behaviors\\\")\\n graph.gen_plot()\\n\\n # box = BoxGraph(fdir, filenames, \\\"Single-Source Foraging\\\")\\n # box = BoxGraph(fdir, filenames, False, (-1, 100), \\\"Multi-Source Foraging\\\")\\n box = BoxGraph(fdir, filenames, False, (-1, 120), \\\"Nest Maintenance with Handcoded behaviors\\\")\\n # box = BoxGraph(\\n # fdir, filenames, \\\"Nest Maintenance \\\\n with \\\\n Handcoded behaviors\\\")\\n box.gen_plot()\",\n \"def write_agp(self, agp_fn, ref_fn, add_suffix_to_unplaced=False):\\n used_components = set()\\n used_edges = set()\\n obj_header_idx = -1\\n\\n agp = AGPFile(agp_fn, \\\"w\\\")\\n agp.add_pragma()\\n agp.add_comment(\\\"# AGP created by RagTag {}\\\".format(get_ragtag_version()))\\n\\n while True:\\n # Find a starting node\\n from_node = None\\n to_node = None\\n cur_ref = None\\n for u, v in sorted(self.edges):\\n if (u, v) not in used_edges:\\n u_base = u[:-2]\\n\\n u_degree = 0\\n if u_base + \\\"_b\\\" in self.nodes:\\n u_degree += self.graph.degree[u_base + \\\"_b\\\"]\\n if u_base + \\\"_e\\\" in self.nodes:\\n u_degree += self.graph.degree[u_base + \\\"_e\\\"]\\n\\n assert u_degree in {2, 4}\\n\\n # Check if we have found a starting target sequence\\n if u_degree == 2:\\n cur_ref = u_base\\n from_node = u\\n to_node = v\\n used_edges.add((u, v))\\n used_edges.add((v, u))\\n break\\n\\n # If we haven't found a new starting target sequence, we are done\\n if from_node is None:\\n break\\n\\n # Initialize this object\\n obj_header_idx += 1\\n obj_header = \\\"scf\\\" + \\\"{0:08}\\\".format(obj_header_idx)\\n obj_pos = 0\\n obj_pid = 1\\n\\n # Process the first target sequence\\n cur_ref_len = self.component_lens[cur_ref]\\n cur_ref_strand = \\\"+\\\"\\n if from_node.endswith(\\\"_b\\\"):\\n cur_ref_strand = \\\"-\\\"\\n agp.add_seq_line(obj_header, obj_pos+1, obj_pos+cur_ref_len, obj_pid, \\\"W\\\", cur_ref, 1, cur_ref_len, cur_ref_strand)\\n obj_pos += cur_ref_len\\n obj_pid += 1\\n used_components.add(cur_ref)\\n\\n # Process the remaining sequences.\\n next_edge_exists = True\\n while next_edge_exists:\\n # Process the patch\\n patch_aln = self.graph[from_node][to_node][\\\"alignment\\\"]\\n patch_query = patch_aln.query\\n patch_strand = \\\"+\\\"\\n if patch_aln.strand:\\n patch_strand = \\\"-\\\"\\n\\n patch_len = patch_aln.their_query_start - patch_aln.my_query_end\\n if patch_len > 0:\\n if patch_aln.is_gap:\\n agp.add_gap_line(obj_header, obj_pos+1, obj_pos+patch_len, obj_pid, \\\"N\\\", patch_len, \\\"scaffold\\\", \\\"yes\\\", \\\"align_genus\\\")\\n else:\\n agp.add_seq_line(obj_header, obj_pos+1, obj_pos+patch_len, obj_pid, \\\"W\\\", patch_query, patch_aln.my_query_end+1, patch_aln.their_query_start, patch_strand)\\n used_components.add(patch_query)\\n obj_pos += patch_len\\n obj_pid += 1\\n\\n # Next, process the reference sequence\\n comp_start = min(0, patch_len)\\n cur_ref = to_node[:-2]\\n cur_ref_len = self.component_lens[cur_ref]\\n cur_ref_strand = \\\"+\\\"\\n if to_node.endswith(\\\"_e\\\"):\\n cur_ref_strand = \\\"-\\\"\\n agp.add_seq_line(obj_header, obj_pos+1, obj_pos+(cur_ref_len + comp_start), obj_pid, \\\"W\\\", cur_ref, 1+(-1*comp_start), cur_ref_len, cur_ref_strand)\\n obj_pos += cur_ref_len + comp_start\\n obj_pid += 1\\n used_components.add(cur_ref)\\n\\n # Look for the next edge\\n from_node = to_node[:-2] + \\\"_b\\\"\\n if to_node.endswith(\\\"_b\\\"):\\n from_node = to_node[:-2] + \\\"_e\\\"\\n\\n if from_node in self.graph.nodes:\\n next_nodes = set(self.graph[from_node])\\n assert len(next_nodes) == 1\\n to_node = next_nodes.pop()\\n used_edges.add((from_node, to_node))\\n used_edges.add((to_node, from_node))\\n else:\\n next_edge_exists = False\\n\\n # Write unplaced reference sequences\\n fai = pysam.FastaFile(ref_fn)\\n all_ref_seqs = set(fai.references)\\n fai.close()\\n remaining_components = all_ref_seqs - used_components\\n for c in sorted(remaining_components):\\n agp.add_seq_line(\\n c + \\\"_RagTag\\\" * add_suffix_to_unplaced,\\n \\\"1\\\",\\n str(self.component_lens[c]),\\n \\\"1\\\",\\n \\\"W\\\",\\n c,\\n \\\"1\\\",\\n str(self.component_lens[c]),\\n \\\"+\\\"\\n )\\n\\n agp.write()\",\n \"def g_n():\\n for gname in os.listdir(sroot):\\n if gname != 's1-league1-game1':\\n continue\\n if gname.startswith('s1'):\\n p0 = os.path.join(sroot, gname)\\n p1 = os.path.join(p0, 'commitment', 'jperret')\\n p2 = os.path.join(p0, 'commitment', 'sa')\\n if os.path.isdir(p1) and os.path.isdir(p2):\\n for fname in os.listdir(p1):\\n if fname.endswith('.aa'):\\n bname = fname[:-3]\\n #~ if bname == 's1-league1-game2_07':\\n #~ continue\\n a = ad.Annotations(os.path.join(p1, fname))\\n a.load_text(os.path.join(p0, 'unannotated', bname+'.ac'))\\n a.gen_full_struct()\\n a.commitments = list(u for u in a.units if u.type == 'Commitment')\\n a2 = ad.Annotations(os.path.join(p2, fname))\\n a2.load_text(os.path.join(p0, 'unannotated', bname+'.ac'))\\n a2.gen_full_struct()\\n a2.commitments = list(u for u in a2.units if u.type == 'Commitment')\\n yield bname, (a, a2)\",\n \"def FindPeaks_graph(self):\\n import string\\n \\n maxima = self['FP_LOC'].copy()\\n maxima = num.where(maxima)\\n maxima = (maxima[1],maxima[0])\\n detectimg = self['FP_DETECT'].copy()\\n \\n id = self._getGraphId()\\n root = 'FindPeaks_%s' % (id,)\\n pngname = root + '.png' ; epsname = root + '.eps'\\n jpgname = root + '.jpg'\\n\\n doStamp(detectimg,pngname,format='PNG')\\n Convert(pngname,jpgname)\\n \\n Painted = Paint(jpgname)\\n Painted.load()\\n Painted.DrawCross(maxima,length=7,color='green')\\n \\n strpeaks = string.strip('%i'% (self['M_NPEAKS']))\\n text = 'NP=%s' % strpeaks \\n \\n # Painted.Graffiti(text,commtextpos)\\n \\n Painted.save(jpgname)\\n Painted.release()\\n \\n Convert(jpgname,epsname)\\n os.system('rm %s %s' % (pngname,jpgname))\\n self['figures']['FindPeaks'] = epsname\\n self['figcomms']['FindPeaks'] = text\",\n \"def merge_tables():\\r\\n filename = \\\"ppxf_results_best.dat\\\"\\r\\n s1 = np.genfromtxt(filename, usecols=(0,), dtype=None).tolist()\\r\\n sref = s1[:]\\r\\n sref.sort()\\r\\n x, y = get_positions(sref).T\\r\\n r = np.sqrt(x * x + y * y)\\r\\n pa = np.rad2deg(np.arctan2(x, y))\\r\\n pa[pa < 0.] += 360.\\r\\n data1 = np.loadtxt(filename, usecols=np.arange(1, 11))\\r\\n ##########################################################################\\r\\n # Account for difference in resolution\\r\\n # Not used anymore because the resolution is now matched in pPXF\\r\\n # fwhm_dif = (2.5 - 2.1) * c / 5500. / 2.3548\\r\\n # data1[:,2] = np.sqrt(data1[:,2]**2 - fwhm_dif**2)\\r\\n ##########################################################################\\r\\n data1 = match_data(s1, sref, data1)\\r\\n results = np.column_stack((sref, x, y, r, pa, data1))\\r\\n header = ['FILE', \\\"X[kpc]\\\", \\\"Y[kpc]\\\",\\r\\n \\\"R[kpc]\\\", \\\"PA\\\",\\r\\n 'V', 'dV', 'S', 'dS', 'h3', 'dh3',\\r\\n 'h4', 'dh4', 'chi/DOF', 'S/N']\\r\\n with open(outtable, \\\"w\\\") as f:\\r\\n for i, field in enumerate(header):\\r\\n print \\\"# {0} : {1}\\\\n\\\".format(i, field)\\r\\n f.write(\\\"# {0} : {1}\\\\n\\\".format(i, field))\\r\\n np.savetxt(f, results, fmt=\\\"%s\\\")\\r\\n return\",\n \"def generate_graph_fca(organism):\\n\\twith open('./organisms/'+organism+'/'+'fcagraph.txt','r') as gfile:\\n\\t\\trnamelst = [] \\n\\t\\tenamelst = []\\n\\t\\tclst = []\\n\\t\\tfor line in gfile:\\n\\t\\t\\te = line.strip().split('\\\\t')\\n\\t\\t\\tfor rname in e[0:2]:\\n\\t\\t\\t\\tif rname not in rnamelst:\\n\\t\\t\\t\\t\\trnamelst.append(rname)\\n\\t\\t\\tenamelst.append((e[0],e[1]))\\n\\t\\t\\tclst.append(e[2])\\n\\t\\t\\t\\n\\t\\tG = igraph.Graph(0,directed=True)\\n\\t\\tG.add_vertices(rnamelst)\\n\\t\\tG.add_edges(enamelst)\\n\\t\\tG.es['color'] = clst\\n\\t\\n\\treturn G\",\n \"def write_output(pfam,\\n indices_from_pfam_id,\\n uniprot):\\n pfam_starts, pfam_ends, pfam_sequences = pfam\\n uniprot_ids, uniprot_sequences = uniprot\\n\\n logging.info('Writing output file %s...', FLAGS.output_file)\\n\\n n_pfam_entries_found = 0\\n n_sequence_mismatches = 0\\n n_repeats = 0\\n n_start_mismatches = 0\\n with tf.io.gfile.GFile(FLAGS.output_file, 'w') as f:\\n f.write(','.join(OUTPUT_FIELDS) + '\\\\n')\\n for uniprot_id, uniprot_sequence in zip(uniprot_ids, uniprot_sequences):\\n for idx in indices_from_pfam_id[uniprot_id]:\\n pfam_start, pfam_end = pfam_starts[idx], pfam_ends[idx]\\n pfam_sequence = pfam_sequences[idx]\\n\\n uniprot_starts = find_all(uniprot_sequence, pfam_sequence)\\n\\n n_pfam_entries_found += 1\\n if uniprot_starts:\\n n_repeats += len(uniprot_starts) > 1\\n n_start_mismatches += pfam_start not in uniprot_starts\\n else:\\n n_sequence_mismatches += 1\\n\\n pfam_id = f'{uniprot_id}/{pfam_start}-{pfam_end}'\\n uniprot_starts = ';'.join([str(i) for i in uniprot_starts])\\n fields = [pfam_id, uniprot_starts, uniprot_sequence]\\n f.write(','.join(fields) + '\\\\n')\\n\\n logging.info('Finished writing %d entries to output file.',\\n n_pfam_entries_found)\\n\\n logging.info('%d / %d Pfam-A seed entries have mismatching sequences.',\\n n_sequence_mismatches, n_pfam_entries_found)\\n logging.info('%d / %d Pfam-A seed entries have repeats.',\\n n_repeats, n_pfam_entries_found)\\n logging.info('%d / %d Pfam-A seed entries have mismatching starts.',\\n n_start_mismatches, n_pfam_entries_found)\",\n \"def overlap_generator(metric, graph):\\n edges =[(edge[0], edge[1]) for edge in nx.edges(graph)]\\n edges = edges + [(edge[1], edge[0]) for edge in nx.edges(graph)]\\n return {edge: metric(graph, edge[0], edge[1]) for edge in tqdm(edges)}\",\n \"def baselineSolutions(filename):\\n \\n def getOtherSaCurrentAnts( ):\\n \\\"\\\"\\\" Retrieve ants in other science subarrays. \\\"\\\"\\\"\\n if subarrayNo == 1:\\n otherSa = Subarray.getSubarrayRef( 2 )\\n otherSaAntAssignments = otherSa.getAntennaAssignments( )\\n elif subarrayNo == 2:\\n otherSa = Subarray.getSubarrayRef( 1 )\\n otherSaAntAssignments = otherSa.getAntennaAssignments( )\\n else:\\n otherSa1Ants = Subarray.getSubarrayRef(1).getAntennaAssignments()\\n otherSa2Ants = Subarray.getSubarrayRef(2).getAntennaAssignments()\\n otherSaAntAssignments = otherSa1Ants + otherSa2Ants\\n\\n otherSaAnts = [ i.carmaAntennaNo for i in otherSaAntAssignments ]\\n return otherSaAnts\\n\\n def toosmall( val ):\\n if abs( val ) < 0.0001:\\n return True\\n else:\\n return False\\n\\n import fileIOPython as fIOP\\n\\n # First determine which antennas will receive updates.\\n antPosVals = fIOP.fileToTable( filename, ignoreEmpty=True, comment=\\\"#\\\" )\\n antsInThisSa = currentAntennaNumbers()\\n antsInOtherScienceSa = getOtherSaCurrentAnts()\\n antNo = 0\\n validAnts = []\\n invalidAnts = []\\n validAntsInOtherScienceSa = []\\n validAntsNotInThisSa = []\\n for pos in antPosVals:\\n antNo += 1\\n x,y,z = float(pos[0]), float(pos[1]), float(pos[2])\\n if toosmall(x) and toosmall(y) and toosmall(z):\\n invalidAnts.append( antNo )\\n else:\\n if antNo in antsInOtherScienceSa:\\n validAntsInOtherScienceSa.append( antNo )\\n if antNo not in antsInThisSa:\\n validAntsNotInThisSa.append( antNo )\\n validAnts.append( antNo )\\n\\n if len( validAntsInOtherScienceSa ) > 0:\\n rfValidAntsInOtherScienceSa = helpers.formatAsRanges( validAntsInOtherScienceSa )\\n error = \\\"\\\"\\n if len(rfValidAntsInOtherScienceSa) > 1:\\n error += \\\"Ants %s currently belong to other science subarrays. \\\"%(rfValidAntsInOtherScienceSa)\\n error += \\\"Please remove them prior to rerunning this command.\\\"\\n else:\\n error += \\\"Ant %s currently belongs to another science subarray. \\\"%(rfValidAntsInOtherScienceSa)\\n error += \\\"Please remove it prior to rerunning this command.\\\"\\n printError( error )\\n return\\n\\n \\n antNo = 0\\n for pos in antPosVals:\\n antNo += 1\\n if antNo in invalidAnts:\\n continue\\n x,y,z = float(pos[0]), float(pos[1]), float(pos[2])\\n baseOff = s.convertBaseline( x, y, z, antNo )\\n\\n if ( baseOff.antNo != antNo ): # Sanity check\\n raise Exception,\\\"Mismatched ant no.\\\"\\n \\n padOffset( round( baseOff.east, 2 ), \\n round( baseOff.north, 2 ),\\n round( baseOff.up, 2 ),\\n antNo )\\n\\n s.setAntPosFilename( filename )\\n\\n rfValidAnts = helpers.formatAsRanges( validAnts )\\n if ( rfValidAnts > 1 ):\\n print \\\"Solutions applied for ants %s.\\\"%(rfValidAnts)\\n else:\\n print \\\"Solutions applied for ant %s.\\\"%(rfValidAnts)\\n \\n if len( invalidAnts ) > 0:\\n rfInvalidAnts = helpers.formatAsRanges( invalidAnts )\\n if ( len( rfInvalidAnts ) > 1 ):\\n printWarning( \\\"Antpos does NOT contain solutions for ants %s.\\\"%(rfInvalidAnts) )\\n else:\\n printWarning( \\\"Antpos does NOT contain a solution for ant %s.\\\"%(rfInvalidAnts) )\\n\\n if len( validAntsNotInThisSa ) > 0:\\n rfValidAntsNotInThisSa = helpers.formatAsRanges( validAntsNotInThisSa )\\n warning = \\\"Solutions were applied for \\\"\\n if len(rfValidAntsNotInThisSa) > 1:\\n warning += \\\"ants %s which do \\\"%rfValidAntsNotInThisSa\\n else:\\n warning += \\\"ant %s which does \\\"%rfValidAntsNotInThisSa\\n warning += \\\"not belong to this subarray. The new solutions \\\"\\n warning += \\\"may not be reflected in the monitor system until these \\\"\\n warning += \\\"ants are added back into a science subarray.\\\" \\n printWarning( warning )\",\n \"def getNetworksFromLoops(loops, genes, fout, pdis=2000, gap=1, cpu=1):\\n ks = [key for key in loops.keys() if key in genes]\\n print(\\\"Merging anchors and annotating loops through networks.\\\")\\n ds = Parallel(n_jobs=cpu, backend=\\\"multiprocessing\\\")(delayed(getNet)(\\n chrom,\\n loops[chrom],\\n genes[chrom],\\n pdis=pdis,\\n gap=gap,\\n ) for chrom in tqdm(ks))\\n anchors, anots, nets, targets = {}, {}, {}, {}\\n for d in ds:\\n for k, v in d[0].items():\\n anchors[k] = v\\n for k, v in d[1].items():\\n anots[k] = v\\n for k, v in d[2].items():\\n nets[k] = v\\n for k, v in d[3].items():\\n targets[k] = v\\n #output results\\n #anchors\\n anchors = pd.DataFrame(anchors).T\\n anchors.to_csv(fout + \\\"_mergedAnchors.txt\\\", sep=\\\"\\\\t\\\", index_label=\\\"anchor\\\")\\n with open(fout + \\\"_mergedAnchors.bed\\\", \\\"w\\\") as fo:\\n for t in anchors.itertuples():\\n line = [t[1], t[2], t[3], t[0]]\\n fo.write(\\\"\\\\t\\\".join(list(map(str, line))) + \\\"\\\\n\\\")\\n #annotations\\n anots = pd.DataFrame(anots).T\\n anots.to_csv(fout + \\\"_loop2anchors.txt\\\", sep=\\\"\\\\t\\\", index_label=\\\"loopId\\\")\\n #networks\\n with open(fout + \\\"_ep_net.sif\\\", \\\"w\\\") as fo:\\n for s, es in nets.items():\\n es = list(es)\\n ta = s.split(\\\"|\\\")[-1]\\n for e in es:\\n tb = e.split(\\\"|\\\")[-1]\\n t = [ta, tb]\\n t.sort()\\n t = \\\"-\\\".join(t)\\n line = [s, t, e]\\n fo.write(\\\"\\\\t\\\".join(line) + \\\"\\\\n\\\")\\n with open(fout + \\\"_targets.txt\\\", \\\"w\\\") as fo:\\n ks = list(targets.keys())\\n ks.sort()\\n line = [\\n \\\"Promoter\\\", \\\"PromoterTarget\\\", \\\"directEnhancer\\\", \\\"indirectEnhancer\\\",\\n \\\"directPromoter\\\", \\\"indirectPromoter\\\", \\\"directEnhancerHub\\\",\\n \\\"indirectEnhancerHub\\\"\\n ]\\n fo.write(\\\"\\\\t\\\".join(line) + \\\"\\\\n\\\")\\n for k in ks:\\n line = [\\n k, targets[k][\\\"targetGene\\\"],\\n \\\",\\\".join(targets[k][\\\"directEnhancer\\\"]),\\n \\\",\\\".join(targets[k][\\\"indirectEnhancer\\\"]),\\n \\\",\\\".join(targets[k][\\\"directPromoter\\\"]),\\n \\\",\\\".join(targets[k][\\\"indirectPromoter\\\"]),\\n targets[k][\\\"directEnhancerHub\\\"],\\n targets[k][\\\"indirectEnhancerHub\\\"]\\n ]\\n fo.write(\\\"\\\\t\\\".join(line) + \\\"\\\\n\\\")\",\n \"def run(input_f, output_f):\\n with open(input_f) as f:\\n lines = f.readlines()\\n\\n # Collect the array dims\\n PE_defs = []\\n module_start = False\\n is_PE = False \\n PE_indices = []\\n for line_id in range(len(lines)):\\n line = lines[line_id]\\n if line.find('Module Definition') != -1:\\n module_start = not module_start\\n if module_start:\\n module_start_pos = line_id\\n is_PE = False\\n else:\\n module_end_pos = line_id\\n if is_PE:\\n PE_defs.append({'def': lines[module_start_pos : module_end_pos + 1], \\\\\\n 'pos': [module_start_pos, module_end_pos]})\\n if module_start:\\n #print(line_id)\\n nxt_line_id = line_id + 1\\n while nxt_line_id < len(lines): \\n nxt_line = lines[nxt_line_id]\\n if nxt_line.find('kernel void PE') != -1:\\n is_PE = True\\n m = re.search(r'void PE(.+?)\\\\(', nxt_line)\\n #print(nxt_line)\\n if m:\\n PE_index = m.group(1).split('_')[1:]\\n PE_indices.append(PE_index)\\n if is_PE:\\n break\\n if nxt_line.find('Module Definition') != -1:\\n break\\n nxt_line_id += 1\\n\\n #print(PE_indices)\\n PE_dims = [int(d) for d in PE_indices[0]]\\n for ind in PE_indices:\\n for dim in range(len(PE_dims)):\\n PE_dims[dim] = max(PE_dims[dim], int(ind[dim]) + 1)\\n #print(PE_dims)\\n \\n PE_lines = PE_defs[0]['def']\\n # Parse the data transfer information\\n data_trans_info = extract_data_trans_info(PE_lines, PE_dims) \\n\\n # Compose the new PE function\\n PE_lines = compose_PE(data_trans_info, PE_dims, PE_defs)\\n\\n line_offset = 0\\n for PE_def in PE_defs:\\n lines = lines[:PE_def['pos'][0] - line_offset] + lines[PE_def['pos'][1] + 1 - line_offset:]\\n line_offset += (PE_def['pos'][1] - PE_def['pos'][0] + 1)\\n\\n lines = lines + PE_lines\\n\\n # Modify the channels\\n lines = modify_channels(lines, data_trans_info, PE_dims)\\n\\n with open(output_f, 'w') as f:\\n for line in lines:\\n f.write(line)\\n # f.writelines(PE_lines)\",\n \"def overlay_resources_score_motifs(motif_sites_input_file,\\n motifs_overlapping_tracks_output_dir,\\n chromatin_tracks_dir_path,\\n chromatin_tracks_files):\\n\\n # for motif_sites_input_file in motif_sites_input_files:\\n with open(motif_sites_input_file) as f:\\n chr_n_file = f.readline().strip().split('\\\\t')[0].strip() + '.bed'\\n # it is assumed for every motif file name there exists a matching file name in the chromatin_tracks_input_dir\\n if chr_n_file in chromatin_tracks_files:\\n motifs_overlapping_tracks_file = motifs_overlapping_tracks_output_dir + '/' + '.'.join(\\n motif_sites_input_file.split('/')[-1].split('.')[0:-1]) + '_overlapping_tracks' + '.bed7'\\n motifs_overlapping_tracks_file_tmp = motifs_overlapping_tracks_file + '_tmp'\\n # create or overwrite output files\\n if not os.path.exists(motifs_overlapping_tracks_file):\\n \\n motif_sites_input_file_sorted = motif_sites_input_file + '_sorted'\\n chromatin_tracks_input_file = chromatin_tracks_dir_path +'/'+ chr_n_file\\n chromatin_tracks_input_file_sorted = chromatin_tracks_input_file + '_sorted'\\n \\n print(\\\"intersecting: \\\" + motif_sites_input_file + ' and ' + chromatin_tracks_input_file)\\n \\n os.system(\\\"\\\"\\\"sort -k1,1 -k2,2n -k3,3n {} > {}\\\"\\\"\\\".format(motif_sites_input_file, motif_sites_input_file_sorted))\\n os.system(\\\"\\\"\\\"sort -k1,1 -k2,2n -k3,3n {} > {}\\\"\\\"\\\".format(chromatin_tracks_input_file, chromatin_tracks_input_file_sorted))\\n \\n\\n motif_sites_file_obj = BedTool(motif_sites_input_file_sorted)\\n motif_sites_file_obj.map(BedTool(chromatin_tracks_input_file_sorted), c=4, o=['collapse']).saveas(motifs_overlapping_tracks_file_tmp)\\n \\n with open(motifs_overlapping_tracks_file_tmp, 'r') as infile, open(motifs_overlapping_tracks_file,\\n 'w') as outfile:\\n line = infile.readline()\\n while line:\\n\\n sline = line.split('\\\\t')\\n if len(sline) > 6:\\n if sline[7] != '.' and sline[7] != \\\".\\\\n\\\":\\n my_list = sline[7].split(',')\\n cell_assay_values_dict_ChromHMM = {}\\n cell_assay_values_dict_cCRE = {}\\n cell_assay_values_dict_IndexDHS = {}\\n cell_assay_values_dict_RegElem = {}\\n cell_assay_values_dict_DNaseq = {}\\n elem_list = []\\n for elem in my_list:\\n # TODO: check if statement below\\n if elem.__contains__('#'):\\n cell_value = elem.split('#')[0]\\n assay_value = elem.split('#')[1]\\n if len(elem.split('#')) > 2:\\n state_value = elem.split('#')[2].rstrip(\\\"\\\\n\\\")\\n\\n if assay_value == \\\"ChromHMM\\\":\\n if cell_value not in list(cell_assay_values_dict_ChromHMM.keys()):\\n cell_assay_values_dict_ChromHMM[cell_value] = []\\n cell_assay_values_dict_ChromHMM[cell_value].append(state_value)\\n\\n elif assay_value == \\\"cCRE\\\":\\n if cell_value not in list(cell_assay_values_dict_cCRE.keys()):\\n cell_assay_values_dict_cCRE[cell_value] = []\\n cell_assay_values_dict_cCRE[cell_value].append(state_value)\\n\\n elif assay_value == \\\"IndexDHS\\\":\\n if cell_value not in list(cell_assay_values_dict_IndexDHS.keys()):\\n cell_assay_values_dict_IndexDHS[cell_value] = []\\n cell_assay_values_dict_IndexDHS[cell_value].append(state_value)\\n\\n elif assay_value == \\\"RegElem\\\":\\n if cell_value not in list(cell_assay_values_dict_RegElem.keys()):\\n cell_assay_values_dict_RegElem[cell_value] = []\\n cell_assay_values_dict_RegElem[cell_value].append(state_value)\\n\\n elif assay_value == \\\"DNase-seq\\\":\\n if cell_value not in list(cell_assay_values_dict_DNaseq.keys()):\\n cell_assay_values_dict_DNaseq[cell_value] = []\\n cell_assay_values_dict_DNaseq[cell_value].append(float(state_value))\\n\\n else:\\n elem_list.append(elem.rstrip(\\\"\\\\n\\\"))\\n\\n for cell in cell_assay_values_dict_ChromHMM:\\n elem_list.append(cell + \\\"#ChromHMM#\\\" +\\n Counter(cell_assay_values_dict_ChromHMM[cell]).most_common(1)[0][\\n 0])\\n\\n for cell in list(cell_assay_values_dict_cCRE.keys()):\\n elem_list.append(\\n cell + \\\"#cCRE#\\\" + Counter(cell_assay_values_dict_cCRE[cell]).most_common(1)[0][\\n 0])\\n\\n for cell in list(cell_assay_values_dict_IndexDHS.keys()):\\n elem_list.append(cell + \\\"#IndexDHS#\\\" +\\n Counter(cell_assay_values_dict_IndexDHS[cell]).most_common(1)[0][\\n 0])\\n\\n for cell in list(cell_assay_values_dict_RegElem.keys()):\\n elem_list.append(cell + \\\"#RegElem#\\\" +\\n Counter(cell_assay_values_dict_RegElem[cell]).most_common(1)[0][0])\\n\\n for cell in list(cell_assay_values_dict_DNaseq.keys()):\\n elem_list.append(\\n cell + \\\"#DNase-seq#\\\" + str(max(cell_assay_values_dict_DNaseq[cell])))\\n\\n outfile.write('\\\\t'.join(sline[0:7]) + '\\\\t' + ','.join(elem_list) + '\\\\n')\\n\\n line = infile.readline()\\n\\n os.remove(motifs_overlapping_tracks_file_tmp)\\n os.remove(motif_sites_input_file_sorted)\\n os.remove(chromatin_tracks_input_file_sorted)\\n\\n print(\\\"Finished intersecting: \\\" + motif_sites_input_file + ' and ' + chromatin_tracks_input_file)\\n else:\\n print(\\\"Use existing data files in \\\" + motifs_overlapping_tracks_file)\\n else:\\n print(\\\"Specified chromatin track file \\\" + chr_n_file + \\\" cannot be found and will be ignored.\\\")\\n return None\\n cleanup()\\n return motifs_overlapping_tracks_file\",\n \"def dpf(self):\\n inigen = IniGen()\\n fields = algorithm_fields.algorithms['dpf']\\n\\n output_uuid_map = {}\\n\\n # set up global parameters\\n algorithm_path = fields['path']\\n enabled = \\\"True\\\"\\n inigen.emit_global(algorithm_path, enabled)\\n\\n for i in xrange(1,4):\\n label = \\\"DPF{0}\\\".format(str(i))\\n lAng_label = 'L{0}ANG'.format(str(i))\\n cAng_label = 'C{0}ANG'.format(str(i))\\n distillate_label = get_distillate_label([lAng_label, cAng_label])\\n\\n # header\\n inigen.emit_run_header(label, CHUNKING, MINTIME, MAXTIME)\\n\\n # body\\n dep_lAng_label = lAng_label\\n dep_lAng_name = fields['deps'][0]\\n dep_lAng_uuid = self.uuid_map[lAng_label]\\n dep_cAng_label = cAng_label\\n dep_cAng_name = fields['deps'][1]\\n dep_cAng_uuid = self.uuid_map[cAng_label]\\n deps = [[dep_lAng_label, dep_lAng_name, dep_lAng_uuid],\\n [dep_cAng_label, dep_cAng_name, dep_cAng_uuid]]\\n\\n param_section_name = fields['params'][0]\\n param_section_value = \\\"Production/{0}/{1}/{2}\\\".format(self.location, self.name, distillate_label)\\n param_name_name = fields['params'][1]\\n param_name_value = \\\"DPF\\\"\\n params = [[param_section_name, param_section_value], [param_name_name, param_name_value]]\\n\\n outputs = fields['outputs']\\n\\n emitted = inigen.emit_run_body(deps, params, outputs)\\n\\n output_uuid_map[label] = emitted[-2][-36:]\\n\\n filename = \\\"{0}/DPF_{1}.ini\\\".format(self.dirname, self.name)\\n inigen.generate_file(filename)\\n return output_uuid_map\",\n \"def draw_graph(self, fpath):\\n import networkx as nx\\n G = self.to_networkx()\\n A = nx.nx_agraph.to_agraph(G)\\n\\n for proc in self.procs.values():\\n nbunch = [proc.name]\\n nbunch += [iport.absname() for iport in proc.iports.values()]\\n nbunch += [oport.absname() for oport in proc.oports.values()]\\n A.add_subgraph(\\n nbunch, name='cluster_' + proc.name,\\n color='lightgray', style='filled', fillcolor='lightgray')\\n # color=lightgray;style=filled;fillcolor=lightgray;\\n A.layout(prog='dot')\\n A.draw(fpath)\",\n \"def parsing(pfam_file):\\n pfam_file = open(pfam_file)\\n outfile = open(\\\"parsed_out_pfam.txt\\\", \\\"w\\\")\\n pfam_dict = {}\\n counter_proteins = 0\\n for line in pfam_file:\\n if not line.startswith(\\\"#\\\"):\\n columns = line.strip()\\n columns = columns.split()\\n if columns[2] not in pfam_dict:\\n pfam_dict[columns[2]] = columns[2],columns[0], columns[4]\\n counter_proteins += 1\\n line = \\\"%-20s: %-20s %-20s \\\\n\\\" %(columns[2], columns[0], columns[4])\\n outfile.write(line)\\n pfam_file.close()\\n print counter_proteins\\n return None\",\n \"def sixteen_graphs(the_dir):\\n # TODO change to deprecation warning\\n warnings.warn(\\\"Does not call sv_pipeline functoins correctly\\\", DeprecationWarning)\\n\\n plb.rcParams['figure.figsize'] = 30, 30\\n plt.clf()\\n plt.figure(1)\\n\\n # should look like: read_data/all_files/chr4_124,017,492_124,029,032_merged.txt\\n merged_files = glob.glob(the_dir + '*merged.txt')\\n print(\\\"Running for {} regions\\\".format(len(merged_files)))\\n for merged_filename in merged_files:\\n # get filenames\\n prefix = merged_filename[len(the_dir):-11]\\n fasta_filename = the_dir + prefix + \\\".fa\\\"\\n bed_filename = the_dir + prefix + \\\"-refcoords.bed\\\"\\n print('Using ' + prefix)\\n\\n for min_matching_length in range(100, 1700, 100):\\n print(min_matching_length)\\n # used for ground truth\\n preset, postset, spanset, gapset = get_read_classifications(prefix,\\\\\\n bed_filename, merged_filename=merged_filename)\\n # Generate and prune graph\\n graph = generate_graph(prefix, fasta_filename, min_matching_length)\\n graph = nx_helpers.remove_nodes(graph, preset)\\n graph = nx_helpers.remove_nodes(graph, postset)\\n\\n # Plot the graph\\n plt.subplot(4, 4, min_matching_length/100)\\n communities = nx_helpers.get_communities(graph)\\n graph, communities = drop_small_communities(graph, communities)\\n node_colors = node_community_colors(graph, communities)\\n pos = nx.spring_layout(graph)\\n title = \\\"Chr {0};\\\\n L={1}; NumCom={2}\\\\nComQual = {3}, MapQual={4}\\\"\\\\\\n .format(prefix, min_matching_length, len(communities),\\\\\\n community_quality(communities, spanset, gapset),\\\\\\n mapping_quality(graph, spanset, gapset))\\n nx.draw(graph, node_color=node_colors, node_size=100, pos=pos)\\n plt.title(title)\\n plt.savefig(\\\"figs/\\\" + prefix + '-16-communities.pdf')\\n plt.clf()\",\n \"def rpfp(self):\\n inigen = IniGen()\\n fields = algorithm_fields.algorithms['rpfp']\\n\\n output_uuid_map = {}\\n\\n # set up global parameters\\n algorithm_path = fields['path']\\n enabled = \\\"True\\\"\\n inigen.emit_global(algorithm_path, enabled)\\n\\n for i in xrange(1,4):\\n label = \\\"RPFP{0}\\\".format(str(i))\\n distillate_label = \\\"L{0}-E_C{1}\\\".format(str(i),str(i))\\n lAng_label = 'L{0}ANG'.format(str(i))\\n cAng_label = 'C{0}ANG'.format(str(i))\\n lMag_label = 'C{0}MAG'.format(str(i))\\n cMag_label = 'C{0}MAG'.format(str(i))\\n distillate_label = get_distillate_label([lAng_label, cAng_label, lMag_label, cMag_label])\\n\\n # header\\n inigen.emit_run_header(label, CHUNKING, MINTIME, MAXTIME)\\n\\n # body\\n dep_lAng_label = lAng_label\\n dep_lAng_name = fields['deps'][0]\\n dep_lAng_uuid = self.uuid_map[lAng_label]\\n dep_cAng_label = cAng_label\\n dep_cAng_name = fields['deps'][1]\\n dep_cAng_uuid = self.uuid_map[cAng_label]\\n dep_lMag_label = lMag_label\\n dep_lMag_name = fields['deps'][2]\\n dep_lMag_uuid = self.uuid_map[lMag_label]\\n dep_cMag_label = cMag_label\\n dep_cMag_name = fields['deps'][3]\\n dep_cMag_uuid = self.uuid_map[cMag_label]\\n \\n deps = [[dep_lAng_label, dep_lAng_name, dep_lAng_uuid],\\n [dep_lMag_label, dep_lMag_name, dep_lMag_uuid],\\n [dep_cAng_label, dep_cAng_name, dep_cAng_uuid],\\n [dep_cMag_label, dep_cMag_name, dep_cMag_uuid]]\\n\\n param_section_name = fields['params'][0]\\n param_section_value = \\\"Production/{0}/{1}/{2}\\\".format(self.location, self.name, distillate_label)\\n param_name_name = fields['params'][1]\\n param_name_value = \\\"RPFP\\\"\\n params = [[param_section_name, param_section_value], [param_name_name, param_name_value]]\\n\\n outputs = fields['outputs']\\n\\n emitted = inigen.emit_run_body(deps, params, outputs)\\n\\n output_uuid_map['REAC_PWR{0}'.format(i)] = emitted[-3][-36:]\\n output_uuid_map['FUND_PWR{0}'.format(i)] = emitted[-2][-36:]\\n\\n filename = \\\"{0}/RPFP_{1}.ini\\\".format(self.dirname, self.name)\\n inigen.generate_file(filename)\\n return output_uuid_map\",\n \"def load_pascal_annotation(filename):\\n tree = ET.parse(filename)\\n objs = tree.findall('object')[0]\\n\\n num_objs = len(objs)\\n\\n boxes = np.zeros((num_objs, 4), dtype=np.uint16)\\n gt_classes = np.zeros((num_objs), dtype=np.int32)\\n num_classes = 3\\n classes = ('__background__', # always index 0\\n 'mine',\\n 'nonmine')\\n class_to_ind = dict(zip(classes, range(num_classes)))\\n\\n overlaps = np.zeros((num_objs, num_classes), dtype=np.float32)\\n # \\\"Seg\\\" area for pascal is just the box area\\n seg_areas = np.zeros((num_objs), dtype=np.float32)\\n ishards = np.zeros((num_objs), dtype=np.int32)\\n\\n # Load object bounding boxes into a data frame.\\n for ix, obj in enumerate(objs):\\n bbox = obj.find('bndbox')\\n\\n # Make pixel indexes 0-based\\n x1 = float(bbox.find('xmin').text) - 1\\n y1 = float(bbox.find('ymin').text) - 1\\n x2 = float(bbox.find('xmax').text) - 1\\n y2 = float(bbox.find('ymax').text) - 1\\n\\n diffc = obj.find('difficult')\\n difficult = 0 if diffc == None else int(diffc.text)\\n ishards[ix] = difficult\\n\\n cls = class_to_ind[obj.find('name').text.lower().strip()]\\n boxes[ix, :] = [x1, y1, x2, y2]\\n gt_classes[ix] = cls\\n overlaps[ix, cls] = 1.0\\n seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1)\\n\\n overlaps = scipy.sparse.csr_matrix(overlaps)\\n\\n return {'boxes': boxes,\\n 'gt_classes': gt_classes,\\n 'gt_ishard': ishards,\\n 'gt_overlaps': overlaps,\\n 'flipped': False,\\n 'seg_areas': seg_areas}\",\n \"def generatePositivePHASLoci(options,whole_mapped_data,phase,cycle):\\n out_filename=options.output_directory_per_run+\\\"/\\\"+options.input_filename+\\\"_\\\"+str(phase)+\\\"_\\\"+str(cycle)+\\\".positive_phase_loci\\\"\\n fhw=open(out_filename,\\\"w\\\")\\n for chromosome in sorted(whole_mapped_data):\\n filename=options.output_directory_per_run+\\\"/\\\"+options.input_filename+\\\"_\\\"+str(phase)+\\\"_\\\"+str(cycle)+\\\"_\\\"+chromosome+\\\".regionsOfInterest.concentrated\\\"\\n try:\\n fhr=open(filename,\\\"r\\\")\\n except FileNotFoundError:\\n continue\\n flag_reg=1000\\n window_start,window_end=0,0\\n for line in fhr:\\n \\\"\\\"\\\"pvalue=float(line.strip().split()[-1])\\n if pvalue>=options.pvalue_cutoff:continue\\\"\\\"\\\"\\n register,start,end=map(int,line.strip().split()[:3])\\n if register==flag_reg:\\n if window_end>start:\\n window_end=end\\n else:\\n fhw.write(chromosome+\\\"\\\\t\\\"+str(window_start)+\\\"\\\\t\\\"+str(window_end)+\\\"\\\\n\\\")\\n window_start=start\\n window_end=end\\n else:\\n if flag_reg!=1000:\\n fhw.write(chromosome+\\\"\\\\t\\\"+str(window_start)+\\\"\\\\t\\\"+str(window_end)+\\\"\\\\n\\\")\\n window_start=start\\n window_end=end\\n flag_reg=register\\n fhr.close()\\n fhw.write(chromosome+\\\"\\\\t\\\"+str(window_start)+\\\"\\\\t\\\"+str(window_end)+\\\"\\\\n\\\")\\n fhw.close()\",\n \"def comparison():\\n path = \\\"Data/data_fronts/\\\"\\n path1 = \\\"Results/labelled_images1010/fronts/\\\"\\n\\n #computes the areas for the first frame in order to normalize the other areas\\n pol0 = pd.DataFrame(pd.read_csv(path1 + \\\"fronts_labelled.m.0.png.txt\\\",sep =' '))\\n #makes an object polygon in order to compute the area\\n pol0 = np.array(pol0)\\n pol0 = Polygon(pol0)\\n\\n polsx = pd.DataFrame(pd.read_csv(path + \\\"Sham_8-2-18_Field 5_1_sx.txt\\\",sep ='\\\\t'))\\n polsx.columns = [\\\"y\\\",\\\"x\\\"]\\n poldx = pd.DataFrame(pd.read_csv(path + \\\"Sham_8-2-18_Field 5_1_dx.txt\\\",sep ='\\\\t'))\\n poldx.columns = [\\\"y\\\",\\\"x\\\"]\\n #makes an object polygon in order to compute the area\\n polsx = polsx.append(poldx)\\n polsx = np.array(polsx)\\n pol1 = Polygon(polsx)\\n\\n\\n areas = []\\n areas_hand = []\\n #computes the areas for all the frames\\n for i in range(42):\\n pol = pd.DataFrame(pd.read_csv(path1 + \\\"fronts_labelled.m.\\\"+str(i)+\\\".png.txt\\\",sep =' '))\\n pol = np.array(pol)\\n pol = Polygon(pol)\\n #normalize the areas with respect to the area of the first frame\\n areas.append(pol.area/pol0.area)\\n\\n polsx = pd.DataFrame(pd.read_csv(path + \\\"Sham_8-2-18_Field 5_\\\"+str(i+1)+\\\"_sx.txt\\\",sep ='\\\\t'))\\n polsx.columns = [\\\"y\\\",\\\"x\\\"]\\n poldx = pd.DataFrame(pd.read_csv(path + \\\"Sham_8-2-18_Field 5_\\\"+str(i+1)+\\\"_dx.txt\\\",sep ='\\\\t'))\\n poldx.columns = [\\\"y\\\",\\\"x\\\"]\\n if poldx[\\\"x\\\"][0]>100:\\n poldx = poldx.reindex(index=poldx.index[::-1])\\n if polsx[\\\"x\\\"][0]<100:\\n polsx = polsx.reindex(index=polsx.index[::-1])\\n polsx = polsx.append(poldx)\\n polsx = np.array(polsx)\\n\\n pol2 = Polygon(polsx)\\n #normalize the areas with respect to the area of the first frame\\n areas_hand.append(pol2.area/pol1.area)\\n #returns the two arrays with the normalized areas\\n return np.array(areas) , np.array(areas_hand)\",\n \"def _parse_pbf(self):\\n # todo pyrosm bounding_box is inefficient, first extract bbox from pbf using pyosmium\\n osm = pyrosm.OSM(filepath=self._pbf, bounding_box=self._bbox)\\n osm.keep_node_info = True\\n logging.info(\\\"Parsing OSM ways and nodes from pbf file\\\")\\n ways = osm.get_network(self._profile)\\n\\n all_nodes = osm._nodes_gdf # todo this has all the attributes but goes out of memory easily\\n way_nodes_ids = ways.nodes.explode().unique().tolist()\\n nodes = all_nodes.loc[all_nodes.id.isin(way_nodes_ids)]\\n\\n def clip_way(way):\\n clipped_way = way.copy()\\n clipped_way.nodes = clipped_way.nodes[:len(way.geometry.coords.xy[0])-1]\\n return clipped_way\\n\\n broken_ways = ways.nodes.apply(lambda x: not all(n in nodes.id.to_list() for n in x))\\n for ix, way in ways.loc[broken_ways].iterrows():\\n ways.loc[ix] = clip_way(way)\\n\\n # all_nodes = osm._node_coordinates\\n # way_nodes = {id: all_nodes[id] for id in way_nodes_ids if id in all_nodes.keys()}\\n # nodes = pd.DataFrame.from_dict(way_nodes, orient='index', columns=['longitude', 'latitude'])\\n # nodes['id'] = nodes.index\\n\\n # ways_nodes_found = ways.nodes.apply(lambda x: all(n in nodes.id.to_list() for n in x))\\n # nodes = pd.DataFrame(columns=['id', 'latitude', 'longitude'])\\n # for ix, way in ways.iterrows():\\n # way_nodes = pd.DataFrame(columns=['id', 'latitude', 'longitude'])\\n # try:\\n # way_nodes.id = way.nodes\\n # way_nodes.latitude = way.geometry.coords.xy[1]\\n # way_nodes.longitude = way.geometry.coords.xy[0]\\n # except:\\n # pass\\n # nodes = nodes.append(way_nodes, ignore_index=True)\\n\\n logging.info(\\\"Done parsing pbf file\\\")\\n return nodes, ways\",\n \"def gaps(args):\\n from jcvi.formats.sizes import agp\\n from jcvi.formats.agp import mask, build\\n\\n p = OptionParser(gaps.__doc__)\\n p.add_option(\\n \\\"--split\\\", default=False, action=\\\"store_true\\\", help=\\\"Generate .split.fasta\\\"\\n )\\n p.set_mingap(default=100)\\n p.set_cpus()\\n opts, args = p.parse_args(args)\\n\\n if len(args) != 1:\\n sys.exit(not p.print_help())\\n\\n (inputfasta,) = args\\n mingap = opts.mingap\\n split = opts.split\\n prefix = inputfasta.rsplit(\\\".\\\", 1)[0]\\n bedfile = prefix + \\\".gaps.bed\\\"\\n\\n if need_update(inputfasta, bedfile):\\n write_gaps_bed(inputfasta, prefix, mingap, opts.cpus)\\n\\n if split:\\n splitfile = prefix + \\\".split.fasta\\\"\\n oagpfile = prefix + \\\".splitobject.agp\\\"\\n cagpfile = prefix + \\\".splitcomponent.agp\\\"\\n\\n if need_update((inputfasta, bedfile), splitfile):\\n\\n sizesagpfile = agp([inputfasta])\\n\\n maskedagpfile = mask([sizesagpfile, bedfile, \\\"--splitobject\\\"])\\n shutil.move(maskedagpfile, oagpfile)\\n logging.debug(\\\"AGP file written to `{0}`.\\\".format(oagpfile))\\n\\n maskedagpfile = mask([sizesagpfile, bedfile, \\\"--splitcomponent\\\"])\\n shutil.move(maskedagpfile, cagpfile)\\n logging.debug(\\\"AGP file written to `{0}`.\\\".format(cagpfile))\\n\\n build([oagpfile, inputfasta, splitfile])\\n cleanup(sizesagpfile)\\n\\n return splitfile, oagpfile, cagpfile\",\n \"def fetchGraph_adjList(fName):\\n G = Graph()\\n adjList = dict()\\n myOpen = gzip.open if fName.split(\\\".\\\")[-1]==\\\"gz\\\" else open\\n with myOpen(fName,'r') as f:\\n for line in f:\\n c = line.split()\\n if c[0]=='p':\\n G.v = int(c[2])\\n G.e = int(c[3])\\n eType = int(c[4])\\n\\n elif c[0]=='e':\\n vi = int(c[1])\\n vj = int(c[2])\\n\\n if vi not in adjList: adjList[vi]=[]\\n adjList[vi].append(vj)\\n\\n if eType==0:\\n if vj not in adjList: adjList[vj]=[]\\n adjList[vj].append(vi)\\n\\n G.adjList = adjList\\n return G\",\n \"def load_pascal_annotation(index):\\n filename = os.path.join(root_path, 'Annotations', index + '.xml')\\n # print(filename)\\n tree = ET.parse(filename)\\n objs = tree.findall('object')\\n num_objs = len(objs)\\n\\n boxes = np.zeros((num_objs, 4), dtype=np.uint16)\\n rboxes = np.zeros((num_objs, 5), dtype=np.uint16)\\n quadboxes = np.zeros((num_objs, 8), dtype=np.uint16)\\n gt_classes = np.zeros((num_objs), dtype=np.int32)\\n # regression for rotate box (x0,y0,x1,y1,h)\\n gt_rbox = np.zeros((num_objs, 5), dtype=np.int32)\\n overlaps = np.zeros((num_objs, num_classes), dtype=np.float32)\\n # \\\"Seg\\\" area for pascal is just the box area\\n seg_areas = np.zeros((num_objs), dtype=np.float32)\\n\\n # Load object bounding boxes into a data frame.\\n for ix, obj in enumerate(objs):\\n bbox = obj.find('bndbox')\\n # Make pixel indexes 0-based\\n x1 = float(bbox.find('xmin').text)\\n y1 = float(bbox.find('ymin').text)\\n x2 = float(bbox.find('xmax').text)\\n y2 = float(bbox.find('ymax').text) \\n \\n class_to_ind = dict(list(zip(classes, list(range(num_classes)))))\\n cls = class_to_ind[obj.find('name').text.lower().strip()]\\n boxes[ix, :] = [x1, y1, x2, y2]\\n \\n # add quadbox object information\\n quadbox = obj.find('quadbox')\\n quadx0 = float(quadbox.find('quadx0').text)\\n quady0 = float(quadbox.find('quady0').text)\\n quadx1 = float(quadbox.find('quadx1').text)\\n quady1 = float(quadbox.find('quady1').text)\\n quadx2 = float(quadbox.find('quadx2').text)\\n quady2 = float(quadbox.find('quady2').text)\\n quadx3 = float(quadbox.find('quadx3').text)\\n quady3 = float(quadbox.find('quady3').text)\\n quadboxes[ix, :] = [quadx0,quady0,quadx1,quady1,quadx2,quady2,quadx3,quady3]\\n\\n # add rbox object information\\n rbox = obj.find('rbox')\\n rx0 = float(rbox.find('x0').text)\\n ry0 = float(rbox.find('y0').text)\\n rx1 = float(rbox.find('x1').text)\\n ry1 = float(rbox.find('y1').text)\\n rh = float(rbox.find('h').text)\\n rboxes[ix, :] = [rx0,ry0,rx1,ry1,rh]\\n \\n gt_classes[ix] = cls\\n overlaps[ix, cls] = 1.0\\n seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1)\\n overlaps = scipy.sparse.csr_matrix(overlaps)\\n # return gt_roidb\\n return {'boxes': boxes,\\n 'rboxes': rboxes,\\n 'quadboxes': quadboxes,\\n 'gt_classes': gt_classes,\\n 'gt_overlaps': overlaps,\\n 'flipped': False,\\n 'seg_areas': seg_areas}\",\n \"def main():\\r\\n\\timport sys\\r\\n\\r\\n\\tlistofSequences = FastAreader(sys.stdin).readFasta() \\r\\n\\tPAMSequences = PAMfinder(listofSequences).classController() # Calls on controller class to return desired models.\\r\\n\\tf = open('Guide Sequences.txt','w') \\r\\n\\tfor i in range(len(PAMSequences[0])):\\r\\n\\t\\tf.write(PAMSequences[0][i]) # Prints the header sequence into the file.\\r\\n\\t\\tf.write('\\\\n') \\r\\n\\t\\tprint(PAMSequences[0][i]) \\r\\n\\t\\tfor j in range(len(PAMSequences[1][i])): \\r\\n\\t\\t\\tif j == 0: \\r\\n\\t\\t\\t\\tf.write(\\\"Forward Strand PAM Sites:\\\") \\r\\n\\t\\t\\t\\tf.write('\\\\n')\\r\\n\\t\\t\\t\\tprint(\\\"Forward Strand PAM Sites:\\\") \\r\\n\\t\\t\\tprint(PAMSequences[1][i][j]) # Prints the forward sequences\\r\\n\\t\\t\\ty = str(PAMSequences[1][i][j]) # Changes from int to string characters.\\r\\n\\t\\t\\tx = ''.join(y) # Joining all the string values so we can print to file.\\r\\n\\t\\t\\tf.write(x) # Write the joined forward sequences to the file.\\r\\n\\t\\t\\tf.write('\\\\n')\\r\\n\\t\\tfor k in range(len(PAMSequences[2][i])): # For reverse sequences, and follows same logic as forward. \\r\\n\\t\\t\\tif k == 0:\\r\\n\\t\\t\\t\\tf.write(\\\"Reverse Strand PAM Sites (in reference to the Top Strand Position):\\\")\\r\\n\\t\\t\\t\\tf.write('\\\\n')\\r\\n\\t\\t\\t\\tprint(\\\"Reverse Strand PAM Sites (in reference to the Top Strand Position):\\\")\\r\\n\\t\\t\\tprint(PAMSequences[2][i][k]) # Prints the reverse sequences with the corresponding positions. \\r\\n\\t\\t\\ta = str(PAMSequences[2][i][k]) # Changes the integer to string characters, allowing for the values to join.\\r\\n\\t\\t\\tb = ''.join(a)\\r\\n\\t\\t\\tf.write(b) # Write all of the reverse sequences onto the text file with their positions. \\r\\n\\t\\t\\tf.write('\\\\n')\\r\\n\\tf.close() # Close the file.\\r\",\n \"def get_ngram_overlap(ngram_file_a, ngram_file_b, freq_bound, corpus_name_a, corpus_name_b, target_dir):\\n print('Comparing n-gram inventories ...')\\n\\n # Read in corpus files\\n df_ngram_counts_a = pd.read_table(ngram_file_a, header=None, names=['Rank', 'Ngram', 'Counts'],\\n skip_blank_lines=True)\\n df_ngram_counts_b = pd.read_table(ngram_file_b, header=None, names=['Rank', 'Ngram', 'Counts'],\\n skip_blank_lines=True)\\n # Build n-gram inventories\\n ngram_list_a = [df_ngram_counts_a.iloc[row_id, 1] for row_id in range(len(df_ngram_counts_a))]\\n ngram_list_b = [df_ngram_counts_b.iloc[row_id, 1] for row_id in range(len(df_ngram_counts_b))]\\n bound_list_a = [df_ngram_counts_a.iloc[row_id, 1] for row_id in range(len(df_ngram_counts_a))\\n if int(df_ngram_counts_a.iloc[row_id, 2]) >= freq_bound]\\n bound_list_b = [df_ngram_counts_b.iloc[row_id, 1] for row_id in range(len(df_ngram_counts_b))\\n if int(df_ngram_counts_b.iloc[row_id, 2]) >= freq_bound]\\n\\n # Calculate total unique n-gram overlap\\n total_shared_ngrams = [ngram for ngram in ngram_list_a if ngram in ngram_list_b]\\n total_shared_count = len(total_shared_ngrams)\\n total_unique_ngrams_a = len(ngram_list_a) - total_shared_count\\n total_unique_ngrams_b = len(ngram_list_b) - total_shared_count\\n\\n # Calculate frequency-bounded unique ngram overlap\\n bound_shared_ngrams = [ngram for ngram in bound_list_a if ngram in bound_list_b]\\n bound_shared_count = len(bound_shared_ngrams)\\n bound_unique_ngrams_a = len(bound_list_a) - bound_shared_count\\n bound_unique_ngrams_b = len(bound_list_b) - bound_shared_count\\n\\n # Calculate overlap fractions\\n total_overlap_fraction_a = total_shared_count / len(ngram_list_a)\\n bound_overlap_fraction_a = bound_shared_count / len(bound_list_a)\\n total_overlap_fraction_b = total_shared_count / len(ngram_list_b)\\n bound_overlap_fraction_b = bound_shared_count / len(bound_list_b)\\n\\n # Write collected information to file\\n gram_size = len(total_shared_ngrams[0].split())\\n overlap_log_path = os.path.join(target_dir, '{:s}_{:s}_{:d}-gram_overlap.txt'\\n .format(corpus_name_a, corpus_name_b, gram_size))\\n with codecs.open(overlap_log_path, 'w', encoding='utf8') as overlap_file:\\n overlap_file.write('Compared corpora: {:s} and {:s}\\\\n'.format(corpus_name_a, corpus_name_b))\\n overlap_file.write('=' * 10 + '\\\\n')\\n overlap_file.write('Total {:s} vocabulary size: {:d} entries\\\\n'.format(corpus_name_a, len(ngram_list_a)))\\n overlap_file.write('Total {:s} vocabulary size: {:d} entries\\\\n'.format(corpus_name_b, len(ngram_list_b)))\\n overlap_file.write('Bound {:s} vocabulary size for bound {:d}: {:d} entries\\\\n'\\n .format(corpus_name_a, freq_bound, len(bound_list_a)))\\n overlap_file.write('Bound fraction for {:s} corpus: {:.4f} entries\\\\n'\\n .format(corpus_name_a, len(bound_list_a) / len(ngram_list_a)))\\n overlap_file.write('Bound {:s} vocabulary for bound {:d} size: {:d} entries\\\\n'\\n .format(corpus_name_b, freq_bound, len(bound_list_b)))\\n overlap_file.write('Bound fraction for {:s} corpus: {:.4f} entries\\\\n'\\n .format(corpus_name_b, len(bound_list_b) / len(ngram_list_b)))\\n overlap_file.write('=' * 10 + '\\\\n')\\n overlap_file.write('Total overlap size: {:d} entries\\\\n'.format(total_shared_count))\\n overlap_file.write('Total unique {:d}-grams for corpus {:s}: {:d}\\\\n'\\n .format(gram_size, corpus_name_a, total_unique_ngrams_a))\\n overlap_file.write('Total unique {:d}-grams for corpus {:s}: {:d}\\\\n'\\n .format(gram_size, corpus_name_b, total_unique_ngrams_b))\\n overlap_file.write('Frequency-bound overlap size for bound {:d}: {:d} entries\\\\n'.\\n format(freq_bound, bound_shared_count))\\n overlap_file.write('Frequency-bound unique {:d}-grams for corpus {:s}: {:d}\\\\n'\\n .format(gram_size, corpus_name_a, bound_unique_ngrams_a))\\n overlap_file.write('Frequency-bound unique {:d}-grams for corpus {:s}: {:d}\\\\n'\\n .format(gram_size, corpus_name_b, bound_unique_ngrams_b))\\n overlap_file.write('=' * 10 + '\\\\n')\\n overlap_file.write('Total overlap fraction for corpus {:s}: {:.4f}\\\\n'\\n .format(corpus_name_a, total_overlap_fraction_a))\\n overlap_file.write('Frequency-bound overlap fraction for corpus {:s} for bound {:d}: {:.4f}\\\\n'\\n .format(corpus_name_a, freq_bound, bound_overlap_fraction_a))\\n overlap_file.write('=' * 10 + '\\\\n')\\n overlap_file.write('Total overlap fraction for corpus {:s}: {:.4f}\\\\n'\\n .format(corpus_name_b, total_overlap_fraction_b))\\n overlap_file.write('Frequency-bound overlap fraction for corpus {:s} for bound {:d}: {:.4f}\\\\n'\\n .format(corpus_name_b, freq_bound, bound_overlap_fraction_b))\\n print('Done.')\",\n \"def Overtopping(self):\\n\\n #sort files\\n leftOverTop = list()\\n RightOverTop = list()\\n # get names of files that has _left or _right at its end\\n All1DFiles = os.listdir(self.OneDResultPath)\\n for i in range(len(All1DFiles)) :\\n if All1DFiles[i].endswith(self.leftOvertopping_Suffix):\\n leftOverTop.append(All1DFiles[i])\\n if All1DFiles[i].endswith(self.RightOvertopping_Suffix):\\n RightOverTop.append(All1DFiles[i])\\n\\n # two dictionaries for overtopping left and right\\n OverToppingSubsLeft = dict()\\n OverToppingSubsRight = dict()\\n # the _left and _right files has all the overtopping discharge\\n # but sometimes the sum of all the overtopping is less than a threshold specified\\n # and then the 2D algorithm does not run so these cross sections you will not find\\n # any inundation beside it in the maps but you will find it in the _left or _right maps\\n\\n # for each sub-basin that has overtopping from the left dike\\n for i in range(len(leftOverTop)):\\n\\n try:\\n # open the file (if there is no column sthe file is empty)\\n data = pd.read_csv(self.OneDResultPath + leftOverTop[i],header =None,delimiter = r'\\\\s+')\\n # add the sub basin to the overtopping dictionary of sub-basins\\n OverToppingSubsLeft[leftOverTop[i][:-len(self.leftOvertopping_Suffix)]] = dict()\\n except:\\n continue\\n # get the XS that overtopping happened from\\n XSs = list(set(data.loc[:,2]))\\n # for each XS get the days\\n for j in range(len(XSs)):\\n OverToppingSubsLeft[leftOverTop[i][:-len(self.leftOvertopping_Suffix)]][XSs[j]] = list(set(data[0][data[2] == XSs[j]].tolist()))\\n\\n for i in range(len(RightOverTop)):\\n\\n try:\\n # open the file\\n data = pd.read_csv(self.OneDResultPath + RightOverTop[i],header =None,delimiter = r'\\\\s+')\\n # add the sub basin to the overtopping dictionary of sub-basins\\n OverToppingSubsRight[RightOverTop[i][:-len(self.RightOvertopping_Suffix)]] = dict()\\n except :\\n continue\\n # get the XS that overtopping happened from\\n XSs = list(set(data.loc[:,2]))\\n # for each XS get the days\\n for j in range(len(XSs)):\\n OverToppingSubsRight[RightOverTop[i][:-len(self.RightOvertopping_Suffix)]][XSs[j]] = list(set(data[0][data[2] == XSs[j]].tolist()))\\n\\n self.OverToppingSubsLeft = OverToppingSubsLeft\\n self.OverToppingSubsRight = OverToppingSubsRight\",\n \"def _get_full_graph(self):\",\n \"def create_all(graph,first_last_fn):\\n trip_id = 1\\n line_num = 0\\n num_trips = 0\\n trip_id2model = {}\\n #paths = {}\\n p = Path(trip_id,graph,line_num=line_num)\\n trip_id2model[trip_id] = p.edges\\n num_trips += 1\\n #paths[trip_id] = p\\n while p.next_line != len(graph.lines):#file_length:\\n graph.trip_id2line_num[trip_id] = line_num\\n line_num = p.next_line\\n trip_id = normalize_simple(graph.lines[line_num])[0]\\n #trip_id = dg.normalize(lines[line_num])[0]\\n p = Path(trip_id,graph,line_num=line_num)\\n trip_id2model[trip_id] = p.edges\\n num_trips += 1\\n # paths[trip_id] = p\\n graph.trip_id2line_num[trip_id] = line_num\\n graph.num_trips = num_trips\\n\\n\\n with open(first_last_fn,'wb') as output:\\n pickle.dump(graph.first_last2trip_ids,output)\\n\\n with open('pickles/trip_id2model.pickle','wb') as output:\\n pickle.dump(trip_id2model,output)\\n #return paths\",\n \"def main():\\n\\n args = get_args()\\n \\n patient_years_dict = {}\\n\\n isolates_to_seq = []\\n\\n with open(args.input_file, \\\"r\\\") as infile1:\\n for line in infile1:\\n if not line.startswith(\\\"PID\\\"):\\n line_elements = line.strip().split(\\\"\\\\t\\\")\\n patient_anumber = line_elements[1].split(\\\"_\\\")[0]\\n patient_year = line_elements[2].split(\\\"-\\\")[0]\\n if patient_anumber not in patient_years_dict:\\n patient_years_dict[patient_anumber] = {patient_year:[line]}\\n else:\\n if patient_year not in patient_years_dict[patient_anumber]:\\n patient_years_dict[patient_anumber][patient_year] = [line]\\n if line not in patient_years_dict[patient_anumber][patient_year]:\\n patient_years_dict[patient_anumber][patient_year].append(line)\\n \\n for patient in patient_years_dict:\\n for year in patient_years_dict[patient]:\\n print(f\\\"Checking patient {patient} and year {year}...\\\")\\n wgs_codes = []\\n pfge_codes = []\\n isolate_dates = []\\n isolate_lines = []\\n for isolate in patient_years_dict[patient][year]:\\n isolate_elements = isolate.strip().split(\\\"\\\\t\\\")\\n wgs_codes.append(int(isolate_elements[5]))\\n pfge_codes.append(int(isolate_elements[4]))\\n isolate_dates.append(isolate_elements[2])\\n isolate_lines.append(isolate)\\n \\n if any(wgs_codes):\\n print(f\\\"\\\\tWGS present, moving on to next year/patient.\\\")\\n continue\\n else:\\n print(f\\\"\\\\tWGS missing, checking PFGE...\\\\n\\\\tPFGE presence/absence codes for {year} are: {pfge_codes}\\\")\\n if any(pfge_codes):\\n pfge_index = pfge_codes.index(1)\\n isolate_to_seq = isolate_dates[pfge_index]\\n isolate_line_to_seq = isolate_lines[pfge_index]\\n print(f\\\"\\\\tPFGE present, selecting first isolate with PFGE to sequence...\\\\n\\\\tIsolate to sequence is ---> {isolate_to_seq} <--- out of possible isolates {isolate_dates}.\\\")\\n isolates_to_seq.append(isolate_line_to_seq)\\n else:\\n print(f\\\"\\\\tPFGE missing...\\\\n\\\\tSelecting 1st available isolate for sequencing ---> {isolate_dates[0]} <--- out of available isolates {isolate_dates}.\\\")\\n isolates_to_seq.append(isolate_lines[0])\\n\\n header = f\\\"PID\\\\tADATE\\\\tCULTDAT\\\\tvalues\\\\tPFGE_Isolates\\\\tSequenced_Isolates\\\\n\\\" \\n to_write = \\\"\\\".join(isolates_to_seq)\\n with open(args.output_file, \\\"w\\\") as outfile1:\\n outfile1.write(header + to_write)\",\n \"async def get_graph_for_file(\\n file_name: str,\\n score: int = 0,\\n par_length: int = 0,\\n co_occ: int = 0,\\n target_collection: List[str] = Query([]),\\n):\\n database = get_db()\\n query_graph_result = database.AQLQuery(\\n query=main_queries.QUERY_GRAPH_VIEW,\\n batchSize=15000,\\n bindVars={\\n \\\"filename\\\": file_name,\\n \\\"score\\\": score,\\n \\\"parlength\\\": par_length,\\n \\\"coocc\\\": co_occ,\\n \\\"targetcollection\\\": target_collection,\\n },\\n )\\n collection_keys = []\\n total_collection_dict = {}\\n total_histogram_dict = {}\\n\\n # extract a dictionary of collection numbers and number of parallels for each\\n for parallel in query_graph_result.result:\\n count_this_parallel = parallel[\\\"parlength\\\"]\\n target_filename = re.sub(\\\"_[0-9][0-9][0-9]\\\",\\\"\\\",parallel[\\\"textname\\\"])\\n if target_filename in total_histogram_dict.keys():\\n total_histogram_dict[target_filename] += count_this_parallel\\n else:\\n total_histogram_dict[target_filename] = count_this_parallel\\n\\n collection_key = re.search(COLLECTION_PATTERN, target_filename)\\n\\n if not collection_key:\\n continue\\n\\n collection = collection_key.group()\\n if collection not in total_collection_dict.keys():\\n total_collection_dict[collection] = count_this_parallel\\n else:\\n total_collection_dict[collection] += count_this_parallel\\n if collection not in collection_keys:\\n collection_keys.append(collection)\\n\\n # find the proper full names vor each collection\\n collections = database.AQLQuery(\\n query=menu_queries.QUERY_COLLECTION_NAMES,\\n bindVars={\\n \\\"collections\\\": collection_keys,\\n \\\"language\\\": get_language_from_filename(file_name),\\n },\\n )\\n\\n collections_with_full_name = {}\\n for collection_result in collections.result[0]:\\n collections_with_full_name.update(collection_result)\\n\\n parallel_graph_name_list = {}\\n for key in total_collection_dict:\\n parallel_graph_name_list.update(\\n {key + \\\" \\\" + collections_with_full_name[key]: total_collection_dict[key]}\\n )\\n\\n unsorted_graphdata_list = list(map(list, parallel_graph_name_list.items()))\\n\\n histogram_data = []\\n for name, count in total_histogram_dict.items():\\n displayname = name\\n query_displayname = database.AQLQuery(\\n query=main_queries.QUERY_DISPLAYNAME,\\n bindVars={\\n \\\"filename\\\": name\\n },\\n rawResults=True\\n )\\n displayname_results = query_displayname.result\\n if displayname_results:\\n displayname = displayname_results[0][0] + ' (' + displayname_results[0][1] + ')'\\n\\n histogram_data.append([displayname, count])\\n\\n # returns a list of the data as needed by Google Graphs\\n return {\\n \\\"piegraphdata\\\": sorted(\\n unsorted_graphdata_list, reverse=True, key=lambda x: x[1]\\n ),\\n \\\"histogramgraphdata\\\": sorted(histogram_data, reverse=True, key=lambda x: x[1]),\\n }\",\n \"def createOutput():\\n\\n firstPeriod = True\\n # get edge No\\n edgesNo = 0\\n edgesSet = set()\\n for timestep, taxiList in vtypeDict.iteritems():\\n for tup in taxiList:\\n edgesSet.add(tup[1])\\n edgesNo = len(edgesSet)\\n\\n outputFile = open(path.FQoutput, 'w')\\n outputFile.write('<?xml version=\\\"1.0\\\"?>\\\\n')\\n outputFile.write('<paramEffects aggregationInterval=\\\"%d\\\" vehicles=\\\"%d\\\" edges=\\\"%d\\\">\\\\n' % (\\n aggInterval, vehSum, edgesNo))\\n for period, quota, vtypeDictR, taxiSum in generatePeriodQuotaSets(True):\\n if quota is None:\\n if not firstPeriod:\\n outputFile.write(\\\"\\\\t</periods>\\\\n\\\")\\n else:\\n firstPeriod = False\\n outputFile.write('\\\\t<periods period=\\\"%d\\\">\\\\n' % (period))\\n else:\\n simpleTaxiMeanVList = [0, 1]\\n simpleEdgeMeanVList = [0, 1]\\n drivenEdgesSet = set()\\n\\n if len(vtypeDictR) == 0: # if the processed FCD returns no Values\\n print(\\\"noData p\\\", period, \\\" q\\\", quota)\\n drivenEdgesSet.add(0)\\n else: # create mean from all taxi speed values\\n for timestep, taxiList in vtypeDictR.iteritems():\\n for tup in taxiList: # all elements in this timestep\\n simpleTaxiMeanVList[0] += tup[2]\\n simpleTaxiMeanVList[1] += 1\\n drivenEdgesSet.add(tup[1])\\n # create mean from all edge speed values which are driven by the\\n # chosen taxis\\n drivenEdgesList = list(drivenEdgesSet)\\n drivenEdgesList.sort()\\n # print \\\"dataSets \\\",simpleTaxiMeanVList[1]\\n\\n # --edgeDump-- #\\n \\\"\\\"\\\"\\n for i in edgeDumpDict.keys(): #all intervals\\n for edge,v in edgeDumpDict[i]:\\n if BinarySearch.isElmInList(drivenEdgesList,edge):\\n simpleEdgeMeanVList[0]+=v\\n simpleEdgeMeanVList[1]+=1\\n \\\"\\\"\\\"\\n # --vtype-- #\\n\\n for timestep, taxiList in vtypeDict.iteritems():\\n for tup in taxiList:\\n if BinarySearch.isElmInList(drivenEdgesList, tup[1]):\\n simpleEdgeMeanVList[0] += tup[2]\\n simpleEdgeMeanVList[1] += 1\\n\\n # calc values for output\\n detectedEdges = len(drivenEdgesSet)\\n relDetectedEdges = detectedEdges * 100.0 / edgesNo\\n vSim = simpleEdgeMeanVList[0] / simpleEdgeMeanVList[1]\\n vSimFCD = simpleTaxiMeanVList[0] / simpleTaxiMeanVList[1]\\n vAbsDiff = vSimFCD - vSim\\n if vSim != 0:\\n vRelDiff = vAbsDiff / vSim * 100\\n else:\\n vRelDiff = 100\\n if vRelDiff < -40:\\n vRelDiff = -35\\n\\n outputFile.write('\\\\t\\\\t<values taxiQuota=\\\"%f\\\" taxis=\\\"%d\\\" simMeanSpeed=\\\"%f\\\" simFcdMeanSpeed=\\\"%f\\\" ' % (\\n quota, taxiSum, vSim, vSimFCD,))\\n outputFile.write('detectedEdges=\\\"%d\\\" notDetectedEdges=\\\"%d\\\" ' % (\\n detectedEdges, edgesNo - detectedEdges))\\n outputFile.write('absSpeedDiff=\\\"%f\\\" relSpeedDiff=\\\"%f\\\" relDetectedEdges=\\\"%f\\\" relNotDetectedEdges=\\\"%f\\\"/>\\\\n' %\\n (vAbsDiff, vRelDiff, relDetectedEdges, 100 - relDetectedEdges))\\n outputFile.write(\\\"\\\\t</periods>\\\\n</paramEffects>\\\")\\n outputFile.close()\",\n \"def load_pascal_annotation(index, pascal_root):\\n classes = ('__background__', # always index 0\\n 'aeroplane', 'bicycle', 'bird', 'boat',\\n 'bottle', 'bus', 'car', 'cat', 'chair',\\n 'cow', 'diningtable', 'dog', 'horse',\\n 'motorbike', 'person', 'pottedplant',\\n 'sheep', 'sofa', 'train', 'tvmonitor')\\n class_to_ind = dict(zip(classes, xrange(21)))\\n\\n filename = osp.join(pascal_root, 'Annotations', index + '.xml')\\n # print 'Loading: {}'.format(filename)\\n\\n def get_data_from_tag(node, tag):\\n return node.getElementsByTagName(tag)[0].childNodes[0].data\\n\\n with open(filename) as f:\\n data = minidom.parseString(f.read())\\n\\n objs = data.getElementsByTagName('object')\\n num_objs = len(objs)\\n\\n boxes = np.zeros((num_objs, 4), dtype=np.uint16)\\n gt_classes = np.zeros((num_objs), dtype=np.int32)\\n overlaps = np.zeros((num_objs, 21), dtype=np.float32)\\n\\n # Load object bounding boxes into a data frame.\\n for ix, obj in enumerate(objs):\\n # Make pixel indexes 0-based\\n x1 = float(get_data_from_tag(obj, 'xmin')) - 1\\n y1 = float(get_data_from_tag(obj, 'ymin')) - 1\\n x2 = float(get_data_from_tag(obj, 'xmax')) - 1\\n y2 = float(get_data_from_tag(obj, 'ymax')) - 1\\n cls = class_to_ind[\\n str(get_data_from_tag(obj, \\\"name\\\")).lower().strip()]\\n boxes[ix, :] = [x1, y1, x2, y2]\\n gt_classes[ix] = cls\\n overlaps[ix, cls] = 1.0\\n\\n overlaps = scipy.sparse.csr_matrix(overlaps)\\n\\n return {'boxes': boxes,\\n 'gt_classes': gt_classes,\\n 'gt_overlaps': overlaps,\\n 'flipped': False,\\n 'index': index}\",\n \"def gen_graph(self):\",\n \"def project(database, frequent_nodes, minsup, freq_labels, length, H, L, L_hat, n_graphs, n_pos, n_neg, pos_index, class_index, neg_index, graph_id_to_list_id, mapper, labels, model, constraints):\\n\\t# Declaring globals for recursive pattern mining\\n\\tglobal __subgraph_count\\n\\tglobal __positive_index\\n\\tglobal __n_pos\\n\\tglobal __n_graphs\\n\\tglobal __dataset\\n\\tglobal __pattern_set\\n\\tglobal __cl_constraints\\n\\tglobal __ml_constraints\\n\\tglobal __negative_index\\n\\tglobal __graph_id_to_list_id\\n\\tglobal __min_threshold\\n\\tglobal __min_index\\n\\n\\t__graph_id_to_list_id = graph_id_to_list_id\\n\\t__ml_constraints = [c for c in constraints[0] if c[0] < n_graphs and c[1] < n_graphs]\\n\\t__cl_constraints = [c for c in constraints[1] if c[0] < n_graphs and c[1] < n_graphs]\\n\\t__positive_index = pos_index\\n\\t__negative_index = neg_index\\n\\t__n_pos = n_pos\\n\\t__n_graphs = n_graphs\\n\\t__H = H\\n\\t__L = L\\n\\t__L_hat = L_hat\\n\\t__dataset = []\\n\\t__pattern_set = []\\n\\t__subgraph_count = 0\\n\\t__min_threshold = sys.maxint\\n\\t__min_index = 0\\n\\tdfs_codes = []\\n\\tprojection_map = {}\\n\\tfeature_selection_model = None\\n\\n\\tif model == \\\"top-k\\\":\\n\\t\\tfeature_selection_model = TopKModel()\\n\\telif model == \\\"greedy\\\":\\n\\t\\tfeature_selection_model = GreedyModel(__n_graphs, __positive_index)\\n\\telif model == \\\"gMGFL\\\":\\n\\t\\tfeature_selection_model = GMGFLModel(__L, __L_hat)\\n\\telif model == \\\"gMLC\\\":\\n\\t\\tfeature_selection_model = GMLCModel(__L, __H)\\n\\telse:\\n\\t\\tlogging.log(logging.ERROR, \\\"Model %s not recognized\\\" %(model))\\n\\t\\texit(0)\\n\\n\\t# TODO: evaluate\\n\\t\\\"\\\"\\\"\\n\\tOnly constraints for current binary split\\n\\tfor con in __ml_constraints:\\n\\t\\tif not labels[con[0]][class_index] == 1 and not labels[con[1]][class_index] == 1:\\n\\t\\t\\t__ml_constraints.remove((con[0], con[1]))\\n\\n\\tfor con in __cl_constraints:\\n\\t\\tif not labels[con[0]][class_index] == 1 and not labels[con[1]][class_index] == 1:\\n\\t\\t\\t__cl_constraints.remove((con[0], con[1]))\\n\\t\\\"\\\"\\\"\\n\\n\\t# clean constraints from not applicable ones\\n\\tfor i, con in enumerate(__ml_constraints):\\n\\t\\tif con[0] >= n_graphs or con[1] >= n_graphs:\\n\\t\\t\\t__ml_constraints.remove(con)\\n\\t\\t\\tcontinue\\n\\t\\ttry:\\n\\t\\t\\tlist_id1 = __graph_id_to_list_id[con[0]]\\n\\t\\t\\tlist_id2 = __graph_id_to_list_id[con[1]]\\n\\t\\t\\t__ml_constraints[i] = (list_id1, list_id2)\\n\\t\\texcept KeyError:\\n\\t\\t\\t__ml_constraints.remove(con)\\n\\n\\tfor i, con in enumerate(__cl_constraints):\\n\\t\\tif con[0] >= n_graphs or con[1] >= n_graphs:\\n\\t\\t\\t__cl_constraints.remove(con)\\n\\t\\t\\tcontinue\\n\\t\\ttry:\\n\\t\\t\\tlist_id1 = __graph_id_to_list_id[con[0]]\\n\\t\\t\\tlist_id2 = __graph_id_to_list_id[con[1]]\\n\\t\\t\\t__cl_constraints[i] = (list_id1, list_id2)\\n\\t\\texcept KeyError:\\n\\t\\t\\t__cl_constraints.remove(con)\\n\\n\\t# TODO: Is this needed?\\n\\tfor l in frequent_nodes:\\n\\t\\t__subgraph_count += 1\\t\\t\\n\\n\\tfor g in database:\\n\\t\\tfor n in g.nodes:\\n\\t\\t\\tedges = get_forward_init(n, g)\\n\\t\\t\\tif len(edges) > 0:\\n\\t\\t\\t\\t for e in edges:\\n\\t\\t\\t\\t\\tnf = g.nodes[e.fromn]\\n\\t\\t\\t\\t\\tnt = g.nodes[e.to]\\n\\t\\t\\t\\t\\tdfsc = dfs_code(0,1,nf.label,e.label,nt.label)\\n\\t\\t\\t\\t\\tpdfs = pre_dfs(g.id,e,None)\\n\\t\\t\\t\\t\\t# because this is a root --> append the predecesspr dfs code (graph id, edge, None)\\n\\t\\t\\t\\t\\tif dfsc in projection_map:\\n\\t\\t\\t\\t\\t\\tprojection_map[dfsc].append(pdfs)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tprojection_map[dfsc] = [pdfs,]\\n\\n\\t# Start Subgraph Mining\\n\\tthreshold = 0 \\t# initial threshold for first length 1 subgraph\\n\\tfor pm in reversed(sorted(projection_map, key=dfs_code_compare)):\\t# sorted by highest fromnode label (order is important)\\n\\t\\tif len(projection_map[pm]) < minsup: # number of graphs, this initial pattern occurs (root patterns)\\n\\t\\t\\tcontinue\\n\\t\\tdfs_codes.append(dfs_code(0,1,pm[2],pm[3],pm[4]))\\t# initial pattern for this projection is always local 0, 1)\\n\\t\\tdfs_codes = mine_subgraph(database, projection_map[pm],\\n\\t\\t\\t\\t\\t\\t\\tdfs_codes, minsup, length, mapper, feature_selection_model)\\n\\t\\tdfs_codes.pop()\\t# dfs_codes is a list of all projections for this initial pattern\\n\\treturn __dataset, __pattern_set\",\n \"def load_sequences_pynast(file_pynast_alignment, file_otumap,\\n frg_start, frg_stop, frg_expected_length,\\n verbose=True, out=sys.stdout, onlyrepr=False,\\n nomerge=False):\\n # load the full pynast GreenGenes alignment with\\n # sequences=1261500 and position=7682\\n # deprecation warning from skbio\\n ali = TabularMSA.read(file_pynast_alignment,\\n format='fasta', constructor=DNA)\\n\\n # set index of alignment to sequence IDs\\n ali.index = [seq.metadata['id'] for seq in ali]\\n\\n if verbose:\\n out.write(\\\"% 8i rows and %i cols in alignment '%s'\\\\n\\\" % (\\n ali.shape[0],\\n ali.shape[1],\\n file_pynast_alignment.split('/')[-1]))\\n\\n # load OTU map\\n (otumap, seqinfo) = read_otumap(file_otumap)\\n # all representative seq IDs\\n seqids_to_use = list(otumap.index)\\n if onlyrepr is False:\\n # all non-representative seq IDs\\n seqids_to_use += [seqid for otu in otumap.values for seqid in otu]\\n if verbose:\\n out.write(\\\"% 8i sequences in OTU map '%s'\\\\n\\\" % (\\n len(seqids_to_use),\\n file_otumap.split('/')[-1]))\\n\\n # subset the alignment to those sequences that are selected from OTU map\\n ali_otumap = ali.loc[set(seqids_to_use) & set(ali.index)]\\n if verbose:\\n out.write((\\\"% 8i sequences selected from OTU map and alignment. \\\"\\n \\\"Surprise: %i sequences of OTU map are NOT in \\\"\\n \\\"alignment!\\\\n\\\") % (\\n ali_otumap.shape[0],\\n len(seqids_to_use) - ali_otumap.shape[0]))\\n # To my surprise, not all OTU-IDs of the SEPP reference tree\\n # (same with the 99 tree of GreenGenes) are in the pynast alignment.\\n # Daniel says: \\\"PyNAST fails on some sequences. The tree is constructed\\n # from the ssu-align alignment (based on infernal), but that alignment\\n # method is lossy so it is not suitable for extracting variable\\n # regions\\\" Therefore, I exclude those 1031 OTU-IDs from further\\n # investigation\\n\\n # trim alignment down to fragment columns\\n ali_fragments = ali_otumap.iloc(axis='position')[frg_start:frg_stop]\\n if verbose:\\n out.write((\\\"%i -> %i cols: trimming alignment to fragment \\\"\\n \\\"coordinates\\\\n\\\") % (\\n ali_otumap.shape[1],\\n ali_fragments.shape[1]))\\n\\n # ungap alignment rows\\n fragments = []\\n num_frags_toolong = 0\\n for fragment_gapped in ali_fragments:\\n fragment = fragment_gapped.degap()\\n if len(fragment) >= frg_expected_length:\\n if len(fragment) > frg_expected_length:\\n num_frags_toolong += 1\\n fragments.append({\\n 'sequence': str(fragment)[:frg_expected_length],\\n 'seqID': fragment_gapped.metadata['id'],\\n 'otuID': seqinfo.loc[fragment_gapped.metadata['id']]})\\n if verbose:\\n out.write((\\\"% 8i fragments with ungapped length >= %int. \\\"\\n \\\"Surprise: %i fragments are too short and %i fragments \\\"\\n \\\"where too long (and have been trimmed)!\\\\n\\\") % (\\n len(fragments),\\n frg_expected_length,\\n ali_fragments.shape[0] - len(fragments), num_frags_toolong))\\n # Another surprise is that the trimmed, degapped sequences from pynast\\n # alignment do NOT all have length 150nt. Following is a length\\n # distribution plot. I checked with Daniel and we decided to omit\\n # frgaments smaller than 150nt and timm all other to 150nt.\\n\\n # convert fragments into Pandas.DataFrame\\n fragments = pd.DataFrame(fragments)\\n if verbose:\\n out.write('% 8i fragments remaining.\\\\n' % fragments.shape[0])\\n if nomerge:\\n return fragments\\n # group fragments by sequence and list true OTUids\\n unique_fragments = fragments.groupby('sequence').agg(lambda x:\\n list(x.values))\\n if verbose:\\n out.write('% 8i unique fragments after collapsing by sequence.\\\\n' %\\n unique_fragments.shape[0])\\n\\n frgs = []\\n for i, (sequence, row) in enumerate(unique_fragments.iterrows()):\\n frgs.append({'sequence': sequence,\\n 'seqIDs': row['seqID'],\\n 'otuIDs': sorted(list(set(row['otuID']))),\\n 'num_non-representative-seqs':\\n len(set(row['seqID']) - set(row['otuID'])),\\n 'only_repr._sequences':\\n len(set(row['seqID']) - set(row['otuID'])) == 0,\\n 'num_pointmutations': 0})\\n\\n return frgs\",\n \"def convert_pc2ply(anno_path, save_path):\\n data_list = []\\n\\n for f in glob.glob(join(anno_path, '*.txt')):\\n class_name = os.path.basename(f).split('_')[0]\\n if class_name not in gt_class: # note: in some room there is 'staris' class..\\n class_name = 'clutter'\\n pc = pd.read_csv(f, header=None, delim_whitespace=True).values\\n labels = np.ones((pc.shape[0], 1)) * gt_class2label[class_name]\\n data_list.append(np.concatenate([pc, labels], 1)) # Nx7\\n\\n pc_label = np.concatenate(data_list, 0)\\n xyz_min = np.amin(pc_label, axis=0)[0:3]\\n pc_label[:, 0:3] -= xyz_min\\n\\n xyz = pc_label[:, :3].astype(np.float32)\\n colors = pc_label[:, 3:6].astype(np.uint8)\\n labels = pc_label[:, 6].astype(np.uint8)\\n write_ply(save_path, (xyz, colors, labels), ['x', 'y', 'z', 'red', 'green', 'blue', 'class'])\\n\\n # save sub_cloud and KDTree file\\n sub_xyz, sub_colors, sub_labels = DP.grid_sub_sampling(xyz, colors, labels, sub_grid_size)\\n sub_colors = sub_colors / 255.0\\n sub_ply_file = join(sub_pc_folder, save_path.split('/')[-1][:-4] + '.ply')\\n write_ply(sub_ply_file, [sub_xyz, sub_colors, sub_labels], ['x', 'y', 'z', 'red', 'green', 'blue', 'class'])\\n\\n search_tree = KDTree(sub_xyz)\\n kd_tree_file = join(sub_pc_folder, str(save_path.split('/')[-1][:-4]) + '_KDTree.pkl')\\n with open(kd_tree_file, 'wb') as f:\\n pickle.dump(search_tree, f)\\n\\n proj_idx = np.squeeze(search_tree.query(xyz, return_distance=False))\\n proj_idx = proj_idx.astype(np.int32)\\n proj_save = join(sub_pc_folder, str(save_path.split('/')[-1][:-4]) + '_proj.pkl')\\n with open(proj_save, 'wb') as f:\\n pickle.dump([proj_idx, labels], f)\",\n \"def mergePed(bnlist=[],faff=[],ofaff=[],newbasename='newped',fo=0):\\r\\n lcdmap = getLCD(bnlist) # list of chr,offset,rs for all snp common to all files\\r\\n print 'got %d lcd snps-%s' % (len(lcdmap),lcdmap[:5])\\r\\n cfped = []\\r\\n coped = []\\r\\n cfgeno = []\\r\\n cogeno = []\\r\\n allrsa = {}\\r\\n ignorers = {}\\r\\n for i,basename in enumerate(bnlist):\\r\\n fped,oped,fgeno,ogeno,trsadict = subsetPed(basename,lcdmap,faff[i],ofaff[i])\\r\\n print '%s gave %d fgeno' % (basename,len(fgeno))\\r\\n for rs in trsadict.keys():\\r\\n tk = trsadict[rs].keys()\\r\\n if len(tk) > 2:\\r\\n print 'for %s, rs %s has alleles %s' % (basename, rs, trsadict[rs])\\r\\n if not allrsa.get(rs,None):\\r\\n allrsa[rs] = {}\\r\\n for a in tk:\\r\\n if not allrsa[rs].get(a,None):\\r\\n allrsa[rs][a] = trsadict[rs][a]\\r\\n else:\\r\\n allrsa[rs][a] += trsadict[rs][a]\\r\\n tk = allrsa[rs].keys()\\r\\n if len(tk) > 2 and not ignorers.get(rs,None): # new\\r\\n #print 'After merge basename %s, rs %s has alleles %s' % (basename, rs,allrsa[rs])\\r\\n ignorers[rs] = rs\\r\\n cfped += fped\\r\\n coped += oped\\r\\n cfgeno += fgeno\\r\\n cogeno += ogeno\\r\\n print 'after merge all have %d fgeno and %d ogeno' % (len(cfgeno),len(cogeno))\\r\\n # now have offspring and founder rows in lcdmap order\\r\\n # write map file\\r\\n print '### found %d markers > 2 alleles' % (len(ignorers.keys()))\\r\\n keepmarkers = [x for x in range(len(lcdmap)) if not ignorers.get(lcdmap[x][2],None)]\\r\\n newmap = ['\\\\t'.join((lcdmap[x][0],lcdmap[x][2],'0','%d' % lcdmap[x][1])) for x in keepmarkers] # chrom,offset,rs\\r\\n f = file('%s.map' % newbasename,'w')\\r\\n f.write('%s\\\\n' % '\\\\n'.join(newmap))\\r\\n f.close()\\r\\n for i,geno in enumerate(cfgeno): # convert each array into a list and keep the good markers\\r\\n gs = ''.join(['%s%s' % (geno[2*x],geno[2*x + 1]) for x in keepmarkers])\\r\\n g = array.array('c',gs) # good ones\\r\\n cfgeno[i] = g # replace\\r\\n print 'cfgeno converted'\\r\\n if not fo: # not founders only - note arrays are not lists!\\r\\n cfped += copy.copy(coped) #\\r\\n del coped\\r\\n for i,geno in enumerate(cogeno): # convert each array into a list and keep the good markers\\r\\n gs = ''.join(['%s%s' % (geno[2*x],geno[2*x + 1]) for x in keepmarkers])\\r\\n g = array.array('c',gs) # good ones\\r\\n cfgeno.append(g) # extend founders\\r\\n del cogeno\\r\\n print 'after if not fo now have %d cfgeno' % (len(cfgeno))\\r\\n f = file('%s.ped' % newbasename,'w')\\r\\n for n,ped in enumerate(cfped):\\r\\n l = ' '.join(ped + list(cfgeno[n]))\\r\\n if n % 100 == 0 and n > 0:\\r\\n print 'writing line %d' % n\\r\\n f.write(l)\\r\\n f.write('\\\\n')\\r\\n f.close()\\r\\n print 'wrote %d map rows and %d ped rows to %s' % (len(newmap),len(cfped),newbasename)\",\n \"def ParseGraph(filename):\\n vertices = []\\n edges = set([])\\n\\n for l in open(filename):\\n fields = [int(f) for f in l.split()]\\n vertex = fields.pop(0)\\n incident = [tuple(sorted([vertex, f])) for f in fields]\\n vertices.append(vertex)\\n edges.update(incident)\\n\\n return vertices, list(edges)\",\n \"def _load_pascal_annotation(self, index):\\n filename = os.path.join(self.cfg.file_path, 'Annotations', index + '.xml')\\n if not os.path.exists(filename):\\n print('Can not find annotations')\\n return {'boxes' : np.zeros((1, 4), dtype=np.uint16),\\n 'gt_classes': np.zeros(1, dtype=np.int32),\\n 'gt_overlaps': scipy.sparse.csr_matrix(\\n np.zeros((1, self.num_classes), dtype=np.float32)),\\n 'flipped' : False,\\n 'seg_areas' : None}\\n tree = ET.parse(filename)\\n objs = tree.findall('object')\\n if not self.cfg.data_set_cfg['use_diff']:\\n # Exclude the samples labeled as difficult\\n non_diff_objs = [\\n obj for obj in objs if int(obj.find('difficult').text) == 0]\\n # if len(non_diff_objs) != len(objs):\\n # print 'Removed {} difficult objects'.format(\\n # len(objs) - len(non_diff_objs))\\n objs = non_diff_objs\\n num_objs = len(objs)\\n\\n boxes = np.zeros((num_objs, 4), dtype=np.uint16)\\n gt_classes = np.zeros((num_objs), dtype=np.int32)\\n overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32)\\n # \\\"Seg\\\" area for pascal is just the box area\\n seg_areas = np.zeros((num_objs), dtype=np.float32)\\n\\n # Load object bounding boxes into a data frame.\\n for ix, obj in enumerate(objs):\\n bbox = obj.find('bndbox')\\n # Make pixel indexes 0-based\\n x1 = float(bbox.find('xmin').text) - 1\\n y1 = float(bbox.find('ymin').text) - 1\\n x2 = float(bbox.find('xmax').text) - 1\\n y2 = float(bbox.find('ymax').text) - 1\\n cls = self._class_to_ind[obj.find('name').text.lower().strip()]\\n boxes[ix, :] = [x1, y1, x2, y2]\\n gt_classes[ix] = cls\\n overlaps[ix, cls] = 1.0\\n seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1)\\n\\n overlaps = scipy.sparse.csr_matrix(overlaps)\\n\\n return {'boxes' : boxes,\\n 'gt_classes': gt_classes,\\n 'gt_overlaps' : overlaps,\\n 'flipped' : False,\\n 'seg_areas' : seg_areas}\",\n \"def agp_prune(self, from_file: str, to_file: str, used: set = None):\\n # reomve used component\\n # and GAPS as they are not used by 'ensembl-analysis/scripts/assembly_loading/load_agp.pl'\\n os.makedirs(dirname(to_file), exist_ok=True)\\n open_ = self.is_gz(from_file) and gzip.open or open\\n if used is None:\\n cmd = r'''{_cat} {_file} > {_out}'''.format(\\n _cat = self.is_gz(from_file) and \\\"zcat\\\" or \\\"cat\\\",\\n _file = from_file,\\n _out = to_file\\n )\\n print(\\\"running %s\\\" % (cmd), file = sys.stderr)\\n sp.run(cmd, shell=True, check=True)\\n return 1\\n writes = 0\\n with open_(from_file, \\\"r\\\") as src:\\n with open(to_file, \\\"w\\\") as dst:\\n for line in src:\\n fields = line.strip().split(\\\"\\\\t\\\")\\n ( asm_id, asm_start, asm_end, asm_part,\\n type_,\\n cmp_id, cmp_start, cmp_end, cmp_strand\\n ) = fields\\n if type_ in \\\"NU\\\" or cmp_id in used:\\n continue\\n used.add(cmp_id)\\n print(line.strip(), file = dst)\\n writes += 1\\n return writes\",\n \"def extract_edges(file_name, file_name_out, nodes):\\n with open(file_name, 'r') as file_in, open(file_name_out, 'w') as file_out:\\n print('source,target,label', file=file_out)\\n\\n # init the previous entry for comparison\\n last_player, last_team, last_league, last_season = (None, None,\\n None, None)\\n this_team = []\\n for line in file_in:\\n player, team, league, season = parse_line(line)\\n player = format_name(player)\\n if last_player is None or (team == last_team and\\n league == last_league and season == last_season):\\n this_team.append(player)\\n else: # new player\\n # process existing team\\n process_team(this_team, nodes, file_out)\\n\\n # reset and add first player of new team\\n this_team = []\\n this_team.append(player)\\n\\n last_player, last_team, last_league, last_season = (player,\\n team, league, season)\\n\\n # there is one last team to process\\n process_team(this_team, nodes, file_out)\",\n \"def load_graph(self, graph: nx.Graph) -> None:\\n\\n self.pos = dict()\\n self.polygons = dict()\\n districts = len(self.data[\\\"features\\\"])\\n\\n for i in range(districts):\\n\\n # Get shape information from file\\n nodes = self.data[\\\"features\\\"][i][\\\"geometry\\\"][\\\"coordinates\\\"][0]\\n area_id = self.data[\\\"features\\\"][i][\\\"properties\\\"][\\\"MOVEMENT_ID\\\"].zfill(4) \\n\\n # Convert list of lists to list of tuples (lng, lat)\\n nodes = list(map(tuple, nodes)) \\n\\n # Prune nodes and remove last node (duplicate of first node)\\n nodes = list(map(lambda x: (x[:2]), nodes)) \\n nodes = nodes[:-1]\\n\\n # Add polygon with node-coordinates to dict\\n self.polygons[area_id] = nodes\\n\\n for j,k in enumerate(nodes):\\n self.pos[area_id+\\\"-\\\"+str(j)]=(k[0], k[1])\\n\\n for j in range(len(nodes)-1):\\n graph.add_edge(\\n u_of_edge=area_id+\\\"-\\\"+str(j), \\n v_of_edge=area_id+\\\"-\\\"+str(j+1))\\n\\n graph.add_edge(\\n u_of_edge=area_id+\\\"-\\\"+str(len(nodes)-1), \\n v_of_edge=area_id+\\\"-\\\"+str(0))\\n \\n self.graph = graph\",\n \"def subsetPed(basename=\\\"\\\",lcdmap = [],faff='1', ofaff='2'):\\r\\n mf = file('%s.map' % basename,'r').readlines()\\r\\n lmap = [x.strip().split() for x in mf]\\r\\n rscols = {} # lookup marker table\\r\\n colrs = [] # lookup rs from column\\r\\n for i,m in enumerate(lmap): # get columns to keep in the order we want them\\r\\n rscols[m[1]] = i # keep track of where each rs is in this map\\r\\n colrs.append(m[1]) # and keep the list of rs for tracking alleles\\r\\n wewant = [rscols[x[2]] for x in lcdmap] # columns we want to keep\\r\\n print '#Subsetped faff=%s ofaff=%s keeping %d (%s) of potential lcd %d for %s' % \\\\\\r\\n (faff,ofaff,len(wewant),wewant[:20],len(lcdmap),basename)\\r\\n pf = file('%s.ped' % basename,'r')\\r\\n ogeno = [] # offspring new lines\\r\\n fgeno = [] # founders\\r\\n oped = [] # for pedigrees\\r\\n fped = []\\r\\n rsadict = {} # keep a count of alleles - seems to be a problem\\r\\n for i,l in enumerate(pf):\\r\\n if (i+1) % 500 == 0:\\r\\n print '%s at line %d' % (basename,i+1)\\r\\n ll = l.strip().split()\\r\\n ped = ll[:6]\\r\\n founder = (ll[2] == '0' and ll[3] == '0') \\r\\n aff = faff\\r\\n if not founder:\\r\\n aff = ofaff\\r\\n ped[5] = aff # adjust as needed\\r\\n if founder:\\r\\n fped.append(ped)\\r\\n else:\\r\\n oped.append(ped)\\r\\n gt = ll[6:]\\r\\n geno = []\\r\\n for snp in wewant: # columns in order\\r\\n thisrs = colrs[snp]\\r\\n base = snp*2\\r\\n g1 = gt[base]\\r\\n g2 = gt[base+1]\\r\\n geno.append(g1)\\r\\n geno.append(g2)\\r\\n if not rsadict.get(thisrs,None):\\r\\n rsadict[thisrs] = {}\\r\\n if g1 <> '0':\\r\\n if not rsadict[thisrs].get(g1,None):\\r\\n rsadict[thisrs][g1] = 1\\r\\n else:\\r\\n rsadict[thisrs][g1] += 1 \\r\\n if g2 <> '0':\\r\\n if not rsadict[thisrs].get(g2,None):\\r\\n rsadict[thisrs][g2] = 1\\r\\n else:\\r\\n rsadict[thisrs][g2] += 1\\r\\n keepgt = array.array('c',geno)\\r\\n if founder:\\r\\n fgeno.append(keepgt)\\r\\n else:\\r\\n ogeno.append(keepgt)\\r\\n print '#Subsetped %s %d fgeno %d ogeno' % (basename,len(fgeno),len(ogeno))\\r\\n return fped,oped,fgeno,ogeno,rsadict\",\n \"def load_all_graphs():\\n all_graphs = []\\n for i in range(7):\\n with open(f'Full_Network_Book_{i+1}.gml', 'rb') as graph_file:\\n all_graphs.append(nx.read_gml(graph_file))\\n\\n return all_graphs\",\n \"def overlapPlot():\\n fig, ax = plt.subplots()\\n x = pickle.load(open(\\\"pickles/input_threshs_for_overlap.pkl\\\", \\\"rb\\\"))\\n y = pickle.load(open(\\\"pickles/overlaps.pkl\\\", \\\"rb\\\"))\\n x.reverse()\\n y.reverse()\\n ax.set_xlabel(\\\"Threshold of YFP-tau\\\", fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.set_ylabel(\\\"Overlap of YFP-tau and AT8-pTau\\\", fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.plot(x,y, '+-')\\n ax.set_ylim((0,1))\\n y_vals = ax.get_yticks()\\n ax.set_yticklabels(['{:,.0%}'.format(y_val) for y_val in y_vals], fontname=\\\"Times New Roman\\\")\\n for tick in ax.get_xticklabels():\\n tick.set_fontname(\\\"Times New Roman\\\")\\n plt.xticks(np.arange(min(x), max(x) + .25, .25))\\n plt.savefig(\\\"matplotlib_figures/overlapPlot.png\\\", dpi=300)\",\n \"def resolve(self):\\n\\n if not debug:\\n print('##gff-version 3')\\n print('##date %s' % date.today())\\n\\n data = self.read_input()\\n # Find best overlap for each distinct chromosome, strand and type\\n for rid in data.keys():\\n # Holder for sequences\\n sequences = list()\\n # Top score so far\\n top_weight = 0\\n # Most far end so far\\n most_far = 0\\n count = 0\\n\\n # If input file was not sorted, we will sort it.\\n # This will allow as to divide file into blocks.\\n if not self.is_sorted:\\n data[rid].sort(key=attrgetter('start'))\\n\\n for region in data[rid]:\\n if len(sequences) > 0 and region.start > most_far:\\n top_weight_tmp, tmp_count = self.get_partial(sequences)\\n top_weight += top_weight_tmp\\n count += tmp_count\\n sequences.clear()\\n\\n most_far = max(region.finish, most_far)\\n sequences.append(region)\\n\\n top_weight_tmp, tmp_count = self.get_partial(sequences)\\n top_weight += top_weight_tmp\\n count += tmp_count\\n\\n # Print score statistics\\n if debug:\\n print(\\\"# Type '{0}' scored: {1:10}\\\".format(rid, top_weight))\\n print(count)\",\n \"def processFiles(fileName):\\n print fileName\\n count_t1 = 0\\n inFile=open(fileName,'r')\\n all_angleList = Counter()\\n rep_angleList = Counter()\\n all_lengthsList = Counter()\\n maxDist_List = Counter()\\n global xCord, yCord, zCord\\n aminoAcidName={}\\n xCord={}\\n yCord={}\\n zCord={}\\n seq_number={}\\n counter=0\\n for i in inFile:\\n if (i[0:6].rstrip()==\\\"NUMMDL\\\"):\\n numOfModels=i[10:14].rstrip()\\n if ((i[0:6].rstrip()==\\\"ENDMDL\\\")or (i[0:6].rstrip()=='TER')):\\n break\\n if (i[0:6].rstrip()==\\\"MODEL\\\" and int(i[10:14].rstrip())>1):\\n break\\n \\n if(i[0:4].rstrip())==\\\"ATOM\\\" and(i[13:15].rstrip())==\\\"CA\\\" and(i[16]=='A'or i[16]==' ')and i[17:20]!= \\\"UNK\\\" :\\n aminoAcidName[counter]=int(aminoAcidLabel[i[17:20]])\\n xCord[counter]=(float(i[30:38]))\\n yCord[counter]=(float(i[38:46]))\\n zCord[counter]=(float(i[46:54]))\\n seq_number[counter]=str(i[22:27])\\n counter+=1\\n\\n protLen=len(yCord)\\n initialLabel=[]\\n sortedLabel=[]\\n sortedIndex=[]\\n outDist={}\\n for m in range(0,3):\\n initialLabel.append(0)\\n sortedLabel.append(0)\\n sortedIndex.append(0)\\n\\n for i in range(0,protLen-2):\\n for j in range(i+1,protLen-1):\\n for k in range(j+1, protLen):\\n global i1,j1,k1\\n i1=i\\n j1=j\\n k1=k\\n keepLabelIndex={}\\n keepLabelIndex[aminoAcidName[i]]=i\\n keepLabelIndex[aminoAcidName[j]]=j\\n keepLabelIndex[aminoAcidName[k]]=k\\n initialLabel[0]=aminoAcidName[i]\\n initialLabel[1]=aminoAcidName[j]\\n initialLabel[2]=aminoAcidName[k]\\n sortedLabel=list(initialLabel)\\n sortedLabel.sort(reverse=True)\\n\\n #Perform Rule- based labelling\\n\\n if (sortedLabel[0]==sortedLabel[1])and(sortedLabel[1]==sortedLabel[2]):\\n dist1_2Temp=calcDist(i,j)\\n dist1_3Temp=calcDist(i,k)\\n dist2_3Temp=calcDist(j,k)\\n if dist1_2Temp>=(max(dist1_2Temp,dist1_3Temp,dist2_3Temp)):\\n indexOf0=i\\n indexOf1=j\\n indexOf2=k\\n elif dist1_3Temp>=(max(dist1_2Temp,dist1_3Temp,dist2_3Temp)):\\n indexOf0=i\\n indexOf1=k\\n indexOf2=j\\n else:\\n indexOf0=j\\n indexOf1=k\\n indexOf2=i\\n elif(aminoAcidName[i]!=aminoAcidName[j])and(aminoAcidName[i]!=aminoAcidName[k]) and(aminoAcidName[j]!=aminoAcidName[k]): \\n for index_ in range(0,3):\\n sortedIndex[index_]=keepLabelIndex[sortedLabel[index_]]\\n indexOf0=sortedIndex[0]\\n indexOf1=sortedIndex[1]\\n indexOf2=sortedIndex[2]\\n elif(sortedLabel[0]==sortedLabel[1])and(sortedLabel[1]!=sortedLabel[2]):\\n indexOf2=keepLabelIndex[sortedLabel[2]]\\n indices=indexFind(indexOf2,i,j,k)\\n a=indexOf2\\n b=indices[0]\\n c=indices[1]\\n dist1_3Temp=calcDist(b,a)\\n dist2_3Temp=calcDist(c,a)\\n if dist1_3Temp>=dist2_3Temp:\\n indexOf0=indices[0]\\n indexOf1=indices[1] \\n else:\\n indexOf0=indices[1]\\n indexOf1=indices[0]\\n elif(sortedLabel[0]!=sortedLabel[1])and(sortedLabel[1]==sortedLabel[2]):\\n indexOf0=keepLabelIndex[sortedLabel[0]]\\n indices=indexFind(indexOf0,i,j,k)\\n if calcDist(indexOf0,indices[0])>= calcDist(indexOf0,indices[1]):\\n indexOf1=indices[0]\\n indexOf2=indices[1] \\n else:\\n indexOf2=indices[0]\\n indexOf1=indices[1]\\n dist01=calcDist(indexOf0,indexOf1)\\n s2=dist01/2\\n dist02=calcDist(indexOf0,indexOf2)\\n s1=dist02\\n dist12=dist01\\n dist03=calcDist(indexOf1,indexOf2)\\n\\n # All lengths calculation \\n all_lengthsList[round(dist01,round_off_to)] += 1\\n all_lengthsList[round(dist02,round_off_to)] += 1\\n all_lengthsList[round(dist03,round_off_to)] += 1\\n\\n maxDist_List[round(max(dist01,dist02,dist03),round_off_to)] +=1\\n\\n s3=(((xCord[indexOf0]+xCord[indexOf1])/2-xCord[indexOf2])**2\\n +((yCord[indexOf0]+yCord[indexOf1])/2-yCord[indexOf2])**2\\n +((zCord[indexOf0]+zCord[indexOf1])/2-zCord[indexOf2])**2)**0.5\\n \\n \\n Theta1=180*(math.acos((s1**2-s2**2-s3**2)/(2*s2*s3)))/3.14\\n if Theta1<=90:\\n all_angleList[round(Theta1,round_off_to)] +=1\\n rep_angleList[round(Theta1,round_off_to)] +=1\\n else:\\n all_angleList[round(abs(180-Theta1),round_off_to)] +=1\\n rep_angleList[round(abs(180-Theta1),round_off_to)] +=1\\n \\n #if Theta1>90: \\n # Theta1=abs(180-Theta1)\\n #print 'Second Theta1, ',Theta1\\n #Theta 2\\n dist02=calcDist(indexOf1,indexOf0)\\n s1=dist02\\n dist01=calcDist(indexOf1,indexOf2)\\n s2=dist01/2\\n s3=(((xCord[indexOf1]+xCord[indexOf2])/2-xCord[indexOf0])**2\\n +((yCord[indexOf1]+yCord[indexOf2])/2-yCord[indexOf0])**2\\n +((zCord[indexOf1]+zCord[indexOf2])/2-zCord[indexOf0])**2)**0.5\\n \\n Theta2=180*(math.acos((s1**2-s2**2-s3**2)/(2*s2*s3)))/3.14 \\n #if Theta2 > 90:\\n # Theta2 = abs(180-Theta2)\\n if Theta2<=90:\\n all_angleList[round(Theta2,round_off_to)] +=1\\n else:\\n all_angleList[round(abs(180-Theta2),round_off_to)] +=1\\n\\n #Theta 3\\n dist02=calcDist(indexOf2,indexOf1)\\n s1=dist02\\n dist01=calcDist(indexOf2,indexOf0)\\n s2=dist01/2\\n s3=(((xCord[indexOf2]+xCord[indexOf0])/2-xCord[indexOf1])**2+\\n ((yCord[indexOf2]+yCord[indexOf0])/2-yCord[indexOf1])**2+\\n ((zCord[indexOf2]+zCord[indexOf0])/2-zCord[indexOf1])**2)**0.5\\n \\n Theta3=180*(math.acos((s1**2-s2**2-s3**2)/(2*s2*s3)))/3.14 \\n #if Theta3 > 90:\\n # Theta3 = abs(180-Theta3)\\n if Theta3<=90:\\n all_angleList[round(Theta3,round_off_to)] +=1\\n else:\\n all_angleList[round(abs(180-Theta3),round_off_to)] +=1\\n # Either writting output to a file or using dictionary or \\n # counter will save you from memory exceptions in this case.\\n #all_angleList[round(Theta1,round_off_to)] +=1\\n #all_angleList[round(Theta2,round_off_to)] +=1\\n #all_angleList[round(Theta3,round_off_to)] +=1\\n\\n #rep_angleList[round(Theta1,round_off_to)] +=1\\n\\n count_t1 = count_t1+1\\n\\n print 'count_t1:',count_t1\\n\\n return [all_angleList,rep_angleList,all_lengthsList,maxDist_List]\",\n \"def comb_fc(filepatt):\\r\\n\\r\\n\\r\\n files = glob.glob(os.path.join(savefolder, filepatt))\\r\\n print(filepatt)\\r\\n \\r\\n if files == []:\\r\\n imgs = []\\r\\n print('No files found for ' + filepatt)\\r\\n return\\r\\n\\r\\n\\r\\n imgs = np.empty((600, 600, 3))\\r\\n for fi, file in enumerate(files):\\r\\n img = cv2.imread(file)\\r\\n \\r\\n if fi == 0:\\r\\n imgs = img\\r\\n else:\\r\\n imgs = np.concatenate((imgs, img), axis = 2)\\r\\n\\r\\n idx = filepatt.find('freq')\\r\\n comb_fcGraph = os.path.join(savefolder, 'comb_' + filepatt[idx: -len('.mat')])\\r\\n cv2.imwrite(comb_fcGraph, imgs)\\r\\n print(comb_fcGraph)\\r\\n\\r\\n # find lowweight\\r\\n pvals_vec = []\\r\\n ciCOH_vec = []\\r\\n pvals = pvals_fc_overtime(ciCOH = ciCOH, ntrials = ntrials, ntemp = ntemp, f = f, t = t)\\r\\n\\r\\n reject, pval_corr = fdr_correction(pvals, alpha=0.05, method='indep')\\r\\n \\r\\n\\r\\n \\r\\n lowweight = min(ciCOH_vec[rejs])\\r\\n\\r\\n return lowweight\",\n \"def pslMap( options ):\\n\\n if options.format == \\\"gtf\\\":\\n use_copy = False\\n else:\\n use_copy = True\\n\\n ninput, noutput, ndiscarded, nskipped, nskipped_small_queries = 0, 0, 0, 0, 0\\n\\n min_length = options.min_aligned\\n\\n for match, qx, tx in iterator_psl_intervals( options ):\\n\\n map_query2target = match.getMapQuery2Target()\\n\\n ninput += 1\\n\\n ## if no filter on qx or tx, use full segment\\n if qx == None:\\n qx = [ (match.mQueryFrom,match.mQueryTo,0) ]\\n elif tx == None:\\n tx = [ (match.mSbjctFrom,match.mSbjctTo,0) ]\\n\\n ## if no overlap: return\\n if not qx or not tx: \\n nskipped += 1\\n continue\\n\\n for query in qx:\\n\\n qstart, qend, qval = query\\n\\n # skip elements that are too small\\n if qend - qstart < min_length: \\n E.debug( \\\"query too small - skipped at %s:%i-%i\\\" % (match.mQueryId, qstart, qend) )\\n nskipped_small_queries += 1\\n continue\\n\\n E.debug( \\\"working on query %s:%i-%i\\\" % (match.mQueryId, qstart, qend) )\\n\\n mqstart, mqend = ( map_query2target.mapRowToCol(qstart, \\n alignlib_lite.py_RIGHT), \\n map_query2target.mapRowToCol(qend, \\n alignlib_lite.py_LEFT) )\\n \\n \\n if match.strand == \\\"-\\\":\\n qstart, qend = match.mQueryLength - qend, match.mQueryLength - qstart\\n\\n for target in tx:\\n\\n tstart, tend, tval = target\\n if tstart >= mqend or tend <= mqstart: continue\\n if tend - tstart < min_length: continue\\n\\n new = alignlib_lite.py_makeAlignmentBlocks()\\n \\n if use_copy:\\n # do copy with range filter\\n if options.loglevel >= 3:\\n\\n mtstart, mtend = map_query2target.mapColToRow(tstart), map_query2target.mapColToRow(tend) \\n E.debug( \\\"query: %i-%i (len=%i)-> %i-%i(len=%i); target: %i-%i (len=%i)-> %i-%i (len=%i)\\\" % \\\\\\n (qstart, qend,\\n qend - qstart,\\n mqstart, mqend,\\n mqend - mqstart,\\n tstart, tend,\\n tend - tstart,\\n mtstart, mtend,\\n mtend - mtstart ) )\\n \\n alignlib_lite.py_copyAlignment( \\n new, \\n map_query2target,\\n qstart, qend,\\n tstart, tend )\\n else:\\n # do copy with alignment filter\\n map_query = qval\\n if map_query:\\n tmp = alignlib_lite.py_makeAlignmentBlocks() \\n alignlib_lite.py_copyAlignment( tmp, map_query2target, map_query, alignlib_lite.py_RR )\\n if options.loglevel >= 5:\\n options.stdlog.write( \\\"######## mapping query ###########\\\\n\\\" )\\n options.stdlog.write( \\\"# %s\\\\n\\\" % str(alignlib_lite.py_AlignmentFormatEmissions( map_query2target ) ))\\n options.stdlog.write( \\\"# %s\\\\n\\\" % str(alignlib_lite.py_AlignmentFormatEmissions( map_query ) ))\\n options.stdlog.write( \\\"# %s\\\\n\\\" % str(alignlib_lite.py_AlignmentFormatEmissions( tmp ) ))\\n else:\\n tmp = map_query2target\\n \\n map_target = tval\\n if map_target:\\n new = alignlib_lite.py_makeAlignmentBlocks()\\n alignlib_lite.py_copyAlignment( new, tmp, map_target, alignlib_lite.py_CR ) \\n if options.loglevel >= 5:\\n options.stdlog.write( \\\"######## mapping target ###########\\\\n\\\" )\\n options.stdlog.write( \\\"# before: %s\\\\n\\\" % str(alignlib_lite.py_AlignmentFormatEmissions( tmp ) ))\\n options.stdlog.write( \\\"# map : %s\\\\n\\\" % str(alignlib_lite.py_AlignmentFormatEmissions( map_target ) ))\\n options.stdlog.write( \\\"# after : %s\\\\n\\\" % str(alignlib_lite.py_AlignmentFormatEmissions( new ) ))\\n else:\\n new = tmp\\n\\n if options.loglevel >= 4:\\n E.debug(\\\"putative match with intervals: %s and %s: %i-%i\\\" % \\\\\\n (str(query), str(target), qstart, qend ))\\n if options.loglevel >= 5:\\n E.debug( \\\"input : %s\\\" % str(alignlib_lite.py_AlignmentFormatEmissions( map_query2target ) ))\\n E.debug( \\\"final : %s\\\" % str(alignlib_lite.py_AlignmentFormatEmissions( new ) ) )\\n\\n if new.getLength() > 0:\\n n = match.copy()\\n n.fromMap( new, use_strand = True )\\n E.info( \\\"match : %s\\\" % (str(n)))\\n\\n if new.getNumAligned() > options.min_aligned:\\n n = match.copy()\\n n.fromMap( new, use_strand = True )\\n options.stdout.write( str(n) + \\\"\\\\n\\\" )\\n noutput += 1\\n else:\\n ndiscarded += 1\\n\\n E.info( \\\"map: ninput=%i, noutput=%i, nskipped=%i, ndiscarded=%i, nsmall_queries=%i\\\" % \\\\\\n (ninput, noutput, nskipped, ndiscarded, nskipped_small_queries) )\",\n \"def build_graphs(df: pd.DataFrame, ir_dir: Path, graph_dir: Path):\\n for _, row in df.iterrows():\\n with open(ir_dir / f\\\"{row['name']}.ll\\\") as f:\\n ir = f.read()\\n graph = pg.from_llvm_ir(ir)\\n graph.features.feature[\\\"devmap_label\\\"].int64_list.value[:] = [row[\\\"label\\\"]]\\n graph.features.feature[\\\"wgsize\\\"].int64_list.value[:] = [row[\\\"wgsize\\\"]]\\n graph.features.feature[\\\"transfer_bytes\\\"].int64_list.value[:] = [\\n row[\\\"transfer_bytes\\\"]\\n ]\\n graph.features.feature[\\\"wgsize_log1p\\\"].float_list.value[:] = [\\n row[\\\"wgsize_log1p\\\"]\\n ]\\n graph.features.feature[\\\"transfer_bytes_log1p\\\"].float_list.value[:] = [\\n row[\\\"transfer_bytes_log1p\\\"]\\n ]\\n pbutil.ToFile(\\n graph, graph_dir / f\\\"{row['name']}.ProgramGraph.pb\\\", exist_ok=False\\n )\",\n \"def test_convert_azfp_01a_different_ranges(azfp_path):\\n azfp_01a_path = azfp_path / '17031001.01A'\\n azfp_xml_path = azfp_path / '17030815.XML'\\n\\n # Convert file\\n echodata = open_raw(\\n raw_file=azfp_01a_path, sonar_model='AZFP', xml_path=azfp_xml_path\\n )\\n assert echodata[\\\"Sonar/Beam_group1\\\"].backscatter_r.sel(channel='55030-125-1').dropna(\\n 'range_sample'\\n ).shape == (360, 438)\\n assert echodata[\\\"Sonar/Beam_group1\\\"].backscatter_r.sel(channel='55030-769-4').dropna(\\n 'range_sample'\\n ).shape == (360, 135)\\n\\n # check convention-required variables in the Platform group\\n check_platform_required_scalar_vars(echodata)\",\n \"def listOfOverlappingTTPairs():\\n listOfHalfModules = listOfTTHalfModules()\\n ttmap = TTModulesMap_instance\\n pairs = []\\n regions = {'A':1, 'B':2, 'C':3}\\n print \\\"Overlapping TT half modules:\\\"\\n for hm1 in listOfHalfModules:\\n for hm2 in listOfHalfModules:\\n # they must be different\\n if hm1 == hm2: continue\\n # they must be both on top or both on bottom\\n if locateTTHalfModule(hm1)[3] != locateTTHalfModule(hm2)[3]: continue\\n # they must be on the same layer\\n if locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0]: continue\\n # avoid duplicates\\n if (hm1, hm2) in pairs: continue\\n if (hm2, hm1) in pairs: continue\\n # they must be contiguous:\\n if (locateTTHalfModule(hm1)[1] == locateTTHalfModule(hm2)[1]):\\n if (abs(locateTTHalfModule(hm1)[2] - locateTTHalfModule(hm2)[2]) == 1):\\n pairs.append( (hm1, hm2) )\\n else:\\n num1 = locateTTHalfModule(hm1)[2]\\n num2 = locateTTHalfModule(hm2)[2]\\n max1 = ttmap.numberOfModules[locateTTHalfModule(hm1)[0]]['Region'+locateTTHalfModule(hm1)[1]] - 1\\n max2 = ttmap.numberOfModules[locateTTHalfModule(hm2)[0]]['Region'+locateTTHalfModule(hm2)[1]] - 1\\n nreg1 = regions[locateTTHalfModule(hm1)[1]]\\n nreg2 = regions[locateTTHalfModule(hm2)[1]]\\n if ( (num1==max1 and num2==0 and nreg2-nreg1==1) or (num2==max2 and num1==0 and nreg1-nreg2==1) ):\\n pairs.append( (hm1, hm2) )\\n print '\\\\t', hm1, hm2\\n ## - same region\\n #if ((abs(locateTTHalfModule(hm1)[2] - locateTTHalfModule(hm2)[2]) != 1)\\n # and (locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0])): continue\\n ## - or neighbouring region\\n #elif not ((locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0])\\n # and ( ( (ttmap.numberOfModules[locateTTHalfModule(hm1)[0]] == locateTTHalfModule(hm1)[2]+1 )\\n # and (locateTTHalfModule(hm2)[2] == 0) )\\n # or ( (ttmap.numberOfModules[locateTTHalfModule(hm2)[0]] == locateTTHalfModule(hm2)[2]+1 )\\n # and (locateTTHalfModule(hm1)[2] == 0) ) ) ): continue\\n ## append to list of pairs\\n #pairs.append( (hm1, hm2) )\\n print\\n return pairs\",\n \"def ggpl_bone_structure(file_name):\\n def planeStructure(beamSection, pillarSection, distancePillars, intersectHeights):\\n fStructs = []\\n \\n \\\"\\\"\\\" createFinalStruct\\n \\n Questo metodo crea una pilastro senza travi\\n \\n @param startPoint: Il punto di intersezione del pilastro con la base del piano di lavoro\\n @param height: L'altezza del pilastro\\n @returns: Il pilastro\\n \\\"\\\"\\\"\\n def createFinalStruct(startPoint, height):\\n pillar = CUBOID([pillarSection[0], pillarSection[1], height])\\n return STRUCT([T(2)(startPoint), pillar])\\n\\n \\\"\\\"\\\" createFStruct\\n \\n Questo metodo crea la struttura portante con il pilastro e le travi di riferimento\\n \\n @param startPoint: Il punto di intersezione del pilastro con la base del piano di lavoro\\n @param height: L'altezza del pilastro\\n @param lengthBeam: La lunghezza delle travi\\n @returns: Il pilastro\\n \\\"\\\"\\\"\\n def createFStruct(startPoint, height, lengthBeam):\\n fStruct = []\\n\\n fStruct.append(createFinalStruct(startPoint, height))\\n hPillar = 0\\n for i in range(len(intersectHeights)):\\n beam = CUBOID([beamSection[1], lengthBeam, beamSection[0]])\\n hPillar += intersectHeights[i]\\n fStruct.append(STRUCT([\\n T(3)(hPillar),\\n T(2)(pillarSection[1] + startPoint),\\n beam\\n ]))\\n return STRUCT(fStruct)\\n\\n height = SUM(intersectHeights) + beamSection[1]\\n\\n startDistance = 0\\n for iterator in range(len(distancePillars)):\\n fStructs.append(createFStruct(startDistance, height, distancePillars[iterator]))\\n\\n startDistance = startDistance + pillarSection[1] + distancePillars[iterator]\\n\\n fStructs.append(createFinalStruct(startDistance, height))\\n\\n return STRUCT(fStructs)\\n \\n \\\"\\\"\\\" createTrasversalBeam\\n \\n Questa funzione crea le travi di collegamento tra una parete e l'altra\\n \\n @param beanSection: una tupla (bx,bz) che contiene la dimensione delle travi\\n @param pillarSection: una tupla (px,py) che contiene la dimensione dei pilastri\\n @param distancePillars: una lista di distanze relative tra un pilastro e l'altro\\n @param intersectHeights: una lista di altezze relative che indicano la distranza tra una trave e l'altra sull'asse x\\n @returns: la struttura base, che corrisponde ad una parete dell'edificio\\n \\\"\\\"\\\"\\n def createTrasversalBeam(distance, beamSection, pillarSection, distancePillars, intersectHeights):\\n y = []\\n for index in range(len(distancePillars)):\\n y.append(pillarSection[1])\\n y.append(- distancePillars[index])\\n y.append(pillarSection[1])\\n\\n x = [\\n - pillarSection[0],\\n distance\\n ]\\n\\n z = []\\n for i in range(len(intersectHeights)):\\n if i == 0:\\n z.append(-intersectHeights[i])\\n else:\\n z.append(-intersectHeights[i] + beamSection[1])\\n z.append(beamSection[1])\\n\\n return PROD([\\n PROD([QUOTE(x), QUOTE(y)]),\\n QUOTE(z)\\n ])\\n \\n \\\"\\\"\\\" parseCSV\\n \\n Questo metodo prende in input un file_name che indica il file csv da parsare per avere le informazioni della struttura\\n \\n Argomenti:\\n file_name (string): il file name del file csv\\n \\n Yields:\\n transaction: il vettore di traslazione tra una parete e l'altra\\n beanSection: una tupla (bx,bz) che contiene la dimensione delle travi\\n pillarSection: una tupla (px,py) che contiene la dimensione dei pilastri\\n distancePillars: una lista di distanze relative tra un pilastro e l'altro\\n intersectHeights: una lista di altezze relative che indicano la distranza tra una trave e l'altra sull'asse x\\n \\\"\\\"\\\"\\n def parseCSV(file_name):\\n odd = True\\n transaction = None\\n with open(file_name, 'rb') as csvfile:\\n builderreader = csv.reader(csvfile)\\n\\n for row in builderreader:\\n if odd:\\n odd = False\\n transaction = [float(row[0]), float(row[1]), float(row[2])]\\n else:\\n odd = True\\n beamSection = [float(row[0]), float(row[1])]\\n pillarSection = [float(row[2]), float(row[3])]\\n\\n distancePillars = []\\n start_point = 5\\n finish_point = int(row[4]) + start_point\\n for index in range(start_point, finish_point):\\n distancePillars.append(int(row[index]))\\n\\n intersectHeights = []\\n start_point = finish_point + 1\\n finish_point = int(row[finish_point]) + start_point\\n for index in range(start_point, finish_point):\\n intersectHeights.append(int(row[index]))\\n\\n yield transaction, beamSection, pillarSection, distancePillars, intersectHeights\\n\\n frames = []\\n for transaction, beamSection, pillarSection, distancePillars, intersectHeights in parseCSV(file_name):\\n frames.append(T(2)(transaction[1]))\\n\\n if transaction[0] != 0:\\n frames.append(\\n createTrasversalBeam(\\n transaction[0], beamSection, pillarSection, distancePillars,intersectHeights\\n )\\n )\\n\\n frames.append(T([1, 3])([transaction[0], transaction[2]]))\\n frames.append(\\n planeStructure(beamSection, pillarSection, distancePillars, intersectHeights)\\n )\\n\\n return STRUCT(frames)\",\n \"def iter_protenn_matches(file: str):\\n with open(file, \\\"rt\\\") as fh:\\n for line in fh:\\n sequence_id, pfam_acc, start, end = line.rstrip().split(\\\"\\\\t\\\")\\n if re.fullmatch(r\\\"PF\\\\d+\\\", pfam_acc):\\n yield sequence_id, pfam_acc, int(start), int(end)\",\n \"def test_documentation_popxl_create_multi_subgraph(self):\\n filename = \\\"create_multi_graphs_from_same_func.py\\\"\\n self.run_python(filename, file_dir=working_dir, working_dir=working_dir)\",\n \"def readMAFOTLaminarOutput(self,PFC,file):\\n print('Reading laminar output')\\n log.info('Reading laminar output')\\n data = np.genfromtxt(file,comments='#')\\n use = np.where(PFC.shadowed_mask != 1)[0]\\n xyz = PFC.centers[use]\\n r,z,phi = tools.xyz2cyl(xyz[:,0],xyz[:,1],xyz[:,2])\\n r = np.round(r,10) #number of decimal places in MAFOT output file\\n\\n #Sometimes the MAFOT calculation returns an error and it discards the\\n #launch point instead of writing to the output file. This results\\n #in less points coming out of MAFOT than we put in. So we amend this\\n #by checking to make sure the points coming out are assigned to the correct\\n #location in the mesh centers.\\n #Could be parallelized in future\\n\\n #Create shared variables so that all multiprocessing cores can access\\n #same variables without needless data transmission\\n tools.lamData = data\\n tools.lamR = r\\n\\n #Prepare intersectionTest across multiple cores\\n t0 = time.time()\\n Ncores = multiprocessing.cpu_count() -2 #reserve 2 cores for overhead\\n print('Initializing parallel MAFOT laminar check across {:d} cores'.format(Ncores))\\n log.info('Initializing parallel MAFOT laminar check across {:d} cores'.format(Ncores))\\n print('Spawning tasks to workers')\\n log.info('Spawning tasks to workers')\\n pool = multiprocessing.Pool(Ncores)\\n indexes = np.asarray(pool.map(tools.readLaminarParallel, np.arange(len(r))))\\n pool.close()\\n\\n PFC.psimin = data[indexes,4]\\n PFC.conLength = data[indexes,3]\\n\\n #R = data[:,0]\\n #Z = data[:,1]\\n #phi = np.radians(data[:,9])\\n #x,y,z = tools.cyl2xyz(R,Z,phi)\\n #PFC.centersLam = np.concatenate((x,y,z)).reshape((-1, 3), order='F')\\n print('Laminar output read')\\n print('Requested {:d} traces from MAFOT'.format(len(r)))\\n print('MAFOT returned {:d} traces'.format(len(data[:,0])))\\n log.info('Laminar output read')\\n log.info('Requested {:d} traces from MAFOT'.format(len(r)))\\n log.info('MAFOT returned {:d} traces'.format(len(data[:,0])))\\n\\n return\",\n \"def write_target_regions(out_f, args, chrom_list, combined_files, snp_files):\\n\\n for chrom in chrom_list: \\n node_name = \\\"/%s\\\" % chrom.name\\n if node_name not in snp_files.snp_index_h5:\\n continue\\n if node_name not in snp_files.snp_tab_h5:\\n continue\\n \\n sys.stderr.write(\\\" %s\\\\n\\\" % chrom.name)\\n\\n sys.stderr.write(\\\" getting genotype counts\\\\n\\\")\\n ref_geno_count = combined_files.ref_count_h5.get_node(node_name)[:]\\n het_geno_count = combined_files.het_count_h5.get_node(node_name)[:]\\n\\n ref_allele_count = ref_geno_count * 2 + het_geno_count\\n # free memory as it is no longer needed\\n del ref_geno_count\\n\\n alt_geno_count = combined_files.alt_count_h5.get_node(node_name)[:]\\n alt_allele_count = alt_geno_count * 2 + het_geno_count\\n\\n del alt_geno_count\\n\\n sys.stderr.write(\\\" getting minor allele counts\\\\n\\\")\\n\\n minor_count = np.amin(np.vstack([ref_allele_count, alt_allele_count]),\\n axis=0)\\n \\n idx = np.where((minor_count >= args.min_minor_allele_count) &\\n (het_geno_count >= args.min_het_count))[0]\\n\\n del het_geno_count\\n del minor_count\\n \\n sys.stderr.write(\\\" %d possible test SNPs\\\\n\\\" % idx.shape[0])\\n\\n read_counts = combined_files.read_count_h5.get_node(node_name)[:]\\n as_read_counts = combined_files.as_count_h5.get_node(node_name)[:]\\n\\n snp_idx = snp_files.snp_index_h5.get_node(node_name)\\n snp_tab = snp_files.snp_tab_h5.get_node(node_name)\\n \\n n_region = 0\\n \\n for i in idx:\\n start = max(1, i+1 - args.target_region_size/2)\\n end = min(chrom.length, i+1 + args.target_region_size/2)\\n\\n n_reads = np.sum(read_counts[start-1:end])\\n n_as_reads = np.sum(as_read_counts[start-1:end])\\n\\n snp_row = snp_tab[snp_idx[i]]\\n\\n if (n_reads >= args.min_read_count) and (n_as_reads >= args.min_as_count):\\n # keep this target region\\n\\n # NOTE: currently this filter just uses total count of AS reads in region.\\n # Would be better to take into account genotypes of each individual, since AS reads\\n # are only useful for test in individuals that are heterozygous for test SNP\\n out_f.write(\\\"%s %d %d %s %s + %s.%d %d %d\\\\n\\\" % \\n (chrom.name, i+1, i+2, snp_row['allele1'],\\n snp_row['allele2'], chrom.name, start+1,\\n start, end))\\n\\n n_region += 1\\n\\n sys.stderr.write(\\\" wrote %d test SNP / target region pairs\\\\n\\\" % n_region)\",\n \"def _load_pascal_annotation(self, index):\\n image = index\\n im_path = self.image_path_from_index(image)\\n im = cv2.imread(im_path)\\n width = im.shape[1]\\n height = im.shape[0]\\n num_objs = 0\\n for ix, obj in enumerate(image.objects):\\n if image.objects[ix].x > width - 2 or image.objects[ix].y > height - 2:\\n continue \\n assert(image.objects[ix].width > 0)\\n assert(image.objects[ix].height > 0)\\n\\n num_objs += 1\\n\\n boxes = np.zeros((num_objs, 4), dtype=np.float32)\\n\\n partial_entity_class = np.zeros((num_objs, 96), dtype=np.int32)\\n partial_relation_class = np.zeros((num_objs, num_objs, 43), dtype=np.int32)\\n gt_classes = np.zeros((0, num_objs, 1), dtype=np.int32)\\n overlaps = np.zeros((0, num_objs, self.num_classes), dtype=np.int64)\\n # \\\"Seg\\\" area for pascal is just the box area\\n seg_areas = np.zeros((num_objs), dtype=np.float32)\\n queries = np.zeros((0, 235), dtype=np.float32)\\n # Load object bounding boxes into a data frame.\\n index = 0\\n \\n for ix, obj in enumerate(image.objects):\\n if image.objects[ix].x > width - 2 or image.objects[ix].y > height - 2:\\n continue\\n # Make pixel indexes 0-based\\n x1_offset = 0.0#image.objects[ix].width * (-0.1)\\n x2_offset = 0.0#image.objects[ix].width * 0.1\\n y1_offset = 0.0#image.objects[ix].height * (-0.1)\\n y2_offset = 0.0#image.objects[ix].height * 0.1\\n boxes[index][0] = max((image.objects[ix].x + x1_offset), 0.0)\\n boxes[index][1] = max((image.objects[ix].y + y1_offset), 0.0)\\n boxes[index][2] = min((image.objects[ix].x + x2_offset + image.objects[ix].width), width - 1)\\n boxes[index][3] = min((image.objects[ix].y + y2_offset + image.objects[ix].height), height - 1)\\n seg_areas[index] = (boxes[index][2] - boxes[index][0] + 1.0) * (boxes[index][3] - boxes[index][1] + 1.0)\\n index += 1\\n assert (boxes[:, 2] > boxes[:, 0]).all()\\n assert (boxes[:, 3]\\t > boxes[:, 1]).all() \\n #load gt classes\\n \\n i_index = 0\\n for i in range(image.objects_labels.shape[0]):\\n if image.objects[i].x > width - 2 or image.objects[i].y > height - 2:\\n continue\\n partial_entity_class[i_index] = image.objects_labels[i]\\n \\n j_index = 0\\n for j in range(image.objects_labels.shape[0]):\\n if image.objects[j].x > width - 2 or image.objects[j].y > height - 2:\\n continue\\n partial_relation_class[i_index, j_index] = image.predicates_labels[i, j]\\n j_index += 1\\n i_index += 1\\n seen = []\\n for query_index in range(image.queries_gt.shape[0]):\\n query_gt_classes = np.zeros((1, num_objs, 1), dtype=np.int32)\\n query_overlaps = np.zeros((1, num_objs, self.num_classes), dtype=np.int64)\\n query_overlaps[0, :, 3] = 1\\n query_gt_classes[0, :, 0] = 3\\n if image.one_hot_relations_gt[query_index][-1] == 1:\\n # print \\\"negative triplet\\\"\\n continue\\n\\n sub = image.one_hot_relations_gt[query_index][:96]\\n obj = image.one_hot_relations_gt[query_index][96:96 * 2]\\n rel = image.one_hot_relations_gt[query_index][96 * 2:]\\n key = str(np.argmax(sub)) + \\\"_\\\" + str(np.argmax(rel)) + \\\"_\\\" + str(np.argmax(obj))\\n if key in seen:\\n continue\\n seen.append(key)\\n\\n found = False\\n i_index = 0\\n for i in range(image.objects_labels.shape[0]):\\n if image.objects[i].x > width - 2 or image.objects[i].y > height - 2:\\n continue\\n if not np.array_equal(image.objects_labels[i], sub):\\n i_index += 1\\n continue\\n j_index = 0\\n for j in range(image.objects_labels.shape[0]):\\n if image.objects[j].x > width - 2 or image.objects[j].y > height - 2:\\n continue \\n\\n if not np.array_equal(image.objects_labels[j], obj):\\n j_index += 1\\n continue\\n if np.array_equal(rel, image.predicates_labels[i, j]):\\n query_gt_classes[0, i_index, 0] = 1\\n query_overlaps[0, i_index, 1] = 1\\n query_overlaps[0, i_index, 3] = 0\\n query_gt_classes[0, j_index, 0] = 2\\n query_overlaps[0, j_index, 2] = 1\\n query_overlaps[0, j_index, 3] = 0\\n \\n #partial_entity_class[i_index] = sub\\n #partial_entity_class[j_index] = obj\\n #partial_relation_class[i_index, j_index] = rel\\n \\n found = True\\n j_index += 1\\n i_index += 1\\n if not found:\\n continue\\n gt_classes = np.concatenate((gt_classes, query_gt_classes), axis=0)\\n overlaps = np.concatenate((overlaps, query_overlaps), axis=0)\\n queries = np.concatenate((queries, image.one_hot_relations_gt[query_index].reshape([1,-1])), axis=0)\\n\\n return {'boxes': boxes,\\n 'gt_classes': gt_classes,\\n 'gt_overlaps': overlaps,\\n 'flipped': False,\\n 'seg_areas': seg_areas,\\n 'query' : queries,\\n 'partial_entity_class' : partial_entity_class,\\n 'partial_relation_class' : partial_relation_class,\\n 'orig_image': None}\",\n \"def prog(args):\\r\\n i_fname, o_fname, pedestal_params, split_list, Num_W = args\\r\\n mesh = stl.mesh.Mesh.from_file(i_fname)\\r\\n #rotate mesh since by default the rotation axis is along X\\r\\n mesh.rotate([0,1,0],np.pi/2)\\r\\n\\r\\n v_arr = np.round(np.vstack(mesh.vectors).astype(float), decimals=1)\\r\\n\\r\\n splt0_arr = np.array(split_list)\\r\\n splt1_arr = np.roll(splt0_arr,-1)\\r\\n\\r\\n pos = cf.cartesian2cylyndrical(v_arr, Num_W)\\r\\n\\r\\n #make splits\\r\\n pos_list=[]\\r\\n for splt0, splt1 in zip(splt0_arr[:-1], splt1_arr[:-1]):\\r\\n pos_idx = np.where((splt0<=pos[:,:,2]) & (splt1>pos[:,:,2]))[0]\\r\\n print(splt0, splt1)\\r\\n #pos = [r, th, z] sectionwise\\r\\n pos_list.append(pos[pos_idx])\\r\\n #add pedestal mesh\\r\\n\\r\\n for sect_num, pos in enumerate(pos_list):\\r\\n pos = cf.add_pedestal(pos, pedestal_params)\\r\\n profiles=np.zeros_like(pos)\\r\\n\\r\\n for i in np.arange(np.shape(pos)[0]):\\r\\n profiles[i] = cf.cylyndrical2cartesian(pos[i])\\r\\n\\r\\n strokes = np.flipud(np.rot90(profiles))\\r\\n #transform data from longeron nodes [xyz] to:\\r\\n #a_arr - rotation angle around the rotation axis\\r\\n #r_arr - length of a segment perpenticular to the rotation axis and corresponding lateral mesh edge\\r\\n #z_arr - corresponding z coordiantes\\r\\n #v_arr - direction vector of the coresponding lateral mesh edge\\r\\n a_arr, r_arr, z_arr, v_arr = cf.transform(strokes, add_pedestal_bottom=True,add_pedestal_top=True)\\r\\n\\r\\n #make a summary plots\\r\\n cf.plot_loft_paths(profiles)\\r\\n cf.plot_loft_paths(pos)\\r\\n cf.plot_surf(a_arr,z_arr,r_arr)\\r\\n\\r\\n #collect data to the dictionary longeron wise\\r\\n res_dict = {'a_arr':np.rot90(a_arr, k=-1),\\r\\n 'r_arr':np.rot90(r_arr, k=-1),\\r\\n 'z_arr':np.rot90(z_arr, k=-1),\\r\\n 'v_arr':np.rot90(v_arr, k=-1)}\\r\\n\\r\\n #save result dictionary\\r\\n if not o_fname:\\r\\n o_fname = i_fname\\r\\n\\r\\n fname='{}_{}.pickle'.format(o_fname, sect_num)\\r\\n with open(fname, 'wb') as f:\\r\\n # Pickle the 'data' dictionary using the highest protocol available.\\r\\n pickle.dump(res_dict, f, pickle.HIGHEST_PROTOCOL)\\r\\n\\r\\n print(fname, ' saved')\",\n \"def file_parse():\\n\\n\\tfilename = input(\\\"Enter the file path for your graph: \\\")\\n\\ttarget = open(filename, 'r')\\n\\n\\ttarget_lines = [] \\t# List of lines from target file\\n\\t\\n\\t# Grab the graph count and node/edge count for the first graph\\n\\ti = 0\\n\\tfor line in target:\\n\\t\\tif i == 0:\\n\\t\\t\\tgraph_count = int(line)\\n\\t\\telif i == 1:\\n\\t\\t\\tnode_count = int(line)\\n\\t\\telif i == 2:\\n\\t\\t\\tedge_count = int(line)\\n\\t\\telse:\\t\\n\\t\\t\\ttarget_lines.append(line.strip('\\\\n'))\\n\\t\\ti += 1\\n\\n\\treturn graph_create(target_lines, graph_count, node_count, edge_count)\",\n \"def mainFunction(f):\\n\\n #############################################################################\\n \\n \\n # biomass hexagon\\n predF = '/vol/v3/lt_stem_v3.1/models/biomassfiaald_20180708_0859/2000/biomassfiaald_20180708_0859_2000_mean.tif'\\n trainF = '/vol/v2/datasets/biomass/nbcd/fia_ald/nbcd_fia_ald_biomass_clipped_to_conus.tif'\\n shpF = '/vol/v1/general_files/datasets/spatial_data/hexagons/hexagons_conus_albers_30km_with_id.shp'\\n trainND = -32768\\n predND = -9999\\n trgField = 'id'\\n descrField = 'id'\\n outDir = '/vol/v3/lt_stem_v3.1/evaluation/biomassfiaald_20180708_0859/hexagon_correlation'\\n xyLim = (500, 500)\\n xLab = 'Reference (tons/ha)'\\n yLab = 'Prediction (tons/ha)'\\n annoXY = (15,420)\\n \\n \\n \\\"\\\"\\\"\\n # cc\\n predF = '/vol/v3/lt_stem_v3.1/models/canopy_20180915_1631/2001/canopy_20180915_1631_2001_mean.tif'\\n trainF = '/vol/v2/stem/conus/reference_rasters/nlcd_2001_canopy_clipped_to_conus_train.tif'\\n #shpF = '/vol/v2/datasets/Eco_Level_III_US/us_eco_l3_no_states_multipart.shp'\\n shpF = '/vol/v1/general_files/datasets/spatial_data/hexagons/hexagons_conus_albers_30km_with_id.shp'\\n trainND = 255\\n predND = 255\\n trgField = 'id'\\n descrField = 'id'\\n #trgField = 'US_L3CODE'\\n #descrField = 'US_L3NAME'\\n #outDir = '/vol/v3/lt_stem_v3.1/evaluation/canopy_20180915_1631/ecoregion_correlation'\\n outDir = '/vol/v3/lt_stem_v3.1/evaluation/canopy_20180915_1631/hexagon_correlation'\\n xyLim = (100, 100)\\n xLab = 'Reference (%)'\\n yLab = 'Prediction (%)'\\n annoXY = (5,82)\\n \\\"\\\"\\\"\\n #############################################################################\\n\\n\\n # get color setup\\n norm = colors.Normalize(vmin=0, vmax=1)\\n f2rgb = cm.ScalarMappable(norm=norm, cmap=cm.get_cmap('YlGnBu_r'))\\n \\n # open the shapefile\\t\\n vDriver = ogr.GetDriverByName(\\\"ESRI Shapefile\\\")\\n vSrc = vDriver.Open(shpF, 0)\\n vLayer = vSrc.GetLayer()\\n \\n commonBox = get_intersec([predF, trainF])\\n\\n#for f in range(vLayer.GetFeatureCount()):\\n feature = vLayer[f]\\n name = feature.GetField(trgField)\\n print('f: '+str(f))\\n outFig = os.path.join(outDir, (trgField.replace(' ','_').lower()+'_'+str(name)+'.png'))\\n if os.path.exists(outFig):\\n #break\\n return\\n \\n descr = feature.GetField(descrField)\\n \\n predP, coords = get_zone_pixels(feature, shpF, predF, 1, [commonBox[0], commonBox[2], commonBox[3], commonBox[1]])#.compressed() [commonBox[0], commonBox[2], commonBox[3], commonBox[1]]\\n trainP, coords = get_zone_pixels(feature, shpF, trainF, 1, [coords[0], coords[1], coords[2], coords[3]])#.compressed()\\n \\n predP = ma.masked_equal(predP, predND)\\n trainP = ma.masked_equal(trainP, trainND)\\n trainP = ma.masked_equal(trainP, 0)\\n\\n combMask = np.logical_not(np.logical_not(predP.mask) * np.logical_not(trainP.mask))\\n predP[combMask] = ma.masked\\n trainP[combMask] = ma.masked\\n predP = predP.compressed()\\n trainP = trainP.compressed()\\n if (predP.shape[0] == 0) | (trainP.shape[0] == 0) | (predP==0).all() | (trainP==0).all():\\n predP = np.array([0,0,1,1], dtype='float64')\\n trainP = np.array([0,0,1,1], dtype='float64')\\n mae = round(np.mean(np.absolute(np.subtract(predP, trainP))),1)\\n rmse = round(np.sqrt(np.mean((predP-trainP)**2)),1)\\n \\n\\n totPixs = trainP.shape[0]\\n sampSize = round(totPixs*1)\\n pickFrom = range(sampSize)\\n #sampIndex = np.random.choice(pickFrom, size=sampSize)\\n sampIndex = pickFrom\\n\\n r = round(np.corrcoef(trainP[sampIndex], predP[sampIndex])[0][1], 2)\\n if (mae == 0) & (r == 1):\\n r = 0.0\\n rColor = f2hex(f2rgb, r)\\n p = sns.jointplot(trainP[sampIndex], predP[sampIndex], kind=\\\"hex\\\", color='blue', xlim=(0,xyLim[0]), ylim=(0,xyLim[1]), size=5)\\n p.ax_joint.set_xlabel(xLab)\\n p.ax_joint.set_ylabel(yLab)\\n p.ax_joint.annotate('r: '+str(r)+'\\\\nrmse: '+str(rmse)+'\\\\nmae: '+str(mae), annoXY)\\n plt.tight_layout()\\n outFig = os.path.join(outDir, (trgField.replace(' ','_').lower()+'_'+str(name)+'.png'))\\n p.savefig(outFig)\\n \\n df = pd.DataFrame({'id':name, 'descr':descr, 'r':r, 'rmse':rmse, 'mae':mae, 'color':rColor, 'img':os.path.basename(outFig)}, index=[0])\\n outCSV = outFig.replace('.png','.csv')\\n df.to_csv(outCSV, ',', index=False)\",\n \"def main():\\n tot = []\\n with open(intersect) as fil:\\n for line in fil:\\n data = []\\n if len(line) > 1:\\n rec = int_parse(line)\\n win = find_winID(rec.wst, w)\\n if int(rec.gst) != -1:\\n imp = rec.info.rstrip().split(';')\\n ID = imp[0].split('=')[1]\\n Name = imp[1].split('=')[1]\\n if imp[2].startswith('fullname'):\\n fullname = imp[2].split('=')[1]\\n if imp[3].startswith('Alias'):\\n Alias = imp[3].split('=')[1]\\n Ontology_term = imp[4].split('=')[1]\\n Dbxref = imp[5].split('=')[1]\\n GO, _ = split_ont(Ontology_term)\\n _, SO = split_ont(Ontology_term)\\n gst = rec.gst\\n gen = rec.gen\\n else:\\n Alias = 'NA'\\n Ontology_term = imp[3].split('=')[1]\\n Dbxref = imp[4].split('=')[1]\\n GO, _ = split_ont(Ontology_term)\\n _, SO = split_ont(Ontology_term)\\n gst = rec.gst\\n gen = rec.gen\\n else:\\n fullname = 'NA'\\n if imp[2].startswith('Alias'):\\n Alias = imp[2].split('=')[1]\\n Ontology_term = imp[3].split('=')[1]\\n Dbxref = imp[4].split('=')[1]\\n GO, _ = split_ont(Ontology_term)\\n _, SO = split_ont(Ontology_term)\\n gst = rec.gst\\n gen = rec.gen\\n else:\\n Alias = 'NA'\\n Ontology_term = imp[2].split('=')[1]\\n Dbxref = imp[3].split('=')[1]\\n GO, _ = split_ont(Ontology_term)\\n _, SO = split_ont(Ontology_term)\\n gst = rec.gst\\n gen = rec.gen\\n else:\\n ID = 'NA'\\n Name = 'NA'\\n fullname = 'NA'\\n gst = 'NA'\\n gen = 'NA'\\n Alias = 'NA'\\n GO = 'NA'\\n SO = 'NA'\\n Dbxref = 'NA'\\n data.append(ID)\\n data.append(Name)\\n data.append(fullname)\\n data.append(gst)\\n data.append(gen)\\n data.append(Alias)\\n data.append(GO)\\n data.append(SO)\\n data.append(Dbxref)\\n data.append(rec.chrom)\\n data.append(win)\\n tot.append(tuple(data))\\n writeTable(tot)\",\n \"def p_and_l_from(files):\\n if isinstance(files, str):\\n files = [files]\\n paths = []\\n labels = []\\n for file in files:\\n print(f'read {file}')\\n with open(file, 'r') as f:\\n lines = f.readlines()\\n for line in lines:\\n line = line.split(' ')\\n paths.append(line[0])\\n labels.append(int(line[1]))\\n return [paths, labels]\",\n \"def make_libfile():\\n # wfc3_obsmodes_uvis\\n wfc3_uvis = [\\n \\\"f218w\\\",\\n \\\"f225w\\\",\\n \\\"f275w\\\",\\n \\\"f336w\\\",\\n \\\"f390m\\\",\\n \\\"f390w\\\",\\n \\\"f410m\\\",\\n \\\"f438w\\\",\\n \\\"f467m\\\",\\n \\\"f475w\\\",\\n \\\"f547m\\\",\\n \\\"f555w\\\",\\n \\\"f606w\\\",\\n \\\"f621m\\\",\\n \\\"f625w\\\",\\n \\\"f689m\\\",\\n \\\"f763m\\\",\\n \\\"f775w\\\",\\n \\\"f814w\\\",\\n \\\"f845m\\\",\\n ]\\n\\n wfc3_ir = [\\n \\\"f098m\\\",\\n \\\"f105w\\\",\\n \\\"f110w\\\",\\n \\\"f125w\\\",\\n \\\"f127m\\\",\\n \\\"f139m\\\",\\n \\\"f140w\\\",\\n \\\"f153m\\\",\\n \\\"f160w\\\",\\n ]\\n\\n wfpc2 = [\\n \\\"f122m\\\",\\n \\\"f157w\\\",\\n \\\"f336w\\\",\\n \\\"f410m\\\",\\n \\\"f467m\\\",\\n \\\"f547m\\\",\\n \\\"f439w\\\",\\n \\\"f569w\\\",\\n \\\"f675w\\\",\\n \\\"f791w\\\",\\n \\\"f170w\\\",\\n \\\"f185w\\\",\\n \\\"f218w\\\",\\n \\\"f255w\\\",\\n \\\"f300w\\\",\\n \\\"f380w\\\",\\n \\\"f555w\\\",\\n \\\"f622w\\\",\\n \\\"f450w\\\",\\n \\\"f606w\\\",\\n \\\"f702w\\\",\\n \\\"f814w\\\",\\n ]\\n\\n acs_wfc = [\\n \\\"f435w\\\",\\n \\\"f475w\\\",\\n \\\"f550m\\\",\\n \\\"f555w\\\",\\n \\\"f606w\\\",\\n \\\"f625w\\\",\\n \\\"f775w\\\",\\n \\\"f814w\\\",\\n ]\\n # galex\\n galex = [\\\"fuv\\\", \\\"nuv\\\"]\\n\\n # Open hd5 file for writing\\n hf = h5py.File(__ROOT__ + \\\"filters.hd5\\\", \\\"w\\\")\\n\\n # Create group for nice hierarchical structure\\n f = hf.create_group(\\\"filters\\\")\\n\\n # Define arrays for \\\"contents\\\" / descriptive information\\n tablenames = []\\n observatories = []\\n instruments = []\\n names = []\\n norms = []\\n cwaves = []\\n pwaves = []\\n comments = []\\n\\n # Loop through WFC3_UVIS filters\\n for filt in wfc3_uvis:\\n\\n # define uvis 1 and uvis2 modes\\n mode_1 = \\\"wfc3, uvis1, \\\" + filt\\n mode_2 = \\\"wfc3, uvis2, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp_1 = stsyn.band(mode_1)\\n bp_2 = stsyn.band(mode_2)\\n\\n # extract the wavelength array\\n wave = bp_1.waveset\\n\\n # compute the average bandpass between uvis1 and uvis2\\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\\n\\n # define the filter name\\n filter_name = \\\"HST_WFC3_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"WFC3\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"avg of uvis1 and uvis2\\\")\\n\\n # Loop through WFC3_IR filters\\n for filt in wfc3_ir:\\n\\n # define ir mode\\n mode = \\\"wfc3, ir, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp = stsyn.band(mode)\\n\\n # extract the wavelength array\\n wave = bp.waveset\\n\\n # define the filter name\\n filter_name = \\\"HST_WFC3_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"WFC3\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"\\\")\\n\\n # Loop through WFPC2 filters\\n for filt in wfpc2:\\n\\n # define chips 1, 2, 3, 4 modes\\n mode_1 = \\\"wfpc2, 1, \\\" + filt\\n mode_2 = \\\"wfpc2, 2, \\\" + filt\\n mode_3 = \\\"wfpc2, 3, \\\" + filt\\n mode_4 = \\\"wfpc2, 4, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp_1 = stsyn.band(mode_1)\\n bp_2 = stsyn.band(mode_2)\\n bp_3 = stsyn.band(mode_3)\\n bp_4 = stsyn.band(mode_4)\\n\\n # extract the wavelength array\\n wave = bp_1.waveset\\n\\n # compute the average bandpass between uvis1 and uvis2\\n bp_avg = np.average([bp_1(wave), bp_2(wave), bp_3(wave), bp_4(wave)], axis=0)\\n\\n # define the filter name\\n filter_name = \\\"HST_WFPC2_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"WFPC2\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"avg of 1, 2, 3, 4\\\")\\n\\n # Loop through ACS filters\\n for filt in acs_wfc:\\n\\n # define wfc1, wfc2 modes\\n mode_1 = \\\"acs, wfc1, \\\" + filt\\n mode_2 = \\\"acs, wfc2, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp_1 = stsyn.band(mode_1)\\n bp_2 = stsyn.band(mode_2)\\n\\n # extract the wavelength array\\n wave = bp_1.waveset\\n\\n # compute the average bandpass between uvis1 and uvis2\\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\\n\\n # define the filter name\\n filter_name = \\\"HST_ACS_WFC_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"ACS_WFC\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"avg of wfc1 and wfc2\\\")\\n\\n # Loop through GALEX filters:\\n for filt in galex:\\n # define ir mode\\n mode = \\\"galex,\\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp = stsyn.band(mode)\\n\\n # extract the wavelength array\\n wave = bp.waveset\\n\\n # define the filter name\\n filter_name = \\\"GALEX_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"GALEX\\\")\\n instruments.append(\\\"GALEX\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"\\\")\\n\\n # smash the contents arrays together\\n contents = np.array(\\n list(\\n zip(\\n tablenames,\\n observatories,\\n instruments,\\n names,\\n norms,\\n cwaves,\\n pwaves,\\n comments,\\n )\\n ),\\n dtype=[\\n (\\\"TABLENAME\\\", \\\"S40\\\"),\\n (\\\"OBSERVATORY\\\", \\\"S30\\\"),\\n (\\\"INSTRUMENT\\\", \\\"S30\\\"),\\n (\\\"NAME\\\", \\\"S10\\\"),\\n (\\\"NORM\\\", \\\"<f8\\\"),\\n (\\\"CWAVE\\\", \\\"<f8\\\"),\\n (\\\"PWAVE\\\", \\\"<f8\\\"),\\n (\\\"COMMENT\\\", \\\"S100\\\"),\\n ],\\n )\\n\\n # add the contents array as an hd5 dataset\\n hf.create_dataset(\\\"content\\\", data=contents)\\n\\n # close the file\\n hf.close()\",\n \"def join(args):\\n from jcvi.formats.agp import OO, Phases, build\\n from jcvi.formats.sizes import Sizes\\n\\n p = OptionParser(join.__doc__)\\n p.add_option(\\\"--newid\\\", default=None, help=\\\"New sequence ID\\\")\\n p.add_option(\\n \\\"--gapsize\\\",\\n default=100,\\n type=\\\"int\\\",\\n help=\\\"Number of N's in between the sequences\\\",\\n )\\n p.add_option(\\\"--gaptype\\\", default=\\\"contig\\\", help=\\\"Gap type to use in the AGP file\\\")\\n p.add_option(\\n \\\"--evidence\\\", default=\\\"\\\", help=\\\"Linkage evidence to report in the AGP file\\\"\\n )\\n p.add_option(\\\"--oo\\\", help=\\\"Use .oo file generated by bambus\\\")\\n opts, args = p.parse_args(args)\\n\\n nargs = len(args)\\n if nargs not in (1, 2):\\n sys.exit(not p.print_help())\\n\\n if nargs == 2:\\n fastafile, phasefile = args\\n phases = DictFile(phasefile)\\n phases = dict((a, Phases[int(b)]) for a, b in phases.items())\\n else:\\n (fastafile,) = args\\n phases = {}\\n\\n sizes = Sizes(fastafile)\\n prefix = fastafile.rsplit(\\\".\\\", 1)[0]\\n agpfile = prefix + \\\".agp\\\"\\n newid = opts.newid\\n oo = opts.oo\\n\\n o = OO(oo, sizes.mapping)\\n\\n if oo:\\n seen = o.contigs\\n # The leftover contigs not in the oo file\\n logging.debug(\\n \\\"A total of {0} contigs ({1} in `{2}`)\\\".format(len(sizes), len(seen), oo)\\n )\\n\\n for ctg, size in sizes.iter_sizes():\\n if ctg in seen:\\n continue\\n o.add(ctg, ctg, size)\\n\\n else:\\n if newid:\\n for ctg, size in sizes.iter_sizes():\\n o.add(newid, ctg, size)\\n else:\\n for scaffold_number, (ctg, size) in enumerate(sizes.iter_sizes()):\\n object_id = \\\"scaffold{0:03d}\\\".format(scaffold_number + 1)\\n o.add(object_id, ctg, size)\\n\\n fw = open(agpfile, \\\"w\\\")\\n o.write_AGP(\\n fw,\\n gapsize=opts.gapsize,\\n gaptype=opts.gaptype,\\n evidence=opts.evidence,\\n phases=phases,\\n )\\n fw.close()\\n\\n joinedfastafile = prefix + \\\".joined.fasta\\\"\\n build([agpfile, fastafile, joinedfastafile])\\n\\n return joinedfastafile\",\n \"def sub_graph_merging(self):\",\n \"def graph(automaton,graph_name=\\\"finite_state_machine\\\",file_name=\\\"finite_state_machine.gv\\\"):\\n letter = next(iter(automaton.states))[0]\\n grph = Digraph(graph_name,filename=file_name)\\n grph.attr(rankdir=letter, size='8,5')\\n #specifying final nodes \\n grph.attr('node', shape='doublecircle')\\n for state in automaton.final_states:\\n grph.node(state)\\n #creating edges\\n \\n grph.attr('node', shape='circle')\\n if(isinstance(automaton,DFA)):\\n grph =addEdgesDFA(grph,automaton)\\n grph.edge(\\\"\\\",automaton.initial_state,\\\"\\\")\\n grph.edge(\\\"\\\",automaton.initial_state,\\\"\\\")\\n else:\\n grph =addEdgesNFA(grph,automaton) \\n return grph\",\n \"def merge(self, g1, g2):\\n logger = logging.getLogger(__name__)\\n \\n \\n g = BaseGraph()\\n g.copy_graph_from(g1)\\n\\n plwn2sumo_dict = defaultdict(set)\\n plwn2sumo_dict = self.get_plwn2sumo_dict()\\n\\n synset_on_vertex_dict = {}\\n for node in g.all_nodes():\\n synset_id = node.synset.synset_id\\n if synset_id in synset_on_vertex_dict:\\n logger.warning(\\\"ID of some synset is not unique.\\\")\\n continue\\n synset_on_vertex_dict[synset_id] = node\\n\\n num_of_edge = 0\\n for edge in g2.all_edges():\\n num_of_edge += 1\\n logger.info(\\\"%d/%d\\\", num_of_edge, g2.num_edges())\\n\\n parent_sumo_concept = edge.source().sumo\\n child_sumo_concept = edge.target().sumo\\n\\n if parent_sumo_concept not in plwn2sumo_dict:\\n logger.warning(\\\"The mapping file doesn't contain sumo concept '%s'.\\\", parent_sumo_concept)\\n continue\\n if child_sumo_concept not in plwn2sumo_dict:\\n logger.warning(\\\"The mapping file doesn't contain sumo concept '%s'.\\\", child_sumo_concept)\\n continue\\n\\n for parent_syn_id in plwn2sumo_dict[parent_sumo_concept]:\\n if parent_syn_id not in synset_on_vertex_dict:\\n logger.warning(\\\"The mapping file contains synset '%d' that is not in the graph.\\\", parent_syn_id)\\n continue\\n p_node = synset_on_vertex_dict[parent_syn_id]\\n for child_syn_id in plwn2sumo_dict[child_sumo_concept]:\\n if child_syn_id not in synset_on_vertex_dict:\\n logger.warning(\\\"The mapping file contains synset '%d' that is not in the graph.\\\", child_syn_id)\\n continue\\n ch_node = synset_on_vertex_dict[child_syn_id]\\n \\n g.add_edge(p_node,\\n ch_node,\\n [(\\\"rel\\\", edge.rel)],\\n simply=True)\\n \\n\\n return g\",\n \"def paesi_example():\\n router = Router(building_file=PROJECT_PATH + \\\"geographycal_data/paesi_elev/paesi_elev\\\")\\n router.clusters(router.graph)\\n router.write2shp(router.acqueduct, \\\"acqueduct1\\\")\",\n \"def calculateOverlap(mfaPairs, exons1, exons2):\\n exonSize = 0\\n noMatchToExons = 0\\n noMatchToNonExons = 0\\n noMatchToGapsInExons = 0\\n noMatchToGapsNotInExons = 0\\n \\n p = -100000\\n for i in exons1:\\n exonSize += i[1] - i[0]\\n for j in xrange(i[0], i[1]):\\n k = mfaPairs[j]\\n l = k\\n if k == GAP:\\n l = p \\n for m in exons2:\\n if(l >= m[0] and l < m[1]):\\n if k == GAP:\\n noMatchToGapsInExons += 1\\n else:\\n noMatchToExons += 1\\n break\\n else:\\n if k == GAP:\\n noMatchToGapsNotInExons += 1\\n else:\\n noMatchToNonExons += 1\\n if k != GAP:\\n p = k\\n return (exonSize, noMatchToExons, noMatchToNonExons,\\\\\\n noMatchToGapsInExons, noMatchToGapsNotInExons)\",\n \"def assemble(filename):\\n count = 0\\n index = { } # Keys are names, values are graph indices.\\n with open(filename, 'r') as f:\\n size = int(f.readline().strip())\\n G = Graph(size)\\n for line in f:\\n words = line.split()\\n s = index.get(words[0], None)\\n d = index.get(words[1], None)\\n if s == None: # Here we are\\n s = index[words[0]] = count # making sure\\n count += 1 # we use index\\n if d == None: # that is not\\n d = index[words[1]] = count # yet in the\\n count += 1 # graph.\\n w = int(words[2])\\n G.add(s,d,w)\\n return G,index\",\n \"def pattern_matching(pattern_base, cc_pattern_base):\\n papers = [os.path.join(target_folder, paper) for paper in os.listdir(target_folder) if \\\".xml\\\" in paper]\\n \\n for paper in papers:\\n paper_text = open(paper[:paper.index('.')]+\\\".txt\\\", 'r').read()\\n \\n annotator = detect_change_events(paper, pattern_base, paper_text) \\n annotator = detect_cause_correlation(paper_text, cc_pattern_base, annotator)\\n \\n # Write the annotations to file\\n with open(paper[:paper.index('.')]+\\\".ann\\\", 'w') as annfile:\\n for annotation in annotator.annotations:\\n annfile.write(annotation+\\\"\\\\n\\\")\",\n \"def main():\\n args = get_args()\\n FILE = args.FILE\\n annotations = args.annotations\\n outfile = args.outfile\\n \\n \\n if not os.path.isfile(FILE):\\n die('\\\"{}\\\" is not a file'.format(FILE))\\n if not os.path.isfile(annotations):\\n die('\\\"{}\\\" is not a file'.format(annotations))\\n if os.path.isfile(FILE) and os.path.isfile(annotations):\\n reader = csv.DictReader(open(FILE), delimiter = '\\\\t', fieldnames = (\\\"qseqid\\\", \\\"sseqid\\\", \\\"pident\\\", \\\"length\\\", \\\"mismatch\\\", \\\"gapopen\\\", \\\"qstart\\\", \\\"qend\\\", \\\"sstart\\\", \\\"send\\\", \\\"evalue\\\", \\\"bitscore\\\"))\\n reader_a = csv.DictReader(open(annotations), fieldnames = (\\\"centroid\\\", \\\"domain\\\", \\\"kingdom\\\", \\\"phylum\\\", \\\"class\\\", \\\"order\\\", \\\"genus\\\", \\\"species\\\"))\\n reader_b = csv.reader(open(annotations, 'r'))\\n anno_dict = {}\\n for row in reader_b:\\n key1 = row[0]\\n anno_dict[key1] = row[1:]\\n\\n #print(anno_dict)\\n \\n \\\"\\\"\\\"for dct in map(dict, reader_a):\\n genus = (f\\\"{dct['genus']}\\\")\\n species = (f\\\"{dct['species']}\\\")\\n if genus == \\\"\\\": \\n print(\\\"NA\\\")\\n else:\\n print(genus)\\n if species == \\\"\\\":\\n print(\\\"NA\\\")\\n else:\\n print(species)\\\"\\\"\\\"\\n for dct in map(dict, reader):\\n seq_id = (f\\\"{dct['sseqid']}\\\") \\n pident = (f\\\"{dct['pident']}\\\")\\n #print(seq_id)\\n for dct_a in map(dict, reader_a):\\n genus = (f\\\"{dct_a['genus']}\\\")\\n species = (f\\\"{dct_a['species']}\\\")\\n if any(seq_id == key for key in anno_dict): \\n \\\"\\\"\\\"print(seq_id)\\n print(pident)\\n print(genus)\\n print(species)\\n #find a way to print genus and species of seq_id\\n \\\"\\\"\\\"\\n \\n else:\\n warn('Cannot find seq \\\"{}\\\" in lookup'.format(seq_id))\\n \\\"\\\"\\\"for line_a in reader_a:\\n an_id = (line_a['centroid']) \\n print('\\\"{}\\\" is an_id'.format(an_id)) \\n for line in reader:\\n seq_id = (line['sseqid'])\\n print('\\\"{}\\\" is seq_id'.format(seq_id))\\n if seq_id == an_id:\\n print(\\\"hi\\\")\\n else:\\n warn('Cannot find seq \\\"{}\\\" in lookup'.format(seq_id))\\n \\\"\\\"\\\"\\n #pprint.pprint(dict_list)\\n #pprint.pprint(dict_list_a)\\n #for key, value in d1.items():\\n #if key is 'sseqid':\\n #print(value)\\n #print(dict_list_a['centroid']) \",\n \"def create_pos_overlap_metric(anchor_boxes):\\n y, x, h, w = np.transpose(anchor_boxes)\\n y0 = y - h // 2\\n x0 = x - w // 2\\n y1 = y + h // 2\\n x1 = x + w // 2\\n\\n def pos_overlap(gt_boxes):\\n pos_overlaps = []\\n for gt_box in gt_boxes:\\n gt_y0, gt_x0, gt_y1, gt_x1 = gt_box\\n gt_area = (gt_x1 - gt_x0) * (gt_y1 - gt_y0)\\n int_y0 = np.maximum(gt_y0, y0)\\n int_x0 = np.maximum(gt_x0, x0)\\n int_y1 = np.minimum(gt_y1, y1)\\n int_x1 = np.minimum(gt_x1, x1)\\n int_area = np.maximum(0, int_x1 - int_x0) * np.maximum(0, int_y1 - int_y0)\\n pos_overlaps.append(int_area / gt_area)\\n # Group by anchor boxes\\n pos_overlaps = np.transpose(pos_overlaps)\\n # Get max metric index\\n gt_indices = np.argmax(pos_overlaps, axis=1)\\n # Choose max metric\\n pos_overlaps = np.squeeze(np.take_along_axis(pos_overlaps, gt_indices[:, np.newaxis], axis=1))\\n # Take respective ground-truth boxes. No reason to return indices, at least in RPN\\n gt_boxes = np.take(gt_boxes, gt_indices, axis=0)\\n return pos_overlaps, gt_boxes\\n return pos_overlap\",\n \"def parse(self):\\n count = [] #count for trainset_size\\n with open(self.file) as f:\\n for line in f:\\n data = line.split(\\\" \\\")[0]\\n filename = data[:-1]\\n id = data[-1:]\\n if (filename not in count):\\n count.append(filename)\\n\\n acid = \\\"\\\"\\n structure = \\\"\\\"\\n with open(self.directory+\\\"/\\\"+filename+\\\".dssp\\\") as dssp:\\n for i in range(28): #skip lines we don't need\\n next(dssp)\\n for line in dssp:\\n if (line[9] != \\\" \\\" and line[10] == \\\" \\\" and line[11] == id and line[13] not in (\\\"*\\\",\\\"!\\\",\\\"B\\\",\\\"Z\\\",\\\"X\\\")):\\n #amino acid sequence\\n if (line[13].islower()):\\n acid += \\\"C\\\"\\n else:\\n acid += line[13]\\n\\n #sequence of the structure\\n if (line[16] in (\\\"H\\\",\\\"G\\\",\\\"I\\\")):\\n structure += \\\"H\\\"\\n elif (line[16] in (\\\"E\\\",\\\"B\\\")):\\n structure += \\\"E\\\"\\n else:\\n structure += \\\"C\\\"\\n\\n if (len(count) > self.trainset_size):\\n self.testset.append((acid,structure))\\n else:\\n self.trainset.append((acid,structure))\",\n \"def single_epoch(g,rows,cols,midpoint):\\n\\n num_top = 10 \\n #3 for 8x8\\n one_to_select = 0 \\n top_nodes = g.top_n_nodes(num_top)\\n '''\\n for k in range(num_top):\\n node_num = top_nodes[k]\\n trip_list = g.node2trip_ids[node_num]\\n print \\\"Next Midpoint: %d\\\" % k\\n print node_num\\n print g.node_to_coords(node_num)\\n print \\\"Num trips: %d\\\" % len(trip_list)\\n for i in range(len(trip_list)):\\n trip_id = trip_list[i]\\n line_num = g.trip_id2line_num[trip_id]\\n p = Path(trip_id,g,line_num)\\n \\\"\\\"\\\"\\n print i\\n print trip_id\\n p.print_path()\\n for i in range(p.graph.num_edges):\\n if p.edges[i]:\\n sys.stdout.write(\\\"%d, \\\" % (i + 1))\\n sys.stdout.write(\\\"\\\\n\\\")\\n sys.stdout.write(\\\"1s: \\\")\\n for key in p.partials.keys():\\n if p.partials[key]:\\n sys.stdout.write(\\\"%d, \\\" % (key + 1))\\n sys.stdout.write(\\\"\\\\n0s: \\\")\\n for key in p.partials.keys():\\n if not p.partials[key]:\\n sys.stdout.write(\\\"%d, \\\" % (key + 1))\\n sys.stdout.write(\\\"\\\\n\\\")\\n #\\\"\\\"\\\"\\n '''\\n\\n #trip_list = g.node2trip_ids[g.best_node]\\n #midpoint = top_nodes[one_to_select]\\n trip_list = g.node2trip_ids[midpoint]\\n print \\\"Selected midpoint: %d\\\" % midpoint \\n print g.node_to_coords(midpoint)\\n out_file = open(\\\"datasets/full_data_%d_%d_%d.txt\\\" % (rows,cols,midpoint),'w')\\n partial_file = open(\\\"datasets/partials_%d_%d_%d.txt\\\" % (rows,cols,midpoint), 'w')\\n for i in range(len(trip_list)):\\n trip_id = trip_list[i]\\n line_num = g.trip_id2line_num[trip_id]\\n p = Path(trip_id,g,line_num=line_num,midpoint=midpoint)\\n \\\"\\\"\\\"\\n print i\\n print trip_id\\n p.print_path()\\n for i in range(p.graph.num_edges):\\n if p.edges[i]:\\n sys.stdout.write(\\\"%d, \\\" % (i + 1))\\n sys.stdout.write(\\\"\\\\n\\\")\\n sys.stdout.write(\\\"1s: \\\")\\n for key in p.partials.keys():\\n if p.partials[key]:\\n sys.stdout.write(\\\"%d, \\\" % (key + 1))\\n sys.stdout.write(\\\"\\\\n0s: \\\")\\n for key in p.partials.keys():\\n if not p.partials[key]:\\n sys.stdout.write(\\\"%d, \\\" % (key + 1))\\n sys.stdout.write(\\\"\\\\n\\\")\\n \\\"\\\"\\\"\\n out_string = str(p.edges)[1:-1]\\n out_file.write(\\\"%s\\\\n\\\" % out_string)\\n for i in range(p.graph.num_edges):\\n if i in p.partials.keys():\\n partial_file.write(\\\"%d\\\" % p.partials[i])\\n else:\\n partial_file.write(\\\"-1\\\")\\n if i < p.graph.num_edges-1:\\n partial_file.write(\\\",\\\")\\n partial_file.write(\\\"\\\\n\\\")\\n\\n out_file.close()\",\n \"def _CreateGraph(self):\\n self.nodes = []\\n self.edges = []\\n for i, r in self.airports.set_index('airport_id').iterrows():\\n self.nodes.append((i,r.to_dict()))\\n for i, r in self.routes.set_index(['src_id','dst_id']).iterrows():\\n self.edges.append((i[0],i[1],r.to_dict()))\\n # print('node ex: {}'.format(self.nodes[0]))\\n # print('edge ex: {}'.format(self.edges[0]))\\n\\n self.graph = self._CreateAdjacencyListGraph()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6383634","0.61519605","0.60640895","0.5620521","0.54954714","0.5461694","0.5433732","0.54307693","0.5381156","0.53631675","0.5311818","0.5308905","0.52986294","0.52673423","0.5267266","0.52432793","0.52378273","0.52373457","0.5227681","0.5227558","0.52236855","0.5220912","0.52207094","0.5205544","0.5199316","0.51859576","0.51727813","0.514736","0.51290923","0.5118723","0.5104484","0.50935584","0.50843287","0.50736636","0.50655156","0.5059325","0.504885","0.50398314","0.50352603","0.5031724","0.502279","0.5015526","0.50128824","0.50101024","0.5005862","0.49965617","0.49885872","0.49883094","0.49863595","0.49846855","0.49760333","0.49744463","0.49605438","0.49501136","0.4944262","0.49412626","0.4939001","0.4935914","0.49327236","0.4931819","0.49256346","0.49238935","0.4922031","0.49035713","0.48980814","0.4894163","0.4892226","0.48888513","0.4885908","0.48822156","0.48738423","0.4871682","0.48711765","0.48711437","0.48684725","0.48683897","0.4864452","0.48619476","0.48618782","0.48610565","0.48537","0.48497668","0.48497495","0.48393613","0.48377183","0.4835893","0.48252782","0.48197168","0.48193327","0.48165363","0.48118383","0.47956577","0.4792985","0.47909433","0.4781549","0.4780083","0.47780254","0.47763658","0.47754413","0.47699142"],"string":"[\n \"0.6383634\",\n \"0.61519605\",\n \"0.60640895\",\n \"0.5620521\",\n \"0.54954714\",\n \"0.5461694\",\n \"0.5433732\",\n \"0.54307693\",\n \"0.5381156\",\n \"0.53631675\",\n \"0.5311818\",\n \"0.5308905\",\n \"0.52986294\",\n \"0.52673423\",\n \"0.5267266\",\n \"0.52432793\",\n \"0.52378273\",\n \"0.52373457\",\n \"0.5227681\",\n \"0.5227558\",\n \"0.52236855\",\n \"0.5220912\",\n \"0.52207094\",\n \"0.5205544\",\n \"0.5199316\",\n \"0.51859576\",\n \"0.51727813\",\n \"0.514736\",\n \"0.51290923\",\n \"0.5118723\",\n \"0.5104484\",\n \"0.50935584\",\n \"0.50843287\",\n \"0.50736636\",\n \"0.50655156\",\n \"0.5059325\",\n \"0.504885\",\n \"0.50398314\",\n \"0.50352603\",\n \"0.5031724\",\n \"0.502279\",\n \"0.5015526\",\n \"0.50128824\",\n \"0.50101024\",\n \"0.5005862\",\n \"0.49965617\",\n \"0.49885872\",\n \"0.49883094\",\n \"0.49863595\",\n \"0.49846855\",\n \"0.49760333\",\n \"0.49744463\",\n \"0.49605438\",\n \"0.49501136\",\n \"0.4944262\",\n \"0.49412626\",\n \"0.4939001\",\n \"0.4935914\",\n \"0.49327236\",\n \"0.4931819\",\n \"0.49256346\",\n \"0.49238935\",\n \"0.4922031\",\n \"0.49035713\",\n \"0.48980814\",\n \"0.4894163\",\n \"0.4892226\",\n \"0.48888513\",\n \"0.4885908\",\n \"0.48822156\",\n \"0.48738423\",\n \"0.4871682\",\n \"0.48711765\",\n \"0.48711437\",\n \"0.48684725\",\n \"0.48683897\",\n \"0.4864452\",\n \"0.48619476\",\n \"0.48618782\",\n \"0.48610565\",\n \"0.48537\",\n \"0.48497668\",\n \"0.48497495\",\n \"0.48393613\",\n \"0.48377183\",\n \"0.4835893\",\n \"0.48252782\",\n \"0.48197168\",\n \"0.48193327\",\n \"0.48165363\",\n \"0.48118383\",\n \"0.47956577\",\n \"0.4792985\",\n \"0.47909433\",\n \"0.4781549\",\n \"0.4780083\",\n \"0.47780254\",\n \"0.47763658\",\n \"0.47754413\",\n \"0.47699142\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.64970756"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14697,"cells":{"query":{"kind":"string","value":"removes nodes from graph in they are in communities smaller than n"},"document":{"kind":"string","value":"def drop_small_communities(graph, communities, n=4):\n for community in communities:\n if len(community) < n:\n nx_helpers.remove_nodes(graph, community)\n communities = [c for c in communities if len(c) >= n]\n return graph, communities"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def keep_important_nodes(graph, number_of_nodes):\n sorted_dict = np.array(\n [\n [k, v]\n for k, v in sorted(\n dict(graph.degree()).items(),\n key=lambda item: item[1],\n )\n ]\n )\n use_nodes = sorted_dict[-number_of_nodes:, 0]\n graph = graph.subgraph(use_nodes)\n return graph","def remove_node(self, n):\r\n keys = self.d.keys()\r\n #check for node in graph\r\n if n not in keys:\r\n raise KeyError(str(n) + \" is not in graph\")\r\n self.d.pop(n)\r\n #discard each occurence of node in the values of others\r\n for k in keys:\r\n edges = self.d[k]\r\n new = edges.discard(n)","def prune(neuron,\n number_of_nodes):\n n = len(neuron.nodes_list)\n for i in range(n - number_of_nodes):\n index = shortest_tips(neuron)\n neuron = remove_node(neuron, index)\n return neuron","def remove_nodes_connections(self, nodes):\n nodes = ensure_list(nodes)\n for nd in nodes:\n for nd_in in self.successors[nd.name]:\n self.predecessors[nd_in.name].remove(nd)\n self.edges.remove((nd, nd_in))\n self.successors.pop(nd.name)\n self.predecessors.pop(nd.name)\n self._node_wip.remove(nd)","def remove(n, c, dnodecomm):\n\n _tot[c] -= k[n]\n _in[c] -= 2 * dnodecomm + network[n][n]\n bl[n] = -1","def eliminate_var(n, g,clq_ind,tree):\r\n l = len(clq_ind) # number of nodes eliminated\r\n \r\n new_ind = scipy.array(g.neighbors(n))\r\n new_clique = g.neighbors(n)\r\n new_clique.append(n) \r\n g.add_edges_from( combinations(new_clique,2) )\r\n \r\n for i,clq in enumerate(clq_ind):\r\n if n in clq:\r\n tree.add_edge(l,i)\r\n clq_ind[i] = scipy.setdiff1d(clq,new_clique)\r\n \r\n clq_ind.append(new_ind)\r\n g.remove_node(n)\r\n tree.node[l]['clique'] = new_clique","def largest_connected_components(adj, n_components=1):\n _, component_indices = connected_components(adj)\n component_sizes = np.bincount(component_indices)\n components_to_keep = np.argsort(component_sizes)[::-1][:n_components] # reverse order to sort descending\n nodes_to_keep = [\n idx for (idx, component) in enumerate(component_indices) if component in components_to_keep\n ]\n return nodes_to_keep","def exclude_nodes_GC(G):\n remove, present = [], []\n # Find giant component\n Gcc = sorted(nx.connected_component_subgraphs(G), key = len, reverse=True)\n G0 = Gcc[0]\n for node in G.nodes():\n if node not in G0.nodes():\n remove.append(node)\n G0.add_node(node,GC= 0)\n else:\n present.append(node)\n G0.add_node(node, GC= 1)\n # Remove nodes not in giant component\n remove_outliers = [node for node in G.nodes() if node not in G0.nodes()]\n G.remove_nodes_from(remove_outliers)\n return G","def disconnected_graph(n):\n g = nx.DiGraph()\n for i in range(0, n):\n g.add_node(i)\n return g","def remove_nodes(self, count=1):\n for i in range(count):\n dead_guy = self.all_nodes.pop()\n self.log.info(\"Removing node %s\" % dead_guy.name)\n dead_guy.decommission()\n self.log.info(\"Client %s is removed\" % dead_guy.name)\n self.save_cluster()\n self.inject_hosts_files()","def trim_cluster( g, cluster, num_edges ) :\n edges = []\n for e in cluster :\n r = sorted( g.edges( e, data = True ), lambda x, y : cmp_edge( g, x, y ) )\n edges.extend( r[-num_edges:] )\n\n sg = networkx.Graph( networkx.subgraph( g, cluster ) )\n for e in sg.edges() :\n sg[e[0]][e[1]][\"reversed_similarity\"] = -sg[e[0]][e[1]][\"similarity\"]\n\n mst_edges = networkx.minimum_spanning_edges( sg, \"reversed_similarity\" )\n \n edges = [(e[0], e[1],) for e in edges ]\n edges += [(e[0], e[1],) for e in mst_edges]\n del_edges = []\n for e in g.edges( cluster ) :\n if (e not in edges and (e[1], e[0],) not in edges) :\n del_edges.append( e )\n g.remove_edges_from( del_edges )\n return g","def prune_network(network):\n rand_int = np.random.random_integers\n num_rxns = len(network.reactions)\n num_cmpds = len(network.compounds)\n total = 0\n prune = list()\n for rxn in network.reactions:\n in_deg = network.in_degree(rxn)\n out_deg = network.out_degree(rxn)\n if in_deg == 0:\n if out_deg <= 1:\n prune.append(rxn)\n else:\n targets = network.successors(rxn)\n flips = rand_int(1, len(targets) - 1)\n while (flips > 0):\n target = targets[rand_int(0, len(targets) - 1)]\n factor = network[rxn][target][\"coefficient\"]\n network.remove_edge(rxn, target)\n network.add_edge(target, rxn, coefficient=factor)\n LOGGER.debug(\"flipped direction of link %s -> %s\",\n str(rxn), str(target))\n targets.remove(target)\n flips -= 1\n total += 1\n elif out_deg == 0:\n if in_deg <= 1:\n prune.append(rxn)\n else:\n targets = network.predecessors(rxn)\n flips = rand_int(1, len(targets) - 1)\n while (flips > 0):\n target = targets[rand_int(0, len(targets) - 1)]\n factor = network[target][rxn][\"coefficient\"]\n network.remove_edge(target, rxn)\n network.add_edge(rxn, target, coefficient=factor)\n LOGGER.debug(\"flipped direction of link %s -> %s\",\n str(rxn), str(target))\n targets.remove(target)\n flips -= 1\n total += 1\n for rxn in prune:\n network.remove_node(rxn)\n LOGGER.debug(\"removed reaction %s\", str(rxn))\n prune = list()\n for cmpd in network.compounds:\n if network.degree(cmpd) == 0:\n prune.append(cmpd)\n for cmpd in prune:\n network.remove_node(cmpd)\n LOGGER.debug(\"removed compound %s\", str(cmpd))\n LOGGER.info(\"%d reaction(s) and %d compound(s) removed\",\n (num_rxns - len(network.reactions)),\n (num_cmpds - len(network.compounds)))\n LOGGER.info(\"direction of %d link(s) reversed\", total)","def disconnect_nodes(self):\n for src_id, trg_id in itertools.product(self.selected_nodes, repeat=2):\n if src_id != trg_id:\n # `discard` ignores non-existing elements (unlike `remove`)\n app.edges[src_id].discard(trg_id)\n self.mark_as_unsaved()\n self.update()","def remove_nodes_from(self, nodes):\n for node in nodes:\n self.remove_node(node)","def _pair_based_graph_cut(self, graph):\n for node in self._find_paired_nodes(graph):\n graph.remove_node(node)\n return","def exclude_nodes_degree(G, min_degree):\n remove = [node for (node, degree) in G.degree().items() if degree < min_degree]\n G.remove_nodes_from(remove)\n #remove new nodes without edges\n remove_zero_degree = [node for (node, degree) in G.degree().items() if degree == 0]\n G.remove_nodes_from(remove_zero_degree)\n return G","def delete_node_cascade(self,n):\n # list will get mutated - copy preemptively\n for j in list(self.node_to_edges(n)):\n self.delete_edge_cascade(j)\n self.delete_node(n)","def remove_previous_connections(self, nodes):\n nodes = ensure_list(nodes)\n for nd in nodes:\n for nd_out in self.predecessors[nd.name]:\n if nd_out.name in self.successors:\n self.successors[nd_out.name].remove(nd)\n self.edges.remove((nd_out, nd))\n self.successors.pop(nd.name)\n self.predecessors.pop(nd.name)\n self._node_wip.remove(nd)","def clean_edges(self):\n for from_node in self.all_nodes():\n for to_node in self.all_nodes():\n if from_node == to_node:\n continue\n dup = list(filter(lambda x: x.from_node == from_node and x.to_node == to_node, self.edges))\n if len(dup) > 1:\n for d in dup[1:]:\n self.edges.remove(d)","def filter_graph(self, sorted_node, ploidy):\n \n for node in sorted_node:\n \n # while number of prefix edge > ploidy level\n while len(self.prefix[node]) > ploidy:\n min_weight_node = min(self.prefix[node], key=self.prefix[node].get)\n self.remove_edge(min_weight_node, node)\n \n # while number of suffix edge > ploidy level\n while len(self.suffix[node]) > ploidy:\n min_weight_node = min(self.suffix[node], key=self.suffix[node].get)\n self.remove_edge(node, min_weight_node)\n \n print(\"Graph is reduced to best overlap graph.\")","def exclude_nodes(self, nodes):","def repress_node_removal_old(graph, active_nodes):\n # list_active = list(active_nodes)\n num_neighbors = {node: len(list(graph.neighbors(node))) for node in active_nodes}\n total_neighbors = sum(num_neighbors.values())\n to_remove = set()\n for node in active_nodes:\n if np.random.random() < num_neighbors[node] / total_neighbors:\n to_remove.add(node)\n # only remove nodes at end so that probabilities are from the same time\n graph.remove_nodes_from(to_remove)\n active_nodes -= to_remove","def make_complete_graph(num_nodes):\n complete_digraph = {}\n if num_nodes > 0 and type(num_nodes) == int:\n neighbors = set([idx for idx in range(num_nodes)])\n for idx in range(num_nodes):\n complete_digraph[idx] = neighbors.copy() #creates adjacency set\n complete_digraph[idx].remove(idx) # pop out self-loop \n return complete_digraph","def delete_orphan_nodes(self):\n used=np.zeros( self.Nnodes(),'b1')\n valid_cells=~self.cells['deleted']\n valid_nodes=self.cells['nodes'][valid_cells,:].ravel()\n valid_nodes=valid_nodes[ valid_nodes>=0 ]\n used[ valid_nodes ]=True\n\n valid_edges=~self.edges['deleted']\n valid_nodes=self.edges['nodes'][valid_edges,:].ravel()\n used[ valid_nodes ]=True\n \n self.log.info(\"%d nodes found to be orphans\"%np.sum(~used))\n\n for n in np.nonzero(~used)[0]:\n self.delete_node(n)","def run_removing_edges(self):\n indices = np.where(self.X==1)\n idx=[]\n for i in range(len(indices[0])):\n idx.append((indices[0][i],indices[1][i]))\n idx = np.array(idx)\n return self.node_equivalent(idx)","def cutoff_graph( g, simi_cutoff ) :\n g = copy.deepcopy( g )\n edges_to_be_deleted = []\n for e in g.edges() :\n if (g[e[0]][e[1]][\"similarity\"] < simi_cutoff) :\n edges_to_be_deleted.append( e )\n g.remove_edges_from( edges_to_be_deleted )\n return g","def remove_nodes(model: onnx.ModelProto,\n predicate: Callable) -> onnx.ModelProto:\n # ! this doesn't handle inputs/outputs\n logger = get_root_logger()\n while True:\n connect = None\n for i, node in enumerate(model.graph.node):\n if predicate(node):\n assert len(node.input) == 1\n assert len(node.output) == 1\n connect = (node.input[0], node.output[0])\n logger.info(f'remove node {node.name}')\n del model.graph.node[i]\n break\n if not connect:\n break\n src, dst = connect\n for node in model.graph.node:\n for i, input in enumerate(node.input):\n if input == dst:\n node.input[i] = src\n return model","def _prune_unreached(self):\n swcdict = {}\n for n in self._data: # Hash all the swc nodes\n swcdict[n[0]] = Node(n[0])\n\n # Try to join all the unconnected branches at first\n for i, n in enumerate(self._data):\n if n[6] not in swcdict:\n # Try to match it\n matched, midx = self.match(n[2:5], n[5])\n if matched:\n self._data[i, 6] = self._data[midx, 0]\n\n # Add mutual links for all nodes\n for n in self._data:\n id = n[0]\n pid = n[6]\n if pid >= 0:\n swcdict[id].add_link(swcdict[pid])\n\n groups = connected_components(set(swcdict.values()))\n lenlist = [len(g) for g in groups]\n maxidx = lenlist.index(max(lenlist))\n set2keep = groups[maxidx]\n id2keep = [n.id for n in set2keep]\n self._data = self._data[np.in1d(self._data[:, 0], np.asarray(id2keep)), :]","def remove_nodes(self, nodes):\n for node in nodes:\n for arc in node.entries:\n arc.src.exits.remove(arc)\n self.arcs.remove(arc)\n for arc in node.exits:\n arc.dest.entries.remove(arc)\n self.arcs.remove(arc)\n self.nodes.remove(node)\n dangling_nodes = []\n for node in self.nodes:\n if node == self.start or node == self.end:\n pass\n else:\n if not node.exits or not node.entries:\n dangling_nodes.append(node)\n if dangling_nodes:\n self.remove_nodes(dangling_nodes)","def disconnect_lowest_ecc(G, num_remove):\n num_removed = []\n spectral_gap = []\n\n g = G.copy()\n vs = np.random.choice(list(g.nodes()), num_remove, replace=False)\n for i, v in enumerate(vs):\n neighbors = list(g.neighbors(v))\n if len(neighbors) == 0:\n continue\n ecc = np.array([nx.eccentricity(G, n) for n in neighbors])\n remove = np.argmin(ecc)\n g.remove_edge(v, neighbors[remove])\n\n num_removed.append(i)\n spectral_gap.append(get_spectral_gap(g))\n\n return num_removed, spectral_gap","def remove_nei(self, key: int):\r\n if self.has_nei(key):\r\n self.neighbors.pop(key)","def prune_to(self, names, merge_monotomies=True):\n self.prune_to_nodes(self.get_nodes(names), merge_monotomies)","def make_complete_graph(num_nodes):\n #initialize empty graph\n complete_graph = {}\n #consider each vertex\n for vertex in range(num_nodes):\n #add vertex with list of neighbours\n complete_graph[vertex] = list(set([j for j in range(num_nodes) if j != vertex]))\n return complete_graph","def matching_graph(n):\r\n k_n = nx.complete_graph(n)\r\n G = nx.Graph()\r\n for i in k_n.edges():\r\n G.add_node(i)\r\n w = []\r\n for i in k_n.edges():\r\n for j in k_n.edges():\r\n if ((j[0] not in i) and (j[1] not in i) and ((i,j) not in w) and ((j,i) not in w)): \r\n w.append((i,j))\r\n G.add_edge(i,j)\r\n return G","def prune_unlinked(self):\n linked_ids = set()\n for (link_from, link_to, link_style, link_tail) in self.links:\n linked_ids.add(link_from)\n linked_ids.add(link_to)\n nodes_to_delete = []\n for name, node in self.nodes.items():\n if node.node_id not in linked_ids:\n nodes_to_delete.append(name)\n for name in nodes_to_delete:\n del self.nodes[name]","def make_complete_graph(num_nodes):\n # initialize empty graph\n complete_graph = {}\n # consider each vertex\n for vertex in range(num_nodes):\n # add vertex with list of neighbours\n complete_graph[vertex] = set([j for j in range(num_nodes) if j != vertex])\n return complete_graph","def reduce_inbound_connections(inbound_counts, nodes):\n nodes_without_inbound = []\n for node in nodes:\n inbound_counts[node] = inbound_counts[node] - 1\n if inbound_counts[node] == 0:\n nodes_without_inbound.append(node)\n return nodes_without_inbound","def complete_graph(n):\n return wgraph_from_adjacency(np.ones((n, n)))","def remove_node(name):\n for file_path in config_files + [node_config_file]:\n with open(file_path, 'r') as f:\n lines = f.readlines()\n\n new_lines = []\n for line in lines:\n if name not in line:\n new_lines.append(line)\n\n with open(file_path, 'w') as f:\n f.writelines(new_lines)\n\n topology_file = Settings.CONF_TOPOLOGY_FILE\n if topology_file != \"\":\n topology_file_path = os.path.join(simulaqron_path, topology_file)\n else:\n topology_file_path = default_topology_file\n\n with open(topology_file_path, 'r') as f:\n topology = json.load(f)\n\n if name in topology:\n topology.pop(name)\n\n for node, neighbors in topology.items():\n if name in neighbors:\n neighbors.remove(name)\n\n with open(topology_file_path, 'w') as f:\n json.dump(topology, f)","def trim_unconnected_components(self):\n\n subgraphs = sorted(\n nx.connected_component_subgraphs(self.graph),\n key=len, reverse=True\n )\n\n self.graph = subgraphs[0]","def delete_node(self,n):\n if self._node_to_edges is not None:\n if len(self._node_to_edges[n])>0:\n print( \"Node %d has edges: %s\"%(n,self._node_to_edges[n]) )\n raise GridException(\"Node still has edges referring to it\")\n del self._node_to_edges[n]\n if self._node_to_cells is not None:\n if len(self._node_to_cells[n])>0:\n raise GridException(\"Node still has cells referring to it\")\n del self._node_to_cells[n]\n if self._node_index is not None:\n self._node_index.delete(n, self.nodes['x'][n,self.xxyy] )\n\n self.push_op(self.undelete_node,n,self.nodes[n].copy())\n\n self.nodes['deleted'][n] = True\n \n # special case, used for undo, reverts to previous state\n # more completely.\n if len(self.nodes)==n+1:\n self.nodes=self.nodes[:-1]","def remove_stuck(traj,size):\n from numpy import sqrt, where\n \n r_min = traj.groupby('particle').first()\n r_max = traj.groupby('particle').last()\n\n pos_columns = ['x','y']\n dist = r_min[pos_columns] - r_max[pos_columns]\n dist_eu = sqrt(dist['x']**2+dist['y']**2)\n\n index_remove = dist_eu.index[where(dist_eu < size)]\n \n traj_new = traj\n for i in range(len(index_remove)):\n traj_new = traj_new[(traj_new['particle'] != index_remove[i])]\n \n return traj_new","def remove_node(self, node):\n self.nodes.pop(self.nodes.index(node))\n node1 = node.neighbour1\n node2 = node.neighbour2\n node1.neighbour2 = node2\n node2.neighbour1 = node1","def remove_edges(self, node: NodeKey) -> Edge:","def remove_node(self, node):\n affected_nodes = [v for u, v in self.edges() if u == node]\n\n for affected_node in affected_nodes:\n node_cpd = self.get_cpds(node=affected_node)\n if node_cpd:\n node_cpd.marginalize([node], inplace=True)\n\n if self.get_cpds(node=node):\n self.remove_cpds(node)\n super(BayesianModel, self).remove_node(node)","def nonconnected():\n nonconnected = nx.MultiDiGraph()\n nonconnected.add_nodes_from(range(6))\n nonconnected.add_edges_from([\n (0, 1),\n (1, 2),\n (2, 3),\n (3, 0),\n (1, 0),\n (1, 0),\n (3, 2),\n (3, 3),\n (4, 4),\n (4, 4)\n ])\n return nonconnected","def on_prune(self, function_graph, node, reason):","def make_complete_graph(num_nodes):\n graph = {}\n for dummy_node in range(num_nodes):\n graph[dummy_node] = set([dummy_x for dummy_x in range(num_nodes)])\n graph[dummy_node].remove(dummy_node)\n return graph","def make_complete_graph(num_nodes):\n graph = {}\n for dummy_node in range(num_nodes):\n graph[dummy_node] = set([dummy_x for dummy_x in range(num_nodes)])\n graph[dummy_node].remove(dummy_node)\n return graph","def remove_stems(graph = None):\n\tfor x,y in basepairs(graph = graph):\n\t\tgraph.remove_node(x)\n\t\tgraph.remove_node(y)","def cleanGraph(self,graph):\n i=0\n while i+1<len(graph):\n if self.getDistance(graph[i],graph[i+1])==0:\n del graph[i+1]\n else:\n i+=1\n return graph","def node_to_nodes(self,n):\n js = self.node_to_edges(n)\n all_nodes = self.edges['nodes'][js].ravel()\n # return np.setdiff1d(all_nodes,[n]) # significantly slower than lists\n return np.array( [nbr for nbr in all_nodes if nbr!=n] )","def cut_ppl_off(self, G):\r\n for pre, node in list(G.edges):\r\n ew = G.edges[pre, node]['weight']\r\n if ew <= -.95:\r\n G.remove_edge(pre, node)\r\n elif ew >= 1:\r\n G.edges[pre, node]['weight'] = 1.0\r\n else:\r\n continue\r\n return G","def clean_edges(self):","def remove_node(self, node):\n # if the node is a part of the graph\n if node.get_name() in self.get_node_names():\n for edge in node.get_incident_edges(): # for every edge incident to the input node\n other_node = edge.get_other_node(node.get_name()) # get the other incident node object\n if other_node.get_name() in self.get_node_names(): # if the other node is a part of the graph\n self.remove_edge(tuple((node, other_node))) # remove the edge\n self.set_nodeset(\n set({\n vertex\n for vertex in self.get_nodeset()\n if not vertex.get_name().__eq__(node.get_name())\n })\n ) # remove the node from the graph's nodeset","def eliminiateEmptyEdges(self, distance = 100):\n print \"Edge elimination started\"\n \n selected_edge_ids = []\n # let us \n \n for point in self.gps_points:\n results = self.idx.nearest(((point.getPoint().x-distance/2), \n (point.getPoint().y-distance/2),\n (point.getPoint().x+distance/2),\n (point.getPoint().y+distance/2)), objects=True)\n for result in results:\n from_node = self.node_counter__node.get(result.object.from_node.getAttributes().get(\"nodecounter\"))\n to_node = self.node_counter__node.get(result.object.to_node.getAttributes().get(\"nodecounter\"))\n edge_counter = self.G.edge[from_node][to_node].get(\"edgecounter\")\n if edge_counter not in selected_edge_ids:\n selected_edge_ids.append(edge_counter)\n print str(len(selected_edge_ids)) + \" edges found to keep.\"\n \n elimination_counter = 0\n for edge in self.G.edges():\n edgecounter = self.G.edge[edge[0]][edge[1]].get(\"edgecounter\")\n if edgecounter not in selected_edge_ids:\n edge_tuple = (self.G.edge[edge[0]][edge[1]].get(\"edge\").from_node, self.G.edge[edge[0]][edge[1]].get(\"edge\").to_node)\n self.G.remove_edge(*edge_tuple)\n elimination_counter = elimination_counter + 1\n \n print str(elimination_counter) + \" edges eliminated.\"","def remove_temporary_nodes(board_id):\n q1 = \"MATCH (n)-[r]-() WHERE n.board = {0} DELETE n, r\".format(board_id)\n q2 = \"MATCH n WHERE n.board = {0} DELETE n\".format(board_id)\n neo4j.CypherQuery(GRAPH_DB, q1).execute_one()\n neo4j.CypherQuery(GRAPH_DB, q2).execute_one()","def remove_nodes(self, nodes, check_ready=True):\n nodes = ensure_list(nodes)\n for nd in nodes:\n if nd not in self.nodes:\n raise Exception(f\"{nd} is not present in the graph\")\n if self.predecessors[nd.name] and check_ready:\n raise Exception(\"this node shoudn't be run, has to wait\")\n self.nodes.remove(nd)\n # adding the node to self._node_wip as for\n self._node_wip.append(nd)\n # if graph is sorted, the sorted list has to be updated\n if hasattr(self, \"sorted_nodes\"):\n if nodes == self.sorted_nodes[: len(nodes)]:\n # if the first node is removed, no need to sort again\n self._sorted_nodes = self.sorted_nodes[len(nodes) :]\n else:\n for nd in nodes:\n self._sorted_nodes.remove(nd)\n # starting from the previous sorted list, so is faster\n self.sorting(presorted=self.sorted_nodes)","def prune(self, n_leaves):\n true_node_count = self.node_count - sum(self.children_left == _tree.TREE_UNDEFINED)\n leaves = np.where(self.children_left == _tree.TREE_LEAF)[0]\n to_remove_count = true_node_count - 2*n_leaves + 1\n\n nodes_to_remove = pruning_order(self, max_to_prune = to_remove_count/2)\n\n # self._copy is gone, but this does the same thing\n out_tree = _tree.Tree(*self.__reduce__()[1])\n out_tree.__setstate__(self.__getstate__().copy())\n\n for node in nodes_to_remove:\n #TODO: Add a Tree method to remove a branch of a tree\n out_tree.children_left[out_tree.children_left[node]] = _tree.TREE_UNDEFINED\n out_tree.children_right[out_tree.children_left[node]] = _tree.TREE_UNDEFINED\n out_tree.children_left[out_tree.children_right[node]] = _tree.TREE_UNDEFINED\n out_tree.children_right[out_tree.children_right[node]] = _tree.TREE_UNDEFINED\n out_tree.children_left[node] = _tree.TREE_LEAF\n out_tree.children_right[node] = _tree.TREE_LEAF\n\n # FIXME: currently should not change node_count, after deletion\n # this is not number of nodes in the tree\n #out_tree.node_count -= 2*len(nodes_to_remove)\n\n return out_tree","def task1(graph, n):\r\n alreadyProcessed = set()\r\n B = [j for j in range(1,n+1)]\r\n position = {B[i]:i for i in range(len(B))}\r\n leftNeighbors = {}\r\n parent = {}\r\n \r\n for v in B:\r\n # nodes processed before the current that have an edge in common are left neighbors\r\n leftNeighbors[v] = set(graph._graph[v]) & alreadyProcessed\r\n alreadyProcessed.add(v)\r\n if leftNeighbors[v]:\r\n # the parent is the closest left neighbor \r\n parent[v] = B[max([position[w] for w in leftNeighbors[v]])]\r\n # if this node's neighbors (other then the parent itself) are not a subset of the parent's neighbors \r\n # it means that it's not a lexOrder\r\n if not leftNeighbors[v] - {parent[v]} <= leftNeighbors[parent[v]]:\r\n return []\r\n return B","def make_complete_graph(num_nodes):\r\n result = {}\r\n for idx in range(0,num_nodes):\r\n result[idx] = set([])\r\n for jdx in range(0,num_nodes):\r\n if (idx!=jdx):\r\n result[idx].add(jdx)\r\n return result","def onnx_remove_node_unused(onnx_model, recursive=True, debug_info=None, **options):\r\n if debug_info is None:\r\n debug_info = [str(type(onnx_model)).rsplit(\r\n '.', maxsplit=1)[-1].strip(\"'>\")]\r\n else:\r\n debug_info = (debug_info +\r\n [str(type(onnx_model)).rsplit('.', maxsplit=1)[-1].strip(\"'>\")])\r\n\r\n if hasattr(onnx_model, 'graph'):\r\n return _apply_optimisation_on_graph(\r\n onnx_remove_node_unused, onnx_model,\r\n recursive=recursive, debug_info=debug_info,\r\n **options)\r\n\r\n graph = onnx_model\r\n data = {}\r\n valid = {}\r\n edges = {}\r\n\r\n for init in graph.initializer:\r\n data[init.name, 0] = init\r\n\r\n for node in graph.node:\r\n data[node.name, 1] = node\r\n for inp in node.input:\r\n data[inp, 0] = node\r\n edges[(inp, 0), (node.name, 1)] = node\r\n for out in node.output:\r\n data[out, 0] = node\r\n edges[(node.name, 1), (out, 0)] = node\r\n\r\n for out in graph.output:\r\n valid[out.name, 0] = True\r\n\r\n modif = 1\r\n while modif > 0:\r\n modif = 0\r\n for e1, e2 in edges: # pylint: disable=E1141\r\n if valid.get(e2, False) and not valid.get(e1, False):\r\n valid[e1] = True\r\n modif += 1\r\n\r\n new_nodes = [n for n in graph.node if (n.name, 1) in valid]\r\n new_inits = [n for n in graph.initializer if (n.name, 0) in valid]\r\n\r\n if recursive:\r\n # Handles subgraphs.\r\n for i in range(len(new_nodes)): # pylint: disable=C0200\r\n node = new_nodes[i]\r\n if node is None or not (node.attribute): # pylint: disable=C0325\r\n continue\r\n new_nodes[i] = _apply_remove_node_fct_node(\r\n onnx_remove_node_unused,\r\n node, recursive=True, debug_info=debug_info + [node.name])\r\n\r\n # Finally create the new graph.\r\n nodes = list(filter(lambda n: n is not None, new_nodes))\r\n graph = make_graph(nodes, onnx_model.name,\r\n onnx_model.input, onnx_model.output,\r\n new_inits)\r\n\r\n graph.value_info.extend(onnx_model.value_info) # pylint: disable=E1101\r\n return graph","def remove_successors_nodes(self, node):\n self._successors_all = []\n self._checking_successors_nodes(node=node, remove=False)\n self.remove_nodes_connections(nodes=node)\n nodes_removed = []\n for nd in self._successors_all:\n if nd in self.nodes:\n nodes_removed.append(nd.name)\n self.remove_nodes(nodes=nd, check_ready=False)\n self.remove_previous_connections(nodes=nd)\n return set(nodes_removed)","def repress_edge_removal(graph, active_nodes, repression_rate):\n for node in active_nodes:\n neighbors = list(graph[node].keys())\n remove_which = np.random.binomial(1, repression_rate, size=(len(neighbors)))\n for idx in range(len(neighbors)):\n if remove_which[idx]:\n graph.remove_edge(node, neighbors[idx])","def repress_node_removal(graph, active_nodes, repression_rate, centralities):\n to_remove = set()\n active = list(active_nodes) # order needed for weights to match\n # TODO: make this more modular?\n # prob propto: norm(degrees) + (1-norm(thresholds))\n degrees = np.array([centralities[node] for node in active_nodes])\n degrees /= max(degrees)\n thresholds = np.array(\n [graph.nodes[node][\"agent\"].threshold for node in active_nodes]\n )\n thresholds /= max(thresholds)\n thresholds = [1 - threshold for threshold in thresholds]\n combined = degrees + thresholds\n probs = combined / sum(combined)\n num_to_remove = int(repression_rate * len(active))\n to_remove = set(np.random.choice(active, num_to_remove, replace=False, p=probs))\n # only remove nodes at end so that probabilities are from the same time\n graph.remove_nodes_from(to_remove)\n active_nodes -= to_remove","def exclude_nodes(self, nodes):\n raise self.Error('qadapter failed to exclude nodes, not implemented yet in sge')","def make_complete_graph(num_nodes):\r\n if num_nodes < 1:\r\n return dict()\r\n else:\r\n new_dict = dict()\r\n for node in range(num_nodes):\r\n other_nodes = range(num_nodes)\r\n other_nodes.pop(node)\r\n new_dict[node]=set(other_nodes)\r\n return new_dict","def test_graph_deletes_nodes(graph_with_edges):\n graph_with_edges.del_nodes('B')\n listy = ['A', 'C', 'D', 'E', 'F']\n for node in listy:\n assert node in graph_with_edges.nodes()\n assert 'B' not in graph_with_edges.nodes()","def delete_small_trajectories(trajectories, best_parameters):\n print('Filtering small trajectories...', end = ' ')\n size = best_parameters['min_size']\n pop_ind =[]\n for k, trajectory in enumerate(trajectories):\n traj = vis.get_points(trajectory)\n if len(np.unique(traj, axis = 0))<=size:\n pop_ind.append(k)\n for index in sorted(pop_ind, reverse = True):\n del trajectories[index]\n print('Done.')","def removeZeroDegreeNodes(self):\n nodesToRemove = []\n for node in self.hashtagGraph.nodes_iter(): \n if (self.hashtagGraph.degree(node) == 0):\n nodesToRemove.append(node)\n if (len(nodesToRemove) > 0):\n self.hashtagGraph.remove_nodes_from(nodesToRemove)","def trim_qgraph(qgraph):\n node_degree = defaultdict(int)\n for edge in qgraph['edges']:\n node_degree[edge['source_id']] += 1\n node_degree[edge['target_id']] += 1\n for node in qgraph['nodes']:\n if node.get('curie', None):\n node_degree[node['id']] = BIG_NUMBER\n edge_importance = {\n edge['id']: node_degree[edge['source_id']] + node_degree[edge['target_id']]\n for edge in qgraph['edges']\n }\n min_importance = min(edge_importance.values())\n if min_importance >= BIG_NUMBER:\n return\n for edge in qgraph['edges']:\n if edge_importance[edge['id']] == min_importance:\n yield {\n 'nodes': qgraph['nodes'],\n 'edges': [e for e in qgraph['edges'] if e['id'] != edge['id']]\n }\n # TODO: remove orphaned nodes","def del_node(self, n):\n try:\n del self.dict[n]\n # remove edges pointing to n\n for key, value in self.dict.iteritems():\n if n in value:\n del self.dict[key][n]\n except (ValueError, KeyError):\n raise AttributeError('No Such Node Exists')","def elide_node(self,n):\n \n js=self.node_to_edges(n)\n assert len(js)==2\n # have to copy this, as the original gets modified by delete\n cs=list(self.node_to_cells(n))\n assert len(cs)<=2\n # second edge is totally removed:\n cell_nodes=[self.cell_to_nodes(c) for c in cs]\n for c in cs:\n self.delete_cell(c)\n new_edge_nodes=[nn\n for nn in self.edges['nodes'][js].ravel()\n if nn!=n]\n self.delete_edge(js[1])\n self.modify_edge(js[0],nodes=new_edge_nodes)\n for c,nodes in zip(cs,cell_nodes):\n nodes=[nn for nn in nodes if nn!=n]\n self.add_cell(_index=c,nodes=nodes)\n self.delete_node(n)","def make_complete_graph(num_nodes):\r\n if num_nodes <= 0:\r\n return dict()\r\n else:\r\n all_nodes_list = [node for node in range(num_nodes)]\r\n tmp_graph = dict()\r\n for node in range(num_nodes):\r\n adjacent_nodes_list = all_nodes_list[:]\r\n adjacent_nodes_list.remove(node)\r\n tmp_graph.update({node: set(adjacent_nodes_list)})\r\n return tmp_graph","def disturb_cluster(n, offset, edges, deletion_factor, optimal_costs):\n rand_edges = rand.permutation(edges.shape[0])\n vertexwise_del_edges = np.zeros(n, dtype=np.int64)\n max_edges_out = deletion_factor * n\n i = 0\n\n for e in rand_edges:\n weight = 1\n # if both vertices can have one more edge deleted...\n if ((vertexwise_del_edges[edges[e][0]-offset] + 1) <= max_edges_out and\n (vertexwise_del_edges[edges[e][1]-offset] + 1) <= max_edges_out):\n # set edge weight to -1\n weight = -1\n optimal_costs[0] += 1\n # count deleted edges for both vertices\n vertexwise_del_edges[edges[e][0]-offset] += 1\n vertexwise_del_edges[edges[e][1]-offset] += 1\n i += 1\n print(edges[e][0], edges[e][1], weight)","def _mout_edges(nodes):\n n = nodes.shape[0]\n edges = []\n for i in range(0, n - 1):\n for j in range(i, n):\n if abs(nodes[i, 0] - nodes[j, 0]) > 1:\n break\n elif abs(nodes[i, 0] - nodes[j, 0]) == 1 and \\\n abs(nodes[i, 1] - nodes[j, 1]) == 0:\n edges.append([i, j])\n elif abs(nodes[i, 1] - nodes[j, 1]) == 1:\n edges.append([i, j])\n return edges","def destroyNodes(self):\r\n for nt in self.listNodes.keys(): \t# for all kind of nodes...\r\n for node in self.listNodes[nt]: \t# for all nodes of type <nt>\r\n if node.graphObject_: node.graphObject_.destroy()","def custom_exponenital_graph(popsize, ncontacts, scale=100):\n print(\"Generating contact graph...\")\n graph = nx.barabasi_albert_graph(popsize, ncontacts)\n\n #Randomly delete nodes\n print(\"Excluding edges from graph...\")\n for node in graph:\n neighbors = list(graph[node].keys())\n num_to_keep = int(min(np.random.exponential(scale=scale, size=1),\n len(neighbors)))\n neighbors_to_keep = np.random.choice(neighbors,\n size=num_to_keep,\n replace=False)\n for neighbor in neighbors:\n if neighbor not in neighbors_to_keep:\n graph.remove_edge(node, neighbor)\n\n return graph","def exact_min_vertex_cover(graph):\n for N in range(1,len(graph.nodes())+1):\n for graph_sub in it.combinations(sorted(graph.nodes(), reverse=True), N):\n graph_temp = graph.copy()\n graph_temp.remove_nodes_from(graph_sub)\n if len(graph_temp.edges()) == 0:\n return list(graph_sub)","def complement_of_cycle(n):\n return complement(nx.cycle_graph(n))","def disconnect_2highest_deg(G, num_remove):\n num_removed = []\n spectral_gap = []\n\n g = G.copy()\n vs = np.random.choice(list(g.nodes()), num_remove, replace=False)\n for i, v in enumerate(vs):\n neighbors = list(g.neighbors(v))\n if len(neighbors) == 0:\n continue\n max_degree = []\n for n in neighbors:\n nneigh = g.neighbors(n)\n degrees = np.array([g.degree(n) for n in nneigh])\n max_degree.append(np.argmax(degrees))\n remove = np.argmax(max_degree)\n g.remove_edge(v, neighbors[remove])\n\n num_removed.append(i)\n spectral_gap.append(get_spectral_gap(g))\n\n return num_removed, spectral_gap","def remove_nodes(self, properties, **kwargs):\r\n\t\traise NotImplementedError","def nodes_with_m_nbrs(G,m):\n nodes = set()\n \n # Iterate over all nodes in G\n for n in G.nodes():\n \n # Check if the number of neighbors of n matches m\n if len(G.neighbors(n)) == m:\n \n # Add the node n to the set\n nodes.add(n)\n \n # Return the nodes with m neighbors\n return nodes","def k_truss(G, k):\n H = G.copy()\n\n n_dropped = 1\n while n_dropped > 0:\n n_dropped = 0\n to_drop = []\n seen = set()\n for u in H:\n nbrs_u = set(H[u])\n seen.add(u)\n new_nbrs = [v for v in nbrs_u if v not in seen]\n for v in new_nbrs:\n if len(nbrs_u & set(H[v])) < (k - 2):\n to_drop.append((u, v))\n H.remove_edges_from(to_drop)\n n_dropped = len(to_drop)\n H.remove_nodes_from(list(nx.isolates(H)))\n\n return H","def prune_to_nodes(self, nodes, merge_monotomies=True):\n to_remove = self.leaves - set(nodes) # This is sufficient to erode all unwanted internal nodes.\n for node in to_remove:\n self.remove_tree_node(node)\n parent = node.parent\n if parent in nodes:\n continue # Only happens if the user wants to keep an internal node.\n elif merge_monotomies and len(parent.children) == 1:\n sib = parent.children[0]\n if parent != self.root:\n # node.parent only has 1 child, so it's removed and node's sib is connected to node's grandparent.\n sib.branch += parent.branch\n par_index = parent.parent.children.index(parent)\n parent.parent.children[par_index] = sib\n sib.parent = parent.parent\n else:\n # self.root now has only 1 child, so it's replaced by that child.\n self.root = sib\n self.root.branch = 0\n self.remove_tree_node(parent, remove_from_parent=False)\n self.process_tree_nodes()","def _prune(self, idx):\n idx = list(idx)\n neurons = []\n for nold in self.neurons:\n k = nold[1] # number of neurons\n ix1 = [i for i in idx if i < k] # index for current neuron type\n idx = [i-k for i in idx if i >= k]\n func = nold[0]\n number = len(ix1)\n W = nold[2][:, ix1]\n bias = nold[3][ix1]\n neurons.append((func, number, W, bias))\n self.neurons = neurons","def remove_possibles(self):\n for row in range(self.board_size):\n for col in range(self.board_size):\n self.remove_poss(row, col)","def _removeEdgesNodes(self, curNode):\n\n # Figure out all edges to be removed first then take them out of the temp graph\n # then remove all the nodes from the temp graph.\n # At the start the temp graph is equal to the initial graph.\n\n self.deletedEdges = set()\n self.deletedNodes = set()\n kNodes = self.kPath.nodeList\n index = 0\n tempNode = kNodes[index]\n index += 1\n while tempNode != curNode:\n edges = self.tempG.edges(tempNode)\n if len(edges) != 0:\n for edge in edges:\n self.deletedEdges.add(edge)\n self.tempG.remove_edge(edge[0], edge[1])\n\n #\n\n self.deletedNodes.add(tempNode)\n self.tempG.remove_node(tempNode)\n tempNode = kNodes[index]\n index += 1\n\n # Also need to remove those old deleted edges that start on curNode\n\n oldDelEdges = self.kPath.deletedEdges\n if self.g.is_directed():\n outEdges = self.g.out_edges(curNode)\n else:\n outEdges = self.g.edges(curNode)\n\n # outEdges = self.g.edges(curNode)\n\n for e in outEdges:\n if e in oldDelEdges:\n self.deletedEdges.add(e)\n self.tempG.remove_edge(e[0], e[1])\n\n # Now delete the edge from the curNode to the next in the path\n\n tempNode = kNodes[index]\n e = (curNode, tempNode)\n self.deletedEdges.add(e)\n self.tempG.remove_edge(curNode, tempNode)","def prune_influence_map(self):\n im = self.get_im()\n\n # First, remove all self-loops\n logger.info('Removing self loops')\n edges_to_remove = []\n for e in im.edges():\n if e[0] == e[1]:\n logger.info('Removing self loop: %s', e)\n edges_to_remove.append((e[0], e[1]))\n # Now remove all the edges to be removed with a single call\n im.remove_edges_from(edges_to_remove)\n\n # Remove parameter nodes from influence map\n remove_im_params(self.model, im)\n\n # Now compare nodes pairwise and look for overlap between child nodes\n logger.info('Get successors of each node')\n succ_dict = {}\n for node in im.nodes():\n succ_dict[node] = set(im.successors(node))\n # Sort and then group nodes by number of successors\n logger.info('Compare combinations of successors')\n group_key_fun = lambda x: len(succ_dict[x])\n nodes_sorted = sorted(im.nodes(), key=group_key_fun)\n groups = itertools.groupby(nodes_sorted, key=group_key_fun)\n # Now iterate over each group and then construct combinations\n # within the group to check for shared sucessors\n edges_to_remove = []\n for gix, group in groups:\n combos = itertools.combinations(group, 2)\n for ix, (p1, p2) in enumerate(combos):\n # Children are identical except for mutual relationship\n if succ_dict[p1].difference(succ_dict[p2]) == set([p2]) and \\\n succ_dict[p2].difference(succ_dict[p1]) == set([p1]):\n for u, v in ((p1, p2), (p2, p1)):\n edges_to_remove.append((u, v))\n logger.debug('Will remove edge (%s, %s)', u, v)\n logger.info('Removing %d edges from influence map' %\n len(edges_to_remove))\n # Now remove all the edges to be removed with a single call\n im.remove_edges_from(edges_to_remove)","def make_complete_graph (num_nodes) :\n graph = dict ()\n if (num_nodes < 1) :\n return graph\n\n for node_ind in range (num_nodes) :\n # create a set containing nodes adjacent to node node_ind\n # node node_ind of the complete graph will have edges to all other nodes except itself\n adj_nodes = range (num_nodes) # list containing numbers from 0 - num_nodes-1\n adj_nodes.remove(node_ind)\n graph[node_ind] = set(adj_nodes)\n\n return graph","def remove_neighbor(self):\n self.fono -= 1","def removeNeighbor(self, neighborID):","def delete_node(ugraph, node):\r\n neighbors = ugraph[node]\r\n ugraph.pop(node)\r\n for neighbor in neighbors:\r\n ugraph[neighbor].remove(node)","def remove_topk_nodes(adj, node_importance_rank, topk):\n for idx in node_importance_rank[:topk]:\n for i in range(adj.shape[0]):\n adj[i, idx] = 0\n adj[idx, i] = 0\n\n return adj","def _remove_dangling_downstream_nodes(\n node: p_pb2.PipelineNode,\n node_ids_to_keep: Collection[str]) -> p_pb2.PipelineNode:\n # Using a loop instead of set intersection to ensure the same order.\n downstream_nodes_to_keep = [\n downstream_node for downstream_node in node.downstream_nodes\n if downstream_node in node_ids_to_keep\n ]\n if len(downstream_nodes_to_keep) == len(node.downstream_nodes):\n return node\n result = p_pb2.PipelineNode()\n result.CopyFrom(node)\n result.downstream_nodes[:] = downstream_nodes_to_keep\n return result","def _delete_edges(self, to_be_deleted_set, adj_dict):\n for pair in to_be_deleted_set:\n first_node = pair[0]\n second_node = pair[1]\n adj_dict.pop((first_node, second_node), None)","def pop_nodes(self, count):\n log.debug('Removing {} Request nodes.'.format(count))\n self.beginRemoveRows(QModelIndex(), 0, count-1)\n if len(self.root_item.children) > 0:\n self.root_item.children = self.root_item.children[count:]\n self.endRemoveRows()","def agents_cleanup(agents, n) -> set:\n return set(agent for agent in agents if agent[0] < n and agent[1] < n)","def trim_edges(self, keep=0.5):\n\n for tid1, tid2 in self.graph.edges():\n if random.random() > keep:\n self.graph.remove_edge(tid1, tid2)","def fix_graph(self,graph):\n graph_compleate_reachable = False\n while not graph_compleate_reachable:\n not_reachable_in ,not_reachable_out = self.not_reachable(graph)\n for n in not_reachable_in:\n graph.add_edge(self.random.randint(0,n-1),n)\n for n in not_reachable_out:\n graph.add_edge(n,self.random.randint(n+1, self.nodes-1))\n graph_compleate_reachable = len(not_reachable_in)==0 and len(not_reachable_out)==0\n return graph"],"string":"[\n \"def keep_important_nodes(graph, number_of_nodes):\\n sorted_dict = np.array(\\n [\\n [k, v]\\n for k, v in sorted(\\n dict(graph.degree()).items(),\\n key=lambda item: item[1],\\n )\\n ]\\n )\\n use_nodes = sorted_dict[-number_of_nodes:, 0]\\n graph = graph.subgraph(use_nodes)\\n return graph\",\n \"def remove_node(self, n):\\r\\n keys = self.d.keys()\\r\\n #check for node in graph\\r\\n if n not in keys:\\r\\n raise KeyError(str(n) + \\\" is not in graph\\\")\\r\\n self.d.pop(n)\\r\\n #discard each occurence of node in the values of others\\r\\n for k in keys:\\r\\n edges = self.d[k]\\r\\n new = edges.discard(n)\",\n \"def prune(neuron,\\n number_of_nodes):\\n n = len(neuron.nodes_list)\\n for i in range(n - number_of_nodes):\\n index = shortest_tips(neuron)\\n neuron = remove_node(neuron, index)\\n return neuron\",\n \"def remove_nodes_connections(self, nodes):\\n nodes = ensure_list(nodes)\\n for nd in nodes:\\n for nd_in in self.successors[nd.name]:\\n self.predecessors[nd_in.name].remove(nd)\\n self.edges.remove((nd, nd_in))\\n self.successors.pop(nd.name)\\n self.predecessors.pop(nd.name)\\n self._node_wip.remove(nd)\",\n \"def remove(n, c, dnodecomm):\\n\\n _tot[c] -= k[n]\\n _in[c] -= 2 * dnodecomm + network[n][n]\\n bl[n] = -1\",\n \"def eliminate_var(n, g,clq_ind,tree):\\r\\n l = len(clq_ind) # number of nodes eliminated\\r\\n \\r\\n new_ind = scipy.array(g.neighbors(n))\\r\\n new_clique = g.neighbors(n)\\r\\n new_clique.append(n) \\r\\n g.add_edges_from( combinations(new_clique,2) )\\r\\n \\r\\n for i,clq in enumerate(clq_ind):\\r\\n if n in clq:\\r\\n tree.add_edge(l,i)\\r\\n clq_ind[i] = scipy.setdiff1d(clq,new_clique)\\r\\n \\r\\n clq_ind.append(new_ind)\\r\\n g.remove_node(n)\\r\\n tree.node[l]['clique'] = new_clique\",\n \"def largest_connected_components(adj, n_components=1):\\n _, component_indices = connected_components(adj)\\n component_sizes = np.bincount(component_indices)\\n components_to_keep = np.argsort(component_sizes)[::-1][:n_components] # reverse order to sort descending\\n nodes_to_keep = [\\n idx for (idx, component) in enumerate(component_indices) if component in components_to_keep\\n ]\\n return nodes_to_keep\",\n \"def exclude_nodes_GC(G):\\n remove, present = [], []\\n # Find giant component\\n Gcc = sorted(nx.connected_component_subgraphs(G), key = len, reverse=True)\\n G0 = Gcc[0]\\n for node in G.nodes():\\n if node not in G0.nodes():\\n remove.append(node)\\n G0.add_node(node,GC= 0)\\n else:\\n present.append(node)\\n G0.add_node(node, GC= 1)\\n # Remove nodes not in giant component\\n remove_outliers = [node for node in G.nodes() if node not in G0.nodes()]\\n G.remove_nodes_from(remove_outliers)\\n return G\",\n \"def disconnected_graph(n):\\n g = nx.DiGraph()\\n for i in range(0, n):\\n g.add_node(i)\\n return g\",\n \"def remove_nodes(self, count=1):\\n for i in range(count):\\n dead_guy = self.all_nodes.pop()\\n self.log.info(\\\"Removing node %s\\\" % dead_guy.name)\\n dead_guy.decommission()\\n self.log.info(\\\"Client %s is removed\\\" % dead_guy.name)\\n self.save_cluster()\\n self.inject_hosts_files()\",\n \"def trim_cluster( g, cluster, num_edges ) :\\n edges = []\\n for e in cluster :\\n r = sorted( g.edges( e, data = True ), lambda x, y : cmp_edge( g, x, y ) )\\n edges.extend( r[-num_edges:] )\\n\\n sg = networkx.Graph( networkx.subgraph( g, cluster ) )\\n for e in sg.edges() :\\n sg[e[0]][e[1]][\\\"reversed_similarity\\\"] = -sg[e[0]][e[1]][\\\"similarity\\\"]\\n\\n mst_edges = networkx.minimum_spanning_edges( sg, \\\"reversed_similarity\\\" )\\n \\n edges = [(e[0], e[1],) for e in edges ]\\n edges += [(e[0], e[1],) for e in mst_edges]\\n del_edges = []\\n for e in g.edges( cluster ) :\\n if (e not in edges and (e[1], e[0],) not in edges) :\\n del_edges.append( e )\\n g.remove_edges_from( del_edges )\\n return g\",\n \"def prune_network(network):\\n rand_int = np.random.random_integers\\n num_rxns = len(network.reactions)\\n num_cmpds = len(network.compounds)\\n total = 0\\n prune = list()\\n for rxn in network.reactions:\\n in_deg = network.in_degree(rxn)\\n out_deg = network.out_degree(rxn)\\n if in_deg == 0:\\n if out_deg <= 1:\\n prune.append(rxn)\\n else:\\n targets = network.successors(rxn)\\n flips = rand_int(1, len(targets) - 1)\\n while (flips > 0):\\n target = targets[rand_int(0, len(targets) - 1)]\\n factor = network[rxn][target][\\\"coefficient\\\"]\\n network.remove_edge(rxn, target)\\n network.add_edge(target, rxn, coefficient=factor)\\n LOGGER.debug(\\\"flipped direction of link %s -> %s\\\",\\n str(rxn), str(target))\\n targets.remove(target)\\n flips -= 1\\n total += 1\\n elif out_deg == 0:\\n if in_deg <= 1:\\n prune.append(rxn)\\n else:\\n targets = network.predecessors(rxn)\\n flips = rand_int(1, len(targets) - 1)\\n while (flips > 0):\\n target = targets[rand_int(0, len(targets) - 1)]\\n factor = network[target][rxn][\\\"coefficient\\\"]\\n network.remove_edge(target, rxn)\\n network.add_edge(rxn, target, coefficient=factor)\\n LOGGER.debug(\\\"flipped direction of link %s -> %s\\\",\\n str(rxn), str(target))\\n targets.remove(target)\\n flips -= 1\\n total += 1\\n for rxn in prune:\\n network.remove_node(rxn)\\n LOGGER.debug(\\\"removed reaction %s\\\", str(rxn))\\n prune = list()\\n for cmpd in network.compounds:\\n if network.degree(cmpd) == 0:\\n prune.append(cmpd)\\n for cmpd in prune:\\n network.remove_node(cmpd)\\n LOGGER.debug(\\\"removed compound %s\\\", str(cmpd))\\n LOGGER.info(\\\"%d reaction(s) and %d compound(s) removed\\\",\\n (num_rxns - len(network.reactions)),\\n (num_cmpds - len(network.compounds)))\\n LOGGER.info(\\\"direction of %d link(s) reversed\\\", total)\",\n \"def disconnect_nodes(self):\\n for src_id, trg_id in itertools.product(self.selected_nodes, repeat=2):\\n if src_id != trg_id:\\n # `discard` ignores non-existing elements (unlike `remove`)\\n app.edges[src_id].discard(trg_id)\\n self.mark_as_unsaved()\\n self.update()\",\n \"def remove_nodes_from(self, nodes):\\n for node in nodes:\\n self.remove_node(node)\",\n \"def _pair_based_graph_cut(self, graph):\\n for node in self._find_paired_nodes(graph):\\n graph.remove_node(node)\\n return\",\n \"def exclude_nodes_degree(G, min_degree):\\n remove = [node for (node, degree) in G.degree().items() if degree < min_degree]\\n G.remove_nodes_from(remove)\\n #remove new nodes without edges\\n remove_zero_degree = [node for (node, degree) in G.degree().items() if degree == 0]\\n G.remove_nodes_from(remove_zero_degree)\\n return G\",\n \"def delete_node_cascade(self,n):\\n # list will get mutated - copy preemptively\\n for j in list(self.node_to_edges(n)):\\n self.delete_edge_cascade(j)\\n self.delete_node(n)\",\n \"def remove_previous_connections(self, nodes):\\n nodes = ensure_list(nodes)\\n for nd in nodes:\\n for nd_out in self.predecessors[nd.name]:\\n if nd_out.name in self.successors:\\n self.successors[nd_out.name].remove(nd)\\n self.edges.remove((nd_out, nd))\\n self.successors.pop(nd.name)\\n self.predecessors.pop(nd.name)\\n self._node_wip.remove(nd)\",\n \"def clean_edges(self):\\n for from_node in self.all_nodes():\\n for to_node in self.all_nodes():\\n if from_node == to_node:\\n continue\\n dup = list(filter(lambda x: x.from_node == from_node and x.to_node == to_node, self.edges))\\n if len(dup) > 1:\\n for d in dup[1:]:\\n self.edges.remove(d)\",\n \"def filter_graph(self, sorted_node, ploidy):\\n \\n for node in sorted_node:\\n \\n # while number of prefix edge > ploidy level\\n while len(self.prefix[node]) > ploidy:\\n min_weight_node = min(self.prefix[node], key=self.prefix[node].get)\\n self.remove_edge(min_weight_node, node)\\n \\n # while number of suffix edge > ploidy level\\n while len(self.suffix[node]) > ploidy:\\n min_weight_node = min(self.suffix[node], key=self.suffix[node].get)\\n self.remove_edge(node, min_weight_node)\\n \\n print(\\\"Graph is reduced to best overlap graph.\\\")\",\n \"def exclude_nodes(self, nodes):\",\n \"def repress_node_removal_old(graph, active_nodes):\\n # list_active = list(active_nodes)\\n num_neighbors = {node: len(list(graph.neighbors(node))) for node in active_nodes}\\n total_neighbors = sum(num_neighbors.values())\\n to_remove = set()\\n for node in active_nodes:\\n if np.random.random() < num_neighbors[node] / total_neighbors:\\n to_remove.add(node)\\n # only remove nodes at end so that probabilities are from the same time\\n graph.remove_nodes_from(to_remove)\\n active_nodes -= to_remove\",\n \"def make_complete_graph(num_nodes):\\n complete_digraph = {}\\n if num_nodes > 0 and type(num_nodes) == int:\\n neighbors = set([idx for idx in range(num_nodes)])\\n for idx in range(num_nodes):\\n complete_digraph[idx] = neighbors.copy() #creates adjacency set\\n complete_digraph[idx].remove(idx) # pop out self-loop \\n return complete_digraph\",\n \"def delete_orphan_nodes(self):\\n used=np.zeros( self.Nnodes(),'b1')\\n valid_cells=~self.cells['deleted']\\n valid_nodes=self.cells['nodes'][valid_cells,:].ravel()\\n valid_nodes=valid_nodes[ valid_nodes>=0 ]\\n used[ valid_nodes ]=True\\n\\n valid_edges=~self.edges['deleted']\\n valid_nodes=self.edges['nodes'][valid_edges,:].ravel()\\n used[ valid_nodes ]=True\\n \\n self.log.info(\\\"%d nodes found to be orphans\\\"%np.sum(~used))\\n\\n for n in np.nonzero(~used)[0]:\\n self.delete_node(n)\",\n \"def run_removing_edges(self):\\n indices = np.where(self.X==1)\\n idx=[]\\n for i in range(len(indices[0])):\\n idx.append((indices[0][i],indices[1][i]))\\n idx = np.array(idx)\\n return self.node_equivalent(idx)\",\n \"def cutoff_graph( g, simi_cutoff ) :\\n g = copy.deepcopy( g )\\n edges_to_be_deleted = []\\n for e in g.edges() :\\n if (g[e[0]][e[1]][\\\"similarity\\\"] < simi_cutoff) :\\n edges_to_be_deleted.append( e )\\n g.remove_edges_from( edges_to_be_deleted )\\n return g\",\n \"def remove_nodes(model: onnx.ModelProto,\\n predicate: Callable) -> onnx.ModelProto:\\n # ! this doesn't handle inputs/outputs\\n logger = get_root_logger()\\n while True:\\n connect = None\\n for i, node in enumerate(model.graph.node):\\n if predicate(node):\\n assert len(node.input) == 1\\n assert len(node.output) == 1\\n connect = (node.input[0], node.output[0])\\n logger.info(f'remove node {node.name}')\\n del model.graph.node[i]\\n break\\n if not connect:\\n break\\n src, dst = connect\\n for node in model.graph.node:\\n for i, input in enumerate(node.input):\\n if input == dst:\\n node.input[i] = src\\n return model\",\n \"def _prune_unreached(self):\\n swcdict = {}\\n for n in self._data: # Hash all the swc nodes\\n swcdict[n[0]] = Node(n[0])\\n\\n # Try to join all the unconnected branches at first\\n for i, n in enumerate(self._data):\\n if n[6] not in swcdict:\\n # Try to match it\\n matched, midx = self.match(n[2:5], n[5])\\n if matched:\\n self._data[i, 6] = self._data[midx, 0]\\n\\n # Add mutual links for all nodes\\n for n in self._data:\\n id = n[0]\\n pid = n[6]\\n if pid >= 0:\\n swcdict[id].add_link(swcdict[pid])\\n\\n groups = connected_components(set(swcdict.values()))\\n lenlist = [len(g) for g in groups]\\n maxidx = lenlist.index(max(lenlist))\\n set2keep = groups[maxidx]\\n id2keep = [n.id for n in set2keep]\\n self._data = self._data[np.in1d(self._data[:, 0], np.asarray(id2keep)), :]\",\n \"def remove_nodes(self, nodes):\\n for node in nodes:\\n for arc in node.entries:\\n arc.src.exits.remove(arc)\\n self.arcs.remove(arc)\\n for arc in node.exits:\\n arc.dest.entries.remove(arc)\\n self.arcs.remove(arc)\\n self.nodes.remove(node)\\n dangling_nodes = []\\n for node in self.nodes:\\n if node == self.start or node == self.end:\\n pass\\n else:\\n if not node.exits or not node.entries:\\n dangling_nodes.append(node)\\n if dangling_nodes:\\n self.remove_nodes(dangling_nodes)\",\n \"def disconnect_lowest_ecc(G, num_remove):\\n num_removed = []\\n spectral_gap = []\\n\\n g = G.copy()\\n vs = np.random.choice(list(g.nodes()), num_remove, replace=False)\\n for i, v in enumerate(vs):\\n neighbors = list(g.neighbors(v))\\n if len(neighbors) == 0:\\n continue\\n ecc = np.array([nx.eccentricity(G, n) for n in neighbors])\\n remove = np.argmin(ecc)\\n g.remove_edge(v, neighbors[remove])\\n\\n num_removed.append(i)\\n spectral_gap.append(get_spectral_gap(g))\\n\\n return num_removed, spectral_gap\",\n \"def remove_nei(self, key: int):\\r\\n if self.has_nei(key):\\r\\n self.neighbors.pop(key)\",\n \"def prune_to(self, names, merge_monotomies=True):\\n self.prune_to_nodes(self.get_nodes(names), merge_monotomies)\",\n \"def make_complete_graph(num_nodes):\\n #initialize empty graph\\n complete_graph = {}\\n #consider each vertex\\n for vertex in range(num_nodes):\\n #add vertex with list of neighbours\\n complete_graph[vertex] = list(set([j for j in range(num_nodes) if j != vertex]))\\n return complete_graph\",\n \"def matching_graph(n):\\r\\n k_n = nx.complete_graph(n)\\r\\n G = nx.Graph()\\r\\n for i in k_n.edges():\\r\\n G.add_node(i)\\r\\n w = []\\r\\n for i in k_n.edges():\\r\\n for j in k_n.edges():\\r\\n if ((j[0] not in i) and (j[1] not in i) and ((i,j) not in w) and ((j,i) not in w)): \\r\\n w.append((i,j))\\r\\n G.add_edge(i,j)\\r\\n return G\",\n \"def prune_unlinked(self):\\n linked_ids = set()\\n for (link_from, link_to, link_style, link_tail) in self.links:\\n linked_ids.add(link_from)\\n linked_ids.add(link_to)\\n nodes_to_delete = []\\n for name, node in self.nodes.items():\\n if node.node_id not in linked_ids:\\n nodes_to_delete.append(name)\\n for name in nodes_to_delete:\\n del self.nodes[name]\",\n \"def make_complete_graph(num_nodes):\\n # initialize empty graph\\n complete_graph = {}\\n # consider each vertex\\n for vertex in range(num_nodes):\\n # add vertex with list of neighbours\\n complete_graph[vertex] = set([j for j in range(num_nodes) if j != vertex])\\n return complete_graph\",\n \"def reduce_inbound_connections(inbound_counts, nodes):\\n nodes_without_inbound = []\\n for node in nodes:\\n inbound_counts[node] = inbound_counts[node] - 1\\n if inbound_counts[node] == 0:\\n nodes_without_inbound.append(node)\\n return nodes_without_inbound\",\n \"def complete_graph(n):\\n return wgraph_from_adjacency(np.ones((n, n)))\",\n \"def remove_node(name):\\n for file_path in config_files + [node_config_file]:\\n with open(file_path, 'r') as f:\\n lines = f.readlines()\\n\\n new_lines = []\\n for line in lines:\\n if name not in line:\\n new_lines.append(line)\\n\\n with open(file_path, 'w') as f:\\n f.writelines(new_lines)\\n\\n topology_file = Settings.CONF_TOPOLOGY_FILE\\n if topology_file != \\\"\\\":\\n topology_file_path = os.path.join(simulaqron_path, topology_file)\\n else:\\n topology_file_path = default_topology_file\\n\\n with open(topology_file_path, 'r') as f:\\n topology = json.load(f)\\n\\n if name in topology:\\n topology.pop(name)\\n\\n for node, neighbors in topology.items():\\n if name in neighbors:\\n neighbors.remove(name)\\n\\n with open(topology_file_path, 'w') as f:\\n json.dump(topology, f)\",\n \"def trim_unconnected_components(self):\\n\\n subgraphs = sorted(\\n nx.connected_component_subgraphs(self.graph),\\n key=len, reverse=True\\n )\\n\\n self.graph = subgraphs[0]\",\n \"def delete_node(self,n):\\n if self._node_to_edges is not None:\\n if len(self._node_to_edges[n])>0:\\n print( \\\"Node %d has edges: %s\\\"%(n,self._node_to_edges[n]) )\\n raise GridException(\\\"Node still has edges referring to it\\\")\\n del self._node_to_edges[n]\\n if self._node_to_cells is not None:\\n if len(self._node_to_cells[n])>0:\\n raise GridException(\\\"Node still has cells referring to it\\\")\\n del self._node_to_cells[n]\\n if self._node_index is not None:\\n self._node_index.delete(n, self.nodes['x'][n,self.xxyy] )\\n\\n self.push_op(self.undelete_node,n,self.nodes[n].copy())\\n\\n self.nodes['deleted'][n] = True\\n \\n # special case, used for undo, reverts to previous state\\n # more completely.\\n if len(self.nodes)==n+1:\\n self.nodes=self.nodes[:-1]\",\n \"def remove_stuck(traj,size):\\n from numpy import sqrt, where\\n \\n r_min = traj.groupby('particle').first()\\n r_max = traj.groupby('particle').last()\\n\\n pos_columns = ['x','y']\\n dist = r_min[pos_columns] - r_max[pos_columns]\\n dist_eu = sqrt(dist['x']**2+dist['y']**2)\\n\\n index_remove = dist_eu.index[where(dist_eu < size)]\\n \\n traj_new = traj\\n for i in range(len(index_remove)):\\n traj_new = traj_new[(traj_new['particle'] != index_remove[i])]\\n \\n return traj_new\",\n \"def remove_node(self, node):\\n self.nodes.pop(self.nodes.index(node))\\n node1 = node.neighbour1\\n node2 = node.neighbour2\\n node1.neighbour2 = node2\\n node2.neighbour1 = node1\",\n \"def remove_edges(self, node: NodeKey) -> Edge:\",\n \"def remove_node(self, node):\\n affected_nodes = [v for u, v in self.edges() if u == node]\\n\\n for affected_node in affected_nodes:\\n node_cpd = self.get_cpds(node=affected_node)\\n if node_cpd:\\n node_cpd.marginalize([node], inplace=True)\\n\\n if self.get_cpds(node=node):\\n self.remove_cpds(node)\\n super(BayesianModel, self).remove_node(node)\",\n \"def nonconnected():\\n nonconnected = nx.MultiDiGraph()\\n nonconnected.add_nodes_from(range(6))\\n nonconnected.add_edges_from([\\n (0, 1),\\n (1, 2),\\n (2, 3),\\n (3, 0),\\n (1, 0),\\n (1, 0),\\n (3, 2),\\n (3, 3),\\n (4, 4),\\n (4, 4)\\n ])\\n return nonconnected\",\n \"def on_prune(self, function_graph, node, reason):\",\n \"def make_complete_graph(num_nodes):\\n graph = {}\\n for dummy_node in range(num_nodes):\\n graph[dummy_node] = set([dummy_x for dummy_x in range(num_nodes)])\\n graph[dummy_node].remove(dummy_node)\\n return graph\",\n \"def make_complete_graph(num_nodes):\\n graph = {}\\n for dummy_node in range(num_nodes):\\n graph[dummy_node] = set([dummy_x for dummy_x in range(num_nodes)])\\n graph[dummy_node].remove(dummy_node)\\n return graph\",\n \"def remove_stems(graph = None):\\n\\tfor x,y in basepairs(graph = graph):\\n\\t\\tgraph.remove_node(x)\\n\\t\\tgraph.remove_node(y)\",\n \"def cleanGraph(self,graph):\\n i=0\\n while i+1<len(graph):\\n if self.getDistance(graph[i],graph[i+1])==0:\\n del graph[i+1]\\n else:\\n i+=1\\n return graph\",\n \"def node_to_nodes(self,n):\\n js = self.node_to_edges(n)\\n all_nodes = self.edges['nodes'][js].ravel()\\n # return np.setdiff1d(all_nodes,[n]) # significantly slower than lists\\n return np.array( [nbr for nbr in all_nodes if nbr!=n] )\",\n \"def cut_ppl_off(self, G):\\r\\n for pre, node in list(G.edges):\\r\\n ew = G.edges[pre, node]['weight']\\r\\n if ew <= -.95:\\r\\n G.remove_edge(pre, node)\\r\\n elif ew >= 1:\\r\\n G.edges[pre, node]['weight'] = 1.0\\r\\n else:\\r\\n continue\\r\\n return G\",\n \"def clean_edges(self):\",\n \"def remove_node(self, node):\\n # if the node is a part of the graph\\n if node.get_name() in self.get_node_names():\\n for edge in node.get_incident_edges(): # for every edge incident to the input node\\n other_node = edge.get_other_node(node.get_name()) # get the other incident node object\\n if other_node.get_name() in self.get_node_names(): # if the other node is a part of the graph\\n self.remove_edge(tuple((node, other_node))) # remove the edge\\n self.set_nodeset(\\n set({\\n vertex\\n for vertex in self.get_nodeset()\\n if not vertex.get_name().__eq__(node.get_name())\\n })\\n ) # remove the node from the graph's nodeset\",\n \"def eliminiateEmptyEdges(self, distance = 100):\\n print \\\"Edge elimination started\\\"\\n \\n selected_edge_ids = []\\n # let us \\n \\n for point in self.gps_points:\\n results = self.idx.nearest(((point.getPoint().x-distance/2), \\n (point.getPoint().y-distance/2),\\n (point.getPoint().x+distance/2),\\n (point.getPoint().y+distance/2)), objects=True)\\n for result in results:\\n from_node = self.node_counter__node.get(result.object.from_node.getAttributes().get(\\\"nodecounter\\\"))\\n to_node = self.node_counter__node.get(result.object.to_node.getAttributes().get(\\\"nodecounter\\\"))\\n edge_counter = self.G.edge[from_node][to_node].get(\\\"edgecounter\\\")\\n if edge_counter not in selected_edge_ids:\\n selected_edge_ids.append(edge_counter)\\n print str(len(selected_edge_ids)) + \\\" edges found to keep.\\\"\\n \\n elimination_counter = 0\\n for edge in self.G.edges():\\n edgecounter = self.G.edge[edge[0]][edge[1]].get(\\\"edgecounter\\\")\\n if edgecounter not in selected_edge_ids:\\n edge_tuple = (self.G.edge[edge[0]][edge[1]].get(\\\"edge\\\").from_node, self.G.edge[edge[0]][edge[1]].get(\\\"edge\\\").to_node)\\n self.G.remove_edge(*edge_tuple)\\n elimination_counter = elimination_counter + 1\\n \\n print str(elimination_counter) + \\\" edges eliminated.\\\"\",\n \"def remove_temporary_nodes(board_id):\\n q1 = \\\"MATCH (n)-[r]-() WHERE n.board = {0} DELETE n, r\\\".format(board_id)\\n q2 = \\\"MATCH n WHERE n.board = {0} DELETE n\\\".format(board_id)\\n neo4j.CypherQuery(GRAPH_DB, q1).execute_one()\\n neo4j.CypherQuery(GRAPH_DB, q2).execute_one()\",\n \"def remove_nodes(self, nodes, check_ready=True):\\n nodes = ensure_list(nodes)\\n for nd in nodes:\\n if nd not in self.nodes:\\n raise Exception(f\\\"{nd} is not present in the graph\\\")\\n if self.predecessors[nd.name] and check_ready:\\n raise Exception(\\\"this node shoudn't be run, has to wait\\\")\\n self.nodes.remove(nd)\\n # adding the node to self._node_wip as for\\n self._node_wip.append(nd)\\n # if graph is sorted, the sorted list has to be updated\\n if hasattr(self, \\\"sorted_nodes\\\"):\\n if nodes == self.sorted_nodes[: len(nodes)]:\\n # if the first node is removed, no need to sort again\\n self._sorted_nodes = self.sorted_nodes[len(nodes) :]\\n else:\\n for nd in nodes:\\n self._sorted_nodes.remove(nd)\\n # starting from the previous sorted list, so is faster\\n self.sorting(presorted=self.sorted_nodes)\",\n \"def prune(self, n_leaves):\\n true_node_count = self.node_count - sum(self.children_left == _tree.TREE_UNDEFINED)\\n leaves = np.where(self.children_left == _tree.TREE_LEAF)[0]\\n to_remove_count = true_node_count - 2*n_leaves + 1\\n\\n nodes_to_remove = pruning_order(self, max_to_prune = to_remove_count/2)\\n\\n # self._copy is gone, but this does the same thing\\n out_tree = _tree.Tree(*self.__reduce__()[1])\\n out_tree.__setstate__(self.__getstate__().copy())\\n\\n for node in nodes_to_remove:\\n #TODO: Add a Tree method to remove a branch of a tree\\n out_tree.children_left[out_tree.children_left[node]] = _tree.TREE_UNDEFINED\\n out_tree.children_right[out_tree.children_left[node]] = _tree.TREE_UNDEFINED\\n out_tree.children_left[out_tree.children_right[node]] = _tree.TREE_UNDEFINED\\n out_tree.children_right[out_tree.children_right[node]] = _tree.TREE_UNDEFINED\\n out_tree.children_left[node] = _tree.TREE_LEAF\\n out_tree.children_right[node] = _tree.TREE_LEAF\\n\\n # FIXME: currently should not change node_count, after deletion\\n # this is not number of nodes in the tree\\n #out_tree.node_count -= 2*len(nodes_to_remove)\\n\\n return out_tree\",\n \"def task1(graph, n):\\r\\n alreadyProcessed = set()\\r\\n B = [j for j in range(1,n+1)]\\r\\n position = {B[i]:i for i in range(len(B))}\\r\\n leftNeighbors = {}\\r\\n parent = {}\\r\\n \\r\\n for v in B:\\r\\n # nodes processed before the current that have an edge in common are left neighbors\\r\\n leftNeighbors[v] = set(graph._graph[v]) & alreadyProcessed\\r\\n alreadyProcessed.add(v)\\r\\n if leftNeighbors[v]:\\r\\n # the parent is the closest left neighbor \\r\\n parent[v] = B[max([position[w] for w in leftNeighbors[v]])]\\r\\n # if this node's neighbors (other then the parent itself) are not a subset of the parent's neighbors \\r\\n # it means that it's not a lexOrder\\r\\n if not leftNeighbors[v] - {parent[v]} <= leftNeighbors[parent[v]]:\\r\\n return []\\r\\n return B\",\n \"def make_complete_graph(num_nodes):\\r\\n result = {}\\r\\n for idx in range(0,num_nodes):\\r\\n result[idx] = set([])\\r\\n for jdx in range(0,num_nodes):\\r\\n if (idx!=jdx):\\r\\n result[idx].add(jdx)\\r\\n return result\",\n \"def onnx_remove_node_unused(onnx_model, recursive=True, debug_info=None, **options):\\r\\n if debug_info is None:\\r\\n debug_info = [str(type(onnx_model)).rsplit(\\r\\n '.', maxsplit=1)[-1].strip(\\\"'>\\\")]\\r\\n else:\\r\\n debug_info = (debug_info +\\r\\n [str(type(onnx_model)).rsplit('.', maxsplit=1)[-1].strip(\\\"'>\\\")])\\r\\n\\r\\n if hasattr(onnx_model, 'graph'):\\r\\n return _apply_optimisation_on_graph(\\r\\n onnx_remove_node_unused, onnx_model,\\r\\n recursive=recursive, debug_info=debug_info,\\r\\n **options)\\r\\n\\r\\n graph = onnx_model\\r\\n data = {}\\r\\n valid = {}\\r\\n edges = {}\\r\\n\\r\\n for init in graph.initializer:\\r\\n data[init.name, 0] = init\\r\\n\\r\\n for node in graph.node:\\r\\n data[node.name, 1] = node\\r\\n for inp in node.input:\\r\\n data[inp, 0] = node\\r\\n edges[(inp, 0), (node.name, 1)] = node\\r\\n for out in node.output:\\r\\n data[out, 0] = node\\r\\n edges[(node.name, 1), (out, 0)] = node\\r\\n\\r\\n for out in graph.output:\\r\\n valid[out.name, 0] = True\\r\\n\\r\\n modif = 1\\r\\n while modif > 0:\\r\\n modif = 0\\r\\n for e1, e2 in edges: # pylint: disable=E1141\\r\\n if valid.get(e2, False) and not valid.get(e1, False):\\r\\n valid[e1] = True\\r\\n modif += 1\\r\\n\\r\\n new_nodes = [n for n in graph.node if (n.name, 1) in valid]\\r\\n new_inits = [n for n in graph.initializer if (n.name, 0) in valid]\\r\\n\\r\\n if recursive:\\r\\n # Handles subgraphs.\\r\\n for i in range(len(new_nodes)): # pylint: disable=C0200\\r\\n node = new_nodes[i]\\r\\n if node is None or not (node.attribute): # pylint: disable=C0325\\r\\n continue\\r\\n new_nodes[i] = _apply_remove_node_fct_node(\\r\\n onnx_remove_node_unused,\\r\\n node, recursive=True, debug_info=debug_info + [node.name])\\r\\n\\r\\n # Finally create the new graph.\\r\\n nodes = list(filter(lambda n: n is not None, new_nodes))\\r\\n graph = make_graph(nodes, onnx_model.name,\\r\\n onnx_model.input, onnx_model.output,\\r\\n new_inits)\\r\\n\\r\\n graph.value_info.extend(onnx_model.value_info) # pylint: disable=E1101\\r\\n return graph\",\n \"def remove_successors_nodes(self, node):\\n self._successors_all = []\\n self._checking_successors_nodes(node=node, remove=False)\\n self.remove_nodes_connections(nodes=node)\\n nodes_removed = []\\n for nd in self._successors_all:\\n if nd in self.nodes:\\n nodes_removed.append(nd.name)\\n self.remove_nodes(nodes=nd, check_ready=False)\\n self.remove_previous_connections(nodes=nd)\\n return set(nodes_removed)\",\n \"def repress_edge_removal(graph, active_nodes, repression_rate):\\n for node in active_nodes:\\n neighbors = list(graph[node].keys())\\n remove_which = np.random.binomial(1, repression_rate, size=(len(neighbors)))\\n for idx in range(len(neighbors)):\\n if remove_which[idx]:\\n graph.remove_edge(node, neighbors[idx])\",\n \"def repress_node_removal(graph, active_nodes, repression_rate, centralities):\\n to_remove = set()\\n active = list(active_nodes) # order needed for weights to match\\n # TODO: make this more modular?\\n # prob propto: norm(degrees) + (1-norm(thresholds))\\n degrees = np.array([centralities[node] for node in active_nodes])\\n degrees /= max(degrees)\\n thresholds = np.array(\\n [graph.nodes[node][\\\"agent\\\"].threshold for node in active_nodes]\\n )\\n thresholds /= max(thresholds)\\n thresholds = [1 - threshold for threshold in thresholds]\\n combined = degrees + thresholds\\n probs = combined / sum(combined)\\n num_to_remove = int(repression_rate * len(active))\\n to_remove = set(np.random.choice(active, num_to_remove, replace=False, p=probs))\\n # only remove nodes at end so that probabilities are from the same time\\n graph.remove_nodes_from(to_remove)\\n active_nodes -= to_remove\",\n \"def exclude_nodes(self, nodes):\\n raise self.Error('qadapter failed to exclude nodes, not implemented yet in sge')\",\n \"def make_complete_graph(num_nodes):\\r\\n if num_nodes < 1:\\r\\n return dict()\\r\\n else:\\r\\n new_dict = dict()\\r\\n for node in range(num_nodes):\\r\\n other_nodes = range(num_nodes)\\r\\n other_nodes.pop(node)\\r\\n new_dict[node]=set(other_nodes)\\r\\n return new_dict\",\n \"def test_graph_deletes_nodes(graph_with_edges):\\n graph_with_edges.del_nodes('B')\\n listy = ['A', 'C', 'D', 'E', 'F']\\n for node in listy:\\n assert node in graph_with_edges.nodes()\\n assert 'B' not in graph_with_edges.nodes()\",\n \"def delete_small_trajectories(trajectories, best_parameters):\\n print('Filtering small trajectories...', end = ' ')\\n size = best_parameters['min_size']\\n pop_ind =[]\\n for k, trajectory in enumerate(trajectories):\\n traj = vis.get_points(trajectory)\\n if len(np.unique(traj, axis = 0))<=size:\\n pop_ind.append(k)\\n for index in sorted(pop_ind, reverse = True):\\n del trajectories[index]\\n print('Done.')\",\n \"def removeZeroDegreeNodes(self):\\n nodesToRemove = []\\n for node in self.hashtagGraph.nodes_iter(): \\n if (self.hashtagGraph.degree(node) == 0):\\n nodesToRemove.append(node)\\n if (len(nodesToRemove) > 0):\\n self.hashtagGraph.remove_nodes_from(nodesToRemove)\",\n \"def trim_qgraph(qgraph):\\n node_degree = defaultdict(int)\\n for edge in qgraph['edges']:\\n node_degree[edge['source_id']] += 1\\n node_degree[edge['target_id']] += 1\\n for node in qgraph['nodes']:\\n if node.get('curie', None):\\n node_degree[node['id']] = BIG_NUMBER\\n edge_importance = {\\n edge['id']: node_degree[edge['source_id']] + node_degree[edge['target_id']]\\n for edge in qgraph['edges']\\n }\\n min_importance = min(edge_importance.values())\\n if min_importance >= BIG_NUMBER:\\n return\\n for edge in qgraph['edges']:\\n if edge_importance[edge['id']] == min_importance:\\n yield {\\n 'nodes': qgraph['nodes'],\\n 'edges': [e for e in qgraph['edges'] if e['id'] != edge['id']]\\n }\\n # TODO: remove orphaned nodes\",\n \"def del_node(self, n):\\n try:\\n del self.dict[n]\\n # remove edges pointing to n\\n for key, value in self.dict.iteritems():\\n if n in value:\\n del self.dict[key][n]\\n except (ValueError, KeyError):\\n raise AttributeError('No Such Node Exists')\",\n \"def elide_node(self,n):\\n \\n js=self.node_to_edges(n)\\n assert len(js)==2\\n # have to copy this, as the original gets modified by delete\\n cs=list(self.node_to_cells(n))\\n assert len(cs)<=2\\n # second edge is totally removed:\\n cell_nodes=[self.cell_to_nodes(c) for c in cs]\\n for c in cs:\\n self.delete_cell(c)\\n new_edge_nodes=[nn\\n for nn in self.edges['nodes'][js].ravel()\\n if nn!=n]\\n self.delete_edge(js[1])\\n self.modify_edge(js[0],nodes=new_edge_nodes)\\n for c,nodes in zip(cs,cell_nodes):\\n nodes=[nn for nn in nodes if nn!=n]\\n self.add_cell(_index=c,nodes=nodes)\\n self.delete_node(n)\",\n \"def make_complete_graph(num_nodes):\\r\\n if num_nodes <= 0:\\r\\n return dict()\\r\\n else:\\r\\n all_nodes_list = [node for node in range(num_nodes)]\\r\\n tmp_graph = dict()\\r\\n for node in range(num_nodes):\\r\\n adjacent_nodes_list = all_nodes_list[:]\\r\\n adjacent_nodes_list.remove(node)\\r\\n tmp_graph.update({node: set(adjacent_nodes_list)})\\r\\n return tmp_graph\",\n \"def disturb_cluster(n, offset, edges, deletion_factor, optimal_costs):\\n rand_edges = rand.permutation(edges.shape[0])\\n vertexwise_del_edges = np.zeros(n, dtype=np.int64)\\n max_edges_out = deletion_factor * n\\n i = 0\\n\\n for e in rand_edges:\\n weight = 1\\n # if both vertices can have one more edge deleted...\\n if ((vertexwise_del_edges[edges[e][0]-offset] + 1) <= max_edges_out and\\n (vertexwise_del_edges[edges[e][1]-offset] + 1) <= max_edges_out):\\n # set edge weight to -1\\n weight = -1\\n optimal_costs[0] += 1\\n # count deleted edges for both vertices\\n vertexwise_del_edges[edges[e][0]-offset] += 1\\n vertexwise_del_edges[edges[e][1]-offset] += 1\\n i += 1\\n print(edges[e][0], edges[e][1], weight)\",\n \"def _mout_edges(nodes):\\n n = nodes.shape[0]\\n edges = []\\n for i in range(0, n - 1):\\n for j in range(i, n):\\n if abs(nodes[i, 0] - nodes[j, 0]) > 1:\\n break\\n elif abs(nodes[i, 0] - nodes[j, 0]) == 1 and \\\\\\n abs(nodes[i, 1] - nodes[j, 1]) == 0:\\n edges.append([i, j])\\n elif abs(nodes[i, 1] - nodes[j, 1]) == 1:\\n edges.append([i, j])\\n return edges\",\n \"def destroyNodes(self):\\r\\n for nt in self.listNodes.keys(): \\t# for all kind of nodes...\\r\\n for node in self.listNodes[nt]: \\t# for all nodes of type <nt>\\r\\n if node.graphObject_: node.graphObject_.destroy()\",\n \"def custom_exponenital_graph(popsize, ncontacts, scale=100):\\n print(\\\"Generating contact graph...\\\")\\n graph = nx.barabasi_albert_graph(popsize, ncontacts)\\n\\n #Randomly delete nodes\\n print(\\\"Excluding edges from graph...\\\")\\n for node in graph:\\n neighbors = list(graph[node].keys())\\n num_to_keep = int(min(np.random.exponential(scale=scale, size=1),\\n len(neighbors)))\\n neighbors_to_keep = np.random.choice(neighbors,\\n size=num_to_keep,\\n replace=False)\\n for neighbor in neighbors:\\n if neighbor not in neighbors_to_keep:\\n graph.remove_edge(node, neighbor)\\n\\n return graph\",\n \"def exact_min_vertex_cover(graph):\\n for N in range(1,len(graph.nodes())+1):\\n for graph_sub in it.combinations(sorted(graph.nodes(), reverse=True), N):\\n graph_temp = graph.copy()\\n graph_temp.remove_nodes_from(graph_sub)\\n if len(graph_temp.edges()) == 0:\\n return list(graph_sub)\",\n \"def complement_of_cycle(n):\\n return complement(nx.cycle_graph(n))\",\n \"def disconnect_2highest_deg(G, num_remove):\\n num_removed = []\\n spectral_gap = []\\n\\n g = G.copy()\\n vs = np.random.choice(list(g.nodes()), num_remove, replace=False)\\n for i, v in enumerate(vs):\\n neighbors = list(g.neighbors(v))\\n if len(neighbors) == 0:\\n continue\\n max_degree = []\\n for n in neighbors:\\n nneigh = g.neighbors(n)\\n degrees = np.array([g.degree(n) for n in nneigh])\\n max_degree.append(np.argmax(degrees))\\n remove = np.argmax(max_degree)\\n g.remove_edge(v, neighbors[remove])\\n\\n num_removed.append(i)\\n spectral_gap.append(get_spectral_gap(g))\\n\\n return num_removed, spectral_gap\",\n \"def remove_nodes(self, properties, **kwargs):\\r\\n\\t\\traise NotImplementedError\",\n \"def nodes_with_m_nbrs(G,m):\\n nodes = set()\\n \\n # Iterate over all nodes in G\\n for n in G.nodes():\\n \\n # Check if the number of neighbors of n matches m\\n if len(G.neighbors(n)) == m:\\n \\n # Add the node n to the set\\n nodes.add(n)\\n \\n # Return the nodes with m neighbors\\n return nodes\",\n \"def k_truss(G, k):\\n H = G.copy()\\n\\n n_dropped = 1\\n while n_dropped > 0:\\n n_dropped = 0\\n to_drop = []\\n seen = set()\\n for u in H:\\n nbrs_u = set(H[u])\\n seen.add(u)\\n new_nbrs = [v for v in nbrs_u if v not in seen]\\n for v in new_nbrs:\\n if len(nbrs_u & set(H[v])) < (k - 2):\\n to_drop.append((u, v))\\n H.remove_edges_from(to_drop)\\n n_dropped = len(to_drop)\\n H.remove_nodes_from(list(nx.isolates(H)))\\n\\n return H\",\n \"def prune_to_nodes(self, nodes, merge_monotomies=True):\\n to_remove = self.leaves - set(nodes) # This is sufficient to erode all unwanted internal nodes.\\n for node in to_remove:\\n self.remove_tree_node(node)\\n parent = node.parent\\n if parent in nodes:\\n continue # Only happens if the user wants to keep an internal node.\\n elif merge_monotomies and len(parent.children) == 1:\\n sib = parent.children[0]\\n if parent != self.root:\\n # node.parent only has 1 child, so it's removed and node's sib is connected to node's grandparent.\\n sib.branch += parent.branch\\n par_index = parent.parent.children.index(parent)\\n parent.parent.children[par_index] = sib\\n sib.parent = parent.parent\\n else:\\n # self.root now has only 1 child, so it's replaced by that child.\\n self.root = sib\\n self.root.branch = 0\\n self.remove_tree_node(parent, remove_from_parent=False)\\n self.process_tree_nodes()\",\n \"def _prune(self, idx):\\n idx = list(idx)\\n neurons = []\\n for nold in self.neurons:\\n k = nold[1] # number of neurons\\n ix1 = [i for i in idx if i < k] # index for current neuron type\\n idx = [i-k for i in idx if i >= k]\\n func = nold[0]\\n number = len(ix1)\\n W = nold[2][:, ix1]\\n bias = nold[3][ix1]\\n neurons.append((func, number, W, bias))\\n self.neurons = neurons\",\n \"def remove_possibles(self):\\n for row in range(self.board_size):\\n for col in range(self.board_size):\\n self.remove_poss(row, col)\",\n \"def _removeEdgesNodes(self, curNode):\\n\\n # Figure out all edges to be removed first then take them out of the temp graph\\n # then remove all the nodes from the temp graph.\\n # At the start the temp graph is equal to the initial graph.\\n\\n self.deletedEdges = set()\\n self.deletedNodes = set()\\n kNodes = self.kPath.nodeList\\n index = 0\\n tempNode = kNodes[index]\\n index += 1\\n while tempNode != curNode:\\n edges = self.tempG.edges(tempNode)\\n if len(edges) != 0:\\n for edge in edges:\\n self.deletedEdges.add(edge)\\n self.tempG.remove_edge(edge[0], edge[1])\\n\\n #\\n\\n self.deletedNodes.add(tempNode)\\n self.tempG.remove_node(tempNode)\\n tempNode = kNodes[index]\\n index += 1\\n\\n # Also need to remove those old deleted edges that start on curNode\\n\\n oldDelEdges = self.kPath.deletedEdges\\n if self.g.is_directed():\\n outEdges = self.g.out_edges(curNode)\\n else:\\n outEdges = self.g.edges(curNode)\\n\\n # outEdges = self.g.edges(curNode)\\n\\n for e in outEdges:\\n if e in oldDelEdges:\\n self.deletedEdges.add(e)\\n self.tempG.remove_edge(e[0], e[1])\\n\\n # Now delete the edge from the curNode to the next in the path\\n\\n tempNode = kNodes[index]\\n e = (curNode, tempNode)\\n self.deletedEdges.add(e)\\n self.tempG.remove_edge(curNode, tempNode)\",\n \"def prune_influence_map(self):\\n im = self.get_im()\\n\\n # First, remove all self-loops\\n logger.info('Removing self loops')\\n edges_to_remove = []\\n for e in im.edges():\\n if e[0] == e[1]:\\n logger.info('Removing self loop: %s', e)\\n edges_to_remove.append((e[0], e[1]))\\n # Now remove all the edges to be removed with a single call\\n im.remove_edges_from(edges_to_remove)\\n\\n # Remove parameter nodes from influence map\\n remove_im_params(self.model, im)\\n\\n # Now compare nodes pairwise and look for overlap between child nodes\\n logger.info('Get successors of each node')\\n succ_dict = {}\\n for node in im.nodes():\\n succ_dict[node] = set(im.successors(node))\\n # Sort and then group nodes by number of successors\\n logger.info('Compare combinations of successors')\\n group_key_fun = lambda x: len(succ_dict[x])\\n nodes_sorted = sorted(im.nodes(), key=group_key_fun)\\n groups = itertools.groupby(nodes_sorted, key=group_key_fun)\\n # Now iterate over each group and then construct combinations\\n # within the group to check for shared sucessors\\n edges_to_remove = []\\n for gix, group in groups:\\n combos = itertools.combinations(group, 2)\\n for ix, (p1, p2) in enumerate(combos):\\n # Children are identical except for mutual relationship\\n if succ_dict[p1].difference(succ_dict[p2]) == set([p2]) and \\\\\\n succ_dict[p2].difference(succ_dict[p1]) == set([p1]):\\n for u, v in ((p1, p2), (p2, p1)):\\n edges_to_remove.append((u, v))\\n logger.debug('Will remove edge (%s, %s)', u, v)\\n logger.info('Removing %d edges from influence map' %\\n len(edges_to_remove))\\n # Now remove all the edges to be removed with a single call\\n im.remove_edges_from(edges_to_remove)\",\n \"def make_complete_graph (num_nodes) :\\n graph = dict ()\\n if (num_nodes < 1) :\\n return graph\\n\\n for node_ind in range (num_nodes) :\\n # create a set containing nodes adjacent to node node_ind\\n # node node_ind of the complete graph will have edges to all other nodes except itself\\n adj_nodes = range (num_nodes) # list containing numbers from 0 - num_nodes-1\\n adj_nodes.remove(node_ind)\\n graph[node_ind] = set(adj_nodes)\\n\\n return graph\",\n \"def remove_neighbor(self):\\n self.fono -= 1\",\n \"def removeNeighbor(self, neighborID):\",\n \"def delete_node(ugraph, node):\\r\\n neighbors = ugraph[node]\\r\\n ugraph.pop(node)\\r\\n for neighbor in neighbors:\\r\\n ugraph[neighbor].remove(node)\",\n \"def remove_topk_nodes(adj, node_importance_rank, topk):\\n for idx in node_importance_rank[:topk]:\\n for i in range(adj.shape[0]):\\n adj[i, idx] = 0\\n adj[idx, i] = 0\\n\\n return adj\",\n \"def _remove_dangling_downstream_nodes(\\n node: p_pb2.PipelineNode,\\n node_ids_to_keep: Collection[str]) -> p_pb2.PipelineNode:\\n # Using a loop instead of set intersection to ensure the same order.\\n downstream_nodes_to_keep = [\\n downstream_node for downstream_node in node.downstream_nodes\\n if downstream_node in node_ids_to_keep\\n ]\\n if len(downstream_nodes_to_keep) == len(node.downstream_nodes):\\n return node\\n result = p_pb2.PipelineNode()\\n result.CopyFrom(node)\\n result.downstream_nodes[:] = downstream_nodes_to_keep\\n return result\",\n \"def _delete_edges(self, to_be_deleted_set, adj_dict):\\n for pair in to_be_deleted_set:\\n first_node = pair[0]\\n second_node = pair[1]\\n adj_dict.pop((first_node, second_node), None)\",\n \"def pop_nodes(self, count):\\n log.debug('Removing {} Request nodes.'.format(count))\\n self.beginRemoveRows(QModelIndex(), 0, count-1)\\n if len(self.root_item.children) > 0:\\n self.root_item.children = self.root_item.children[count:]\\n self.endRemoveRows()\",\n \"def agents_cleanup(agents, n) -> set:\\n return set(agent for agent in agents if agent[0] < n and agent[1] < n)\",\n \"def trim_edges(self, keep=0.5):\\n\\n for tid1, tid2 in self.graph.edges():\\n if random.random() > keep:\\n self.graph.remove_edge(tid1, tid2)\",\n \"def fix_graph(self,graph):\\n graph_compleate_reachable = False\\n while not graph_compleate_reachable:\\n not_reachable_in ,not_reachable_out = self.not_reachable(graph)\\n for n in not_reachable_in:\\n graph.add_edge(self.random.randint(0,n-1),n)\\n for n in not_reachable_out:\\n graph.add_edge(n,self.random.randint(n+1, self.nodes-1))\\n graph_compleate_reachable = len(not_reachable_in)==0 and len(not_reachable_out)==0\\n return graph\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69280136","0.68292296","0.67802733","0.66563076","0.6461734","0.64381963","0.64123416","0.63864523","0.6341436","0.62839335","0.6267461","0.6262071","0.6231139","0.61691225","0.6163174","0.6140132","0.61174977","0.61075747","0.61025345","0.60737944","0.60666347","0.60567206","0.60521644","0.6047738","0.6041141","0.60200036","0.601443","0.60082656","0.5997524","0.5968756","0.59551066","0.59444606","0.59244287","0.59216917","0.5915557","0.5875342","0.5865288","0.5845523","0.58303887","0.5818341","0.57926","0.5789625","0.5780602","0.57777613","0.5775879","0.5771675","0.57665795","0.57646006","0.57646006","0.57593673","0.57573354","0.5756297","0.57421666","0.5736244","0.5724493","0.57212037","0.57113147","0.568514","0.5682028","0.56725466","0.5672467","0.5669334","0.5648154","0.5647603","0.56408143","0.5637346","0.56366354","0.56258416","0.56245","0.5618186","0.56181055","0.5617229","0.560551","0.560206","0.5591927","0.558589","0.55837756","0.5579033","0.5573859","0.5571059","0.55635315","0.55550283","0.5552744","0.55508447","0.55486566","0.55483884","0.5542774","0.5541013","0.55405307","0.5539565","0.55393773","0.5539349","0.5536906","0.5519875","0.55063134","0.55045086","0.5503121","0.55023223","0.55007166","0.5490234"],"string":"[\n \"0.69280136\",\n \"0.68292296\",\n \"0.67802733\",\n \"0.66563076\",\n \"0.6461734\",\n \"0.64381963\",\n \"0.64123416\",\n \"0.63864523\",\n \"0.6341436\",\n \"0.62839335\",\n \"0.6267461\",\n \"0.6262071\",\n \"0.6231139\",\n \"0.61691225\",\n \"0.6163174\",\n \"0.6140132\",\n \"0.61174977\",\n \"0.61075747\",\n \"0.61025345\",\n \"0.60737944\",\n \"0.60666347\",\n \"0.60567206\",\n \"0.60521644\",\n \"0.6047738\",\n \"0.6041141\",\n \"0.60200036\",\n \"0.601443\",\n \"0.60082656\",\n \"0.5997524\",\n \"0.5968756\",\n \"0.59551066\",\n \"0.59444606\",\n \"0.59244287\",\n \"0.59216917\",\n \"0.5915557\",\n \"0.5875342\",\n \"0.5865288\",\n \"0.5845523\",\n \"0.58303887\",\n \"0.5818341\",\n \"0.57926\",\n \"0.5789625\",\n \"0.5780602\",\n \"0.57777613\",\n \"0.5775879\",\n \"0.5771675\",\n \"0.57665795\",\n \"0.57646006\",\n \"0.57646006\",\n \"0.57593673\",\n \"0.57573354\",\n \"0.5756297\",\n \"0.57421666\",\n \"0.5736244\",\n \"0.5724493\",\n \"0.57212037\",\n \"0.57113147\",\n \"0.568514\",\n \"0.5682028\",\n \"0.56725466\",\n \"0.5672467\",\n \"0.5669334\",\n \"0.5648154\",\n \"0.5647603\",\n \"0.56408143\",\n \"0.5637346\",\n \"0.56366354\",\n \"0.56258416\",\n \"0.56245\",\n \"0.5618186\",\n \"0.56181055\",\n \"0.5617229\",\n \"0.560551\",\n \"0.560206\",\n \"0.5591927\",\n \"0.558589\",\n \"0.55837756\",\n \"0.5579033\",\n \"0.5573859\",\n \"0.5571059\",\n \"0.55635315\",\n \"0.55550283\",\n \"0.5552744\",\n \"0.55508447\",\n \"0.55486566\",\n \"0.55483884\",\n \"0.5542774\",\n \"0.5541013\",\n \"0.55405307\",\n \"0.5539565\",\n \"0.55393773\",\n \"0.5539349\",\n \"0.5536906\",\n \"0.5519875\",\n \"0.55063134\",\n \"0.55045086\",\n \"0.5503121\",\n \"0.55023223\",\n \"0.55007166\",\n \"0.5490234\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8111857"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14698,"cells":{"query":{"kind":"string","value":"Determines the quality of the mapping (assignment of edges) based on the \"ground truth\" of spanset and gapset. Sums up number of edges between spanset and gapset. Assumes undirected graph see comments"},"document":{"kind":"string","value":"def mapping_quality(graph, spanset, gapset):\n the_sum = sum(sum(1 for edge in graph.edges(node) if edge[1] in gapset) for node in spanset)\n # if directed graph, uncomment this:\n #the_sum += sum(sum(1 for edge in graph.edges(node) if edge[1] in spanset) for node in gapset)\n return the_sum"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def countEdges(self):\n n = 0\n for (hub, table) in self.totsupport.iteritems():\n n += len(table)\n return n","def community_quality(communities, spanset, gapset):\n if len(communities) != 2:\n return -1\n\n com_sets = [set(c) for c in communities]\n spanset = set(spanset)\n gapset = set(gapset)\n\n spanset_0 = len(com_sets[0].difference(spanset))\n spanset_1 = len(com_sets[1].difference(spanset))\n gapset_0 = len(com_sets[0].difference(gapset))\n gapset_1 = len(com_sets[1].difference(gapset))\n\n # used for determining which community corresponds to gapset and spanset\n spanset_i = 1 - np.argmax([spanset_0, spanset_1])\n gapset_i = 1 - np.argmax([gapset_0, gapset_1])\n\n if spanset_i == gapset_i:\n # Error in finding community quality\n return -1\n elif spanset_i == 0:\n return spanset_0 + gapset_1\n elif spanset_i == 1:\n return spanset_1 + gapset_0\n else:\n return -1","def test_can_traverse_wide_grid(self):\n grid = [[\"1\", \"0\", \"1\", \"1\", \"0\", \"1\", \"0\", \"0\", \"1\", \"0\"]]\n result = num_islands(grid)\n self.assertEqual(result, 4)","def make_set_cover_nr(gRNA_hits, num_sets = 1, target_ids = [], low_coverage_penalty = 0,\n num_lengths_to_track = None, prioritise_3prime = False, optimal_depth = 5,\n suppress_warning = False):\n collapsed_grnas = gRNA_hits.collapse()\n if not target_ids:\n target_ids = set().union(*[set(cg) for cg in collapsed_grnas])\n else:\n target_ids = set(target_ids)\n ## function to regenerate set cover solutions from collapsed_grna object\n collapsed_grnas_original = collapsed_grnas.copy()\n def generate_sc_solutions():\n ## sort in order of smallest set cover size, smallest redundancy, and size of largest set in set cover\n minweight_sc = limited_minweight_SC(collapsed_grnas, num_sets, targets = target_ids,\n low_coverage_penalty = low_coverage_penalty,\n num_lengths_to_track = num_lengths_to_track)\n ## optimal solutions\n max_depth = min(optimal_depth, max(map(len, minweight_sc)))\n max_redundancy = max(map(lambda C:C.redundancy, minweight_sc))/len(target_ids)\n print(max_depth, max_redundancy)\n optimal_sc = limited_optimal_SC(target_ids, collapsed_grnas_original,\n size = max_depth, redundancy = max_redundancy)\n print(\"num unfiltered optimal sc:\", len(optimal_sc))\n ## remove duplicates\n optimal_sc = [C for C in optimal_sc\n if all(map(lambda minweight_C:(len(C) != minweight_C\n and C != minweight_C),\n minweight_sc))]\n print(\"num filtered optimal sc:\", len(optimal_sc))\n return sorted(minweight_sc + optimal_sc,\n key = lambda C:(len(C), C.redundancy, -C.max_coverage))\n sc_solutions = []\n sc_solutions.extend(generate_sc_solutions())\n eliminated_grna = []\n ## function to generate set covers\n def make_set_cover(restore = []):\n ## restore only works if gRNA belonged in the current set cover\n curr_sc = sc_solutions[0]\n for grna in restore:\n curr_sc.add_grna(grna)\n eliminated_grna.remove(grna)\n ## if current set cover solution has at least one CollapsedgRNA with no gRNA left\n while not curr_sc.all_not_empty():\n sink = sc_solutions.pop(0) ## remove set cover solution\n ## generate more possible gRNA sets if no pre-generated set covers are left\n if not sc_solutions:\n collapsed_grnas.remove_grna(*eliminated_grna)\n collapsed_grnas.remove_empty()\n sc_solutions.extend(generate_sc_solutions())\n if not sc_solutions:\n if not suppress_warning:\n print((\"\\nError: The provided gRNA sequences cannot cover all\"\n \" target sequences at least once.\\n\"))\n return []\n ## select next solution\n curr_sc = sc_solutions[0]\n ## consume=True -> remove selected gRNA from CollapsedgRNA\n output = curr_sc.generate_grna_set(prioritise_3prime = prioritise_3prime, consume = True)\n eliminated_grna.extend(output)\n return output\n return make_set_cover","def num_edges(g):\n total_edges_with_duplicates = sum(len(v) for v in g.values())\n return total_edges_with_duplicates // 2","def countEdges(self):\n return numpy.count_nonzero(self.supportArray) / 2","def cal_expected_map(self, ranking_list, total_rel=0):\r\n s = 0.0\r\n pr = 0\r\n pn = 0\r\n for ele in reversed(ranking_list):\r\n rel_doc_cnt = ele[0]\r\n this_doc_cnt = ele[1]\r\n nonrel_doc_cnt = this_doc_cnt - rel_doc_cnt\r\n s += self.A(pr, pn, rel_doc_cnt, nonrel_doc_cnt)\r\n pr += rel_doc_cnt\r\n pn += nonrel_doc_cnt\r\n total_rel += rel_doc_cnt\r\n #print s/total_rel\r\n if total_rel == 0:\r\n return 0\r\n return s/total_rel","def best_pairing(current_end, end_dict, inverse_dict, blast_hits, l_min_score, r_min_score):\n #this duplicates part of trio_hits - should try to rewrite that to use this function\n \n l_flange = int(end_dict[current_end][1])\n l_contig = end_dict[current_end][0]\n \n #first find blast hits for the target scaffold end\n left_matches = []\n for hit in blast_hits:\n if hit[0] == l_contig and int(hit[11]) >= l_min_score:\n left_matches.append(hit)\n \n link_count = {}\n \n #then find other ends with correctly oriented hits adjacent to the target hits\n for slink in end_dict:\n link = end_dict[slink][0]\n \n right_matches = []\n\n for hit in blast_hits:\n if hit[0] == link and int(hit[11]) >= r_min_score: \n right_matches.append(hit)\n \n for lhit in left_matches:\n for rhit in right_matches:\n srhit = inverse_dict[rhit[0]]\n r_flange = end_dict[srhit][1]\n joint_flange = l_flange + r_flange\n \n if lhit[1] == rhit[1]:\n lh_start = int(lhit[8])\n lh_end = int(lhit[9])\n rh_start = int(rhit[8])\n rh_end = int(rhit[9])\n\n if abs(lh_start - rh_start) < joint_flange + 3000:\n if (lh_end - lh_start)/(rh_end - rh_start) < 0:\n if abs(lh_end - rh_end) > abs(lh_start - rh_start):\n link_score = int(lhit[11]) * int(rhit[11])\n if not link in link_count: \n link_count[link] = link_score\n elif link_score > link_count[link]:\n link_count[link] = link_score\n return link_count","def n_inequalities(self):\n try: \n return self._n_inequalities\n except AttributeError:\n self._n_inequalities = 0\n for i in self.inequalities(): self._n_inequalities += 1\n return self._n_inequalities","def seg_to_affgraph(seg_gt, nhood):\n nhood = np.ascontiguousarray(nhood, np.int32)\n shape = seg_gt.shape\n n_edge = nhood.shape[0]\n aff = np.zeros((n_edge,)+shape,dtype=np.int16)\n\n for e in range(n_edge):\n aff[e, \\\n max(0,-nhood[e,0]):min(shape[0],shape[0]-nhood[e,0]), \\\n max(0,-nhood[e,1]):min(shape[1],shape[1]-nhood[e,1]), \\\n max(0,-nhood[e,2]):min(shape[2],shape[2]-nhood[e,2])] = \\\n (seg_gt[max(0,-nhood[e,0]):min(shape[0],shape[0]-nhood[e,0]), \\\n max(0,-nhood[e,1]):min(shape[1],shape[1]-nhood[e,1]), \\\n max(0,-nhood[e,2]):min(shape[2],shape[2]-nhood[e,2])] == \\\n seg_gt[max(0,nhood[e,0]):min(shape[0],shape[0]+nhood[e,0]), \\\n max(0,nhood[e,1]):min(shape[1],shape[1]+nhood[e,1]), \\\n max(0,nhood[e,2]):min(shape[2],shape[2]+nhood[e,2])] ) \\\n * ( seg_gt[max(0,-nhood[e,0]):min(shape[0],shape[0]-nhood[e,0]), \\\n max(0,-nhood[e,1]):min(shape[1],shape[1]-nhood[e,1]), \\\n max(0,-nhood[e,2]):min(shape[2],shape[2]-nhood[e,2])] > 0 ) \\\n * ( seg_gt[max(0,nhood[e,0]):min(shape[0],shape[0]+nhood[e,0]), \\\n max(0,nhood[e,1]):min(shape[1],shape[1]+nhood[e,1]), \\\n max(0,nhood[e,2]):min(shape[2],shape[2]+nhood[e,2])] > 0 )\n\n return aff","def test_metric(self, qset: Iterator[Tuple[str, float]]) -> Dict[str, float]:\n res = dict(mks0=0.0, mks1=0.0, mks2=0.0, sum_weights=0.0, sum_wlen=0.0, n=0)\n hist = {k: {} for k in {\"mks0\", \"mks1\", \"mks2\", \"l\"}} # pylint: disable=C0208\n wei = {k: {} for k in hist}\n res[\"hist\"] = hist\n res[\"histnow\"] = wei\n\n for el, _ in self.enumerate_test_metric(qset):\n le = len(el.value)\n w = el.weight\n res[\"mks0\"] += w * el.mks0\n res[\"mks1\"] += w * el.mks1\n res[\"mks2\"] += w * el.mks2\n res[\"sum_weights\"] += w\n res[\"sum_wlen\"] += w * le\n res[\"n\"] += 1\n\n if el.mks0 not in hist[\"mks0\"]:\n hist[\"mks0\"][el.mks0] = w\n wei[\"mks0\"][el.mks0] = 1\n else:\n hist[\"mks0\"][el.mks0] += w\n wei[\"mks0\"][el.mks0] += 1\n if el.mks1 not in hist[\"mks1\"]:\n hist[\"mks1\"][el.mks1] = w\n wei[\"mks1\"][el.mks1] = 1\n else:\n hist[\"mks1\"][el.mks1] += w\n wei[\"mks1\"][el.mks1] += 1\n if el.mks2 not in hist[\"mks2\"]:\n hist[\"mks2\"][el.mks2] = w\n wei[\"mks2\"][el.mks2] = 1\n else:\n hist[\"mks2\"][el.mks2] += w\n wei[\"mks2\"][el.mks2] += 1\n if le not in hist[\"l\"]:\n hist[\"l\"][le] = w\n wei[\"l\"][le] = 1\n else:\n hist[\"l\"][le] += w\n wei[\"l\"][le] += 1\n return res","def calculate_edge_spans(self):\n for edge in self.edges:\n from_index = self.layers.index(edge.from_node.layer)\n to_index = self.layers.index(edge.to_node.layer)\n edge.span = abs(from_index - to_index)","def count_automorphisms(g: Graph) -> int:\n\n def generate_mapping(g: Graph, h: Graph):\n \"\"\"\n Generates the corresponding mapping from vertex to vertex for the isomorphism between graphs g and h.\n We map g to h.\n :param g: A graph\n :param h: A graph\n :return: A permutation with the mapping from g to h\n \"\"\"\n mapping = [0] * len(g.vertices)\n for v_g in g:\n for v_h in h:\n if v_g.colornum == v_h.colornum:\n mapping[v_g.label] = v_h.label\n return permutation(len(mapping), mapping=mapping)\n\n def generate_automorphisms(g: Graph, h: Graph, d: list[Vertex], i: list[Vertex]):\n \"\"\"\n Is called recursively to traverse through the branching tree and to find all automorphisms.\n :param g: A copy of the original graph\n :param h: Another copy of the original graph\n :param d: A list with pre-colored vertices for graph g\n :param i: A list with pre-colored vertices for graph h\n \"\"\"\n\n # Refine the graphs g and h.\n color_refinement([g, h])\n\n # Make sure that the colors are balanced, and check for a bijection.\n if not is_balanced(g, h):\n return\n if is_bijection(g, h):\n\n # Generate the mapping from g -> h.\n p = generate_mapping(g, h)\n\n # If the permutation cannot be generated by this generating set, we need to add it.\n if not is_member(generating_set, p):\n generating_set.append(p)\n\n # We can now back to the last trivial ancestor nodes in the branching tree.\n while [v.label for v in d] != [v.label for v in i]:\n # We remove the vertices from d and i and mark them as 'used'.\n # This should prevent the algorithm from trying to re-explore a branch that may be skipped.\n # FIXME: This strategy seems too aggressive, the results are sometimes off by a factor 2 or 4\n d.pop().pre_labeled = True\n i.pop().pre_labeled = True\n\n return\n\n c, next_color = get_c([g, h])\n for v_g in g:\n if v_g.colornum == c:# and not v_g.pre_labeled:\n x = v_g\n break\n\n for v_h in h:\n if v_h.colornum == c and not v_h.pre_labeled:\n g1 = g + Graph(False)\n h1 = h + Graph(False)\n g1.vertices[g.vertices.index(x)].colornum = next_color\n h1.vertices[h.vertices.index(v_h)].colornum = next_color\n d.append(x)\n i.append(v_h)\n generate_automorphisms(g1, h1, d, i)\n\n generating_set = []\n graph_copy_1 = g + Graph(False)\n graph_copy_2 = g + Graph(False)\n for v in graph_copy_1.vertices:\n v.pre_labeled = False\n for v in graph_copy_2.vertices:\n v.pre_labeled = False\n generate_automorphisms(graph_copy_1, graph_copy_2, [], [])\n return compute_order(generating_set)","def test_can_traverse_tall_grid(self):\n grid = [\n [\"0\"],\n [\"1\"],\n [\"1\"],\n [\"0\"],\n [\"1\"],\n [\"0\"],\n [\"1\"],\n [\"0\"],\n [\"1\"],\n ]\n result = num_islands(grid)\n self.assertEqual(result, 4)","def matching_score(self,set1, set2):\n set_set1=set(set1)\n set_set2=set(set2)\n '''print(\" set_set12\")\n print(set_set1)\n print(set_set2)'''\n return len(set_set1.intersection(set_set2)) ** 2 / (float(len(set1)) * len(set2))\n #return len(set_set1.intersection(set_set2)) / len(set_set1.union(set_set2))","def test_for_grader():\n test_map1 = np.array([\n [1, 1, 1, 1, 1, 1, 1, 1, 1],\n [1, 0, 1, 0, 0, 0, 1, 0, 1],\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\n [1, 0, 0, 0, 1, 0, 0, 0, 1],\n [1, 1, 1, 1, 1, 1, 1, 1, 1]])\n x_spacing1 = 1\n y_spacing1 = 1\n start1 = np.array([[1.5], [1.5], [0]])\n goal1 = np.array([[7.5], [1], [0]])\n path1 = dijkstras(test_map1,x_spacing1,y_spacing1,start1,goal1)\n s = 0\n for i in range(len(path1)-1):\n s += np.sqrt((path1[i][0]-path1[i+1][0])**2 + (path1[i][1]-path1[i+1][1])**2)\n print(\"Path 1 length:\")\n print(s)\n\n\n test_map2 = np.array([\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [1, 1, 1, 1, 1, 1, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 1, 1, 1, 1, 1, 1, 1]])\n start2 = np.array([[0.4], [0.4], [1.5707963267948966]])\n goal2 = np.array([[0.4], [1.8], [-1.5707963267948966]])\n x_spacing2 = 0.2\n y_spacing2 = 0.2\n path2 = dijkstras(test_map2,x_spacing2,y_spacing2,start2,goal2)\n s = 0\n for i in range(len(path2)-1):\n s += np.sqrt((path2[i][0]-path2[i+1][0])**2 + (path2[i][1]-path2[i+1][1])**2)\n print(\"Path 2 length:\")\n print(s)","def get_GNS_cut_reduced(self):\n # we build the optimization around the casted digraph instead of multidigraph\n # for simplicity\n G = self.base_digraph\n s_1 = self.sources[0]\n s_2 = self.sources[1]\n t_1 = self.destinations[0]\n t_2 = self.destinations[1]\n edges = G.edges()\n nodes = G.nodes()\n\n try:\n\n # Great an gurobi instance of the optimization model\n m = Model(\"GNS\")\n m.setParam('OutputFlag', False)\n\n x_v = {}\n # vertex variables for s_1, t_1 cut\n for v in nodes:\n x_v[v] = m.addVar(vtype=GRB.BINARY)\n\n y_v = {}\n # vertex variables for s_2, t_2 cut\n for v in nodes:\n y_v[v] = m.addVar(vtype=GRB.BINARY)\n\n z_v = {}\n # vertex variables for s_2, t_1 cut\n for v in nodes:\n z_v[v] = m.addVar(vtype=GRB.BINARY)\n\n e = {}\n # GNS indicator variable\n for (u,v) in edges:\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\n\n # Done with decision variable creation\n # update model\n m.update()\n\n # Constraints\n # 1. Constraints for s_1 - t_1 cut\n for (u,v) in edges:\n if (u,v) == (s_1, t_1):\n m.addConstr(e[u,v] >= 1)\n elif u == s_1:\n m.addConstr(x_v[v] + e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-x_v[u] + e[u,v] >= 0)\n else:\n m.addConstr(x_v[v] - x_v[u] + e[u,v] >= 0)\n\n if (u,v) == (s_2, t_2):\n m.addConstr(e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(y_v[v] + e[u,v] >= 1)\n elif v == t_2:\n m.addConstr(-y_v[u] + e[u,v] >= 0)\n else:\n m.addConstr(y_v[v] - y_v[u] + e[u,v] >= 0)\n\n if (u,v) == (s_2, t_1):\n m.addConstr(e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(z_v[v] + e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-z_v[u] + e[u,v] >= 0)\n else:\n m.addConstr(z_v[v] - z_v[u] + e[u,v] >= 0)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n #print \"Min GNS cut value = \" + str(m.objVal)\n #print \"GNS cut edges:\"\n cut_set_edges = []\n for u,v in edges:\n if e[u,v].x != 0:\n #print (u,v), str(G[u][v]['capacity'])\n cut_set_edges.append((u,v, G[u][v]['capacity']))\n return (m.objVal, cut_set_edges)\n else:\n # something went wrong...err...\n print \"Something was wrong\"\n return None, None\n\n except GurobiError:\n print ('Error report from Gurobi')","def compute_num_edges(graph):\n # return the number of edges\n return sum([len(graph[source_node].keys()) for source_node in graph.keys()]) / 2","def test_returns_correct_number_of_islands(self):\n grid = [\n [\"1\", \"1\", \"1\", \"0\", \"0\"],\n [\"1\", \"1\", \"0\", \"0\", \"1\"],\n [\"1\", \"0\", \"1\", \"0\", \"1\"],\n [\"0\", \"1\", \"1\", \"1\", \"1\"],\n [\"1\", \"0\", \"1\", \"1\", \"1\"],\n ]\n result = num_islands(grid)\n self.assertEqual(result, 3)","def __used(self):\n tot=0\n assign={}\n for c in self.assigned :\n if not assign.has_key(c.start) :\n assign[c.start]=c.end\n tot+=c.end-c.start+1\n return tot","def return_num_edges(self):\n return sum(map(lambda x: len(x),self.__adj))","def _compute_packet_heatmap(simulators, span):\n _check_span_keywords(span=span)\n n = simulators[0].model.network.num_nodes\n packet_count = np.zeros([n, n])\n for simulator in simulators:\n if simulator.model.network.num_nodes != n:\n raise ValueError(\"Inconsistent number of nodes are found among the simulators.\")\n if span in overall_range_keywords:\n latency = simulator.latency\n elif span in extended_range_keywords:\n start_index = simulator.batch_stats[-1]['end_index']\n latency = simulator.latency[start_index:]\n elif span in final_batch_range_keywords:\n start_index = simulator.batch_stats[-1]['start_index']\n end_index = simulator.batch_stats[-1]['end_index']\n latency = simulator.latency[start_index:end_index]\n for latency_dict in latency:\n packet_count[latency_dict['Source ID']][latency_dict['Destination ID']] += 1\n max_packet = np.nanmax(packet_count)\n min_packet = np.nanmin(packet_count)\n for i in range(n):\n for j in range(n):\n if i == j:\n packet_count[i][j] = np.nan\n else:\n packet_count[i][j] = (packet_count[i][j] - min_packet) / (max_packet - min_packet)\n return packet_count","def EdgeWeights(setOfEdges, multiSetOfEdges):\n weights = dict()\n for edge in setOfEdges:\n weights[edge] = multiSetOfEdges.count(edge)\n # a way to normalize edge weights\n # edgeWeights = map((1 / max(list(weights.values()))), weights.values())\n return weights","def test_edges_and_weights():\n edges, weights, state_value = edges_weights_specified_state(\n PROBABILITYMATRIX,\n MARKET,\n SNULL)\n assert len(edges) == len(weights) == (len(state_value)**2)","def query_size_of_adjacent_nodes(self, node_curie, source_type, adjacent_type, kp=\"infores:rtx-kg2\", rel_type=None):\n\n res = None\n source_type = ComputeFTEST.convert_string_to_snake_case(source_type.replace('biolink:',''))\n source_type = ComputeFTEST.convert_string_biolinkformat(source_type)\n adjacent_type = ComputeFTEST.convert_string_to_snake_case(adjacent_type.replace('biolink:',''))\n adjacent_type = ComputeFTEST.convert_string_biolinkformat(adjacent_type)\n\n if rel_type is None:\n normalized_nodes = self.nodesynonymizer.get_canonical_curies(node_curie)\n failure_nodes = list()\n mapping = {node:normalized_nodes[node]['preferred_curie'] for node in normalized_nodes if normalized_nodes[node] is not None}\n failure_nodes += list(normalized_nodes.keys() - mapping.keys())\n query_nodes = list(set(mapping.values()))\n query_nodes = [curie_id.replace(\"'\", \"''\") if \"'\" in curie_id else curie_id for curie_id in query_nodes]\n # special_curie_ids = [curie_id for curie_id in query_nodes if \"'\" in curie_id]\n\n # Get connected to kg2c sqlite\n connection = sqlite3.connect(self.sqlite_file_path)\n cursor = connection.cursor()\n\n # Extract the neighbor count data\n node_keys_str = \"','\".join(query_nodes) # SQL wants ('node1', 'node2') format for string lists\n sql_query = f\"SELECT N.id, N.neighbor_counts \" \\\n f\"FROM neighbors AS N \" \\\n f\"WHERE N.id IN ('{node_keys_str}')\"\n cursor.execute(sql_query)\n rows = cursor.fetchall()\n rows = [curie_id.replace(\"\\'\",\"'\").replace(\"''\", \"'\") if \"'\" in curie_id else curie_id for curie_id in rows]\n connection.close()\n\n # Load the counts into a dictionary\n neighbor_counts_dict = {row[0]:eval(row[1]) for row in rows}\n\n res_dict = {node:neighbor_counts_dict[mapping[node]].get(adjacent_type) for node in mapping if mapping[node] in neighbor_counts_dict and neighbor_counts_dict[mapping[node]].get(adjacent_type) is not None}\n failure_nodes += list(mapping.keys() - res_dict.keys())\n\n if len(failure_nodes) != 0:\n return (res_dict, failure_nodes)\n else:\n return (res_dict, [])\n\n else:\n # if kp == 'ARAX/KG1':\n # self.response.warning(f\"Since the edge type '{rel_type}' is from KG1, we still use the DSL expand(kg=ARAX/KG1) to query neighbor count. However, the total node count is based on KG2c from 'nodesynonymizer.get_total_entity_count'. So the FET result might not be accurate.\")\n\n # construct the instance of ARAXQuery class\n araxq = ARAXQuery()\n\n # check if node_curie is a str or a list\n if type(node_curie) is str:\n query_node_curie = node_curie\n elif type(node_curie) is list:\n node_id_list_str = \"[\"\n for index in range(len(node_curie)):\n node = node_curie[index]\n if index + 1 == len(node_curie):\n node_id_list_str = node_id_list_str + str(node) + \"]\"\n else:\n node_id_list_str = node_id_list_str + str(node) + \",\"\n\n query_node_curie = node_id_list_str\n else:\n self.response.error(\"The 'node_curie' argument of 'query_size_of_adjacent_nodes' method within FET only accepts str or list\")\n return res\n\n # call the method of ARAXQuery class to query adjacent node\n query = {\"operations\": {\"actions\": [\n \"create_message\",\n f\"add_qnode(ids={query_node_curie}, categories={source_type}, key=FET_n00)\",\n f\"add_qnode(categories={adjacent_type}, key=FET_n01)\",\n f\"add_qedge(subject=FET_n00, object=FET_n01, key=FET_e00, predicates={rel_type})\",\n f\"expand(edge_key=FET_e00,kp={kp})\",\n #\"resultify()\",\n \"return(message=true, store=false)\"\n ]}}\n\n try:\n result = araxq.query(query)\n if result.status != 'OK':\n self.response.error(f\"Fail to query adjacent nodes from infores:rtx-kg2 for {node_curie}\")\n return res\n else:\n res_dict = dict()\n message = araxq.response.envelope.message\n if type(node_curie) is str:\n tmplist = set([edge_key for edge_key in message.knowledge_graph.edges if message.knowledge_graph.edges[edge_key].subject == node_curie or message.knowledge_graph.edges[edge_key].object == node_curie]) ## edge has no direction\n if len(tmplist) == 0:\n self.response.warning(f\"Fail to query adjacent nodes from {kp} for {node_curie} in FET probably because expander ignores node type. For more details, please see issue897.\")\n return (res_dict,[node_curie])\n res_dict[node_curie] = len(tmplist)\n return (res_dict,[])\n else:\n check_empty = False\n failure_nodes = list()\n for node in node_curie:\n tmplist = set([edge_key for edge_key in message.knowledge_graph.edges if message.knowledge_graph.edges[edge_key].subject == node or message.knowledge_graph.edges[edge_key].object == node]) ## edge has no direction\n if len(tmplist) == 0:\n self.response.warning(f\"Fail to query adjacent nodes from {kp} for {node} in FET probably because expander ignores node type. For more details, please see issue897.\")\n failure_nodes.append(node)\n check_empty = True\n continue\n res_dict[node] = len(tmplist)\n\n if check_empty is True:\n return (res_dict,failure_nodes)\n else:\n return (res_dict,[])\n except:\n tb = traceback.format_exc()\n error_type, error, _ = sys.exc_info()\n self.response.error(tb, error_code=error_type.__name__)\n self.response.error(f\"Something went wrong with querying adjacent nodes from {kp} for {node_curie}\")\n return res","def test_weighting(self):\n dset = self.dset.spec.sel(\n lons=self.lons_inexact, lats=self.lats_inexact, method=\"idw\"\n )\n for stat in [\"hs\", \"tp\"]:\n idw = dset.spec.stats([stat])[stat].values\n site0 = self.dset.isel(site=[0]).spec.stats([stat])[stat].values\n site1 = self.dset.isel(site=[1]).spec.stats([stat])[stat].values\n lower = np.array([min(s1, s2) for s1, s2 in zip(site0, site1)])\n upper = np.array([max(s1, s2) for s1, s2 in zip(site0, site1)])\n assert (upper - idw > 0).all() and (idw - lower > 0).all()","def compute_m_paths_of_len_back(g, sampl, end_times, path_len=5, cost=1, its=100, max_duration=sys.maxint):\n\n num_of_paths_dict = {}\n\n # for each node in source, generate random paths and count the number of times they end up in each\n # dest. node\n for dest, end_time in zip(sampl, end_times):\n print \"Processing dest node: {} (ending at time {})\".format(dest, end_time)\n num_of_paths_dict[(dest, end_time)] = {source: 0 for source in g.nodes()}\n for _ in range(its):\n d = random_path_backwards(g, dest, path_len, end_time, cost, max_duration)\n if d is not None:\n num_of_paths_dict[(dest, end_time)][d] += 1\n\n return num_of_paths_dict","def edge_count(adjList):\n edges = {}\n for id, neigh in enumerate(adjList):\n for n in neigh:\n edges[max(n, id), min(n, id)] = id\n\n return len(edges)","def num_cusps_of_regions(self):\n G = self._get_puncturefinder_graph()\n # return [sum(G.subgraph(vertices=region).edge_labels())\n # for region in G.connected_components()]\n return [sum(edge[2]['weight']\n for edge in subgraph.edges(data=True))\n for subgraph in nx.connected_component_subgraphs(G)]","def count_property_range_hits(prop, node_dict, hits):\n\tres = []\n\t# sets tuple position to use in dict value\n\tswitcher = {\n \"length\": (0,(0,4000,8000,12000,16000,20000)),\n \"steps\": (1,(0,2,4,8,16,32)),\n \"cov\": (2,(1,10,100,1000,10000,100000)),\n \"cv\": (3, (0,0.05,0.10,0.15,0.20,0.25))\n }\n\tif prop not in switcher:\n\t\treturn res\n\ttup_pos = switcher[prop][0]\n\tnode_cnt = 0\n\tpos_cnt = 0\n\tfor ind in range(len(switcher[prop][1])-1):\n\t\tmin_val = switcher[prop][1][ind]\n\t\tmax_val = switcher[prop][1][ind+1]\n\t\tfor node in node_dict.keys():\n\t\t\tval = node_dict[node][tup_pos]\n\t\t\tif ind < len(switcher[prop][1])-2:\n\t\t\t\trange_test_val = (min_val <= val < max_val)\n\t\t\telse:\n\t\t\t\trange_test_val = (min_val <= val <= max_val)\n\t\t\t# print \"range bool is\", range_test_val\n\t\t\tif range_test_val:\n\t\t\t\tnode_cnt += 1\n\t\t\t\tif node in hits: pos_cnt += 1\n\t\tif node_cnt > 0:\n\t\t\tres.append( (pos_cnt, node_cnt, round(float(pos_cnt)/node_cnt,2)))\n\t\telse:\n\t\t\tres.append((0,0,0))\n\t\tnode_cnt = 0\n\t\tpos_cnt = 0\n\treturn res","def count_islands(grid):\n grid_copy = list(grid)\n count = 0\n for i in range(0, len(grid_copy)):\n for j in range (0, len(grid_copy[0])):\n if grid[i][j] and grid_copy[i][j]:\n _dfs(grid_copy, i, j)\n count += 1\n return count","def compute_district_weights(dist_changes, elec_sets, elec_set_dict, state_gdf, partition, prec_draws_outcomes,\\\n geo_id, primary_elecs, runoff_elecs, elec_match_dict, bases, outcomes,\\\n recency_W1, cand_race_dict, min_cand_weights_dict):\n \n black_pref_cands_prim_dist = pd.DataFrame(columns = dist_changes)\n black_pref_cands_prim_dist[\"Election Set\"] = elec_sets\n hisp_pref_cands_prim_dist = pd.DataFrame(columns = dist_changes)\n hisp_pref_cands_prim_dist[\"Election Set\"] = elec_sets\n #store runoff preferences for instances where minority-preferred candidate needs to switch between primary and runoff\n black_pref_cands_runoffs_dist = pd.DataFrame(columns = dist_changes)\n black_pref_cands_runoffs_dist[\"Election Set\"] = elec_sets\n hisp_pref_cands_runoffs_dist = pd.DataFrame(columns = dist_changes)\n hisp_pref_cands_runoffs_dist[\"Election Set\"] = elec_sets \n \n black_conf_W3_dist = np.empty((len(elec_sets),0), float)\n hisp_conf_W3_dist = np.empty((len(elec_sets),0), float)\n neither_conf_W3_dist = np.empty((len(elec_sets),0), float)\n \n for district in dist_changes: \n state_gdf[\"New Map\"] = state_gdf.index.map(dict(partition.assignment))\n dist_prec_list = list(state_gdf[state_gdf[\"New Map\"] == district][geo_id])\n dist_prec_indices = state_gdf.index[state_gdf[geo_id].isin(dist_prec_list)].tolist()\n district_support_all = cand_pref_outcome_sum(prec_draws_outcomes, dist_prec_indices, bases, outcomes)\n \n black_pref_prob_single_dist = []\n hisp_pref_prob_single_dist = []\n \n for elec_set in elec_sets: \n HCVAP_support_elec = district_support_all[('HCVAP', elec_set_dict[elec_set]['Primary'])]\n hisp_pref_cand_dist = max(HCVAP_support_elec.items(), key=operator.itemgetter(1))[0]\n hisp_pref_prob_dist = HCVAP_support_elec[hisp_pref_cand_dist]\n hisp_pref_prob_single_dist.append(hisp_pref_prob_dist) \n \n BCVAP_support_elec = district_support_all[('BCVAP', elec_set_dict[elec_set]['Primary'])]\n black_pref_cand_dist = max(BCVAP_support_elec.items(), key=operator.itemgetter(1))[0]\n black_pref_prob_dist = BCVAP_support_elec[black_pref_cand_dist]\n black_pref_prob_single_dist.append(black_pref_prob_dist)\n \n black_pref_cands_prim_dist.at[black_pref_cands_prim_dist[\"Election Set\"] == elec_set, district] = black_pref_cand_dist\n hisp_pref_cands_prim_dist.at[hisp_pref_cands_prim_dist[\"Election Set\"] == elec_set, district] = hisp_pref_cand_dist \n \n if 'Runoff' in elec_set_dict[elec_set].keys():\n HCVAP_support_elec = district_support_all[('HCVAP', elec_set_dict[elec_set]['Runoff'])]\n hisp_pref_cand_dist = max(HCVAP_support_elec.items(), key=operator.itemgetter(1))[0]\n hisp_pref_cands_runoffs_dist.at[hisp_pref_cands_runoffs_dist[\"Election Set\"] == elec_set, district] = hisp_pref_cand_dist\n \n BCVAP_support_elec = district_support_all[('BCVAP', elec_set_dict[elec_set]['Runoff'])]\n black_pref_cand_dist = max(BCVAP_support_elec.items(), key=operator.itemgetter(1))[0] \n black_pref_cands_runoffs_dist.at[black_pref_cands_runoffs_dist[\"Election Set\"] == elec_set, district] = black_pref_cand_dist\n \n black_pref_conf_single_dist = [prob_conf_conversion(x) for x in black_pref_prob_single_dist]\n black_conf_W3_dist = np.append(black_conf_W3_dist, np.array([black_pref_conf_single_dist]).transpose(), axis = 1) \n \n hisp_pref_conf_single_dist = [prob_conf_conversion(x) for x in hisp_pref_prob_single_dist]\n hisp_conf_W3_dist = np.append(hisp_conf_W3_dist, np.array([hisp_pref_conf_single_dist]).transpose(), axis = 1) \n \n neither_pref_conf_single_dist = [prob_conf_conversion(x*y) for x,y in zip(black_pref_prob_single_dist,hisp_pref_prob_single_dist)]\n neither_conf_W3_dist = np.append(neither_conf_W3_dist, np.array([neither_pref_conf_single_dist]).transpose(), axis = 1) \n \n #compute W2 (\"in-group\"-minority-preference weight) \n min_cand_black_W2_dist, min_cand_hisp_W2_dist, min_cand_neither_W2_dist = compute_W2(elec_sets, \\\n dist_changes, min_cand_weights_dict, black_pref_cands_prim_dist, hisp_pref_cands_prim_dist, cand_race_dict)\n ################################################################################ \n #compute final election weights per district\n recency_W1 = recency_W1.copy()[:, dist_changes]\n black_weight_dist = recency_W1*min_cand_black_W2_dist*black_conf_W3_dist\n hisp_weight_dist = recency_W1*min_cand_hisp_W2_dist*hisp_conf_W3_dist \n neither_weight_dist = recency_W1*min_cand_neither_W2_dist*neither_conf_W3_dist\n \n return black_weight_dist, hisp_weight_dist, neither_weight_dist, black_pref_cands_prim_dist, \\\n black_pref_cands_runoffs_dist, hisp_pref_cands_prim_dist, hisp_pref_cands_runoffs_dist","def num_edges(self):\n return sum(1 for _ in self.iteredges())","def cost(graph, gates_qubits_pairs):\n for allowed, gate in enumerate(gates_qubits_pairs):\n if gate not in graph.edges():\n break\n return len(gates_qubits_pairs) - allowed","def get_coverage(self):\n coverage = np.zeros(self.Set.Shape, dtype=np.int8)\n for ig in self.Set:\n igram = self.load_ma(ig)\n coverage[~igram.mask] += 1\n\n return coverage","def street_segment_count(Gu):\n if nx.is_directed(Gu): # pragma: no cover\n msg = \"`Gu` must be undirected\"\n raise ValueError(msg)\n return len(Gu.edges)","def good_turing_mapping(self, threshold=5) -> Dict[int, float]:\n total_count_counts = sum(self.count_counts.values(), Counter())\n # total_count_counts[2] is number of bigrams that occurred twice\n\n def good_turing(c): \n return (c+1) * (total_count_counts[c+1]) / total_count_counts.get(c, 1)\n gtm = {c: good_turing(c) for c in range(threshold)}\n return {k: v for k, v in gtm.items() if v > 0} # can't have 0 counts","def _num_edges(self):\n return int(self._edge_map[-1])","def count_gates(qobj, basis, qubits):\n\n #TO DO\n pass","def compute_m_paths_of_len_forw(g, sampl, start_times, path_len=5, cost=1, its=100, max_duration=sys.maxint):\n\n num_of_paths_dict = {}\n\n # for each node in source, generate random paths and count the number of times they end up in each\n # dest. node\n for source, start_time in zip(sampl, start_times):\n print \"Processing source node: {} (starting at time {})\".format(source, start_time)\n num_of_paths_dict[(source, start_time)] = {dest: 0 for dest in g.nodes()}\n for _ in range(its):\n d = random_path_forward(g, source, path_len, start_time, cost, max_duration)\n if d is not None:\n num_of_paths_dict[(source, start_time)][d] += 1\n\n return num_of_paths_dict","def calculateIndels(mfaPairs, regions):\n gapLength = 0\n gaps = [0]*1000\n for i in regions:\n for j in xrange(i[0], i[1]):\n k = mfaPairs[j]\n if k == GAP:\n gapLength += 1\n else:\n if gapLength != 0:\n gaps[gapLength] += 1\n gapLength = 0\n return gaps","def get_number_of_measurement(self):\n used_fragments = set()\n counter = 0\n for fragment in self.observed_fragments:\n num_of_isotope = 0\n used_counter = 0\n for i in self.mdv[fragment]:\n num_of_isotope = num_of_isotope + 1\n if self.mdv[fragment][i]['use'] == 'use':\n\n counter = counter + 1\n used_counter = used_counter + 1\n if num_of_isotope == used_counter:\n used_fragments.add(fragment)\n return counter-len(used_fragments)","def get_gini(self, rows):\n label_count = defaultdict(int)\n total_count = 0\n for row in rows:\n label = row[self.target_attribute]\n label_count[label] += 1\n total_count += 1\n return 1 - sum([np.square(float(label_count[label])/total_count) for label in label_count.keys()])","def branchNBound2(nationtxt, bound, scheme):\n\n\n nation = nationLoader(nationtxt)\n transmitterCosts = scheme\n\n neighborCount = {}\n for province in nation:\n neighborCount.update({province:len(nation.get(province)[0])})\n\n\n neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__)\n\n #~ neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__, reverse=True)\n\n for key in neighborCountSorted:\n provinces.append(key)\n #~ print provinces\n\n upperbound = bound\n #~ print bound\n\n\n\n solution = []\n\n\n counter = 0\n\n\n\n\n while index >= 0:\n\n counter += 1\n if counter % 100000000 == 0:\n print counter\n print \"Now at:\", nation\n\n\n if index == -1:\n break\n\n # Assign transmitter\n if nation[provinces[index]][1] == numTransmitters:\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n else:\n costs, index = updateTransmitter(nation, False, scheme, provinces, costs, index)\n\n # Check if costs are above upper bound\n if (costs + (len(provinces) - (index + 1)) * transmitterCosts[0]) > upperbound:\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n # Check if a neighbor has the same transmitter\n conflict = False\n for neighbor in nation[provinces[index]][0]:\n if nation[neighbor][1] == nation[provinces[index]][1]:\n conflict = True\n break\n\n if conflict:\n continue\n\n # Check if a solution is found\n if index == len(provinces) - 1:\n #~ print \"\\nSOLUTION:\"\n if costs < upperbound:\n solution = []\n solution.append(json_deep_copy(nation))\n upperbound = costs\n #~ print \"Score:\", upperbound\n #~ print nation\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n index += 1\n\n\n\n usedTrans = []\n fivePlus = 0\n fivePlusNoDuplicate = 0\n\n for nation in solution:\n\n one = 0\n two = 0\n three = 0\n four = 0\n five = 0\n six = 0\n seven = 0\n\n for province in nation:\n\n if nation[province][1] == 1:\n one += 1\n if nation[province][1] == 2:\n two += 1\n if nation[province][1] == 3:\n three += 1\n if nation[province][1] == 4:\n four += 1\n if nation[province][1] == 5:\n five += 1\n if nation[province][1] == 6:\n six += 1\n if nation[province][1] == 7:\n seven += 1\n\n\n if five > 0 or six > 0 or seven > 0:\n fivePlus += 1\n if transmitterCosts[3] != transmitterCosts[4]:\n fivePlusNoDuplicate += 1\n\n usedTrans.append([one, two, three, four, five, six, seven])\n\n return counter","def test_sum_counts_by_consensus(self):\r\n #otu_table = parse_otu_table(self.otu_table)\r\n #otu_table = parse_biom_table(self.otu_table)\r\n obs_result, obs_mapping = sum_counts_by_consensus(self.otu_table, 3)\r\n exp_result = {(\r\n 'Root', 'Bacteria', 'Actinobacteria'): array([1, 0, 2, 4]),\r\n ('Root', 'Bacteria', 'Firmicutes'): array([1, 3, 1, 1]),\r\n ('Root', 'Bacteria', 'Other'): array([1, 2, 1, 0])}\r\n exp_mapping = {'s1': 0, 's2': 1, 's3': 2, 's4': 3}\r\n self.assertItemsEqual(obs_result, exp_result)\r\n self.assertEqual(obs_mapping, exp_mapping)\r\n\r\n obs_result, obs_mapping = sum_counts_by_consensus(self.otu_table, 2)\r\n exp_result = {('Root', 'Bacteria'): array([3, 5, 4, 5])}\r\n exp_mapping = {'s1': 0, 's2': 1, 's3': 2, 's4': 3}\r\n self.assertItemsEqual(obs_result, exp_result)\r\n self.assertEqual(obs_mapping, exp_mapping)\r\n\r\n obs_result, obs_mapping = sum_counts_by_consensus(self.otu_table, 4)\r\n exp_result = {('Root', 'Bacteria', 'Actinobacteria', 'Actinobacteria'):\r\n array([1, 0, 2, 4]),\r\n ('Root', 'Bacteria', 'Firmicutes', '\"Clostridia\"'):\r\n array([1, 3, 1, 1]),\r\n ('Root', 'Bacteria', 'Other', 'Other'): array([1, 2, 1, 0])}\r\n exp_mapping = {'s1': 0, 's2': 1, 's3': 2, 's4': 3}\r\n self.assertItemsEqual(obs_result, exp_result)\r\n self.assertEqual(obs_mapping, exp_mapping)","def get_routing_solution(self):\n G = self.base_digraph\n s1 = self.sources[0]\n s2 = self.sources[1]\n t1 = self.destinations[0]\n t2 = self.destinations[1]\n\n try:\n m = Model('routing')\n m.setParam('OutputFlag', False)\n\n # variables,\n # We have one variable per edge per session\n # e is the dict of dict for the variables\n e = {}\n r = {}\n for i in [1,2]:\n e[i] = {}\n r[i] = m.addVar()\n for u,v in G.edges():\n e[i][u,v] = m.addVar(lb=0)\n\n m.update()\n\n obj = quicksum(r.values())\n m.setObjective(obj, GRB.MAXIMIZE)\n\n # constraints\n # 1. conservations of flow at all intermediate nodes\n # 2. capacity constraints for each edge\n\n for u,v in G.edges():\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\n\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\n\n for n in G.nodes():\n if n not in [s1, s2, t1, t2]:\n for i in [1, 2]:\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\n m.addConstr(inflow == outflow)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n for u, v in G.edges():\n G[u][v]['Routing'] = {}\n G[u][v]['Routing'][1] = e[1][u,v].x\n G[u][v]['Routing'][2] = e[2][u,v].x\n return (m.objVal, r[1].x, r[2].x)\n else:\n # something went wrong...err...\n print \"Something was wrong, no optimal solution obtained\"\n return None, None, None\n\n except GurobiError:\n Print ('Error Report from Gurobi')","def compute_matches(self):\n\t\tself.local_database[\"figure_number\"] = [0] * len(self.local_database[\"feature_vectors\"])\n\t\tForensics = wbForensicsHOG(Database=self.local_database)\n\t\tForensics.KDTree_pairs(leaf_size = len(self.local_database)+1)\n\t\tForensics.d_rank(pairs=Forensics.pairs, distances=Forensics.dists, ratios=Forensics.ratios)\n\n\t\tself.local_matches = Forensics.Dist_Rank","def syn_gid(self, src_gid, tgt_gid):\n i = 0\n if (src_gid < self.num_mit): # Target is granule\n i = (tgt_gid * self.num_mit + src_gid + 1 + \n self.num_mit + self.num_gran) * 100 + 1\n else: # Target is mitral\n i = (src_gid * self.num_mit + tgt_gid + 1 + \n self.num_mit + self.num_gran) * 100\n return i","def networkx_directed_cut_size(graph, vertex_set_l, vertex_set_r=None):\n edges = nx.edge_boundary(graph, vertex_set_l, vertex_set_r, data=\"weight\", default=1)\n return sum(weight for u, v, weight in edges)","def get_good_label_distrib(semrel_dict, semrel_counts):\n\n # Do cardinality check on srdict first, to see if there are enough elements to fulfill the distribution in five_semrels.\n srdict_counts = {key:len(value) for key, value in semrel_dict.items()}\n\n # This variable will hold the number of collocations to add to the distribution in place of unfulfillable other labels.\n num_coll_to_add = 0\n\n # Go through all non-'collocation' labels in the dictionary that contains the requested number of labels.\n for label, count in semrel_counts.items():\n\n if label != 'collocation':\n\n # Get the difference in cardinality between the available set and the requested set.\n diffc = srdict_counts[label] - semrel_counts[label]\n\n # If negative, i.e. if there are more requested than available, record the difference (this is how many instances\n # of 'collocation' to add) and change the number of requested words to the number available.\n if diffc < 0:\n num_coll_to_add += abs(diffc)\n semrel_counts[label] = srdict_counts[label]\n\n # Adjust the values in 'collocation' in the dictionary.\n if 'collocation' in set(semrel_counts.keys()):\n semrel_counts['collocation'] += num_coll_to_add\n else:\n semrel_counts['collocation'] = num_coll_to_add\n\n return semrel_counts","def get_invariant_dimensions(self, sdfg: dace.sdfg.SDFG, graph: dace.sdfg.SDFGState,\n map_entries: List[nodes.MapEntry], map_exits: List[nodes.MapExit],\n node: nodes.AccessNode):\n variant_dimensions = set()\n subset_length = -1\n\n for in_edge in graph.in_edges(node):\n if in_edge.src in map_exits:\n other_edge = graph.memlet_path(in_edge)[-2]\n other_subset = other_edge.data.subset \\\n if other_edge.data.data == node.data \\\n else other_edge.data.other_subset\n\n for (idx, (ssbs1, ssbs2)) \\\n in enumerate(zip(in_edge.data.subset, other_subset)):\n if ssbs1 != ssbs2:\n variant_dimensions.add(idx)\n else:\n warnings.warn(\"SubgraphFusion::Nodes between two maps to be\"\n \"fused with *incoming* edges\"\n \"from outside the maps are not\"\n \"allowed yet.\")\n\n if subset_length < 0:\n subset_length = other_subset.dims()\n else:\n assert other_subset.dims() == subset_length\n\n for out_edge in graph.out_edges(node):\n if out_edge.dst in map_entries:\n for other_edge in graph.out_edges(out_edge.dst):\n if other_edge.src_conn and other_edge.src_conn[3:] == out_edge.dst_conn[2:]:\n other_subset = other_edge.data.subset \\\n if other_edge.data.data == node.data \\\n else other_edge.data.other_subset\n for (idx, (ssbs1, ssbs2)) in enumerate(zip(out_edge.data.subset, other_subset)):\n if ssbs1 != ssbs2:\n variant_dimensions.add(idx)\n assert other_subset.dims() == subset_length\n\n invariant_dimensions = set([i for i in range(subset_length)]) - variant_dimensions\n return invariant_dimensions","def test_figure4(self):\n\n topics = get_topics('msmarco-passage-dev-subset')\n qrels = get_qrels('msmarco-passage-dev-subset')\n\n self.assertEqual(len(topics), 6980)\n self.assertEqual(len(qrels), 6980)\n\n # Compute the average length of queries:\n avg_qlen = sum([len(topics[t]['title'].split()) for t in topics])/len(topics)\n\n # Compute the average number of relevance judgments per query:\n avg_qrels = sum([len(qrels[t]) for t in topics])/len(topics)\n\n self.assertAlmostEqual(avg_qlen, 5.925, delta=0.001)\n self.assertAlmostEqual(avg_qrels, 1.065, delta=0.001)","def measureSpecificityUsingDict(foundJunctionsBed, ests, wiggle=0, goodFile=None, badFile=None):\n\n overlaps = 0\n noOverlaps = 0\n\n # do it slow for now\n # read in all the junctions we found\n found = {} # found[chr][(left, right)] = count\n for line in open(foundJunctionsBed):\n if line.startswith(\"track\"):\n continue\n\n if len(line) < 3:\n continue\n\n pieces = line.split(\"\\t\")\n #print pieces\n if len(pieces) == 0:\n continue\n\n if pieces[0].startswith(\"Plasmodium_falciparum\"):\n pieces[0] = pieces[0].split(\"|\")[1].replace(\"MAL\", \"chr\")\n\n if pieces[0].startswith(\"psu|Pf\"):\n pieces[0] = \"chr\" + str(int(pieces[0].split()[0].split(\"|\")[1].split(\"_\")[1]))\n\n\n if not found.has_key(pieces[0]):\n found[pieces[0]] = {}\n\n leftEdge, rightEdge = getEdges(int(pieces[1]), pieces[10], pieces[11])\n if not found[pieces[0]].has_key( (leftEdge,rightEdge) ):\n found[pieces[0]][(leftEdge,rightEdge)] = 0\n found[pieces[0]][(leftEdge,rightEdge)] += 1\n\n # for every one of our junction, do they overlap with an est?\n if goodFile != None and badFile != None:\n goodOut = open(goodFile, \"w\")\n badOut = open(badFile, \"w\")\n\n for chr, edgeDict in found.iteritems():\n for (leftEdge, rightEdge) in edgeDict.keys():\n foundOne = False\n for x in range(leftEdge-wiggle, leftEdge+wiggle+1):\n for y in range(rightEdge-wiggle, rightEdge+wiggle+1):\n if ests.has_key(chr):\n if ests[chr].has_key( (x, y) ):\n foundOne = True\n if foundOne:\n overlaps += found[chr][(leftEdge,rightEdge)]\n if goodFile != None:\n goodOut.write(\"\\t\".join([chr, str(leftEdge), str(rightEdge), str(overlaps)]))\n goodOut.write(\"\\n\")\n else:\n noOverlaps += found[chr][(leftEdge,rightEdge)]\n if badFile != None:\n badOut.write(\"\\t\".join([chr, str(leftEdge), str(rightEdge), str(noOverlaps)]))\n badOut.write(\"\\n\")\n\n if (noOverlaps + overlaps) > 0:\n print \"%s overlapped but %s did not. %.2d%% overlapped\" % (overlaps, noOverlaps, (overlaps*100.0)/(noOverlaps+overlaps))\n\n return (overlaps*100.0) / (noOverlaps + overlaps)\n else:\n print \"No junctions found!\"\n return 0","def count_edges(input_first, input_second, problem):\n\tcount = 0\n\tfor idx in xrange(len(input_first)):\n\t\tfor index in xrange(len(input_second)):\n\t\t\tif (input_first[idx], input_second[index]) in problem:\n\t\t\t\tcount += 1\n\t\t\telif (input_second[index], input_first[idx]) in problem:\n\t\t\t\tcount += 1\n\treturn count","def GraphBetter(metric_set1_sorted, metric_set2_sorted, base_is_set_2):\n total_bitrate_difference_ratio = 0.0\n count = 0\n for bitrate, metric in metric_set1_sorted:\n for i in range(len(metric_set2_sorted) - 1):\n s2_bitrate_0, s2_metric_0 = metric_set2_sorted[i]\n s2_bitrate_1, s2_metric_1 = metric_set2_sorted[i + 1]\n # We have a point on either side of our metric range.\n if metric > s2_metric_0 and metric <= s2_metric_1:\n\n # Calculate a slope.\n if s2_metric_1 - s2_metric_0 != 0:\n metric_slope = ((s2_bitrate_1 - s2_bitrate_0) /\n (s2_metric_1 - s2_metric_0))\n else:\n metric_slope = 0\n\n estimated_s2_bitrate = (s2_bitrate_0 + (metric - s2_metric_0) *\n metric_slope)\n\n # Calculate percentage difference as given by base.\n if base_is_set_2 == 0:\n bitrate_difference_ratio = ((bitrate - estimated_s2_bitrate) /\n bitrate)\n else:\n bitrate_difference_ratio = ((bitrate - estimated_s2_bitrate) /\n estimated_s2_bitrate)\n\n total_bitrate_difference_ratio += bitrate_difference_ratio\n count += 1\n break\n\n # Calculate the average improvement between graphs.\n if count != 0:\n avg = total_bitrate_difference_ratio / count\n\n else:\n avg = 0.0\n\n return avg","def gal_count(clusters):\n sum = 0\n for x in clusters:\n sum += x.ngal\n return sum","def numIslands(grid):\n # count to store each new island found\n count = 0\n # If the grid is empty, return 0\n if not grid:\n return count\n\n y_max = len(grid)\n x_max = len(grid[0])\n \n for i in range(len(grid)):\n for j in range(len(grid[0])):\n if grid[i][j] == '1':\n dfs(grid, i, j)\n count += 1\n return count","def _num_edges(self):\n return len(self._eid2partid)","def calculate_betweenness(graph, edges):\n for root in graph:\n visited = set()\n _bfs({root: [1, []]}, graph, edges, visited)","def countMatches(g1, g2):\n if g1 is None or g2 is None or len(g1) == 0 or len(g1[0]) == 0: # sanity check\n return 0\n count = 0\n for i in range(len(g1)):\n for j in range(len(g1[0])):\n if g1[i][j] == g2[i][j] == 1 and search_grid(g1, g2, i, j):\n count = count + 1\n return count","def compute_visit_freq_table(self, episodes):\n visited_states = {state: 0 for state in self._all_states}\n visited_sets_episodes = []\n for episode in episodes:\n visited_set = set()\n if episode.solved:\n visited_set.add(self.goal_state)\n states_batch = [self.obs2tuple(obs) for obs in\n episode.transition_batch.observation]\n for state in states_batch:\n visited_states[state] += 1\n visited_set.add(state)\n self._visited_states_in_history.add(state)\n visited_sets_episodes.append(visited_set)\n if episode.solved:\n visited_states[self.goal_state] += 1\n\n visited_freq = np.mean([len(x) / 3 ** self.n_disks\n for x in visited_sets_episodes])\n visited_states = {state: visited_states[state] /\n (len(episodes) * 3 ** self.n_disks)\n for state in self._all_states}\n return visited_states, visited_freq","def count_paths((min_i, min_j), (max_i, max_j)):\n\n def explore((i, j), path):\n found = 0\n for (x, y) in neighbors((min_i, min_j), (max_i, max_j), (i, j)):\n if (x, y) == (max_i, max_j):\n found += 1\n debug(\"neighbor %r of node %r on path %r is a goal node: +1\" % ((x, y), (i, j), path))\n elif (x, y) in path: \n debug(\"neighbor %r of node %r already on path %r; ignoring...\" % ((x, y), (i, j), path))\n continue\n else:\n debug(\"neighbor %r of node %r not already on path %r; exploring ...\" % ((x, y), (i, j), path))\n found += explore((x, y), mkpath(path, (x, y)))\n return found\n return explore((0, 0), set([(0, 0)]))","def calc_precision_map(self, output_filenm=\"\"):\n logger.info(\"Calculating precision map\")\n success_map, total_map = {}, {} # map from query r to a dict of path and ratio of success\n # not sure why I am getting RuntimeError: dictionary changed size during iteration.\n train_map = [((e1, r), e2_list) for ((e1, r), e2_list) in self.train_map.items()]\n for ((e1, r), e2_list) in tqdm(train_map):\n c = self.args.cluster_assignments[self.entity_vocab[e1]]\n if c not in success_map:\n success_map[c] = {}\n if c not in total_map:\n total_map[c] = {}\n if r not in success_map[c]:\n success_map[c][r] = {}\n if r not in total_map[c]:\n total_map[c][r] = {}\n paths_for_this_relation = self.args.path_prior_map_per_relation[c][r]\n for p_ctr, (path, _) in enumerate(paths_for_this_relation.items()):\n ans = self.execute_one_program(e1, path, depth=0, max_branch=100)\n if len(ans) == 0:\n continue\n # execute the path get answer\n if path not in success_map[c][r]:\n success_map[c][r][path] = 0\n if path not in total_map[c][r]:\n total_map[c][r][path] = 0\n for a in ans:\n if a in e2_list:\n success_map[c][r][path] += 1\n total_map[c][r][path] += 1\n\n precision_map = {}\n for c, _ in success_map.items():\n for r, _ in success_map[c].items():\n if c not in precision_map:\n precision_map[c] = {}\n if r not in precision_map[c]:\n precision_map[c][r] = {}\n for path, s_c in success_map[c][r].items():\n precision_map[c][r][path] = s_c / total_map[c][r][path]\n\n if not output_filenm:\n dir_name = os.path.join(args.data_dir, \"data\", self.args.dataset_name, \"linkage={}\".format(self.args.linkage))\n output_filenm = os.path.join(dir_name, \"precision_map.pkl\")\n logger.info(\"Dumping precision map at {}\".format(output_filenm))\n with open(output_filenm, \"wb\") as fout:\n pickle.dump(precision_map, fout)\n logger.info(\"Done...\")","def count_islands(matrix):\n visited = init_visited(matrix)\n num_islands = 0\n for i in range(len(matrix)):\n for j in range(len(matrix)):\n if matrix[i][j] and not visited[i][j]:\n check_neighbours(matrix, (i, j), visited)\n num_islands += 1\n # print(visited)\n return num_islands","def calc_w_inference(g1, inf_g1, g2, inf_g2, consider_label):\n edges_g1 = np.count_nonzero(g1)\n edges_g2 = np.count_nonzero(g2)\n\n overlap_r1 = 0\n overlap_r2 = 0\n n_nodes = len(g1)\n for i in range(n_nodes):\n for j in range(n_nodes):\n if consider_label:\n if (g1[i][j] != NO_REL_SYMBOL and inf_g2[i][j]!= NO_REL_SYMBOL) and (g1[i][j] == inf_g2[i][j]):\n overlap_r1 += 1 # how much g1 recalls \"populated\"-g2\n if (inf_g1[i][j] != NO_REL_SYMBOL and g2[i][j]!= NO_REL_SYMBOL) and (inf_g1[i][j] == g2[i][j]):\n overlap_r2 += 1 # how much g2 recalls \"populated\"-g2\n else:\n if (g1[i][j] != NO_REL_SYMBOL and inf_g2[i][j]!= NO_REL_SYMBOL):\n overlap_r1 += 1\n if (inf_g1[i][j] != NO_REL_SYMBOL and g2[i][j]!= NO_REL_SYMBOL):\n overlap_r2 += 1\n\n r1 = float(overlap_r1) / float(edges_g1)\n r2 = float(overlap_r2) / float(edges_g2)\n return (r1 + r2) / float(2)","def anchors_to_adjacency(set_path, n_proteomes, mailbox_reader):\n frame_list = []\n for idx in range(n_proteomes):\n with mailbox_reader(idx) as file_handle:\n frame_list.append(\n pd.read_csv(\n file_handle, sep=\"\\t\", index_col=0\n ).convert_dtypes()\n )\n nodes = pd.concat(\n frame_list,\n ignore_index=True,\n )\n del frame_list\n graph = nx.Graph()\n for unused_tuple, subframe in nodes.groupby(\n by=[\"syn.anchor.id\", \"syn.anchor.sub_id\"]\n ):\n ids = subframe[\"member_ids\"]\n n_ids = len(ids)\n graph.add_nodes_from(ids)\n if n_ids > 1:\n edges = combinations(ids, 2)\n graph.add_edges_from(edges, weight=n_ids)\n outpath = set_path / ANCHORS_FILE\n summarypath = outpath.parent / (\n outpath.name[: -len(outpath.suffix)] + \"_summary.tsv\"\n )\n histpath = outpath.parent / (\n outpath.name[: -len(outpath.suffix)] + \"_hist.tsv\"\n )\n components = [\n c\n for c in sorted(nx.connected_components(graph), key=len, reverse=True)\n if len(c) > 1\n ]\n fh = outpath.open(\"w\")\n fh.write(\"idx\\tcluster_id\\tsize\\tmembers\\n\")\n n_items = 0\n count_list = []\n hash_list = []\n id_list = []\n for i, comp in enumerate(components):\n component = np.sort(pd.Index(list(comp)).to_numpy())\n id_list.append(i)\n size = len(comp)\n count_list.append(size)\n hash_list.append(hash_array(component))\n for node in component:\n fh.write(f\"{n_items}\\t{i}\\t{size}\\t{node}\\n\")\n n_items += 1\n fh.close()\n n_clusts = len(count_list)\n del graph, components\n cluster_counts = pd.DataFrame({\"size\": count_list})\n largest_cluster = cluster_counts[\"size\"].max()\n cluster_hist = (\n pd.DataFrame(cluster_counts.value_counts()).sort_index().reset_index()\n )\n cluster_hist = cluster_hist.set_index(\"size\")\n cluster_hist = cluster_hist.rename(columns={0: \"n\"})\n cluster_hist[\"item_pct\"] = (\n cluster_hist[\"n\"] * cluster_hist.index * 100.0 / n_items\n )\n cluster_hist.to_csv(histpath, sep=\"\\t\", float_format=\"%5.2f\")\n cluster_hist[\"cluster_pct\"] = cluster_hist[\"n\"] * 100.0 / n_clusts\n cluster_hist.to_csv(histpath, sep=\"\\t\", float_format=\"%5.2f\")\n clusters = pd.DataFrame(\n {\"anchor.id\": id_list, \"count\": count_list, \"hash\": hash_list}\n )\n clusters.to_csv(summarypath, sep=\"\\t\")\n stats_dict = {\n \"in_anchor\": n_items,\n \"syn.anchors.n\": n_clusts,\n \"syn.anchors.largest\": largest_cluster,\n }\n return stats_dict","def _identify_required_grads(self):\n self.grad_expected += 1\n if self.grad_expected == 1: # only backpropagate once from each node\n for child in self.children:\n child._identify_required_grads()","def compute_sw_threshold(flanking_reads, paf_dict, fasta_dict, window_size):\n\n max_scores = []\n for query, target in itertools.product(flanking_reads, flanking_reads):\n\n if str(query + target) in paf_dict:\n overlap_info = paf_dict[query+target]\n elif str(target + query) in paf_dict:\n # get info and swap them\n overlap_info = paf_dict[target+query]\n query, target = target, query\n else:\n continue\n\n query_start = overlap_info['query_start']\n query_end = overlap_info['query_end']\n target_start = overlap_info['target_start']\n target_end = overlap_info['target_end']\n\n query_seq = fasta_dict[query][query_start:query_end]\n target_seq = fasta_dict[target][target_start:target_end]\n\n # Get scores for this pair; store in cur_scores\n cur_scores = []\n if window_size:\n # Use rolling window\n min_len = min(len(query_seq), len(target_seq))\n for start, end in utils.pairwise(range(0, min_len, window_size)):\n qs = query_seq[start:end]\n ts = target_seq[start:end]\n score = smith_waterman.smith_waterman(qs, ts)\n cur_scores.append(score)\n\n if cur_scores:\n score = max(cur_scores)\n max_scores.append(score)\n else:\n # No rolling window\n score = smith_waterman.smith_waterman(query_seq, target_seq)\n max_scores.append(score)\n\n threshold = 0.9 * max(max_scores)\n\n print(\"using {} as threshold\".format(threshold))\n\n plt.subplot(2, 3, 2)\n plt.hist(max_scores)\n plt.title(\"FLANKING READS\\nhistogram of num_gaps / len(aligned_sequence)\\nthreshold = {}\\nwindow_size = {}\\nshowing {} scores\"\n .format(threshold, window_size, len(max_scores)))\n\n\n\n return threshold","def test_count_gaps(self):\n field = Field.create()\n self.assertEqual(field.count_gaps(), 0)\n\n field = Field.create(generate_valid_state(np.array([\n [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n [1, 0, 1, 0, 1, 1, 1, 1, 1, 1],\n ])))\n self.assertEqual(field.count_gaps(), 0)\n\n field = Field.create(generate_valid_state(np.array([\n [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n ])))\n self.assertEqual(field.count_gaps(), 1)\n\n field = Field.create(generate_valid_state(np.array([\n [1, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n [0, 1, 1, 0, 0, 0, 0, 0, 1, 0],\n [1, 0, 0, 1, 0, 0, 0, 0, 1, 0],\n [0, 0, 0, 1, 0, 0, 0, 1, 1, 1],\n ])))\n self.assertEqual(field.count_gaps(), 6)","def compute_map(ranks, gnd, kappas=[]):\n\n map = 0.\n nq = len(gnd) # number of queries\n aps = np.zeros(nq)\n pr = np.zeros(len(kappas))\n prs = np.zeros((nq, len(kappas)))\n nempty = 0\n\n for i in np.arange(nq):\n qgnd = np.array(gnd[i]['ok'])\n\n # no positive images, skip from the average\n if qgnd.shape[0] == 0:\n aps[i] = float('nan')\n prs[i, :] = float('nan')\n nempty += 1\n continue\n\n try:\n qgndj = np.array(gnd[i]['junk'])\n except:\n qgndj = np.empty(0)\n\n # sorted positions of positive and junk images (0 based)\n pos = np.arange(ranks.shape[0])[np.in1d(ranks[:,i], qgnd)]\n junk = np.arange(ranks.shape[0])[np.in1d(ranks[:,i], qgndj)]\n\n k = 0;\n ij = 0;\n if len(junk):\n # decrease positions of positives based on the number of\n # junk images appearing before them\n ip = 0\n while (ip < len(pos)):\n while (ij < len(junk) and pos[ip] > junk[ij]):\n k += 1\n ij += 1\n pos[ip] = pos[ip] - k\n ip += 1\n\n # compute ap\n ap = compute_ap(pos, len(qgnd))\n map = map + ap\n aps[i] = ap\n\n # compute precision @ k\n pos += 1 # get it to 1-based\n for j in np.arange(len(kappas)):\n kq = min(max(pos), kappas[j]); \n prs[i, j] = (pos <= kq).sum() / kq\n pr = pr + prs[i, :]\n\n map = map / (nq - nempty)\n pr = pr / (nq - nempty)\n\n return map, aps, pr, prs","def compute_probability_weights(indexing, \n counts, \n image, \n binary_set_mappings): \n S_w_cardinalities = np.zeros_like(indexing)\n\n countsgeq2 = sum(c>=2 for c in counts) # compute amount of indices that have count>=2\n countseq1 = [v for v in range(indexing.shape[0]) if counts[indexing[v]]==1]\n K_cardinalities = np.zeros_like(indexing)\n for card,w in enumerate(countseq1[::-1]):\n K_cardinalities[w] = card\n\n for w,index in enumerate(indexing):\n if counts[index] >= 3:\n S_w_cardinalities[w] = len(image)\n elif counts[index] == 2:\n offset = 1 if w==binary_set_mappings[index] else 0\n S_w_cardinalities[w] = len(image) - 1 + offset\n elif counts[index] == 1:\n S_w_cardinalities[w] = countsgeq2 + K_cardinalities[w]\n\n return S_w_cardinalities/np.sum(S_w_cardinalities)","def get_GNS_cut(self):\n # we build the optimization around the casted digraph instead of multidigraph\n # for simplicity\n G = self.base_digraph\n s_1 = self.sources[0]\n s_2 = self.sources[1]\n t_1 = self.destinations[0]\n t_2 = self.destinations[1]\n edges = G.edges()\n nodes = G.nodes()\n\n try:\n\n # Great an gurobi instance of the optimization model\n m = Model(\"GNS\")\n m.setParam('OutputFlag', False)\n\n x_v = {}\n # vertex variables for s_1, t_1 cut\n for v in nodes:\n x_v[v] = m.addVar(vtype=GRB.BINARY)\n\n x_e = {}\n # edge variables for s_1, t_1 cut\n for (u,v) in edges:\n x_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n y_v = {}\n # vertex variables for s_2, t_2 cut\n for v in nodes:\n y_v[v] = m.addVar(vtype=GRB.BINARY)\n\n y_e = {}\n # edge variables for s_2, t_2 cut\n for (u,v) in edges:\n y_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n z_v = {}\n # vertex variables for s_2, t_1 cut\n for v in nodes:\n z_v[v] = m.addVar(vtype=GRB.BINARY)\n\n z_e = {}\n # edge variables for s_2, t_1 cut\n for (u,v) in edges:\n z_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n e = {}\n # GNS indicator variable\n for (u,v) in edges:\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\n\n # Done with decision variable creation\n # update model\n m.update()\n\n # Constraints\n # 1. Constraints for s_1 - t_1 cut\n for (u,v) in edges:\n if (u,v) == (s_1, t_1):\n m.addConstr(x_e[u,v] >= 1)\n elif u == s_1:\n m.addConstr(x_v[v] + x_e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-x_v[u] + x_e[u,v] >= 0)\n else:\n m.addConstr(x_v[v] - x_v[u] + x_e[u,v] >= 0)\n\n # 2. Constraints for s_2 - t_2 cut\n for (u,v) in edges:\n if (u,v) == (s_2, t_2):\n m.addConstr(y_e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(y_v[v] + y_e[u,v] >= 1)\n elif v == t_2:\n m.addConstr(-y_v[u] + y_e[u,v] >= 0)\n else:\n m.addConstr(y_v[v] - y_v[u] + y_e[u,v] >= 0)\n\n # 3. Constraints for s_2 - t_1 cut\n for (u,v) in edges:\n if (u,v) == (s_2, t_1):\n m.addConstr(z_e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(z_v[v] + z_e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-z_v[u] + z_e[u,v] >= 0)\n else:\n m.addConstr(z_v[v] - z_v[u] + z_e[u,v] >= 0)\n\n # 4. Constraints for e[u,v] >= max(x_e[u,v], y_e[u,v], z_e[u,v])\n for (u,v) in edges:\n m.addConstr(e[u,v] >= x_e[u,v])\n m.addConstr(e[u,v] >= y_e[u,v])\n m.addConstr(e[u,v] >= z_e[u,v])\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n print \"Min GNS cut value = \" + str(m.objVal)\n print \"GNS cut edges:\"\n\n for u,v in edges:\n if e[u,v].x != 0:\n print (u,v)\n print \"s1-t1 cut edges in GNS:\"\n for u,v in edges:\n if x_e[u,v].x != 0:\n print (u,v)\n\n print \"s2-t2 cut edges in GNS:\"\n for u,v in edges:\n if y_e[u,v].x != 0:\n print (u,v)\n\n print \"s2-t1 cut edges in GNS:\"\n for u,v in edges:\n if z_e[u,v].x != 0:\n print (u,v)\n else:\n # something went wrong...err...\n print \"Something was wrong\"\n\n except GurobiError:\n print ('Error report from Gurobi')","def count_genes(node_id):\n node = tree.node(node_id)\n\n if options.loglevel >= 6:\n options.stdlog.write(\"# node_id=%i\\n\" % node_id)\n if options.loglevel >= 10:\n options.stdlog.write(\"# sets=%s\\n\" % (str(genes)))\n\n # species in pattern\n num_species_in_pattern = len(positive_set)\n\n if node.succ:\n # process non-leaf node\n for s in node.succ:\n\n # propagate: terminated nodes force upper nodes to terminate\n # (assigned to None).\n if not genes[s]:\n genes[node_id] = None\n return\n\n # total number of genes at node\n num_genes_at_node = 0\n # total number of species at node\n num_species_at_node = 0\n\n # compute new gene set for each species at node\n for x in positive_set:\n genes[node_id][x] = genes[node_id][x].union(genes[s][x])\n\n num_genes_for_species = len(genes[node_id][x])\n if exit_function(num_genes_for_species):\n genes[node_id] = None\n return\n num_genes_at_node += num_genes_for_species\n if num_genes_for_species:\n num_species_at_node += 1\n\n if options.loglevel >= 6:\n print \"node=\", node_id, \"species_at_node\", num_species_at_node, \"genes_at_node=\", num_genes_at_node, \\\n \"num_genes_for_species=\", num_genes_for_species, \"ngenes=\", sum(\n map(lambda x: len(x), genes[node_id]))\n options.stdlog.write(\n \"# genes at node %i\\t%s\\n\" % (node_id, genes[node_id]))\n if outgroups:\n print sum([len(genes[node_id][x]) for x in outgroups])\n print check_outgroup_function(genes[node_id])\n\n # check stop criterion\n if total_species_function(num_species_at_node, num_species_in_pattern):\n # check if positive requirements are fulfilled\n for x in positive_set:\n if not keep_function(len(genes[node_id][x])):\n if options.loglevel >= 6:\n options.stdlog.write(\n \"# keep function false for species %i\\n\" % x)\n break\n else:\n if total_genes_function(num_genes_at_node, num_species_in_pattern):\n if options.loglevel >= 6:\n options.stdlog.write(\"# recording node %i\\n\" % x)\n ortholog_nodes.append((node_id, genes[node_id]))\n genes[node_id] = None\n return\n elif check_outgroup_function(genes[node_id]):\n ortholog_nodes.append((node_id, genes[node_id]))\n genes[node_id] = None\n return\n elif negative_set:\n if total_genes_function(num_genes_at_node, num_species_in_pattern):\n if options.loglevel >= 6:\n options.stdlog.write(\"# recording node %i\\n\" % node_id)\n ortholog_nodes.append((node_id, genes[node_id]))\n\n else:\n # process leaf\n s, t, g, q = parseIdentifier(node.data.taxon, options)\n c = options.org2column[s]\n if c in positive_set:\n genes[node_id][c].add(g)\n elif c in negative_set:\n genes[node_id] = None","def cal_pn(grams_set, grams, candidate, reference):\n count = 0\n for gram in grams_set:\n # print(gram)\n count += count_clip(gram, grams, reference)\n # calculate log() for p, so '+10**-8' avoid 'p==0'\n p = count / len(grams) + 10**-8 \n return p","def compute_detection_counts(kinds, valid_mask, aoi_mask, scene_counts):\n scene_counts = np.maximum(scene_counts, 1)\n if len(kinds):\n pairs = (kinds == 'pair_trawlers')\n singles = (kinds == 'single_trawler')\n scales = (kinds == 'pair_trawlers') * 2 + (kinds == 'single_trawler')\n aoi_pts = round((scales * (valid_mask & aoi_mask) / scene_counts).sum(), 1) \n aoi_pairs = round((pairs * (valid_mask & aoi_mask) / scene_counts).sum(), 1) \n else:\n aoi_pts = aoi_pairs = 0\n return aoi_pts, aoi_pairs","def graph_count(self) -> int:\n return int(self.graph_tuple_stats.graph_count)","def branchNBound(nationtxt, bound, scheme):\n provinces = []\n index = 0\n costs = 0\n numTransmitters = 7\n\n transmitterCosts = scheme\n nation = nationLoader(nationtxt)\n\n\n neighborCount = {}\n for province in nation:\n neighborCount.update({province:len(nation.get(province)[0])})\n\n\n #~ neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__)\n\n neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__, reverse=True)\n\n for key in neighborCountSorted:\n provinces.append(key)\n #~ print provinces\n\n upperbound = bound\n #~ print bound\n #~ print bound\n\n\n\n solution = []\n\n\n counter = 0\n\n\n\n\n\n while index >= 0:\n\n\n counter += 1\n if counter % 100000000 == 0:\n print counter\n print \"Now at:\", nation\n\n\n if index == -1:\n break\n\n # Assign transmitter\n if nation[provinces[index]][1] == numTransmitters:\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n else:\n costs, index = updateTransmitter(nation, False, scheme, provinces, costs, index)\n\n # Check if costs are above upper bound\n if (costs + (len(provinces) - (index + 1)) * transmitterCosts[0]) > upperbound:\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n # Check if a neighbor has the same transmitter\n conflict = False\n for neighbor in nation[provinces[index]][0]:\n if nation[neighbor][1] == nation[provinces[index]][1]:\n conflict = True\n break\n\n if conflict:\n continue\n\n # Check if a solution is found\n if index == len(provinces) - 1:\n #~ print \"\\nSOLUTION:\"\n if costs < upperbound:\n solution = []\n solution.append(json_deep_copy(nation))\n upperbound = costs\n #~ print \"Score:\", upperbound\n #~ print nation\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n index += 1\n\n\n usedTrans = []\n fivePlus = 0\n fivePlusNoDuplicate = 0\n\n for nation in solution:\n\n one = 0\n two = 0\n three = 0\n four = 0\n five = 0\n six = 0\n seven = 0\n\n for province in nation:\n\n if nation[province][1] == 1:\n one += 1\n if nation[province][1] == 2:\n two += 1\n if nation[province][1] == 3:\n three += 1\n if nation[province][1] == 4:\n four += 1\n if nation[province][1] == 5:\n five += 1\n if nation[province][1] == 6:\n six += 1\n if nation[province][1] == 7:\n seven += 1\n\n\n if five > 0 or six > 0 or seven > 0:\n fivePlus += 1\n if transmitterCosts[3] != transmitterCosts[4]:\n fivePlusNoDuplicate += 1\n\n usedTrans.append([one, two, three, four, five, six, seven])\n\n return fivePlus, fivePlusNoDuplicate, usedTrans, upperbound, len(solution), counter\n #~ f.write(\"\\n Used Transmitters: \"+ str(one)+\" \"+ str(two)+\" \"+ str(three)+\" \"+ str(four)+\" \"+ str(five)+\" \"+ str(six)+\" \"+ str(seven)+\"\\n Cost: \"+str(upperbound)+\"\\n Number of solutions: \"+str(len(solution))+\"\\n Iterations: \"+str(counter)+\"\\n\"+\"\\n\"+\"\\n\"+\"\\n\")\n\n #~ print \"transmitter frequecies:\", one, two, three, four, five, six, seven\n #~ print \"Solutions:\", solution\n #~ print \"Cost:\", upperbound\n #~ print \"Number of solutions:\", len(solution)\n #~ print \"Iterations:\", counter","def caculate_network_statistics(self):\n divide_factor_sum = 0 \n for key in self.stars.keys():\n star = self.stars[key]\n if star.nb_num == 0 :\n self.standalone_star_num += 1 \n\n divide_factor = star.nb_num + 2 * (star.spec_num - star.shared_spec_num )/self.ave_starlet_size\n divide_factor_sum += divide_factor\n divide_factor_int = round(divide_factor)\n self.star_divide_factor_dist[divide_factor_int] = self.star_divide_factor_dist.get(divide_factor_int,0) + 1\n if star.spec_num < star.shared_spec_num:\n print(\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\")\n print(\"with star \" + star.id + \" \" + str(star.spec_num) + \"is less than\" + str(star.shared_spec_num))\n if star.spec_num > star.shared_spec_num:\n self.star_lost_spec_num += star.spec_num - star.shared_spec_num\n self.ave_divide_factor_star = divide_factor_sum/self.stars_length\n\n divide_factor_sum = 0 \n for key in self.starlets.keys():\n starlet = self.starlets[key]\n if starlet.nb_num == 0 :\n self.standalone_starlet_num += 1 \n\n divide_factor = starlet.nb_num + 2 * (starlet.spec_num - starlet.shared_spec_num )/self.ave_star_size\n divide_factor_sum += divide_factor\n divide_factor_int = round(divide_factor)\n self.starlet_divide_factor_dist[divide_factor_int] = self.starlet_divide_factor_dist.get(divide_factor_int,0) + 1\n if starlet.spec_num < starlet.shared_spec_num:\n print(\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\")\n print(\"with star \" + starlet.id + \" \" + str(starlet.spec_num) + \"is less than\" + str(starlet.shared_spec_num))\n if starlet.spec_num > starlet.shared_spec_num:\n self.starlet_lost_spec_num += starlet.spec_num - starlet.shared_spec_num\n self.ave_divide_factor_starlet = divide_factor_sum/self.starlets_length","def num_edges(self):\r\n return len(self.__generate_edges())","def edge_mapping(self):\n ...","def connected_set_sizes(self):\n self._assert_counted_at_lag()\n return self._connected_set_sizes","def graph_helper(device, output,input,target):\n output = output.clone().squeeze()\n corrects = torch.zeros(output.shape[0])\n for i in range(output.shape[0]): # goes through each iteration\n outputi = output[i]\n golden_label = convert_to_bits(device, outputi, input)\n target = target.view(target.size(0), -1)\n corrects[i] += torch.amin(golden_label == target, dim=[0]).sum().item() # counts the number that are the same i.e. correct predictions\n correct = corrects.cpu().detach().numpy()\n return correct","def _n_regions_to_allocate(send_buffering, recording):\n if recording and send_buffering:\n return 5\n if recording or send_buffering:\n return 4\n return 3","def _tally_limits(self, limits, elements, connections=None):\n counts = {}\n for x in limits:\n ele = elements[x]\n if self.use_coordination:\n ele += str(len(connections[x]))\n if ele not in counts:\n counts[ele] = 0\n counts[ele] += 1\n return counts","def a_star(my_map, start_locs, goal_locs, h_values, agent, constraints):\n\n ##############################\n # Task 1.1: Extend the A* search to search in the space-time domain\n # rather than space domain, only.\n # Build constraint table if there are constraints\n\n constraint_table = build_constraint_table(constraints, agent)\n\n open_list = []\n closed_list = dict()\n nodes_opened = 0\n max_opened = 500\n start_loc = start_locs[0]\n goal_loc = goal_locs[0]\n if len(start_locs) > 1: # If there is more than 1 start location then this is a multi-cell agent\n multi = True\n else:\n multi = False\n\n # determine when the last constraint is on the goal node (or any of the goal node cells in the case of multi-cell)\n earliest_goal_timestep = 0\n if len(constraint_table) != 0:\n for time in [item for item in sorted(list(constraint_table.keys()), reverse=True)]:\n flat_list = [item for sublist in constraint_table[time] for item in sublist]\n if(goal_locs[0] in flat_list):\n earliest_goal_timestep = time\n break\n elif(multi): # if multi cell check if any of the agents goal cells are constrained \n if(goal_locs[1] in flat_list): \n earliest_goal_timestep = time\n break\n\n h_value = h_values[start_loc]\n goal_orientation = orientation(goal_locs)\n\n root = {'loc': start_loc,'orientation': orientation(start_locs), 'g_val': 0, 'h_val': h_value, 'time': 0, 'parent': None}\n push_node(open_list, root)\n closed_list[(root['loc'], root['time'], root['orientation'])] = root\n\n while len(open_list ) > 0 and nodes_opened < max_opened:\n curr = pop_node(open_list)\n nodes_opened = nodes_opened + 1\n \n if curr['loc'] == goal_loc and curr['orientation'] == goal_orientation and curr['time'] >= earliest_goal_timestep:\n return get_path(curr)\n ############################\n child_orient = curr['orientation']\n for dir in range(7):\n if dir < 5:\n child_loc = move(curr['loc'], dir)\n elif not multi: \n continue\n\n if dir == 5:\n # clockwise rotation \n child_orient = curr['orientation'] - 1\n if child_orient < 1:\n child_orient = 4\n if dir == 6:\n # counter-clockwise rotation \n child_orient = curr['orientation'] + 1\n if child_orient > 4:\n child_orient = 1\n \n if test_map(my_map, child_loc[0], child_loc[1], child_orient, dir):\n continue\n \n # check if the head location is constrained \n if is_constrained(curr['loc'], child_loc, child_orient, dir, curr['time'] + 1, constraint_table):\n continue\n\n # if this is a multi cell agent check if the tail is constrained \n if multi:\n # check the next tail location \n row_t, col_t, _, _ = find_tail_positions(curr['loc'][0], curr['loc'][1], curr['orientation'], dir)\n next_row_t, next_col_t, next_row_t_inter, next_col_t_inter = find_tail_positions(child_loc[0], child_loc[1], child_orient, dir)\n\n if is_constrained((row_t,col_t), (next_row_t, next_col_t), child_orient, dir, curr['time'] + 1, constraint_table):\n continue\n\n # if the agent is rotating check if the intermediate location is constrained\n if dir == 5 or dir == 6: \n if is_constrained((row_t,col_t), (next_row_t_inter, next_col_t_inter), child_orient, dir, curr['time'] + 1, constraint_table):\n continue\n\n child = {'loc': child_loc,\n 'orientation': child_orient,\n 'g_val': curr['g_val'] + 1,\n 'h_val': h_values[child_loc] + orient_cost(child_orient, goal_orientation),\n 'time': curr['time'] + 1,\n 'parent': curr}\n\n if (child['loc'], child['time'], child['orientation']) in closed_list:\n existing_node = closed_list[(child['loc'], child['time'], child['orientation'])]\n \n if compare_nodes(child, existing_node):\n closed_list[(child['loc'], child['time'], child['orientation'])] = child\n push_node(open_list, child)\n else:\n closed_list[(child['loc'], child['time'], child['orientation'])] = child\n push_node(open_list, child)\n \n return None # Failed to find solutions","def _number_of_edges(self):\n if self._edges is None:\n return 0\n return len(self._edges)","def baseline_score(self,t0,t1):\n return len(set(t0) & set(t1))/len(set(t0).union(set(t1)))","def trio_hits(l_contig, mid_contig_end, blast_hits, olap_dict, cont_dict):\n mid_contig = mid_contig_end.split(\"prime_\")[1]\n length_mid = len(cont_dict[mid_contig].seq) \n right_links = []\n right_links = list(olap_dict[mid_contig_end].keys())\n \n #If contigs are chromosomal, ensure they are adjacent\n if chr_links:\n if l_contig in chr_links: \n new_right_links= []\n for r_l in right_links:\n if r_l not in chr_links or r_l in chr_links[l_contig]:\n new_right_links.append(r_l)\n right_links = new_right_links \n \n if len(right_links) == 1:\n outcome = right_links[0]\n elif len(right_links) == 0:\n outcome = \"link_listempty\"\n else:\n left_matches = []\n for hit in blast_hits:\n if (hit[0] == l_contig) and (int(hit[11]) >= l_min_score):\n left_matches.append(hit)\n link_count = {}\n for link in right_links:\n \n right_matches = []\n\n for hit in blast_hits:\n if (hit[0] == link) and (int(hit[11]) >= r_min_score): \n right_matches.append(hit)\n \n for lhit in left_matches:\n for rhit in right_matches:\n if lhit[1] == rhit[1]:\n lh_start = int(lhit[8])\n lh_end = int(lhit[9])\n rh_start = int(rhit[8])\n rh_end = int(rhit[9])\n if abs(lh_start - rh_start) < length_mid + 100:\n if (lh_end - lh_start)/(rh_end - rh_start) < 0:\n if abs(lh_end - rh_end) > abs(lh_start - rh_start):\n link_score = int(lhit[11]) * int(rhit[11])\n if not link in link_count: \n link_count[link] = link_score\n elif link_score > link_count[link]:\n link_count[link] = link_score\n \n number_of_matches = len(link_count)\n if number_of_matches == 1:\n outcome = list(link_count.keys())[0]\n if number_of_matches == 0:\n outcome = \"link_unmatched\"\n if number_of_matches > 1:\n outcome = max(link_count, key = link_count.get)\n\n return outcome","def count_accuracy(G_true, G):\n B_true = G_true != 0# nx.to_numpy_array(G_true) != 0\n B = G != 0# nx.to_numpy_array(G) != 0\n d = B.shape[0]\n # linear index of nonzeros\n pred = np.flatnonzero(B)\n cond = np.flatnonzero(B_true)\n cond_reversed = np.flatnonzero(B_true.T)\n cond_skeleton = np.concatenate([cond, cond_reversed])\n # true pos\n true_pos = np.intersect1d(pred, cond, assume_unique=True)\n\n # false pos\n false_pos = np.setdiff1d(pred, cond_skeleton, assume_unique=True)\n # reverse\n extra = np.setdiff1d(pred, cond, assume_unique=True)\n reverse = np.intersect1d(extra, cond_reversed, assume_unique=True)\n # compute ratio\n pred_size = len(pred)\n cond_neg_size = 0.5 * d * (d - 1) - len(cond)\n fdr = float(len(reverse) + len(false_pos)) / max(pred_size, 1)\n tpr = float(len(true_pos)) / max(len(cond), 1)\n fpr = float(len(reverse) + len(false_pos)) / max(cond_neg_size, 1)\n # structural hamming distance\n B_lower = np.tril(B + B.T)\n pred_lower = np.flatnonzero(B_lower)\n cond_lower = np.flatnonzero(np.tril(B_true + B_true.T))\n extra_lower = np.setdiff1d(pred_lower, cond_lower, assume_unique=True)\n missing_lower = np.setdiff1d(cond_lower, pred_lower, assume_unique=True)\n shd = len(extra_lower) + len(missing_lower) + len(reverse)\n return shd, tpr, fpr, fdr, pred_size","def num_edges(self):\n return sum(len(v.adj) for v in self.vertices.values())","def labelled_attachment(gold_trees, pred_trees):\n count_match, count_total = 0, 0\n for gold, pred in zip(gold_trees, pred_trees):\n triples_pairs = zip(\n gold.get_triples(include_root=True),\n pred.get_triples(include_root=True),\n )\n for (g_src, g_trg, g_rel), (p_src, p_trg, p_rel) in triples_pairs:\n assert g_src == p_src\n count_total += 1\n if g_trg == p_trg and g_rel == p_rel:\n count_match += 1\n if count_match == 0 or count_total == 0:\n return 0.0\n else:\n return float(count_match) / count_total","def score(tmp_dir, locusList, ranges):\r\n\t\r\n\tloc = ''\r\n\tpos = 1\r\n\tcount_indel = 0\r\n\tholes = 0\r\n\tsnps = 0\r\n\tcovMax=combined_covMax=covSum=covSum2= 0 \r\n\tcovMin = combined_covMin =99999\r\n\tpercentage_coverages =[]\r\n\tsnpList = []\r\n\tindelList = []\r\n\tresults = {} \r\n\t\r\n\tpileup_file = os.path.join(tmp_dir, 'all.pileup')\r\n\tfor l in open(pileup_file):\r\n\t\tt = l.split()\r\n\t\tif loc == '':\r\n\t\t\tloc = t[0] \r\n\t\t\tpos = ranges[loc][0] + 1 \r\n\t\tif t[0] != loc:\r\n\t\t\tresults =GenerateResult(ranges,\r\n\t\t\t\t\t\t\t\t\tholes, locusList,\r\n\t\t\t\t\t\t\t\t\tloc,snps,count_indel,\r\n\t\t\t\t\t\t\t\t\tsnpList, indelList,\r\n\t\t\t\t\t\t\t\t\tpercentage_coverages,combined_covMin,\r\n\t\t\t\t\t\t\t\t\tcombined_covMax, covMin, covMax,covSum, results)\r\n\t\t\t# reset locus vars\r\n\t\t\tloc = t[0] \r\n\t\t\tpos = ranges[loc][0] + 1 \r\n\t\t\tcount_indel = 0\r\n\t\t\tholes =snps=covMax=combined_covMax=covSum=covSum2= 0 \r\n\t\t\tcovMin =combined_covMin= 99999\r\n\t snpList = []\r\n\t\t\tindelList = []\r\n\t\t\tpercentage_coverages =[]\r\n\t\there = int(t[1])\r\n\t\tif here - 1 < ranges[loc][0]: \r\n\t\t\tcontinue\r\n\t\telif here - 1 >= ranges[loc][1]: \r\n\t\t\tcontinue\r\n\t\twhile pos < here: \r\n\t\t\tholes += 1 \r\n\t\t\tpos += 1\r\n\r\n\t\tv, indel, array_of_all_indels,most_common_indel = pile(t[2], t[4])\r\n\t\tx = v.items()\r\n\t\tx.sort(lambda a,b: compGreater(t[2], a, b))\r\n\t\t\r\n\t\tif x[0][0] != t[2].lower():\r\n\t\t\tsnps += 1\r\n\t\t\tsnpList.append((pos,t[2],v));\r\n\t\tc = x[0][1] \r\n\t\tcov= int(most_common_indel)/float(t[3]) \r\n\t\tif cov > 0.5: \r\n count_indel += 1\r\n indel_type = Counter(array_of_all_indels) \r\n indel_type = indel_type.items()\r\n indelList.append((int(pos),t[2], indel_type))\r\n\t\tcovSum += c \r\n\t\tcovSum2 += c * c\r\n\t\tif c > covMax:\r\n\t\t\tcovMax = c\r\n\t\tif c < covMin:\r\n\t\t\tcovMin = c\r\n\t\tcombined_c = x[0][1] + x[1][1] + x[2][1] + x[3][1] \r\n\t\tif combined_c > combined_covMax:\r\n\t\t\tcombined_covMax = c \r\n\t\tif combined_c < combined_covMin:\r\n\t\t\tcombined_covMin = c \r\n\t\t\r\n\t\tn = int(t[3]) \r\n\t\tjs = []\r\n\t\tfor (_,j) in x[1:]: \r\n\t\t\tjs.append(j) \r\n\t\tpercentage_coverage = sum(js)/float(n)*100 \r\n\t\tpercentage_coverages.append(round(float(percentage_coverage),2))\r\n\t\tpos = here + 1\r\n\tresults =GenerateResult(ranges,\r\n\t\t\t\t\t\t\tholes,\r\n\t\t\t\t\t\t\tlocusList,loc,\r\n\t\t\t\t\t\t\tsnps,count_indel,\r\n\t\t\t\t\t\t\tsnpList,indelList,\r\n\t\t\t\t\t\t\tpercentage_coverages,combined_covMin,\r\n\t\t\t\t\t\t\tcombined_covMax, covMin, covMax,\r\n\t\t\t\t\t\t\tcovSum, results)\r\n\t\r\n\treturn results","def __create_d_map(self):\n goal_map = {}\n # collect all goal nodes\n for i, row in enumerate(self.map.get_node_grid()):\n for j, node in enumerate(row):\n if node.borders_tile_of_type(Quarantine):\n goal_map[node.get_name()] = (i, j)\n # calculate distance to closest goal node for each node\n for i, row in enumerate(self.map.get_node_grid()):\n for j, node in enumerate(row):\n distances = [\n abs(i - y) + abs(j - x)\n for node_name, (y, x) in goal_map.items()\n ]\n self.d_map[node.get_name()] = min(distances)","def getNet(chrom, loops, genes, pdis=2000, gap=1):\n #step 1 get merged anchors\n anchors = stichAnchors(chrom, loops, margin=gap)\n #step 2 annotate anchors\n nanchors = {}\n ts = np.array([[tss] for tss in genes.keys()])\n tree = KDTree(ts)\n for anchor in anchors:\n gs, ds = findOverlapOrNearest(genes, ts, tree, anchor.start,\n anchor.end)\n if len(gs) > 1:\n t = \"Promoter\"\n d = 0\n else:\n d = ds[0]\n if abs(d) <= pdis:\n t = \"Promoter\"\n else:\n t = \"Enhancer\"\n n = anchor.chrom + \":\" + str(anchor.start) + \"-\" + str(\n anchor.end) + \"|\" + t\n nanchors[n] = {\n \"chrom\":\n anchor.chrom,\n \"start\":\n anchor.start,\n \"end\":\n anchor.end,\n \"type\":\n n.split(\"|\")[-1],\n \"nearestDistanceToTSS\":\n d,\n \"nearestGene\":\n \",\".join([g.name for g in gs]),\n \"nearestGeneLoc\":\n \",\".join([\n g.chrom + \":\" + str(g.start) + \"-\" + str(g.end) + \"|\" +\n g.strand + \"|\" + g.name for g in gs\n ])\n }\n anchors = nanchors\n del nanchors\n #step 3 assign each anchor to merged annotated anchor and build the network\n anchorCov = {}\n for k, v in anchors.items():\n for i in range(v[\"start\"], v[\"end\"] + 1):\n anchorCov[i] = k\n ds = {} #anchor annotations\n nets = {} #net information\n G = nx.Graph() #networkx graph structure\n for loop in loops:\n xt, yt = None, None\n for i in range(loop.x_start, loop.x_end + 1):\n if i in anchorCov:\n xt = anchorCov[i]\n break\n for i in range(loop.y_start, loop.y_end + 1):\n if i in anchorCov:\n yt = anchorCov[i]\n break\n ds[loop.id] = {\n \"mergedAnchorA\": xt,\n \"mergedAnchorB\": yt,\n }\n if xt == yt:\n continue\n ns = [xt, yt]\n ns.sort() #sort for converging keys\n if ns[0] not in nets:\n nets[ns[0]] = set()\n nets[ns[0]].add(ns[1])\n #network edges\n G.add_edge(ns[0], ns[1])\n #step 4 find all enhancers linked to target gene\n targets = {}\n #step 4.1 find the direct enhancer that link to promoter\n for node in G.nodes:\n if node.split(\"|\")[-1] == \"Promoter\":\n if node in targets:\n continue\n targets[node] = {\n \"targetGene\": anchors[node][\"nearestGeneLoc\"],\n \"directEnhancer\": set(),\n \"indirectEnhancer\": set(),\n \"directPromoter\": set(),\n \"indirectPromoter\": set()\n }\n ns = list(nx.descendants(G, node))\n #find all releated nodes\n for n in ns:\n p = nx.algorithms.shortest_path(G, source=node, target=n)\n if n.split(\"|\")[-1] == \"Promoter\":\n if len(p) == 2:\n targets[node][\"directPromoter\"].add(n)\n else:\n targets[node][\"indirectPromoter\"].add(n)\n if n.split(\"|\")[-1] == \"Enhancer\":\n if len(p) == 2:\n targets[node][\"directEnhancer\"].add(n)\n else:\n targets[node][\"indirectEnhancer\"].add(n)\n #step 4.2. find hub enhancer\n #only using non-redundant node to find hubs\n nns = []\n tmp = set()\n for n in ns:\n tn = n.split(\"|\")[0]\n if tn not in tmp:\n nns.append(n)\n tmp.add(tn)\n ns = list(nns)\n ns.append(node)\n subg = G.subgraph(ns)\n try:\n hubs, authorities = nx.hits(subg,\n max_iter=1000,\n normalized=True)\n except:\n print(\n \"For %s, hard to find the hub by running HITS algorithm of 1000 iteration.\"\n % node)\n targets[node][\"directEnhancerHub\"] = \"\"\n targets[node][\"indirectEnhancerHub\"] = \"\"\n continue\n hubs = pd.Series(hubs)\n hubs = hubs.sort_values(inplace=False, ascending=False)\n if len(targets[node][\"directEnhancer\"]) >= 2:\n des = hubs[list(targets[node][\"directEnhancer\"])]\n des = des.sort_values(inplace=False, ascending=False)\n targets[node][\"directEnhancerHub\"] = des.index[0]\n else:\n targets[node][\"directEnhancerHub\"] = \"\"\n if len(targets[node][\"indirectEnhancer\"]) >= 2:\n indes = hubs[list(targets[node][\"indirectEnhancer\"])]\n indes = indes.sort_values(inplace=False, ascending=False)\n targets[node][\"indirectEnhancerHub\"] = indes.index[0]\n else:\n targets[node][\"indirectEnhancerHub\"] = \"\"\n return anchors, ds, nets, targets","def edgecount(self):\n\n raise NotImplementedError","def update_cnt_map(self,s):\r\n cnts = []\r\n num_grid = self.cnt_map.shape[0]*self.cnt_map.shape[1]\r\n old_coverage =num_grid- self.cnt_map.flatten().tolist().count(0)\r\n for sj in s:\r\n grid_s = self.get_gridState(sj)\r\n self.cnt_map[grid_s[0], grid_s[1]] += 1\r\n cnts.append(self.cnt_map[grid_s[0], grid_s[1]])\r\n\r\n self.map_coverage = num_grid - self.cnt_map.flatten().tolist().count(0)\r\n print(\"Coverage:\",self.map_coverage)\r\n print(\"Change of coverage:\",self.map_coverage-old_coverage)\r\n\r\n return cnts","def num_vertex_sets(self, r):\n return sage.all.binomial(self.n, r)","def _measure(d, sources, target, niter=25, bound=None):\n uniques = {}\n for source in sources:\n others = list(sources)\n others.remove(source)\n others = list(flatten(others))\n uniques[source] = one_way_skar(d, source, target, others)\n return uniques","def num_accepts(self, max_len: int, bound: Sequence[Text] = ()) -> Tuple[int, int, int]:\n lt1: Dict[FrozenSet[int], int] = collections.defaultdict(int)\n lt2: Dict[FrozenSet[int], int] = collections.defaultdict(int)\n eq1: Dict[FrozenSet[int], int] = collections.defaultdict(int)\n eq2: Dict[FrozenSet[int], int] = collections.defaultdict(int)\n gt1: Dict[FrozenSet[int], int] = collections.defaultdict(int)\n gt2: Dict[FrozenSet[int], int] = collections.defaultdict(int)\n eq1[frozenset(self.start_nodes)] = 1\n num_accepted_le = int(self.accepts(\"\"))\n num_accepted_gt = 0\n for c in itertools.islice(itertools.chain(bound, itertools.repeat(None)), 0, max_len):\n for nodes, count in lt1.items():\n for element in self.possible_transitions(nodes):\n next_nodes = frozenset(self.next_nodes(nodes, element))\n lt2[next_nodes] += count\n for nodes, count in eq1.items():\n for element in self.possible_transitions(nodes):\n next_nodes = frozenset(self.next_nodes(nodes, element))\n if c is None or (element is not None and element > c):\n gt2[next_nodes] += count\n elif element == c:\n eq2[next_nodes] += count\n else:\n lt2[next_nodes] += count\n for nodes, count in gt1.items():\n for element in self.possible_transitions(nodes):\n next_nodes = frozenset(self.next_nodes(nodes, element))\n gt2[next_nodes] += count\n num_accepted_le += self._sum_tables(eq2)\n num_accepted_le += self._sum_tables(lt2)\n num_accepted_gt += self._sum_tables(gt2)\n if not lt2 and not eq2 and not gt2:\n break # Exit early if we know this regex cannot accept anymore strings.\n lt1, lt2 = lt2, collections.defaultdict(int)\n eq1, eq2 = eq2, collections.defaultdict(int)\n gt1, gt2 = gt2, collections.defaultdict(int)\n num_accepted_eq = int(len(bound) <= max_len and self.accepts(bound))\n return num_accepted_le - num_accepted_eq, num_accepted_eq, num_accepted_gt","def ngraphs(self):\n return len(self.__graph_list)"],"string":"[\n \"def countEdges(self):\\n n = 0\\n for (hub, table) in self.totsupport.iteritems():\\n n += len(table)\\n return n\",\n \"def community_quality(communities, spanset, gapset):\\n if len(communities) != 2:\\n return -1\\n\\n com_sets = [set(c) for c in communities]\\n spanset = set(spanset)\\n gapset = set(gapset)\\n\\n spanset_0 = len(com_sets[0].difference(spanset))\\n spanset_1 = len(com_sets[1].difference(spanset))\\n gapset_0 = len(com_sets[0].difference(gapset))\\n gapset_1 = len(com_sets[1].difference(gapset))\\n\\n # used for determining which community corresponds to gapset and spanset\\n spanset_i = 1 - np.argmax([spanset_0, spanset_1])\\n gapset_i = 1 - np.argmax([gapset_0, gapset_1])\\n\\n if spanset_i == gapset_i:\\n # Error in finding community quality\\n return -1\\n elif spanset_i == 0:\\n return spanset_0 + gapset_1\\n elif spanset_i == 1:\\n return spanset_1 + gapset_0\\n else:\\n return -1\",\n \"def test_can_traverse_wide_grid(self):\\n grid = [[\\\"1\\\", \\\"0\\\", \\\"1\\\", \\\"1\\\", \\\"0\\\", \\\"1\\\", \\\"0\\\", \\\"0\\\", \\\"1\\\", \\\"0\\\"]]\\n result = num_islands(grid)\\n self.assertEqual(result, 4)\",\n \"def make_set_cover_nr(gRNA_hits, num_sets = 1, target_ids = [], low_coverage_penalty = 0,\\n num_lengths_to_track = None, prioritise_3prime = False, optimal_depth = 5,\\n suppress_warning = False):\\n collapsed_grnas = gRNA_hits.collapse()\\n if not target_ids:\\n target_ids = set().union(*[set(cg) for cg in collapsed_grnas])\\n else:\\n target_ids = set(target_ids)\\n ## function to regenerate set cover solutions from collapsed_grna object\\n collapsed_grnas_original = collapsed_grnas.copy()\\n def generate_sc_solutions():\\n ## sort in order of smallest set cover size, smallest redundancy, and size of largest set in set cover\\n minweight_sc = limited_minweight_SC(collapsed_grnas, num_sets, targets = target_ids,\\n low_coverage_penalty = low_coverage_penalty,\\n num_lengths_to_track = num_lengths_to_track)\\n ## optimal solutions\\n max_depth = min(optimal_depth, max(map(len, minweight_sc)))\\n max_redundancy = max(map(lambda C:C.redundancy, minweight_sc))/len(target_ids)\\n print(max_depth, max_redundancy)\\n optimal_sc = limited_optimal_SC(target_ids, collapsed_grnas_original,\\n size = max_depth, redundancy = max_redundancy)\\n print(\\\"num unfiltered optimal sc:\\\", len(optimal_sc))\\n ## remove duplicates\\n optimal_sc = [C for C in optimal_sc\\n if all(map(lambda minweight_C:(len(C) != minweight_C\\n and C != minweight_C),\\n minweight_sc))]\\n print(\\\"num filtered optimal sc:\\\", len(optimal_sc))\\n return sorted(minweight_sc + optimal_sc,\\n key = lambda C:(len(C), C.redundancy, -C.max_coverage))\\n sc_solutions = []\\n sc_solutions.extend(generate_sc_solutions())\\n eliminated_grna = []\\n ## function to generate set covers\\n def make_set_cover(restore = []):\\n ## restore only works if gRNA belonged in the current set cover\\n curr_sc = sc_solutions[0]\\n for grna in restore:\\n curr_sc.add_grna(grna)\\n eliminated_grna.remove(grna)\\n ## if current set cover solution has at least one CollapsedgRNA with no gRNA left\\n while not curr_sc.all_not_empty():\\n sink = sc_solutions.pop(0) ## remove set cover solution\\n ## generate more possible gRNA sets if no pre-generated set covers are left\\n if not sc_solutions:\\n collapsed_grnas.remove_grna(*eliminated_grna)\\n collapsed_grnas.remove_empty()\\n sc_solutions.extend(generate_sc_solutions())\\n if not sc_solutions:\\n if not suppress_warning:\\n print((\\\"\\\\nError: The provided gRNA sequences cannot cover all\\\"\\n \\\" target sequences at least once.\\\\n\\\"))\\n return []\\n ## select next solution\\n curr_sc = sc_solutions[0]\\n ## consume=True -> remove selected gRNA from CollapsedgRNA\\n output = curr_sc.generate_grna_set(prioritise_3prime = prioritise_3prime, consume = True)\\n eliminated_grna.extend(output)\\n return output\\n return make_set_cover\",\n \"def num_edges(g):\\n total_edges_with_duplicates = sum(len(v) for v in g.values())\\n return total_edges_with_duplicates // 2\",\n \"def countEdges(self):\\n return numpy.count_nonzero(self.supportArray) / 2\",\n \"def cal_expected_map(self, ranking_list, total_rel=0):\\r\\n s = 0.0\\r\\n pr = 0\\r\\n pn = 0\\r\\n for ele in reversed(ranking_list):\\r\\n rel_doc_cnt = ele[0]\\r\\n this_doc_cnt = ele[1]\\r\\n nonrel_doc_cnt = this_doc_cnt - rel_doc_cnt\\r\\n s += self.A(pr, pn, rel_doc_cnt, nonrel_doc_cnt)\\r\\n pr += rel_doc_cnt\\r\\n pn += nonrel_doc_cnt\\r\\n total_rel += rel_doc_cnt\\r\\n #print s/total_rel\\r\\n if total_rel == 0:\\r\\n return 0\\r\\n return s/total_rel\",\n \"def best_pairing(current_end, end_dict, inverse_dict, blast_hits, l_min_score, r_min_score):\\n #this duplicates part of trio_hits - should try to rewrite that to use this function\\n \\n l_flange = int(end_dict[current_end][1])\\n l_contig = end_dict[current_end][0]\\n \\n #first find blast hits for the target scaffold end\\n left_matches = []\\n for hit in blast_hits:\\n if hit[0] == l_contig and int(hit[11]) >= l_min_score:\\n left_matches.append(hit)\\n \\n link_count = {}\\n \\n #then find other ends with correctly oriented hits adjacent to the target hits\\n for slink in end_dict:\\n link = end_dict[slink][0]\\n \\n right_matches = []\\n\\n for hit in blast_hits:\\n if hit[0] == link and int(hit[11]) >= r_min_score: \\n right_matches.append(hit)\\n \\n for lhit in left_matches:\\n for rhit in right_matches:\\n srhit = inverse_dict[rhit[0]]\\n r_flange = end_dict[srhit][1]\\n joint_flange = l_flange + r_flange\\n \\n if lhit[1] == rhit[1]:\\n lh_start = int(lhit[8])\\n lh_end = int(lhit[9])\\n rh_start = int(rhit[8])\\n rh_end = int(rhit[9])\\n\\n if abs(lh_start - rh_start) < joint_flange + 3000:\\n if (lh_end - lh_start)/(rh_end - rh_start) < 0:\\n if abs(lh_end - rh_end) > abs(lh_start - rh_start):\\n link_score = int(lhit[11]) * int(rhit[11])\\n if not link in link_count: \\n link_count[link] = link_score\\n elif link_score > link_count[link]:\\n link_count[link] = link_score\\n return link_count\",\n \"def n_inequalities(self):\\n try: \\n return self._n_inequalities\\n except AttributeError:\\n self._n_inequalities = 0\\n for i in self.inequalities(): self._n_inequalities += 1\\n return self._n_inequalities\",\n \"def seg_to_affgraph(seg_gt, nhood):\\n nhood = np.ascontiguousarray(nhood, np.int32)\\n shape = seg_gt.shape\\n n_edge = nhood.shape[0]\\n aff = np.zeros((n_edge,)+shape,dtype=np.int16)\\n\\n for e in range(n_edge):\\n aff[e, \\\\\\n max(0,-nhood[e,0]):min(shape[0],shape[0]-nhood[e,0]), \\\\\\n max(0,-nhood[e,1]):min(shape[1],shape[1]-nhood[e,1]), \\\\\\n max(0,-nhood[e,2]):min(shape[2],shape[2]-nhood[e,2])] = \\\\\\n (seg_gt[max(0,-nhood[e,0]):min(shape[0],shape[0]-nhood[e,0]), \\\\\\n max(0,-nhood[e,1]):min(shape[1],shape[1]-nhood[e,1]), \\\\\\n max(0,-nhood[e,2]):min(shape[2],shape[2]-nhood[e,2])] == \\\\\\n seg_gt[max(0,nhood[e,0]):min(shape[0],shape[0]+nhood[e,0]), \\\\\\n max(0,nhood[e,1]):min(shape[1],shape[1]+nhood[e,1]), \\\\\\n max(0,nhood[e,2]):min(shape[2],shape[2]+nhood[e,2])] ) \\\\\\n * ( seg_gt[max(0,-nhood[e,0]):min(shape[0],shape[0]-nhood[e,0]), \\\\\\n max(0,-nhood[e,1]):min(shape[1],shape[1]-nhood[e,1]), \\\\\\n max(0,-nhood[e,2]):min(shape[2],shape[2]-nhood[e,2])] > 0 ) \\\\\\n * ( seg_gt[max(0,nhood[e,0]):min(shape[0],shape[0]+nhood[e,0]), \\\\\\n max(0,nhood[e,1]):min(shape[1],shape[1]+nhood[e,1]), \\\\\\n max(0,nhood[e,2]):min(shape[2],shape[2]+nhood[e,2])] > 0 )\\n\\n return aff\",\n \"def test_metric(self, qset: Iterator[Tuple[str, float]]) -> Dict[str, float]:\\n res = dict(mks0=0.0, mks1=0.0, mks2=0.0, sum_weights=0.0, sum_wlen=0.0, n=0)\\n hist = {k: {} for k in {\\\"mks0\\\", \\\"mks1\\\", \\\"mks2\\\", \\\"l\\\"}} # pylint: disable=C0208\\n wei = {k: {} for k in hist}\\n res[\\\"hist\\\"] = hist\\n res[\\\"histnow\\\"] = wei\\n\\n for el, _ in self.enumerate_test_metric(qset):\\n le = len(el.value)\\n w = el.weight\\n res[\\\"mks0\\\"] += w * el.mks0\\n res[\\\"mks1\\\"] += w * el.mks1\\n res[\\\"mks2\\\"] += w * el.mks2\\n res[\\\"sum_weights\\\"] += w\\n res[\\\"sum_wlen\\\"] += w * le\\n res[\\\"n\\\"] += 1\\n\\n if el.mks0 not in hist[\\\"mks0\\\"]:\\n hist[\\\"mks0\\\"][el.mks0] = w\\n wei[\\\"mks0\\\"][el.mks0] = 1\\n else:\\n hist[\\\"mks0\\\"][el.mks0] += w\\n wei[\\\"mks0\\\"][el.mks0] += 1\\n if el.mks1 not in hist[\\\"mks1\\\"]:\\n hist[\\\"mks1\\\"][el.mks1] = w\\n wei[\\\"mks1\\\"][el.mks1] = 1\\n else:\\n hist[\\\"mks1\\\"][el.mks1] += w\\n wei[\\\"mks1\\\"][el.mks1] += 1\\n if el.mks2 not in hist[\\\"mks2\\\"]:\\n hist[\\\"mks2\\\"][el.mks2] = w\\n wei[\\\"mks2\\\"][el.mks2] = 1\\n else:\\n hist[\\\"mks2\\\"][el.mks2] += w\\n wei[\\\"mks2\\\"][el.mks2] += 1\\n if le not in hist[\\\"l\\\"]:\\n hist[\\\"l\\\"][le] = w\\n wei[\\\"l\\\"][le] = 1\\n else:\\n hist[\\\"l\\\"][le] += w\\n wei[\\\"l\\\"][le] += 1\\n return res\",\n \"def calculate_edge_spans(self):\\n for edge in self.edges:\\n from_index = self.layers.index(edge.from_node.layer)\\n to_index = self.layers.index(edge.to_node.layer)\\n edge.span = abs(from_index - to_index)\",\n \"def count_automorphisms(g: Graph) -> int:\\n\\n def generate_mapping(g: Graph, h: Graph):\\n \\\"\\\"\\\"\\n Generates the corresponding mapping from vertex to vertex for the isomorphism between graphs g and h.\\n We map g to h.\\n :param g: A graph\\n :param h: A graph\\n :return: A permutation with the mapping from g to h\\n \\\"\\\"\\\"\\n mapping = [0] * len(g.vertices)\\n for v_g in g:\\n for v_h in h:\\n if v_g.colornum == v_h.colornum:\\n mapping[v_g.label] = v_h.label\\n return permutation(len(mapping), mapping=mapping)\\n\\n def generate_automorphisms(g: Graph, h: Graph, d: list[Vertex], i: list[Vertex]):\\n \\\"\\\"\\\"\\n Is called recursively to traverse through the branching tree and to find all automorphisms.\\n :param g: A copy of the original graph\\n :param h: Another copy of the original graph\\n :param d: A list with pre-colored vertices for graph g\\n :param i: A list with pre-colored vertices for graph h\\n \\\"\\\"\\\"\\n\\n # Refine the graphs g and h.\\n color_refinement([g, h])\\n\\n # Make sure that the colors are balanced, and check for a bijection.\\n if not is_balanced(g, h):\\n return\\n if is_bijection(g, h):\\n\\n # Generate the mapping from g -> h.\\n p = generate_mapping(g, h)\\n\\n # If the permutation cannot be generated by this generating set, we need to add it.\\n if not is_member(generating_set, p):\\n generating_set.append(p)\\n\\n # We can now back to the last trivial ancestor nodes in the branching tree.\\n while [v.label for v in d] != [v.label for v in i]:\\n # We remove the vertices from d and i and mark them as 'used'.\\n # This should prevent the algorithm from trying to re-explore a branch that may be skipped.\\n # FIXME: This strategy seems too aggressive, the results are sometimes off by a factor 2 or 4\\n d.pop().pre_labeled = True\\n i.pop().pre_labeled = True\\n\\n return\\n\\n c, next_color = get_c([g, h])\\n for v_g in g:\\n if v_g.colornum == c:# and not v_g.pre_labeled:\\n x = v_g\\n break\\n\\n for v_h in h:\\n if v_h.colornum == c and not v_h.pre_labeled:\\n g1 = g + Graph(False)\\n h1 = h + Graph(False)\\n g1.vertices[g.vertices.index(x)].colornum = next_color\\n h1.vertices[h.vertices.index(v_h)].colornum = next_color\\n d.append(x)\\n i.append(v_h)\\n generate_automorphisms(g1, h1, d, i)\\n\\n generating_set = []\\n graph_copy_1 = g + Graph(False)\\n graph_copy_2 = g + Graph(False)\\n for v in graph_copy_1.vertices:\\n v.pre_labeled = False\\n for v in graph_copy_2.vertices:\\n v.pre_labeled = False\\n generate_automorphisms(graph_copy_1, graph_copy_2, [], [])\\n return compute_order(generating_set)\",\n \"def test_can_traverse_tall_grid(self):\\n grid = [\\n [\\\"0\\\"],\\n [\\\"1\\\"],\\n [\\\"1\\\"],\\n [\\\"0\\\"],\\n [\\\"1\\\"],\\n [\\\"0\\\"],\\n [\\\"1\\\"],\\n [\\\"0\\\"],\\n [\\\"1\\\"],\\n ]\\n result = num_islands(grid)\\n self.assertEqual(result, 4)\",\n \"def matching_score(self,set1, set2):\\n set_set1=set(set1)\\n set_set2=set(set2)\\n '''print(\\\" set_set12\\\")\\n print(set_set1)\\n print(set_set2)'''\\n return len(set_set1.intersection(set_set2)) ** 2 / (float(len(set1)) * len(set2))\\n #return len(set_set1.intersection(set_set2)) / len(set_set1.union(set_set2))\",\n \"def test_for_grader():\\n test_map1 = np.array([\\n [1, 1, 1, 1, 1, 1, 1, 1, 1],\\n [1, 0, 1, 0, 0, 0, 1, 0, 1],\\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\\n [1, 0, 0, 0, 1, 0, 0, 0, 1],\\n [1, 1, 1, 1, 1, 1, 1, 1, 1]])\\n x_spacing1 = 1\\n y_spacing1 = 1\\n start1 = np.array([[1.5], [1.5], [0]])\\n goal1 = np.array([[7.5], [1], [0]])\\n path1 = dijkstras(test_map1,x_spacing1,y_spacing1,start1,goal1)\\n s = 0\\n for i in range(len(path1)-1):\\n s += np.sqrt((path1[i][0]-path1[i+1][0])**2 + (path1[i][1]-path1[i+1][1])**2)\\n print(\\\"Path 1 length:\\\")\\n print(s)\\n\\n\\n test_map2 = np.array([\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [1, 1, 1, 1, 1, 1, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 1, 1, 1, 1, 1, 1, 1]])\\n start2 = np.array([[0.4], [0.4], [1.5707963267948966]])\\n goal2 = np.array([[0.4], [1.8], [-1.5707963267948966]])\\n x_spacing2 = 0.2\\n y_spacing2 = 0.2\\n path2 = dijkstras(test_map2,x_spacing2,y_spacing2,start2,goal2)\\n s = 0\\n for i in range(len(path2)-1):\\n s += np.sqrt((path2[i][0]-path2[i+1][0])**2 + (path2[i][1]-path2[i+1][1])**2)\\n print(\\\"Path 2 length:\\\")\\n print(s)\",\n \"def get_GNS_cut_reduced(self):\\n # we build the optimization around the casted digraph instead of multidigraph\\n # for simplicity\\n G = self.base_digraph\\n s_1 = self.sources[0]\\n s_2 = self.sources[1]\\n t_1 = self.destinations[0]\\n t_2 = self.destinations[1]\\n edges = G.edges()\\n nodes = G.nodes()\\n\\n try:\\n\\n # Great an gurobi instance of the optimization model\\n m = Model(\\\"GNS\\\")\\n m.setParam('OutputFlag', False)\\n\\n x_v = {}\\n # vertex variables for s_1, t_1 cut\\n for v in nodes:\\n x_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n y_v = {}\\n # vertex variables for s_2, t_2 cut\\n for v in nodes:\\n y_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n z_v = {}\\n # vertex variables for s_2, t_1 cut\\n for v in nodes:\\n z_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n e = {}\\n # GNS indicator variable\\n for (u,v) in edges:\\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\\n\\n # Done with decision variable creation\\n # update model\\n m.update()\\n\\n # Constraints\\n # 1. Constraints for s_1 - t_1 cut\\n for (u,v) in edges:\\n if (u,v) == (s_1, t_1):\\n m.addConstr(e[u,v] >= 1)\\n elif u == s_1:\\n m.addConstr(x_v[v] + e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-x_v[u] + e[u,v] >= 0)\\n else:\\n m.addConstr(x_v[v] - x_v[u] + e[u,v] >= 0)\\n\\n if (u,v) == (s_2, t_2):\\n m.addConstr(e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(y_v[v] + e[u,v] >= 1)\\n elif v == t_2:\\n m.addConstr(-y_v[u] + e[u,v] >= 0)\\n else:\\n m.addConstr(y_v[v] - y_v[u] + e[u,v] >= 0)\\n\\n if (u,v) == (s_2, t_1):\\n m.addConstr(e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(z_v[v] + e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-z_v[u] + e[u,v] >= 0)\\n else:\\n m.addConstr(z_v[v] - z_v[u] + e[u,v] >= 0)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n #print \\\"Min GNS cut value = \\\" + str(m.objVal)\\n #print \\\"GNS cut edges:\\\"\\n cut_set_edges = []\\n for u,v in edges:\\n if e[u,v].x != 0:\\n #print (u,v), str(G[u][v]['capacity'])\\n cut_set_edges.append((u,v, G[u][v]['capacity']))\\n return (m.objVal, cut_set_edges)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong\\\"\\n return None, None\\n\\n except GurobiError:\\n print ('Error report from Gurobi')\",\n \"def compute_num_edges(graph):\\n # return the number of edges\\n return sum([len(graph[source_node].keys()) for source_node in graph.keys()]) / 2\",\n \"def test_returns_correct_number_of_islands(self):\\n grid = [\\n [\\\"1\\\", \\\"1\\\", \\\"1\\\", \\\"0\\\", \\\"0\\\"],\\n [\\\"1\\\", \\\"1\\\", \\\"0\\\", \\\"0\\\", \\\"1\\\"],\\n [\\\"1\\\", \\\"0\\\", \\\"1\\\", \\\"0\\\", \\\"1\\\"],\\n [\\\"0\\\", \\\"1\\\", \\\"1\\\", \\\"1\\\", \\\"1\\\"],\\n [\\\"1\\\", \\\"0\\\", \\\"1\\\", \\\"1\\\", \\\"1\\\"],\\n ]\\n result = num_islands(grid)\\n self.assertEqual(result, 3)\",\n \"def __used(self):\\n tot=0\\n assign={}\\n for c in self.assigned :\\n if not assign.has_key(c.start) :\\n assign[c.start]=c.end\\n tot+=c.end-c.start+1\\n return tot\",\n \"def return_num_edges(self):\\n return sum(map(lambda x: len(x),self.__adj))\",\n \"def _compute_packet_heatmap(simulators, span):\\n _check_span_keywords(span=span)\\n n = simulators[0].model.network.num_nodes\\n packet_count = np.zeros([n, n])\\n for simulator in simulators:\\n if simulator.model.network.num_nodes != n:\\n raise ValueError(\\\"Inconsistent number of nodes are found among the simulators.\\\")\\n if span in overall_range_keywords:\\n latency = simulator.latency\\n elif span in extended_range_keywords:\\n start_index = simulator.batch_stats[-1]['end_index']\\n latency = simulator.latency[start_index:]\\n elif span in final_batch_range_keywords:\\n start_index = simulator.batch_stats[-1]['start_index']\\n end_index = simulator.batch_stats[-1]['end_index']\\n latency = simulator.latency[start_index:end_index]\\n for latency_dict in latency:\\n packet_count[latency_dict['Source ID']][latency_dict['Destination ID']] += 1\\n max_packet = np.nanmax(packet_count)\\n min_packet = np.nanmin(packet_count)\\n for i in range(n):\\n for j in range(n):\\n if i == j:\\n packet_count[i][j] = np.nan\\n else:\\n packet_count[i][j] = (packet_count[i][j] - min_packet) / (max_packet - min_packet)\\n return packet_count\",\n \"def EdgeWeights(setOfEdges, multiSetOfEdges):\\n weights = dict()\\n for edge in setOfEdges:\\n weights[edge] = multiSetOfEdges.count(edge)\\n # a way to normalize edge weights\\n # edgeWeights = map((1 / max(list(weights.values()))), weights.values())\\n return weights\",\n \"def test_edges_and_weights():\\n edges, weights, state_value = edges_weights_specified_state(\\n PROBABILITYMATRIX,\\n MARKET,\\n SNULL)\\n assert len(edges) == len(weights) == (len(state_value)**2)\",\n \"def query_size_of_adjacent_nodes(self, node_curie, source_type, adjacent_type, kp=\\\"infores:rtx-kg2\\\", rel_type=None):\\n\\n res = None\\n source_type = ComputeFTEST.convert_string_to_snake_case(source_type.replace('biolink:',''))\\n source_type = ComputeFTEST.convert_string_biolinkformat(source_type)\\n adjacent_type = ComputeFTEST.convert_string_to_snake_case(adjacent_type.replace('biolink:',''))\\n adjacent_type = ComputeFTEST.convert_string_biolinkformat(adjacent_type)\\n\\n if rel_type is None:\\n normalized_nodes = self.nodesynonymizer.get_canonical_curies(node_curie)\\n failure_nodes = list()\\n mapping = {node:normalized_nodes[node]['preferred_curie'] for node in normalized_nodes if normalized_nodes[node] is not None}\\n failure_nodes += list(normalized_nodes.keys() - mapping.keys())\\n query_nodes = list(set(mapping.values()))\\n query_nodes = [curie_id.replace(\\\"'\\\", \\\"''\\\") if \\\"'\\\" in curie_id else curie_id for curie_id in query_nodes]\\n # special_curie_ids = [curie_id for curie_id in query_nodes if \\\"'\\\" in curie_id]\\n\\n # Get connected to kg2c sqlite\\n connection = sqlite3.connect(self.sqlite_file_path)\\n cursor = connection.cursor()\\n\\n # Extract the neighbor count data\\n node_keys_str = \\\"','\\\".join(query_nodes) # SQL wants ('node1', 'node2') format for string lists\\n sql_query = f\\\"SELECT N.id, N.neighbor_counts \\\" \\\\\\n f\\\"FROM neighbors AS N \\\" \\\\\\n f\\\"WHERE N.id IN ('{node_keys_str}')\\\"\\n cursor.execute(sql_query)\\n rows = cursor.fetchall()\\n rows = [curie_id.replace(\\\"\\\\'\\\",\\\"'\\\").replace(\\\"''\\\", \\\"'\\\") if \\\"'\\\" in curie_id else curie_id for curie_id in rows]\\n connection.close()\\n\\n # Load the counts into a dictionary\\n neighbor_counts_dict = {row[0]:eval(row[1]) for row in rows}\\n\\n res_dict = {node:neighbor_counts_dict[mapping[node]].get(adjacent_type) for node in mapping if mapping[node] in neighbor_counts_dict and neighbor_counts_dict[mapping[node]].get(adjacent_type) is not None}\\n failure_nodes += list(mapping.keys() - res_dict.keys())\\n\\n if len(failure_nodes) != 0:\\n return (res_dict, failure_nodes)\\n else:\\n return (res_dict, [])\\n\\n else:\\n # if kp == 'ARAX/KG1':\\n # self.response.warning(f\\\"Since the edge type '{rel_type}' is from KG1, we still use the DSL expand(kg=ARAX/KG1) to query neighbor count. However, the total node count is based on KG2c from 'nodesynonymizer.get_total_entity_count'. So the FET result might not be accurate.\\\")\\n\\n # construct the instance of ARAXQuery class\\n araxq = ARAXQuery()\\n\\n # check if node_curie is a str or a list\\n if type(node_curie) is str:\\n query_node_curie = node_curie\\n elif type(node_curie) is list:\\n node_id_list_str = \\\"[\\\"\\n for index in range(len(node_curie)):\\n node = node_curie[index]\\n if index + 1 == len(node_curie):\\n node_id_list_str = node_id_list_str + str(node) + \\\"]\\\"\\n else:\\n node_id_list_str = node_id_list_str + str(node) + \\\",\\\"\\n\\n query_node_curie = node_id_list_str\\n else:\\n self.response.error(\\\"The 'node_curie' argument of 'query_size_of_adjacent_nodes' method within FET only accepts str or list\\\")\\n return res\\n\\n # call the method of ARAXQuery class to query adjacent node\\n query = {\\\"operations\\\": {\\\"actions\\\": [\\n \\\"create_message\\\",\\n f\\\"add_qnode(ids={query_node_curie}, categories={source_type}, key=FET_n00)\\\",\\n f\\\"add_qnode(categories={adjacent_type}, key=FET_n01)\\\",\\n f\\\"add_qedge(subject=FET_n00, object=FET_n01, key=FET_e00, predicates={rel_type})\\\",\\n f\\\"expand(edge_key=FET_e00,kp={kp})\\\",\\n #\\\"resultify()\\\",\\n \\\"return(message=true, store=false)\\\"\\n ]}}\\n\\n try:\\n result = araxq.query(query)\\n if result.status != 'OK':\\n self.response.error(f\\\"Fail to query adjacent nodes from infores:rtx-kg2 for {node_curie}\\\")\\n return res\\n else:\\n res_dict = dict()\\n message = araxq.response.envelope.message\\n if type(node_curie) is str:\\n tmplist = set([edge_key for edge_key in message.knowledge_graph.edges if message.knowledge_graph.edges[edge_key].subject == node_curie or message.knowledge_graph.edges[edge_key].object == node_curie]) ## edge has no direction\\n if len(tmplist) == 0:\\n self.response.warning(f\\\"Fail to query adjacent nodes from {kp} for {node_curie} in FET probably because expander ignores node type. For more details, please see issue897.\\\")\\n return (res_dict,[node_curie])\\n res_dict[node_curie] = len(tmplist)\\n return (res_dict,[])\\n else:\\n check_empty = False\\n failure_nodes = list()\\n for node in node_curie:\\n tmplist = set([edge_key for edge_key in message.knowledge_graph.edges if message.knowledge_graph.edges[edge_key].subject == node or message.knowledge_graph.edges[edge_key].object == node]) ## edge has no direction\\n if len(tmplist) == 0:\\n self.response.warning(f\\\"Fail to query adjacent nodes from {kp} for {node} in FET probably because expander ignores node type. For more details, please see issue897.\\\")\\n failure_nodes.append(node)\\n check_empty = True\\n continue\\n res_dict[node] = len(tmplist)\\n\\n if check_empty is True:\\n return (res_dict,failure_nodes)\\n else:\\n return (res_dict,[])\\n except:\\n tb = traceback.format_exc()\\n error_type, error, _ = sys.exc_info()\\n self.response.error(tb, error_code=error_type.__name__)\\n self.response.error(f\\\"Something went wrong with querying adjacent nodes from {kp} for {node_curie}\\\")\\n return res\",\n \"def test_weighting(self):\\n dset = self.dset.spec.sel(\\n lons=self.lons_inexact, lats=self.lats_inexact, method=\\\"idw\\\"\\n )\\n for stat in [\\\"hs\\\", \\\"tp\\\"]:\\n idw = dset.spec.stats([stat])[stat].values\\n site0 = self.dset.isel(site=[0]).spec.stats([stat])[stat].values\\n site1 = self.dset.isel(site=[1]).spec.stats([stat])[stat].values\\n lower = np.array([min(s1, s2) for s1, s2 in zip(site0, site1)])\\n upper = np.array([max(s1, s2) for s1, s2 in zip(site0, site1)])\\n assert (upper - idw > 0).all() and (idw - lower > 0).all()\",\n \"def compute_m_paths_of_len_back(g, sampl, end_times, path_len=5, cost=1, its=100, max_duration=sys.maxint):\\n\\n num_of_paths_dict = {}\\n\\n # for each node in source, generate random paths and count the number of times they end up in each\\n # dest. node\\n for dest, end_time in zip(sampl, end_times):\\n print \\\"Processing dest node: {} (ending at time {})\\\".format(dest, end_time)\\n num_of_paths_dict[(dest, end_time)] = {source: 0 for source in g.nodes()}\\n for _ in range(its):\\n d = random_path_backwards(g, dest, path_len, end_time, cost, max_duration)\\n if d is not None:\\n num_of_paths_dict[(dest, end_time)][d] += 1\\n\\n return num_of_paths_dict\",\n \"def edge_count(adjList):\\n edges = {}\\n for id, neigh in enumerate(adjList):\\n for n in neigh:\\n edges[max(n, id), min(n, id)] = id\\n\\n return len(edges)\",\n \"def num_cusps_of_regions(self):\\n G = self._get_puncturefinder_graph()\\n # return [sum(G.subgraph(vertices=region).edge_labels())\\n # for region in G.connected_components()]\\n return [sum(edge[2]['weight']\\n for edge in subgraph.edges(data=True))\\n for subgraph in nx.connected_component_subgraphs(G)]\",\n \"def count_property_range_hits(prop, node_dict, hits):\\n\\tres = []\\n\\t# sets tuple position to use in dict value\\n\\tswitcher = {\\n \\\"length\\\": (0,(0,4000,8000,12000,16000,20000)),\\n \\\"steps\\\": (1,(0,2,4,8,16,32)),\\n \\\"cov\\\": (2,(1,10,100,1000,10000,100000)),\\n \\\"cv\\\": (3, (0,0.05,0.10,0.15,0.20,0.25))\\n }\\n\\tif prop not in switcher:\\n\\t\\treturn res\\n\\ttup_pos = switcher[prop][0]\\n\\tnode_cnt = 0\\n\\tpos_cnt = 0\\n\\tfor ind in range(len(switcher[prop][1])-1):\\n\\t\\tmin_val = switcher[prop][1][ind]\\n\\t\\tmax_val = switcher[prop][1][ind+1]\\n\\t\\tfor node in node_dict.keys():\\n\\t\\t\\tval = node_dict[node][tup_pos]\\n\\t\\t\\tif ind < len(switcher[prop][1])-2:\\n\\t\\t\\t\\trange_test_val = (min_val <= val < max_val)\\n\\t\\t\\telse:\\n\\t\\t\\t\\trange_test_val = (min_val <= val <= max_val)\\n\\t\\t\\t# print \\\"range bool is\\\", range_test_val\\n\\t\\t\\tif range_test_val:\\n\\t\\t\\t\\tnode_cnt += 1\\n\\t\\t\\t\\tif node in hits: pos_cnt += 1\\n\\t\\tif node_cnt > 0:\\n\\t\\t\\tres.append( (pos_cnt, node_cnt, round(float(pos_cnt)/node_cnt,2)))\\n\\t\\telse:\\n\\t\\t\\tres.append((0,0,0))\\n\\t\\tnode_cnt = 0\\n\\t\\tpos_cnt = 0\\n\\treturn res\",\n \"def count_islands(grid):\\n grid_copy = list(grid)\\n count = 0\\n for i in range(0, len(grid_copy)):\\n for j in range (0, len(grid_copy[0])):\\n if grid[i][j] and grid_copy[i][j]:\\n _dfs(grid_copy, i, j)\\n count += 1\\n return count\",\n \"def compute_district_weights(dist_changes, elec_sets, elec_set_dict, state_gdf, partition, prec_draws_outcomes,\\\\\\n geo_id, primary_elecs, runoff_elecs, elec_match_dict, bases, outcomes,\\\\\\n recency_W1, cand_race_dict, min_cand_weights_dict):\\n \\n black_pref_cands_prim_dist = pd.DataFrame(columns = dist_changes)\\n black_pref_cands_prim_dist[\\\"Election Set\\\"] = elec_sets\\n hisp_pref_cands_prim_dist = pd.DataFrame(columns = dist_changes)\\n hisp_pref_cands_prim_dist[\\\"Election Set\\\"] = elec_sets\\n #store runoff preferences for instances where minority-preferred candidate needs to switch between primary and runoff\\n black_pref_cands_runoffs_dist = pd.DataFrame(columns = dist_changes)\\n black_pref_cands_runoffs_dist[\\\"Election Set\\\"] = elec_sets\\n hisp_pref_cands_runoffs_dist = pd.DataFrame(columns = dist_changes)\\n hisp_pref_cands_runoffs_dist[\\\"Election Set\\\"] = elec_sets \\n \\n black_conf_W3_dist = np.empty((len(elec_sets),0), float)\\n hisp_conf_W3_dist = np.empty((len(elec_sets),0), float)\\n neither_conf_W3_dist = np.empty((len(elec_sets),0), float)\\n \\n for district in dist_changes: \\n state_gdf[\\\"New Map\\\"] = state_gdf.index.map(dict(partition.assignment))\\n dist_prec_list = list(state_gdf[state_gdf[\\\"New Map\\\"] == district][geo_id])\\n dist_prec_indices = state_gdf.index[state_gdf[geo_id].isin(dist_prec_list)].tolist()\\n district_support_all = cand_pref_outcome_sum(prec_draws_outcomes, dist_prec_indices, bases, outcomes)\\n \\n black_pref_prob_single_dist = []\\n hisp_pref_prob_single_dist = []\\n \\n for elec_set in elec_sets: \\n HCVAP_support_elec = district_support_all[('HCVAP', elec_set_dict[elec_set]['Primary'])]\\n hisp_pref_cand_dist = max(HCVAP_support_elec.items(), key=operator.itemgetter(1))[0]\\n hisp_pref_prob_dist = HCVAP_support_elec[hisp_pref_cand_dist]\\n hisp_pref_prob_single_dist.append(hisp_pref_prob_dist) \\n \\n BCVAP_support_elec = district_support_all[('BCVAP', elec_set_dict[elec_set]['Primary'])]\\n black_pref_cand_dist = max(BCVAP_support_elec.items(), key=operator.itemgetter(1))[0]\\n black_pref_prob_dist = BCVAP_support_elec[black_pref_cand_dist]\\n black_pref_prob_single_dist.append(black_pref_prob_dist)\\n \\n black_pref_cands_prim_dist.at[black_pref_cands_prim_dist[\\\"Election Set\\\"] == elec_set, district] = black_pref_cand_dist\\n hisp_pref_cands_prim_dist.at[hisp_pref_cands_prim_dist[\\\"Election Set\\\"] == elec_set, district] = hisp_pref_cand_dist \\n \\n if 'Runoff' in elec_set_dict[elec_set].keys():\\n HCVAP_support_elec = district_support_all[('HCVAP', elec_set_dict[elec_set]['Runoff'])]\\n hisp_pref_cand_dist = max(HCVAP_support_elec.items(), key=operator.itemgetter(1))[0]\\n hisp_pref_cands_runoffs_dist.at[hisp_pref_cands_runoffs_dist[\\\"Election Set\\\"] == elec_set, district] = hisp_pref_cand_dist\\n \\n BCVAP_support_elec = district_support_all[('BCVAP', elec_set_dict[elec_set]['Runoff'])]\\n black_pref_cand_dist = max(BCVAP_support_elec.items(), key=operator.itemgetter(1))[0] \\n black_pref_cands_runoffs_dist.at[black_pref_cands_runoffs_dist[\\\"Election Set\\\"] == elec_set, district] = black_pref_cand_dist\\n \\n black_pref_conf_single_dist = [prob_conf_conversion(x) for x in black_pref_prob_single_dist]\\n black_conf_W3_dist = np.append(black_conf_W3_dist, np.array([black_pref_conf_single_dist]).transpose(), axis = 1) \\n \\n hisp_pref_conf_single_dist = [prob_conf_conversion(x) for x in hisp_pref_prob_single_dist]\\n hisp_conf_W3_dist = np.append(hisp_conf_W3_dist, np.array([hisp_pref_conf_single_dist]).transpose(), axis = 1) \\n \\n neither_pref_conf_single_dist = [prob_conf_conversion(x*y) for x,y in zip(black_pref_prob_single_dist,hisp_pref_prob_single_dist)]\\n neither_conf_W3_dist = np.append(neither_conf_W3_dist, np.array([neither_pref_conf_single_dist]).transpose(), axis = 1) \\n \\n #compute W2 (\\\"in-group\\\"-minority-preference weight) \\n min_cand_black_W2_dist, min_cand_hisp_W2_dist, min_cand_neither_W2_dist = compute_W2(elec_sets, \\\\\\n dist_changes, min_cand_weights_dict, black_pref_cands_prim_dist, hisp_pref_cands_prim_dist, cand_race_dict)\\n ################################################################################ \\n #compute final election weights per district\\n recency_W1 = recency_W1.copy()[:, dist_changes]\\n black_weight_dist = recency_W1*min_cand_black_W2_dist*black_conf_W3_dist\\n hisp_weight_dist = recency_W1*min_cand_hisp_W2_dist*hisp_conf_W3_dist \\n neither_weight_dist = recency_W1*min_cand_neither_W2_dist*neither_conf_W3_dist\\n \\n return black_weight_dist, hisp_weight_dist, neither_weight_dist, black_pref_cands_prim_dist, \\\\\\n black_pref_cands_runoffs_dist, hisp_pref_cands_prim_dist, hisp_pref_cands_runoffs_dist\",\n \"def num_edges(self):\\n return sum(1 for _ in self.iteredges())\",\n \"def cost(graph, gates_qubits_pairs):\\n for allowed, gate in enumerate(gates_qubits_pairs):\\n if gate not in graph.edges():\\n break\\n return len(gates_qubits_pairs) - allowed\",\n \"def get_coverage(self):\\n coverage = np.zeros(self.Set.Shape, dtype=np.int8)\\n for ig in self.Set:\\n igram = self.load_ma(ig)\\n coverage[~igram.mask] += 1\\n\\n return coverage\",\n \"def street_segment_count(Gu):\\n if nx.is_directed(Gu): # pragma: no cover\\n msg = \\\"`Gu` must be undirected\\\"\\n raise ValueError(msg)\\n return len(Gu.edges)\",\n \"def good_turing_mapping(self, threshold=5) -> Dict[int, float]:\\n total_count_counts = sum(self.count_counts.values(), Counter())\\n # total_count_counts[2] is number of bigrams that occurred twice\\n\\n def good_turing(c): \\n return (c+1) * (total_count_counts[c+1]) / total_count_counts.get(c, 1)\\n gtm = {c: good_turing(c) for c in range(threshold)}\\n return {k: v for k, v in gtm.items() if v > 0} # can't have 0 counts\",\n \"def _num_edges(self):\\n return int(self._edge_map[-1])\",\n \"def count_gates(qobj, basis, qubits):\\n\\n #TO DO\\n pass\",\n \"def compute_m_paths_of_len_forw(g, sampl, start_times, path_len=5, cost=1, its=100, max_duration=sys.maxint):\\n\\n num_of_paths_dict = {}\\n\\n # for each node in source, generate random paths and count the number of times they end up in each\\n # dest. node\\n for source, start_time in zip(sampl, start_times):\\n print \\\"Processing source node: {} (starting at time {})\\\".format(source, start_time)\\n num_of_paths_dict[(source, start_time)] = {dest: 0 for dest in g.nodes()}\\n for _ in range(its):\\n d = random_path_forward(g, source, path_len, start_time, cost, max_duration)\\n if d is not None:\\n num_of_paths_dict[(source, start_time)][d] += 1\\n\\n return num_of_paths_dict\",\n \"def calculateIndels(mfaPairs, regions):\\n gapLength = 0\\n gaps = [0]*1000\\n for i in regions:\\n for j in xrange(i[0], i[1]):\\n k = mfaPairs[j]\\n if k == GAP:\\n gapLength += 1\\n else:\\n if gapLength != 0:\\n gaps[gapLength] += 1\\n gapLength = 0\\n return gaps\",\n \"def get_number_of_measurement(self):\\n used_fragments = set()\\n counter = 0\\n for fragment in self.observed_fragments:\\n num_of_isotope = 0\\n used_counter = 0\\n for i in self.mdv[fragment]:\\n num_of_isotope = num_of_isotope + 1\\n if self.mdv[fragment][i]['use'] == 'use':\\n\\n counter = counter + 1\\n used_counter = used_counter + 1\\n if num_of_isotope == used_counter:\\n used_fragments.add(fragment)\\n return counter-len(used_fragments)\",\n \"def get_gini(self, rows):\\n label_count = defaultdict(int)\\n total_count = 0\\n for row in rows:\\n label = row[self.target_attribute]\\n label_count[label] += 1\\n total_count += 1\\n return 1 - sum([np.square(float(label_count[label])/total_count) for label in label_count.keys()])\",\n \"def branchNBound2(nationtxt, bound, scheme):\\n\\n\\n nation = nationLoader(nationtxt)\\n transmitterCosts = scheme\\n\\n neighborCount = {}\\n for province in nation:\\n neighborCount.update({province:len(nation.get(province)[0])})\\n\\n\\n neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__)\\n\\n #~ neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__, reverse=True)\\n\\n for key in neighborCountSorted:\\n provinces.append(key)\\n #~ print provinces\\n\\n upperbound = bound\\n #~ print bound\\n\\n\\n\\n solution = []\\n\\n\\n counter = 0\\n\\n\\n\\n\\n while index >= 0:\\n\\n counter += 1\\n if counter % 100000000 == 0:\\n print counter\\n print \\\"Now at:\\\", nation\\n\\n\\n if index == -1:\\n break\\n\\n # Assign transmitter\\n if nation[provinces[index]][1] == numTransmitters:\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n else:\\n costs, index = updateTransmitter(nation, False, scheme, provinces, costs, index)\\n\\n # Check if costs are above upper bound\\n if (costs + (len(provinces) - (index + 1)) * transmitterCosts[0]) > upperbound:\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n # Check if a neighbor has the same transmitter\\n conflict = False\\n for neighbor in nation[provinces[index]][0]:\\n if nation[neighbor][1] == nation[provinces[index]][1]:\\n conflict = True\\n break\\n\\n if conflict:\\n continue\\n\\n # Check if a solution is found\\n if index == len(provinces) - 1:\\n #~ print \\\"\\\\nSOLUTION:\\\"\\n if costs < upperbound:\\n solution = []\\n solution.append(json_deep_copy(nation))\\n upperbound = costs\\n #~ print \\\"Score:\\\", upperbound\\n #~ print nation\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n index += 1\\n\\n\\n\\n usedTrans = []\\n fivePlus = 0\\n fivePlusNoDuplicate = 0\\n\\n for nation in solution:\\n\\n one = 0\\n two = 0\\n three = 0\\n four = 0\\n five = 0\\n six = 0\\n seven = 0\\n\\n for province in nation:\\n\\n if nation[province][1] == 1:\\n one += 1\\n if nation[province][1] == 2:\\n two += 1\\n if nation[province][1] == 3:\\n three += 1\\n if nation[province][1] == 4:\\n four += 1\\n if nation[province][1] == 5:\\n five += 1\\n if nation[province][1] == 6:\\n six += 1\\n if nation[province][1] == 7:\\n seven += 1\\n\\n\\n if five > 0 or six > 0 or seven > 0:\\n fivePlus += 1\\n if transmitterCosts[3] != transmitterCosts[4]:\\n fivePlusNoDuplicate += 1\\n\\n usedTrans.append([one, two, three, four, five, six, seven])\\n\\n return counter\",\n \"def test_sum_counts_by_consensus(self):\\r\\n #otu_table = parse_otu_table(self.otu_table)\\r\\n #otu_table = parse_biom_table(self.otu_table)\\r\\n obs_result, obs_mapping = sum_counts_by_consensus(self.otu_table, 3)\\r\\n exp_result = {(\\r\\n 'Root', 'Bacteria', 'Actinobacteria'): array([1, 0, 2, 4]),\\r\\n ('Root', 'Bacteria', 'Firmicutes'): array([1, 3, 1, 1]),\\r\\n ('Root', 'Bacteria', 'Other'): array([1, 2, 1, 0])}\\r\\n exp_mapping = {'s1': 0, 's2': 1, 's3': 2, 's4': 3}\\r\\n self.assertItemsEqual(obs_result, exp_result)\\r\\n self.assertEqual(obs_mapping, exp_mapping)\\r\\n\\r\\n obs_result, obs_mapping = sum_counts_by_consensus(self.otu_table, 2)\\r\\n exp_result = {('Root', 'Bacteria'): array([3, 5, 4, 5])}\\r\\n exp_mapping = {'s1': 0, 's2': 1, 's3': 2, 's4': 3}\\r\\n self.assertItemsEqual(obs_result, exp_result)\\r\\n self.assertEqual(obs_mapping, exp_mapping)\\r\\n\\r\\n obs_result, obs_mapping = sum_counts_by_consensus(self.otu_table, 4)\\r\\n exp_result = {('Root', 'Bacteria', 'Actinobacteria', 'Actinobacteria'):\\r\\n array([1, 0, 2, 4]),\\r\\n ('Root', 'Bacteria', 'Firmicutes', '\\\"Clostridia\\\"'):\\r\\n array([1, 3, 1, 1]),\\r\\n ('Root', 'Bacteria', 'Other', 'Other'): array([1, 2, 1, 0])}\\r\\n exp_mapping = {'s1': 0, 's2': 1, 's3': 2, 's4': 3}\\r\\n self.assertItemsEqual(obs_result, exp_result)\\r\\n self.assertEqual(obs_mapping, exp_mapping)\",\n \"def get_routing_solution(self):\\n G = self.base_digraph\\n s1 = self.sources[0]\\n s2 = self.sources[1]\\n t1 = self.destinations[0]\\n t2 = self.destinations[1]\\n\\n try:\\n m = Model('routing')\\n m.setParam('OutputFlag', False)\\n\\n # variables,\\n # We have one variable per edge per session\\n # e is the dict of dict for the variables\\n e = {}\\n r = {}\\n for i in [1,2]:\\n e[i] = {}\\n r[i] = m.addVar()\\n for u,v in G.edges():\\n e[i][u,v] = m.addVar(lb=0)\\n\\n m.update()\\n\\n obj = quicksum(r.values())\\n m.setObjective(obj, GRB.MAXIMIZE)\\n\\n # constraints\\n # 1. conservations of flow at all intermediate nodes\\n # 2. capacity constraints for each edge\\n\\n for u,v in G.edges():\\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\\n\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\\n\\n for n in G.nodes():\\n if n not in [s1, s2, t1, t2]:\\n for i in [1, 2]:\\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\\n m.addConstr(inflow == outflow)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n for u, v in G.edges():\\n G[u][v]['Routing'] = {}\\n G[u][v]['Routing'][1] = e[1][u,v].x\\n G[u][v]['Routing'][2] = e[2][u,v].x\\n return (m.objVal, r[1].x, r[2].x)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong, no optimal solution obtained\\\"\\n return None, None, None\\n\\n except GurobiError:\\n Print ('Error Report from Gurobi')\",\n \"def compute_matches(self):\\n\\t\\tself.local_database[\\\"figure_number\\\"] = [0] * len(self.local_database[\\\"feature_vectors\\\"])\\n\\t\\tForensics = wbForensicsHOG(Database=self.local_database)\\n\\t\\tForensics.KDTree_pairs(leaf_size = len(self.local_database)+1)\\n\\t\\tForensics.d_rank(pairs=Forensics.pairs, distances=Forensics.dists, ratios=Forensics.ratios)\\n\\n\\t\\tself.local_matches = Forensics.Dist_Rank\",\n \"def syn_gid(self, src_gid, tgt_gid):\\n i = 0\\n if (src_gid < self.num_mit): # Target is granule\\n i = (tgt_gid * self.num_mit + src_gid + 1 + \\n self.num_mit + self.num_gran) * 100 + 1\\n else: # Target is mitral\\n i = (src_gid * self.num_mit + tgt_gid + 1 + \\n self.num_mit + self.num_gran) * 100\\n return i\",\n \"def networkx_directed_cut_size(graph, vertex_set_l, vertex_set_r=None):\\n edges = nx.edge_boundary(graph, vertex_set_l, vertex_set_r, data=\\\"weight\\\", default=1)\\n return sum(weight for u, v, weight in edges)\",\n \"def get_good_label_distrib(semrel_dict, semrel_counts):\\n\\n # Do cardinality check on srdict first, to see if there are enough elements to fulfill the distribution in five_semrels.\\n srdict_counts = {key:len(value) for key, value in semrel_dict.items()}\\n\\n # This variable will hold the number of collocations to add to the distribution in place of unfulfillable other labels.\\n num_coll_to_add = 0\\n\\n # Go through all non-'collocation' labels in the dictionary that contains the requested number of labels.\\n for label, count in semrel_counts.items():\\n\\n if label != 'collocation':\\n\\n # Get the difference in cardinality between the available set and the requested set.\\n diffc = srdict_counts[label] - semrel_counts[label]\\n\\n # If negative, i.e. if there are more requested than available, record the difference (this is how many instances\\n # of 'collocation' to add) and change the number of requested words to the number available.\\n if diffc < 0:\\n num_coll_to_add += abs(diffc)\\n semrel_counts[label] = srdict_counts[label]\\n\\n # Adjust the values in 'collocation' in the dictionary.\\n if 'collocation' in set(semrel_counts.keys()):\\n semrel_counts['collocation'] += num_coll_to_add\\n else:\\n semrel_counts['collocation'] = num_coll_to_add\\n\\n return semrel_counts\",\n \"def get_invariant_dimensions(self, sdfg: dace.sdfg.SDFG, graph: dace.sdfg.SDFGState,\\n map_entries: List[nodes.MapEntry], map_exits: List[nodes.MapExit],\\n node: nodes.AccessNode):\\n variant_dimensions = set()\\n subset_length = -1\\n\\n for in_edge in graph.in_edges(node):\\n if in_edge.src in map_exits:\\n other_edge = graph.memlet_path(in_edge)[-2]\\n other_subset = other_edge.data.subset \\\\\\n if other_edge.data.data == node.data \\\\\\n else other_edge.data.other_subset\\n\\n for (idx, (ssbs1, ssbs2)) \\\\\\n in enumerate(zip(in_edge.data.subset, other_subset)):\\n if ssbs1 != ssbs2:\\n variant_dimensions.add(idx)\\n else:\\n warnings.warn(\\\"SubgraphFusion::Nodes between two maps to be\\\"\\n \\\"fused with *incoming* edges\\\"\\n \\\"from outside the maps are not\\\"\\n \\\"allowed yet.\\\")\\n\\n if subset_length < 0:\\n subset_length = other_subset.dims()\\n else:\\n assert other_subset.dims() == subset_length\\n\\n for out_edge in graph.out_edges(node):\\n if out_edge.dst in map_entries:\\n for other_edge in graph.out_edges(out_edge.dst):\\n if other_edge.src_conn and other_edge.src_conn[3:] == out_edge.dst_conn[2:]:\\n other_subset = other_edge.data.subset \\\\\\n if other_edge.data.data == node.data \\\\\\n else other_edge.data.other_subset\\n for (idx, (ssbs1, ssbs2)) in enumerate(zip(out_edge.data.subset, other_subset)):\\n if ssbs1 != ssbs2:\\n variant_dimensions.add(idx)\\n assert other_subset.dims() == subset_length\\n\\n invariant_dimensions = set([i for i in range(subset_length)]) - variant_dimensions\\n return invariant_dimensions\",\n \"def test_figure4(self):\\n\\n topics = get_topics('msmarco-passage-dev-subset')\\n qrels = get_qrels('msmarco-passage-dev-subset')\\n\\n self.assertEqual(len(topics), 6980)\\n self.assertEqual(len(qrels), 6980)\\n\\n # Compute the average length of queries:\\n avg_qlen = sum([len(topics[t]['title'].split()) for t in topics])/len(topics)\\n\\n # Compute the average number of relevance judgments per query:\\n avg_qrels = sum([len(qrels[t]) for t in topics])/len(topics)\\n\\n self.assertAlmostEqual(avg_qlen, 5.925, delta=0.001)\\n self.assertAlmostEqual(avg_qrels, 1.065, delta=0.001)\",\n \"def measureSpecificityUsingDict(foundJunctionsBed, ests, wiggle=0, goodFile=None, badFile=None):\\n\\n overlaps = 0\\n noOverlaps = 0\\n\\n # do it slow for now\\n # read in all the junctions we found\\n found = {} # found[chr][(left, right)] = count\\n for line in open(foundJunctionsBed):\\n if line.startswith(\\\"track\\\"):\\n continue\\n\\n if len(line) < 3:\\n continue\\n\\n pieces = line.split(\\\"\\\\t\\\")\\n #print pieces\\n if len(pieces) == 0:\\n continue\\n\\n if pieces[0].startswith(\\\"Plasmodium_falciparum\\\"):\\n pieces[0] = pieces[0].split(\\\"|\\\")[1].replace(\\\"MAL\\\", \\\"chr\\\")\\n\\n if pieces[0].startswith(\\\"psu|Pf\\\"):\\n pieces[0] = \\\"chr\\\" + str(int(pieces[0].split()[0].split(\\\"|\\\")[1].split(\\\"_\\\")[1]))\\n\\n\\n if not found.has_key(pieces[0]):\\n found[pieces[0]] = {}\\n\\n leftEdge, rightEdge = getEdges(int(pieces[1]), pieces[10], pieces[11])\\n if not found[pieces[0]].has_key( (leftEdge,rightEdge) ):\\n found[pieces[0]][(leftEdge,rightEdge)] = 0\\n found[pieces[0]][(leftEdge,rightEdge)] += 1\\n\\n # for every one of our junction, do they overlap with an est?\\n if goodFile != None and badFile != None:\\n goodOut = open(goodFile, \\\"w\\\")\\n badOut = open(badFile, \\\"w\\\")\\n\\n for chr, edgeDict in found.iteritems():\\n for (leftEdge, rightEdge) in edgeDict.keys():\\n foundOne = False\\n for x in range(leftEdge-wiggle, leftEdge+wiggle+1):\\n for y in range(rightEdge-wiggle, rightEdge+wiggle+1):\\n if ests.has_key(chr):\\n if ests[chr].has_key( (x, y) ):\\n foundOne = True\\n if foundOne:\\n overlaps += found[chr][(leftEdge,rightEdge)]\\n if goodFile != None:\\n goodOut.write(\\\"\\\\t\\\".join([chr, str(leftEdge), str(rightEdge), str(overlaps)]))\\n goodOut.write(\\\"\\\\n\\\")\\n else:\\n noOverlaps += found[chr][(leftEdge,rightEdge)]\\n if badFile != None:\\n badOut.write(\\\"\\\\t\\\".join([chr, str(leftEdge), str(rightEdge), str(noOverlaps)]))\\n badOut.write(\\\"\\\\n\\\")\\n\\n if (noOverlaps + overlaps) > 0:\\n print \\\"%s overlapped but %s did not. %.2d%% overlapped\\\" % (overlaps, noOverlaps, (overlaps*100.0)/(noOverlaps+overlaps))\\n\\n return (overlaps*100.0) / (noOverlaps + overlaps)\\n else:\\n print \\\"No junctions found!\\\"\\n return 0\",\n \"def count_edges(input_first, input_second, problem):\\n\\tcount = 0\\n\\tfor idx in xrange(len(input_first)):\\n\\t\\tfor index in xrange(len(input_second)):\\n\\t\\t\\tif (input_first[idx], input_second[index]) in problem:\\n\\t\\t\\t\\tcount += 1\\n\\t\\t\\telif (input_second[index], input_first[idx]) in problem:\\n\\t\\t\\t\\tcount += 1\\n\\treturn count\",\n \"def GraphBetter(metric_set1_sorted, metric_set2_sorted, base_is_set_2):\\n total_bitrate_difference_ratio = 0.0\\n count = 0\\n for bitrate, metric in metric_set1_sorted:\\n for i in range(len(metric_set2_sorted) - 1):\\n s2_bitrate_0, s2_metric_0 = metric_set2_sorted[i]\\n s2_bitrate_1, s2_metric_1 = metric_set2_sorted[i + 1]\\n # We have a point on either side of our metric range.\\n if metric > s2_metric_0 and metric <= s2_metric_1:\\n\\n # Calculate a slope.\\n if s2_metric_1 - s2_metric_0 != 0:\\n metric_slope = ((s2_bitrate_1 - s2_bitrate_0) /\\n (s2_metric_1 - s2_metric_0))\\n else:\\n metric_slope = 0\\n\\n estimated_s2_bitrate = (s2_bitrate_0 + (metric - s2_metric_0) *\\n metric_slope)\\n\\n # Calculate percentage difference as given by base.\\n if base_is_set_2 == 0:\\n bitrate_difference_ratio = ((bitrate - estimated_s2_bitrate) /\\n bitrate)\\n else:\\n bitrate_difference_ratio = ((bitrate - estimated_s2_bitrate) /\\n estimated_s2_bitrate)\\n\\n total_bitrate_difference_ratio += bitrate_difference_ratio\\n count += 1\\n break\\n\\n # Calculate the average improvement between graphs.\\n if count != 0:\\n avg = total_bitrate_difference_ratio / count\\n\\n else:\\n avg = 0.0\\n\\n return avg\",\n \"def gal_count(clusters):\\n sum = 0\\n for x in clusters:\\n sum += x.ngal\\n return sum\",\n \"def numIslands(grid):\\n # count to store each new island found\\n count = 0\\n # If the grid is empty, return 0\\n if not grid:\\n return count\\n\\n y_max = len(grid)\\n x_max = len(grid[0])\\n \\n for i in range(len(grid)):\\n for j in range(len(grid[0])):\\n if grid[i][j] == '1':\\n dfs(grid, i, j)\\n count += 1\\n return count\",\n \"def _num_edges(self):\\n return len(self._eid2partid)\",\n \"def calculate_betweenness(graph, edges):\\n for root in graph:\\n visited = set()\\n _bfs({root: [1, []]}, graph, edges, visited)\",\n \"def countMatches(g1, g2):\\n if g1 is None or g2 is None or len(g1) == 0 or len(g1[0]) == 0: # sanity check\\n return 0\\n count = 0\\n for i in range(len(g1)):\\n for j in range(len(g1[0])):\\n if g1[i][j] == g2[i][j] == 1 and search_grid(g1, g2, i, j):\\n count = count + 1\\n return count\",\n \"def compute_visit_freq_table(self, episodes):\\n visited_states = {state: 0 for state in self._all_states}\\n visited_sets_episodes = []\\n for episode in episodes:\\n visited_set = set()\\n if episode.solved:\\n visited_set.add(self.goal_state)\\n states_batch = [self.obs2tuple(obs) for obs in\\n episode.transition_batch.observation]\\n for state in states_batch:\\n visited_states[state] += 1\\n visited_set.add(state)\\n self._visited_states_in_history.add(state)\\n visited_sets_episodes.append(visited_set)\\n if episode.solved:\\n visited_states[self.goal_state] += 1\\n\\n visited_freq = np.mean([len(x) / 3 ** self.n_disks\\n for x in visited_sets_episodes])\\n visited_states = {state: visited_states[state] /\\n (len(episodes) * 3 ** self.n_disks)\\n for state in self._all_states}\\n return visited_states, visited_freq\",\n \"def count_paths((min_i, min_j), (max_i, max_j)):\\n\\n def explore((i, j), path):\\n found = 0\\n for (x, y) in neighbors((min_i, min_j), (max_i, max_j), (i, j)):\\n if (x, y) == (max_i, max_j):\\n found += 1\\n debug(\\\"neighbor %r of node %r on path %r is a goal node: +1\\\" % ((x, y), (i, j), path))\\n elif (x, y) in path: \\n debug(\\\"neighbor %r of node %r already on path %r; ignoring...\\\" % ((x, y), (i, j), path))\\n continue\\n else:\\n debug(\\\"neighbor %r of node %r not already on path %r; exploring ...\\\" % ((x, y), (i, j), path))\\n found += explore((x, y), mkpath(path, (x, y)))\\n return found\\n return explore((0, 0), set([(0, 0)]))\",\n \"def calc_precision_map(self, output_filenm=\\\"\\\"):\\n logger.info(\\\"Calculating precision map\\\")\\n success_map, total_map = {}, {} # map from query r to a dict of path and ratio of success\\n # not sure why I am getting RuntimeError: dictionary changed size during iteration.\\n train_map = [((e1, r), e2_list) for ((e1, r), e2_list) in self.train_map.items()]\\n for ((e1, r), e2_list) in tqdm(train_map):\\n c = self.args.cluster_assignments[self.entity_vocab[e1]]\\n if c not in success_map:\\n success_map[c] = {}\\n if c not in total_map:\\n total_map[c] = {}\\n if r not in success_map[c]:\\n success_map[c][r] = {}\\n if r not in total_map[c]:\\n total_map[c][r] = {}\\n paths_for_this_relation = self.args.path_prior_map_per_relation[c][r]\\n for p_ctr, (path, _) in enumerate(paths_for_this_relation.items()):\\n ans = self.execute_one_program(e1, path, depth=0, max_branch=100)\\n if len(ans) == 0:\\n continue\\n # execute the path get answer\\n if path not in success_map[c][r]:\\n success_map[c][r][path] = 0\\n if path not in total_map[c][r]:\\n total_map[c][r][path] = 0\\n for a in ans:\\n if a in e2_list:\\n success_map[c][r][path] += 1\\n total_map[c][r][path] += 1\\n\\n precision_map = {}\\n for c, _ in success_map.items():\\n for r, _ in success_map[c].items():\\n if c not in precision_map:\\n precision_map[c] = {}\\n if r not in precision_map[c]:\\n precision_map[c][r] = {}\\n for path, s_c in success_map[c][r].items():\\n precision_map[c][r][path] = s_c / total_map[c][r][path]\\n\\n if not output_filenm:\\n dir_name = os.path.join(args.data_dir, \\\"data\\\", self.args.dataset_name, \\\"linkage={}\\\".format(self.args.linkage))\\n output_filenm = os.path.join(dir_name, \\\"precision_map.pkl\\\")\\n logger.info(\\\"Dumping precision map at {}\\\".format(output_filenm))\\n with open(output_filenm, \\\"wb\\\") as fout:\\n pickle.dump(precision_map, fout)\\n logger.info(\\\"Done...\\\")\",\n \"def count_islands(matrix):\\n visited = init_visited(matrix)\\n num_islands = 0\\n for i in range(len(matrix)):\\n for j in range(len(matrix)):\\n if matrix[i][j] and not visited[i][j]:\\n check_neighbours(matrix, (i, j), visited)\\n num_islands += 1\\n # print(visited)\\n return num_islands\",\n \"def calc_w_inference(g1, inf_g1, g2, inf_g2, consider_label):\\n edges_g1 = np.count_nonzero(g1)\\n edges_g2 = np.count_nonzero(g2)\\n\\n overlap_r1 = 0\\n overlap_r2 = 0\\n n_nodes = len(g1)\\n for i in range(n_nodes):\\n for j in range(n_nodes):\\n if consider_label:\\n if (g1[i][j] != NO_REL_SYMBOL and inf_g2[i][j]!= NO_REL_SYMBOL) and (g1[i][j] == inf_g2[i][j]):\\n overlap_r1 += 1 # how much g1 recalls \\\"populated\\\"-g2\\n if (inf_g1[i][j] != NO_REL_SYMBOL and g2[i][j]!= NO_REL_SYMBOL) and (inf_g1[i][j] == g2[i][j]):\\n overlap_r2 += 1 # how much g2 recalls \\\"populated\\\"-g2\\n else:\\n if (g1[i][j] != NO_REL_SYMBOL and inf_g2[i][j]!= NO_REL_SYMBOL):\\n overlap_r1 += 1\\n if (inf_g1[i][j] != NO_REL_SYMBOL and g2[i][j]!= NO_REL_SYMBOL):\\n overlap_r2 += 1\\n\\n r1 = float(overlap_r1) / float(edges_g1)\\n r2 = float(overlap_r2) / float(edges_g2)\\n return (r1 + r2) / float(2)\",\n \"def anchors_to_adjacency(set_path, n_proteomes, mailbox_reader):\\n frame_list = []\\n for idx in range(n_proteomes):\\n with mailbox_reader(idx) as file_handle:\\n frame_list.append(\\n pd.read_csv(\\n file_handle, sep=\\\"\\\\t\\\", index_col=0\\n ).convert_dtypes()\\n )\\n nodes = pd.concat(\\n frame_list,\\n ignore_index=True,\\n )\\n del frame_list\\n graph = nx.Graph()\\n for unused_tuple, subframe in nodes.groupby(\\n by=[\\\"syn.anchor.id\\\", \\\"syn.anchor.sub_id\\\"]\\n ):\\n ids = subframe[\\\"member_ids\\\"]\\n n_ids = len(ids)\\n graph.add_nodes_from(ids)\\n if n_ids > 1:\\n edges = combinations(ids, 2)\\n graph.add_edges_from(edges, weight=n_ids)\\n outpath = set_path / ANCHORS_FILE\\n summarypath = outpath.parent / (\\n outpath.name[: -len(outpath.suffix)] + \\\"_summary.tsv\\\"\\n )\\n histpath = outpath.parent / (\\n outpath.name[: -len(outpath.suffix)] + \\\"_hist.tsv\\\"\\n )\\n components = [\\n c\\n for c in sorted(nx.connected_components(graph), key=len, reverse=True)\\n if len(c) > 1\\n ]\\n fh = outpath.open(\\\"w\\\")\\n fh.write(\\\"idx\\\\tcluster_id\\\\tsize\\\\tmembers\\\\n\\\")\\n n_items = 0\\n count_list = []\\n hash_list = []\\n id_list = []\\n for i, comp in enumerate(components):\\n component = np.sort(pd.Index(list(comp)).to_numpy())\\n id_list.append(i)\\n size = len(comp)\\n count_list.append(size)\\n hash_list.append(hash_array(component))\\n for node in component:\\n fh.write(f\\\"{n_items}\\\\t{i}\\\\t{size}\\\\t{node}\\\\n\\\")\\n n_items += 1\\n fh.close()\\n n_clusts = len(count_list)\\n del graph, components\\n cluster_counts = pd.DataFrame({\\\"size\\\": count_list})\\n largest_cluster = cluster_counts[\\\"size\\\"].max()\\n cluster_hist = (\\n pd.DataFrame(cluster_counts.value_counts()).sort_index().reset_index()\\n )\\n cluster_hist = cluster_hist.set_index(\\\"size\\\")\\n cluster_hist = cluster_hist.rename(columns={0: \\\"n\\\"})\\n cluster_hist[\\\"item_pct\\\"] = (\\n cluster_hist[\\\"n\\\"] * cluster_hist.index * 100.0 / n_items\\n )\\n cluster_hist.to_csv(histpath, sep=\\\"\\\\t\\\", float_format=\\\"%5.2f\\\")\\n cluster_hist[\\\"cluster_pct\\\"] = cluster_hist[\\\"n\\\"] * 100.0 / n_clusts\\n cluster_hist.to_csv(histpath, sep=\\\"\\\\t\\\", float_format=\\\"%5.2f\\\")\\n clusters = pd.DataFrame(\\n {\\\"anchor.id\\\": id_list, \\\"count\\\": count_list, \\\"hash\\\": hash_list}\\n )\\n clusters.to_csv(summarypath, sep=\\\"\\\\t\\\")\\n stats_dict = {\\n \\\"in_anchor\\\": n_items,\\n \\\"syn.anchors.n\\\": n_clusts,\\n \\\"syn.anchors.largest\\\": largest_cluster,\\n }\\n return stats_dict\",\n \"def _identify_required_grads(self):\\n self.grad_expected += 1\\n if self.grad_expected == 1: # only backpropagate once from each node\\n for child in self.children:\\n child._identify_required_grads()\",\n \"def compute_sw_threshold(flanking_reads, paf_dict, fasta_dict, window_size):\\n\\n max_scores = []\\n for query, target in itertools.product(flanking_reads, flanking_reads):\\n\\n if str(query + target) in paf_dict:\\n overlap_info = paf_dict[query+target]\\n elif str(target + query) in paf_dict:\\n # get info and swap them\\n overlap_info = paf_dict[target+query]\\n query, target = target, query\\n else:\\n continue\\n\\n query_start = overlap_info['query_start']\\n query_end = overlap_info['query_end']\\n target_start = overlap_info['target_start']\\n target_end = overlap_info['target_end']\\n\\n query_seq = fasta_dict[query][query_start:query_end]\\n target_seq = fasta_dict[target][target_start:target_end]\\n\\n # Get scores for this pair; store in cur_scores\\n cur_scores = []\\n if window_size:\\n # Use rolling window\\n min_len = min(len(query_seq), len(target_seq))\\n for start, end in utils.pairwise(range(0, min_len, window_size)):\\n qs = query_seq[start:end]\\n ts = target_seq[start:end]\\n score = smith_waterman.smith_waterman(qs, ts)\\n cur_scores.append(score)\\n\\n if cur_scores:\\n score = max(cur_scores)\\n max_scores.append(score)\\n else:\\n # No rolling window\\n score = smith_waterman.smith_waterman(query_seq, target_seq)\\n max_scores.append(score)\\n\\n threshold = 0.9 * max(max_scores)\\n\\n print(\\\"using {} as threshold\\\".format(threshold))\\n\\n plt.subplot(2, 3, 2)\\n plt.hist(max_scores)\\n plt.title(\\\"FLANKING READS\\\\nhistogram of num_gaps / len(aligned_sequence)\\\\nthreshold = {}\\\\nwindow_size = {}\\\\nshowing {} scores\\\"\\n .format(threshold, window_size, len(max_scores)))\\n\\n\\n\\n return threshold\",\n \"def test_count_gaps(self):\\n field = Field.create()\\n self.assertEqual(field.count_gaps(), 0)\\n\\n field = Field.create(generate_valid_state(np.array([\\n [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\\n [1, 0, 1, 0, 1, 1, 1, 1, 1, 1],\\n ])))\\n self.assertEqual(field.count_gaps(), 0)\\n\\n field = Field.create(generate_valid_state(np.array([\\n [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\\n ])))\\n self.assertEqual(field.count_gaps(), 1)\\n\\n field = Field.create(generate_valid_state(np.array([\\n [1, 0, 0, 0, 0, 0, 0, 0, 1, 0],\\n [0, 1, 1, 0, 0, 0, 0, 0, 1, 0],\\n [1, 0, 0, 1, 0, 0, 0, 0, 1, 0],\\n [0, 0, 0, 1, 0, 0, 0, 1, 1, 1],\\n ])))\\n self.assertEqual(field.count_gaps(), 6)\",\n \"def compute_map(ranks, gnd, kappas=[]):\\n\\n map = 0.\\n nq = len(gnd) # number of queries\\n aps = np.zeros(nq)\\n pr = np.zeros(len(kappas))\\n prs = np.zeros((nq, len(kappas)))\\n nempty = 0\\n\\n for i in np.arange(nq):\\n qgnd = np.array(gnd[i]['ok'])\\n\\n # no positive images, skip from the average\\n if qgnd.shape[0] == 0:\\n aps[i] = float('nan')\\n prs[i, :] = float('nan')\\n nempty += 1\\n continue\\n\\n try:\\n qgndj = np.array(gnd[i]['junk'])\\n except:\\n qgndj = np.empty(0)\\n\\n # sorted positions of positive and junk images (0 based)\\n pos = np.arange(ranks.shape[0])[np.in1d(ranks[:,i], qgnd)]\\n junk = np.arange(ranks.shape[0])[np.in1d(ranks[:,i], qgndj)]\\n\\n k = 0;\\n ij = 0;\\n if len(junk):\\n # decrease positions of positives based on the number of\\n # junk images appearing before them\\n ip = 0\\n while (ip < len(pos)):\\n while (ij < len(junk) and pos[ip] > junk[ij]):\\n k += 1\\n ij += 1\\n pos[ip] = pos[ip] - k\\n ip += 1\\n\\n # compute ap\\n ap = compute_ap(pos, len(qgnd))\\n map = map + ap\\n aps[i] = ap\\n\\n # compute precision @ k\\n pos += 1 # get it to 1-based\\n for j in np.arange(len(kappas)):\\n kq = min(max(pos), kappas[j]); \\n prs[i, j] = (pos <= kq).sum() / kq\\n pr = pr + prs[i, :]\\n\\n map = map / (nq - nempty)\\n pr = pr / (nq - nempty)\\n\\n return map, aps, pr, prs\",\n \"def compute_probability_weights(indexing, \\n counts, \\n image, \\n binary_set_mappings): \\n S_w_cardinalities = np.zeros_like(indexing)\\n\\n countsgeq2 = sum(c>=2 for c in counts) # compute amount of indices that have count>=2\\n countseq1 = [v for v in range(indexing.shape[0]) if counts[indexing[v]]==1]\\n K_cardinalities = np.zeros_like(indexing)\\n for card,w in enumerate(countseq1[::-1]):\\n K_cardinalities[w] = card\\n\\n for w,index in enumerate(indexing):\\n if counts[index] >= 3:\\n S_w_cardinalities[w] = len(image)\\n elif counts[index] == 2:\\n offset = 1 if w==binary_set_mappings[index] else 0\\n S_w_cardinalities[w] = len(image) - 1 + offset\\n elif counts[index] == 1:\\n S_w_cardinalities[w] = countsgeq2 + K_cardinalities[w]\\n\\n return S_w_cardinalities/np.sum(S_w_cardinalities)\",\n \"def get_GNS_cut(self):\\n # we build the optimization around the casted digraph instead of multidigraph\\n # for simplicity\\n G = self.base_digraph\\n s_1 = self.sources[0]\\n s_2 = self.sources[1]\\n t_1 = self.destinations[0]\\n t_2 = self.destinations[1]\\n edges = G.edges()\\n nodes = G.nodes()\\n\\n try:\\n\\n # Great an gurobi instance of the optimization model\\n m = Model(\\\"GNS\\\")\\n m.setParam('OutputFlag', False)\\n\\n x_v = {}\\n # vertex variables for s_1, t_1 cut\\n for v in nodes:\\n x_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n x_e = {}\\n # edge variables for s_1, t_1 cut\\n for (u,v) in edges:\\n x_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n y_v = {}\\n # vertex variables for s_2, t_2 cut\\n for v in nodes:\\n y_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n y_e = {}\\n # edge variables for s_2, t_2 cut\\n for (u,v) in edges:\\n y_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n z_v = {}\\n # vertex variables for s_2, t_1 cut\\n for v in nodes:\\n z_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n z_e = {}\\n # edge variables for s_2, t_1 cut\\n for (u,v) in edges:\\n z_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n e = {}\\n # GNS indicator variable\\n for (u,v) in edges:\\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\\n\\n # Done with decision variable creation\\n # update model\\n m.update()\\n\\n # Constraints\\n # 1. Constraints for s_1 - t_1 cut\\n for (u,v) in edges:\\n if (u,v) == (s_1, t_1):\\n m.addConstr(x_e[u,v] >= 1)\\n elif u == s_1:\\n m.addConstr(x_v[v] + x_e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-x_v[u] + x_e[u,v] >= 0)\\n else:\\n m.addConstr(x_v[v] - x_v[u] + x_e[u,v] >= 0)\\n\\n # 2. Constraints for s_2 - t_2 cut\\n for (u,v) in edges:\\n if (u,v) == (s_2, t_2):\\n m.addConstr(y_e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(y_v[v] + y_e[u,v] >= 1)\\n elif v == t_2:\\n m.addConstr(-y_v[u] + y_e[u,v] >= 0)\\n else:\\n m.addConstr(y_v[v] - y_v[u] + y_e[u,v] >= 0)\\n\\n # 3. Constraints for s_2 - t_1 cut\\n for (u,v) in edges:\\n if (u,v) == (s_2, t_1):\\n m.addConstr(z_e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(z_v[v] + z_e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-z_v[u] + z_e[u,v] >= 0)\\n else:\\n m.addConstr(z_v[v] - z_v[u] + z_e[u,v] >= 0)\\n\\n # 4. Constraints for e[u,v] >= max(x_e[u,v], y_e[u,v], z_e[u,v])\\n for (u,v) in edges:\\n m.addConstr(e[u,v] >= x_e[u,v])\\n m.addConstr(e[u,v] >= y_e[u,v])\\n m.addConstr(e[u,v] >= z_e[u,v])\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n print \\\"Min GNS cut value = \\\" + str(m.objVal)\\n print \\\"GNS cut edges:\\\"\\n\\n for u,v in edges:\\n if e[u,v].x != 0:\\n print (u,v)\\n print \\\"s1-t1 cut edges in GNS:\\\"\\n for u,v in edges:\\n if x_e[u,v].x != 0:\\n print (u,v)\\n\\n print \\\"s2-t2 cut edges in GNS:\\\"\\n for u,v in edges:\\n if y_e[u,v].x != 0:\\n print (u,v)\\n\\n print \\\"s2-t1 cut edges in GNS:\\\"\\n for u,v in edges:\\n if z_e[u,v].x != 0:\\n print (u,v)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong\\\"\\n\\n except GurobiError:\\n print ('Error report from Gurobi')\",\n \"def count_genes(node_id):\\n node = tree.node(node_id)\\n\\n if options.loglevel >= 6:\\n options.stdlog.write(\\\"# node_id=%i\\\\n\\\" % node_id)\\n if options.loglevel >= 10:\\n options.stdlog.write(\\\"# sets=%s\\\\n\\\" % (str(genes)))\\n\\n # species in pattern\\n num_species_in_pattern = len(positive_set)\\n\\n if node.succ:\\n # process non-leaf node\\n for s in node.succ:\\n\\n # propagate: terminated nodes force upper nodes to terminate\\n # (assigned to None).\\n if not genes[s]:\\n genes[node_id] = None\\n return\\n\\n # total number of genes at node\\n num_genes_at_node = 0\\n # total number of species at node\\n num_species_at_node = 0\\n\\n # compute new gene set for each species at node\\n for x in positive_set:\\n genes[node_id][x] = genes[node_id][x].union(genes[s][x])\\n\\n num_genes_for_species = len(genes[node_id][x])\\n if exit_function(num_genes_for_species):\\n genes[node_id] = None\\n return\\n num_genes_at_node += num_genes_for_species\\n if num_genes_for_species:\\n num_species_at_node += 1\\n\\n if options.loglevel >= 6:\\n print \\\"node=\\\", node_id, \\\"species_at_node\\\", num_species_at_node, \\\"genes_at_node=\\\", num_genes_at_node, \\\\\\n \\\"num_genes_for_species=\\\", num_genes_for_species, \\\"ngenes=\\\", sum(\\n map(lambda x: len(x), genes[node_id]))\\n options.stdlog.write(\\n \\\"# genes at node %i\\\\t%s\\\\n\\\" % (node_id, genes[node_id]))\\n if outgroups:\\n print sum([len(genes[node_id][x]) for x in outgroups])\\n print check_outgroup_function(genes[node_id])\\n\\n # check stop criterion\\n if total_species_function(num_species_at_node, num_species_in_pattern):\\n # check if positive requirements are fulfilled\\n for x in positive_set:\\n if not keep_function(len(genes[node_id][x])):\\n if options.loglevel >= 6:\\n options.stdlog.write(\\n \\\"# keep function false for species %i\\\\n\\\" % x)\\n break\\n else:\\n if total_genes_function(num_genes_at_node, num_species_in_pattern):\\n if options.loglevel >= 6:\\n options.stdlog.write(\\\"# recording node %i\\\\n\\\" % x)\\n ortholog_nodes.append((node_id, genes[node_id]))\\n genes[node_id] = None\\n return\\n elif check_outgroup_function(genes[node_id]):\\n ortholog_nodes.append((node_id, genes[node_id]))\\n genes[node_id] = None\\n return\\n elif negative_set:\\n if total_genes_function(num_genes_at_node, num_species_in_pattern):\\n if options.loglevel >= 6:\\n options.stdlog.write(\\\"# recording node %i\\\\n\\\" % node_id)\\n ortholog_nodes.append((node_id, genes[node_id]))\\n\\n else:\\n # process leaf\\n s, t, g, q = parseIdentifier(node.data.taxon, options)\\n c = options.org2column[s]\\n if c in positive_set:\\n genes[node_id][c].add(g)\\n elif c in negative_set:\\n genes[node_id] = None\",\n \"def cal_pn(grams_set, grams, candidate, reference):\\n count = 0\\n for gram in grams_set:\\n # print(gram)\\n count += count_clip(gram, grams, reference)\\n # calculate log() for p, so '+10**-8' avoid 'p==0'\\n p = count / len(grams) + 10**-8 \\n return p\",\n \"def compute_detection_counts(kinds, valid_mask, aoi_mask, scene_counts):\\n scene_counts = np.maximum(scene_counts, 1)\\n if len(kinds):\\n pairs = (kinds == 'pair_trawlers')\\n singles = (kinds == 'single_trawler')\\n scales = (kinds == 'pair_trawlers') * 2 + (kinds == 'single_trawler')\\n aoi_pts = round((scales * (valid_mask & aoi_mask) / scene_counts).sum(), 1) \\n aoi_pairs = round((pairs * (valid_mask & aoi_mask) / scene_counts).sum(), 1) \\n else:\\n aoi_pts = aoi_pairs = 0\\n return aoi_pts, aoi_pairs\",\n \"def graph_count(self) -> int:\\n return int(self.graph_tuple_stats.graph_count)\",\n \"def branchNBound(nationtxt, bound, scheme):\\n provinces = []\\n index = 0\\n costs = 0\\n numTransmitters = 7\\n\\n transmitterCosts = scheme\\n nation = nationLoader(nationtxt)\\n\\n\\n neighborCount = {}\\n for province in nation:\\n neighborCount.update({province:len(nation.get(province)[0])})\\n\\n\\n #~ neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__)\\n\\n neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__, reverse=True)\\n\\n for key in neighborCountSorted:\\n provinces.append(key)\\n #~ print provinces\\n\\n upperbound = bound\\n #~ print bound\\n #~ print bound\\n\\n\\n\\n solution = []\\n\\n\\n counter = 0\\n\\n\\n\\n\\n\\n while index >= 0:\\n\\n\\n counter += 1\\n if counter % 100000000 == 0:\\n print counter\\n print \\\"Now at:\\\", nation\\n\\n\\n if index == -1:\\n break\\n\\n # Assign transmitter\\n if nation[provinces[index]][1] == numTransmitters:\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n else:\\n costs, index = updateTransmitter(nation, False, scheme, provinces, costs, index)\\n\\n # Check if costs are above upper bound\\n if (costs + (len(provinces) - (index + 1)) * transmitterCosts[0]) > upperbound:\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n # Check if a neighbor has the same transmitter\\n conflict = False\\n for neighbor in nation[provinces[index]][0]:\\n if nation[neighbor][1] == nation[provinces[index]][1]:\\n conflict = True\\n break\\n\\n if conflict:\\n continue\\n\\n # Check if a solution is found\\n if index == len(provinces) - 1:\\n #~ print \\\"\\\\nSOLUTION:\\\"\\n if costs < upperbound:\\n solution = []\\n solution.append(json_deep_copy(nation))\\n upperbound = costs\\n #~ print \\\"Score:\\\", upperbound\\n #~ print nation\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n index += 1\\n\\n\\n usedTrans = []\\n fivePlus = 0\\n fivePlusNoDuplicate = 0\\n\\n for nation in solution:\\n\\n one = 0\\n two = 0\\n three = 0\\n four = 0\\n five = 0\\n six = 0\\n seven = 0\\n\\n for province in nation:\\n\\n if nation[province][1] == 1:\\n one += 1\\n if nation[province][1] == 2:\\n two += 1\\n if nation[province][1] == 3:\\n three += 1\\n if nation[province][1] == 4:\\n four += 1\\n if nation[province][1] == 5:\\n five += 1\\n if nation[province][1] == 6:\\n six += 1\\n if nation[province][1] == 7:\\n seven += 1\\n\\n\\n if five > 0 or six > 0 or seven > 0:\\n fivePlus += 1\\n if transmitterCosts[3] != transmitterCosts[4]:\\n fivePlusNoDuplicate += 1\\n\\n usedTrans.append([one, two, three, four, five, six, seven])\\n\\n return fivePlus, fivePlusNoDuplicate, usedTrans, upperbound, len(solution), counter\\n #~ f.write(\\\"\\\\n Used Transmitters: \\\"+ str(one)+\\\" \\\"+ str(two)+\\\" \\\"+ str(three)+\\\" \\\"+ str(four)+\\\" \\\"+ str(five)+\\\" \\\"+ str(six)+\\\" \\\"+ str(seven)+\\\"\\\\n Cost: \\\"+str(upperbound)+\\\"\\\\n Number of solutions: \\\"+str(len(solution))+\\\"\\\\n Iterations: \\\"+str(counter)+\\\"\\\\n\\\"+\\\"\\\\n\\\"+\\\"\\\\n\\\"+\\\"\\\\n\\\")\\n\\n #~ print \\\"transmitter frequecies:\\\", one, two, three, four, five, six, seven\\n #~ print \\\"Solutions:\\\", solution\\n #~ print \\\"Cost:\\\", upperbound\\n #~ print \\\"Number of solutions:\\\", len(solution)\\n #~ print \\\"Iterations:\\\", counter\",\n \"def caculate_network_statistics(self):\\n divide_factor_sum = 0 \\n for key in self.stars.keys():\\n star = self.stars[key]\\n if star.nb_num == 0 :\\n self.standalone_star_num += 1 \\n\\n divide_factor = star.nb_num + 2 * (star.spec_num - star.shared_spec_num )/self.ave_starlet_size\\n divide_factor_sum += divide_factor\\n divide_factor_int = round(divide_factor)\\n self.star_divide_factor_dist[divide_factor_int] = self.star_divide_factor_dist.get(divide_factor_int,0) + 1\\n if star.spec_num < star.shared_spec_num:\\n print(\\\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\\\")\\n print(\\\"with star \\\" + star.id + \\\" \\\" + str(star.spec_num) + \\\"is less than\\\" + str(star.shared_spec_num))\\n if star.spec_num > star.shared_spec_num:\\n self.star_lost_spec_num += star.spec_num - star.shared_spec_num\\n self.ave_divide_factor_star = divide_factor_sum/self.stars_length\\n\\n divide_factor_sum = 0 \\n for key in self.starlets.keys():\\n starlet = self.starlets[key]\\n if starlet.nb_num == 0 :\\n self.standalone_starlet_num += 1 \\n\\n divide_factor = starlet.nb_num + 2 * (starlet.spec_num - starlet.shared_spec_num )/self.ave_star_size\\n divide_factor_sum += divide_factor\\n divide_factor_int = round(divide_factor)\\n self.starlet_divide_factor_dist[divide_factor_int] = self.starlet_divide_factor_dist.get(divide_factor_int,0) + 1\\n if starlet.spec_num < starlet.shared_spec_num:\\n print(\\\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\\\")\\n print(\\\"with star \\\" + starlet.id + \\\" \\\" + str(starlet.spec_num) + \\\"is less than\\\" + str(starlet.shared_spec_num))\\n if starlet.spec_num > starlet.shared_spec_num:\\n self.starlet_lost_spec_num += starlet.spec_num - starlet.shared_spec_num\\n self.ave_divide_factor_starlet = divide_factor_sum/self.starlets_length\",\n \"def num_edges(self):\\r\\n return len(self.__generate_edges())\",\n \"def edge_mapping(self):\\n ...\",\n \"def connected_set_sizes(self):\\n self._assert_counted_at_lag()\\n return self._connected_set_sizes\",\n \"def graph_helper(device, output,input,target):\\n output = output.clone().squeeze()\\n corrects = torch.zeros(output.shape[0])\\n for i in range(output.shape[0]): # goes through each iteration\\n outputi = output[i]\\n golden_label = convert_to_bits(device, outputi, input)\\n target = target.view(target.size(0), -1)\\n corrects[i] += torch.amin(golden_label == target, dim=[0]).sum().item() # counts the number that are the same i.e. correct predictions\\n correct = corrects.cpu().detach().numpy()\\n return correct\",\n \"def _n_regions_to_allocate(send_buffering, recording):\\n if recording and send_buffering:\\n return 5\\n if recording or send_buffering:\\n return 4\\n return 3\",\n \"def _tally_limits(self, limits, elements, connections=None):\\n counts = {}\\n for x in limits:\\n ele = elements[x]\\n if self.use_coordination:\\n ele += str(len(connections[x]))\\n if ele not in counts:\\n counts[ele] = 0\\n counts[ele] += 1\\n return counts\",\n \"def a_star(my_map, start_locs, goal_locs, h_values, agent, constraints):\\n\\n ##############################\\n # Task 1.1: Extend the A* search to search in the space-time domain\\n # rather than space domain, only.\\n # Build constraint table if there are constraints\\n\\n constraint_table = build_constraint_table(constraints, agent)\\n\\n open_list = []\\n closed_list = dict()\\n nodes_opened = 0\\n max_opened = 500\\n start_loc = start_locs[0]\\n goal_loc = goal_locs[0]\\n if len(start_locs) > 1: # If there is more than 1 start location then this is a multi-cell agent\\n multi = True\\n else:\\n multi = False\\n\\n # determine when the last constraint is on the goal node (or any of the goal node cells in the case of multi-cell)\\n earliest_goal_timestep = 0\\n if len(constraint_table) != 0:\\n for time in [item for item in sorted(list(constraint_table.keys()), reverse=True)]:\\n flat_list = [item for sublist in constraint_table[time] for item in sublist]\\n if(goal_locs[0] in flat_list):\\n earliest_goal_timestep = time\\n break\\n elif(multi): # if multi cell check if any of the agents goal cells are constrained \\n if(goal_locs[1] in flat_list): \\n earliest_goal_timestep = time\\n break\\n\\n h_value = h_values[start_loc]\\n goal_orientation = orientation(goal_locs)\\n\\n root = {'loc': start_loc,'orientation': orientation(start_locs), 'g_val': 0, 'h_val': h_value, 'time': 0, 'parent': None}\\n push_node(open_list, root)\\n closed_list[(root['loc'], root['time'], root['orientation'])] = root\\n\\n while len(open_list ) > 0 and nodes_opened < max_opened:\\n curr = pop_node(open_list)\\n nodes_opened = nodes_opened + 1\\n \\n if curr['loc'] == goal_loc and curr['orientation'] == goal_orientation and curr['time'] >= earliest_goal_timestep:\\n return get_path(curr)\\n ############################\\n child_orient = curr['orientation']\\n for dir in range(7):\\n if dir < 5:\\n child_loc = move(curr['loc'], dir)\\n elif not multi: \\n continue\\n\\n if dir == 5:\\n # clockwise rotation \\n child_orient = curr['orientation'] - 1\\n if child_orient < 1:\\n child_orient = 4\\n if dir == 6:\\n # counter-clockwise rotation \\n child_orient = curr['orientation'] + 1\\n if child_orient > 4:\\n child_orient = 1\\n \\n if test_map(my_map, child_loc[0], child_loc[1], child_orient, dir):\\n continue\\n \\n # check if the head location is constrained \\n if is_constrained(curr['loc'], child_loc, child_orient, dir, curr['time'] + 1, constraint_table):\\n continue\\n\\n # if this is a multi cell agent check if the tail is constrained \\n if multi:\\n # check the next tail location \\n row_t, col_t, _, _ = find_tail_positions(curr['loc'][0], curr['loc'][1], curr['orientation'], dir)\\n next_row_t, next_col_t, next_row_t_inter, next_col_t_inter = find_tail_positions(child_loc[0], child_loc[1], child_orient, dir)\\n\\n if is_constrained((row_t,col_t), (next_row_t, next_col_t), child_orient, dir, curr['time'] + 1, constraint_table):\\n continue\\n\\n # if the agent is rotating check if the intermediate location is constrained\\n if dir == 5 or dir == 6: \\n if is_constrained((row_t,col_t), (next_row_t_inter, next_col_t_inter), child_orient, dir, curr['time'] + 1, constraint_table):\\n continue\\n\\n child = {'loc': child_loc,\\n 'orientation': child_orient,\\n 'g_val': curr['g_val'] + 1,\\n 'h_val': h_values[child_loc] + orient_cost(child_orient, goal_orientation),\\n 'time': curr['time'] + 1,\\n 'parent': curr}\\n\\n if (child['loc'], child['time'], child['orientation']) in closed_list:\\n existing_node = closed_list[(child['loc'], child['time'], child['orientation'])]\\n \\n if compare_nodes(child, existing_node):\\n closed_list[(child['loc'], child['time'], child['orientation'])] = child\\n push_node(open_list, child)\\n else:\\n closed_list[(child['loc'], child['time'], child['orientation'])] = child\\n push_node(open_list, child)\\n \\n return None # Failed to find solutions\",\n \"def _number_of_edges(self):\\n if self._edges is None:\\n return 0\\n return len(self._edges)\",\n \"def baseline_score(self,t0,t1):\\n return len(set(t0) & set(t1))/len(set(t0).union(set(t1)))\",\n \"def trio_hits(l_contig, mid_contig_end, blast_hits, olap_dict, cont_dict):\\n mid_contig = mid_contig_end.split(\\\"prime_\\\")[1]\\n length_mid = len(cont_dict[mid_contig].seq) \\n right_links = []\\n right_links = list(olap_dict[mid_contig_end].keys())\\n \\n #If contigs are chromosomal, ensure they are adjacent\\n if chr_links:\\n if l_contig in chr_links: \\n new_right_links= []\\n for r_l in right_links:\\n if r_l not in chr_links or r_l in chr_links[l_contig]:\\n new_right_links.append(r_l)\\n right_links = new_right_links \\n \\n if len(right_links) == 1:\\n outcome = right_links[0]\\n elif len(right_links) == 0:\\n outcome = \\\"link_listempty\\\"\\n else:\\n left_matches = []\\n for hit in blast_hits:\\n if (hit[0] == l_contig) and (int(hit[11]) >= l_min_score):\\n left_matches.append(hit)\\n link_count = {}\\n for link in right_links:\\n \\n right_matches = []\\n\\n for hit in blast_hits:\\n if (hit[0] == link) and (int(hit[11]) >= r_min_score): \\n right_matches.append(hit)\\n \\n for lhit in left_matches:\\n for rhit in right_matches:\\n if lhit[1] == rhit[1]:\\n lh_start = int(lhit[8])\\n lh_end = int(lhit[9])\\n rh_start = int(rhit[8])\\n rh_end = int(rhit[9])\\n if abs(lh_start - rh_start) < length_mid + 100:\\n if (lh_end - lh_start)/(rh_end - rh_start) < 0:\\n if abs(lh_end - rh_end) > abs(lh_start - rh_start):\\n link_score = int(lhit[11]) * int(rhit[11])\\n if not link in link_count: \\n link_count[link] = link_score\\n elif link_score > link_count[link]:\\n link_count[link] = link_score\\n \\n number_of_matches = len(link_count)\\n if number_of_matches == 1:\\n outcome = list(link_count.keys())[0]\\n if number_of_matches == 0:\\n outcome = \\\"link_unmatched\\\"\\n if number_of_matches > 1:\\n outcome = max(link_count, key = link_count.get)\\n\\n return outcome\",\n \"def count_accuracy(G_true, G):\\n B_true = G_true != 0# nx.to_numpy_array(G_true) != 0\\n B = G != 0# nx.to_numpy_array(G) != 0\\n d = B.shape[0]\\n # linear index of nonzeros\\n pred = np.flatnonzero(B)\\n cond = np.flatnonzero(B_true)\\n cond_reversed = np.flatnonzero(B_true.T)\\n cond_skeleton = np.concatenate([cond, cond_reversed])\\n # true pos\\n true_pos = np.intersect1d(pred, cond, assume_unique=True)\\n\\n # false pos\\n false_pos = np.setdiff1d(pred, cond_skeleton, assume_unique=True)\\n # reverse\\n extra = np.setdiff1d(pred, cond, assume_unique=True)\\n reverse = np.intersect1d(extra, cond_reversed, assume_unique=True)\\n # compute ratio\\n pred_size = len(pred)\\n cond_neg_size = 0.5 * d * (d - 1) - len(cond)\\n fdr = float(len(reverse) + len(false_pos)) / max(pred_size, 1)\\n tpr = float(len(true_pos)) / max(len(cond), 1)\\n fpr = float(len(reverse) + len(false_pos)) / max(cond_neg_size, 1)\\n # structural hamming distance\\n B_lower = np.tril(B + B.T)\\n pred_lower = np.flatnonzero(B_lower)\\n cond_lower = np.flatnonzero(np.tril(B_true + B_true.T))\\n extra_lower = np.setdiff1d(pred_lower, cond_lower, assume_unique=True)\\n missing_lower = np.setdiff1d(cond_lower, pred_lower, assume_unique=True)\\n shd = len(extra_lower) + len(missing_lower) + len(reverse)\\n return shd, tpr, fpr, fdr, pred_size\",\n \"def num_edges(self):\\n return sum(len(v.adj) for v in self.vertices.values())\",\n \"def labelled_attachment(gold_trees, pred_trees):\\n count_match, count_total = 0, 0\\n for gold, pred in zip(gold_trees, pred_trees):\\n triples_pairs = zip(\\n gold.get_triples(include_root=True),\\n pred.get_triples(include_root=True),\\n )\\n for (g_src, g_trg, g_rel), (p_src, p_trg, p_rel) in triples_pairs:\\n assert g_src == p_src\\n count_total += 1\\n if g_trg == p_trg and g_rel == p_rel:\\n count_match += 1\\n if count_match == 0 or count_total == 0:\\n return 0.0\\n else:\\n return float(count_match) / count_total\",\n \"def score(tmp_dir, locusList, ranges):\\r\\n\\t\\r\\n\\tloc = ''\\r\\n\\tpos = 1\\r\\n\\tcount_indel = 0\\r\\n\\tholes = 0\\r\\n\\tsnps = 0\\r\\n\\tcovMax=combined_covMax=covSum=covSum2= 0 \\r\\n\\tcovMin = combined_covMin =99999\\r\\n\\tpercentage_coverages =[]\\r\\n\\tsnpList = []\\r\\n\\tindelList = []\\r\\n\\tresults = {} \\r\\n\\t\\r\\n\\tpileup_file = os.path.join(tmp_dir, 'all.pileup')\\r\\n\\tfor l in open(pileup_file):\\r\\n\\t\\tt = l.split()\\r\\n\\t\\tif loc == '':\\r\\n\\t\\t\\tloc = t[0] \\r\\n\\t\\t\\tpos = ranges[loc][0] + 1 \\r\\n\\t\\tif t[0] != loc:\\r\\n\\t\\t\\tresults =GenerateResult(ranges,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tholes, locusList,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tloc,snps,count_indel,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tsnpList, indelList,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tpercentage_coverages,combined_covMin,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcombined_covMax, covMin, covMax,covSum, results)\\r\\n\\t\\t\\t# reset locus vars\\r\\n\\t\\t\\tloc = t[0] \\r\\n\\t\\t\\tpos = ranges[loc][0] + 1 \\r\\n\\t\\t\\tcount_indel = 0\\r\\n\\t\\t\\tholes =snps=covMax=combined_covMax=covSum=covSum2= 0 \\r\\n\\t\\t\\tcovMin =combined_covMin= 99999\\r\\n\\t snpList = []\\r\\n\\t\\t\\tindelList = []\\r\\n\\t\\t\\tpercentage_coverages =[]\\r\\n\\t\\there = int(t[1])\\r\\n\\t\\tif here - 1 < ranges[loc][0]: \\r\\n\\t\\t\\tcontinue\\r\\n\\t\\telif here - 1 >= ranges[loc][1]: \\r\\n\\t\\t\\tcontinue\\r\\n\\t\\twhile pos < here: \\r\\n\\t\\t\\tholes += 1 \\r\\n\\t\\t\\tpos += 1\\r\\n\\r\\n\\t\\tv, indel, array_of_all_indels,most_common_indel = pile(t[2], t[4])\\r\\n\\t\\tx = v.items()\\r\\n\\t\\tx.sort(lambda a,b: compGreater(t[2], a, b))\\r\\n\\t\\t\\r\\n\\t\\tif x[0][0] != t[2].lower():\\r\\n\\t\\t\\tsnps += 1\\r\\n\\t\\t\\tsnpList.append((pos,t[2],v));\\r\\n\\t\\tc = x[0][1] \\r\\n\\t\\tcov= int(most_common_indel)/float(t[3]) \\r\\n\\t\\tif cov > 0.5: \\r\\n count_indel += 1\\r\\n indel_type = Counter(array_of_all_indels) \\r\\n indel_type = indel_type.items()\\r\\n indelList.append((int(pos),t[2], indel_type))\\r\\n\\t\\tcovSum += c \\r\\n\\t\\tcovSum2 += c * c\\r\\n\\t\\tif c > covMax:\\r\\n\\t\\t\\tcovMax = c\\r\\n\\t\\tif c < covMin:\\r\\n\\t\\t\\tcovMin = c\\r\\n\\t\\tcombined_c = x[0][1] + x[1][1] + x[2][1] + x[3][1] \\r\\n\\t\\tif combined_c > combined_covMax:\\r\\n\\t\\t\\tcombined_covMax = c \\r\\n\\t\\tif combined_c < combined_covMin:\\r\\n\\t\\t\\tcombined_covMin = c \\r\\n\\t\\t\\r\\n\\t\\tn = int(t[3]) \\r\\n\\t\\tjs = []\\r\\n\\t\\tfor (_,j) in x[1:]: \\r\\n\\t\\t\\tjs.append(j) \\r\\n\\t\\tpercentage_coverage = sum(js)/float(n)*100 \\r\\n\\t\\tpercentage_coverages.append(round(float(percentage_coverage),2))\\r\\n\\t\\tpos = here + 1\\r\\n\\tresults =GenerateResult(ranges,\\r\\n\\t\\t\\t\\t\\t\\t\\tholes,\\r\\n\\t\\t\\t\\t\\t\\t\\tlocusList,loc,\\r\\n\\t\\t\\t\\t\\t\\t\\tsnps,count_indel,\\r\\n\\t\\t\\t\\t\\t\\t\\tsnpList,indelList,\\r\\n\\t\\t\\t\\t\\t\\t\\tpercentage_coverages,combined_covMin,\\r\\n\\t\\t\\t\\t\\t\\t\\tcombined_covMax, covMin, covMax,\\r\\n\\t\\t\\t\\t\\t\\t\\tcovSum, results)\\r\\n\\t\\r\\n\\treturn results\",\n \"def __create_d_map(self):\\n goal_map = {}\\n # collect all goal nodes\\n for i, row in enumerate(self.map.get_node_grid()):\\n for j, node in enumerate(row):\\n if node.borders_tile_of_type(Quarantine):\\n goal_map[node.get_name()] = (i, j)\\n # calculate distance to closest goal node for each node\\n for i, row in enumerate(self.map.get_node_grid()):\\n for j, node in enumerate(row):\\n distances = [\\n abs(i - y) + abs(j - x)\\n for node_name, (y, x) in goal_map.items()\\n ]\\n self.d_map[node.get_name()] = min(distances)\",\n \"def getNet(chrom, loops, genes, pdis=2000, gap=1):\\n #step 1 get merged anchors\\n anchors = stichAnchors(chrom, loops, margin=gap)\\n #step 2 annotate anchors\\n nanchors = {}\\n ts = np.array([[tss] for tss in genes.keys()])\\n tree = KDTree(ts)\\n for anchor in anchors:\\n gs, ds = findOverlapOrNearest(genes, ts, tree, anchor.start,\\n anchor.end)\\n if len(gs) > 1:\\n t = \\\"Promoter\\\"\\n d = 0\\n else:\\n d = ds[0]\\n if abs(d) <= pdis:\\n t = \\\"Promoter\\\"\\n else:\\n t = \\\"Enhancer\\\"\\n n = anchor.chrom + \\\":\\\" + str(anchor.start) + \\\"-\\\" + str(\\n anchor.end) + \\\"|\\\" + t\\n nanchors[n] = {\\n \\\"chrom\\\":\\n anchor.chrom,\\n \\\"start\\\":\\n anchor.start,\\n \\\"end\\\":\\n anchor.end,\\n \\\"type\\\":\\n n.split(\\\"|\\\")[-1],\\n \\\"nearestDistanceToTSS\\\":\\n d,\\n \\\"nearestGene\\\":\\n \\\",\\\".join([g.name for g in gs]),\\n \\\"nearestGeneLoc\\\":\\n \\\",\\\".join([\\n g.chrom + \\\":\\\" + str(g.start) + \\\"-\\\" + str(g.end) + \\\"|\\\" +\\n g.strand + \\\"|\\\" + g.name for g in gs\\n ])\\n }\\n anchors = nanchors\\n del nanchors\\n #step 3 assign each anchor to merged annotated anchor and build the network\\n anchorCov = {}\\n for k, v in anchors.items():\\n for i in range(v[\\\"start\\\"], v[\\\"end\\\"] + 1):\\n anchorCov[i] = k\\n ds = {} #anchor annotations\\n nets = {} #net information\\n G = nx.Graph() #networkx graph structure\\n for loop in loops:\\n xt, yt = None, None\\n for i in range(loop.x_start, loop.x_end + 1):\\n if i in anchorCov:\\n xt = anchorCov[i]\\n break\\n for i in range(loop.y_start, loop.y_end + 1):\\n if i in anchorCov:\\n yt = anchorCov[i]\\n break\\n ds[loop.id] = {\\n \\\"mergedAnchorA\\\": xt,\\n \\\"mergedAnchorB\\\": yt,\\n }\\n if xt == yt:\\n continue\\n ns = [xt, yt]\\n ns.sort() #sort for converging keys\\n if ns[0] not in nets:\\n nets[ns[0]] = set()\\n nets[ns[0]].add(ns[1])\\n #network edges\\n G.add_edge(ns[0], ns[1])\\n #step 4 find all enhancers linked to target gene\\n targets = {}\\n #step 4.1 find the direct enhancer that link to promoter\\n for node in G.nodes:\\n if node.split(\\\"|\\\")[-1] == \\\"Promoter\\\":\\n if node in targets:\\n continue\\n targets[node] = {\\n \\\"targetGene\\\": anchors[node][\\\"nearestGeneLoc\\\"],\\n \\\"directEnhancer\\\": set(),\\n \\\"indirectEnhancer\\\": set(),\\n \\\"directPromoter\\\": set(),\\n \\\"indirectPromoter\\\": set()\\n }\\n ns = list(nx.descendants(G, node))\\n #find all releated nodes\\n for n in ns:\\n p = nx.algorithms.shortest_path(G, source=node, target=n)\\n if n.split(\\\"|\\\")[-1] == \\\"Promoter\\\":\\n if len(p) == 2:\\n targets[node][\\\"directPromoter\\\"].add(n)\\n else:\\n targets[node][\\\"indirectPromoter\\\"].add(n)\\n if n.split(\\\"|\\\")[-1] == \\\"Enhancer\\\":\\n if len(p) == 2:\\n targets[node][\\\"directEnhancer\\\"].add(n)\\n else:\\n targets[node][\\\"indirectEnhancer\\\"].add(n)\\n #step 4.2. find hub enhancer\\n #only using non-redundant node to find hubs\\n nns = []\\n tmp = set()\\n for n in ns:\\n tn = n.split(\\\"|\\\")[0]\\n if tn not in tmp:\\n nns.append(n)\\n tmp.add(tn)\\n ns = list(nns)\\n ns.append(node)\\n subg = G.subgraph(ns)\\n try:\\n hubs, authorities = nx.hits(subg,\\n max_iter=1000,\\n normalized=True)\\n except:\\n print(\\n \\\"For %s, hard to find the hub by running HITS algorithm of 1000 iteration.\\\"\\n % node)\\n targets[node][\\\"directEnhancerHub\\\"] = \\\"\\\"\\n targets[node][\\\"indirectEnhancerHub\\\"] = \\\"\\\"\\n continue\\n hubs = pd.Series(hubs)\\n hubs = hubs.sort_values(inplace=False, ascending=False)\\n if len(targets[node][\\\"directEnhancer\\\"]) >= 2:\\n des = hubs[list(targets[node][\\\"directEnhancer\\\"])]\\n des = des.sort_values(inplace=False, ascending=False)\\n targets[node][\\\"directEnhancerHub\\\"] = des.index[0]\\n else:\\n targets[node][\\\"directEnhancerHub\\\"] = \\\"\\\"\\n if len(targets[node][\\\"indirectEnhancer\\\"]) >= 2:\\n indes = hubs[list(targets[node][\\\"indirectEnhancer\\\"])]\\n indes = indes.sort_values(inplace=False, ascending=False)\\n targets[node][\\\"indirectEnhancerHub\\\"] = indes.index[0]\\n else:\\n targets[node][\\\"indirectEnhancerHub\\\"] = \\\"\\\"\\n return anchors, ds, nets, targets\",\n \"def edgecount(self):\\n\\n raise NotImplementedError\",\n \"def update_cnt_map(self,s):\\r\\n cnts = []\\r\\n num_grid = self.cnt_map.shape[0]*self.cnt_map.shape[1]\\r\\n old_coverage =num_grid- self.cnt_map.flatten().tolist().count(0)\\r\\n for sj in s:\\r\\n grid_s = self.get_gridState(sj)\\r\\n self.cnt_map[grid_s[0], grid_s[1]] += 1\\r\\n cnts.append(self.cnt_map[grid_s[0], grid_s[1]])\\r\\n\\r\\n self.map_coverage = num_grid - self.cnt_map.flatten().tolist().count(0)\\r\\n print(\\\"Coverage:\\\",self.map_coverage)\\r\\n print(\\\"Change of coverage:\\\",self.map_coverage-old_coverage)\\r\\n\\r\\n return cnts\",\n \"def num_vertex_sets(self, r):\\n return sage.all.binomial(self.n, r)\",\n \"def _measure(d, sources, target, niter=25, bound=None):\\n uniques = {}\\n for source in sources:\\n others = list(sources)\\n others.remove(source)\\n others = list(flatten(others))\\n uniques[source] = one_way_skar(d, source, target, others)\\n return uniques\",\n \"def num_accepts(self, max_len: int, bound: Sequence[Text] = ()) -> Tuple[int, int, int]:\\n lt1: Dict[FrozenSet[int], int] = collections.defaultdict(int)\\n lt2: Dict[FrozenSet[int], int] = collections.defaultdict(int)\\n eq1: Dict[FrozenSet[int], int] = collections.defaultdict(int)\\n eq2: Dict[FrozenSet[int], int] = collections.defaultdict(int)\\n gt1: Dict[FrozenSet[int], int] = collections.defaultdict(int)\\n gt2: Dict[FrozenSet[int], int] = collections.defaultdict(int)\\n eq1[frozenset(self.start_nodes)] = 1\\n num_accepted_le = int(self.accepts(\\\"\\\"))\\n num_accepted_gt = 0\\n for c in itertools.islice(itertools.chain(bound, itertools.repeat(None)), 0, max_len):\\n for nodes, count in lt1.items():\\n for element in self.possible_transitions(nodes):\\n next_nodes = frozenset(self.next_nodes(nodes, element))\\n lt2[next_nodes] += count\\n for nodes, count in eq1.items():\\n for element in self.possible_transitions(nodes):\\n next_nodes = frozenset(self.next_nodes(nodes, element))\\n if c is None or (element is not None and element > c):\\n gt2[next_nodes] += count\\n elif element == c:\\n eq2[next_nodes] += count\\n else:\\n lt2[next_nodes] += count\\n for nodes, count in gt1.items():\\n for element in self.possible_transitions(nodes):\\n next_nodes = frozenset(self.next_nodes(nodes, element))\\n gt2[next_nodes] += count\\n num_accepted_le += self._sum_tables(eq2)\\n num_accepted_le += self._sum_tables(lt2)\\n num_accepted_gt += self._sum_tables(gt2)\\n if not lt2 and not eq2 and not gt2:\\n break # Exit early if we know this regex cannot accept anymore strings.\\n lt1, lt2 = lt2, collections.defaultdict(int)\\n eq1, eq2 = eq2, collections.defaultdict(int)\\n gt1, gt2 = gt2, collections.defaultdict(int)\\n num_accepted_eq = int(len(bound) <= max_len and self.accepts(bound))\\n return num_accepted_le - num_accepted_eq, num_accepted_eq, num_accepted_gt\",\n \"def ngraphs(self):\\n return len(self.__graph_list)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.55912036","0.553591","0.5377618","0.53747284","0.53365","0.5324719","0.5322185","0.5320498","0.5284785","0.52796876","0.5255801","0.5249715","0.5231621","0.5206148","0.51990473","0.519828","0.51928836","0.51651835","0.51341033","0.5120622","0.511521","0.50705624","0.50290227","0.50163823","0.4992436","0.4988187","0.49855474","0.4982166","0.49643457","0.49609903","0.49577478","0.4957743","0.495684","0.49374598","0.49325547","0.49322334","0.49283648","0.49229264","0.49050444","0.49033442","0.49029535","0.49019447","0.4893439","0.4883423","0.4881097","0.48619235","0.48595798","0.48561826","0.48549777","0.4847156","0.4844232","0.48439333","0.48387665","0.48373616","0.48359963","0.48277542","0.4824394","0.48224562","0.4808553","0.48048452","0.480327","0.48028198","0.47973576","0.47969812","0.47947153","0.4790513","0.4789815","0.47862697","0.47836447","0.4781645","0.47810516","0.47787675","0.4777506","0.4776505","0.4775789","0.47756165","0.47710043","0.4770346","0.4760356","0.47590548","0.47575983","0.47562096","0.47510913","0.4746985","0.4742629","0.473586","0.4735321","0.47304162","0.47303396","0.47295368","0.4719648","0.47173932","0.4715765","0.4710587","0.47085005","0.47030592","0.47025165","0.4700585","0.46986598","0.46980533"],"string":"[\n \"0.55912036\",\n \"0.553591\",\n \"0.5377618\",\n \"0.53747284\",\n \"0.53365\",\n \"0.5324719\",\n \"0.5322185\",\n \"0.5320498\",\n \"0.5284785\",\n \"0.52796876\",\n \"0.5255801\",\n \"0.5249715\",\n \"0.5231621\",\n \"0.5206148\",\n \"0.51990473\",\n \"0.519828\",\n \"0.51928836\",\n \"0.51651835\",\n \"0.51341033\",\n \"0.5120622\",\n \"0.511521\",\n \"0.50705624\",\n \"0.50290227\",\n \"0.50163823\",\n \"0.4992436\",\n \"0.4988187\",\n \"0.49855474\",\n \"0.4982166\",\n \"0.49643457\",\n \"0.49609903\",\n \"0.49577478\",\n \"0.4957743\",\n \"0.495684\",\n \"0.49374598\",\n \"0.49325547\",\n \"0.49322334\",\n \"0.49283648\",\n \"0.49229264\",\n \"0.49050444\",\n \"0.49033442\",\n \"0.49029535\",\n \"0.49019447\",\n \"0.4893439\",\n \"0.4883423\",\n \"0.4881097\",\n \"0.48619235\",\n \"0.48595798\",\n \"0.48561826\",\n \"0.48549777\",\n \"0.4847156\",\n \"0.4844232\",\n \"0.48439333\",\n \"0.48387665\",\n \"0.48373616\",\n \"0.48359963\",\n \"0.48277542\",\n \"0.4824394\",\n \"0.48224562\",\n \"0.4808553\",\n \"0.48048452\",\n \"0.480327\",\n \"0.48028198\",\n \"0.47973576\",\n \"0.47969812\",\n \"0.47947153\",\n \"0.4790513\",\n \"0.4789815\",\n \"0.47862697\",\n \"0.47836447\",\n \"0.4781645\",\n \"0.47810516\",\n \"0.47787675\",\n \"0.4777506\",\n \"0.4776505\",\n \"0.4775789\",\n \"0.47756165\",\n \"0.47710043\",\n \"0.4770346\",\n \"0.4760356\",\n \"0.47590548\",\n \"0.47575983\",\n \"0.47562096\",\n \"0.47510913\",\n \"0.4746985\",\n \"0.4742629\",\n \"0.473586\",\n \"0.4735321\",\n \"0.47304162\",\n \"0.47303396\",\n \"0.47295368\",\n \"0.4719648\",\n \"0.47173932\",\n \"0.4715765\",\n \"0.4710587\",\n \"0.47085005\",\n \"0.47030592\",\n \"0.47025165\",\n \"0.4700585\",\n \"0.46986598\",\n \"0.46980533\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8308598"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14699,"cells":{"query":{"kind":"string","value":"Determines the quality of the communities based on the \"ground truth\" of spanset and gapset. First, determines which community corresponds to gapset and spanset. Then, returns number of wrong nodes."},"document":{"kind":"string","value":"def community_quality(communities, spanset, gapset):\n if len(communities) != 2:\n return -1\n\n com_sets = [set(c) for c in communities]\n spanset = set(spanset)\n gapset = set(gapset)\n\n spanset_0 = len(com_sets[0].difference(spanset))\n spanset_1 = len(com_sets[1].difference(spanset))\n gapset_0 = len(com_sets[0].difference(gapset))\n gapset_1 = len(com_sets[1].difference(gapset))\n\n # used for determining which community corresponds to gapset and spanset\n spanset_i = 1 - np.argmax([spanset_0, spanset_1])\n gapset_i = 1 - np.argmax([gapset_0, gapset_1])\n\n if spanset_i == gapset_i:\n # Error in finding community quality\n return -1\n elif spanset_i == 0:\n return spanset_0 + gapset_1\n elif spanset_i == 1:\n return spanset_1 + gapset_0\n else:\n return -1"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def mapping_quality(graph, spanset, gapset):\n the_sum = sum(sum(1 for edge in graph.edges(node) if edge[1] in gapset) for node in spanset)\n # if directed graph, uncomment this:\n #the_sum += sum(sum(1 for edge in graph.edges(node) if edge[1] in spanset) for node in gapset)\n return the_sum","def compare(self):\n len0 = len(self.cluster_lists[0])\n len1 = len(self.cluster_lists[1])\n longer_index = 0 if len0 >= len1 else 1\n shorter_index = 1 if len1 <= len0 else 0\n self.stars_length = len(self.cluster_lists[shorter_index]) \n self.starlets_length = len(self.cluster_lists[longer_index]) \n # build the noeds for shorter cluster list, and get the\n # distribution of cluster size.\n for cluster in self.cluster_lists[shorter_index]:\n len_spectra = len(cluster.get_spectra())\n star = ClusterNode(cluster.id, len_spectra) \n self.stars[cluster.id] = star\n\n self.cluster_spectra_num[shorter_index] += len_spectra\n self.cluster_size_dist[shorter_index][len_spectra] = self.cluster_size_dist[shorter_index].get(len_spectra,0) + 1\n # build the noeds for longer cluster list, and get the\n # distribution of cluster size.\n for cluster in self.cluster_lists[longer_index]:\n len_spectra = len(cluster.get_spectra())\n starlet = ClusterNode(cluster.id, len_spectra) \n self.starlets[cluster.id] = starlet\n\n self.cluster_spectra_num[longer_index] += len_spectra\n self.cluster_size_dist[longer_index][len_spectra] = self.cluster_size_dist[longer_index].get(len_spectra,0) + 1\n # do the comparing, and network building\n for i in range (0, len(self.cluster_lists[shorter_index])):\n cluster0 = self.cluster_lists[shorter_index][i] \n for j in range (i, len(self.cluster_lists[longer_index])):\n cluster1 = self.cluster_lists[longer_index][j] \n (shared_spec_num, similarity) = self.calculate_similarity(cluster0, cluster1)\n if similarity == 0:\n continue\n self.similarity_dist[int(similarity*10)] = self.similarity_dist.get(int(similarity*10),0) + 1\n self.shared_spec_num += shared_spec_num\n\n self.stars[cluster0.id].add_nb_node(cluster1.id, similarity, shared_spec_num)\n self.starlets[cluster1.id].add_nb_node(cluster0.id, similarity, shared_spec_num)\n\n self.ave_star_size = self.cluster_spectra_num[shorter_index]/self.stars_length\n self.ave_starlet_size = self.cluster_spectra_num[longer_index]/self.starlets_length","def communities_with_protesters(partition, active_nodes):\n return len(set([partition[node] for node in active_nodes]))","def community_detection(net_G):\r\n if list(nx.isolates(net_G)) == []:\r\n part = community.best_partition(net_G)\r\n #values = [part.get(node) for node in net_G.nodes()]\r\n #nx.draw_spring(net_G, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=False)\r\n #plt.show()\r\n else:\r\n net_G = net_G.copy()\r\n net_G.remove_nodes_from(list(nx.isolates(net_G)))\r\n part = community.best_partition(net_G)\r\n list_nodes = []\r\n for com in set(part.values()):\r\n list_nodes.append([nodes for nodes in part.keys() if part[nodes] == com])\r\n num_of_communities = len(list_nodes)\r\n partition_performance = nx.algorithms.community.quality.performance(net_G, list_nodes)\r\n net_communities = [[\"Numbers of communities:\", num_of_communities], \\\r\n [\"Partition performance:\", partition_performance]]\r\n return net_communities","def make_set_cover_nr(gRNA_hits, num_sets = 1, target_ids = [], low_coverage_penalty = 0,\n num_lengths_to_track = None, prioritise_3prime = False, optimal_depth = 5,\n suppress_warning = False):\n collapsed_grnas = gRNA_hits.collapse()\n if not target_ids:\n target_ids = set().union(*[set(cg) for cg in collapsed_grnas])\n else:\n target_ids = set(target_ids)\n ## function to regenerate set cover solutions from collapsed_grna object\n collapsed_grnas_original = collapsed_grnas.copy()\n def generate_sc_solutions():\n ## sort in order of smallest set cover size, smallest redundancy, and size of largest set in set cover\n minweight_sc = limited_minweight_SC(collapsed_grnas, num_sets, targets = target_ids,\n low_coverage_penalty = low_coverage_penalty,\n num_lengths_to_track = num_lengths_to_track)\n ## optimal solutions\n max_depth = min(optimal_depth, max(map(len, minweight_sc)))\n max_redundancy = max(map(lambda C:C.redundancy, minweight_sc))/len(target_ids)\n print(max_depth, max_redundancy)\n optimal_sc = limited_optimal_SC(target_ids, collapsed_grnas_original,\n size = max_depth, redundancy = max_redundancy)\n print(\"num unfiltered optimal sc:\", len(optimal_sc))\n ## remove duplicates\n optimal_sc = [C for C in optimal_sc\n if all(map(lambda minweight_C:(len(C) != minweight_C\n and C != minweight_C),\n minweight_sc))]\n print(\"num filtered optimal sc:\", len(optimal_sc))\n return sorted(minweight_sc + optimal_sc,\n key = lambda C:(len(C), C.redundancy, -C.max_coverage))\n sc_solutions = []\n sc_solutions.extend(generate_sc_solutions())\n eliminated_grna = []\n ## function to generate set covers\n def make_set_cover(restore = []):\n ## restore only works if gRNA belonged in the current set cover\n curr_sc = sc_solutions[0]\n for grna in restore:\n curr_sc.add_grna(grna)\n eliminated_grna.remove(grna)\n ## if current set cover solution has at least one CollapsedgRNA with no gRNA left\n while not curr_sc.all_not_empty():\n sink = sc_solutions.pop(0) ## remove set cover solution\n ## generate more possible gRNA sets if no pre-generated set covers are left\n if not sc_solutions:\n collapsed_grnas.remove_grna(*eliminated_grna)\n collapsed_grnas.remove_empty()\n sc_solutions.extend(generate_sc_solutions())\n if not sc_solutions:\n if not suppress_warning:\n print((\"\\nError: The provided gRNA sequences cannot cover all\"\n \" target sequences at least once.\\n\"))\n return []\n ## select next solution\n curr_sc = sc_solutions[0]\n ## consume=True -> remove selected gRNA from CollapsedgRNA\n output = curr_sc.generate_grna_set(prioritise_3prime = prioritise_3prime, consume = True)\n eliminated_grna.extend(output)\n return output\n return make_set_cover","def calc_skill_cluster_sets(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, blocks_one_clusnum, skill_str, seas):\r\n prec_arr, recall_arr, F1_arr, clus_num_arr = [], [], [], []\r\n\r\n prec_vals = sorted(np.unique(blocks_one_clusnum[skill_str].values), reverse = True)\r\n #loop through first element separately so that subsequent values can be appended\r\n node_cluster_set_test_str, ds_arr = [], []\r\n for prec in prec_vals:\r\n node_cluster_set_test_str_app = blocks_one_clusnum['set'][np.where(blocks_one_clusnum[skill_str]==prec)[0]].values\r\n for clus in node_cluster_set_test_str_app:\r\n #add cluster to cluster set\r\n node_cluster_set_test_str = np.append(node_cluster_set_test_str, clus)\r\n node_cluster_set_test_str = np.unique(node_cluster_set_test_str)\r\n node_num = len(node_cluster_set_test_str) # number of nodes in cluster set\r\n clus_num_arr.append(node_num)\r\n #calculate skill score of cluster set by calculating the number of days blocked from the GTD and selecting the season\r\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\r\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \"blocking\", dims={\"time\": GTD['time']})\r\n blocked_days_clus_xr['time'] = GTD['time']\r\n blocked_days_clus_sel = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\r\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_sel)\r\n prec_arr.append(prec)\r\n recall_arr.append(recall)\r\n F1_arr.append(F1)\r\n\r\n return clus_num_arr, prec_arr, recall_arr, F1_arr","def g_minority_1_dev(by_grps):\n if by_grps[0][0]==by_grps[0][1]:\n print(\"Failed g_1dev_t2 -- small groups match\")\n return False\n \n cts = 0\n ctn = 0\n cto = 0\n big_letter= \"\"\n \n for item in by_grps[1]:\n if item==\"S\":\n cts+=1\n if item==\"N\":\n ctn+=1 \n if item==\"O\":\n cto+=1\n if(cts==4 or ctn==4 or cto ==4):\n pass\n else:\n print(\"Failed g_1dev_t2 -- no large group consistency\")\n return False\n \n if(cts==4):\n big_letter = \"S\"\n if(cto==4):\n big_letter = \"O\"\n if(ctn == 4):\n big_letter = \"N\"\n \n for item in by_grps[0]:\n if(item==big_letter):\n print(\"Faield g_1dev_t2 -- a small group member and large group letter are the same\")\n return False\n print(\"Confirmed g_1dev_t2 -- small group with 1 deviancy and large group are different\")\n return True","def caculate_network_statistics(self):\n divide_factor_sum = 0 \n for key in self.stars.keys():\n star = self.stars[key]\n if star.nb_num == 0 :\n self.standalone_star_num += 1 \n\n divide_factor = star.nb_num + 2 * (star.spec_num - star.shared_spec_num )/self.ave_starlet_size\n divide_factor_sum += divide_factor\n divide_factor_int = round(divide_factor)\n self.star_divide_factor_dist[divide_factor_int] = self.star_divide_factor_dist.get(divide_factor_int,0) + 1\n if star.spec_num < star.shared_spec_num:\n print(\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\")\n print(\"with star \" + star.id + \" \" + str(star.spec_num) + \"is less than\" + str(star.shared_spec_num))\n if star.spec_num > star.shared_spec_num:\n self.star_lost_spec_num += star.spec_num - star.shared_spec_num\n self.ave_divide_factor_star = divide_factor_sum/self.stars_length\n\n divide_factor_sum = 0 \n for key in self.starlets.keys():\n starlet = self.starlets[key]\n if starlet.nb_num == 0 :\n self.standalone_starlet_num += 1 \n\n divide_factor = starlet.nb_num + 2 * (starlet.spec_num - starlet.shared_spec_num )/self.ave_star_size\n divide_factor_sum += divide_factor\n divide_factor_int = round(divide_factor)\n self.starlet_divide_factor_dist[divide_factor_int] = self.starlet_divide_factor_dist.get(divide_factor_int,0) + 1\n if starlet.spec_num < starlet.shared_spec_num:\n print(\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\")\n print(\"with star \" + starlet.id + \" \" + str(starlet.spec_num) + \"is less than\" + str(starlet.shared_spec_num))\n if starlet.spec_num > starlet.shared_spec_num:\n self.starlet_lost_spec_num += starlet.spec_num - starlet.shared_spec_num\n self.ave_divide_factor_starlet = divide_factor_sum/self.starlets_length","def get_GNS_cut_reduced(self):\n # we build the optimization around the casted digraph instead of multidigraph\n # for simplicity\n G = self.base_digraph\n s_1 = self.sources[0]\n s_2 = self.sources[1]\n t_1 = self.destinations[0]\n t_2 = self.destinations[1]\n edges = G.edges()\n nodes = G.nodes()\n\n try:\n\n # Great an gurobi instance of the optimization model\n m = Model(\"GNS\")\n m.setParam('OutputFlag', False)\n\n x_v = {}\n # vertex variables for s_1, t_1 cut\n for v in nodes:\n x_v[v] = m.addVar(vtype=GRB.BINARY)\n\n y_v = {}\n # vertex variables for s_2, t_2 cut\n for v in nodes:\n y_v[v] = m.addVar(vtype=GRB.BINARY)\n\n z_v = {}\n # vertex variables for s_2, t_1 cut\n for v in nodes:\n z_v[v] = m.addVar(vtype=GRB.BINARY)\n\n e = {}\n # GNS indicator variable\n for (u,v) in edges:\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\n\n # Done with decision variable creation\n # update model\n m.update()\n\n # Constraints\n # 1. Constraints for s_1 - t_1 cut\n for (u,v) in edges:\n if (u,v) == (s_1, t_1):\n m.addConstr(e[u,v] >= 1)\n elif u == s_1:\n m.addConstr(x_v[v] + e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-x_v[u] + e[u,v] >= 0)\n else:\n m.addConstr(x_v[v] - x_v[u] + e[u,v] >= 0)\n\n if (u,v) == (s_2, t_2):\n m.addConstr(e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(y_v[v] + e[u,v] >= 1)\n elif v == t_2:\n m.addConstr(-y_v[u] + e[u,v] >= 0)\n else:\n m.addConstr(y_v[v] - y_v[u] + e[u,v] >= 0)\n\n if (u,v) == (s_2, t_1):\n m.addConstr(e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(z_v[v] + e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-z_v[u] + e[u,v] >= 0)\n else:\n m.addConstr(z_v[v] - z_v[u] + e[u,v] >= 0)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n #print \"Min GNS cut value = \" + str(m.objVal)\n #print \"GNS cut edges:\"\n cut_set_edges = []\n for u,v in edges:\n if e[u,v].x != 0:\n #print (u,v), str(G[u][v]['capacity'])\n cut_set_edges.append((u,v, G[u][v]['capacity']))\n return (m.objVal, cut_set_edges)\n else:\n # something went wrong...err...\n print \"Something was wrong\"\n return None, None\n\n except GurobiError:\n print ('Error report from Gurobi')","def test_graphs_threshold_omst_global_cost_efficiency2():\n # the function is optmized at the 3rd OMST, so it is going to yeild the same results\n # as the exhaustive search\n\n # Groundtruth\n expected = np.load(\"groundtruth/graphs_threshold/omst_gce.npy\")\n\n # Data\n graph = np.load(\"sample_data/graphs_threshold/graph.npy\")\n\n # Run\n n_msts = 5\n _, CIJtree, _, _, _, _, _, _ = threshold_omst_global_cost_efficiency(\n graph, n_msts=n_msts\n )\n\n # Test\n np.testing.assert_array_equal(expected, CIJtree)","def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\n logger.debug(f\"comparing {node1},{node2}, traversed {traversed}\")\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\n #remove dummies\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\n #remove dummies\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\n logger.debug(f\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\")\n logger.debug(f\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\")\n if not nbrs1 or not nbrs2:\n if compare_two_nodes(G, node1, node2, ports_weight):\n match_pair[node1] = node2\n logger.debug(f\"no new neihbours, returning recursion {match_pair}\")\n return\n elif len(nbrs1)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n logger.debug(f\"skipping high fanout nets due to large computation, {node1} {nbrs1}\")\n traversed.append(node1)\n return\n elif len(nbrs2)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n traversed.append(node2)\n logger.debug(f\"skipping high fanout nets due to large computation, {node2} {nbrs2}\")\n return\n\n if node1 == node2:\n if node1 in match_pair.keys() or node1 in match_pair.values():\n logger.debug(\"avoid existing pair wise symmetry\")\n return\n logger.debug(f\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\")\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\n ## TBD: filter based on primitive constraints\n ## Right now will try to figure out S/D paths\n if len(SD_nbrs) ==0:\n logger.debug(f\"No SD paths found to traverse\")\n match_pair[node1]=node1\n elif len(SD_nbrs) ==1:\n logger.debug(f\"traversing single S/D path {SD_nbrs}\")\n match_pair[node1]=node1\n traversed.append(node1)\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\n else:\n logger.debug(f\" multiple nodes diverging {SD_nbrs}\")\n logger.debug(f\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\")\n match_pair[node1]=node1\n traversed.append(node1)\n new_sp=sorted(set(SD_nbrs)-set(traversed))\n all_match_pairs_local={}\n for nbr1,nbr2 in combinations(new_sp, 2):\n logger.debug(f\"recursive pair call from single branch {nbr1} {nbr2}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n if new_pair:\n #new_pair[nbr1]=nbr2\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\n if len(all_match_pairs_local)==1:\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\n logger.debug(f\"found inline pair: {pprint.pformat(match_pair, indent=4)}\")\n else:\n for nbr1 in new_sp:\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\n logger.debug(f\"recursive single branch call from single branch {nbr1} {nbr1}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif nbrs1 == nbrs2:\n logger.debug(f\"traversing converging branch\")\n match_pair[node1]=node2\n traversed+=[node1,node2]\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\n logger.debug(f\"all non traversed neighbours: {nbrs1}\")\n if len(nbrs1)==1:\n nbr1=nbr2=nbrs1[0]\n logger.debug(f\"keeping single converged branch inline {nbr1} {nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n else:\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\n logger.debug(f\"recursive call from converged branch {nbr1} {nbr2}\")\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif compare_two_nodes(G,node1,node2,ports_weight):\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\n match_pair[node1]=node2\n traversed+=[node1,node2]\n logger.debug(f\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\")\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\n if len(nbrs1)==0 or len(nbrs2)==0:\n logger.debug(f\"no new SD neihbours, returning recursion {match_pair}\")\n elif len(nbrs1) ==1 and len(nbrs2)==1:\n logger.debug(f\"traversing binary branch\")\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\n elif unique_match:\n logger.debug(f'traversing unique matches {unique_match}')\n match_pair[node1]=node2\n traversed+=[node1,node2]\n for nbr1,nbr2 in unique_match.items():\n logger.debug(f\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\n logger.debug(f\"setting new start points {node1} {node2}\")\n match_pair[node1]=node2\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n else:\n match_pair = {}\n logger.debug(f\"end all traversal from binary branch {node1} {node2}\")\n\n else:\n match_pair = {}\n logger.debug(f\"end of recursion branch, matches {match_pair}\")","def test_figure4(self):\n\n topics = get_topics('msmarco-passage-dev-subset')\n qrels = get_qrels('msmarco-passage-dev-subset')\n\n self.assertEqual(len(topics), 6980)\n self.assertEqual(len(qrels), 6980)\n\n # Compute the average length of queries:\n avg_qlen = sum([len(topics[t]['title'].split()) for t in topics])/len(topics)\n\n # Compute the average number of relevance judgments per query:\n avg_qrels = sum([len(qrels[t]) for t in topics])/len(topics)\n\n self.assertAlmostEqual(avg_qlen, 5.925, delta=0.001)\n self.assertAlmostEqual(avg_qrels, 1.065, delta=0.001)","def branchNBound2(nationtxt, bound, scheme):\n\n\n nation = nationLoader(nationtxt)\n transmitterCosts = scheme\n\n neighborCount = {}\n for province in nation:\n neighborCount.update({province:len(nation.get(province)[0])})\n\n\n neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__)\n\n #~ neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__, reverse=True)\n\n for key in neighborCountSorted:\n provinces.append(key)\n #~ print provinces\n\n upperbound = bound\n #~ print bound\n\n\n\n solution = []\n\n\n counter = 0\n\n\n\n\n while index >= 0:\n\n counter += 1\n if counter % 100000000 == 0:\n print counter\n print \"Now at:\", nation\n\n\n if index == -1:\n break\n\n # Assign transmitter\n if nation[provinces[index]][1] == numTransmitters:\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n else:\n costs, index = updateTransmitter(nation, False, scheme, provinces, costs, index)\n\n # Check if costs are above upper bound\n if (costs + (len(provinces) - (index + 1)) * transmitterCosts[0]) > upperbound:\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n # Check if a neighbor has the same transmitter\n conflict = False\n for neighbor in nation[provinces[index]][0]:\n if nation[neighbor][1] == nation[provinces[index]][1]:\n conflict = True\n break\n\n if conflict:\n continue\n\n # Check if a solution is found\n if index == len(provinces) - 1:\n #~ print \"\\nSOLUTION:\"\n if costs < upperbound:\n solution = []\n solution.append(json_deep_copy(nation))\n upperbound = costs\n #~ print \"Score:\", upperbound\n #~ print nation\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n index += 1\n\n\n\n usedTrans = []\n fivePlus = 0\n fivePlusNoDuplicate = 0\n\n for nation in solution:\n\n one = 0\n two = 0\n three = 0\n four = 0\n five = 0\n six = 0\n seven = 0\n\n for province in nation:\n\n if nation[province][1] == 1:\n one += 1\n if nation[province][1] == 2:\n two += 1\n if nation[province][1] == 3:\n three += 1\n if nation[province][1] == 4:\n four += 1\n if nation[province][1] == 5:\n five += 1\n if nation[province][1] == 6:\n six += 1\n if nation[province][1] == 7:\n seven += 1\n\n\n if five > 0 or six > 0 or seven > 0:\n fivePlus += 1\n if transmitterCosts[3] != transmitterCosts[4]:\n fivePlusNoDuplicate += 1\n\n usedTrans.append([one, two, three, four, five, six, seven])\n\n return counter","def specificity():\n\tatlas = 'power'\n\tproject='hcp'\n\tdf_columns=['Task','Hub Measure','Q+/Q-','Average Edge i-j Weight',\"Strength of r's, i's PC & j's Q\"]\n\ttasks = ['REST','WM','GAMBLING','RELATIONAL','MOTOR','LANGUAGE','SOCIAL',]\n\tknown_membership,network_names,num_nodes,name_int_dict = network_labels(atlas)\n\tdf = pd.DataFrame(columns = df_columns)\n\tfor task in tasks:\n\t\tprint task\n\t\t# subjects = np.array(hcp_subjects).copy()\n\t\t# subjects = list(subjects)\n\t\t# subjects = remove_missing_subjects(subjects,task,atlas)\n\t\tsubjects = np.load('/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_subs_fz.npy' %('hcp',task,atlas))\n\t\tstatic_results = graph_metrics(subjects,task,atlas,'fz')\n\t\tsubject_pcs = static_results['subject_pcs']\n\t\tsubject_wmds = static_results['subject_wmds']\n\t\tsubject_mods = static_results['subject_mods']\n\t\tsubject_wmds = static_results['subject_wmds']\n\t\tmatrices = static_results['matrices']\n\t\t#sum of weight changes for each node, by each node.\n\t\thub_nodes = ['WCD']\n\t\t# hub_nodes = ['PC']\n\t\tdriver_nodes_list = ['Q+','Q-']\n\t\t# driver_nodes_list = ['Q+']\n\t\tmean_pc = np.nanmean(subject_pcs,axis=0)\n\t\tmean_wmd = np.nanmean(subject_wmds,axis=0)\n\t\tmod_pc_corr = np.zeros(subject_pcs.shape[1])\n\t\tfor i in range(subject_pcs.shape[1]):\n\t\t\tmod_pc_corr[i] = nan_pearsonr(subject_mods,subject_pcs[:,i])[0]\n\t\tmod_wmd_corr = np.zeros(subject_wmds.shape[1])\n\t\tfor i in range(subject_wmds.shape[1]):\n\t\t\tmod_wmd_corr[i] = nan_pearsonr(subject_mods,subject_wmds[:,i])[0]\n\t\tfor hub_node in hub_nodes:\n\t\t\tif hub_node == 'PC':\n\t\t\t\tpc_edge_corr = np.arctanh(pc_edge_correlation(subject_pcs,matrices,path='/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_pc_edge_corr_z.npy' %(project,task,atlas)))\n\t\t\t\tconnector_nodes = np.where(mod_pc_corr>0.0)[0]\n\t\t\t\tlocal_nodes = np.where(mod_pc_corr<0.0)[0]\n\t\t\telse:\n\t\t\t\tpc_edge_corr = np.arctanh(pc_edge_correlation(subject_wmds,matrices,path='/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_wmd_edge_corr_z.npy' %(project,task,atlas)))\n\t\t\t\tconnector_nodes = np.where(mod_wmd_corr>0.0)[0]\n\t\t\t\tlocal_nodes = np.where(mod_wmd_corr<0.0)[0]\n\t\t\tedge_thresh_val = 50.0\n\t\t\tedge_thresh = np.percentile(np.nanmean(matrices,axis=0),edge_thresh_val)\n\t\t\tpc_edge_corr[:,np.nanmean(matrices,axis=0)<edge_thresh] = np.nan\n\t\t\tfor driver_nodes in driver_nodes_list:\n\t\t\t\tweight_change_matrix_between = np.zeros((num_nodes,num_nodes))\n\t\t\t\tweight_change_matrix_within = np.zeros((num_nodes,num_nodes))\n\t\t\t\tif driver_nodes == 'Q-':\n\t\t\t\t\tdriver_nodes_array = local_nodes\n\t\t\t\telse:\n\t\t\t\t\tdriver_nodes_array = connector_nodes\n\t\t\t\tfor n1,n2 in permutations(range(num_nodes),2):\n\t\t\t\t\tif n1 not in driver_nodes_array:\n\t\t\t\t\t\tcontinue\n\t\t\t\t\tif known_membership[n2] == 0:\n\t\t\t\t\t\tcontinue\n\t\t\t\t\tarray = pc_edge_corr[n1][n2]\n\t\t\t\t\tweight_change_matrix_between[n1,n2] = np.nansum(pc_edge_corr[n1][n2][np.where((known_membership!=known_membership[n2])&(np.arange(264)!=n1))])\n\t\t\t\t\tweight_change_matrix_within[n1,n2] = np.nansum(pc_edge_corr[n1][n2][np.where((known_membership==known_membership[n2])&(np.arange(264)!=n1))])\n\t\t\t\t\t# for n3 in range(264):\n\t\t\t\t\t# \tif n1 == n3:\n\t\t\t\t\t# \t\tcontinue\n\t\t\t\t\t# \tif known_membership[n3]!= known_membership[n2]:\n\t\t\t\t\t# \t\tweight_change_matrix_between[n1,n2] = np.nansum([weight_change_matrix_between[n1,n2],array[n3]])\n\t\t\t\t\t# \t\tbetween_len = between_len + 1\n\t\t\t\t\t# \telse:\n\t\t\t\t\t# \t\tweight_change_matrix_within[n1,n2] = np.nansum([weight_change_matrix_within[n1,n2],array[n3]])\n\t\t\t\t\t# \t\tcommunity_len = community_len + 1\n\t\t\t\t\t# weight_change_matrix_within[n1,n2] = weight_change_matrix_within[n1,n2] / community_len\n\t\t\t\t\t# weight_change_matrix_between[n1,n2] = weight_change_matrix_between[n1,n2] / between_len\n\t\t\t\ttemp_matrix = np.nanmean(matrices,axis=0)\n\t\t\t\tweight_matrix = weight_change_matrix_within-weight_change_matrix_between\n\t\t\t\tweight_matrix[np.isnan(weight_matrix)] = 0.0\n\t\t\t\tif hub_node == 'PC':\n\t\t\t\t\tdf_columns=['Task','Hub Measure','Q+/Q-','Average Edge i-j Weight',\"Strength of r's, i's PC & j's Q\"]\n\t\t\t\telse:\n\t\t\t\t\tdf_columns=['Task','Hub Measure','Q+/Q-','Average Edge i-j Weight',\"Strength of r's, i's WCD & j's Q\"]\n\t\t\t\tdf_array = []\n\t\t\t\tfor i,j in zip(temp_matrix[weight_matrix!=0.0].reshape(-1),weight_matrix[weight_matrix!=0.0].reshape(-1)):\n\t\t\t\t\tdf_array.append([task,hub_node,driver_nodes,i,j])\n\t\t\t\tdf = pd.concat([df,pd.DataFrame(df_array,columns=df_columns)],axis=0)\n\t\t\t\tprint hub_node, driver_nodes\n\t\t\t\tprint pearsonr(weight_matrix[weight_matrix!=0.0].reshape(-1),temp_matrix[weight_matrix!=0.0].reshape(-1))\n\t\t\t\t1/0\n\n\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q+') &(df['Hub Measure']=='PC')],\"Strength of r's, i's PC & j's Q\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_pcqplus_%s.pdf'%(edge_thresh_val))\n\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q-') &(df['Hub Measure']=='PC')],\"Strength of r's, i's PC & j's Q\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_pcqminus_%s.pdf'%(edge_thresh_val))\n\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q+') &(df['Hub Measure']=='WCD')],\"Strength of r's, i's WCD & j's Q\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_wmdqplus_%s.pdf'%(edge_thresh_val))\n\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q-') &(df['Hub Measure']=='WCD')],\"Strength of r's, i's WCD & j's Q\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_wmdqminus_%s.pdf'%(edge_thresh_val))\n\t# \"\"\"\n\t# Are connector nodes modulating the edges that are most variable across subjects?\n\t# \"\"\"\n\t# atlas='power'\n\t# known_membership,network_names,num_nodes,name_int_dict = network_labels(atlas)\n\t# for task in tasks:\n\t# \tpc_thresh = 75\n\t# \tlocal_thresh = 25\n\t# \tsubjects = np.array(hcp_subjects).copy()\n\t# \tsubjects = list(subjects)\n\t# \tsubjects = remove_missing_subjects(subjects,task,atlas)\n\t# \tstatic_results = graph_metrics(subjects,task,atlas)\n\t# \tsubject_pcs = static_results['subject_pcs']\n\t# \tsubject_wmds = static_results['subject_wmds']\n\t# \tmatrices = static_results['matrices']\n\t# \tmatrices[:,np.nanmean(matrices,axis=0)<0.0] = np.nan\n\t# \tpc_edge_corr = np.arctanh(pc_edge_correlation(subject_wmds,matrices,path='/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_wmd_edge_corr_z.npy' %(project,task,atlas)))\n\t# \t# pc_edge_corr = pc_edge_correlation(subject_pcs,matrices,path='/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_pc_edge_corr_z.npy' %(project,task,atlas))\n\t# \tstd_mod = []\n\t# \ttstd = np.std(matrices,axis=0).reshape(-1)\n\t# \tfor i in range(num_nodes):\n\t# \t\tstd_mod.append(nan_pearsonr(pc_edge_corr[i].reshape(-1),tstd)[0])\n\t# \t# print task, pearsonr(np.nanmean(subject_pcs,axis=0),std_mod)\n\t# \tprint task, pearsonr(np.nanmean(subject_wmds,axis=0),std_mod)\n\t# \tplot_corr_matrix(np.std(matrices,axis=0),network_names.copy(),out_file=None,plot_corr=True,return_array=False)","def branchNBound(nationtxt, bound, scheme):\n provinces = []\n index = 0\n costs = 0\n numTransmitters = 7\n\n transmitterCosts = scheme\n nation = nationLoader(nationtxt)\n\n\n neighborCount = {}\n for province in nation:\n neighborCount.update({province:len(nation.get(province)[0])})\n\n\n #~ neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__)\n\n neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__, reverse=True)\n\n for key in neighborCountSorted:\n provinces.append(key)\n #~ print provinces\n\n upperbound = bound\n #~ print bound\n #~ print bound\n\n\n\n solution = []\n\n\n counter = 0\n\n\n\n\n\n while index >= 0:\n\n\n counter += 1\n if counter % 100000000 == 0:\n print counter\n print \"Now at:\", nation\n\n\n if index == -1:\n break\n\n # Assign transmitter\n if nation[provinces[index]][1] == numTransmitters:\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n else:\n costs, index = updateTransmitter(nation, False, scheme, provinces, costs, index)\n\n # Check if costs are above upper bound\n if (costs + (len(provinces) - (index + 1)) * transmitterCosts[0]) > upperbound:\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n # Check if a neighbor has the same transmitter\n conflict = False\n for neighbor in nation[provinces[index]][0]:\n if nation[neighbor][1] == nation[provinces[index]][1]:\n conflict = True\n break\n\n if conflict:\n continue\n\n # Check if a solution is found\n if index == len(provinces) - 1:\n #~ print \"\\nSOLUTION:\"\n if costs < upperbound:\n solution = []\n solution.append(json_deep_copy(nation))\n upperbound = costs\n #~ print \"Score:\", upperbound\n #~ print nation\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\n continue\n\n index += 1\n\n\n usedTrans = []\n fivePlus = 0\n fivePlusNoDuplicate = 0\n\n for nation in solution:\n\n one = 0\n two = 0\n three = 0\n four = 0\n five = 0\n six = 0\n seven = 0\n\n for province in nation:\n\n if nation[province][1] == 1:\n one += 1\n if nation[province][1] == 2:\n two += 1\n if nation[province][1] == 3:\n three += 1\n if nation[province][1] == 4:\n four += 1\n if nation[province][1] == 5:\n five += 1\n if nation[province][1] == 6:\n six += 1\n if nation[province][1] == 7:\n seven += 1\n\n\n if five > 0 or six > 0 or seven > 0:\n fivePlus += 1\n if transmitterCosts[3] != transmitterCosts[4]:\n fivePlusNoDuplicate += 1\n\n usedTrans.append([one, two, three, four, five, six, seven])\n\n return fivePlus, fivePlusNoDuplicate, usedTrans, upperbound, len(solution), counter\n #~ f.write(\"\\n Used Transmitters: \"+ str(one)+\" \"+ str(two)+\" \"+ str(three)+\" \"+ str(four)+\" \"+ str(five)+\" \"+ str(six)+\" \"+ str(seven)+\"\\n Cost: \"+str(upperbound)+\"\\n Number of solutions: \"+str(len(solution))+\"\\n Iterations: \"+str(counter)+\"\\n\"+\"\\n\"+\"\\n\"+\"\\n\")\n\n #~ print \"transmitter frequecies:\", one, two, three, four, five, six, seven\n #~ print \"Solutions:\", solution\n #~ print \"Cost:\", upperbound\n #~ print \"Number of solutions:\", len(solution)\n #~ print \"Iterations:\", counter","def test_graphs_threshold_omst_global_cost_efficiency():\n # the function is optmized at the 3rd OMST.\n\n # Groundtruth\n expected = np.load(\"groundtruth/graphs_threshold/omst_gce.npy\")\n\n # Data\n graph = np.load(\"sample_data/graphs_threshold/graph.npy\")\n\n # Run\n _, CIJtree, _, _, _, _, _, _ = threshold_omst_global_cost_efficiency(\n graph, n_msts=None\n )\n\n # Test\n np.testing.assert_array_equal(expected, CIJtree)","def compute_district_weights(dist_changes, elec_sets, elec_set_dict, state_gdf, partition, prec_draws_outcomes,\\\n geo_id, primary_elecs, runoff_elecs, elec_match_dict, bases, outcomes,\\\n recency_W1, cand_race_dict, min_cand_weights_dict):\n \n black_pref_cands_prim_dist = pd.DataFrame(columns = dist_changes)\n black_pref_cands_prim_dist[\"Election Set\"] = elec_sets\n hisp_pref_cands_prim_dist = pd.DataFrame(columns = dist_changes)\n hisp_pref_cands_prim_dist[\"Election Set\"] = elec_sets\n #store runoff preferences for instances where minority-preferred candidate needs to switch between primary and runoff\n black_pref_cands_runoffs_dist = pd.DataFrame(columns = dist_changes)\n black_pref_cands_runoffs_dist[\"Election Set\"] = elec_sets\n hisp_pref_cands_runoffs_dist = pd.DataFrame(columns = dist_changes)\n hisp_pref_cands_runoffs_dist[\"Election Set\"] = elec_sets \n \n black_conf_W3_dist = np.empty((len(elec_sets),0), float)\n hisp_conf_W3_dist = np.empty((len(elec_sets),0), float)\n neither_conf_W3_dist = np.empty((len(elec_sets),0), float)\n \n for district in dist_changes: \n state_gdf[\"New Map\"] = state_gdf.index.map(dict(partition.assignment))\n dist_prec_list = list(state_gdf[state_gdf[\"New Map\"] == district][geo_id])\n dist_prec_indices = state_gdf.index[state_gdf[geo_id].isin(dist_prec_list)].tolist()\n district_support_all = cand_pref_outcome_sum(prec_draws_outcomes, dist_prec_indices, bases, outcomes)\n \n black_pref_prob_single_dist = []\n hisp_pref_prob_single_dist = []\n \n for elec_set in elec_sets: \n HCVAP_support_elec = district_support_all[('HCVAP', elec_set_dict[elec_set]['Primary'])]\n hisp_pref_cand_dist = max(HCVAP_support_elec.items(), key=operator.itemgetter(1))[0]\n hisp_pref_prob_dist = HCVAP_support_elec[hisp_pref_cand_dist]\n hisp_pref_prob_single_dist.append(hisp_pref_prob_dist) \n \n BCVAP_support_elec = district_support_all[('BCVAP', elec_set_dict[elec_set]['Primary'])]\n black_pref_cand_dist = max(BCVAP_support_elec.items(), key=operator.itemgetter(1))[0]\n black_pref_prob_dist = BCVAP_support_elec[black_pref_cand_dist]\n black_pref_prob_single_dist.append(black_pref_prob_dist)\n \n black_pref_cands_prim_dist.at[black_pref_cands_prim_dist[\"Election Set\"] == elec_set, district] = black_pref_cand_dist\n hisp_pref_cands_prim_dist.at[hisp_pref_cands_prim_dist[\"Election Set\"] == elec_set, district] = hisp_pref_cand_dist \n \n if 'Runoff' in elec_set_dict[elec_set].keys():\n HCVAP_support_elec = district_support_all[('HCVAP', elec_set_dict[elec_set]['Runoff'])]\n hisp_pref_cand_dist = max(HCVAP_support_elec.items(), key=operator.itemgetter(1))[0]\n hisp_pref_cands_runoffs_dist.at[hisp_pref_cands_runoffs_dist[\"Election Set\"] == elec_set, district] = hisp_pref_cand_dist\n \n BCVAP_support_elec = district_support_all[('BCVAP', elec_set_dict[elec_set]['Runoff'])]\n black_pref_cand_dist = max(BCVAP_support_elec.items(), key=operator.itemgetter(1))[0] \n black_pref_cands_runoffs_dist.at[black_pref_cands_runoffs_dist[\"Election Set\"] == elec_set, district] = black_pref_cand_dist\n \n black_pref_conf_single_dist = [prob_conf_conversion(x) for x in black_pref_prob_single_dist]\n black_conf_W3_dist = np.append(black_conf_W3_dist, np.array([black_pref_conf_single_dist]).transpose(), axis = 1) \n \n hisp_pref_conf_single_dist = [prob_conf_conversion(x) for x in hisp_pref_prob_single_dist]\n hisp_conf_W3_dist = np.append(hisp_conf_W3_dist, np.array([hisp_pref_conf_single_dist]).transpose(), axis = 1) \n \n neither_pref_conf_single_dist = [prob_conf_conversion(x*y) for x,y in zip(black_pref_prob_single_dist,hisp_pref_prob_single_dist)]\n neither_conf_W3_dist = np.append(neither_conf_W3_dist, np.array([neither_pref_conf_single_dist]).transpose(), axis = 1) \n \n #compute W2 (\"in-group\"-minority-preference weight) \n min_cand_black_W2_dist, min_cand_hisp_W2_dist, min_cand_neither_W2_dist = compute_W2(elec_sets, \\\n dist_changes, min_cand_weights_dict, black_pref_cands_prim_dist, hisp_pref_cands_prim_dist, cand_race_dict)\n ################################################################################ \n #compute final election weights per district\n recency_W1 = recency_W1.copy()[:, dist_changes]\n black_weight_dist = recency_W1*min_cand_black_W2_dist*black_conf_W3_dist\n hisp_weight_dist = recency_W1*min_cand_hisp_W2_dist*hisp_conf_W3_dist \n neither_weight_dist = recency_W1*min_cand_neither_W2_dist*neither_conf_W3_dist\n \n return black_weight_dist, hisp_weight_dist, neither_weight_dist, black_pref_cands_prim_dist, \\\n black_pref_cands_runoffs_dist, hisp_pref_cands_prim_dist, hisp_pref_cands_runoffs_dist","def test_local_efficiency_disconnected_graph(self):\n assert_equal(nx.local_efficiency(self.G1), 0)","def fit_score(self, solution):\r\n illegal_neighbours = 0\r\n legal_neighbours = 0\r\n for polygon in solution.genetic_units.values():\r\n for neighbour_id in polygon.neighbours_ids:\r\n if polygon.color is solution.genetic_units[neighbour_id].color:\r\n illegal_neighbours += 1\r\n else:\r\n legal_neighbours += 1\r\n if self.sorting_order is ScoresSortingOrder.ASCENDING:\r\n return illegal_neighbours\r\n else:\r\n return legal_neighbours","def _majority(data_set):\r\n pair = _count_parties(data_set)\r\n democrats = pair[0]\r\n republicans = pair[1]\r\n if democrats > republicans: return \"D\"\r\n if democrats < republicans: return \"R\"\r\n else: return None","def determine_measure_position(self):\n green_probs = []\n net_size = len(self.net)\n #Belief propagation:\n #Analyzes each position's probability of obtaining\n #green when measuring at a time t+1.\n for i in range(0, net_size):\n accum = 0\n for j in range(0, net_size):\n distance = self.__get_distance(i, j)\n if distance == 0: #Probability of measure green at distance 0 from 'i'.\n accum += self.net[i].value * self.ct[0][0]\n elif distance == 1: #Probability of measure green at distance 1 from 'i'.\n accum += self.net[i].value * self.ct[1][0]\n elif distance == 2: #Probability of measure green at distance 2 from 'i'.\n accum += self.net[i].value * self.ct[2][0]\n elif distance == 3: #Probability of measure green at distance 3 from 'i'.\n accum += self.net[i].value * self.ct[3][0]\n else: #Probability of measure green at a distance >= 4 from 'i'.\n accum += self.net[i].value * self.ct[4][0]\n green_probs.append(accum)\n #Returns the position in which the probability of\n #obtaining green when measuring is the highest.\n return self.net[np.argmax(green_probs)].id","def get_communities(num_of_neighbors, is_self_loops, relevant_period_groups, full_confusion_csv, classes_csv_file, priod_group_column, similarty_csv = ''):\n\n # generate class_names dict\n cnt = 0\n class_name_dict = {}\n with open(classes_csv_file, 'r') as f:\n reader = csv.reader(f)\n for row in reader:\n if cnt > 0:\n class_name_dict[int(row[8])] = row[1]\n cnt = cnt + 1\n\n\n full_conf = np.genfromtxt(full_confusion_csv, delimiter=',')\n relevant_conf = full_conf[:,:num_of_neighbors+1]\n flatten_conf = np.zeros((relevant_conf.shape[0]*num_of_neighbors,2), dtype=np.int32)\n if similarty_csv != '':\n similarity_mat = np.genfromtxt(similarty_csv, delimiter=',')\n similarity_conf_mat = np.zeros((200, 200), dtype=np.float32)\n print(similarity_mat.shape)\n\n\n row = 0\n for k in range(relevant_conf.shape[0]):\n for m in range(num_of_neighbors):\n flatten_conf[row, 0] = relevant_conf[k,0]\n flatten_conf[row,1] = relevant_conf[k,m+1]\n if similarty_csv != '':\n similarity_conf_mat[int(relevant_conf[k,0]), int(relevant_conf[k,m+1]) ] += similarity_mat[k, m]\n\n row = row + 1\n\n confusion_mat = confusion_matrix(flatten_conf[:,0], flatten_conf[:,1])\n if similarty_csv != '':\n confusion_mat = similarity_conf_mat\n\n confusion_mat = confusion_mat.astype('float') / confusion_mat.sum(axis=1)[:, np.newaxis]\n symmetric_confusion = (confusion_mat + np.transpose(confusion_mat)) / 2\n if not is_self_loops:\n np.fill_diagonal(symmetric_confusion, 0)\n\n # taking only the relevant classes\n if relevant_period_groups != -1:\n df = pd.read_csv(classes_csv_file)\n period_groups = df[priod_group_column]\n relevant_classes = []\n for group in relevant_period_groups:\n group_slice = df[period_groups == group]\n relevant_classes.extend(group_slice['id_period_sorted'].values)\n\n L = len(relevant_classes)\n relevant_confusion = np.zeros((L,L), dtype=np.float32)\n class_node_dict = {}\n for m,cls_i in enumerate(relevant_classes):\n class_node_dict[m] = cls_i\n for n,cls_j in enumerate(relevant_classes):\n relevant_confusion[m,n] = symmetric_confusion[cls_i,cls_j]\n else:\n relevant_confusion = symmetric_confusion\n\n G = nx.from_numpy_matrix(relevant_confusion)\n\n # find best communities based on modularity grade\n resolution_vec = np.linspace(0.0,2,50)\n mod_vec = np.zeros_like(resolution_vec)\n best_modularity = -1\n best_communities = -1\n best_res = -1\n for k in range(resolution_vec.size):\n partition = community.best_partition(G, weight='weight', resolution=resolution_vec[k])\n modularity = community.modularity(partition, G, weight='weight')\n mod_vec[k] = modularity\n if (modularity > best_modularity):\n best_modularity = modularity\n best_communities = partition\n best_res = resolution_vec[k]\n\n summary_str = 'best resolution: %.3f\\nbest modularity: %.3f\\nnumber of communities: %d' % (best_res,best_modularity,len(set(best_communities.values())))\n\n #plt.plot(resolution_vec,mod_vec)\n #plt.show()\n\n # generate community summary file\n count = 0\n strr = ''\n summary_file_name = 'community_summary.csv'\n for com in set(best_communities.values()):\n count += 1.\n list_nodes = [nodes for nodes in best_communities.keys() if best_communities[nodes] == com]\n strr += 'community,' + str(com) + '\\n'\n for nd in list_nodes:\n if relevant_period_groups == -1:\n strr += class_name_dict[nd] + ',id,' + str(nd) + '\\n'\n else:\n strr += class_name_dict[class_node_dict[nd]] + ',id,' + str(class_node_dict[nd]) + '\\n'\n strr += '\\n'\n with open(summary_file_name, \"w\") as text_file:\n text_file.write(strr)\n\n print(strr)\n # summary for map visualization tool\n strr = ''\n for k in range(relevant_confusion.shape[0]):\n comm = partition[k]\n comm_members = [nodes for nodes in partition.keys() if partition[nodes] == comm]\n if relevant_period_groups == -1:\n strr += 'id,' + str(k) + ',community,' + str(comm) + ',community_members,'\n else:\n strr += 'id,' + str(class_node_dict[k]) + ',community,' + str(comm) + ',community_members,'\n for member in comm_members:\n if relevant_period_groups == -1:\n strr += str(member) + ','\n else:\n strr += str(class_node_dict[member]) + ','\n strr += '\\n'\n with open('nodes_communities.csv', \"w\") as text_file:\n text_file.write(strr)\n\n\n\n return summary_str","def get_rank(cutoff: dict, coverage: float, quality: float, length: int, contigs: int, genome_size: int, is_paired: bool) -> list:\n rank = None\n reason = []\n coverage = float(f'{float(coverage):.2f}')\n quality = float(f'{float(quality):.2f}')\n length = round(float(f'{float(length):.2f}'))\n contigs = int(contigs)\n genome_size = int(genome_size)\n gold = cutoff['gold']\n silver = cutoff['silver']\n bronze = cutoff['bronze']\n\n if coverage >= gold['coverage'] and quality >= gold['quality'] and length >= gold['length'] and contigs <= gold['contigs'] and is_paired:\n reason.append('passed all cutoffs')\n rank = 'gold'\n elif coverage >= silver['coverage'] and quality >= silver['quality'] and length >= silver['length'] and contigs <= silver['contigs'] and is_paired:\n if coverage < gold['coverage']:\n reason.append(f\"Low coverage ({coverage:.2f}x, expect >= {gold['coverage']}x)\")\n if quality < gold['quality']:\n reason.append(f\"Poor read quality (Q{quality:.2f}, expect >= Q{gold['quality']})\")\n if length < gold['length']:\n reason.append(f\"Short read length ({length}bp, expect >= {gold['length']} bp)\")\n if contigs > gold['contigs']:\n reason.append(f\"Too many contigs ({contigs}, expect <= {gold['contigs']})\")\n rank = 'silver'\n elif coverage >= bronze['coverage'] and quality >= bronze['quality'] and length >= bronze['length'] and contigs <= bronze['contigs']:\n if coverage < silver['coverage']:\n reason.append(f\"Low coverage ({coverage:.2f}x, expect >= {silver['coverage']}x)\")\n if quality < silver['quality']:\n reason.append(f\"Poor read quality (Q{quality:.2f}, expect >= Q{silver['quality']})\")\n if length < silver['length']:\n reason.append(f\"Short read length ({length}bp, expect >= {silver['length']} bp)\")\n if contigs > silver['contigs']:\n reason.append(f\"Too many contigs ({contigs}, expect <= {silver['contigs']})\")\n if not is_paired:\n reason.append(f\"Single-end reads\")\n rank = 'bronze'\n\n if not rank:\n rank = 'exclude'\n\n if coverage < bronze['coverage']:\n reason.append(f\"Low coverage ({coverage:.2f}x, expect >= {bronze['coverage']}x)\")\n if quality < bronze['quality']:\n reason.append(f\"Poor read quality (Q{quality:.2f}, expect >= Q{bronze['quality']})\")\n if length < bronze['length']:\n reason.append(f\"Short read length ({length:.2f}bp, expect >= {bronze['length']} bp)\")\n if contigs > bronze['contigs']:\n reason.append(f\"Too many contigs ({contigs}, expect <= {bronze['contigs']})\")\n\n if cutoff['min-assembled-size']:\n if genome_size < cutoff['min-assembled-size']:\n reason.append(f\"Assembled size is too small ({genome_size} bp, expect <= {cutoff['min-assembled-size']})\")\n\n if cutoff['max-assembled-size']:\n if genome_size < cutoff['max-assembled-size']:\n reason.append(f\"Assembled size is too large ({genome_size} bp, expect <= {cutoff['max-assembled-size']})\")\n\n reason = \";\".join(sorted(reason))\n return [rank, reason]","def check_all_nodes_covered(G, solution_set):\n \n # List of nodes\n nodes_in_graph = list(G.nodes())\n \n # Nodes in solution_set\n edges_in_solution_set = [x for l in solution_set for x in l]\n nodes_in_solution_set = list(set(itertools.chain.from_iterable(edges_in_solution_set)))\n \n # Check for completeness\n for node in nodes_in_graph:\n if node not in nodes_in_solution_set:\n return False, [node]\n \n return True, []","def calc_cohesion( g, sg0, sg1, max_csize ) :\n score = 0.0\n n0 = len( sg0 )\n n1 = len( sg1 )\n if (n0 + n1 <= max_csize) :\n boundary_edges = networkx.edge_boundary( g, sg0, sg1 )\n for e in boundary_edges :\n score += g[e[0]][e[1]][\"similarity\"]\n return score / max( n0, n1 )","def most_discriminating( features_df, labels_df, top=5):\n \n columns = features_df.shape[1]\n labels_df = labels_df[['file', 'candy_id']].set_index('file')\n qualities = np.zeros(columns)\n \n _left = 0\n _right = 1\n\n _c = 0\n _h = 1\n\n # globals\n cases = float(labels_df['candy_id'].count()) # total cases\n\n p_c_A = (labels_df['candy_id'] == 0).sum() / cases\n p_h_A = 1.0 - p_c_A\n\n\n for feature in range(columns):\n\n branch_cases = np.zeros(2) # total on each branch\n pi = np.zeros(2) # proportion on each branch\n\n split = np.array([\n #c, h\n [0, 0], #left\n [0, 0] #right\n ])\n\n for index, value in features_df[feature].iteritems():\n split[value][labels_df.loc[index][0]] += 1\n\n branch_cases[_left] = split[_left].sum()\n branch_cases[_right] = split[_right].sum()\n \n if branch_cases[_left] == 0.0 or branch_cases[_right] == 0.0:\n qualities[feature] = 0\n continue\n \n pi[_left] = branch_cases[_left] / cases\n pi[_right] = branch_cases[_right] / cases\n\n p_c_B = split[_left][_c] / branch_cases[_left]\n p_h_B = split[_left][_h] / branch_cases[_left]\n\n p_c_C = split[_right][_c] / branch_cases[_right]\n p_h_C = split[_right][_h] / branch_cases[_right]\n\n gini_tree = 1.0 - (math.pow(p_c_A, 2) + math.pow(p_h_A, 2))\n\n gini_left = 1.0 - (math.pow(p_c_B, 2) + math.pow(p_h_B, 2))\n gini_right = 1.0 - (math.pow(p_c_C, 2) + math.pow(p_h_C, 2))\n\n quality = gini_tree - pi[_left] * gini_left - pi[_right] * gini_right\n\n qualities[feature] = quality\n return list(reversed(qualities.argsort()))[:top]","def test_edges_and_weights():\n edges, weights, state_value = edges_weights_specified_state(\n PROBABILITYMATRIX,\n MARKET,\n SNULL)\n assert len(edges) == len(weights) == (len(state_value)**2)","def test_efficiency_disconnected_nodes(self):\n assert_equal(nx.efficiency(self.G1, 1, 2), 0)","def matching_score(self,set1, set2):\n set_set1=set(set1)\n set_set2=set(set2)\n '''print(\" set_set12\")\n print(set_set1)\n print(set_set2)'''\n return len(set_set1.intersection(set_set2)) ** 2 / (float(len(set1)) * len(set2))\n #return len(set_set1.intersection(set_set2)) / len(set_set1.union(set_set2))","def SA(targetMDG):\n hill_climbers = []\n for i in range(NUM_Population):\n hill_climbers.append(SimulatedAnnealing(targetMDG))\n\n completed_climbers = []\n completed_max_climbers = []\n\n # k: int, number of neighbors to be considered\n k = 20\n i = 0\n not_increased = 0\n max_score = 0\n\n while True:\n for climber in hill_climbers[:]:\n result = climber.climb_with_annealing(k, i)\n if not result:\n completed_climbers.append(climber)\n hill_climbers.remove(climber)\n max_completed_climber = SimulatedAnnealing(targetMDG)\n max_completed_climber.result = climber.max_result\n max_completed_climber.update_score()\n completed_max_climbers.append(max_completed_climber)\n\n total_climbers = hill_climbers + completed_climbers + completed_max_climbers\n total_climbers.sort()\n print(\"Iteration \", i, \": \", total_climbers[-1].score)\n\n if total_climbers[-1].score - max_score != 0:\n not_increased = 0\n else:\n not_increased += 1\n\n if len(hill_climbers) == 0 or not_increased == 10:\n break\n i += 1\n max_score = total_climbers[-1].score\n\n total_climbers = hill_climbers + completed_climbers + completed_max_climbers\n total_climbers.sort()\n\n max_climber = total_climbers[-1]\n\n print(\"TurboMQ = \", max_climber.score)\n for c in max_climber.result: # print all clusters which are not singleton\n if 1 != len(c.get_nodes()):\n print(c.get_nodes())\n\n return max_climber.result","def evaluation(deploymentID, start_time,\n end_time, sites, validation, manOrLik):\n \n estScoreBound = 5\n falsePositive_dep = 0\n falseNegative_dep = 0\n truePositive_dep = 0\n trueNegative_dep = 0\n\n db_con = MySQLdb.connect(user=\"root\", db=\"qraat\")\n for i in sites:\n truePositive = 0\n trueNegative = 0\n falsePositive = 0\n falseNegative = 0\n \n cur = db_con.cursor()\n cur.execute(\"\"\"SELECT isPulse, band3, band10, frequency,\n ec, tnp, edsp, fdsp, edsnr, fdsnr\n FROM est INNER JOIN est_class%s\n ON ID = est_class%s.estID\n INNER JOIN estscore2\n ON ID = estscore2.estID\n WHERE timestamp > %s\n AND timestamp < %s\n AND deploymentID = %s\n AND siteID = %s\n AND setNum = %s;\n \"\"\"%(manOrLik, manOrLik, start_time, end_time,\n deploymentID, i, validation))\n for row in cur.fetchall():\n estData = {'band3':row[1], 'band10':row[2],\n 'frequency':row[3], 'ec':row[4], 'tnp':row[5],\n 'edsp':row[6], 'fdsp':row[7],\n 'edsnr':row[8], 'fdsnr':row[9]}\n \n #Classify data\n isPulse = modifiedBC(deploymentID, i, start_time,\n validation, estData, manOrLik)\n\n #Determine whether the classification results are correct or not\n if (row[0] == 1):\n if (isPulse == 1):\n truePositive += 1\n else:\n falseNegative += 1\n else:\n if (isPulse == 1):\n falsePositive += 1\n else:\n trueNegative += 1\n \n falsePositive_dep += falsePositive\n falseNegative_dep += falseNegative\n truePositive_dep += truePositive\n trueNegative_dep += trueNegative\n return [truePositive_dep, trueNegative_dep,\n falsePositive_dep, falseNegative_dep]","def find_non_neighbors_with_most_info(participant_data,\n true_distro_by_round,\n network_topology_name,\n additional_names_count,\n divergence_type=\"JS\",\n memory_length=5,\n graph=False):\n\n participant_differences = {}\n\n net = nb.net(network_topology_name)\n\n # We start by going through each participant\n for participant, data in participant_data.items():\n # and we're going to calculate the divergences for combo of additional names\n\n # First we look at the overall divergence without unstructured names\n div_no_unstructured_by_round = []\n\n distro_by_round_no_unstructured = impose_limited_memory(data[\"distro_by_round_no_unstructured\"],\n memory_length=memory_length)\n for game_round in range(1,26):\n\n # a new list of names needs to be truncated to induce some memory\n seen_distro_with_no_unstructured, true_distro = create_continuity_and_probabilities(\n distro_by_round_no_unstructured[game_round],\n true_distro_by_round[game_round])\n\n # KL divergence between real and distro with additional names\n if divergence_type == \"JS\":\n div_no_unstructured_by_round.append(JS(seen_distro_with_no_unstructured, true_distro))\n else:\n div_no_unstructured_by_round.append(KL(seen_distro_with_no_unstructured, true_distro))\n\n # Then we calculate the divergence for the real rounds with unstructured\n\n div_with_unstructured_by_round = []\n\n distro_by_round_unstructured = impose_limited_memory(data[\"distro_by_round_unstructured\"],\n memory_length=memory_length)\n for game_round in range(1,26):\n\n # a new list of names needs to be truncated to induce some memory\n seen_distro_with_unstructured, true_distro_2 = create_continuity_and_probabilities(\n distro_by_round_unstructured[game_round],\n true_distro_by_round[game_round])\n\n # KL divergence between real and distro with additional names\n if divergence_type == \"JS\":\n div_with_unstructured_by_round.append(JS(seen_distro_with_unstructured, true_distro_2))\n else:\n div_with_unstructured_by_round.append(KL(seen_distro_with_unstructured, true_distro_2))\n\n # We'll select the non-neighbors with the most information (the smallest diff in KL) so\n # we'll need to track the smallest divergences\n smallest_divergence = None\n\n # We get all the non-neighbors of the ego node\n non_neighbors = net.get_non_alters(participant)\n\n # We get all possible combinations of non-neighbors\n non_neighbor_combinations = combinations(non_neighbors,additional_names_count)\n\n\n for combo in non_neighbor_combinations:\n\n names_to_add_by_round = defaultdict(list)\n for not_neighbor in combo:\n # We get the names played by the participant and append it to lists of names for\n # each round\n for round, name in enumerate(participant_data[not_neighbor][\"names_played\"]):\n names_to_add_by_round[round].append(name)\n\n # We go through round by round and add in the newly visible names\n simulated_distro_by_round = {}\n\n # now we add to distribution with out unstructured\n for game_round in range(1,26):\n no_unstructured = list(data[\"distro_by_round_no_unstructured\"][game_round])\n no_unstructured.extend(names_to_add_by_round[game_round])\n\n simulated_distro_by_round[game_round] = no_unstructured\n\n # That new list of names needs to be truncated to induce some memory\n distro_by_round_with_non_neighbors = impose_limited_memory(simulated_distro_by_round,\n memory_length=memory_length)\n\n divergence_by_round = []\n for game_round in range(1,26):\n\n seen_distro_non_neighbors, true_distro = create_continuity_and_probabilities(\n distro_by_round_with_non_neighbors[game_round],\n true_distro_by_round[game_round])\n\n # Then we calculate the divergence from distro with weakest link to true distro\n if divergence_type == \"JS\":\n div_with_non_neighbors = JS(seen_distro_non_neighbors, true_distro)\n else:\n div_with_non_neighbors = KL(seen_distro_non_neighbors, true_distro)\n divergence_by_round.append(div_with_non_neighbors)\n\n\n # the sum is the area under the curve, or the total divergences for the whole run.\n total_diff_in_divergences = sum(divergence_by_round)\n\n if smallest_divergence != None:\n if total_diff_in_divergences < sum(smallest_divergence):\n smallest_divergence = divergence_by_round\n alters_with_smallest_divergence = combo\n else:\n smallest_divergence = divergence_by_round\n alters_with_smallest_divergence = combo\n\n # now that we have the smallest divergence to the true distro from simulated weakest\n # link distro, we compare it to the divergence to the true distro from the real additional\n # name distro. A positive difference as calculated means the additiona name version carries # more information (because it is closer to the true)\n\n game_diffs = [i-j for i, j in zip(smallest_divergence,div_with_unstructured_by_round)]\n\n divergence_ratio = [1 - actual/total if total !=0 else 0 for actual, total in zip(div_with_unstructured_by_round, div_no_unstructured_by_round)]\n\n #print(\"comparison:\", divergence_by_round)\n #print(\"base_diff:\", div_no_unstructured_by_round)\n #print(\"ratio:\", divergence_ratio)\n\n participant_differences[participant] = (game_diffs, alters_with_smallest_divergence, div_no_unstructured_by_round, divergence_ratio)\n\n return participant_differences","def query_size_of_adjacent_nodes(self, node_curie, source_type, adjacent_type, kp=\"infores:rtx-kg2\", rel_type=None):\n\n res = None\n source_type = ComputeFTEST.convert_string_to_snake_case(source_type.replace('biolink:',''))\n source_type = ComputeFTEST.convert_string_biolinkformat(source_type)\n adjacent_type = ComputeFTEST.convert_string_to_snake_case(adjacent_type.replace('biolink:',''))\n adjacent_type = ComputeFTEST.convert_string_biolinkformat(adjacent_type)\n\n if rel_type is None:\n normalized_nodes = self.nodesynonymizer.get_canonical_curies(node_curie)\n failure_nodes = list()\n mapping = {node:normalized_nodes[node]['preferred_curie'] for node in normalized_nodes if normalized_nodes[node] is not None}\n failure_nodes += list(normalized_nodes.keys() - mapping.keys())\n query_nodes = list(set(mapping.values()))\n query_nodes = [curie_id.replace(\"'\", \"''\") if \"'\" in curie_id else curie_id for curie_id in query_nodes]\n # special_curie_ids = [curie_id for curie_id in query_nodes if \"'\" in curie_id]\n\n # Get connected to kg2c sqlite\n connection = sqlite3.connect(self.sqlite_file_path)\n cursor = connection.cursor()\n\n # Extract the neighbor count data\n node_keys_str = \"','\".join(query_nodes) # SQL wants ('node1', 'node2') format for string lists\n sql_query = f\"SELECT N.id, N.neighbor_counts \" \\\n f\"FROM neighbors AS N \" \\\n f\"WHERE N.id IN ('{node_keys_str}')\"\n cursor.execute(sql_query)\n rows = cursor.fetchall()\n rows = [curie_id.replace(\"\\'\",\"'\").replace(\"''\", \"'\") if \"'\" in curie_id else curie_id for curie_id in rows]\n connection.close()\n\n # Load the counts into a dictionary\n neighbor_counts_dict = {row[0]:eval(row[1]) for row in rows}\n\n res_dict = {node:neighbor_counts_dict[mapping[node]].get(adjacent_type) for node in mapping if mapping[node] in neighbor_counts_dict and neighbor_counts_dict[mapping[node]].get(adjacent_type) is not None}\n failure_nodes += list(mapping.keys() - res_dict.keys())\n\n if len(failure_nodes) != 0:\n return (res_dict, failure_nodes)\n else:\n return (res_dict, [])\n\n else:\n # if kp == 'ARAX/KG1':\n # self.response.warning(f\"Since the edge type '{rel_type}' is from KG1, we still use the DSL expand(kg=ARAX/KG1) to query neighbor count. However, the total node count is based on KG2c from 'nodesynonymizer.get_total_entity_count'. So the FET result might not be accurate.\")\n\n # construct the instance of ARAXQuery class\n araxq = ARAXQuery()\n\n # check if node_curie is a str or a list\n if type(node_curie) is str:\n query_node_curie = node_curie\n elif type(node_curie) is list:\n node_id_list_str = \"[\"\n for index in range(len(node_curie)):\n node = node_curie[index]\n if index + 1 == len(node_curie):\n node_id_list_str = node_id_list_str + str(node) + \"]\"\n else:\n node_id_list_str = node_id_list_str + str(node) + \",\"\n\n query_node_curie = node_id_list_str\n else:\n self.response.error(\"The 'node_curie' argument of 'query_size_of_adjacent_nodes' method within FET only accepts str or list\")\n return res\n\n # call the method of ARAXQuery class to query adjacent node\n query = {\"operations\": {\"actions\": [\n \"create_message\",\n f\"add_qnode(ids={query_node_curie}, categories={source_type}, key=FET_n00)\",\n f\"add_qnode(categories={adjacent_type}, key=FET_n01)\",\n f\"add_qedge(subject=FET_n00, object=FET_n01, key=FET_e00, predicates={rel_type})\",\n f\"expand(edge_key=FET_e00,kp={kp})\",\n #\"resultify()\",\n \"return(message=true, store=false)\"\n ]}}\n\n try:\n result = araxq.query(query)\n if result.status != 'OK':\n self.response.error(f\"Fail to query adjacent nodes from infores:rtx-kg2 for {node_curie}\")\n return res\n else:\n res_dict = dict()\n message = araxq.response.envelope.message\n if type(node_curie) is str:\n tmplist = set([edge_key for edge_key in message.knowledge_graph.edges if message.knowledge_graph.edges[edge_key].subject == node_curie or message.knowledge_graph.edges[edge_key].object == node_curie]) ## edge has no direction\n if len(tmplist) == 0:\n self.response.warning(f\"Fail to query adjacent nodes from {kp} for {node_curie} in FET probably because expander ignores node type. For more details, please see issue897.\")\n return (res_dict,[node_curie])\n res_dict[node_curie] = len(tmplist)\n return (res_dict,[])\n else:\n check_empty = False\n failure_nodes = list()\n for node in node_curie:\n tmplist = set([edge_key for edge_key in message.knowledge_graph.edges if message.knowledge_graph.edges[edge_key].subject == node or message.knowledge_graph.edges[edge_key].object == node]) ## edge has no direction\n if len(tmplist) == 0:\n self.response.warning(f\"Fail to query adjacent nodes from {kp} for {node} in FET probably because expander ignores node type. For more details, please see issue897.\")\n failure_nodes.append(node)\n check_empty = True\n continue\n res_dict[node] = len(tmplist)\n\n if check_empty is True:\n return (res_dict,failure_nodes)\n else:\n return (res_dict,[])\n except:\n tb = traceback.format_exc()\n error_type, error, _ = sys.exc_info()\n self.response.error(tb, error_code=error_type.__name__)\n self.response.error(f\"Something went wrong with querying adjacent nodes from {kp} for {node_curie}\")\n return res","def narrative_consistency(self, metric='betweenness', nodes=None): # measures centrality\n if metric == 'betweenness':\n vals = nx.betweenness_centrality(self.graph)\n elif metric == 'degree':\n vals = {n[0]: n[1] for n in self.graph.degree()}\n elif metric == 'closeness':\n vals = nx.closeness_centrality(self.graph)\n else:\n vals_b = nx.betweenness_centrality(self.graph)\n vals_d = {n[0]: n[1] for n in self.graph.degree()}\n vals_c = nx.closeness_centrality(self.graph)\n\n min_ = min(vals_b.values())\n delta = max(vals_b.values()) - min_\n vals_b = {k: (v - min_) / delta for k, v in vals_b.items()}\n\n min_ = min(vals_d.values())\n delta = max(vals_d.values()) - min_\n vals_d = {k: (v - min_) / delta for k, v in vals_d.items()}\n\n min_ = min(vals_c.values())\n delta = max(vals_c.values()) - min_\n vals_c = {k: (v - min_) / delta for k, v in vals_c.items()}\n\n vals = {k: (v + vals_b.get(k, 0) + vals_c.get(k, 0)) / 3 for k, v in vals_d.items()}\n\n if nodes is None:\n return sum(-math.log(v) for v in vals.values() if v > 0) / self.graph.number_of_nodes()\n\n return sum(-math.log(v) for k, v in vals.items() if v > 0 and k in nodes) / len(nodes)","def test_net_score():\n player = sequence_threshold.Player()\n\n player.cards = SortedSet()\n assert player.get_net_score(1) == 1\n assert player.get_net_score(6) == 6\n assert player.get_net_score(35) == 35\n\n player.cards = SortedSet([2, 7, 36])\n # Taking a card one lower than a card you have decreases your score by one.\n assert player.get_net_score(1) == -1\n assert player.get_net_score(6) == -1\n assert player.get_net_score(35) == -1\n # Taking a card one higher than a card you have does not change your score.\n assert player.get_net_score(3) == 0\n assert player.get_net_score(8) == 0\n assert player.get_net_score(37) == 0\n # You can never take a card you already have. This should cause an error rather than return 0.\n with pytest.raises(Exception):\n player.get_net_score(2)\n with pytest.raises(Exception):\n player.get_net_score(7)\n with pytest.raises(Exception):\n player.get_net_score(36)\n\n player.cards = SortedSet([2, 4, 27, 29])\n # Completing these sequences with the in-between card decreases your score by the higher card amount.\n assert player.get_net_score(3) == -4\n assert player.get_net_score(28) == -29","def nodes_ratio(data: Data, position_against_soma=None, node_types=None, filter_layers=None):\n soma = data.morphology.get_soma()\n if position_against_soma=='above':\n criterion=lambda nod:((nod['type'] in node_types) if node_types is not None else True) and nod['y']<soma['y']\n elif position_against_soma=='below':\n criterion=lambda nod:((nod['type'] in node_types) if node_types is not None else True) and nod['y']>soma['y']\n else:\n criterion=lambda nod:nod['type'] in node_types if node_types is not None else True\n num_type_nodes = data.morphology.get_node_by_types(node_types)\n if filter_layers and isinstance(filter_layers, list):\n result = {}\n for layer in filter_layers:\n filter_layer_depth = data.reference_layer_depths.get(layer)\n y_min, y_max, is_scale = filter_layer_depth.pia_side, filter_layer_depth.wm_side, filter_layer_depth.scale\n if is_scale:\n selected_nodes = data.morphology.filter_nodes(lambda nod: criterion(nod) and y_min<nod['y']<y_max)\n else:\n selected_nodes = data.morphology.filter_nodes(lambda nod: criterion(nod) and nod['y']>y_min)\n result[layer]=len(selected_nodes)/len(num_type_nodes)\n return result\n else:\n selected_nodes = data.morphology.filter_nodes(criterion)\n return len(selected_nodes)/len(num_type_nodes)","def minimum_spanning_arborescence(sol):","def do_conflict(g, source, prob):\n\n count1, count2, count3 = 0, 0, 0\n\n g.node[source][\"m\"] = source\n for n in g.neighbors_iter(source):\n g.node[n][\"m\"] = source\n\n peer = random.choice(g.neighbors(source))\n for n in g.neighbors_iter(peer):\n if \"m\" not in g.node[n]:\n g.node[n][\"m\"] = peer\n count1 += 1\n\n for n in g.neighbors_iter(peer):\n if g.node[n][\"m\"] == source:\n result = resolve(g, n, source, peer, prob)\n g.node[n][\"m\"] = result\n if result == peer:\n count2 += 1\n else:\n count3 += 1\n\n clear_mappings(g, source)\n clear_mappings(g, peer)\n\n share = float(count1)/len(g.neighbors(peer))\n wins = float(count2)/float(count2+count3)\n\n return share, wins","def protesting_communities(partition, active_nodes):\n communities = defaultdict(int)\n for node in active_nodes:\n communities[partition[node]] += 1\n return communities","def test_create_problems(self):\n # runs 10 attempts to generate satisfiable problems\n sat, unsat = 0, 0\n for _ in range(10):\n # creates 3-CNFs with 20 vars & 90 clauses (phase transition)\n clauses = create_sat_problem(False, 'randkcnf', 3, 20, 91)\n with Solver(name='Glucose3', bootstrap_with=clauses) as solver:\n if solver.solve():\n sat += 1\n else:\n unsat += 1\n self.assertTrue(sat > 0)\n self.assertTrue(unsat > 0)","def test_compare_genomes_2(self):\n self.pmr_gnm.annotation_status = \"final\"\n self.pmr_gnm.name = \"Trixie\"\n import_genome.compare_genomes(self.genome_pair, self.eval_flags)\n count = count_status(self.genome_pair, \"error\", \"warning\")\n with self.subTest():\n self.assertEqual(len(self.genome_pair.evaluations), 13)\n with self.subTest():\n self.assertEqual(count, 0)","def respect_matching(self, network):\n\n # Iterate over the connected components of the network\n\n for component in nx.connected_component_subgraphs(network):\n\n # If the component has only two nodes it is respected by default\n\n if component.number_of_nodes() < 3:\n continue\n\n # Partition the nodes into biparite sets\n\n left, right = nx.bipartite.sets(component)\n\n # As a convention, the left side is the one with fewer vertices.\n # Swap left and right if right has fewer vertices.\n\n if len(left) > len(right):\n left, right = right, left\n\n # The way we encode the constraint that a maximum cardinality\n # matching of the symmetrization graph be respected is to force\n # one edge incident to each vertex on the left side of each\n # component be activated, while at most one edge incident to each\n # vertex of the right side be activated. This will activate a\n # maximum cardinality matching of the graph IFF the size of the\n # maximum cardinality matching of each component is the number of\n # vertices in the smaller biparite set of that component. Here we\n # run a check to verify that this is the case.\n\n mcm_size = len(nx.max_weight_matching(component,\n maxcardinality=True))\n\n assert mcm_size == len(left)\n\n # Iterate over vertices on the smaller biparite set and force\n # exactly one of their incident edges to be activated\n\n for l in left:\n table = self.activation_variables[l]\n lits = [table[r] for r in table]\n self.at_most_one(lits)\n self.add_clause(lits)\n\n # Iterate over vertices on the larger bipartite set and force\n # at most one of their incident edges to be activated\n\n for r in right:\n table = self.activation_variables[r]\n lits = [table[l] for l in table]\n self.at_most_one(lits)","def GraphBetter(metric_set1_sorted, metric_set2_sorted, base_is_set_2):\n total_bitrate_difference_ratio = 0.0\n count = 0\n for bitrate, metric in metric_set1_sorted:\n for i in range(len(metric_set2_sorted) - 1):\n s2_bitrate_0, s2_metric_0 = metric_set2_sorted[i]\n s2_bitrate_1, s2_metric_1 = metric_set2_sorted[i + 1]\n # We have a point on either side of our metric range.\n if metric > s2_metric_0 and metric <= s2_metric_1:\n\n # Calculate a slope.\n if s2_metric_1 - s2_metric_0 != 0:\n metric_slope = ((s2_bitrate_1 - s2_bitrate_0) /\n (s2_metric_1 - s2_metric_0))\n else:\n metric_slope = 0\n\n estimated_s2_bitrate = (s2_bitrate_0 + (metric - s2_metric_0) *\n metric_slope)\n\n # Calculate percentage difference as given by base.\n if base_is_set_2 == 0:\n bitrate_difference_ratio = ((bitrate - estimated_s2_bitrate) /\n bitrate)\n else:\n bitrate_difference_ratio = ((bitrate - estimated_s2_bitrate) /\n estimated_s2_bitrate)\n\n total_bitrate_difference_ratio += bitrate_difference_ratio\n count += 1\n break\n\n # Calculate the average improvement between graphs.\n if count != 0:\n avg = total_bitrate_difference_ratio / count\n\n else:\n avg = 0.0\n\n return avg","def get_network_score(self):\n for key in self.nodes:\n node = self.nodes[key]\n if node.is_dc:\n neighbors_total = 0\n for neighbor in node.neighbors:\n weight = (neighbor.weight / node.neighbors_magnitude)\n neighbors_total += weight * neighbor.individual_score\n\n neighbor_score = neighbors_total / len(node.neighbors)\n relative_score = (node.individual_score + neighbor_score) / 2\n node.relative_score = relative_score\n\n total = 0\n for key in self.nodes:\n node = self.nodes[key]\n total += node.relative_score\n score = total / len(self.nodes)\n\n return score","def create_network(self, community_detection, wt_steps, n_clust, network_from, neighbors, top):\n \n if network_from == 'top_n':\n sort_by_scores = []\n\n for pair, score in scores_update.items():\n sort_by_scores.append([pair[0], pair[1], score[2]])\n top_n = sorted(sort_by_scores, reverse=False, key=lambda x: x[2])[:top]\n\n # Convert from distance to similarity for edge\n for score in top_n: \n c = 1/(1 + score[2])\n score[2] = c\n\n flat = [tuple(pair) for pair in top_n]\n\n elif network_from == 'knn': \n flat = []\n projection_knn = nearest_neighbors(neighbors=neighbors)\n\n for projection, knn in projection_knn.items():\n for n in knn:\n flat.append((projection, n[0], abs(n[3]))) # p1, p2, score\n\n clusters = {}\n g = Graph.TupleList(flat, weights=True)\n\n if community_detection == 'walktrap':\n try:\n wt = Graph.community_walktrap(g, weights='weight', steps=wt_steps)\n cluster_dendrogram = wt.as_clustering(n_clust)\n except:\n self.show_cluster_fail()\n elif community_detection == 'betweenness':\n try:\n ebs = Graph.community_edge_betweenness(g, weights='weight', directed=True)\n cluster_dendrogram = ebs.as_clustering(n_clust)\n except:\n self.show_cluster_fail()\n\n for community, projection in enumerate(cluster_dendrogram.subgraphs()):\n clusters[community] = projection.vs['name']\n\n #convert node IDs back to ints\n for cluster, nodes in clusters.items():\n clusters[cluster] = sorted([int(node) for node in nodes])\n \n remove_outliers(clusters)\n\n clustered = []\n for cluster, nodes in clusters.items():\n for n in nodes:\n clustered.append(n)\n\n clusters['singles'] = [] # Add singles to clusters if not in top n scores\n clusters['removed'] = []\n \n for node in projection_2D:\n if node not in clustered and node not in drop:\n clusters['singles'].append(node)\n elif node in drop:\n clusters['removed'].append(node)\n \n G = nx.Graph()\n\n for pair in flat:\n G.add_edge(int(pair[0]), int(pair[1]), weight=pair[2])\n\n #if you want to see directionality in the networkx plot\n #G = nx.MultiDiGraph(G)\n\n #adds singles if not in top n scores\n for node_key in projection_2D:\n if node_key not in G.nodes:\n G.add_node(node_key)\n\n return flat, clusters, G","def all_best_nr(potential_coverage, all_coverage, covered):\n ## get redundancy count\n potential_redundancy = {grna_seq: len(set(hit.target_id for hit in hits\n if hit.target_id in covered))\n for grna_seq, hits in all_coverage.items()\n if grna_seq in potential_coverage}\n best_redundancy = min(potential_redundancy.values())\n return {grna_seq: potential_coverage[grna_seq]\n for grna_seq, redundancy in potential_redundancy.items()\n if redundancy == best_redundancy}","def hypergraph_bipartiteness(hypergraph, vertex_set_l, vertex_set_r):\n hyplogging.logger.debug(\"Computing hypergraph bipartiteness.\")\n hyplogging.logger.debug(f\" Left set size: {len(vertex_set_l)}\")\n hyplogging.logger.debug(f\" Right set size: {len(vertex_set_r)}\")\n vol_s = hypergraph_volume(hypergraph, vertex_set_l + vertex_set_r)\n\n vertex_set_l = set(vertex_set_l)\n vertex_set_r = set(vertex_set_r)\n\n w_l_not_l = 0\n w_r_not_r = 0\n w_l_r = 0\n w_r_l = 0\n for edge in hypergraph.edges:\n edge_set = set(edge)\n edge_l_intersection = len(vertex_set_l.intersection(edge_set))\n edge_r_intersection = len(vertex_set_r.intersection(edge_set))\n edge_entirely_inside_l = edge_l_intersection == len(edge_set)\n edge_entirely_inside_r = edge_r_intersection == len(edge_set)\n\n if edge_entirely_inside_l:\n w_l_not_l += 1\n if edge_entirely_inside_r:\n w_r_not_r += 1\n if edge_l_intersection > 0 and not edge_r_intersection > 0:\n w_l_r += 1\n if edge_r_intersection > 0 and not edge_l_intersection > 0:\n w_r_l += 1\n\n # Compute the bipartiteness\n bipart = (w_l_not_l + w_r_not_r + w_l_r + w_r_l) / vol_s\n hyplogging.logger.debug(f\"Computed bipartiteness: {bipart}\")\n return bipart","def testSpeciesRichness(self):\n c1 = CoalescenceTree(os.path.join(\"output\", \"data_49_1.db\"))\n c2 = CoalescenceTree(os.path.join(\"output\", \"data_49_6.db\"))\n c3 = CoalescenceTree(os.path.join(\"output\", \"data_49_10.db\"))\n self.assertEqual(451, c1.get_species_richness(1))\n self.assertEqual(2623, c1.get_species_richness(2))\n self.assertEqual(6957, c1.get_species_richness(3))\n self.assertEqual(9486, c1.get_species_richness(4))\n self.assertEqual(153, c1.get_species_richness(5))\n self.assertEqual(332, c1.get_species_richness(6))\n self.assertEqual(438, c1.get_species_richness(7))\n self.assertEqual(470, c1.get_species_richness(8))\n self.assertEqual(159, c1.get_species_richness(9))\n self.assertEqual(314, c1.get_species_richness(10))\n self.assertEqual(424, c1.get_species_richness(11))\n self.assertEqual(459, c1.get_species_richness(12))\n self.assertEqual(167, c2.get_species_richness(5))\n self.assertEqual(334, c2.get_species_richness(6))\n self.assertEqual(413, c2.get_species_richness(7))\n self.assertEqual(470, c2.get_species_richness(8))\n self.assertEqual(164, c2.get_species_richness(9))\n self.assertEqual(338, c2.get_species_richness(10))\n self.assertEqual(424, c2.get_species_richness(11))\n self.assertEqual(464, c2.get_species_richness(12))\n self.assertEqual(163, c3.get_species_richness(5))\n self.assertEqual(318, c3.get_species_richness(6))\n self.assertEqual(439, c3.get_species_richness(11))\n self.assertEqual(446, c3.get_species_richness(12))","def get_graph_karateclub():\n all_members = set(range(34))\n club1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 16, 17, 19, 21}\n # club2 = all_members - club1\n\n G = eg.Graph(name=\"Zachary's Karate Club\")\n for node in all_members:\n G.add_node(node+1)\n\n zacharydat = \"\"\"\\\n0 1 1 1 1 1 1 1 1 0 1 1 1 1 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 0\n1 0 1 1 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 1 0 0 0\n1 1 0 1 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0\n1 1 1 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1\n0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1\n1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 1\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1\n0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1\n0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 1\n0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 1 1\n0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 0 0 0 0 0 1 1 1 0 1\n0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 0 1 1 1 0 1 1 0 0 1 1 1 1 1 1 1 0\"\"\"\n\n for row, line in enumerate(zacharydat.split('\\n')):\n thisrow = [int(b) for b in line.split()]\n for col, entry in enumerate(thisrow):\n if entry == 1:\n G.add_edge(row+1, col+1)\n\n # Add the name of each member's club as a node attribute.\n for v in G:\n G.nodes[v]['club'] = 'Mr. Hi' if v in club1 else 'Officer'\n return G","def find_max_independent_set(graph, params):\r\n\r\n max_ind_set = []\r\n\r\n # QHACK #\r\n\r\n # function that takes in a graph and outputs the hamiltonians\r\n cost_h, mixer_h = qaoa.max_independent_set(graph, constrained=True) # Assume the graph they give me is good\r\n\r\n def qaoa_layer(gamma, alpha):\r\n qaoa.cost_layer(gamma, cost_h)\r\n qaoa.mixer_layer(alpha, mixer_h)\r\n\r\n dev = qml.device(\"default.qubit\", wires=range(NODES))\r\n\r\n def circuit(params, **kwargs): \r\n qml.layer(qaoa_layer, N_LAYERS, params[0], params[1]) \r\n\r\n @qml.qnode(dev)\r\n def probability_circuit(gamma, alpha):\r\n circuit([gamma, alpha])\r\n return qml.probs(wires=range(NODES))\r\n\r\n answer = probability_circuit(params[0], params[1])\r\n\r\n maxn = 0\r\n maxn = max(answer)\r\n\r\n for i in range(len(answer)):\r\n if maxn == answer[i]:\r\n decimal = i\r\n \r\n binary_num = []\r\n def DecimalToBinary(decimal):\r\n if decimal >= 1:\r\n DecimalToBinary(decimal // 2)\r\n binary_num.append(decimal % 2)\r\n \r\n DecimalToBinary(decimal)\r\n\r\n if len(binary_num) < 6:\r\n if len(binary_num) < 5:\r\n if len(binary_num) < 4:\r\n if len(binary_num) < 3:\r\n if len(binary_num) < 2:\r\n binary_num.insert(0, 0) # At beginning append 0\r\n binary_num.insert(0, 0)\r\n binary_num.insert(0, 0)\r\n binary_num.insert(0, 0)\r\n binary_num.insert(0, 0)\r\n\r\n for i in range(6):\r\n if binary_num[i] == 1:\r\n max_ind_set.append(i)\r\n\r\n # QHACK #\r\n\r\n return max_ind_set","def test_branches_and_nodes_regression(\n traces, areas, snap_threshold, allowed_loops, already_clipped, data_regression\n):\n branches, nodes = branches_and_nodes.branches_and_nodes(\n traces, areas, snap_threshold, allowed_loops, already_clipped\n )\n\n branches_value_counts = branches[general.CONNECTION_COLUMN].value_counts().to_dict()\n nodes_value_counts = nodes[general.CLASS_COLUMN].value_counts().to_dict()\n\n data_regression.check({**branches_value_counts, **nodes_value_counts})","def test_maximum_common_subgraph(graph1, graph2, attrs):\n expected = vermouth.graph_utils.categorical_maximum_common_subgraph(graph1, graph2, attrs)\n\n found = vermouth.graph_utils.maximum_common_subgraph(graph1, graph2, attrs)\n\n note((\"Attributes that must match\", attrs))\n note((\"Graph 1 nodes\", graph1.nodes(data=True)))\n note((\"Graph 1 edges\", graph1.edges))\n note((\"Graph 2 nodes\", graph2.nodes(data=True)))\n note((\"Graph 2 edges\", graph2.edges))\n # We don't find all MCS'es. See comment in\n # vermouth.graph_utils.maximum_common_subgraph\n found = make_into_set(found)\n expected = make_into_set(expected)\n\n if found == expected:\n event(\"Exact match\")\n assert found <= expected","def find_random_others(participant_data,\n true_distro_by_round,\n network_topology_name,\n additional_names_count,\n only_non_neighbors=False,\n divergence_type=\"JS\",\n memory_length=5,\n graph=False):\n\n participant_differences = {}\n\n net = nb.net(network_topology_name)\n\n # We start by going through each participant\n for participant, data in participant_data.items():\n # First we look at the overall divergence without unstructured names\n div_no_unstructured_by_round = []\n\n distro_by_round_no_unstructured = impose_limited_memory(data[\"distro_by_round_no_unstructured\"],\n memory_length=memory_length)\n for game_round in range(1,26):\n\n # a new list of names needs to be truncated to induce some memory\n seen_distro_with_no_unstructured, true_distro = create_continuity_and_probabilities(\n distro_by_round_no_unstructured[game_round],\n true_distro_by_round[game_round])\n\n # divergence between real and distro with no additional names\n if divergence_type == \"JS\":\n div_no_unstructured_by_round.append(JS(seen_distro_with_no_unstructured, true_distro))\n else:\n div_no_unstructured_by_round.append(KL(seen_distro_with_no_unstructured, true_distro))\n\n\n # Then we calculate the KL divergence for the real rounds with unstructured\n div_with_unstructured_by_round = []\n\n distro_by_round_unstructured = impose_limited_memory(data[\"distro_by_round_unstructured\"],\n memory_length=memory_length)\n for game_round in range(1,26):\n\n # a new list of names needs to be truncated to induce some memory\n seen_distro_with_unstructured, true_distro_2 = create_continuity_and_probabilities(\n distro_by_round_unstructured[game_round],\n true_distro_by_round[game_round])\n\n # KL divergence between real and distro with additional name\n if divergence_type == \"JS\":\n div_with_unstructured_by_round.append(JS(seen_distro_with_unstructured, true_distro_2))\n else:\n div_with_unstructured_by_round.append(KL(seen_distro_with_unstructured, true_distro_2))\n\n\n\n if only_non_neighbors == True:\n # We get all the non-neighbors of the ego node\n random_others = list(net.get_non_alters(participant))\n else:\n random_others = list(net.network.nodes())\n random_others.remove(participant)\n\n # We randomly select a combination of non-neighbors\n random_others_combination = random.sample(random_others, additional_names_count)\n\n names_to_add_by_round = defaultdict(list)\n for random_other in random_others_combination:\n # We get the names played by the participant and append it to lists of names for\n # each round\n for round, name in enumerate(participant_data[random_other][\"names_played\"]):\n names_to_add_by_round[round].append(name)\n\n # We go through round by round and add in the newly visible names\n simulated_distro_by_round = {}\n\n # now we add to distribution with out unstructured\n for game_round in range(1,26):\n no_unstructured = list(data[\"distro_by_round_no_unstructured\"][game_round])\n no_unstructured.extend(names_to_add_by_round[game_round])\n\n simulated_distro_by_round[game_round] = no_unstructured\n\n # That new list of names needs to be truncated to induce some memory\n distro_by_round_with_random_others = impose_limited_memory(simulated_distro_by_round,\n memory_length=memory_length)\n\n divergence_by_round = []\n for game_round in range(1,26):\n\n seen_distro_random_others, true_distro = create_continuity_and_probabilities(\n distro_by_round_with_random_others[game_round],\n true_distro_by_round[game_round])\n\n # Then we calculate the divergence from distro with the additional names to true distro\n if divergence_type == \"JS\":\n div_with_random_others = JS(seen_distro_random_others, true_distro)\n else:\n div_with_random_others = KL(seen_distro_random_others, true_distro)\n divergence_by_round.append(div_with_random_others)\n\n # now that we have the divergence to the true distro from simulated distro, we compare it\n # to the divergence to the true distro from the real additional name distro. A positive\n # difference as calculated means the additional name version carries more information\n # (because it is closer to the true)\n\n game_diffs = [i-j for i, j in zip(divergence_by_round,div_with_unstructured_by_round)]\n\n divergence_ratio = [1 - actual/total if total !=0 else 0 for actual, total in zip(div_with_unstructured_by_round, div_no_unstructured_by_round)]\n\n #print(\"comparison:\", divergence_by_round)\n #print(\"base_diff:\", div_no_unstructured_by_round)\n #print(\"ratio:\", divergence_ratio)\n\n participant_differences[participant] = (game_diffs, random_others_combination, div_no_unstructured_by_round, divergence_ratio)\n\n return participant_differences","def getNet(chrom, loops, genes, pdis=2000, gap=1):\n #step 1 get merged anchors\n anchors = stichAnchors(chrom, loops, margin=gap)\n #step 2 annotate anchors\n nanchors = {}\n ts = np.array([[tss] for tss in genes.keys()])\n tree = KDTree(ts)\n for anchor in anchors:\n gs, ds = findOverlapOrNearest(genes, ts, tree, anchor.start,\n anchor.end)\n if len(gs) > 1:\n t = \"Promoter\"\n d = 0\n else:\n d = ds[0]\n if abs(d) <= pdis:\n t = \"Promoter\"\n else:\n t = \"Enhancer\"\n n = anchor.chrom + \":\" + str(anchor.start) + \"-\" + str(\n anchor.end) + \"|\" + t\n nanchors[n] = {\n \"chrom\":\n anchor.chrom,\n \"start\":\n anchor.start,\n \"end\":\n anchor.end,\n \"type\":\n n.split(\"|\")[-1],\n \"nearestDistanceToTSS\":\n d,\n \"nearestGene\":\n \",\".join([g.name for g in gs]),\n \"nearestGeneLoc\":\n \",\".join([\n g.chrom + \":\" + str(g.start) + \"-\" + str(g.end) + \"|\" +\n g.strand + \"|\" + g.name for g in gs\n ])\n }\n anchors = nanchors\n del nanchors\n #step 3 assign each anchor to merged annotated anchor and build the network\n anchorCov = {}\n for k, v in anchors.items():\n for i in range(v[\"start\"], v[\"end\"] + 1):\n anchorCov[i] = k\n ds = {} #anchor annotations\n nets = {} #net information\n G = nx.Graph() #networkx graph structure\n for loop in loops:\n xt, yt = None, None\n for i in range(loop.x_start, loop.x_end + 1):\n if i in anchorCov:\n xt = anchorCov[i]\n break\n for i in range(loop.y_start, loop.y_end + 1):\n if i in anchorCov:\n yt = anchorCov[i]\n break\n ds[loop.id] = {\n \"mergedAnchorA\": xt,\n \"mergedAnchorB\": yt,\n }\n if xt == yt:\n continue\n ns = [xt, yt]\n ns.sort() #sort for converging keys\n if ns[0] not in nets:\n nets[ns[0]] = set()\n nets[ns[0]].add(ns[1])\n #network edges\n G.add_edge(ns[0], ns[1])\n #step 4 find all enhancers linked to target gene\n targets = {}\n #step 4.1 find the direct enhancer that link to promoter\n for node in G.nodes:\n if node.split(\"|\")[-1] == \"Promoter\":\n if node in targets:\n continue\n targets[node] = {\n \"targetGene\": anchors[node][\"nearestGeneLoc\"],\n \"directEnhancer\": set(),\n \"indirectEnhancer\": set(),\n \"directPromoter\": set(),\n \"indirectPromoter\": set()\n }\n ns = list(nx.descendants(G, node))\n #find all releated nodes\n for n in ns:\n p = nx.algorithms.shortest_path(G, source=node, target=n)\n if n.split(\"|\")[-1] == \"Promoter\":\n if len(p) == 2:\n targets[node][\"directPromoter\"].add(n)\n else:\n targets[node][\"indirectPromoter\"].add(n)\n if n.split(\"|\")[-1] == \"Enhancer\":\n if len(p) == 2:\n targets[node][\"directEnhancer\"].add(n)\n else:\n targets[node][\"indirectEnhancer\"].add(n)\n #step 4.2. find hub enhancer\n #only using non-redundant node to find hubs\n nns = []\n tmp = set()\n for n in ns:\n tn = n.split(\"|\")[0]\n if tn not in tmp:\n nns.append(n)\n tmp.add(tn)\n ns = list(nns)\n ns.append(node)\n subg = G.subgraph(ns)\n try:\n hubs, authorities = nx.hits(subg,\n max_iter=1000,\n normalized=True)\n except:\n print(\n \"For %s, hard to find the hub by running HITS algorithm of 1000 iteration.\"\n % node)\n targets[node][\"directEnhancerHub\"] = \"\"\n targets[node][\"indirectEnhancerHub\"] = \"\"\n continue\n hubs = pd.Series(hubs)\n hubs = hubs.sort_values(inplace=False, ascending=False)\n if len(targets[node][\"directEnhancer\"]) >= 2:\n des = hubs[list(targets[node][\"directEnhancer\"])]\n des = des.sort_values(inplace=False, ascending=False)\n targets[node][\"directEnhancerHub\"] = des.index[0]\n else:\n targets[node][\"directEnhancerHub\"] = \"\"\n if len(targets[node][\"indirectEnhancer\"]) >= 2:\n indes = hubs[list(targets[node][\"indirectEnhancer\"])]\n indes = indes.sort_values(inplace=False, ascending=False)\n targets[node][\"indirectEnhancerHub\"] = indes.index[0]\n else:\n targets[node][\"indirectEnhancerHub\"] = \"\"\n return anchors, ds, nets, targets","def checkNumNeighbors():","def test_weight(self):\n # Folder must be root to load in make_net properly\n if os.getcwd().split('\\\\')[-1] == 'tests': os.chdir('..')\n \n # Create parents\n cfg = Config()\n cfg.genome.weight_min_value = -2\n cfg.genome.weight_max_value = 2\n gene1, gene2 = get_connection_genes((-1, 0), cfg.genome)\n \n # Ratio of 0.5, so possible to cross to both parents\n p1 = False\n p2 = False\n for _ in range(100):\n gene3 = gene1.crossover(other=gene2, cfg=cfg.genome, ratio=0.5)\n if gene3.weight == gene1.weight:\n p1 = True\n elif gene3.weight == gene2.weight:\n p2 = True\n else:\n raise self.failureException(\"Must be mutated to one of parent's values\")\n if p1 and p2: break\n self.assertTrue(p1 and p2)\n \n # Ratio of 1, so always inherits from first parent\n for _ in range(100):\n gene3 = gene1.crossover(other=gene2, cfg=cfg.genome, ratio=1)\n self.assertEqual(gene3.weight, gene1.weight)\n \n # Ratio of 0, so always inherits from second parent\n for _ in range(100):\n gene3 = gene1.crossover(other=gene2, cfg=cfg.genome, ratio=0)\n self.assertEqual(gene3.weight, gene2.weight)","def get_GNS_cut(self):\n # we build the optimization around the casted digraph instead of multidigraph\n # for simplicity\n G = self.base_digraph\n s_1 = self.sources[0]\n s_2 = self.sources[1]\n t_1 = self.destinations[0]\n t_2 = self.destinations[1]\n edges = G.edges()\n nodes = G.nodes()\n\n try:\n\n # Great an gurobi instance of the optimization model\n m = Model(\"GNS\")\n m.setParam('OutputFlag', False)\n\n x_v = {}\n # vertex variables for s_1, t_1 cut\n for v in nodes:\n x_v[v] = m.addVar(vtype=GRB.BINARY)\n\n x_e = {}\n # edge variables for s_1, t_1 cut\n for (u,v) in edges:\n x_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n y_v = {}\n # vertex variables for s_2, t_2 cut\n for v in nodes:\n y_v[v] = m.addVar(vtype=GRB.BINARY)\n\n y_e = {}\n # edge variables for s_2, t_2 cut\n for (u,v) in edges:\n y_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n z_v = {}\n # vertex variables for s_2, t_1 cut\n for v in nodes:\n z_v[v] = m.addVar(vtype=GRB.BINARY)\n\n z_e = {}\n # edge variables for s_2, t_1 cut\n for (u,v) in edges:\n z_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n e = {}\n # GNS indicator variable\n for (u,v) in edges:\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\n\n # Done with decision variable creation\n # update model\n m.update()\n\n # Constraints\n # 1. Constraints for s_1 - t_1 cut\n for (u,v) in edges:\n if (u,v) == (s_1, t_1):\n m.addConstr(x_e[u,v] >= 1)\n elif u == s_1:\n m.addConstr(x_v[v] + x_e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-x_v[u] + x_e[u,v] >= 0)\n else:\n m.addConstr(x_v[v] - x_v[u] + x_e[u,v] >= 0)\n\n # 2. Constraints for s_2 - t_2 cut\n for (u,v) in edges:\n if (u,v) == (s_2, t_2):\n m.addConstr(y_e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(y_v[v] + y_e[u,v] >= 1)\n elif v == t_2:\n m.addConstr(-y_v[u] + y_e[u,v] >= 0)\n else:\n m.addConstr(y_v[v] - y_v[u] + y_e[u,v] >= 0)\n\n # 3. Constraints for s_2 - t_1 cut\n for (u,v) in edges:\n if (u,v) == (s_2, t_1):\n m.addConstr(z_e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(z_v[v] + z_e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-z_v[u] + z_e[u,v] >= 0)\n else:\n m.addConstr(z_v[v] - z_v[u] + z_e[u,v] >= 0)\n\n # 4. Constraints for e[u,v] >= max(x_e[u,v], y_e[u,v], z_e[u,v])\n for (u,v) in edges:\n m.addConstr(e[u,v] >= x_e[u,v])\n m.addConstr(e[u,v] >= y_e[u,v])\n m.addConstr(e[u,v] >= z_e[u,v])\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n print \"Min GNS cut value = \" + str(m.objVal)\n print \"GNS cut edges:\"\n\n for u,v in edges:\n if e[u,v].x != 0:\n print (u,v)\n print \"s1-t1 cut edges in GNS:\"\n for u,v in edges:\n if x_e[u,v].x != 0:\n print (u,v)\n\n print \"s2-t2 cut edges in GNS:\"\n for u,v in edges:\n if y_e[u,v].x != 0:\n print (u,v)\n\n print \"s2-t1 cut edges in GNS:\"\n for u,v in edges:\n if z_e[u,v].x != 0:\n print (u,v)\n else:\n # something went wrong...err...\n print \"Something was wrong\"\n\n except GurobiError:\n print ('Error report from Gurobi')","def testProtractedCommunityParametersStored(self):\n self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8], self.c.get_community_references())\n self.assertEqual(\n 1, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=100)\n )\n self.assertEqual(\n 2, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=100)\n )\n self.assertEqual(\n 3, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=25, max_speciation_gen=100)\n )\n self.assertEqual(\n 4, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=25, max_speciation_gen=100)\n )\n self.assertEqual(\n 5, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=200)\n )\n self.assertEqual(\n 6, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=200)\n )\n self.assertEqual(\n 7, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=0.0, max_speciation_gen=2000)\n )\n self.assertEqual(\n 8, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=0.0, max_speciation_gen=2000)\n )\n ed1 = {\n \"speciation_rate\": 0.1,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 50,\n \"max_speciation_gen\": 100,\n }\n ed2 = {\n \"speciation_rate\": 0.2,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 50,\n \"max_speciation_gen\": 100,\n }\n ed3 = {\n \"speciation_rate\": 0.1,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 25,\n \"max_speciation_gen\": 100,\n }\n ed4 = {\n \"speciation_rate\": 0.2,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 25,\n \"max_speciation_gen\": 100,\n }\n ed5 = {\n \"speciation_rate\": 0.1,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 50,\n \"max_speciation_gen\": 200,\n }\n ed6 = {\n \"speciation_rate\": 0.2,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 50,\n \"max_speciation_gen\": 200,\n }\n ed7 = {\n \"speciation_rate\": 0.1,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 0.0,\n \"max_speciation_gen\": 2000,\n }\n ed8 = {\n \"speciation_rate\": 0.2,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 0.0,\n \"max_speciation_gen\": 2000,\n }\n com1_dict = self.c.get_community_parameters(1)\n com2_dict = self.c.get_community_parameters(2)\n com3_dict = self.c.get_community_parameters(3)\n com4_dict = self.c.get_community_parameters(4)\n com5_dict = self.c.get_community_parameters(5)\n com6_dict = self.c.get_community_parameters(6)\n com7_dict = self.c.get_community_parameters(7)\n com8_dict = self.c.get_community_parameters(8)\n self.assertEqual(ed1, com1_dict)\n self.assertEqual(ed2, com2_dict)\n self.assertEqual(ed3, com3_dict)\n self.assertEqual(ed4, com4_dict)\n self.assertEqual(ed5, com5_dict)\n self.assertEqual(ed6, com6_dict)\n self.assertEqual(ed7, com7_dict)\n self.assertEqual(ed8, com8_dict)","def testProtractedCommunityParametersStored(self):\n self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8], self.c.get_community_references())\n self.assertEqual(\n 1, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=100)\n )\n self.assertEqual(\n 2, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=100)\n )\n self.assertEqual(\n 3, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=25, max_speciation_gen=100)\n )\n self.assertEqual(\n 4, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=25, max_speciation_gen=100)\n )\n self.assertEqual(\n 5, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=200)\n )\n self.assertEqual(\n 6, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=200)\n )\n self.assertEqual(\n 7, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=0.0, max_speciation_gen=2000)\n )\n self.assertEqual(\n 8, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=0.0, max_speciation_gen=2000)\n )\n ed1 = {\n \"speciation_rate\": 0.1,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 50,\n \"max_speciation_gen\": 100,\n }\n ed2 = {\n \"speciation_rate\": 0.2,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 50,\n \"max_speciation_gen\": 100,\n }\n ed3 = {\n \"speciation_rate\": 0.1,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 25,\n \"max_speciation_gen\": 100,\n }\n ed4 = {\n \"speciation_rate\": 0.2,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 25,\n \"max_speciation_gen\": 100,\n }\n ed5 = {\n \"speciation_rate\": 0.1,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 50,\n \"max_speciation_gen\": 200,\n }\n ed6 = {\n \"speciation_rate\": 0.2,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 50,\n \"max_speciation_gen\": 200,\n }\n ed7 = {\n \"speciation_rate\": 0.1,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 0.0,\n \"max_speciation_gen\": 2000,\n }\n ed8 = {\n \"speciation_rate\": 0.2,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 0.0,\n \"max_speciation_gen\": 2000,\n }\n com1_dict = self.c.get_community_parameters(1)\n com2_dict = self.c.get_community_parameters(2)\n com3_dict = self.c.get_community_parameters(3)\n com4_dict = self.c.get_community_parameters(4)\n com5_dict = self.c.get_community_parameters(5)\n com6_dict = self.c.get_community_parameters(6)\n com7_dict = self.c.get_community_parameters(7)\n com8_dict = self.c.get_community_parameters(8)\n self.assertEqual(ed1, com1_dict)\n self.assertEqual(ed2, com2_dict)\n self.assertEqual(ed3, com3_dict)\n self.assertEqual(ed4, com4_dict)\n self.assertEqual(ed5, com5_dict)\n self.assertEqual(ed6, com6_dict)\n self.assertEqual(ed7, com7_dict)\n self.assertEqual(ed8, com8_dict)","def testProtractedCommunityParametersStored(self):\n self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8], self.c.get_community_references())\n self.assertEqual(\n 1, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=100)\n )\n self.assertEqual(\n 2, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=100)\n )\n self.assertEqual(\n 3, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=25, max_speciation_gen=100)\n )\n self.assertEqual(\n 4, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=25, max_speciation_gen=100)\n )\n self.assertEqual(\n 5, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=200)\n )\n self.assertEqual(\n 6, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=200)\n )\n self.assertEqual(\n 7, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=0.0, max_speciation_gen=2000)\n )\n self.assertEqual(\n 8, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=0.0, max_speciation_gen=2000)\n )\n ed1 = {\n \"speciation_rate\": 0.1,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 50,\n \"max_speciation_gen\": 100,\n }\n ed2 = {\n \"speciation_rate\": 0.2,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 50,\n \"max_speciation_gen\": 100,\n }\n ed3 = {\n \"speciation_rate\": 0.1,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 25,\n \"max_speciation_gen\": 100,\n }\n ed4 = {\n \"speciation_rate\": 0.2,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 25,\n \"max_speciation_gen\": 100,\n }\n ed5 = {\n \"speciation_rate\": 0.1,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 50,\n \"max_speciation_gen\": 200,\n }\n ed6 = {\n \"speciation_rate\": 0.2,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 50,\n \"max_speciation_gen\": 200,\n }\n ed7 = {\n \"speciation_rate\": 0.1,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 0.0,\n \"max_speciation_gen\": 2000,\n }\n ed8 = {\n \"speciation_rate\": 0.2,\n \"time\": 0.0,\n \"fragments\": 0,\n \"metacommunity_reference\": 0,\n \"min_speciation_gen\": 0.0,\n \"max_speciation_gen\": 2000,\n }\n com1_dict = self.c.get_community_parameters(1)\n com2_dict = self.c.get_community_parameters(2)\n com3_dict = self.c.get_community_parameters(3)\n com4_dict = self.c.get_community_parameters(4)\n com5_dict = self.c.get_community_parameters(5)\n com6_dict = self.c.get_community_parameters(6)\n com7_dict = self.c.get_community_parameters(7)\n com8_dict = self.c.get_community_parameters(8)\n self.assertEqual(ed1, com1_dict)\n self.assertEqual(ed2, com2_dict)\n self.assertEqual(ed3, com3_dict)\n self.assertEqual(ed4, com4_dict)\n self.assertEqual(ed5, com5_dict)\n self.assertEqual(ed6, com6_dict)\n self.assertEqual(ed7, com7_dict)\n self.assertEqual(ed8, com8_dict)","def test_local_efficiency_complete_graph(self):\n for n in range(3, 10):\n G = nx.complete_graph(n)\n assert_equal(nx.local_efficiency(G), 1)","def compute_W2(elec_sets, districts, min_cand_weights_dict, black_pref_cands_df, hisp_pref_cands_df, \\\n cand_race_dict):\n \n min_cand_black_W2 = np.empty((len(elec_sets),0), float)\n min_cand_hisp_W2 = np.empty((len(elec_sets),0), float)\n min_cand_neither_W2 = np.empty((len(elec_sets),0), float)\n \n for dist in districts:\n black_pref = list(black_pref_cands_df[dist])\n\n black_pref_race = [cand_race_dict[bp] for bp in black_pref]\n black_cand_weight = [min_cand_weights_dict[\"Relevant Minority\"] if \"Black\" in bpr else \\\n min_cand_weights_dict[\"Other\"] for bpr in black_pref_race]\n min_cand_black_W2 = np.append(min_cand_black_W2, np.array([black_cand_weight]).transpose(), axis = 1)\n \n hisp_pref = list(hisp_pref_cands_df[dist])\n hisp_pref_race = [cand_race_dict[hp] for hp in hisp_pref]\n hisp_cand_weight = [min_cand_weights_dict[\"Relevant Minority\"] if \"Hispanic\" in hpr else \\\n min_cand_weights_dict[\"Other\"] for hpr in hisp_pref_race]\n min_cand_hisp_W2 = np.append(min_cand_hisp_W2, np.array([hisp_cand_weight]).transpose(), axis = 1)\n \n neither_cand_weight = [min_cand_weights_dict['Relevant Minority'] if ('Hispanic' in hpr and 'Black' in bpr) else\\\n min_cand_weights_dict['Other'] if ('Hispanic' not in hpr and 'Black' not in bpr) else \\\n min_cand_weights_dict['Partial '] for bpr,hpr in zip(black_pref_race, hisp_pref_race)]\n min_cand_neither_W2 = np.append(min_cand_neither_W2, np.array([neither_cand_weight]).transpose(), axis = 1)\n \n return min_cand_black_W2, min_cand_hisp_W2, min_cand_neither_W2","def testOutputCandidateDesignAssignmentsWithSusbetOfPairs(self):\n pretest_data = pd.DataFrame({\n 'date': pd.to_datetime(['2019-01-01', '2019-10-01'] * 20),\n 'geo': sorted(list(range(20)) * 2),\n 'response': range(100, 140),\n 'spend': range(40),\n })\n test_class = TrimmedMatchGeoXDesign(\n GeoXType.HEAVY_UP,\n pretest_data=pretest_data,\n time_window_for_design=self.design_window,\n time_window_for_eval=self.evaluation_window,\n )\n\n _ = test_class.report_candidate_designs(\n budget_list=[30],\n iroas_list=[0],\n use_cross_validation=True,\n num_simulations=10,\n )\n test_class.generate_balanced_assignment(pair_index=1, base_seed=0)\n self.assertTrue(\n test_class.geo_level_eval_data[1].equals(\n pd.DataFrame({\n 'geo': list(range(2, 20)),\n 'pair': sorted(list(range(2, 11)) * 2),\n 'response': [101 + 2 * x for x in range(2, 20)],\n 'spend': [1 + 2 * x for x in range(2, 20)],\n 'assignment': [\n TREATMENT, CONTROL, CONTROL, TREATMENT, CONTROL, TREATMENT,\n CONTROL, TREATMENT, CONTROL, TREATMENT, TREATMENT, CONTROL,\n TREATMENT, CONTROL, TREATMENT, CONTROL, CONTROL, TREATMENT\n ]\n })))\n\n test_class.generate_balanced_assignment(\n pair_index=2, base_seed=0)\n self.assertTrue(\n test_class.geo_level_eval_data[2].equals(\n pd.DataFrame({\n 'geo': list(range(4, 20)),\n 'pair': sorted(list(range(3, 11)) * 2),\n 'response': [101 + 2 * x for x in range(4, 20)],\n 'spend': [1 + 2 * x for x in range(4, 20)],\n 'assignment': [CONTROL, TREATMENT, TREATMENT, CONTROL, CONTROL,\n TREATMENT, CONTROL, TREATMENT, CONTROL,\n TREATMENT, CONTROL, TREATMENT, TREATMENT,\n CONTROL, TREATMENT, CONTROL]\n })))","def make_get_minimum_set(gRNA_hits, manual_check = True, exclude_seqs = set(), targets = None,\n prioritise_nr = False, sc_algorithm = \"LAR\", num_sets = 1, tie_breaker = None,\n low_coverage_penalty = 0.5, suppress_warning = False,\n impossible_set_message = impossible_set_message_default):\n # ## filter by excluded sequences\n if exclude_seqs:\n gRNA_hits.set_seqs_check(\"exclude\", False, [str(s) for s in exclude_seqs])\n gRNA_hits = gRNA_hits.filter_seqs_all_checks_passed(quiet = suppress_warning)\n gRNA_hits = gRNA_hits.filter_hits_all_checks_passed(quiet = suppress_warning)\n if prioritise_nr:\n set_cover = make_set_cover_nr(gRNA_hits, num_sets = num_sets, target_ids = targets,\n num_lengths_to_track = None,\n low_coverage_penalty = low_coverage_penalty,\n suppress_warning = suppress_warning)\n else:\n ## tie breakers should return 2 values: <gRNASeq>, [<gRNAHits>]\n ## note: If antisense, tie break by minimum -end. Else, tie break by minimum start.\n ## note: tie-breaker uses AVERAGE distance of hits (to inferred N-terminus)\n if tie_breaker is None:\n tie_breaker = lambda *args: tuple(all_best_pos(*args).items())[0]\n set_cover = make_set_cover_pos(gRNA_hits, num_sets = num_sets, target_ids = targets,\n algorithm = sc_algorithm, id_key = lambda x:x.target_id,\n tie_breaker = tie_breaker,\n suppress_warning = suppress_warning)\n set_num = [0]\n def get_minimum_set():\n restore = []\n set_num[0] += 1\n while True:\n ## solve set_cover\n selected_grna = set_cover(restore = restore)\n restore = selected_grna\n ## if empty set, print message and break out of loop to exit and return the empty set\n if len(selected_grna) == 0:\n print(impossible_set_message)\n break\n ## if valid set AND manual check NOT requested, break out of loop to exit and return the valid set\n elif not manual_check: break\n ## if valid set AND manual check requested\n else:\n ## print gRNA sequences in selected_grna to screen for user to evaluate\n sorted_grna = sorted(selected_grna, key = lambda grna:grna.id)\n usr_input = manual_check_prompt(sorted_grna, set_num[0])\n if usr_input.upper() == 'X':\n break\n else:\n ## id_list and seq_list have same order as selected_grna\n id_list = tuple(grna.id for grna in selected_grna)\n seq_list = tuple(str(grna.seq).upper() for grna in selected_grna)\n ## remove gRNA from list of gRNAs to restore upon next set cover generation\n if usr_input in id_list:\n index = id_list.index(usr_input)\n restore.remove(selected_grna[index])\n elif usr_input.upper() in seq_list:\n index = seq_list.index(usr_input)\n restore.remove(selected_grna[index])\n else:\n print(\"Invalid input.\")\n return [str(grna.seq) for grna in selected_grna]\n return get_minimum_set","def test_expected_growth(self):\r\n\r\n graph = nx.lollipop_graph(4, 1)\r\n graph.add_edge(4, 2)\r\n\r\n c = [3, 4]\r\n result = clique.search(c, graph, iterations=100)\r\n assert result == [0, 1, 2, 3]","def testSameRMSEWhenPairsAreSpecifiedOrNotDifferentGeoOrder(self):\n test_class1 = TrimmedMatchGeoXDesign(\n GeoXType.HEAVY_UP,\n pretest_data=self.nontrivial_data,\n time_window_for_design=self.design_window,\n time_window_for_eval=self.evaluation_window,\n matching_metrics={'response': 1.0},\n pairs=None)\n\n for geox_type in GeoXType:\n if geox_type == GeoXType.CONTROL:\n continue\n\n test_class1._geox_type = geox_type\n _, expected_detailed_results = test_class1.report_candidate_designs(\n budget_list=[30, 40],\n iroas_list=[0, 2],\n use_cross_validation=True,\n num_simulations=10)\n\n # change the order of geo1 and geo2 in some of the pairs\n pairs = [x.copy() for x in test_class1.pairs]\n pairs[0].loc[0:3, 'geo1'] = test_class1.pairs[0].loc[0:3, 'geo2']\n pairs[0].loc[0:3, 'geo2'] = test_class1.pairs[0].loc[0:3, 'geo1']\n\n test_class2 = TrimmedMatchGeoXDesign(\n geox_type,\n pretest_data=self.nontrivial_data,\n time_window_for_design=self.design_window,\n time_window_for_eval=self.evaluation_window,\n matching_metrics={'response': 1.0},\n pairs=pairs)\n _, detailed_results = test_class2.report_candidate_designs(\n budget_list=[30, 40],\n iroas_list=[0, 2],\n use_cross_validation=True,\n num_simulations=10)\n\n for key in detailed_results.keys():\n self.assertTrue(\n np.array_equal(detailed_results[key]['estimate'],\n expected_detailed_results[key]['estimate']))","def test_grovers_waltz_basis_gates(self):\n shots = 2000\n circuits = ref_algorithms.grovers_circuit(final_measure=True,\n allow_sampling=True)\n targets = ref_algorithms.grovers_counts(shots)\n job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='u1,u2,u3,cx')\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)","def test_global_efficiency_complete_graph(self):\n for n in range(2, 10):\n G = nx.complete_graph(n)\n assert_equal(nx.global_efficiency(G), 1)","def greedy_build(nodes, priors=None, cutoff=200, considered=set(), uniq='', targets=[]):\n\n\t# Tracks frequency of states for each character in nodes\n\tcharacter_mutation_mapping = defaultdict(int)\n\n\t# G models the network that is returned recursively\n\tG = nx.DiGraph()\n\n\troot = root_finder(nodes)\n\n\t# Base case check for recursion, returns a graph with one node corresponding to the root of the remaining nodes\n\tif len(nodes) <= cutoff or len(nodes) == 1:\n\t\troot = root_finder(nodes)\n\t\tG.add_node(root)\n\t\treturn G, [[root, nodes]]\n\n\t# Accounting for frequency of mutated states per character, in order to choose the best split\n\tfor node in nodes:\n\t\tnode_list = node.split(\"_\")[0].split('|')\n\t\tfor i in range(0, len(node_list)):\n\t\t\tchar = node_list[i]\n\t\t\tif char != '0' and char != '-':\n\t\t\t\tcharacter_mutation_mapping[(str(i), char)] += 1\n #if char != '0':\n # if char == \"-\":\n # character_mutation_mapping[(str(i), char)] -= 1\n # else:\n # character_mutation_mapping[(str(i), char)] += 1\n\n\t# Choosing the best mutation to split on (ie character and state)\n\tcharacter, state = 0, 0\n\tmax_cost = 0\n\n\tmin_prior = 1\n\tif priors:\n\t\tfor i in priors.keys():\n\t\t\tfor j in priors[i].keys():\n\t\t\t\tmin_prior = min(min_prior, priors[i][j])\n\n\tfor i,j in character_mutation_mapping:\n\t\tif not (i,j) in considered:\n\t\t\tif not priors:\n\t\t\t\tif max_cost < character_mutation_mapping[(i, j)]:\n\t\t\t\t\tmax_cost = character_mutation_mapping[(i, j)]\n\t\t\t\t\tcharacter, state = i, j\n\t\t\telse:\n\t\t\t\tif j not in priors[int(i)]:\n\t\t\t\t\tpriors[int(i)][j] = min_prior\n\t\t\t\tif max_cost < -np.log(priors[int(i)][j]) * character_mutation_mapping[(i, j)]:\n\t\t\t\t\tmax_cost = -np.log(priors[int(i)][j]) * character_mutation_mapping[(i, j)]\n\t\t\t\t\tcharacter, state = i, j\n\tcharacter = int(character)\n\n\n\t# If there is no good split left, stop the process and return a graph with the remainder of nodes\n\tif character == 0 and state == 0:\n\t\tif len(nodes) == 1:\n\t\t\tG.add_node(nodes[0])\n\t\telse:\n\t\t\tfor i in range(0, len(nodes)):\n\t\t\t\tif nodes[i] != root:\n\t\t\t\t\tG.add_edge(root, nodes[i])\n\t\treturn G, []\n\n\t# Splitting nodes based on whether they have the mutation, don't have the mutation, or are NA('-') in that character\n\t# Right split is where nodes with the mutation go, everyone else goes to left split or NA chars\n\tleft_split, right_split, NA_chars = [], [], []\n\tright_split_temp = []\n\tleft_split_temp = []\n\tfor node in nodes:\n\t\tnode_list = node.split('|')\n\t\tif node_list[character] == state:\n\t\t\tright_split.append(node)\n\t\telif node_list[character] == '-':\n\t\t\tNA_chars.append(node)\n\t\telse:\n\t\t\tleft_split.append(node)\n\n\n\t# Seperates all nodes with NA in the character chosen to be split upon\n\t# Puts in right split or left split based on which list shares more mutated characters with this string\n\tfor node in NA_chars:\n\t\tright_split_score = 0\n\t\tleft_split_score = 0\n\t\tnode_list = node.split('|')\n\t\tnum_not_missing = len([n for n in node_list if n != \"-\"])\n\t\tfor i in range(0, len(node_list)):\n\t\t\tif node_list[i] != '0' and node_list[i] != '-':\n\t\t\t\tfor node_2 in left_split:\n\t\t\t\t\tnode2_list = node_2.split('|')\n\t\t\t\t\tif node_list[i] == node2_list[i]:\n\t\t\t\t\t\tleft_split_score += 1\n\t\t\t\tfor node_2 in right_split:\n\t\t\t\t\tnode2_list = node_2.split('|')\n\t\t\t\t\tif node_list[i] == node2_list[i]:\n\t\t\t\t\t\tright_split_score += 1\n\n\t\tavg_left_split_score = left_split_score / float(len(left_split) * num_not_missing + 1)\n\t\tavg_right_split_score = right_split_score / float(len(right_split) * num_not_missing + 1)\n\n\t\tif avg_left_split_score < avg_right_split_score:\n\t\t\tright_split_temp.append(node)\n\t\telse:\n\t\t\tleft_split_temp.append(node)\n\n\tright_split += right_split_temp\n\tleft_split += left_split_temp\n\n\t# Add character, state that split occurred to already considered mutations\n\tconsidered.add((str(character), state))\n\tG = nx.DiGraph()\n\t#splitter = str(character) + \" \" + str(state) + \" (\" + uniq + \")\"\n\tsplitter = root\n\n\t# Recursively build left side of network (ie side that did not mutation at the character with the specific state)\n\tG.add_node(splitter)\n\tleft_subproblems = []\n\tleft_network = None\n\tif len(left_split) != 0:\n\t\tleft_root = root_finder(left_split)\n\t\t# if left_root not in left_split and left_root in targets:\n\t\t# \tleft_root = left_root + \"_unique\"\n\n\t\tleft_network, left_subproblems = greedy_build(left_split, priors, cutoff, considered.copy(), uniq + \"0\", targets=targets)\n\n\t\tleft_nodes = [node for node in left_network.nodes() if left_network.in_degree(node) == 0]\n\t\tdup_dict = {}\n\t\tfor n in left_network:\n\t\t\tif n in list(G.nodes()) and n != left_root:\n\t\t\t\tdup_dict[n] = n + \"_\" + str(hashlib.md5(left_root.encode('utf-8')).hexdigest())\n\t\tleft_network = nx.relabel_nodes(left_network, dup_dict)\n\t\tG = nx.compose(G, left_network)\n\t\tif root != left_root:\n\t\t\tG.add_edge(splitter, left_root, weight=0, label=\"None\")\n\n\t# Recursively build right side of network\n\tright_network, right_subproblems = greedy_build(right_split, priors, cutoff, considered.copy(), uniq + \"1\", targets=targets)\n\tright_nodes = [node for node in right_network.nodes() if right_network.in_degree(node) == 0]\n\tright_root = root_finder(right_split)\n\n\tdup_dict = {}\n\tfor n in right_network:\n\t\tif n in list(G.nodes()) and n != right_root:\n\t\t\tdup_dict[n] = n + \"_\" + str(hashlib.md5(right_root.encode('utf-8')).hexdigest())\n\tfor n in dup_dict:\n\t\trename_dict = {n: dup_dict[n]}\n\t\tif right_network.out_degree(n) != 0:\n\t\t\tright_network = nx.relabel_nodes(right_network, rename_dict)\n\t\telse:\n\t\t\trename_dict = {n: dup_dict[n]}\n\t\t\tG = nx.relabel_nodes(G, rename_dict)\n\n\tG = nx.compose(G, right_network)\n\t# if right_root not in right_split and right_root in targets:\n\t# \tright_root = right_root + \"_unique\"\n\t#for node in right_nodes:\n\tif root != right_root:\n\t\tif not priors:\n\t\t\tG.add_edge(splitter, right_root, weight=1, label = str(character) + \": 0 -> \" + str(state))\n\t\telse:\n\t\t\tG.add_edge(splitter, right_root, weight=-np.log(priors[int(character)][state]), label=str(character) + \": 0 -> \" + str(state))\n\n\n\treturn G, left_subproblems + right_subproblems","def simulate_weakest_ties(participant_data,\n true_distro_by_round,\n network_topology_name,\n additional_name_count,\n divergence_type=\"JS\",\n memory_length=5,\n graph=False):\n\n participant_differences = {}\n\n net = nb.net(network_topology_name)\n weakest_links = net.calc_weakest_ties(additional_name_count)\n\n # We start by going through each participant\n for participant, data in participant_data.items():\n # and we're going to calculate the total divergence for each weakest link\n\n # First we look at the overall divergence without unstructured names\n div_no_unstructured_by_round = []\n\n distro_by_round_no_unstructured = impose_limited_memory(data[\"distro_by_round_no_unstructured\"],\n memory_length=memory_length)\n for game_round in range(1,26):\n\n # a new list of names needs to be truncated to induce some memory\n seen_distro_with_no_unstructured, true_distro = create_continuity_and_probabilities(\n distro_by_round_no_unstructured[game_round],\n true_distro_by_round[game_round])\n\n # divergence between real and distro with additional names\n if divergence_type == \"JS\":\n div_no_unstructured_by_round.append(JS(seen_distro_with_no_unstructured, true_distro))\n else:\n div_no_unstructured_by_round.append(KL(seen_distro_with_no_unstructured, true_distro))\n\n\n # Next we calculate the divergence for the real rounds with unstructured\n div_with_unstructured_by_round = []\n\n distro_by_round_unstructured = impose_limited_memory(data[\"distro_by_round_unstructured\"],\n memory_length=memory_length)\n for game_round in range(1,26):\n\n # a new list of names needs to be truncated to induce some memory\n seen_distro_with_unstructured, true_distro_2 = create_continuity_and_probabilities(\n distro_by_round_unstructured[game_round],\n true_distro_by_round[game_round])\n # divergence between real and distro with additional names\n if divergence_type == \"JS\":\n div_with_unstructured_by_round.append(JS(seen_distro_with_unstructured, true_distro_2))\n else:\n div_with_unstructured_by_round.append(KL(seen_distro_with_unstructured, true_distro_2))\n\n names_to_add_by_round = defaultdict(list)\n for new_alter in weakest_links[participant]:\n # We get the name played by the partic. and append it to lists of names for each round\n for round, name in enumerate(participant_data[new_alter][\"names_played\"]):\n names_to_add_by_round[round].append(name)\n\n # We go through round by round and add in the newly visible names\n simulated_distro_by_round = {}\n\n for game_round in range(1,26):\n no_unstructured = list(data[\"distro_by_round_no_unstructured\"][game_round])\n no_unstructured.extend(names_to_add_by_round[game_round])\n simulated_distro_by_round[game_round] = no_unstructured\n\n # That new list of names needs to be truncated to induce some memory\n distro_by_round_weakest_link = impose_limited_memory(simulated_distro_by_round,\n memory_length=memory_length)\n\n divergence_weakest_by_round = []\n for game_round in range(1,26):\n\n seen_distro_weakest_link, true_distro = create_continuity_and_probabilities(\n distro_by_round_weakest_link[game_round],\n true_distro_by_round[game_round])\n\n\n # Then we calculate the divergence from distro with weakest link to true distro\n if divergence_type == \"JS\":\n div_with_weakest_link = JS(seen_distro_weakest_link, true_distro)\n else:\n div_with_weakest_link = KL(seen_distro_weakest_link, true_distro)\n divergence_weakest_by_round.append(div_with_weakest_link)\n\n game_diffs = [i-j for i, j in zip(divergence_weakest_by_round,div_with_unstructured_by_round)]\n\n\n\n divergence_ratio = [1 - actual/total if total !=0 else 0 for actual, total in zip(div_with_unstructured_by_round, div_no_unstructured_by_round)]\n\n #print(\"comparison:\", divergence_weakest_by_round)\n #print(\"base_diff:\", div_no_unstructured_by_round)\n #print(\"ratio:\", divergence_ratio)\n\n participant_differences[participant] = (game_diffs,\n weakest_links[participant],\n div_no_unstructured_by_round,\n divergence_ratio)\n\n return participant_differences","def test_using_ego_graph(self):\n assert_equal(nx.local_efficiency(self.G3), 7 / 12)","def build_graphs_each_team(df_all_stats, curr_year, curr_team):\n idx = (df_all_stats[curr_year]['Tm'] == curr_team) & (df_all_stats[curr_year]['MP_adv'] > 200)\n Team_df = df_all_stats[curr_year][['Player', 'AST', 'PS/G', 'Pos', 'MP']][idx]\n # can't keep everyone bc some rosters bigger than others so will mess up stats - taking the top 8 players\n Team_df = Team_df.sort_values(['MP'], ascending=False)\n Team_df = Team_df.iloc[0:8]\n curr_team_ast_pts = Team_df[['AST', 'PS/G']].values\n summed_ast_pts = curr_team_ast_pts.sum(axis=0)\n # lets make a matrix of all pairwise comparisons\n all_pairwise_edges = np.ndarray(shape= (np.shape(curr_team_ast_pts)[0], np.shape(curr_team_ast_pts)[0]))\n # build the ratio for edges = (100 * AST for a person / AST total) * (100 * PTS for a person / PTS total)\n for i in range(0, np.shape(curr_team_ast_pts)[0]):\n for j in range(0, np.shape(curr_team_ast_pts)[0]):\n# all_pairwise_edges[i,j] = (100 * curr_team_ast_pts[i][0]/summed_ast_pts[0])\n# * (100 * curr_team_ast_pts[j][1]/summed_ast_pts[1])\n all_pairwise_edges[i, j] = (curr_team_ast_pts[i][0]) * (curr_team_ast_pts[j][1])\n # for the nodes lets use player names\n pnames = Team_df['Player'].tolist()\n curr_positions = Team_df['Pos'].tolist()\n minutes_played = Team_df['MP'].tolist()\n ast_given = Team_df['AST'].tolist()\n node_size_use = Team_df['PS/G']\n node_size_use = node_size_use.as_matrix()\n G = nx.DiGraph()\n G.add_nodes_from(pnames)\n # to save the PS/G for node size later\n points_per_game = {}\n pos_ = {}\n mp_ = {}\n ast_ = {}\n for i in range(0, len(pnames)):\n points_per_game[pnames[i]] = node_size_use[i]\n pos_[pnames[i]] = curr_positions[i]\n mp_[pnames[i]] = minutes_played[i]\n ast_[pnames[i]] = ast_given[i]\n nx.set_node_attributes(G, points_per_game, 'ppg')\n nx.set_node_attributes(G, pos_, 'pos')\n nx.set_node_attributes(G, mp_, 'mp')\n nx.set_node_attributes(G, ast_, 'ast')\n labels_use = {}\n outward_vs_inward_direction = []\n for i in range(0, np.shape(curr_team_ast_pts)[0]):\n labels_use[pnames[i]] = pnames[i]\n# for j in range(0,np.shape(curr_team_ast_pts)[0]):\n# G.add_edge(pnames[i],pnames[j], weight= all_pairwise_edges[i,j])\n# G.add_edge(pnames[j],pnames[i], weight= all_pairwise_edges[j,i])\n for j in range(i+1, np.shape(curr_team_ast_pts)[0]):\n if (all_pairwise_edges[i, j] > all_pairwise_edges[j, i]) & (all_pairwise_edges[i, j] > 5):\n G.add_edge(pnames[i], pnames[j], weight=all_pairwise_edges[i, j])\n outward_vs_inward_direction.append('k')\n elif (all_pairwise_edges[j, i] > all_pairwise_edges[i, j]) & (all_pairwise_edges[j, i] > 5):\n G.add_edge(pnames[j], pnames[i], weight=all_pairwise_edges[j, i])\n outward_vs_inward_direction.append('k')\n return G","def match_detections(self, ground_truths, detections):\n\t\tif not ground_truths or not detections:\n\t\t\treturn (0.,0.,(0.,len(detections)), (0., len(ground_truths)))\n\n\t\tground_truths, detections = ObjectAreaEvaluator.prune_and_polygon(ground_truths, detections)\n\t\tground_truth_count = len(ground_truths)\n\t\tdetection_count = len(detections)\n\t\tif ground_truth_count == 0 or detection_count == 0:\n\t\t\treturn (0., 0., (0., float(detection_count)), (0., float(ground_truth_count)))\n\n\t\tprecision_matrix, recall_matrix = self.build_matrices(ground_truths, detections)\n\t\tground_truth_count = precision_matrix.shape[0]\n\t\tdetection_count = precision_matrix.shape[1]\n\t\tground_truth_sets_precision = defaultdict(set) # number of ground truth items that match a particular detection in the precision matrix\n\t\tdetection_sets_precision = defaultdict(set) # number of detection items that match a particular ground truth in the precision matrix\n\t\tground_truth_sets_recall = defaultdict(set) # number of ground truth items that match a particular detection in the recall matrix\n\t\tdetection_sets_recall = defaultdict(set) # number of detection items that match a particular ground truth in the recall matrix\n\n\t\tfor gt_index in range(ground_truth_count):\n\t\t\tfor det_index in range(detection_count):\n\t\t\t\tif precision_matrix[gt_index, det_index] >= self.precision_threshold:\n\t\t\t\t\tground_truth_sets_precision[det_index].add(gt_index)\n\t\t\t\t\tdetection_sets_precision[gt_index].add(det_index)\n\t\t\t\tif recall_matrix[gt_index, det_index] >= self.recall_threshold:\n\t\t\t\t\tground_truth_sets_recall[det_index].add(gt_index)\n\t\t\t\t\tdetection_sets_recall[gt_index].add(det_index)\n\n\t\tmatch_ground_truth = [[] for number in xrange(ground_truth_count)]\n\t\tmatch_detection = [[] for number in xrange(detection_count)]\n\n\t\tfor gt_index in detection_sets_precision:\n\t\t\tmatching_detections_precision = detection_sets_precision[gt_index]\n\t\t\tif len(matching_detections_precision) == 1:\n\t\t\t\t(detection_precision, ) = matching_detections_precision\n\t\t\t\tif len(ground_truth_sets_precision[detection_precision]) == 1:\n\t\t\t\t\tmatch_ground_truth[gt_index].append(detection_precision)\n\t\t\telse:\n\t\t\t\t# one-to-many (one ground truth to many detections)\n\t\t\t\tgt_sum = 0.\n\t\t\t\tfor detection_precision in matching_detections_precision:\n\t\t\t\t\tgt_sum += recall_matrix[gt_index, detection_precision]\n\t\t\t\tif gt_sum >= self.recall_threshold:\n\t\t\t\t\tfor detection_precision in matching_detections_precision:\n\t\t\t\t\t\tmatch_ground_truth[gt_index].append(detection_precision)\n\t\t\t\t\t\tmatch_detection[detection_precision].append(gt_index)\n\t\tfor det_index in ground_truth_sets_recall:\n\t\t\tmatching_ground_truths_recall = ground_truth_sets_recall[det_index]\n\t\t\tif len(matching_ground_truths_recall) == 1:\n\t\t\t\t(ground_truth_recall, ) = matching_ground_truths_recall\n\t\t\t\tif len(detection_sets_recall[ground_truth_recall]) == 1:\n\t\t\t\t\tmatch_detection[det_index].append(ground_truth_recall)\n\t\t\telse:\n\t\t\t\t# many-to-one (many ground truths covered by one detection)\n\t\t\t\tdet_sum = 0\n\t\t\t\tfor ground_truth_recall in matching_ground_truths_recall:\n\t\t\t\t\tdet_sum += precision_matrix[ground_truth_recall, det_index]\n\t\t\t\tif det_sum >= self.precision_threshold:\n\t\t\t\t\tfor ground_truth_recall in matching_ground_truths_recall:\n\t\t\t\t\t\tdet_sum += precision_matrix[ground_truth_recall, det_index]\n\t\t\t\t\t\tmatch_detection[det_index].append(ground_truth_recall)\n\t\t\t\t\t\tmatch_ground_truth[ground_truth_recall].append(det_index)\n\t\treturn match_ground_truth, match_detection","def no_match():\n S1=Spectrum.Spectrum()\n S1.add_peak(50.7,234)\n S1.add_peak(54.6,585)\n S1.add_peak(60.7,773)\n S1.add_peak(65.6,387)\n S1.add_peak(87.7,546)\n S1.add_peak(104.6,598)\n S1.pep_mass=100\n S1.euclidean_scale()\n\n S2=Spectrum.Spectrum()\n S2.add_peak(50.2,234)\n S2.add_peak(53.8,585)\n S2.add_peak(61.3,773)\n S2.add_peak(66.2,387)\n S2.add_peak(88.1,546)\n S2.add_peak(103.9,598)\n S2.pep_mass=100\n S2.euclidean_scale()\n\n score,peaks=similarity.cosine_score_max(S1,S2)\n assert peaks==0, \"Incorrect number of peaks matched with greedy method\"\n assert score==0, \"Incorrect score with greedy method\"\n \n\n score,peaks=similarity.cosine_score_greedy(S1,S2)\n assert peaks==0, \"Incorrect number of peaks matched with maximum weighted method\"\n assert score==0, \"Incorrect score with maximum weighted method\"","def main():\n with open(sys.argv[1], 'r') as test_cases:\n\n # Initialize possible pairs, pairs, and social graph Graph\n possible_pairs = set()\n pairs = set()\n social_graph = Graph()\n\n # Find true pairs of sender, recipient and vice versa for graph\n for test in test_cases:\n # Parse line into sender, recipient\n parsed_line = test.rstrip().split('\\t')\n sender, recipient = parsed_line[1], parsed_line[2]\n\n # Determine which sender, recipient reciprocal pairs exist\n # Candidates are tested against possible pairs\n # True pairs are stored in pairs\n if (recipient, sender) in possible_pairs:\n pairs.add(frozenset({x for x in (sender, recipient)}))\n else:\n possible_pairs.add((sender, recipient))\n\n # From pairs, add to social graph\n for pair in pairs:\n u, v = pair\n social_graph.add_pair(u, v)\n\n # Compute maximal cliques of size >= 3 only\n max_cliques_gt_3 = [\n clique\n for clique in social_graph.max_cliques()\n if len(clique) >= 3]\n\n # Sort maximal cliques, ascending, and pretty print\n for cluster in sorted(map(\n lambda x: \", \".join(sorted(x)),\n max_cliques_gt_3)):\n print cluster","def test_grovers_minimal_basis_gates(self):\n shots = 2000\n circuits = ref_algorithms.grovers_circuit(final_measure=True,\n allow_sampling=True)\n targets = ref_algorithms.grovers_counts(shots)\n job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='U,CX')\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)","def score(tmp_dir, locusList, ranges):\r\n\t\r\n\tloc = ''\r\n\tpos = 1\r\n\tcount_indel = 0\r\n\tholes = 0\r\n\tsnps = 0\r\n\tcovMax=combined_covMax=covSum=covSum2= 0 \r\n\tcovMin = combined_covMin =99999\r\n\tpercentage_coverages =[]\r\n\tsnpList = []\r\n\tindelList = []\r\n\tresults = {} \r\n\t\r\n\tpileup_file = os.path.join(tmp_dir, 'all.pileup')\r\n\tfor l in open(pileup_file):\r\n\t\tt = l.split()\r\n\t\tif loc == '':\r\n\t\t\tloc = t[0] \r\n\t\t\tpos = ranges[loc][0] + 1 \r\n\t\tif t[0] != loc:\r\n\t\t\tresults =GenerateResult(ranges,\r\n\t\t\t\t\t\t\t\t\tholes, locusList,\r\n\t\t\t\t\t\t\t\t\tloc,snps,count_indel,\r\n\t\t\t\t\t\t\t\t\tsnpList, indelList,\r\n\t\t\t\t\t\t\t\t\tpercentage_coverages,combined_covMin,\r\n\t\t\t\t\t\t\t\t\tcombined_covMax, covMin, covMax,covSum, results)\r\n\t\t\t# reset locus vars\r\n\t\t\tloc = t[0] \r\n\t\t\tpos = ranges[loc][0] + 1 \r\n\t\t\tcount_indel = 0\r\n\t\t\tholes =snps=covMax=combined_covMax=covSum=covSum2= 0 \r\n\t\t\tcovMin =combined_covMin= 99999\r\n\t snpList = []\r\n\t\t\tindelList = []\r\n\t\t\tpercentage_coverages =[]\r\n\t\there = int(t[1])\r\n\t\tif here - 1 < ranges[loc][0]: \r\n\t\t\tcontinue\r\n\t\telif here - 1 >= ranges[loc][1]: \r\n\t\t\tcontinue\r\n\t\twhile pos < here: \r\n\t\t\tholes += 1 \r\n\t\t\tpos += 1\r\n\r\n\t\tv, indel, array_of_all_indels,most_common_indel = pile(t[2], t[4])\r\n\t\tx = v.items()\r\n\t\tx.sort(lambda a,b: compGreater(t[2], a, b))\r\n\t\t\r\n\t\tif x[0][0] != t[2].lower():\r\n\t\t\tsnps += 1\r\n\t\t\tsnpList.append((pos,t[2],v));\r\n\t\tc = x[0][1] \r\n\t\tcov= int(most_common_indel)/float(t[3]) \r\n\t\tif cov > 0.5: \r\n count_indel += 1\r\n indel_type = Counter(array_of_all_indels) \r\n indel_type = indel_type.items()\r\n indelList.append((int(pos),t[2], indel_type))\r\n\t\tcovSum += c \r\n\t\tcovSum2 += c * c\r\n\t\tif c > covMax:\r\n\t\t\tcovMax = c\r\n\t\tif c < covMin:\r\n\t\t\tcovMin = c\r\n\t\tcombined_c = x[0][1] + x[1][1] + x[2][1] + x[3][1] \r\n\t\tif combined_c > combined_covMax:\r\n\t\t\tcombined_covMax = c \r\n\t\tif combined_c < combined_covMin:\r\n\t\t\tcombined_covMin = c \r\n\t\t\r\n\t\tn = int(t[3]) \r\n\t\tjs = []\r\n\t\tfor (_,j) in x[1:]: \r\n\t\t\tjs.append(j) \r\n\t\tpercentage_coverage = sum(js)/float(n)*100 \r\n\t\tpercentage_coverages.append(round(float(percentage_coverage),2))\r\n\t\tpos = here + 1\r\n\tresults =GenerateResult(ranges,\r\n\t\t\t\t\t\t\tholes,\r\n\t\t\t\t\t\t\tlocusList,loc,\r\n\t\t\t\t\t\t\tsnps,count_indel,\r\n\t\t\t\t\t\t\tsnpList,indelList,\r\n\t\t\t\t\t\t\tpercentage_coverages,combined_covMin,\r\n\t\t\t\t\t\t\tcombined_covMax, covMin, covMax,\r\n\t\t\t\t\t\t\tcovSum, results)\r\n\t\r\n\treturn results","def pc_edge_q_figure(tasks = ['REST','WM','GAMBLING','RELATIONAL','MOTOR','LANGUAGE','SOCIAL']):\n\tdriver = 'PC'\n\tproject='hcp'\n\ttasks = ['REST','WM','GAMBLING','RELATIONAL','MOTOR','LANGUAGE','SOCIAL']\n\tatlas = 'power'\n\trun_version = 'fz'\n\tknown_membership,network_names,num_nodes,name_int_dict = network_labels(atlas)\n\tq_corr_matrix = []\n\tpc_corr_matrix = []\n\t#order by primary versus secondary networks. \n\tnetwork_order = ['Auditory','Sensory/somatomotor Hand','Sensory/somatomotor Mouth','Visual','Dorsal attention','Ventral attention',\n\t'Cingulo-opercular Task Control','Salience','Fronto-parietal Task Control','Default mode','Cerebellar','Subcortical','Memory retrieval?','Uncertain']\n\tcolors = np.array(pd.read_csv('%smodularity/Consensus264.csv'%(homedir),header=None)[34].values)\n\tcolors[colors=='Pale blue'] = '#ADD8E6'\n\tcolors[colors=='Teal'] = '#008080'\n\tswap_indices = []\n\tfor nn in network_order:\n\t\toriginal_idx = np.where(network_names == nn)\n\t\tfor i in range(len(original_idx[0])):\n\t\t\tswap_indices.append(original_idx[0][i])\n\tlocality_df = pd.DataFrame()\n\tstats = []\n\tfor task in tasks:\n\t\tprint task\n\t\tsubjects = np.load('%sdynamic_mod/results/%s_%s_%s_subs_%s.npy' %(homedir,project,task,atlas,run_version))\n\t\tstatic_results = graph_metrics(subjects,task,atlas,run_version)\n\t\tsubject_pcs = static_results['subject_pcs']\n\t\tsubject_mods = static_results['subject_mods']\n\t\tsubject_wmds = static_results['subject_wmds']\n\t\tmatrices = static_results['matrices']\n\t\tassert subject_pcs.shape[0] == len(subjects)\n\t\tmean_pc = np.nanmean(subject_pcs,axis=0)\n\t\tmean_wmd = np.nanmean(subject_wmds,axis=0)\n\t\tmod_pc_corr = np.zeros(subject_pcs.shape[1])\n\t\tfor i in range(subject_pcs.shape[1]):\n\t\t\tmod_pc_corr[i] = nan_pearsonr(subject_mods,subject_pcs[:,i])[0]\n\t\tmod_wmd_corr = np.zeros(subject_wmds.shape[1])\n\t\tfor i in range(subject_wmds.shape[1]):\n\t\t\tmod_wmd_corr[i] = nan_pearsonr(subject_mods,subject_wmds[:,i])[0]\n\t\tif driver == 'PC': m = np.load('%s/dynamic_mod/results/full_med_matrix_new_%s.npy'%(homedir,task))\n\t\telse: m = np.load('%s/dynamic_mod/results/full_med_matrix_new_%s_wmds.npy'%(homedir,task))\n\t\tmean_conn = np.nanmean(matrices,axis=0)\n\t\te_tresh = np.percentile(mean_conn,85)\n\t\tfor i in range(264):\n\t\t\treal_t = scipy.stats.ttest_ind(np.abs(m)[i][np.argwhere(mean_conn[i]>=e_tresh)][:,:,np.arange(264)!=i].reshape(-1),np.abs(m)[i][np.argwhere(mean_conn[i]<e_tresh)][:,:,np.arange(264)!=i].reshape(-1))[0]\n\t\t\t# real_t = scipy.stats.ttest_ind(m[i][np.argwhere(mean_conn[i]>=e_tresh)][:,:,np.arange(264)!=i].reshape(-1),m[i][np.argwhere(mean_conn[i]<e_tresh)][:,:,np.arange(264)!=i].reshape(-1))[0]\n\t\t\tif mod_pc_corr[i] > 0.0:\n\t\t\t\tlocality_df = locality_df.append({\"Node Type\":'Connector Hub','t':real_t,'Task':task.capitalize()},ignore_index=True)\n\t\t\telse:\n\t\t\t\tlocality_df = locality_df.append({\"Node Type\":'Local Node','t':real_t,'Task':task.capitalize()},ignore_index=True)\n\t\tlocality_df.dropna(inplace=True)\n\t\tif driver == 'PC':\n\t\t\tpredict_nodes = np.where(mod_pc_corr>0.0)[0]\n\t\t\tlocal_predict_nodes = np.where(mod_pc_corr<0.0)[0]\n\t\t\tpc_edge_corr = np.arctanh(pc_edge_correlation(subject_pcs,matrices,path='%s/dynamic_mod/results/%s_%s_%s_pc_edge_corr_z.npy' %(homedir,project,task,atlas)))\n\t\tif driver == 'WMD':\n\t\t\tpredict_nodes = np.where(mod_wmd_corr>0.0)[0]\n\t\t\tlocal_predict_nodes = np.where(mod_wmd_corr<0.0)[0]\n\t\t\tpc_edge_corr = np.arctanh(pc_edge_correlation(subject_wmds,matrices,path='%s/dynamic_mod/results/%s_%s_%s_wmd_edge_corr_z.npy' %(homedir,project,task,atlas)))\n\t\tn_nodes = pc_edge_corr.shape[0]\n\t\tq_edge_corr = np.zeros((n_nodes,n_nodes))\n\t\tperf_edge_corr = np.zeros((n_nodes,n_nodes))\n\t\tfor i,j in combinations(range(n_nodes),2):\n\t\t\tijqcorr = nan_pearsonr(matrices[:,i,j],subject_mods)[0]\n\t\t\tq_edge_corr[i,j] = ijqcorr\n\t\t\tq_edge_corr[j,i] = ijqcorr\n\t\t# \tcontinue\n\t\t# \tif task not in ['WM','RELATIONAL','SOCIAL','LANGUAGE']:\n\t\t# \t\tcontinue\n\t\t# \tijqcorr = nan_pearsonr(matrices[:,i,j],task_perf)[0]\n\t\t# \tperf_edge_corr[i,j] = ijqcorr\n\t\t# \tperf_edge_corr[j,i] = ijqcorr\n\t\tpc_corr_matrix.append(np.nanmean(pc_edge_corr[predict_nodes,:,:],axis=0))\n\t\tq_corr_matrix.append(q_edge_corr)\n\t\t# if task in ['WM','RELATIONAL','SOCIAL','LANGUAGE']:\n\t\t\t# print nan_pearsonr(perf_edge_corr.reshape(-1),np.nanmean(pc_edge_corr[predict_nodes,:,:],axis=0).reshape(-1))\n\t\t\t# plot_corr_matrix(perf_edge_corr[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file='%s/dynamic_mod/figures/%s_%s_edge_perf_corr_matrix.pdf'%(homedir,task,run_version),reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\n\t\t# plot_corr_matrix(np.nanmean(m[predict_nodes,:,:],axis=0)[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file='%s/dynamic_mod/figures/%s_%s_%s_mediation_matrix.pdf'%(homedir,task,driver,run_version),reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\n\t\t# plot_corr_matrix(np.nanmean(pc_edge_corr[predict_nodes],axis=0)[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file='%s/dynamic_mod/figures/%s_%s_pcedge__corr_matrix.pdf'%(homedir,task,run_version),reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\n\t\t# plot_corr_matrix(q_edge_corr[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file='%s/dynamic_mod/figures/%s_%s_%s_qedgecorr_matrix.pdf'%(homedir,task,driver,run_version),reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\n\tplot_corr_matrix(np.nanmean(q_corr_matrix,axis=0)[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file='%s/dynamic_mod/figures/%s_mean_q_corr_matrix.pdf'%(homedir,run_version),reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\n\tplot_corr_matrix(np.nanmean(pc_corr_matrix,axis=0)[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file='%s/dynamic_mod/figures/%s_mean_pc_corr_matrix.pdf'%(homedir,run_version),reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\n\tplot_corr_matrix(np.nanmean(m[predict_nodes,:,:],axis=0)[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file='%s/dynamic_mod/figures/%s_%s_mean_mediation_matrix_withbar.pdf'%(homedir,driver,run_version),reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\t\n\t# plot_corr_matrix(np.nanmean(pc_corr_matrix,axis=0)[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file=None,reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\n\tf = sns.plt.figure(figsize=(18,6))\n\tsns.set_style(\"white\")\n\tsns.set_style(\"ticks\")\n\tsns.set(context=\"paper\",font='Helvetica',font_scale=1.2)\n\tsns.violinplot(data=locality_df[locality_df['Node Type']=='Connector Hub'],x='Task',y='t',hue='Task',inner='quartile',palette=sns.palettes.color_palette('Paired',7))\n\tsns.plt.ylabel(\"T Test Values, mediation values of node's nieghbors \\n versus mediation of node's non-neighbors\")\n\tsns.plt.legend(bbox_to_anchor=[1,1.05],ncol=7,columnspacing=10)\n\tsns.plt.savefig('%s/dynamic_mod/figures/%s_mediation_t_test.pdf'%(homedir,run_version))\n\tsns.plt.show()\n\n\t# plot_corr_matrix(mean_conn[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file=None,reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)","def minimumTeachings(self, n: int, languages: List[List[int]], friendships: List[List[int]]) -> int:\n def dfs(p):\n if p == m + 1:\n return 0\n candi = set()\n for q in f_edges[p]:\n if q > p and not l_edges[p] & l_edges[q]:\n candi |= l_edges[q]\n if not candi:\n return dfs(p + 1)\n res = float('inf')\n for lang in candi:\n # l_edges[p].add(lang)\n res = min(res, 1 + dfs(p + 1))\n # l_edges[p].remove(lang)\n # print(p, candi, res, l_edges)\n return res\n\n f_edges = defaultdict(set)\n m = len(languages)\n for p, q in friendships:\n f_edges[p].add(q)\n f_edges[q].add(p)\n l_edges = defaultdict(set)\n\n for i, lst in enumerate(languages, 1):\n l_edges[i] = set(lst)\n print('f_edges', f_edges)\n print('l_edges', l_edges)\n return dfs(1)","def check_stats(mc, div_ratio, max_depth, num_iters=1000, num_cpus=1, plot=False):\n a_samples, b_samples = (int(mc.num_a / div_ratio), int(mc.num_b / div_ratio))\n div = (30, 10) # num_samples / x per region\n new_mc = mc.subsample(a_samples, b_samples)\n new_mc.create_connections()\n args_dict = new_mc.compute_stats()\n print_args_dict(args_dict, out=True)\n\n num_samples = np.ceil([a_samples / div[0], b_samples / div[1]]).astype(np.int32)\n print(\"Sampling {}\".format(num_samples))\n\n if plot:\n nx_graph = nx_create_graph(new_mc.graph)\n start, end = new_mc.gen_random_samples(num_samples, zeroed=False)\n os.makedirs(os.path.join(here, \"..\", \"figures\"), exist_ok=True)\n nx_vis_force(\n nx_graph,\n new_mc.a_indices,\n new_mc.num_a + new_mc.b_indices,\n start,\n end,\n name=os.path.join(here, \"..\", \"figures\", \"mouse_graph_small.png\"),\n )\n\n def random_var_gen(iter_val):\n start, end = new_mc.gen_random_samples(num_samples, zeroed=False)\n return start, end\n\n def fn_to_eval(start, end):\n reachable = find_connected_limited(\n new_mc.graph, start, end, max_depth=max_depth\n )\n return (len(reachable),)\n\n # Stats check\n args_dict[\"max_depth\"] = max_depth\n args_dict[\"total_samples\"] = num_samples[0]\n args_dict[\"static_verbose\"] = False\n cp = CombProb(\n new_mc.num_a,\n float(num_samples[0]),\n new_mc.num_senders,\n new_mc.num_b,\n float(num_samples[1]),\n MatrixConnectivity.static_expected_connections,\n verbose=False,\n **args_dict,\n )\n result_mpf = {\n \"expected\": cp.expected_connections(),\n \"total\": cp.get_all_prob(),\n }\n\n result = monte_carlo(fn_to_eval, random_var_gen, num_iters, num_cpus=num_cpus)\n df = list_to_df(\n result,\n [\"Connections\"],\n )\n result = summarise_monte_carlo(\n df,\n plot=False,\n )\n ordered_dist = get_distribution(df, \"Connections\", num_iters)\n\n return {\n \"full_results\": df,\n \"summary_stats\": result,\n \"dist\": ordered_dist,\n \"mpf\": result_mpf,\n \"difference\": dist_difference(result_mpf[\"total\"], ordered_dist),\n }","def test_count_neighbors(self):\n m, n = 5, 5\n k, p = 0.2, 0.7\n agents = [ConwayAgent(ii, ii & 0x1 == 1) for ii in range(m * n)]\n C = ConwayModel(m, n, k, p, agents)\n\n to_count = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]])\n expected = np.array([[1, 1, 2], [2, 3, 1], [0, 2, 1]])\n result = C.count_neighbors(to_count)\n self.assertTrue(np.all(expected == result))","def rule154_network():\n # fmt: off\n tpm = np.array([\n [0, 0, 0, 0, 0],\n [0, 1, 0, 0, 1],\n [1, 0, 1, 0, 0],\n [1, 0, 1, 0, 1],\n [0, 1, 0, 1, 0],\n [0, 0, 0, 1, 1],\n [1, 1, 0, 1, 0],\n [1, 1, 0, 1, 1],\n [0, 0, 1, 0, 1],\n [0, 1, 1, 0, 0],\n [1, 0, 0, 0, 1],\n [1, 0, 0, 0, 0],\n [0, 1, 1, 0, 1],\n [0, 0, 1, 0, 0],\n [1, 1, 1, 0, 1],\n [1, 1, 1, 0, 0],\n [1, 0, 0, 1, 0],\n [0, 1, 0, 1, 1],\n [0, 0, 1, 1, 0],\n [1, 0, 1, 1, 1],\n [1, 1, 0, 0, 0],\n [0, 0, 0, 0, 1],\n [0, 1, 0, 0, 0],\n [1, 1, 0, 0, 1],\n [1, 0, 1, 1, 0],\n [0, 1, 1, 1, 1],\n [0, 0, 0, 1, 0],\n [1, 0, 0, 1, 1],\n [1, 1, 1, 1, 0],\n [0, 0, 1, 1, 1],\n [0, 1, 1, 1, 0],\n [1, 1, 1, 1, 1],\n ])\n cm = np.array([\n [1, 1, 0, 0, 1],\n [1, 1, 1, 0, 0],\n [0, 1, 1, 1, 0],\n [0, 0, 1, 1, 1],\n [1, 0, 0, 1, 1],\n ])\n # fmt: on\n return Network(tpm, cm=cm, node_labels=LABELS[:tpm.shape[1]])","def calc_skill_clusters(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, SOM_clusters_block, seas):\r\n ds_arr_ones = []\r\n for clus in SOM_clusters_block:\r\n node_cluster_set_test = [clus]\r\n node_cluster_set_test_str = [str(clus).replace(',', '') for clus in node_cluster_set_test]\r\n #calculate the blocked days which the new cluster determines\r\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\r\n #define as DataArray and select JJA to remove the extended days included for classifying blocks\r\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \"blocking\", dims={\"time\": GTD['time']})\r\n blocked_days_clus_xr['time'] = GTD['time']\r\n blocked_days_clus_seas = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\r\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_seas)\r\n #calculate precision, recall and F1\r\n if len(str(node_cluster_set_test)) == 1:\r\n comb_str = f\"{node_cluster_set_test[0]}\".replace(\"'\", \"\")\r\n else:\r\n comb_str = f\"{str(node_cluster_set_test)[1:-1]}\".replace(\"'\", \"\") \r\n ds=xr.Dataset({'precision': prec, 'recall': recall, 'F1': F1, 'clus_num': int(len(node_cluster_set_test)), 'set': str(comb_str)})\r\n ds_arr_ones.append(ds)\r\n blocks_one_clusnum = xr.concat(ds_arr_ones, dim = \"set\")\r\n return blocks_one_clusnum","def make_set_cover_pos(gRNA_hits, num_sets = 1, target_ids = [], algorithm = \"LAR\",\n id_key = lambda x: x, tie_breaker = tie_break_first, suppress_warning = False):\n # exclude_seqs = set(str(s).upper() for s in exclude_seqs)\n # gRNA_coverage = {seq: hits for seq, hits in gRNA_hits.hits.items()\n # if str(seq).upper() not in exclude_seqs}\n gRNA_coverage = gRNA_hits.hits\n eliminated_gRNA = {}\n ## prepare target ids\n if not target_ids:\n target_ids = set(hit.target_id for hit in gRNA_hits.flatten_hits())\n else:\n target_ids = set(target_ids)\n ## selected set cover algorithm\n if algorithm in (\"LAR\", \"greedy\"):\n set_cover_algo = set_cover_LAR if algorithm == \"LAR\" else set_cover_greedy\n else:\n raise Exception(f\"Invalid algorithm name: '{algorithm}'\")\n def coverage_possible():\n return set(id_key(hit) for hits in gRNA_coverage.values() for hit in hits) >= set(target_ids)\n ## function to generate set covers\n def make_set_cover(restore = []):\n for grna in restore:\n gRNA_coverage[grna.seq] = eliminated_gRNA[grna.seq]\n if not coverage_possible():\n if not suppress_warning:\n print((\"\\nError: The provided gRNA sequences cannot cover all target sequences\"\n \" at least once.\\n\"))\n return []\n selected_grnas = set_cover_algo(gRNA_coverage, target_ids, id_key = id_key, tie_breaker = tie_breaker)\n ## remove selected gRNA from candidates, and covert to gRNA object\n output = []\n for grna_seq in selected_grnas:\n ## remove\n eliminated_gRNA[grna_seq] = gRNA_coverage[grna_seq]\n del gRNA_coverage[grna_seq]\n ## convert gRNA sequences to gRNA object\n grna_seq_obj = gRNA_hits.get_gRNAseq_by_seq(grna_seq)\n output.append(gRNA(grna_seq_obj.id, grna_seq_obj))\n return output\n return make_set_cover","def Test_NumNodes(Graph_MD):\n N_Knoten = Graph_MD.number_of_nodes()\n \n return N_Knoten","def compute_small_worldness(G, metric, niter=100, nrand=5, seed=None):\n G = max(nx.connected_component_subgraphs(G), key=len)\n\n if metric == 'omega':\n small_worldness = nx.algorithms.smallworld.omega(G,\n niter=niter,\n nrand=nrand,\n seed=seed)\n elif metric == 'sigma':\n small_worldness = nx.algorithms.smallworld.sigma(G,\n niter=niter,\n nrand=nrand,\n seed=seed)\n else:\n raise ValueError('Small world metric not available.')\n return small_worldness","def dissimilarity(clusters):\n totDist = 0\n for c in clusters:\n totDist += c.variability()\n return totDist","def is_modern(self):\n G = self.poset().hasse_diagram()\n for x in G:\n nx = list(G.neighbors_in(x))\n nx.append(x)\n if min(nx) < x and max(nx) > x:\n return False\n return True","def distance_score(vertex1, board, player_id): #implement preference for closer settlements\n num_buildings = 0\n total_dist = 0\n player_buildings = board.get_player_settlements(player_id) + board.get_player_cities(player_id)\n\n if len(player_buildings) == 0: #if it is our first turn\n return 0\n\n player_roads = board.get_player_roads(player_id)\n accessible_vertices = list(set(player_buildings+ [vertex for pair in player_roads for vertex in pair]))\n get_distance = lambda v: manhattan_distance(v, vertex1, board)\n min_distance = min(map(get_distance, accessible_vertices))\n\n enemy_buildings = [v for v in board.settlements if board.settlements[v] != player_id]\n enemy_roads = [r for r in board.roads if board.roads[r] != player_id]\n\n\n \"\"\"\n for s in board.settlements:\n if board.settlements[s] != player_id:\n vertex2 = s\n total_dist_enemies += manhattan_distance(vertex1, vertex2, board)\n num_buildings+=1\n\n for c in board.cities:\n if board.cities[c] != player_id:\n vertex2 = c\n total_dist_enemies += manhattan_distance(vertex1, vertex2, board)\n num_buildings+=1\n\n \"\"\"\n return min_distance","def test_all_used(self):\n # diagram:\n # \n # c1\n # c3\n # c2\n n = self._process(\"\"\"\nclass c1 \"C1\"\nclass c2 \"C2\"\nclass c3 \"C3\"\n\n:layout:\n right g1: c1 c3\n left g2: c3 c2\n\"\"\")\n c1 = find_style(n, 'c1')\n c2 = find_style(n, 'c2')\n c3 = find_style(n, 'c3')\n\n self._check_c_not(MiddleEq, c1, c3)\n self._check_c_not(MinHDist, c1, c3)","def evaluate(model, graph, test_set, true_triples, num_nodes, batch_size=16, hits_at_k=[1, 3, 10], filter_candidates=True, verbose=True):\n\n device = 'cuda' if torch.cuda.is_available() else 'cpu'\n\n rng = tqdm.trange if verbose else range\n\n ranks = []\n for head in [True, False]: # head or tail prediction\n\n for fr in rng(0, len(test_set), batch_size):\n to = min(fr + batch_size, len(test_set))\n\n batch = test_set[fr:to, :].to(device=device)\n bn, _ = batch.size()\n\n # compute the full score matrix (filter later)\n bases = batch[:, 1:] if head else batch[:, :2]\n targets = batch[:, 0] if head else batch[:, 2]\n\n # collect the triples for which to compute scores\n bexp = bases.view(bn, 1, 2).expand(bn, num_nodes, 2)\n ar = torch.arange(num_nodes, device=device).view(1, num_nodes, 1).expand(bn, num_nodes, 1)\n toscore = torch.cat([ar, bexp] if head else [bexp, ar], dim=2)\n assert toscore.size() == (bn, num_nodes, 3)\n\n scores, _ = model(graph, toscore)\n assert scores.size() == (bn, num_nodes)\n\n # filter out the true triples that aren't the target\n if filter_candidates:\n filter_scores(scores, batch, true_triples, head=head)\n\n # Select the true scores, and count the number of values larger than than\n true_scores = scores[torch.arange(bn, device=device), targets]\n raw_ranks = torch.sum(scores > true_scores.view(bn, 1), dim=1, dtype=torch.long)\n # -- This is the \"optimistic\" rank (assuming it's sorted to the front of the ties)\n num_ties = torch.sum(scores == true_scores.view(bn, 1), dim=1, dtype=torch.long)\n\n # Account for ties (put the true example halfway down the ties)\n branks = raw_ranks + (num_ties - 1) // 2\n\n ranks.extend((branks + 1).tolist())\n\n mrr = sum([1.0/rank for rank in ranks])/len(ranks)\n\n hits = []\n for k in hits_at_k:\n hits.append(sum([1.0 if rank <= k else 0.0 for rank in ranks]) / len(ranks))\n\n return mrr, tuple(hits), ranks","def cal_pn(grams_set, grams, candidate, reference):\n count = 0\n for gram in grams_set:\n # print(gram)\n count += count_clip(gram, grams, reference)\n # calculate log() for p, so '+10**-8' avoid 'p==0'\n p = count / len(grams) + 10**-8 \n return p","def part1c_0():\n xs = exampleInput\n T = submission.computeEdgeMarginals(simpleCRF, xs)\n for t in T:\n grader.requireIsEqual( 1.0, sum(t.values()) )","def test_is_gsp_satisfied(self):\n mask_conv = MaskConv2d(32, 32, 3)\n\n self.assertTrue(is_gsp_satisfied(mask_conv, 1))\n self.assertFalse(is_gsp_satisfied(mask_conv, 2))\n\n mask_conv.mask.data[:16, :16] = 0\n mask_conv.mask.data[16:, 16:] = 0\n self.assertTrue(is_gsp_satisfied(mask_conv, 2))\n\n mask_conv.mask.data[15, 15] = 1\n mask_conv.mask.data[15, 16] = 0\n mask_conv.mask.data[16, 15] = 1\n mask_conv.mask.data[16, 16] = 0\n self.assertFalse(is_gsp_satisfied(mask_conv, 2))\n self.assertIsNone(get_group_allocation(mask_conv.mask, 2)[0])\n self.assertIsNone(get_group_allocation(mask_conv.mask, 2)[1])","def worst_atom(self, g_u, g_v, active_set):\n\n max_w = None\n max_m_w = None\n max_n_w = None\n max_score = -float('inf')\n\n for w in active_set:\n m_w, n_w = self.polytope.vertex(w)\n score_w = np.sum(g_u * m_w) + np.sum(g_v * n_w)\n\n if score_w > max_score:\n max_w = w\n max_m_w = m_w\n max_n_w = n_w\n max_score = score_w\n\n return max_w, max_m_w, max_n_w","def cost(graph, gates_qubits_pairs):\n for allowed, gate in enumerate(gates_qubits_pairs):\n if gate not in graph.edges():\n break\n return len(gates_qubits_pairs) - allowed","def testSameRMSEWhenPairsAreSpecifiedOrNot(self):\n test_class1 = TrimmedMatchGeoXDesign(\n GeoXType.HEAVY_UP,\n pretest_data=self.nontrivial_data,\n time_window_for_design=self.design_window,\n time_window_for_eval=self.evaluation_window,\n matching_metrics={'response': 1.0},\n pairs=None)\n\n for geox_type in GeoXType:\n if geox_type == GeoXType.CONTROL:\n continue\n\n test_class1._geox_type = geox_type\n _, expected_detailed_results = test_class1.report_candidate_designs(\n budget_list=[30, 40],\n iroas_list=[0, 2],\n use_cross_validation=True,\n num_simulations=10)\n\n test_class2 = TrimmedMatchGeoXDesign(\n geox_type,\n pretest_data=self.nontrivial_data,\n time_window_for_design=self.design_window,\n time_window_for_eval=self.evaluation_window,\n matching_metrics={'response': 1.0},\n pairs=test_class1.pairs)\n _, detailed_results = test_class2.report_candidate_designs(\n budget_list=[30, 40],\n iroas_list=[0, 2],\n use_cross_validation=True,\n num_simulations=10)\n\n for key in detailed_results.keys():\n self.assertTrue(\n np.array_equal(detailed_results[key]['estimate'],\n expected_detailed_results[key]['estimate']))","def check_consistency(precision, index_calls, father_calls, mother_calls):\n\n def to_str(hla):\n return hla.prec_str(precision)\n\n mismatches = 0\n for gene in 'ABC':\n summand = 0\n index_set = set(map(to_str, index_calls[gene]))\n father_set = set(map(to_str, father_calls[gene]))\n mother_set = set(map(to_str, mother_calls[gene]))\n if father_calls and mother_calls:\n # have both mother and father calls, more complex\n # print('index', index_set, 'father', father_set, 'mother',\n # mother_set)\n if not index_set & father_set:\n summand = 1\n if not index_set & mother_set:\n summand = max(summand, 1)\n if len(index_set) == 1:\n if not index_set & father_set or not index_set & mother_set:\n summand = 2\n else:\n summand = 2 - len(index_set & (mother_set | father_set))\n # print('gene {} summand {}'.format(gene, summand),\n # file=sys.stdout)\n else:\n # have only one calls, easier\n either_set = father_set or mother_set\n if not either_set & index_set:\n summand = 1\n mismatches += summand\n return mismatches","def find_progenitors_at_z(self, SH, mtree, z1, z2):\n \n for ss in range(z1, z2):\n # nodes at redshift ss\n ss_indx = np.where(mtree.data.snapshotNumber.values == ss)\n nodeID = mtree.data.index.values[ss_indx]\n nodeID_desc = mtree.data.descendantIndex.values[ss_indx]\n \n # find number of progenitors for nodes at redshift ss\n if ss != z1:\n _progcounts = np.zeros(len(nodeID))\n for ii in range(len(nodeID_past_desc)):\n if nodeID_past_desc[ii] in nodeID:\n indx = np.where(nodeID == nodeID_past_desc[ii])\n _progcounts[indx] = count[ii]\n\n nodeID_desc_unique, count = np.unique(nodeID_desc, return_counts=True)\n nodeID_desc_unique=nodeID_desc_unique[1:]; count=count[1:]\n \n nodeID_past = nodeID\n nodeID_past_desc = nodeID_desc_unique\n if ss != z1:\n _progcounts_past = _progcounts\n print('_progcounts', _progcounts)","def compare_graphs(self):\n\t\tpass"],"string":"[\n \"def mapping_quality(graph, spanset, gapset):\\n the_sum = sum(sum(1 for edge in graph.edges(node) if edge[1] in gapset) for node in spanset)\\n # if directed graph, uncomment this:\\n #the_sum += sum(sum(1 for edge in graph.edges(node) if edge[1] in spanset) for node in gapset)\\n return the_sum\",\n \"def compare(self):\\n len0 = len(self.cluster_lists[0])\\n len1 = len(self.cluster_lists[1])\\n longer_index = 0 if len0 >= len1 else 1\\n shorter_index = 1 if len1 <= len0 else 0\\n self.stars_length = len(self.cluster_lists[shorter_index]) \\n self.starlets_length = len(self.cluster_lists[longer_index]) \\n # build the noeds for shorter cluster list, and get the\\n # distribution of cluster size.\\n for cluster in self.cluster_lists[shorter_index]:\\n len_spectra = len(cluster.get_spectra())\\n star = ClusterNode(cluster.id, len_spectra) \\n self.stars[cluster.id] = star\\n\\n self.cluster_spectra_num[shorter_index] += len_spectra\\n self.cluster_size_dist[shorter_index][len_spectra] = self.cluster_size_dist[shorter_index].get(len_spectra,0) + 1\\n # build the noeds for longer cluster list, and get the\\n # distribution of cluster size.\\n for cluster in self.cluster_lists[longer_index]:\\n len_spectra = len(cluster.get_spectra())\\n starlet = ClusterNode(cluster.id, len_spectra) \\n self.starlets[cluster.id] = starlet\\n\\n self.cluster_spectra_num[longer_index] += len_spectra\\n self.cluster_size_dist[longer_index][len_spectra] = self.cluster_size_dist[longer_index].get(len_spectra,0) + 1\\n # do the comparing, and network building\\n for i in range (0, len(self.cluster_lists[shorter_index])):\\n cluster0 = self.cluster_lists[shorter_index][i] \\n for j in range (i, len(self.cluster_lists[longer_index])):\\n cluster1 = self.cluster_lists[longer_index][j] \\n (shared_spec_num, similarity) = self.calculate_similarity(cluster0, cluster1)\\n if similarity == 0:\\n continue\\n self.similarity_dist[int(similarity*10)] = self.similarity_dist.get(int(similarity*10),0) + 1\\n self.shared_spec_num += shared_spec_num\\n\\n self.stars[cluster0.id].add_nb_node(cluster1.id, similarity, shared_spec_num)\\n self.starlets[cluster1.id].add_nb_node(cluster0.id, similarity, shared_spec_num)\\n\\n self.ave_star_size = self.cluster_spectra_num[shorter_index]/self.stars_length\\n self.ave_starlet_size = self.cluster_spectra_num[longer_index]/self.starlets_length\",\n \"def communities_with_protesters(partition, active_nodes):\\n return len(set([partition[node] for node in active_nodes]))\",\n \"def community_detection(net_G):\\r\\n if list(nx.isolates(net_G)) == []:\\r\\n part = community.best_partition(net_G)\\r\\n #values = [part.get(node) for node in net_G.nodes()]\\r\\n #nx.draw_spring(net_G, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=False)\\r\\n #plt.show()\\r\\n else:\\r\\n net_G = net_G.copy()\\r\\n net_G.remove_nodes_from(list(nx.isolates(net_G)))\\r\\n part = community.best_partition(net_G)\\r\\n list_nodes = []\\r\\n for com in set(part.values()):\\r\\n list_nodes.append([nodes for nodes in part.keys() if part[nodes] == com])\\r\\n num_of_communities = len(list_nodes)\\r\\n partition_performance = nx.algorithms.community.quality.performance(net_G, list_nodes)\\r\\n net_communities = [[\\\"Numbers of communities:\\\", num_of_communities], \\\\\\r\\n [\\\"Partition performance:\\\", partition_performance]]\\r\\n return net_communities\",\n \"def make_set_cover_nr(gRNA_hits, num_sets = 1, target_ids = [], low_coverage_penalty = 0,\\n num_lengths_to_track = None, prioritise_3prime = False, optimal_depth = 5,\\n suppress_warning = False):\\n collapsed_grnas = gRNA_hits.collapse()\\n if not target_ids:\\n target_ids = set().union(*[set(cg) for cg in collapsed_grnas])\\n else:\\n target_ids = set(target_ids)\\n ## function to regenerate set cover solutions from collapsed_grna object\\n collapsed_grnas_original = collapsed_grnas.copy()\\n def generate_sc_solutions():\\n ## sort in order of smallest set cover size, smallest redundancy, and size of largest set in set cover\\n minweight_sc = limited_minweight_SC(collapsed_grnas, num_sets, targets = target_ids,\\n low_coverage_penalty = low_coverage_penalty,\\n num_lengths_to_track = num_lengths_to_track)\\n ## optimal solutions\\n max_depth = min(optimal_depth, max(map(len, minweight_sc)))\\n max_redundancy = max(map(lambda C:C.redundancy, minweight_sc))/len(target_ids)\\n print(max_depth, max_redundancy)\\n optimal_sc = limited_optimal_SC(target_ids, collapsed_grnas_original,\\n size = max_depth, redundancy = max_redundancy)\\n print(\\\"num unfiltered optimal sc:\\\", len(optimal_sc))\\n ## remove duplicates\\n optimal_sc = [C for C in optimal_sc\\n if all(map(lambda minweight_C:(len(C) != minweight_C\\n and C != minweight_C),\\n minweight_sc))]\\n print(\\\"num filtered optimal sc:\\\", len(optimal_sc))\\n return sorted(minweight_sc + optimal_sc,\\n key = lambda C:(len(C), C.redundancy, -C.max_coverage))\\n sc_solutions = []\\n sc_solutions.extend(generate_sc_solutions())\\n eliminated_grna = []\\n ## function to generate set covers\\n def make_set_cover(restore = []):\\n ## restore only works if gRNA belonged in the current set cover\\n curr_sc = sc_solutions[0]\\n for grna in restore:\\n curr_sc.add_grna(grna)\\n eliminated_grna.remove(grna)\\n ## if current set cover solution has at least one CollapsedgRNA with no gRNA left\\n while not curr_sc.all_not_empty():\\n sink = sc_solutions.pop(0) ## remove set cover solution\\n ## generate more possible gRNA sets if no pre-generated set covers are left\\n if not sc_solutions:\\n collapsed_grnas.remove_grna(*eliminated_grna)\\n collapsed_grnas.remove_empty()\\n sc_solutions.extend(generate_sc_solutions())\\n if not sc_solutions:\\n if not suppress_warning:\\n print((\\\"\\\\nError: The provided gRNA sequences cannot cover all\\\"\\n \\\" target sequences at least once.\\\\n\\\"))\\n return []\\n ## select next solution\\n curr_sc = sc_solutions[0]\\n ## consume=True -> remove selected gRNA from CollapsedgRNA\\n output = curr_sc.generate_grna_set(prioritise_3prime = prioritise_3prime, consume = True)\\n eliminated_grna.extend(output)\\n return output\\n return make_set_cover\",\n \"def calc_skill_cluster_sets(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, blocks_one_clusnum, skill_str, seas):\\r\\n prec_arr, recall_arr, F1_arr, clus_num_arr = [], [], [], []\\r\\n\\r\\n prec_vals = sorted(np.unique(blocks_one_clusnum[skill_str].values), reverse = True)\\r\\n #loop through first element separately so that subsequent values can be appended\\r\\n node_cluster_set_test_str, ds_arr = [], []\\r\\n for prec in prec_vals:\\r\\n node_cluster_set_test_str_app = blocks_one_clusnum['set'][np.where(blocks_one_clusnum[skill_str]==prec)[0]].values\\r\\n for clus in node_cluster_set_test_str_app:\\r\\n #add cluster to cluster set\\r\\n node_cluster_set_test_str = np.append(node_cluster_set_test_str, clus)\\r\\n node_cluster_set_test_str = np.unique(node_cluster_set_test_str)\\r\\n node_num = len(node_cluster_set_test_str) # number of nodes in cluster set\\r\\n clus_num_arr.append(node_num)\\r\\n #calculate skill score of cluster set by calculating the number of days blocked from the GTD and selecting the season\\r\\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\\r\\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \\\"blocking\\\", dims={\\\"time\\\": GTD['time']})\\r\\n blocked_days_clus_xr['time'] = GTD['time']\\r\\n blocked_days_clus_sel = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\\r\\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_sel)\\r\\n prec_arr.append(prec)\\r\\n recall_arr.append(recall)\\r\\n F1_arr.append(F1)\\r\\n\\r\\n return clus_num_arr, prec_arr, recall_arr, F1_arr\",\n \"def g_minority_1_dev(by_grps):\\n if by_grps[0][0]==by_grps[0][1]:\\n print(\\\"Failed g_1dev_t2 -- small groups match\\\")\\n return False\\n \\n cts = 0\\n ctn = 0\\n cto = 0\\n big_letter= \\\"\\\"\\n \\n for item in by_grps[1]:\\n if item==\\\"S\\\":\\n cts+=1\\n if item==\\\"N\\\":\\n ctn+=1 \\n if item==\\\"O\\\":\\n cto+=1\\n if(cts==4 or ctn==4 or cto ==4):\\n pass\\n else:\\n print(\\\"Failed g_1dev_t2 -- no large group consistency\\\")\\n return False\\n \\n if(cts==4):\\n big_letter = \\\"S\\\"\\n if(cto==4):\\n big_letter = \\\"O\\\"\\n if(ctn == 4):\\n big_letter = \\\"N\\\"\\n \\n for item in by_grps[0]:\\n if(item==big_letter):\\n print(\\\"Faield g_1dev_t2 -- a small group member and large group letter are the same\\\")\\n return False\\n print(\\\"Confirmed g_1dev_t2 -- small group with 1 deviancy and large group are different\\\")\\n return True\",\n \"def caculate_network_statistics(self):\\n divide_factor_sum = 0 \\n for key in self.stars.keys():\\n star = self.stars[key]\\n if star.nb_num == 0 :\\n self.standalone_star_num += 1 \\n\\n divide_factor = star.nb_num + 2 * (star.spec_num - star.shared_spec_num )/self.ave_starlet_size\\n divide_factor_sum += divide_factor\\n divide_factor_int = round(divide_factor)\\n self.star_divide_factor_dist[divide_factor_int] = self.star_divide_factor_dist.get(divide_factor_int,0) + 1\\n if star.spec_num < star.shared_spec_num:\\n print(\\\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\\\")\\n print(\\\"with star \\\" + star.id + \\\" \\\" + str(star.spec_num) + \\\"is less than\\\" + str(star.shared_spec_num))\\n if star.spec_num > star.shared_spec_num:\\n self.star_lost_spec_num += star.spec_num - star.shared_spec_num\\n self.ave_divide_factor_star = divide_factor_sum/self.stars_length\\n\\n divide_factor_sum = 0 \\n for key in self.starlets.keys():\\n starlet = self.starlets[key]\\n if starlet.nb_num == 0 :\\n self.standalone_starlet_num += 1 \\n\\n divide_factor = starlet.nb_num + 2 * (starlet.spec_num - starlet.shared_spec_num )/self.ave_star_size\\n divide_factor_sum += divide_factor\\n divide_factor_int = round(divide_factor)\\n self.starlet_divide_factor_dist[divide_factor_int] = self.starlet_divide_factor_dist.get(divide_factor_int,0) + 1\\n if starlet.spec_num < starlet.shared_spec_num:\\n print(\\\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\\\")\\n print(\\\"with star \\\" + starlet.id + \\\" \\\" + str(starlet.spec_num) + \\\"is less than\\\" + str(starlet.shared_spec_num))\\n if starlet.spec_num > starlet.shared_spec_num:\\n self.starlet_lost_spec_num += starlet.spec_num - starlet.shared_spec_num\\n self.ave_divide_factor_starlet = divide_factor_sum/self.starlets_length\",\n \"def get_GNS_cut_reduced(self):\\n # we build the optimization around the casted digraph instead of multidigraph\\n # for simplicity\\n G = self.base_digraph\\n s_1 = self.sources[0]\\n s_2 = self.sources[1]\\n t_1 = self.destinations[0]\\n t_2 = self.destinations[1]\\n edges = G.edges()\\n nodes = G.nodes()\\n\\n try:\\n\\n # Great an gurobi instance of the optimization model\\n m = Model(\\\"GNS\\\")\\n m.setParam('OutputFlag', False)\\n\\n x_v = {}\\n # vertex variables for s_1, t_1 cut\\n for v in nodes:\\n x_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n y_v = {}\\n # vertex variables for s_2, t_2 cut\\n for v in nodes:\\n y_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n z_v = {}\\n # vertex variables for s_2, t_1 cut\\n for v in nodes:\\n z_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n e = {}\\n # GNS indicator variable\\n for (u,v) in edges:\\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\\n\\n # Done with decision variable creation\\n # update model\\n m.update()\\n\\n # Constraints\\n # 1. Constraints for s_1 - t_1 cut\\n for (u,v) in edges:\\n if (u,v) == (s_1, t_1):\\n m.addConstr(e[u,v] >= 1)\\n elif u == s_1:\\n m.addConstr(x_v[v] + e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-x_v[u] + e[u,v] >= 0)\\n else:\\n m.addConstr(x_v[v] - x_v[u] + e[u,v] >= 0)\\n\\n if (u,v) == (s_2, t_2):\\n m.addConstr(e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(y_v[v] + e[u,v] >= 1)\\n elif v == t_2:\\n m.addConstr(-y_v[u] + e[u,v] >= 0)\\n else:\\n m.addConstr(y_v[v] - y_v[u] + e[u,v] >= 0)\\n\\n if (u,v) == (s_2, t_1):\\n m.addConstr(e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(z_v[v] + e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-z_v[u] + e[u,v] >= 0)\\n else:\\n m.addConstr(z_v[v] - z_v[u] + e[u,v] >= 0)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n #print \\\"Min GNS cut value = \\\" + str(m.objVal)\\n #print \\\"GNS cut edges:\\\"\\n cut_set_edges = []\\n for u,v in edges:\\n if e[u,v].x != 0:\\n #print (u,v), str(G[u][v]['capacity'])\\n cut_set_edges.append((u,v, G[u][v]['capacity']))\\n return (m.objVal, cut_set_edges)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong\\\"\\n return None, None\\n\\n except GurobiError:\\n print ('Error report from Gurobi')\",\n \"def test_graphs_threshold_omst_global_cost_efficiency2():\\n # the function is optmized at the 3rd OMST, so it is going to yeild the same results\\n # as the exhaustive search\\n\\n # Groundtruth\\n expected = np.load(\\\"groundtruth/graphs_threshold/omst_gce.npy\\\")\\n\\n # Data\\n graph = np.load(\\\"sample_data/graphs_threshold/graph.npy\\\")\\n\\n # Run\\n n_msts = 5\\n _, CIJtree, _, _, _, _, _, _ = threshold_omst_global_cost_efficiency(\\n graph, n_msts=n_msts\\n )\\n\\n # Test\\n np.testing.assert_array_equal(expected, CIJtree)\",\n \"def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\\n logger.debug(f\\\"comparing {node1},{node2}, traversed {traversed}\\\")\\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\\n #remove dummies\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\\n #remove dummies\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\\n logger.debug(f\\\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\\\")\\n logger.debug(f\\\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\\\")\\n if not nbrs1 or not nbrs2:\\n if compare_two_nodes(G, node1, node2, ports_weight):\\n match_pair[node1] = node2\\n logger.debug(f\\\"no new neihbours, returning recursion {match_pair}\\\")\\n return\\n elif len(nbrs1)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node1} {nbrs1}\\\")\\n traversed.append(node1)\\n return\\n elif len(nbrs2)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n traversed.append(node2)\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node2} {nbrs2}\\\")\\n return\\n\\n if node1 == node2:\\n if node1 in match_pair.keys() or node1 in match_pair.values():\\n logger.debug(\\\"avoid existing pair wise symmetry\\\")\\n return\\n logger.debug(f\\\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\\\")\\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\\n ## TBD: filter based on primitive constraints\\n ## Right now will try to figure out S/D paths\\n if len(SD_nbrs) ==0:\\n logger.debug(f\\\"No SD paths found to traverse\\\")\\n match_pair[node1]=node1\\n elif len(SD_nbrs) ==1:\\n logger.debug(f\\\"traversing single S/D path {SD_nbrs}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\\n else:\\n logger.debug(f\\\" multiple nodes diverging {SD_nbrs}\\\")\\n logger.debug(f\\\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n new_sp=sorted(set(SD_nbrs)-set(traversed))\\n all_match_pairs_local={}\\n for nbr1,nbr2 in combinations(new_sp, 2):\\n logger.debug(f\\\"recursive pair call from single branch {nbr1} {nbr2}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n if new_pair:\\n #new_pair[nbr1]=nbr2\\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\\n if len(all_match_pairs_local)==1:\\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\\n logger.debug(f\\\"found inline pair: {pprint.pformat(match_pair, indent=4)}\\\")\\n else:\\n for nbr1 in new_sp:\\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\\n logger.debug(f\\\"recursive single branch call from single branch {nbr1} {nbr1}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif nbrs1 == nbrs2:\\n logger.debug(f\\\"traversing converging branch\\\")\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\\n logger.debug(f\\\"all non traversed neighbours: {nbrs1}\\\")\\n if len(nbrs1)==1:\\n nbr1=nbr2=nbrs1[0]\\n logger.debug(f\\\"keeping single converged branch inline {nbr1} {nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n else:\\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\\n logger.debug(f\\\"recursive call from converged branch {nbr1} {nbr2}\\\")\\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif compare_two_nodes(G,node1,node2,ports_weight):\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n logger.debug(f\\\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\\\")\\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\\n if len(nbrs1)==0 or len(nbrs2)==0:\\n logger.debug(f\\\"no new SD neihbours, returning recursion {match_pair}\\\")\\n elif len(nbrs1) ==1 and len(nbrs2)==1:\\n logger.debug(f\\\"traversing binary branch\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\\n elif unique_match:\\n logger.debug(f'traversing unique matches {unique_match}')\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n for nbr1,nbr2 in unique_match.items():\\n logger.debug(f\\\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\\n logger.debug(f\\\"setting new start points {node1} {node2}\\\")\\n match_pair[node1]=node2\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end all traversal from binary branch {node1} {node2}\\\")\\n\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end of recursion branch, matches {match_pair}\\\")\",\n \"def test_figure4(self):\\n\\n topics = get_topics('msmarco-passage-dev-subset')\\n qrels = get_qrels('msmarco-passage-dev-subset')\\n\\n self.assertEqual(len(topics), 6980)\\n self.assertEqual(len(qrels), 6980)\\n\\n # Compute the average length of queries:\\n avg_qlen = sum([len(topics[t]['title'].split()) for t in topics])/len(topics)\\n\\n # Compute the average number of relevance judgments per query:\\n avg_qrels = sum([len(qrels[t]) for t in topics])/len(topics)\\n\\n self.assertAlmostEqual(avg_qlen, 5.925, delta=0.001)\\n self.assertAlmostEqual(avg_qrels, 1.065, delta=0.001)\",\n \"def branchNBound2(nationtxt, bound, scheme):\\n\\n\\n nation = nationLoader(nationtxt)\\n transmitterCosts = scheme\\n\\n neighborCount = {}\\n for province in nation:\\n neighborCount.update({province:len(nation.get(province)[0])})\\n\\n\\n neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__)\\n\\n #~ neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__, reverse=True)\\n\\n for key in neighborCountSorted:\\n provinces.append(key)\\n #~ print provinces\\n\\n upperbound = bound\\n #~ print bound\\n\\n\\n\\n solution = []\\n\\n\\n counter = 0\\n\\n\\n\\n\\n while index >= 0:\\n\\n counter += 1\\n if counter % 100000000 == 0:\\n print counter\\n print \\\"Now at:\\\", nation\\n\\n\\n if index == -1:\\n break\\n\\n # Assign transmitter\\n if nation[provinces[index]][1] == numTransmitters:\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n else:\\n costs, index = updateTransmitter(nation, False, scheme, provinces, costs, index)\\n\\n # Check if costs are above upper bound\\n if (costs + (len(provinces) - (index + 1)) * transmitterCosts[0]) > upperbound:\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n # Check if a neighbor has the same transmitter\\n conflict = False\\n for neighbor in nation[provinces[index]][0]:\\n if nation[neighbor][1] == nation[provinces[index]][1]:\\n conflict = True\\n break\\n\\n if conflict:\\n continue\\n\\n # Check if a solution is found\\n if index == len(provinces) - 1:\\n #~ print \\\"\\\\nSOLUTION:\\\"\\n if costs < upperbound:\\n solution = []\\n solution.append(json_deep_copy(nation))\\n upperbound = costs\\n #~ print \\\"Score:\\\", upperbound\\n #~ print nation\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n index += 1\\n\\n\\n\\n usedTrans = []\\n fivePlus = 0\\n fivePlusNoDuplicate = 0\\n\\n for nation in solution:\\n\\n one = 0\\n two = 0\\n three = 0\\n four = 0\\n five = 0\\n six = 0\\n seven = 0\\n\\n for province in nation:\\n\\n if nation[province][1] == 1:\\n one += 1\\n if nation[province][1] == 2:\\n two += 1\\n if nation[province][1] == 3:\\n three += 1\\n if nation[province][1] == 4:\\n four += 1\\n if nation[province][1] == 5:\\n five += 1\\n if nation[province][1] == 6:\\n six += 1\\n if nation[province][1] == 7:\\n seven += 1\\n\\n\\n if five > 0 or six > 0 or seven > 0:\\n fivePlus += 1\\n if transmitterCosts[3] != transmitterCosts[4]:\\n fivePlusNoDuplicate += 1\\n\\n usedTrans.append([one, two, three, four, five, six, seven])\\n\\n return counter\",\n \"def specificity():\\n\\tatlas = 'power'\\n\\tproject='hcp'\\n\\tdf_columns=['Task','Hub Measure','Q+/Q-','Average Edge i-j Weight',\\\"Strength of r's, i's PC & j's Q\\\"]\\n\\ttasks = ['REST','WM','GAMBLING','RELATIONAL','MOTOR','LANGUAGE','SOCIAL',]\\n\\tknown_membership,network_names,num_nodes,name_int_dict = network_labels(atlas)\\n\\tdf = pd.DataFrame(columns = df_columns)\\n\\tfor task in tasks:\\n\\t\\tprint task\\n\\t\\t# subjects = np.array(hcp_subjects).copy()\\n\\t\\t# subjects = list(subjects)\\n\\t\\t# subjects = remove_missing_subjects(subjects,task,atlas)\\n\\t\\tsubjects = np.load('/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_subs_fz.npy' %('hcp',task,atlas))\\n\\t\\tstatic_results = graph_metrics(subjects,task,atlas,'fz')\\n\\t\\tsubject_pcs = static_results['subject_pcs']\\n\\t\\tsubject_wmds = static_results['subject_wmds']\\n\\t\\tsubject_mods = static_results['subject_mods']\\n\\t\\tsubject_wmds = static_results['subject_wmds']\\n\\t\\tmatrices = static_results['matrices']\\n\\t\\t#sum of weight changes for each node, by each node.\\n\\t\\thub_nodes = ['WCD']\\n\\t\\t# hub_nodes = ['PC']\\n\\t\\tdriver_nodes_list = ['Q+','Q-']\\n\\t\\t# driver_nodes_list = ['Q+']\\n\\t\\tmean_pc = np.nanmean(subject_pcs,axis=0)\\n\\t\\tmean_wmd = np.nanmean(subject_wmds,axis=0)\\n\\t\\tmod_pc_corr = np.zeros(subject_pcs.shape[1])\\n\\t\\tfor i in range(subject_pcs.shape[1]):\\n\\t\\t\\tmod_pc_corr[i] = nan_pearsonr(subject_mods,subject_pcs[:,i])[0]\\n\\t\\tmod_wmd_corr = np.zeros(subject_wmds.shape[1])\\n\\t\\tfor i in range(subject_wmds.shape[1]):\\n\\t\\t\\tmod_wmd_corr[i] = nan_pearsonr(subject_mods,subject_wmds[:,i])[0]\\n\\t\\tfor hub_node in hub_nodes:\\n\\t\\t\\tif hub_node == 'PC':\\n\\t\\t\\t\\tpc_edge_corr = np.arctanh(pc_edge_correlation(subject_pcs,matrices,path='/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_pc_edge_corr_z.npy' %(project,task,atlas)))\\n\\t\\t\\t\\tconnector_nodes = np.where(mod_pc_corr>0.0)[0]\\n\\t\\t\\t\\tlocal_nodes = np.where(mod_pc_corr<0.0)[0]\\n\\t\\t\\telse:\\n\\t\\t\\t\\tpc_edge_corr = np.arctanh(pc_edge_correlation(subject_wmds,matrices,path='/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_wmd_edge_corr_z.npy' %(project,task,atlas)))\\n\\t\\t\\t\\tconnector_nodes = np.where(mod_wmd_corr>0.0)[0]\\n\\t\\t\\t\\tlocal_nodes = np.where(mod_wmd_corr<0.0)[0]\\n\\t\\t\\tedge_thresh_val = 50.0\\n\\t\\t\\tedge_thresh = np.percentile(np.nanmean(matrices,axis=0),edge_thresh_val)\\n\\t\\t\\tpc_edge_corr[:,np.nanmean(matrices,axis=0)<edge_thresh] = np.nan\\n\\t\\t\\tfor driver_nodes in driver_nodes_list:\\n\\t\\t\\t\\tweight_change_matrix_between = np.zeros((num_nodes,num_nodes))\\n\\t\\t\\t\\tweight_change_matrix_within = np.zeros((num_nodes,num_nodes))\\n\\t\\t\\t\\tif driver_nodes == 'Q-':\\n\\t\\t\\t\\t\\tdriver_nodes_array = local_nodes\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tdriver_nodes_array = connector_nodes\\n\\t\\t\\t\\tfor n1,n2 in permutations(range(num_nodes),2):\\n\\t\\t\\t\\t\\tif n1 not in driver_nodes_array:\\n\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\tif known_membership[n2] == 0:\\n\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\tarray = pc_edge_corr[n1][n2]\\n\\t\\t\\t\\t\\tweight_change_matrix_between[n1,n2] = np.nansum(pc_edge_corr[n1][n2][np.where((known_membership!=known_membership[n2])&(np.arange(264)!=n1))])\\n\\t\\t\\t\\t\\tweight_change_matrix_within[n1,n2] = np.nansum(pc_edge_corr[n1][n2][np.where((known_membership==known_membership[n2])&(np.arange(264)!=n1))])\\n\\t\\t\\t\\t\\t# for n3 in range(264):\\n\\t\\t\\t\\t\\t# \\tif n1 == n3:\\n\\t\\t\\t\\t\\t# \\t\\tcontinue\\n\\t\\t\\t\\t\\t# \\tif known_membership[n3]!= known_membership[n2]:\\n\\t\\t\\t\\t\\t# \\t\\tweight_change_matrix_between[n1,n2] = np.nansum([weight_change_matrix_between[n1,n2],array[n3]])\\n\\t\\t\\t\\t\\t# \\t\\tbetween_len = between_len + 1\\n\\t\\t\\t\\t\\t# \\telse:\\n\\t\\t\\t\\t\\t# \\t\\tweight_change_matrix_within[n1,n2] = np.nansum([weight_change_matrix_within[n1,n2],array[n3]])\\n\\t\\t\\t\\t\\t# \\t\\tcommunity_len = community_len + 1\\n\\t\\t\\t\\t\\t# weight_change_matrix_within[n1,n2] = weight_change_matrix_within[n1,n2] / community_len\\n\\t\\t\\t\\t\\t# weight_change_matrix_between[n1,n2] = weight_change_matrix_between[n1,n2] / between_len\\n\\t\\t\\t\\ttemp_matrix = np.nanmean(matrices,axis=0)\\n\\t\\t\\t\\tweight_matrix = weight_change_matrix_within-weight_change_matrix_between\\n\\t\\t\\t\\tweight_matrix[np.isnan(weight_matrix)] = 0.0\\n\\t\\t\\t\\tif hub_node == 'PC':\\n\\t\\t\\t\\t\\tdf_columns=['Task','Hub Measure','Q+/Q-','Average Edge i-j Weight',\\\"Strength of r's, i's PC & j's Q\\\"]\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tdf_columns=['Task','Hub Measure','Q+/Q-','Average Edge i-j Weight',\\\"Strength of r's, i's WCD & j's Q\\\"]\\n\\t\\t\\t\\tdf_array = []\\n\\t\\t\\t\\tfor i,j in zip(temp_matrix[weight_matrix!=0.0].reshape(-1),weight_matrix[weight_matrix!=0.0].reshape(-1)):\\n\\t\\t\\t\\t\\tdf_array.append([task,hub_node,driver_nodes,i,j])\\n\\t\\t\\t\\tdf = pd.concat([df,pd.DataFrame(df_array,columns=df_columns)],axis=0)\\n\\t\\t\\t\\tprint hub_node, driver_nodes\\n\\t\\t\\t\\tprint pearsonr(weight_matrix[weight_matrix!=0.0].reshape(-1),temp_matrix[weight_matrix!=0.0].reshape(-1))\\n\\t\\t\\t\\t1/0\\n\\n\\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q+') &(df['Hub Measure']=='PC')],\\\"Strength of r's, i's PC & j's Q\\\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_pcqplus_%s.pdf'%(edge_thresh_val))\\n\\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q-') &(df['Hub Measure']=='PC')],\\\"Strength of r's, i's PC & j's Q\\\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_pcqminus_%s.pdf'%(edge_thresh_val))\\n\\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q+') &(df['Hub Measure']=='WCD')],\\\"Strength of r's, i's WCD & j's Q\\\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_wmdqplus_%s.pdf'%(edge_thresh_val))\\n\\t# plot_connectivity_results(df[(df['Q+/Q-']=='Q-') &(df['Hub Measure']=='WCD')],\\\"Strength of r's, i's WCD & j's Q\\\",'Average Edge i-j Weight','/home/despoB/mb3152/dynamic_mod/figures/edge_spec_wmdqminus_%s.pdf'%(edge_thresh_val))\\n\\t# \\\"\\\"\\\"\\n\\t# Are connector nodes modulating the edges that are most variable across subjects?\\n\\t# \\\"\\\"\\\"\\n\\t# atlas='power'\\n\\t# known_membership,network_names,num_nodes,name_int_dict = network_labels(atlas)\\n\\t# for task in tasks:\\n\\t# \\tpc_thresh = 75\\n\\t# \\tlocal_thresh = 25\\n\\t# \\tsubjects = np.array(hcp_subjects).copy()\\n\\t# \\tsubjects = list(subjects)\\n\\t# \\tsubjects = remove_missing_subjects(subjects,task,atlas)\\n\\t# \\tstatic_results = graph_metrics(subjects,task,atlas)\\n\\t# \\tsubject_pcs = static_results['subject_pcs']\\n\\t# \\tsubject_wmds = static_results['subject_wmds']\\n\\t# \\tmatrices = static_results['matrices']\\n\\t# \\tmatrices[:,np.nanmean(matrices,axis=0)<0.0] = np.nan\\n\\t# \\tpc_edge_corr = np.arctanh(pc_edge_correlation(subject_wmds,matrices,path='/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_wmd_edge_corr_z.npy' %(project,task,atlas)))\\n\\t# \\t# pc_edge_corr = pc_edge_correlation(subject_pcs,matrices,path='/home/despoB/mb3152/dynamic_mod/results/%s_%s_%s_pc_edge_corr_z.npy' %(project,task,atlas))\\n\\t# \\tstd_mod = []\\n\\t# \\ttstd = np.std(matrices,axis=0).reshape(-1)\\n\\t# \\tfor i in range(num_nodes):\\n\\t# \\t\\tstd_mod.append(nan_pearsonr(pc_edge_corr[i].reshape(-1),tstd)[0])\\n\\t# \\t# print task, pearsonr(np.nanmean(subject_pcs,axis=0),std_mod)\\n\\t# \\tprint task, pearsonr(np.nanmean(subject_wmds,axis=0),std_mod)\\n\\t# \\tplot_corr_matrix(np.std(matrices,axis=0),network_names.copy(),out_file=None,plot_corr=True,return_array=False)\",\n \"def branchNBound(nationtxt, bound, scheme):\\n provinces = []\\n index = 0\\n costs = 0\\n numTransmitters = 7\\n\\n transmitterCosts = scheme\\n nation = nationLoader(nationtxt)\\n\\n\\n neighborCount = {}\\n for province in nation:\\n neighborCount.update({province:len(nation.get(province)[0])})\\n\\n\\n #~ neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__)\\n\\n neighborCountSorted = sorted(neighborCount, key=neighborCount.__getitem__, reverse=True)\\n\\n for key in neighborCountSorted:\\n provinces.append(key)\\n #~ print provinces\\n\\n upperbound = bound\\n #~ print bound\\n #~ print bound\\n\\n\\n\\n solution = []\\n\\n\\n counter = 0\\n\\n\\n\\n\\n\\n while index >= 0:\\n\\n\\n counter += 1\\n if counter % 100000000 == 0:\\n print counter\\n print \\\"Now at:\\\", nation\\n\\n\\n if index == -1:\\n break\\n\\n # Assign transmitter\\n if nation[provinces[index]][1] == numTransmitters:\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n else:\\n costs, index = updateTransmitter(nation, False, scheme, provinces, costs, index)\\n\\n # Check if costs are above upper bound\\n if (costs + (len(provinces) - (index + 1)) * transmitterCosts[0]) > upperbound:\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n # Check if a neighbor has the same transmitter\\n conflict = False\\n for neighbor in nation[provinces[index]][0]:\\n if nation[neighbor][1] == nation[provinces[index]][1]:\\n conflict = True\\n break\\n\\n if conflict:\\n continue\\n\\n # Check if a solution is found\\n if index == len(provinces) - 1:\\n #~ print \\\"\\\\nSOLUTION:\\\"\\n if costs < upperbound:\\n solution = []\\n solution.append(json_deep_copy(nation))\\n upperbound = costs\\n #~ print \\\"Score:\\\", upperbound\\n #~ print nation\\n costs, index = updateTransmitter(nation, True, scheme, provinces, costs, index)\\n continue\\n\\n index += 1\\n\\n\\n usedTrans = []\\n fivePlus = 0\\n fivePlusNoDuplicate = 0\\n\\n for nation in solution:\\n\\n one = 0\\n two = 0\\n three = 0\\n four = 0\\n five = 0\\n six = 0\\n seven = 0\\n\\n for province in nation:\\n\\n if nation[province][1] == 1:\\n one += 1\\n if nation[province][1] == 2:\\n two += 1\\n if nation[province][1] == 3:\\n three += 1\\n if nation[province][1] == 4:\\n four += 1\\n if nation[province][1] == 5:\\n five += 1\\n if nation[province][1] == 6:\\n six += 1\\n if nation[province][1] == 7:\\n seven += 1\\n\\n\\n if five > 0 or six > 0 or seven > 0:\\n fivePlus += 1\\n if transmitterCosts[3] != transmitterCosts[4]:\\n fivePlusNoDuplicate += 1\\n\\n usedTrans.append([one, two, three, four, five, six, seven])\\n\\n return fivePlus, fivePlusNoDuplicate, usedTrans, upperbound, len(solution), counter\\n #~ f.write(\\\"\\\\n Used Transmitters: \\\"+ str(one)+\\\" \\\"+ str(two)+\\\" \\\"+ str(three)+\\\" \\\"+ str(four)+\\\" \\\"+ str(five)+\\\" \\\"+ str(six)+\\\" \\\"+ str(seven)+\\\"\\\\n Cost: \\\"+str(upperbound)+\\\"\\\\n Number of solutions: \\\"+str(len(solution))+\\\"\\\\n Iterations: \\\"+str(counter)+\\\"\\\\n\\\"+\\\"\\\\n\\\"+\\\"\\\\n\\\"+\\\"\\\\n\\\")\\n\\n #~ print \\\"transmitter frequecies:\\\", one, two, three, four, five, six, seven\\n #~ print \\\"Solutions:\\\", solution\\n #~ print \\\"Cost:\\\", upperbound\\n #~ print \\\"Number of solutions:\\\", len(solution)\\n #~ print \\\"Iterations:\\\", counter\",\n \"def test_graphs_threshold_omst_global_cost_efficiency():\\n # the function is optmized at the 3rd OMST.\\n\\n # Groundtruth\\n expected = np.load(\\\"groundtruth/graphs_threshold/omst_gce.npy\\\")\\n\\n # Data\\n graph = np.load(\\\"sample_data/graphs_threshold/graph.npy\\\")\\n\\n # Run\\n _, CIJtree, _, _, _, _, _, _ = threshold_omst_global_cost_efficiency(\\n graph, n_msts=None\\n )\\n\\n # Test\\n np.testing.assert_array_equal(expected, CIJtree)\",\n \"def compute_district_weights(dist_changes, elec_sets, elec_set_dict, state_gdf, partition, prec_draws_outcomes,\\\\\\n geo_id, primary_elecs, runoff_elecs, elec_match_dict, bases, outcomes,\\\\\\n recency_W1, cand_race_dict, min_cand_weights_dict):\\n \\n black_pref_cands_prim_dist = pd.DataFrame(columns = dist_changes)\\n black_pref_cands_prim_dist[\\\"Election Set\\\"] = elec_sets\\n hisp_pref_cands_prim_dist = pd.DataFrame(columns = dist_changes)\\n hisp_pref_cands_prim_dist[\\\"Election Set\\\"] = elec_sets\\n #store runoff preferences for instances where minority-preferred candidate needs to switch between primary and runoff\\n black_pref_cands_runoffs_dist = pd.DataFrame(columns = dist_changes)\\n black_pref_cands_runoffs_dist[\\\"Election Set\\\"] = elec_sets\\n hisp_pref_cands_runoffs_dist = pd.DataFrame(columns = dist_changes)\\n hisp_pref_cands_runoffs_dist[\\\"Election Set\\\"] = elec_sets \\n \\n black_conf_W3_dist = np.empty((len(elec_sets),0), float)\\n hisp_conf_W3_dist = np.empty((len(elec_sets),0), float)\\n neither_conf_W3_dist = np.empty((len(elec_sets),0), float)\\n \\n for district in dist_changes: \\n state_gdf[\\\"New Map\\\"] = state_gdf.index.map(dict(partition.assignment))\\n dist_prec_list = list(state_gdf[state_gdf[\\\"New Map\\\"] == district][geo_id])\\n dist_prec_indices = state_gdf.index[state_gdf[geo_id].isin(dist_prec_list)].tolist()\\n district_support_all = cand_pref_outcome_sum(prec_draws_outcomes, dist_prec_indices, bases, outcomes)\\n \\n black_pref_prob_single_dist = []\\n hisp_pref_prob_single_dist = []\\n \\n for elec_set in elec_sets: \\n HCVAP_support_elec = district_support_all[('HCVAP', elec_set_dict[elec_set]['Primary'])]\\n hisp_pref_cand_dist = max(HCVAP_support_elec.items(), key=operator.itemgetter(1))[0]\\n hisp_pref_prob_dist = HCVAP_support_elec[hisp_pref_cand_dist]\\n hisp_pref_prob_single_dist.append(hisp_pref_prob_dist) \\n \\n BCVAP_support_elec = district_support_all[('BCVAP', elec_set_dict[elec_set]['Primary'])]\\n black_pref_cand_dist = max(BCVAP_support_elec.items(), key=operator.itemgetter(1))[0]\\n black_pref_prob_dist = BCVAP_support_elec[black_pref_cand_dist]\\n black_pref_prob_single_dist.append(black_pref_prob_dist)\\n \\n black_pref_cands_prim_dist.at[black_pref_cands_prim_dist[\\\"Election Set\\\"] == elec_set, district] = black_pref_cand_dist\\n hisp_pref_cands_prim_dist.at[hisp_pref_cands_prim_dist[\\\"Election Set\\\"] == elec_set, district] = hisp_pref_cand_dist \\n \\n if 'Runoff' in elec_set_dict[elec_set].keys():\\n HCVAP_support_elec = district_support_all[('HCVAP', elec_set_dict[elec_set]['Runoff'])]\\n hisp_pref_cand_dist = max(HCVAP_support_elec.items(), key=operator.itemgetter(1))[0]\\n hisp_pref_cands_runoffs_dist.at[hisp_pref_cands_runoffs_dist[\\\"Election Set\\\"] == elec_set, district] = hisp_pref_cand_dist\\n \\n BCVAP_support_elec = district_support_all[('BCVAP', elec_set_dict[elec_set]['Runoff'])]\\n black_pref_cand_dist = max(BCVAP_support_elec.items(), key=operator.itemgetter(1))[0] \\n black_pref_cands_runoffs_dist.at[black_pref_cands_runoffs_dist[\\\"Election Set\\\"] == elec_set, district] = black_pref_cand_dist\\n \\n black_pref_conf_single_dist = [prob_conf_conversion(x) for x in black_pref_prob_single_dist]\\n black_conf_W3_dist = np.append(black_conf_W3_dist, np.array([black_pref_conf_single_dist]).transpose(), axis = 1) \\n \\n hisp_pref_conf_single_dist = [prob_conf_conversion(x) for x in hisp_pref_prob_single_dist]\\n hisp_conf_W3_dist = np.append(hisp_conf_W3_dist, np.array([hisp_pref_conf_single_dist]).transpose(), axis = 1) \\n \\n neither_pref_conf_single_dist = [prob_conf_conversion(x*y) for x,y in zip(black_pref_prob_single_dist,hisp_pref_prob_single_dist)]\\n neither_conf_W3_dist = np.append(neither_conf_W3_dist, np.array([neither_pref_conf_single_dist]).transpose(), axis = 1) \\n \\n #compute W2 (\\\"in-group\\\"-minority-preference weight) \\n min_cand_black_W2_dist, min_cand_hisp_W2_dist, min_cand_neither_W2_dist = compute_W2(elec_sets, \\\\\\n dist_changes, min_cand_weights_dict, black_pref_cands_prim_dist, hisp_pref_cands_prim_dist, cand_race_dict)\\n ################################################################################ \\n #compute final election weights per district\\n recency_W1 = recency_W1.copy()[:, dist_changes]\\n black_weight_dist = recency_W1*min_cand_black_W2_dist*black_conf_W3_dist\\n hisp_weight_dist = recency_W1*min_cand_hisp_W2_dist*hisp_conf_W3_dist \\n neither_weight_dist = recency_W1*min_cand_neither_W2_dist*neither_conf_W3_dist\\n \\n return black_weight_dist, hisp_weight_dist, neither_weight_dist, black_pref_cands_prim_dist, \\\\\\n black_pref_cands_runoffs_dist, hisp_pref_cands_prim_dist, hisp_pref_cands_runoffs_dist\",\n \"def test_local_efficiency_disconnected_graph(self):\\n assert_equal(nx.local_efficiency(self.G1), 0)\",\n \"def fit_score(self, solution):\\r\\n illegal_neighbours = 0\\r\\n legal_neighbours = 0\\r\\n for polygon in solution.genetic_units.values():\\r\\n for neighbour_id in polygon.neighbours_ids:\\r\\n if polygon.color is solution.genetic_units[neighbour_id].color:\\r\\n illegal_neighbours += 1\\r\\n else:\\r\\n legal_neighbours += 1\\r\\n if self.sorting_order is ScoresSortingOrder.ASCENDING:\\r\\n return illegal_neighbours\\r\\n else:\\r\\n return legal_neighbours\",\n \"def _majority(data_set):\\r\\n pair = _count_parties(data_set)\\r\\n democrats = pair[0]\\r\\n republicans = pair[1]\\r\\n if democrats > republicans: return \\\"D\\\"\\r\\n if democrats < republicans: return \\\"R\\\"\\r\\n else: return None\",\n \"def determine_measure_position(self):\\n green_probs = []\\n net_size = len(self.net)\\n #Belief propagation:\\n #Analyzes each position's probability of obtaining\\n #green when measuring at a time t+1.\\n for i in range(0, net_size):\\n accum = 0\\n for j in range(0, net_size):\\n distance = self.__get_distance(i, j)\\n if distance == 0: #Probability of measure green at distance 0 from 'i'.\\n accum += self.net[i].value * self.ct[0][0]\\n elif distance == 1: #Probability of measure green at distance 1 from 'i'.\\n accum += self.net[i].value * self.ct[1][0]\\n elif distance == 2: #Probability of measure green at distance 2 from 'i'.\\n accum += self.net[i].value * self.ct[2][0]\\n elif distance == 3: #Probability of measure green at distance 3 from 'i'.\\n accum += self.net[i].value * self.ct[3][0]\\n else: #Probability of measure green at a distance >= 4 from 'i'.\\n accum += self.net[i].value * self.ct[4][0]\\n green_probs.append(accum)\\n #Returns the position in which the probability of\\n #obtaining green when measuring is the highest.\\n return self.net[np.argmax(green_probs)].id\",\n \"def get_communities(num_of_neighbors, is_self_loops, relevant_period_groups, full_confusion_csv, classes_csv_file, priod_group_column, similarty_csv = ''):\\n\\n # generate class_names dict\\n cnt = 0\\n class_name_dict = {}\\n with open(classes_csv_file, 'r') as f:\\n reader = csv.reader(f)\\n for row in reader:\\n if cnt > 0:\\n class_name_dict[int(row[8])] = row[1]\\n cnt = cnt + 1\\n\\n\\n full_conf = np.genfromtxt(full_confusion_csv, delimiter=',')\\n relevant_conf = full_conf[:,:num_of_neighbors+1]\\n flatten_conf = np.zeros((relevant_conf.shape[0]*num_of_neighbors,2), dtype=np.int32)\\n if similarty_csv != '':\\n similarity_mat = np.genfromtxt(similarty_csv, delimiter=',')\\n similarity_conf_mat = np.zeros((200, 200), dtype=np.float32)\\n print(similarity_mat.shape)\\n\\n\\n row = 0\\n for k in range(relevant_conf.shape[0]):\\n for m in range(num_of_neighbors):\\n flatten_conf[row, 0] = relevant_conf[k,0]\\n flatten_conf[row,1] = relevant_conf[k,m+1]\\n if similarty_csv != '':\\n similarity_conf_mat[int(relevant_conf[k,0]), int(relevant_conf[k,m+1]) ] += similarity_mat[k, m]\\n\\n row = row + 1\\n\\n confusion_mat = confusion_matrix(flatten_conf[:,0], flatten_conf[:,1])\\n if similarty_csv != '':\\n confusion_mat = similarity_conf_mat\\n\\n confusion_mat = confusion_mat.astype('float') / confusion_mat.sum(axis=1)[:, np.newaxis]\\n symmetric_confusion = (confusion_mat + np.transpose(confusion_mat)) / 2\\n if not is_self_loops:\\n np.fill_diagonal(symmetric_confusion, 0)\\n\\n # taking only the relevant classes\\n if relevant_period_groups != -1:\\n df = pd.read_csv(classes_csv_file)\\n period_groups = df[priod_group_column]\\n relevant_classes = []\\n for group in relevant_period_groups:\\n group_slice = df[period_groups == group]\\n relevant_classes.extend(group_slice['id_period_sorted'].values)\\n\\n L = len(relevant_classes)\\n relevant_confusion = np.zeros((L,L), dtype=np.float32)\\n class_node_dict = {}\\n for m,cls_i in enumerate(relevant_classes):\\n class_node_dict[m] = cls_i\\n for n,cls_j in enumerate(relevant_classes):\\n relevant_confusion[m,n] = symmetric_confusion[cls_i,cls_j]\\n else:\\n relevant_confusion = symmetric_confusion\\n\\n G = nx.from_numpy_matrix(relevant_confusion)\\n\\n # find best communities based on modularity grade\\n resolution_vec = np.linspace(0.0,2,50)\\n mod_vec = np.zeros_like(resolution_vec)\\n best_modularity = -1\\n best_communities = -1\\n best_res = -1\\n for k in range(resolution_vec.size):\\n partition = community.best_partition(G, weight='weight', resolution=resolution_vec[k])\\n modularity = community.modularity(partition, G, weight='weight')\\n mod_vec[k] = modularity\\n if (modularity > best_modularity):\\n best_modularity = modularity\\n best_communities = partition\\n best_res = resolution_vec[k]\\n\\n summary_str = 'best resolution: %.3f\\\\nbest modularity: %.3f\\\\nnumber of communities: %d' % (best_res,best_modularity,len(set(best_communities.values())))\\n\\n #plt.plot(resolution_vec,mod_vec)\\n #plt.show()\\n\\n # generate community summary file\\n count = 0\\n strr = ''\\n summary_file_name = 'community_summary.csv'\\n for com in set(best_communities.values()):\\n count += 1.\\n list_nodes = [nodes for nodes in best_communities.keys() if best_communities[nodes] == com]\\n strr += 'community,' + str(com) + '\\\\n'\\n for nd in list_nodes:\\n if relevant_period_groups == -1:\\n strr += class_name_dict[nd] + ',id,' + str(nd) + '\\\\n'\\n else:\\n strr += class_name_dict[class_node_dict[nd]] + ',id,' + str(class_node_dict[nd]) + '\\\\n'\\n strr += '\\\\n'\\n with open(summary_file_name, \\\"w\\\") as text_file:\\n text_file.write(strr)\\n\\n print(strr)\\n # summary for map visualization tool\\n strr = ''\\n for k in range(relevant_confusion.shape[0]):\\n comm = partition[k]\\n comm_members = [nodes for nodes in partition.keys() if partition[nodes] == comm]\\n if relevant_period_groups == -1:\\n strr += 'id,' + str(k) + ',community,' + str(comm) + ',community_members,'\\n else:\\n strr += 'id,' + str(class_node_dict[k]) + ',community,' + str(comm) + ',community_members,'\\n for member in comm_members:\\n if relevant_period_groups == -1:\\n strr += str(member) + ','\\n else:\\n strr += str(class_node_dict[member]) + ','\\n strr += '\\\\n'\\n with open('nodes_communities.csv', \\\"w\\\") as text_file:\\n text_file.write(strr)\\n\\n\\n\\n return summary_str\",\n \"def get_rank(cutoff: dict, coverage: float, quality: float, length: int, contigs: int, genome_size: int, is_paired: bool) -> list:\\n rank = None\\n reason = []\\n coverage = float(f'{float(coverage):.2f}')\\n quality = float(f'{float(quality):.2f}')\\n length = round(float(f'{float(length):.2f}'))\\n contigs = int(contigs)\\n genome_size = int(genome_size)\\n gold = cutoff['gold']\\n silver = cutoff['silver']\\n bronze = cutoff['bronze']\\n\\n if coverage >= gold['coverage'] and quality >= gold['quality'] and length >= gold['length'] and contigs <= gold['contigs'] and is_paired:\\n reason.append('passed all cutoffs')\\n rank = 'gold'\\n elif coverage >= silver['coverage'] and quality >= silver['quality'] and length >= silver['length'] and contigs <= silver['contigs'] and is_paired:\\n if coverage < gold['coverage']:\\n reason.append(f\\\"Low coverage ({coverage:.2f}x, expect >= {gold['coverage']}x)\\\")\\n if quality < gold['quality']:\\n reason.append(f\\\"Poor read quality (Q{quality:.2f}, expect >= Q{gold['quality']})\\\")\\n if length < gold['length']:\\n reason.append(f\\\"Short read length ({length}bp, expect >= {gold['length']} bp)\\\")\\n if contigs > gold['contigs']:\\n reason.append(f\\\"Too many contigs ({contigs}, expect <= {gold['contigs']})\\\")\\n rank = 'silver'\\n elif coverage >= bronze['coverage'] and quality >= bronze['quality'] and length >= bronze['length'] and contigs <= bronze['contigs']:\\n if coverage < silver['coverage']:\\n reason.append(f\\\"Low coverage ({coverage:.2f}x, expect >= {silver['coverage']}x)\\\")\\n if quality < silver['quality']:\\n reason.append(f\\\"Poor read quality (Q{quality:.2f}, expect >= Q{silver['quality']})\\\")\\n if length < silver['length']:\\n reason.append(f\\\"Short read length ({length}bp, expect >= {silver['length']} bp)\\\")\\n if contigs > silver['contigs']:\\n reason.append(f\\\"Too many contigs ({contigs}, expect <= {silver['contigs']})\\\")\\n if not is_paired:\\n reason.append(f\\\"Single-end reads\\\")\\n rank = 'bronze'\\n\\n if not rank:\\n rank = 'exclude'\\n\\n if coverage < bronze['coverage']:\\n reason.append(f\\\"Low coverage ({coverage:.2f}x, expect >= {bronze['coverage']}x)\\\")\\n if quality < bronze['quality']:\\n reason.append(f\\\"Poor read quality (Q{quality:.2f}, expect >= Q{bronze['quality']})\\\")\\n if length < bronze['length']:\\n reason.append(f\\\"Short read length ({length:.2f}bp, expect >= {bronze['length']} bp)\\\")\\n if contigs > bronze['contigs']:\\n reason.append(f\\\"Too many contigs ({contigs}, expect <= {bronze['contigs']})\\\")\\n\\n if cutoff['min-assembled-size']:\\n if genome_size < cutoff['min-assembled-size']:\\n reason.append(f\\\"Assembled size is too small ({genome_size} bp, expect <= {cutoff['min-assembled-size']})\\\")\\n\\n if cutoff['max-assembled-size']:\\n if genome_size < cutoff['max-assembled-size']:\\n reason.append(f\\\"Assembled size is too large ({genome_size} bp, expect <= {cutoff['max-assembled-size']})\\\")\\n\\n reason = \\\";\\\".join(sorted(reason))\\n return [rank, reason]\",\n \"def check_all_nodes_covered(G, solution_set):\\n \\n # List of nodes\\n nodes_in_graph = list(G.nodes())\\n \\n # Nodes in solution_set\\n edges_in_solution_set = [x for l in solution_set for x in l]\\n nodes_in_solution_set = list(set(itertools.chain.from_iterable(edges_in_solution_set)))\\n \\n # Check for completeness\\n for node in nodes_in_graph:\\n if node not in nodes_in_solution_set:\\n return False, [node]\\n \\n return True, []\",\n \"def calc_cohesion( g, sg0, sg1, max_csize ) :\\n score = 0.0\\n n0 = len( sg0 )\\n n1 = len( sg1 )\\n if (n0 + n1 <= max_csize) :\\n boundary_edges = networkx.edge_boundary( g, sg0, sg1 )\\n for e in boundary_edges :\\n score += g[e[0]][e[1]][\\\"similarity\\\"]\\n return score / max( n0, n1 )\",\n \"def most_discriminating( features_df, labels_df, top=5):\\n \\n columns = features_df.shape[1]\\n labels_df = labels_df[['file', 'candy_id']].set_index('file')\\n qualities = np.zeros(columns)\\n \\n _left = 0\\n _right = 1\\n\\n _c = 0\\n _h = 1\\n\\n # globals\\n cases = float(labels_df['candy_id'].count()) # total cases\\n\\n p_c_A = (labels_df['candy_id'] == 0).sum() / cases\\n p_h_A = 1.0 - p_c_A\\n\\n\\n for feature in range(columns):\\n\\n branch_cases = np.zeros(2) # total on each branch\\n pi = np.zeros(2) # proportion on each branch\\n\\n split = np.array([\\n #c, h\\n [0, 0], #left\\n [0, 0] #right\\n ])\\n\\n for index, value in features_df[feature].iteritems():\\n split[value][labels_df.loc[index][0]] += 1\\n\\n branch_cases[_left] = split[_left].sum()\\n branch_cases[_right] = split[_right].sum()\\n \\n if branch_cases[_left] == 0.0 or branch_cases[_right] == 0.0:\\n qualities[feature] = 0\\n continue\\n \\n pi[_left] = branch_cases[_left] / cases\\n pi[_right] = branch_cases[_right] / cases\\n\\n p_c_B = split[_left][_c] / branch_cases[_left]\\n p_h_B = split[_left][_h] / branch_cases[_left]\\n\\n p_c_C = split[_right][_c] / branch_cases[_right]\\n p_h_C = split[_right][_h] / branch_cases[_right]\\n\\n gini_tree = 1.0 - (math.pow(p_c_A, 2) + math.pow(p_h_A, 2))\\n\\n gini_left = 1.0 - (math.pow(p_c_B, 2) + math.pow(p_h_B, 2))\\n gini_right = 1.0 - (math.pow(p_c_C, 2) + math.pow(p_h_C, 2))\\n\\n quality = gini_tree - pi[_left] * gini_left - pi[_right] * gini_right\\n\\n qualities[feature] = quality\\n return list(reversed(qualities.argsort()))[:top]\",\n \"def test_edges_and_weights():\\n edges, weights, state_value = edges_weights_specified_state(\\n PROBABILITYMATRIX,\\n MARKET,\\n SNULL)\\n assert len(edges) == len(weights) == (len(state_value)**2)\",\n \"def test_efficiency_disconnected_nodes(self):\\n assert_equal(nx.efficiency(self.G1, 1, 2), 0)\",\n \"def matching_score(self,set1, set2):\\n set_set1=set(set1)\\n set_set2=set(set2)\\n '''print(\\\" set_set12\\\")\\n print(set_set1)\\n print(set_set2)'''\\n return len(set_set1.intersection(set_set2)) ** 2 / (float(len(set1)) * len(set2))\\n #return len(set_set1.intersection(set_set2)) / len(set_set1.union(set_set2))\",\n \"def SA(targetMDG):\\n hill_climbers = []\\n for i in range(NUM_Population):\\n hill_climbers.append(SimulatedAnnealing(targetMDG))\\n\\n completed_climbers = []\\n completed_max_climbers = []\\n\\n # k: int, number of neighbors to be considered\\n k = 20\\n i = 0\\n not_increased = 0\\n max_score = 0\\n\\n while True:\\n for climber in hill_climbers[:]:\\n result = climber.climb_with_annealing(k, i)\\n if not result:\\n completed_climbers.append(climber)\\n hill_climbers.remove(climber)\\n max_completed_climber = SimulatedAnnealing(targetMDG)\\n max_completed_climber.result = climber.max_result\\n max_completed_climber.update_score()\\n completed_max_climbers.append(max_completed_climber)\\n\\n total_climbers = hill_climbers + completed_climbers + completed_max_climbers\\n total_climbers.sort()\\n print(\\\"Iteration \\\", i, \\\": \\\", total_climbers[-1].score)\\n\\n if total_climbers[-1].score - max_score != 0:\\n not_increased = 0\\n else:\\n not_increased += 1\\n\\n if len(hill_climbers) == 0 or not_increased == 10:\\n break\\n i += 1\\n max_score = total_climbers[-1].score\\n\\n total_climbers = hill_climbers + completed_climbers + completed_max_climbers\\n total_climbers.sort()\\n\\n max_climber = total_climbers[-1]\\n\\n print(\\\"TurboMQ = \\\", max_climber.score)\\n for c in max_climber.result: # print all clusters which are not singleton\\n if 1 != len(c.get_nodes()):\\n print(c.get_nodes())\\n\\n return max_climber.result\",\n \"def evaluation(deploymentID, start_time,\\n end_time, sites, validation, manOrLik):\\n \\n estScoreBound = 5\\n falsePositive_dep = 0\\n falseNegative_dep = 0\\n truePositive_dep = 0\\n trueNegative_dep = 0\\n\\n db_con = MySQLdb.connect(user=\\\"root\\\", db=\\\"qraat\\\")\\n for i in sites:\\n truePositive = 0\\n trueNegative = 0\\n falsePositive = 0\\n falseNegative = 0\\n \\n cur = db_con.cursor()\\n cur.execute(\\\"\\\"\\\"SELECT isPulse, band3, band10, frequency,\\n ec, tnp, edsp, fdsp, edsnr, fdsnr\\n FROM est INNER JOIN est_class%s\\n ON ID = est_class%s.estID\\n INNER JOIN estscore2\\n ON ID = estscore2.estID\\n WHERE timestamp > %s\\n AND timestamp < %s\\n AND deploymentID = %s\\n AND siteID = %s\\n AND setNum = %s;\\n \\\"\\\"\\\"%(manOrLik, manOrLik, start_time, end_time,\\n deploymentID, i, validation))\\n for row in cur.fetchall():\\n estData = {'band3':row[1], 'band10':row[2],\\n 'frequency':row[3], 'ec':row[4], 'tnp':row[5],\\n 'edsp':row[6], 'fdsp':row[7],\\n 'edsnr':row[8], 'fdsnr':row[9]}\\n \\n #Classify data\\n isPulse = modifiedBC(deploymentID, i, start_time,\\n validation, estData, manOrLik)\\n\\n #Determine whether the classification results are correct or not\\n if (row[0] == 1):\\n if (isPulse == 1):\\n truePositive += 1\\n else:\\n falseNegative += 1\\n else:\\n if (isPulse == 1):\\n falsePositive += 1\\n else:\\n trueNegative += 1\\n \\n falsePositive_dep += falsePositive\\n falseNegative_dep += falseNegative\\n truePositive_dep += truePositive\\n trueNegative_dep += trueNegative\\n return [truePositive_dep, trueNegative_dep,\\n falsePositive_dep, falseNegative_dep]\",\n \"def find_non_neighbors_with_most_info(participant_data,\\n true_distro_by_round,\\n network_topology_name,\\n additional_names_count,\\n divergence_type=\\\"JS\\\",\\n memory_length=5,\\n graph=False):\\n\\n participant_differences = {}\\n\\n net = nb.net(network_topology_name)\\n\\n # We start by going through each participant\\n for participant, data in participant_data.items():\\n # and we're going to calculate the divergences for combo of additional names\\n\\n # First we look at the overall divergence without unstructured names\\n div_no_unstructured_by_round = []\\n\\n distro_by_round_no_unstructured = impose_limited_memory(data[\\\"distro_by_round_no_unstructured\\\"],\\n memory_length=memory_length)\\n for game_round in range(1,26):\\n\\n # a new list of names needs to be truncated to induce some memory\\n seen_distro_with_no_unstructured, true_distro = create_continuity_and_probabilities(\\n distro_by_round_no_unstructured[game_round],\\n true_distro_by_round[game_round])\\n\\n # KL divergence between real and distro with additional names\\n if divergence_type == \\\"JS\\\":\\n div_no_unstructured_by_round.append(JS(seen_distro_with_no_unstructured, true_distro))\\n else:\\n div_no_unstructured_by_round.append(KL(seen_distro_with_no_unstructured, true_distro))\\n\\n # Then we calculate the divergence for the real rounds with unstructured\\n\\n div_with_unstructured_by_round = []\\n\\n distro_by_round_unstructured = impose_limited_memory(data[\\\"distro_by_round_unstructured\\\"],\\n memory_length=memory_length)\\n for game_round in range(1,26):\\n\\n # a new list of names needs to be truncated to induce some memory\\n seen_distro_with_unstructured, true_distro_2 = create_continuity_and_probabilities(\\n distro_by_round_unstructured[game_round],\\n true_distro_by_round[game_round])\\n\\n # KL divergence between real and distro with additional names\\n if divergence_type == \\\"JS\\\":\\n div_with_unstructured_by_round.append(JS(seen_distro_with_unstructured, true_distro_2))\\n else:\\n div_with_unstructured_by_round.append(KL(seen_distro_with_unstructured, true_distro_2))\\n\\n # We'll select the non-neighbors with the most information (the smallest diff in KL) so\\n # we'll need to track the smallest divergences\\n smallest_divergence = None\\n\\n # We get all the non-neighbors of the ego node\\n non_neighbors = net.get_non_alters(participant)\\n\\n # We get all possible combinations of non-neighbors\\n non_neighbor_combinations = combinations(non_neighbors,additional_names_count)\\n\\n\\n for combo in non_neighbor_combinations:\\n\\n names_to_add_by_round = defaultdict(list)\\n for not_neighbor in combo:\\n # We get the names played by the participant and append it to lists of names for\\n # each round\\n for round, name in enumerate(participant_data[not_neighbor][\\\"names_played\\\"]):\\n names_to_add_by_round[round].append(name)\\n\\n # We go through round by round and add in the newly visible names\\n simulated_distro_by_round = {}\\n\\n # now we add to distribution with out unstructured\\n for game_round in range(1,26):\\n no_unstructured = list(data[\\\"distro_by_round_no_unstructured\\\"][game_round])\\n no_unstructured.extend(names_to_add_by_round[game_round])\\n\\n simulated_distro_by_round[game_round] = no_unstructured\\n\\n # That new list of names needs to be truncated to induce some memory\\n distro_by_round_with_non_neighbors = impose_limited_memory(simulated_distro_by_round,\\n memory_length=memory_length)\\n\\n divergence_by_round = []\\n for game_round in range(1,26):\\n\\n seen_distro_non_neighbors, true_distro = create_continuity_and_probabilities(\\n distro_by_round_with_non_neighbors[game_round],\\n true_distro_by_round[game_round])\\n\\n # Then we calculate the divergence from distro with weakest link to true distro\\n if divergence_type == \\\"JS\\\":\\n div_with_non_neighbors = JS(seen_distro_non_neighbors, true_distro)\\n else:\\n div_with_non_neighbors = KL(seen_distro_non_neighbors, true_distro)\\n divergence_by_round.append(div_with_non_neighbors)\\n\\n\\n # the sum is the area under the curve, or the total divergences for the whole run.\\n total_diff_in_divergences = sum(divergence_by_round)\\n\\n if smallest_divergence != None:\\n if total_diff_in_divergences < sum(smallest_divergence):\\n smallest_divergence = divergence_by_round\\n alters_with_smallest_divergence = combo\\n else:\\n smallest_divergence = divergence_by_round\\n alters_with_smallest_divergence = combo\\n\\n # now that we have the smallest divergence to the true distro from simulated weakest\\n # link distro, we compare it to the divergence to the true distro from the real additional\\n # name distro. A positive difference as calculated means the additiona name version carries # more information (because it is closer to the true)\\n\\n game_diffs = [i-j for i, j in zip(smallest_divergence,div_with_unstructured_by_round)]\\n\\n divergence_ratio = [1 - actual/total if total !=0 else 0 for actual, total in zip(div_with_unstructured_by_round, div_no_unstructured_by_round)]\\n\\n #print(\\\"comparison:\\\", divergence_by_round)\\n #print(\\\"base_diff:\\\", div_no_unstructured_by_round)\\n #print(\\\"ratio:\\\", divergence_ratio)\\n\\n participant_differences[participant] = (game_diffs, alters_with_smallest_divergence, div_no_unstructured_by_round, divergence_ratio)\\n\\n return participant_differences\",\n \"def query_size_of_adjacent_nodes(self, node_curie, source_type, adjacent_type, kp=\\\"infores:rtx-kg2\\\", rel_type=None):\\n\\n res = None\\n source_type = ComputeFTEST.convert_string_to_snake_case(source_type.replace('biolink:',''))\\n source_type = ComputeFTEST.convert_string_biolinkformat(source_type)\\n adjacent_type = ComputeFTEST.convert_string_to_snake_case(adjacent_type.replace('biolink:',''))\\n adjacent_type = ComputeFTEST.convert_string_biolinkformat(adjacent_type)\\n\\n if rel_type is None:\\n normalized_nodes = self.nodesynonymizer.get_canonical_curies(node_curie)\\n failure_nodes = list()\\n mapping = {node:normalized_nodes[node]['preferred_curie'] for node in normalized_nodes if normalized_nodes[node] is not None}\\n failure_nodes += list(normalized_nodes.keys() - mapping.keys())\\n query_nodes = list(set(mapping.values()))\\n query_nodes = [curie_id.replace(\\\"'\\\", \\\"''\\\") if \\\"'\\\" in curie_id else curie_id for curie_id in query_nodes]\\n # special_curie_ids = [curie_id for curie_id in query_nodes if \\\"'\\\" in curie_id]\\n\\n # Get connected to kg2c sqlite\\n connection = sqlite3.connect(self.sqlite_file_path)\\n cursor = connection.cursor()\\n\\n # Extract the neighbor count data\\n node_keys_str = \\\"','\\\".join(query_nodes) # SQL wants ('node1', 'node2') format for string lists\\n sql_query = f\\\"SELECT N.id, N.neighbor_counts \\\" \\\\\\n f\\\"FROM neighbors AS N \\\" \\\\\\n f\\\"WHERE N.id IN ('{node_keys_str}')\\\"\\n cursor.execute(sql_query)\\n rows = cursor.fetchall()\\n rows = [curie_id.replace(\\\"\\\\'\\\",\\\"'\\\").replace(\\\"''\\\", \\\"'\\\") if \\\"'\\\" in curie_id else curie_id for curie_id in rows]\\n connection.close()\\n\\n # Load the counts into a dictionary\\n neighbor_counts_dict = {row[0]:eval(row[1]) for row in rows}\\n\\n res_dict = {node:neighbor_counts_dict[mapping[node]].get(adjacent_type) for node in mapping if mapping[node] in neighbor_counts_dict and neighbor_counts_dict[mapping[node]].get(adjacent_type) is not None}\\n failure_nodes += list(mapping.keys() - res_dict.keys())\\n\\n if len(failure_nodes) != 0:\\n return (res_dict, failure_nodes)\\n else:\\n return (res_dict, [])\\n\\n else:\\n # if kp == 'ARAX/KG1':\\n # self.response.warning(f\\\"Since the edge type '{rel_type}' is from KG1, we still use the DSL expand(kg=ARAX/KG1) to query neighbor count. However, the total node count is based on KG2c from 'nodesynonymizer.get_total_entity_count'. So the FET result might not be accurate.\\\")\\n\\n # construct the instance of ARAXQuery class\\n araxq = ARAXQuery()\\n\\n # check if node_curie is a str or a list\\n if type(node_curie) is str:\\n query_node_curie = node_curie\\n elif type(node_curie) is list:\\n node_id_list_str = \\\"[\\\"\\n for index in range(len(node_curie)):\\n node = node_curie[index]\\n if index + 1 == len(node_curie):\\n node_id_list_str = node_id_list_str + str(node) + \\\"]\\\"\\n else:\\n node_id_list_str = node_id_list_str + str(node) + \\\",\\\"\\n\\n query_node_curie = node_id_list_str\\n else:\\n self.response.error(\\\"The 'node_curie' argument of 'query_size_of_adjacent_nodes' method within FET only accepts str or list\\\")\\n return res\\n\\n # call the method of ARAXQuery class to query adjacent node\\n query = {\\\"operations\\\": {\\\"actions\\\": [\\n \\\"create_message\\\",\\n f\\\"add_qnode(ids={query_node_curie}, categories={source_type}, key=FET_n00)\\\",\\n f\\\"add_qnode(categories={adjacent_type}, key=FET_n01)\\\",\\n f\\\"add_qedge(subject=FET_n00, object=FET_n01, key=FET_e00, predicates={rel_type})\\\",\\n f\\\"expand(edge_key=FET_e00,kp={kp})\\\",\\n #\\\"resultify()\\\",\\n \\\"return(message=true, store=false)\\\"\\n ]}}\\n\\n try:\\n result = araxq.query(query)\\n if result.status != 'OK':\\n self.response.error(f\\\"Fail to query adjacent nodes from infores:rtx-kg2 for {node_curie}\\\")\\n return res\\n else:\\n res_dict = dict()\\n message = araxq.response.envelope.message\\n if type(node_curie) is str:\\n tmplist = set([edge_key for edge_key in message.knowledge_graph.edges if message.knowledge_graph.edges[edge_key].subject == node_curie or message.knowledge_graph.edges[edge_key].object == node_curie]) ## edge has no direction\\n if len(tmplist) == 0:\\n self.response.warning(f\\\"Fail to query adjacent nodes from {kp} for {node_curie} in FET probably because expander ignores node type. For more details, please see issue897.\\\")\\n return (res_dict,[node_curie])\\n res_dict[node_curie] = len(tmplist)\\n return (res_dict,[])\\n else:\\n check_empty = False\\n failure_nodes = list()\\n for node in node_curie:\\n tmplist = set([edge_key for edge_key in message.knowledge_graph.edges if message.knowledge_graph.edges[edge_key].subject == node or message.knowledge_graph.edges[edge_key].object == node]) ## edge has no direction\\n if len(tmplist) == 0:\\n self.response.warning(f\\\"Fail to query adjacent nodes from {kp} for {node} in FET probably because expander ignores node type. For more details, please see issue897.\\\")\\n failure_nodes.append(node)\\n check_empty = True\\n continue\\n res_dict[node] = len(tmplist)\\n\\n if check_empty is True:\\n return (res_dict,failure_nodes)\\n else:\\n return (res_dict,[])\\n except:\\n tb = traceback.format_exc()\\n error_type, error, _ = sys.exc_info()\\n self.response.error(tb, error_code=error_type.__name__)\\n self.response.error(f\\\"Something went wrong with querying adjacent nodes from {kp} for {node_curie}\\\")\\n return res\",\n \"def narrative_consistency(self, metric='betweenness', nodes=None): # measures centrality\\n if metric == 'betweenness':\\n vals = nx.betweenness_centrality(self.graph)\\n elif metric == 'degree':\\n vals = {n[0]: n[1] for n in self.graph.degree()}\\n elif metric == 'closeness':\\n vals = nx.closeness_centrality(self.graph)\\n else:\\n vals_b = nx.betweenness_centrality(self.graph)\\n vals_d = {n[0]: n[1] for n in self.graph.degree()}\\n vals_c = nx.closeness_centrality(self.graph)\\n\\n min_ = min(vals_b.values())\\n delta = max(vals_b.values()) - min_\\n vals_b = {k: (v - min_) / delta for k, v in vals_b.items()}\\n\\n min_ = min(vals_d.values())\\n delta = max(vals_d.values()) - min_\\n vals_d = {k: (v - min_) / delta for k, v in vals_d.items()}\\n\\n min_ = min(vals_c.values())\\n delta = max(vals_c.values()) - min_\\n vals_c = {k: (v - min_) / delta for k, v in vals_c.items()}\\n\\n vals = {k: (v + vals_b.get(k, 0) + vals_c.get(k, 0)) / 3 for k, v in vals_d.items()}\\n\\n if nodes is None:\\n return sum(-math.log(v) for v in vals.values() if v > 0) / self.graph.number_of_nodes()\\n\\n return sum(-math.log(v) for k, v in vals.items() if v > 0 and k in nodes) / len(nodes)\",\n \"def test_net_score():\\n player = sequence_threshold.Player()\\n\\n player.cards = SortedSet()\\n assert player.get_net_score(1) == 1\\n assert player.get_net_score(6) == 6\\n assert player.get_net_score(35) == 35\\n\\n player.cards = SortedSet([2, 7, 36])\\n # Taking a card one lower than a card you have decreases your score by one.\\n assert player.get_net_score(1) == -1\\n assert player.get_net_score(6) == -1\\n assert player.get_net_score(35) == -1\\n # Taking a card one higher than a card you have does not change your score.\\n assert player.get_net_score(3) == 0\\n assert player.get_net_score(8) == 0\\n assert player.get_net_score(37) == 0\\n # You can never take a card you already have. This should cause an error rather than return 0.\\n with pytest.raises(Exception):\\n player.get_net_score(2)\\n with pytest.raises(Exception):\\n player.get_net_score(7)\\n with pytest.raises(Exception):\\n player.get_net_score(36)\\n\\n player.cards = SortedSet([2, 4, 27, 29])\\n # Completing these sequences with the in-between card decreases your score by the higher card amount.\\n assert player.get_net_score(3) == -4\\n assert player.get_net_score(28) == -29\",\n \"def nodes_ratio(data: Data, position_against_soma=None, node_types=None, filter_layers=None):\\n soma = data.morphology.get_soma()\\n if position_against_soma=='above':\\n criterion=lambda nod:((nod['type'] in node_types) if node_types is not None else True) and nod['y']<soma['y']\\n elif position_against_soma=='below':\\n criterion=lambda nod:((nod['type'] in node_types) if node_types is not None else True) and nod['y']>soma['y']\\n else:\\n criterion=lambda nod:nod['type'] in node_types if node_types is not None else True\\n num_type_nodes = data.morphology.get_node_by_types(node_types)\\n if filter_layers and isinstance(filter_layers, list):\\n result = {}\\n for layer in filter_layers:\\n filter_layer_depth = data.reference_layer_depths.get(layer)\\n y_min, y_max, is_scale = filter_layer_depth.pia_side, filter_layer_depth.wm_side, filter_layer_depth.scale\\n if is_scale:\\n selected_nodes = data.morphology.filter_nodes(lambda nod: criterion(nod) and y_min<nod['y']<y_max)\\n else:\\n selected_nodes = data.morphology.filter_nodes(lambda nod: criterion(nod) and nod['y']>y_min)\\n result[layer]=len(selected_nodes)/len(num_type_nodes)\\n return result\\n else:\\n selected_nodes = data.morphology.filter_nodes(criterion)\\n return len(selected_nodes)/len(num_type_nodes)\",\n \"def minimum_spanning_arborescence(sol):\",\n \"def do_conflict(g, source, prob):\\n\\n count1, count2, count3 = 0, 0, 0\\n\\n g.node[source][\\\"m\\\"] = source\\n for n in g.neighbors_iter(source):\\n g.node[n][\\\"m\\\"] = source\\n\\n peer = random.choice(g.neighbors(source))\\n for n in g.neighbors_iter(peer):\\n if \\\"m\\\" not in g.node[n]:\\n g.node[n][\\\"m\\\"] = peer\\n count1 += 1\\n\\n for n in g.neighbors_iter(peer):\\n if g.node[n][\\\"m\\\"] == source:\\n result = resolve(g, n, source, peer, prob)\\n g.node[n][\\\"m\\\"] = result\\n if result == peer:\\n count2 += 1\\n else:\\n count3 += 1\\n\\n clear_mappings(g, source)\\n clear_mappings(g, peer)\\n\\n share = float(count1)/len(g.neighbors(peer))\\n wins = float(count2)/float(count2+count3)\\n\\n return share, wins\",\n \"def protesting_communities(partition, active_nodes):\\n communities = defaultdict(int)\\n for node in active_nodes:\\n communities[partition[node]] += 1\\n return communities\",\n \"def test_create_problems(self):\\n # runs 10 attempts to generate satisfiable problems\\n sat, unsat = 0, 0\\n for _ in range(10):\\n # creates 3-CNFs with 20 vars & 90 clauses (phase transition)\\n clauses = create_sat_problem(False, 'randkcnf', 3, 20, 91)\\n with Solver(name='Glucose3', bootstrap_with=clauses) as solver:\\n if solver.solve():\\n sat += 1\\n else:\\n unsat += 1\\n self.assertTrue(sat > 0)\\n self.assertTrue(unsat > 0)\",\n \"def test_compare_genomes_2(self):\\n self.pmr_gnm.annotation_status = \\\"final\\\"\\n self.pmr_gnm.name = \\\"Trixie\\\"\\n import_genome.compare_genomes(self.genome_pair, self.eval_flags)\\n count = count_status(self.genome_pair, \\\"error\\\", \\\"warning\\\")\\n with self.subTest():\\n self.assertEqual(len(self.genome_pair.evaluations), 13)\\n with self.subTest():\\n self.assertEqual(count, 0)\",\n \"def respect_matching(self, network):\\n\\n # Iterate over the connected components of the network\\n\\n for component in nx.connected_component_subgraphs(network):\\n\\n # If the component has only two nodes it is respected by default\\n\\n if component.number_of_nodes() < 3:\\n continue\\n\\n # Partition the nodes into biparite sets\\n\\n left, right = nx.bipartite.sets(component)\\n\\n # As a convention, the left side is the one with fewer vertices.\\n # Swap left and right if right has fewer vertices.\\n\\n if len(left) > len(right):\\n left, right = right, left\\n\\n # The way we encode the constraint that a maximum cardinality\\n # matching of the symmetrization graph be respected is to force\\n # one edge incident to each vertex on the left side of each\\n # component be activated, while at most one edge incident to each\\n # vertex of the right side be activated. This will activate a\\n # maximum cardinality matching of the graph IFF the size of the\\n # maximum cardinality matching of each component is the number of\\n # vertices in the smaller biparite set of that component. Here we\\n # run a check to verify that this is the case.\\n\\n mcm_size = len(nx.max_weight_matching(component,\\n maxcardinality=True))\\n\\n assert mcm_size == len(left)\\n\\n # Iterate over vertices on the smaller biparite set and force\\n # exactly one of their incident edges to be activated\\n\\n for l in left:\\n table = self.activation_variables[l]\\n lits = [table[r] for r in table]\\n self.at_most_one(lits)\\n self.add_clause(lits)\\n\\n # Iterate over vertices on the larger bipartite set and force\\n # at most one of their incident edges to be activated\\n\\n for r in right:\\n table = self.activation_variables[r]\\n lits = [table[l] for l in table]\\n self.at_most_one(lits)\",\n \"def GraphBetter(metric_set1_sorted, metric_set2_sorted, base_is_set_2):\\n total_bitrate_difference_ratio = 0.0\\n count = 0\\n for bitrate, metric in metric_set1_sorted:\\n for i in range(len(metric_set2_sorted) - 1):\\n s2_bitrate_0, s2_metric_0 = metric_set2_sorted[i]\\n s2_bitrate_1, s2_metric_1 = metric_set2_sorted[i + 1]\\n # We have a point on either side of our metric range.\\n if metric > s2_metric_0 and metric <= s2_metric_1:\\n\\n # Calculate a slope.\\n if s2_metric_1 - s2_metric_0 != 0:\\n metric_slope = ((s2_bitrate_1 - s2_bitrate_0) /\\n (s2_metric_1 - s2_metric_0))\\n else:\\n metric_slope = 0\\n\\n estimated_s2_bitrate = (s2_bitrate_0 + (metric - s2_metric_0) *\\n metric_slope)\\n\\n # Calculate percentage difference as given by base.\\n if base_is_set_2 == 0:\\n bitrate_difference_ratio = ((bitrate - estimated_s2_bitrate) /\\n bitrate)\\n else:\\n bitrate_difference_ratio = ((bitrate - estimated_s2_bitrate) /\\n estimated_s2_bitrate)\\n\\n total_bitrate_difference_ratio += bitrate_difference_ratio\\n count += 1\\n break\\n\\n # Calculate the average improvement between graphs.\\n if count != 0:\\n avg = total_bitrate_difference_ratio / count\\n\\n else:\\n avg = 0.0\\n\\n return avg\",\n \"def get_network_score(self):\\n for key in self.nodes:\\n node = self.nodes[key]\\n if node.is_dc:\\n neighbors_total = 0\\n for neighbor in node.neighbors:\\n weight = (neighbor.weight / node.neighbors_magnitude)\\n neighbors_total += weight * neighbor.individual_score\\n\\n neighbor_score = neighbors_total / len(node.neighbors)\\n relative_score = (node.individual_score + neighbor_score) / 2\\n node.relative_score = relative_score\\n\\n total = 0\\n for key in self.nodes:\\n node = self.nodes[key]\\n total += node.relative_score\\n score = total / len(self.nodes)\\n\\n return score\",\n \"def create_network(self, community_detection, wt_steps, n_clust, network_from, neighbors, top):\\n \\n if network_from == 'top_n':\\n sort_by_scores = []\\n\\n for pair, score in scores_update.items():\\n sort_by_scores.append([pair[0], pair[1], score[2]])\\n top_n = sorted(sort_by_scores, reverse=False, key=lambda x: x[2])[:top]\\n\\n # Convert from distance to similarity for edge\\n for score in top_n: \\n c = 1/(1 + score[2])\\n score[2] = c\\n\\n flat = [tuple(pair) for pair in top_n]\\n\\n elif network_from == 'knn': \\n flat = []\\n projection_knn = nearest_neighbors(neighbors=neighbors)\\n\\n for projection, knn in projection_knn.items():\\n for n in knn:\\n flat.append((projection, n[0], abs(n[3]))) # p1, p2, score\\n\\n clusters = {}\\n g = Graph.TupleList(flat, weights=True)\\n\\n if community_detection == 'walktrap':\\n try:\\n wt = Graph.community_walktrap(g, weights='weight', steps=wt_steps)\\n cluster_dendrogram = wt.as_clustering(n_clust)\\n except:\\n self.show_cluster_fail()\\n elif community_detection == 'betweenness':\\n try:\\n ebs = Graph.community_edge_betweenness(g, weights='weight', directed=True)\\n cluster_dendrogram = ebs.as_clustering(n_clust)\\n except:\\n self.show_cluster_fail()\\n\\n for community, projection in enumerate(cluster_dendrogram.subgraphs()):\\n clusters[community] = projection.vs['name']\\n\\n #convert node IDs back to ints\\n for cluster, nodes in clusters.items():\\n clusters[cluster] = sorted([int(node) for node in nodes])\\n \\n remove_outliers(clusters)\\n\\n clustered = []\\n for cluster, nodes in clusters.items():\\n for n in nodes:\\n clustered.append(n)\\n\\n clusters['singles'] = [] # Add singles to clusters if not in top n scores\\n clusters['removed'] = []\\n \\n for node in projection_2D:\\n if node not in clustered and node not in drop:\\n clusters['singles'].append(node)\\n elif node in drop:\\n clusters['removed'].append(node)\\n \\n G = nx.Graph()\\n\\n for pair in flat:\\n G.add_edge(int(pair[0]), int(pair[1]), weight=pair[2])\\n\\n #if you want to see directionality in the networkx plot\\n #G = nx.MultiDiGraph(G)\\n\\n #adds singles if not in top n scores\\n for node_key in projection_2D:\\n if node_key not in G.nodes:\\n G.add_node(node_key)\\n\\n return flat, clusters, G\",\n \"def all_best_nr(potential_coverage, all_coverage, covered):\\n ## get redundancy count\\n potential_redundancy = {grna_seq: len(set(hit.target_id for hit in hits\\n if hit.target_id in covered))\\n for grna_seq, hits in all_coverage.items()\\n if grna_seq in potential_coverage}\\n best_redundancy = min(potential_redundancy.values())\\n return {grna_seq: potential_coverage[grna_seq]\\n for grna_seq, redundancy in potential_redundancy.items()\\n if redundancy == best_redundancy}\",\n \"def hypergraph_bipartiteness(hypergraph, vertex_set_l, vertex_set_r):\\n hyplogging.logger.debug(\\\"Computing hypergraph bipartiteness.\\\")\\n hyplogging.logger.debug(f\\\" Left set size: {len(vertex_set_l)}\\\")\\n hyplogging.logger.debug(f\\\" Right set size: {len(vertex_set_r)}\\\")\\n vol_s = hypergraph_volume(hypergraph, vertex_set_l + vertex_set_r)\\n\\n vertex_set_l = set(vertex_set_l)\\n vertex_set_r = set(vertex_set_r)\\n\\n w_l_not_l = 0\\n w_r_not_r = 0\\n w_l_r = 0\\n w_r_l = 0\\n for edge in hypergraph.edges:\\n edge_set = set(edge)\\n edge_l_intersection = len(vertex_set_l.intersection(edge_set))\\n edge_r_intersection = len(vertex_set_r.intersection(edge_set))\\n edge_entirely_inside_l = edge_l_intersection == len(edge_set)\\n edge_entirely_inside_r = edge_r_intersection == len(edge_set)\\n\\n if edge_entirely_inside_l:\\n w_l_not_l += 1\\n if edge_entirely_inside_r:\\n w_r_not_r += 1\\n if edge_l_intersection > 0 and not edge_r_intersection > 0:\\n w_l_r += 1\\n if edge_r_intersection > 0 and not edge_l_intersection > 0:\\n w_r_l += 1\\n\\n # Compute the bipartiteness\\n bipart = (w_l_not_l + w_r_not_r + w_l_r + w_r_l) / vol_s\\n hyplogging.logger.debug(f\\\"Computed bipartiteness: {bipart}\\\")\\n return bipart\",\n \"def testSpeciesRichness(self):\\n c1 = CoalescenceTree(os.path.join(\\\"output\\\", \\\"data_49_1.db\\\"))\\n c2 = CoalescenceTree(os.path.join(\\\"output\\\", \\\"data_49_6.db\\\"))\\n c3 = CoalescenceTree(os.path.join(\\\"output\\\", \\\"data_49_10.db\\\"))\\n self.assertEqual(451, c1.get_species_richness(1))\\n self.assertEqual(2623, c1.get_species_richness(2))\\n self.assertEqual(6957, c1.get_species_richness(3))\\n self.assertEqual(9486, c1.get_species_richness(4))\\n self.assertEqual(153, c1.get_species_richness(5))\\n self.assertEqual(332, c1.get_species_richness(6))\\n self.assertEqual(438, c1.get_species_richness(7))\\n self.assertEqual(470, c1.get_species_richness(8))\\n self.assertEqual(159, c1.get_species_richness(9))\\n self.assertEqual(314, c1.get_species_richness(10))\\n self.assertEqual(424, c1.get_species_richness(11))\\n self.assertEqual(459, c1.get_species_richness(12))\\n self.assertEqual(167, c2.get_species_richness(5))\\n self.assertEqual(334, c2.get_species_richness(6))\\n self.assertEqual(413, c2.get_species_richness(7))\\n self.assertEqual(470, c2.get_species_richness(8))\\n self.assertEqual(164, c2.get_species_richness(9))\\n self.assertEqual(338, c2.get_species_richness(10))\\n self.assertEqual(424, c2.get_species_richness(11))\\n self.assertEqual(464, c2.get_species_richness(12))\\n self.assertEqual(163, c3.get_species_richness(5))\\n self.assertEqual(318, c3.get_species_richness(6))\\n self.assertEqual(439, c3.get_species_richness(11))\\n self.assertEqual(446, c3.get_species_richness(12))\",\n \"def get_graph_karateclub():\\n all_members = set(range(34))\\n club1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 16, 17, 19, 21}\\n # club2 = all_members - club1\\n\\n G = eg.Graph(name=\\\"Zachary's Karate Club\\\")\\n for node in all_members:\\n G.add_node(node+1)\\n\\n zacharydat = \\\"\\\"\\\"\\\\\\n0 1 1 1 1 1 1 1 1 0 1 1 1 1 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 0\\n1 0 1 1 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 1 0 0 0\\n1 1 0 1 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0\\n1 1 1 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1\\n0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1\\n1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\\n0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\\n1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\\n1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 1\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 0\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1\\n0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1\\n0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 1\\n0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\\n1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 1 1\\n0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 0 0 0 0 0 1 1 1 0 1\\n0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 0 1 1 1 0 1 1 0 0 1 1 1 1 1 1 1 0\\\"\\\"\\\"\\n\\n for row, line in enumerate(zacharydat.split('\\\\n')):\\n thisrow = [int(b) for b in line.split()]\\n for col, entry in enumerate(thisrow):\\n if entry == 1:\\n G.add_edge(row+1, col+1)\\n\\n # Add the name of each member's club as a node attribute.\\n for v in G:\\n G.nodes[v]['club'] = 'Mr. Hi' if v in club1 else 'Officer'\\n return G\",\n \"def find_max_independent_set(graph, params):\\r\\n\\r\\n max_ind_set = []\\r\\n\\r\\n # QHACK #\\r\\n\\r\\n # function that takes in a graph and outputs the hamiltonians\\r\\n cost_h, mixer_h = qaoa.max_independent_set(graph, constrained=True) # Assume the graph they give me is good\\r\\n\\r\\n def qaoa_layer(gamma, alpha):\\r\\n qaoa.cost_layer(gamma, cost_h)\\r\\n qaoa.mixer_layer(alpha, mixer_h)\\r\\n\\r\\n dev = qml.device(\\\"default.qubit\\\", wires=range(NODES))\\r\\n\\r\\n def circuit(params, **kwargs): \\r\\n qml.layer(qaoa_layer, N_LAYERS, params[0], params[1]) \\r\\n\\r\\n @qml.qnode(dev)\\r\\n def probability_circuit(gamma, alpha):\\r\\n circuit([gamma, alpha])\\r\\n return qml.probs(wires=range(NODES))\\r\\n\\r\\n answer = probability_circuit(params[0], params[1])\\r\\n\\r\\n maxn = 0\\r\\n maxn = max(answer)\\r\\n\\r\\n for i in range(len(answer)):\\r\\n if maxn == answer[i]:\\r\\n decimal = i\\r\\n \\r\\n binary_num = []\\r\\n def DecimalToBinary(decimal):\\r\\n if decimal >= 1:\\r\\n DecimalToBinary(decimal // 2)\\r\\n binary_num.append(decimal % 2)\\r\\n \\r\\n DecimalToBinary(decimal)\\r\\n\\r\\n if len(binary_num) < 6:\\r\\n if len(binary_num) < 5:\\r\\n if len(binary_num) < 4:\\r\\n if len(binary_num) < 3:\\r\\n if len(binary_num) < 2:\\r\\n binary_num.insert(0, 0) # At beginning append 0\\r\\n binary_num.insert(0, 0)\\r\\n binary_num.insert(0, 0)\\r\\n binary_num.insert(0, 0)\\r\\n binary_num.insert(0, 0)\\r\\n\\r\\n for i in range(6):\\r\\n if binary_num[i] == 1:\\r\\n max_ind_set.append(i)\\r\\n\\r\\n # QHACK #\\r\\n\\r\\n return max_ind_set\",\n \"def test_branches_and_nodes_regression(\\n traces, areas, snap_threshold, allowed_loops, already_clipped, data_regression\\n):\\n branches, nodes = branches_and_nodes.branches_and_nodes(\\n traces, areas, snap_threshold, allowed_loops, already_clipped\\n )\\n\\n branches_value_counts = branches[general.CONNECTION_COLUMN].value_counts().to_dict()\\n nodes_value_counts = nodes[general.CLASS_COLUMN].value_counts().to_dict()\\n\\n data_regression.check({**branches_value_counts, **nodes_value_counts})\",\n \"def test_maximum_common_subgraph(graph1, graph2, attrs):\\n expected = vermouth.graph_utils.categorical_maximum_common_subgraph(graph1, graph2, attrs)\\n\\n found = vermouth.graph_utils.maximum_common_subgraph(graph1, graph2, attrs)\\n\\n note((\\\"Attributes that must match\\\", attrs))\\n note((\\\"Graph 1 nodes\\\", graph1.nodes(data=True)))\\n note((\\\"Graph 1 edges\\\", graph1.edges))\\n note((\\\"Graph 2 nodes\\\", graph2.nodes(data=True)))\\n note((\\\"Graph 2 edges\\\", graph2.edges))\\n # We don't find all MCS'es. See comment in\\n # vermouth.graph_utils.maximum_common_subgraph\\n found = make_into_set(found)\\n expected = make_into_set(expected)\\n\\n if found == expected:\\n event(\\\"Exact match\\\")\\n assert found <= expected\",\n \"def find_random_others(participant_data,\\n true_distro_by_round,\\n network_topology_name,\\n additional_names_count,\\n only_non_neighbors=False,\\n divergence_type=\\\"JS\\\",\\n memory_length=5,\\n graph=False):\\n\\n participant_differences = {}\\n\\n net = nb.net(network_topology_name)\\n\\n # We start by going through each participant\\n for participant, data in participant_data.items():\\n # First we look at the overall divergence without unstructured names\\n div_no_unstructured_by_round = []\\n\\n distro_by_round_no_unstructured = impose_limited_memory(data[\\\"distro_by_round_no_unstructured\\\"],\\n memory_length=memory_length)\\n for game_round in range(1,26):\\n\\n # a new list of names needs to be truncated to induce some memory\\n seen_distro_with_no_unstructured, true_distro = create_continuity_and_probabilities(\\n distro_by_round_no_unstructured[game_round],\\n true_distro_by_round[game_round])\\n\\n # divergence between real and distro with no additional names\\n if divergence_type == \\\"JS\\\":\\n div_no_unstructured_by_round.append(JS(seen_distro_with_no_unstructured, true_distro))\\n else:\\n div_no_unstructured_by_round.append(KL(seen_distro_with_no_unstructured, true_distro))\\n\\n\\n # Then we calculate the KL divergence for the real rounds with unstructured\\n div_with_unstructured_by_round = []\\n\\n distro_by_round_unstructured = impose_limited_memory(data[\\\"distro_by_round_unstructured\\\"],\\n memory_length=memory_length)\\n for game_round in range(1,26):\\n\\n # a new list of names needs to be truncated to induce some memory\\n seen_distro_with_unstructured, true_distro_2 = create_continuity_and_probabilities(\\n distro_by_round_unstructured[game_round],\\n true_distro_by_round[game_round])\\n\\n # KL divergence between real and distro with additional name\\n if divergence_type == \\\"JS\\\":\\n div_with_unstructured_by_round.append(JS(seen_distro_with_unstructured, true_distro_2))\\n else:\\n div_with_unstructured_by_round.append(KL(seen_distro_with_unstructured, true_distro_2))\\n\\n\\n\\n if only_non_neighbors == True:\\n # We get all the non-neighbors of the ego node\\n random_others = list(net.get_non_alters(participant))\\n else:\\n random_others = list(net.network.nodes())\\n random_others.remove(participant)\\n\\n # We randomly select a combination of non-neighbors\\n random_others_combination = random.sample(random_others, additional_names_count)\\n\\n names_to_add_by_round = defaultdict(list)\\n for random_other in random_others_combination:\\n # We get the names played by the participant and append it to lists of names for\\n # each round\\n for round, name in enumerate(participant_data[random_other][\\\"names_played\\\"]):\\n names_to_add_by_round[round].append(name)\\n\\n # We go through round by round and add in the newly visible names\\n simulated_distro_by_round = {}\\n\\n # now we add to distribution with out unstructured\\n for game_round in range(1,26):\\n no_unstructured = list(data[\\\"distro_by_round_no_unstructured\\\"][game_round])\\n no_unstructured.extend(names_to_add_by_round[game_round])\\n\\n simulated_distro_by_round[game_round] = no_unstructured\\n\\n # That new list of names needs to be truncated to induce some memory\\n distro_by_round_with_random_others = impose_limited_memory(simulated_distro_by_round,\\n memory_length=memory_length)\\n\\n divergence_by_round = []\\n for game_round in range(1,26):\\n\\n seen_distro_random_others, true_distro = create_continuity_and_probabilities(\\n distro_by_round_with_random_others[game_round],\\n true_distro_by_round[game_round])\\n\\n # Then we calculate the divergence from distro with the additional names to true distro\\n if divergence_type == \\\"JS\\\":\\n div_with_random_others = JS(seen_distro_random_others, true_distro)\\n else:\\n div_with_random_others = KL(seen_distro_random_others, true_distro)\\n divergence_by_round.append(div_with_random_others)\\n\\n # now that we have the divergence to the true distro from simulated distro, we compare it\\n # to the divergence to the true distro from the real additional name distro. A positive\\n # difference as calculated means the additional name version carries more information\\n # (because it is closer to the true)\\n\\n game_diffs = [i-j for i, j in zip(divergence_by_round,div_with_unstructured_by_round)]\\n\\n divergence_ratio = [1 - actual/total if total !=0 else 0 for actual, total in zip(div_with_unstructured_by_round, div_no_unstructured_by_round)]\\n\\n #print(\\\"comparison:\\\", divergence_by_round)\\n #print(\\\"base_diff:\\\", div_no_unstructured_by_round)\\n #print(\\\"ratio:\\\", divergence_ratio)\\n\\n participant_differences[participant] = (game_diffs, random_others_combination, div_no_unstructured_by_round, divergence_ratio)\\n\\n return participant_differences\",\n \"def getNet(chrom, loops, genes, pdis=2000, gap=1):\\n #step 1 get merged anchors\\n anchors = stichAnchors(chrom, loops, margin=gap)\\n #step 2 annotate anchors\\n nanchors = {}\\n ts = np.array([[tss] for tss in genes.keys()])\\n tree = KDTree(ts)\\n for anchor in anchors:\\n gs, ds = findOverlapOrNearest(genes, ts, tree, anchor.start,\\n anchor.end)\\n if len(gs) > 1:\\n t = \\\"Promoter\\\"\\n d = 0\\n else:\\n d = ds[0]\\n if abs(d) <= pdis:\\n t = \\\"Promoter\\\"\\n else:\\n t = \\\"Enhancer\\\"\\n n = anchor.chrom + \\\":\\\" + str(anchor.start) + \\\"-\\\" + str(\\n anchor.end) + \\\"|\\\" + t\\n nanchors[n] = {\\n \\\"chrom\\\":\\n anchor.chrom,\\n \\\"start\\\":\\n anchor.start,\\n \\\"end\\\":\\n anchor.end,\\n \\\"type\\\":\\n n.split(\\\"|\\\")[-1],\\n \\\"nearestDistanceToTSS\\\":\\n d,\\n \\\"nearestGene\\\":\\n \\\",\\\".join([g.name for g in gs]),\\n \\\"nearestGeneLoc\\\":\\n \\\",\\\".join([\\n g.chrom + \\\":\\\" + str(g.start) + \\\"-\\\" + str(g.end) + \\\"|\\\" +\\n g.strand + \\\"|\\\" + g.name for g in gs\\n ])\\n }\\n anchors = nanchors\\n del nanchors\\n #step 3 assign each anchor to merged annotated anchor and build the network\\n anchorCov = {}\\n for k, v in anchors.items():\\n for i in range(v[\\\"start\\\"], v[\\\"end\\\"] + 1):\\n anchorCov[i] = k\\n ds = {} #anchor annotations\\n nets = {} #net information\\n G = nx.Graph() #networkx graph structure\\n for loop in loops:\\n xt, yt = None, None\\n for i in range(loop.x_start, loop.x_end + 1):\\n if i in anchorCov:\\n xt = anchorCov[i]\\n break\\n for i in range(loop.y_start, loop.y_end + 1):\\n if i in anchorCov:\\n yt = anchorCov[i]\\n break\\n ds[loop.id] = {\\n \\\"mergedAnchorA\\\": xt,\\n \\\"mergedAnchorB\\\": yt,\\n }\\n if xt == yt:\\n continue\\n ns = [xt, yt]\\n ns.sort() #sort for converging keys\\n if ns[0] not in nets:\\n nets[ns[0]] = set()\\n nets[ns[0]].add(ns[1])\\n #network edges\\n G.add_edge(ns[0], ns[1])\\n #step 4 find all enhancers linked to target gene\\n targets = {}\\n #step 4.1 find the direct enhancer that link to promoter\\n for node in G.nodes:\\n if node.split(\\\"|\\\")[-1] == \\\"Promoter\\\":\\n if node in targets:\\n continue\\n targets[node] = {\\n \\\"targetGene\\\": anchors[node][\\\"nearestGeneLoc\\\"],\\n \\\"directEnhancer\\\": set(),\\n \\\"indirectEnhancer\\\": set(),\\n \\\"directPromoter\\\": set(),\\n \\\"indirectPromoter\\\": set()\\n }\\n ns = list(nx.descendants(G, node))\\n #find all releated nodes\\n for n in ns:\\n p = nx.algorithms.shortest_path(G, source=node, target=n)\\n if n.split(\\\"|\\\")[-1] == \\\"Promoter\\\":\\n if len(p) == 2:\\n targets[node][\\\"directPromoter\\\"].add(n)\\n else:\\n targets[node][\\\"indirectPromoter\\\"].add(n)\\n if n.split(\\\"|\\\")[-1] == \\\"Enhancer\\\":\\n if len(p) == 2:\\n targets[node][\\\"directEnhancer\\\"].add(n)\\n else:\\n targets[node][\\\"indirectEnhancer\\\"].add(n)\\n #step 4.2. find hub enhancer\\n #only using non-redundant node to find hubs\\n nns = []\\n tmp = set()\\n for n in ns:\\n tn = n.split(\\\"|\\\")[0]\\n if tn not in tmp:\\n nns.append(n)\\n tmp.add(tn)\\n ns = list(nns)\\n ns.append(node)\\n subg = G.subgraph(ns)\\n try:\\n hubs, authorities = nx.hits(subg,\\n max_iter=1000,\\n normalized=True)\\n except:\\n print(\\n \\\"For %s, hard to find the hub by running HITS algorithm of 1000 iteration.\\\"\\n % node)\\n targets[node][\\\"directEnhancerHub\\\"] = \\\"\\\"\\n targets[node][\\\"indirectEnhancerHub\\\"] = \\\"\\\"\\n continue\\n hubs = pd.Series(hubs)\\n hubs = hubs.sort_values(inplace=False, ascending=False)\\n if len(targets[node][\\\"directEnhancer\\\"]) >= 2:\\n des = hubs[list(targets[node][\\\"directEnhancer\\\"])]\\n des = des.sort_values(inplace=False, ascending=False)\\n targets[node][\\\"directEnhancerHub\\\"] = des.index[0]\\n else:\\n targets[node][\\\"directEnhancerHub\\\"] = \\\"\\\"\\n if len(targets[node][\\\"indirectEnhancer\\\"]) >= 2:\\n indes = hubs[list(targets[node][\\\"indirectEnhancer\\\"])]\\n indes = indes.sort_values(inplace=False, ascending=False)\\n targets[node][\\\"indirectEnhancerHub\\\"] = indes.index[0]\\n else:\\n targets[node][\\\"indirectEnhancerHub\\\"] = \\\"\\\"\\n return anchors, ds, nets, targets\",\n \"def checkNumNeighbors():\",\n \"def test_weight(self):\\n # Folder must be root to load in make_net properly\\n if os.getcwd().split('\\\\\\\\')[-1] == 'tests': os.chdir('..')\\n \\n # Create parents\\n cfg = Config()\\n cfg.genome.weight_min_value = -2\\n cfg.genome.weight_max_value = 2\\n gene1, gene2 = get_connection_genes((-1, 0), cfg.genome)\\n \\n # Ratio of 0.5, so possible to cross to both parents\\n p1 = False\\n p2 = False\\n for _ in range(100):\\n gene3 = gene1.crossover(other=gene2, cfg=cfg.genome, ratio=0.5)\\n if gene3.weight == gene1.weight:\\n p1 = True\\n elif gene3.weight == gene2.weight:\\n p2 = True\\n else:\\n raise self.failureException(\\\"Must be mutated to one of parent's values\\\")\\n if p1 and p2: break\\n self.assertTrue(p1 and p2)\\n \\n # Ratio of 1, so always inherits from first parent\\n for _ in range(100):\\n gene3 = gene1.crossover(other=gene2, cfg=cfg.genome, ratio=1)\\n self.assertEqual(gene3.weight, gene1.weight)\\n \\n # Ratio of 0, so always inherits from second parent\\n for _ in range(100):\\n gene3 = gene1.crossover(other=gene2, cfg=cfg.genome, ratio=0)\\n self.assertEqual(gene3.weight, gene2.weight)\",\n \"def get_GNS_cut(self):\\n # we build the optimization around the casted digraph instead of multidigraph\\n # for simplicity\\n G = self.base_digraph\\n s_1 = self.sources[0]\\n s_2 = self.sources[1]\\n t_1 = self.destinations[0]\\n t_2 = self.destinations[1]\\n edges = G.edges()\\n nodes = G.nodes()\\n\\n try:\\n\\n # Great an gurobi instance of the optimization model\\n m = Model(\\\"GNS\\\")\\n m.setParam('OutputFlag', False)\\n\\n x_v = {}\\n # vertex variables for s_1, t_1 cut\\n for v in nodes:\\n x_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n x_e = {}\\n # edge variables for s_1, t_1 cut\\n for (u,v) in edges:\\n x_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n y_v = {}\\n # vertex variables for s_2, t_2 cut\\n for v in nodes:\\n y_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n y_e = {}\\n # edge variables for s_2, t_2 cut\\n for (u,v) in edges:\\n y_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n z_v = {}\\n # vertex variables for s_2, t_1 cut\\n for v in nodes:\\n z_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n z_e = {}\\n # edge variables for s_2, t_1 cut\\n for (u,v) in edges:\\n z_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n e = {}\\n # GNS indicator variable\\n for (u,v) in edges:\\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\\n\\n # Done with decision variable creation\\n # update model\\n m.update()\\n\\n # Constraints\\n # 1. Constraints for s_1 - t_1 cut\\n for (u,v) in edges:\\n if (u,v) == (s_1, t_1):\\n m.addConstr(x_e[u,v] >= 1)\\n elif u == s_1:\\n m.addConstr(x_v[v] + x_e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-x_v[u] + x_e[u,v] >= 0)\\n else:\\n m.addConstr(x_v[v] - x_v[u] + x_e[u,v] >= 0)\\n\\n # 2. Constraints for s_2 - t_2 cut\\n for (u,v) in edges:\\n if (u,v) == (s_2, t_2):\\n m.addConstr(y_e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(y_v[v] + y_e[u,v] >= 1)\\n elif v == t_2:\\n m.addConstr(-y_v[u] + y_e[u,v] >= 0)\\n else:\\n m.addConstr(y_v[v] - y_v[u] + y_e[u,v] >= 0)\\n\\n # 3. Constraints for s_2 - t_1 cut\\n for (u,v) in edges:\\n if (u,v) == (s_2, t_1):\\n m.addConstr(z_e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(z_v[v] + z_e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-z_v[u] + z_e[u,v] >= 0)\\n else:\\n m.addConstr(z_v[v] - z_v[u] + z_e[u,v] >= 0)\\n\\n # 4. Constraints for e[u,v] >= max(x_e[u,v], y_e[u,v], z_e[u,v])\\n for (u,v) in edges:\\n m.addConstr(e[u,v] >= x_e[u,v])\\n m.addConstr(e[u,v] >= y_e[u,v])\\n m.addConstr(e[u,v] >= z_e[u,v])\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n print \\\"Min GNS cut value = \\\" + str(m.objVal)\\n print \\\"GNS cut edges:\\\"\\n\\n for u,v in edges:\\n if e[u,v].x != 0:\\n print (u,v)\\n print \\\"s1-t1 cut edges in GNS:\\\"\\n for u,v in edges:\\n if x_e[u,v].x != 0:\\n print (u,v)\\n\\n print \\\"s2-t2 cut edges in GNS:\\\"\\n for u,v in edges:\\n if y_e[u,v].x != 0:\\n print (u,v)\\n\\n print \\\"s2-t1 cut edges in GNS:\\\"\\n for u,v in edges:\\n if z_e[u,v].x != 0:\\n print (u,v)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong\\\"\\n\\n except GurobiError:\\n print ('Error report from Gurobi')\",\n \"def testProtractedCommunityParametersStored(self):\\n self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8], self.c.get_community_references())\\n self.assertEqual(\\n 1, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=100)\\n )\\n self.assertEqual(\\n 2, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=100)\\n )\\n self.assertEqual(\\n 3, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=25, max_speciation_gen=100)\\n )\\n self.assertEqual(\\n 4, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=25, max_speciation_gen=100)\\n )\\n self.assertEqual(\\n 5, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=200)\\n )\\n self.assertEqual(\\n 6, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=200)\\n )\\n self.assertEqual(\\n 7, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=0.0, max_speciation_gen=2000)\\n )\\n self.assertEqual(\\n 8, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=0.0, max_speciation_gen=2000)\\n )\\n ed1 = {\\n \\\"speciation_rate\\\": 0.1,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 50,\\n \\\"max_speciation_gen\\\": 100,\\n }\\n ed2 = {\\n \\\"speciation_rate\\\": 0.2,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 50,\\n \\\"max_speciation_gen\\\": 100,\\n }\\n ed3 = {\\n \\\"speciation_rate\\\": 0.1,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 25,\\n \\\"max_speciation_gen\\\": 100,\\n }\\n ed4 = {\\n \\\"speciation_rate\\\": 0.2,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 25,\\n \\\"max_speciation_gen\\\": 100,\\n }\\n ed5 = {\\n \\\"speciation_rate\\\": 0.1,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 50,\\n \\\"max_speciation_gen\\\": 200,\\n }\\n ed6 = {\\n \\\"speciation_rate\\\": 0.2,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 50,\\n \\\"max_speciation_gen\\\": 200,\\n }\\n ed7 = {\\n \\\"speciation_rate\\\": 0.1,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 0.0,\\n \\\"max_speciation_gen\\\": 2000,\\n }\\n ed8 = {\\n \\\"speciation_rate\\\": 0.2,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 0.0,\\n \\\"max_speciation_gen\\\": 2000,\\n }\\n com1_dict = self.c.get_community_parameters(1)\\n com2_dict = self.c.get_community_parameters(2)\\n com3_dict = self.c.get_community_parameters(3)\\n com4_dict = self.c.get_community_parameters(4)\\n com5_dict = self.c.get_community_parameters(5)\\n com6_dict = self.c.get_community_parameters(6)\\n com7_dict = self.c.get_community_parameters(7)\\n com8_dict = self.c.get_community_parameters(8)\\n self.assertEqual(ed1, com1_dict)\\n self.assertEqual(ed2, com2_dict)\\n self.assertEqual(ed3, com3_dict)\\n self.assertEqual(ed4, com4_dict)\\n self.assertEqual(ed5, com5_dict)\\n self.assertEqual(ed6, com6_dict)\\n self.assertEqual(ed7, com7_dict)\\n self.assertEqual(ed8, com8_dict)\",\n \"def testProtractedCommunityParametersStored(self):\\n self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8], self.c.get_community_references())\\n self.assertEqual(\\n 1, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=100)\\n )\\n self.assertEqual(\\n 2, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=100)\\n )\\n self.assertEqual(\\n 3, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=25, max_speciation_gen=100)\\n )\\n self.assertEqual(\\n 4, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=25, max_speciation_gen=100)\\n )\\n self.assertEqual(\\n 5, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=200)\\n )\\n self.assertEqual(\\n 6, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=200)\\n )\\n self.assertEqual(\\n 7, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=0.0, max_speciation_gen=2000)\\n )\\n self.assertEqual(\\n 8, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=0.0, max_speciation_gen=2000)\\n )\\n ed1 = {\\n \\\"speciation_rate\\\": 0.1,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 50,\\n \\\"max_speciation_gen\\\": 100,\\n }\\n ed2 = {\\n \\\"speciation_rate\\\": 0.2,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 50,\\n \\\"max_speciation_gen\\\": 100,\\n }\\n ed3 = {\\n \\\"speciation_rate\\\": 0.1,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 25,\\n \\\"max_speciation_gen\\\": 100,\\n }\\n ed4 = {\\n \\\"speciation_rate\\\": 0.2,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 25,\\n \\\"max_speciation_gen\\\": 100,\\n }\\n ed5 = {\\n \\\"speciation_rate\\\": 0.1,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 50,\\n \\\"max_speciation_gen\\\": 200,\\n }\\n ed6 = {\\n \\\"speciation_rate\\\": 0.2,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 50,\\n \\\"max_speciation_gen\\\": 200,\\n }\\n ed7 = {\\n \\\"speciation_rate\\\": 0.1,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 0.0,\\n \\\"max_speciation_gen\\\": 2000,\\n }\\n ed8 = {\\n \\\"speciation_rate\\\": 0.2,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 0.0,\\n \\\"max_speciation_gen\\\": 2000,\\n }\\n com1_dict = self.c.get_community_parameters(1)\\n com2_dict = self.c.get_community_parameters(2)\\n com3_dict = self.c.get_community_parameters(3)\\n com4_dict = self.c.get_community_parameters(4)\\n com5_dict = self.c.get_community_parameters(5)\\n com6_dict = self.c.get_community_parameters(6)\\n com7_dict = self.c.get_community_parameters(7)\\n com8_dict = self.c.get_community_parameters(8)\\n self.assertEqual(ed1, com1_dict)\\n self.assertEqual(ed2, com2_dict)\\n self.assertEqual(ed3, com3_dict)\\n self.assertEqual(ed4, com4_dict)\\n self.assertEqual(ed5, com5_dict)\\n self.assertEqual(ed6, com6_dict)\\n self.assertEqual(ed7, com7_dict)\\n self.assertEqual(ed8, com8_dict)\",\n \"def testProtractedCommunityParametersStored(self):\\n self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8], self.c.get_community_references())\\n self.assertEqual(\\n 1, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=100)\\n )\\n self.assertEqual(\\n 2, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=100)\\n )\\n self.assertEqual(\\n 3, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=25, max_speciation_gen=100)\\n )\\n self.assertEqual(\\n 4, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=25, max_speciation_gen=100)\\n )\\n self.assertEqual(\\n 5, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=200)\\n )\\n self.assertEqual(\\n 6, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=50, max_speciation_gen=200)\\n )\\n self.assertEqual(\\n 7, self.c.get_community_reference(0.1, 0.0, False, 0, 0.0, min_speciation_gen=0.0, max_speciation_gen=2000)\\n )\\n self.assertEqual(\\n 8, self.c.get_community_reference(0.2, 0.0, False, 0, 0.0, min_speciation_gen=0.0, max_speciation_gen=2000)\\n )\\n ed1 = {\\n \\\"speciation_rate\\\": 0.1,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 50,\\n \\\"max_speciation_gen\\\": 100,\\n }\\n ed2 = {\\n \\\"speciation_rate\\\": 0.2,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 50,\\n \\\"max_speciation_gen\\\": 100,\\n }\\n ed3 = {\\n \\\"speciation_rate\\\": 0.1,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 25,\\n \\\"max_speciation_gen\\\": 100,\\n }\\n ed4 = {\\n \\\"speciation_rate\\\": 0.2,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 25,\\n \\\"max_speciation_gen\\\": 100,\\n }\\n ed5 = {\\n \\\"speciation_rate\\\": 0.1,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 50,\\n \\\"max_speciation_gen\\\": 200,\\n }\\n ed6 = {\\n \\\"speciation_rate\\\": 0.2,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 50,\\n \\\"max_speciation_gen\\\": 200,\\n }\\n ed7 = {\\n \\\"speciation_rate\\\": 0.1,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 0.0,\\n \\\"max_speciation_gen\\\": 2000,\\n }\\n ed8 = {\\n \\\"speciation_rate\\\": 0.2,\\n \\\"time\\\": 0.0,\\n \\\"fragments\\\": 0,\\n \\\"metacommunity_reference\\\": 0,\\n \\\"min_speciation_gen\\\": 0.0,\\n \\\"max_speciation_gen\\\": 2000,\\n }\\n com1_dict = self.c.get_community_parameters(1)\\n com2_dict = self.c.get_community_parameters(2)\\n com3_dict = self.c.get_community_parameters(3)\\n com4_dict = self.c.get_community_parameters(4)\\n com5_dict = self.c.get_community_parameters(5)\\n com6_dict = self.c.get_community_parameters(6)\\n com7_dict = self.c.get_community_parameters(7)\\n com8_dict = self.c.get_community_parameters(8)\\n self.assertEqual(ed1, com1_dict)\\n self.assertEqual(ed2, com2_dict)\\n self.assertEqual(ed3, com3_dict)\\n self.assertEqual(ed4, com4_dict)\\n self.assertEqual(ed5, com5_dict)\\n self.assertEqual(ed6, com6_dict)\\n self.assertEqual(ed7, com7_dict)\\n self.assertEqual(ed8, com8_dict)\",\n \"def test_local_efficiency_complete_graph(self):\\n for n in range(3, 10):\\n G = nx.complete_graph(n)\\n assert_equal(nx.local_efficiency(G), 1)\",\n \"def compute_W2(elec_sets, districts, min_cand_weights_dict, black_pref_cands_df, hisp_pref_cands_df, \\\\\\n cand_race_dict):\\n \\n min_cand_black_W2 = np.empty((len(elec_sets),0), float)\\n min_cand_hisp_W2 = np.empty((len(elec_sets),0), float)\\n min_cand_neither_W2 = np.empty((len(elec_sets),0), float)\\n \\n for dist in districts:\\n black_pref = list(black_pref_cands_df[dist])\\n\\n black_pref_race = [cand_race_dict[bp] for bp in black_pref]\\n black_cand_weight = [min_cand_weights_dict[\\\"Relevant Minority\\\"] if \\\"Black\\\" in bpr else \\\\\\n min_cand_weights_dict[\\\"Other\\\"] for bpr in black_pref_race]\\n min_cand_black_W2 = np.append(min_cand_black_W2, np.array([black_cand_weight]).transpose(), axis = 1)\\n \\n hisp_pref = list(hisp_pref_cands_df[dist])\\n hisp_pref_race = [cand_race_dict[hp] for hp in hisp_pref]\\n hisp_cand_weight = [min_cand_weights_dict[\\\"Relevant Minority\\\"] if \\\"Hispanic\\\" in hpr else \\\\\\n min_cand_weights_dict[\\\"Other\\\"] for hpr in hisp_pref_race]\\n min_cand_hisp_W2 = np.append(min_cand_hisp_W2, np.array([hisp_cand_weight]).transpose(), axis = 1)\\n \\n neither_cand_weight = [min_cand_weights_dict['Relevant Minority'] if ('Hispanic' in hpr and 'Black' in bpr) else\\\\\\n min_cand_weights_dict['Other'] if ('Hispanic' not in hpr and 'Black' not in bpr) else \\\\\\n min_cand_weights_dict['Partial '] for bpr,hpr in zip(black_pref_race, hisp_pref_race)]\\n min_cand_neither_W2 = np.append(min_cand_neither_W2, np.array([neither_cand_weight]).transpose(), axis = 1)\\n \\n return min_cand_black_W2, min_cand_hisp_W2, min_cand_neither_W2\",\n \"def testOutputCandidateDesignAssignmentsWithSusbetOfPairs(self):\\n pretest_data = pd.DataFrame({\\n 'date': pd.to_datetime(['2019-01-01', '2019-10-01'] * 20),\\n 'geo': sorted(list(range(20)) * 2),\\n 'response': range(100, 140),\\n 'spend': range(40),\\n })\\n test_class = TrimmedMatchGeoXDesign(\\n GeoXType.HEAVY_UP,\\n pretest_data=pretest_data,\\n time_window_for_design=self.design_window,\\n time_window_for_eval=self.evaluation_window,\\n )\\n\\n _ = test_class.report_candidate_designs(\\n budget_list=[30],\\n iroas_list=[0],\\n use_cross_validation=True,\\n num_simulations=10,\\n )\\n test_class.generate_balanced_assignment(pair_index=1, base_seed=0)\\n self.assertTrue(\\n test_class.geo_level_eval_data[1].equals(\\n pd.DataFrame({\\n 'geo': list(range(2, 20)),\\n 'pair': sorted(list(range(2, 11)) * 2),\\n 'response': [101 + 2 * x for x in range(2, 20)],\\n 'spend': [1 + 2 * x for x in range(2, 20)],\\n 'assignment': [\\n TREATMENT, CONTROL, CONTROL, TREATMENT, CONTROL, TREATMENT,\\n CONTROL, TREATMENT, CONTROL, TREATMENT, TREATMENT, CONTROL,\\n TREATMENT, CONTROL, TREATMENT, CONTROL, CONTROL, TREATMENT\\n ]\\n })))\\n\\n test_class.generate_balanced_assignment(\\n pair_index=2, base_seed=0)\\n self.assertTrue(\\n test_class.geo_level_eval_data[2].equals(\\n pd.DataFrame({\\n 'geo': list(range(4, 20)),\\n 'pair': sorted(list(range(3, 11)) * 2),\\n 'response': [101 + 2 * x for x in range(4, 20)],\\n 'spend': [1 + 2 * x for x in range(4, 20)],\\n 'assignment': [CONTROL, TREATMENT, TREATMENT, CONTROL, CONTROL,\\n TREATMENT, CONTROL, TREATMENT, CONTROL,\\n TREATMENT, CONTROL, TREATMENT, TREATMENT,\\n CONTROL, TREATMENT, CONTROL]\\n })))\",\n \"def make_get_minimum_set(gRNA_hits, manual_check = True, exclude_seqs = set(), targets = None,\\n prioritise_nr = False, sc_algorithm = \\\"LAR\\\", num_sets = 1, tie_breaker = None,\\n low_coverage_penalty = 0.5, suppress_warning = False,\\n impossible_set_message = impossible_set_message_default):\\n # ## filter by excluded sequences\\n if exclude_seqs:\\n gRNA_hits.set_seqs_check(\\\"exclude\\\", False, [str(s) for s in exclude_seqs])\\n gRNA_hits = gRNA_hits.filter_seqs_all_checks_passed(quiet = suppress_warning)\\n gRNA_hits = gRNA_hits.filter_hits_all_checks_passed(quiet = suppress_warning)\\n if prioritise_nr:\\n set_cover = make_set_cover_nr(gRNA_hits, num_sets = num_sets, target_ids = targets,\\n num_lengths_to_track = None,\\n low_coverage_penalty = low_coverage_penalty,\\n suppress_warning = suppress_warning)\\n else:\\n ## tie breakers should return 2 values: <gRNASeq>, [<gRNAHits>]\\n ## note: If antisense, tie break by minimum -end. Else, tie break by minimum start.\\n ## note: tie-breaker uses AVERAGE distance of hits (to inferred N-terminus)\\n if tie_breaker is None:\\n tie_breaker = lambda *args: tuple(all_best_pos(*args).items())[0]\\n set_cover = make_set_cover_pos(gRNA_hits, num_sets = num_sets, target_ids = targets,\\n algorithm = sc_algorithm, id_key = lambda x:x.target_id,\\n tie_breaker = tie_breaker,\\n suppress_warning = suppress_warning)\\n set_num = [0]\\n def get_minimum_set():\\n restore = []\\n set_num[0] += 1\\n while True:\\n ## solve set_cover\\n selected_grna = set_cover(restore = restore)\\n restore = selected_grna\\n ## if empty set, print message and break out of loop to exit and return the empty set\\n if len(selected_grna) == 0:\\n print(impossible_set_message)\\n break\\n ## if valid set AND manual check NOT requested, break out of loop to exit and return the valid set\\n elif not manual_check: break\\n ## if valid set AND manual check requested\\n else:\\n ## print gRNA sequences in selected_grna to screen for user to evaluate\\n sorted_grna = sorted(selected_grna, key = lambda grna:grna.id)\\n usr_input = manual_check_prompt(sorted_grna, set_num[0])\\n if usr_input.upper() == 'X':\\n break\\n else:\\n ## id_list and seq_list have same order as selected_grna\\n id_list = tuple(grna.id for grna in selected_grna)\\n seq_list = tuple(str(grna.seq).upper() for grna in selected_grna)\\n ## remove gRNA from list of gRNAs to restore upon next set cover generation\\n if usr_input in id_list:\\n index = id_list.index(usr_input)\\n restore.remove(selected_grna[index])\\n elif usr_input.upper() in seq_list:\\n index = seq_list.index(usr_input)\\n restore.remove(selected_grna[index])\\n else:\\n print(\\\"Invalid input.\\\")\\n return [str(grna.seq) for grna in selected_grna]\\n return get_minimum_set\",\n \"def test_expected_growth(self):\\r\\n\\r\\n graph = nx.lollipop_graph(4, 1)\\r\\n graph.add_edge(4, 2)\\r\\n\\r\\n c = [3, 4]\\r\\n result = clique.search(c, graph, iterations=100)\\r\\n assert result == [0, 1, 2, 3]\",\n \"def testSameRMSEWhenPairsAreSpecifiedOrNotDifferentGeoOrder(self):\\n test_class1 = TrimmedMatchGeoXDesign(\\n GeoXType.HEAVY_UP,\\n pretest_data=self.nontrivial_data,\\n time_window_for_design=self.design_window,\\n time_window_for_eval=self.evaluation_window,\\n matching_metrics={'response': 1.0},\\n pairs=None)\\n\\n for geox_type in GeoXType:\\n if geox_type == GeoXType.CONTROL:\\n continue\\n\\n test_class1._geox_type = geox_type\\n _, expected_detailed_results = test_class1.report_candidate_designs(\\n budget_list=[30, 40],\\n iroas_list=[0, 2],\\n use_cross_validation=True,\\n num_simulations=10)\\n\\n # change the order of geo1 and geo2 in some of the pairs\\n pairs = [x.copy() for x in test_class1.pairs]\\n pairs[0].loc[0:3, 'geo1'] = test_class1.pairs[0].loc[0:3, 'geo2']\\n pairs[0].loc[0:3, 'geo2'] = test_class1.pairs[0].loc[0:3, 'geo1']\\n\\n test_class2 = TrimmedMatchGeoXDesign(\\n geox_type,\\n pretest_data=self.nontrivial_data,\\n time_window_for_design=self.design_window,\\n time_window_for_eval=self.evaluation_window,\\n matching_metrics={'response': 1.0},\\n pairs=pairs)\\n _, detailed_results = test_class2.report_candidate_designs(\\n budget_list=[30, 40],\\n iroas_list=[0, 2],\\n use_cross_validation=True,\\n num_simulations=10)\\n\\n for key in detailed_results.keys():\\n self.assertTrue(\\n np.array_equal(detailed_results[key]['estimate'],\\n expected_detailed_results[key]['estimate']))\",\n \"def test_grovers_waltz_basis_gates(self):\\n shots = 2000\\n circuits = ref_algorithms.grovers_circuit(final_measure=True,\\n allow_sampling=True)\\n targets = ref_algorithms.grovers_counts(shots)\\n job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='u1,u2,u3,cx')\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)\",\n \"def test_global_efficiency_complete_graph(self):\\n for n in range(2, 10):\\n G = nx.complete_graph(n)\\n assert_equal(nx.global_efficiency(G), 1)\",\n \"def greedy_build(nodes, priors=None, cutoff=200, considered=set(), uniq='', targets=[]):\\n\\n\\t# Tracks frequency of states for each character in nodes\\n\\tcharacter_mutation_mapping = defaultdict(int)\\n\\n\\t# G models the network that is returned recursively\\n\\tG = nx.DiGraph()\\n\\n\\troot = root_finder(nodes)\\n\\n\\t# Base case check for recursion, returns a graph with one node corresponding to the root of the remaining nodes\\n\\tif len(nodes) <= cutoff or len(nodes) == 1:\\n\\t\\troot = root_finder(nodes)\\n\\t\\tG.add_node(root)\\n\\t\\treturn G, [[root, nodes]]\\n\\n\\t# Accounting for frequency of mutated states per character, in order to choose the best split\\n\\tfor node in nodes:\\n\\t\\tnode_list = node.split(\\\"_\\\")[0].split('|')\\n\\t\\tfor i in range(0, len(node_list)):\\n\\t\\t\\tchar = node_list[i]\\n\\t\\t\\tif char != '0' and char != '-':\\n\\t\\t\\t\\tcharacter_mutation_mapping[(str(i), char)] += 1\\n #if char != '0':\\n # if char == \\\"-\\\":\\n # character_mutation_mapping[(str(i), char)] -= 1\\n # else:\\n # character_mutation_mapping[(str(i), char)] += 1\\n\\n\\t# Choosing the best mutation to split on (ie character and state)\\n\\tcharacter, state = 0, 0\\n\\tmax_cost = 0\\n\\n\\tmin_prior = 1\\n\\tif priors:\\n\\t\\tfor i in priors.keys():\\n\\t\\t\\tfor j in priors[i].keys():\\n\\t\\t\\t\\tmin_prior = min(min_prior, priors[i][j])\\n\\n\\tfor i,j in character_mutation_mapping:\\n\\t\\tif not (i,j) in considered:\\n\\t\\t\\tif not priors:\\n\\t\\t\\t\\tif max_cost < character_mutation_mapping[(i, j)]:\\n\\t\\t\\t\\t\\tmax_cost = character_mutation_mapping[(i, j)]\\n\\t\\t\\t\\t\\tcharacter, state = i, j\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif j not in priors[int(i)]:\\n\\t\\t\\t\\t\\tpriors[int(i)][j] = min_prior\\n\\t\\t\\t\\tif max_cost < -np.log(priors[int(i)][j]) * character_mutation_mapping[(i, j)]:\\n\\t\\t\\t\\t\\tmax_cost = -np.log(priors[int(i)][j]) * character_mutation_mapping[(i, j)]\\n\\t\\t\\t\\t\\tcharacter, state = i, j\\n\\tcharacter = int(character)\\n\\n\\n\\t# If there is no good split left, stop the process and return a graph with the remainder of nodes\\n\\tif character == 0 and state == 0:\\n\\t\\tif len(nodes) == 1:\\n\\t\\t\\tG.add_node(nodes[0])\\n\\t\\telse:\\n\\t\\t\\tfor i in range(0, len(nodes)):\\n\\t\\t\\t\\tif nodes[i] != root:\\n\\t\\t\\t\\t\\tG.add_edge(root, nodes[i])\\n\\t\\treturn G, []\\n\\n\\t# Splitting nodes based on whether they have the mutation, don't have the mutation, or are NA('-') in that character\\n\\t# Right split is where nodes with the mutation go, everyone else goes to left split or NA chars\\n\\tleft_split, right_split, NA_chars = [], [], []\\n\\tright_split_temp = []\\n\\tleft_split_temp = []\\n\\tfor node in nodes:\\n\\t\\tnode_list = node.split('|')\\n\\t\\tif node_list[character] == state:\\n\\t\\t\\tright_split.append(node)\\n\\t\\telif node_list[character] == '-':\\n\\t\\t\\tNA_chars.append(node)\\n\\t\\telse:\\n\\t\\t\\tleft_split.append(node)\\n\\n\\n\\t# Seperates all nodes with NA in the character chosen to be split upon\\n\\t# Puts in right split or left split based on which list shares more mutated characters with this string\\n\\tfor node in NA_chars:\\n\\t\\tright_split_score = 0\\n\\t\\tleft_split_score = 0\\n\\t\\tnode_list = node.split('|')\\n\\t\\tnum_not_missing = len([n for n in node_list if n != \\\"-\\\"])\\n\\t\\tfor i in range(0, len(node_list)):\\n\\t\\t\\tif node_list[i] != '0' and node_list[i] != '-':\\n\\t\\t\\t\\tfor node_2 in left_split:\\n\\t\\t\\t\\t\\tnode2_list = node_2.split('|')\\n\\t\\t\\t\\t\\tif node_list[i] == node2_list[i]:\\n\\t\\t\\t\\t\\t\\tleft_split_score += 1\\n\\t\\t\\t\\tfor node_2 in right_split:\\n\\t\\t\\t\\t\\tnode2_list = node_2.split('|')\\n\\t\\t\\t\\t\\tif node_list[i] == node2_list[i]:\\n\\t\\t\\t\\t\\t\\tright_split_score += 1\\n\\n\\t\\tavg_left_split_score = left_split_score / float(len(left_split) * num_not_missing + 1)\\n\\t\\tavg_right_split_score = right_split_score / float(len(right_split) * num_not_missing + 1)\\n\\n\\t\\tif avg_left_split_score < avg_right_split_score:\\n\\t\\t\\tright_split_temp.append(node)\\n\\t\\telse:\\n\\t\\t\\tleft_split_temp.append(node)\\n\\n\\tright_split += right_split_temp\\n\\tleft_split += left_split_temp\\n\\n\\t# Add character, state that split occurred to already considered mutations\\n\\tconsidered.add((str(character), state))\\n\\tG = nx.DiGraph()\\n\\t#splitter = str(character) + \\\" \\\" + str(state) + \\\" (\\\" + uniq + \\\")\\\"\\n\\tsplitter = root\\n\\n\\t# Recursively build left side of network (ie side that did not mutation at the character with the specific state)\\n\\tG.add_node(splitter)\\n\\tleft_subproblems = []\\n\\tleft_network = None\\n\\tif len(left_split) != 0:\\n\\t\\tleft_root = root_finder(left_split)\\n\\t\\t# if left_root not in left_split and left_root in targets:\\n\\t\\t# \\tleft_root = left_root + \\\"_unique\\\"\\n\\n\\t\\tleft_network, left_subproblems = greedy_build(left_split, priors, cutoff, considered.copy(), uniq + \\\"0\\\", targets=targets)\\n\\n\\t\\tleft_nodes = [node for node in left_network.nodes() if left_network.in_degree(node) == 0]\\n\\t\\tdup_dict = {}\\n\\t\\tfor n in left_network:\\n\\t\\t\\tif n in list(G.nodes()) and n != left_root:\\n\\t\\t\\t\\tdup_dict[n] = n + \\\"_\\\" + str(hashlib.md5(left_root.encode('utf-8')).hexdigest())\\n\\t\\tleft_network = nx.relabel_nodes(left_network, dup_dict)\\n\\t\\tG = nx.compose(G, left_network)\\n\\t\\tif root != left_root:\\n\\t\\t\\tG.add_edge(splitter, left_root, weight=0, label=\\\"None\\\")\\n\\n\\t# Recursively build right side of network\\n\\tright_network, right_subproblems = greedy_build(right_split, priors, cutoff, considered.copy(), uniq + \\\"1\\\", targets=targets)\\n\\tright_nodes = [node for node in right_network.nodes() if right_network.in_degree(node) == 0]\\n\\tright_root = root_finder(right_split)\\n\\n\\tdup_dict = {}\\n\\tfor n in right_network:\\n\\t\\tif n in list(G.nodes()) and n != right_root:\\n\\t\\t\\tdup_dict[n] = n + \\\"_\\\" + str(hashlib.md5(right_root.encode('utf-8')).hexdigest())\\n\\tfor n in dup_dict:\\n\\t\\trename_dict = {n: dup_dict[n]}\\n\\t\\tif right_network.out_degree(n) != 0:\\n\\t\\t\\tright_network = nx.relabel_nodes(right_network, rename_dict)\\n\\t\\telse:\\n\\t\\t\\trename_dict = {n: dup_dict[n]}\\n\\t\\t\\tG = nx.relabel_nodes(G, rename_dict)\\n\\n\\tG = nx.compose(G, right_network)\\n\\t# if right_root not in right_split and right_root in targets:\\n\\t# \\tright_root = right_root + \\\"_unique\\\"\\n\\t#for node in right_nodes:\\n\\tif root != right_root:\\n\\t\\tif not priors:\\n\\t\\t\\tG.add_edge(splitter, right_root, weight=1, label = str(character) + \\\": 0 -> \\\" + str(state))\\n\\t\\telse:\\n\\t\\t\\tG.add_edge(splitter, right_root, weight=-np.log(priors[int(character)][state]), label=str(character) + \\\": 0 -> \\\" + str(state))\\n\\n\\n\\treturn G, left_subproblems + right_subproblems\",\n \"def simulate_weakest_ties(participant_data,\\n true_distro_by_round,\\n network_topology_name,\\n additional_name_count,\\n divergence_type=\\\"JS\\\",\\n memory_length=5,\\n graph=False):\\n\\n participant_differences = {}\\n\\n net = nb.net(network_topology_name)\\n weakest_links = net.calc_weakest_ties(additional_name_count)\\n\\n # We start by going through each participant\\n for participant, data in participant_data.items():\\n # and we're going to calculate the total divergence for each weakest link\\n\\n # First we look at the overall divergence without unstructured names\\n div_no_unstructured_by_round = []\\n\\n distro_by_round_no_unstructured = impose_limited_memory(data[\\\"distro_by_round_no_unstructured\\\"],\\n memory_length=memory_length)\\n for game_round in range(1,26):\\n\\n # a new list of names needs to be truncated to induce some memory\\n seen_distro_with_no_unstructured, true_distro = create_continuity_and_probabilities(\\n distro_by_round_no_unstructured[game_round],\\n true_distro_by_round[game_round])\\n\\n # divergence between real and distro with additional names\\n if divergence_type == \\\"JS\\\":\\n div_no_unstructured_by_round.append(JS(seen_distro_with_no_unstructured, true_distro))\\n else:\\n div_no_unstructured_by_round.append(KL(seen_distro_with_no_unstructured, true_distro))\\n\\n\\n # Next we calculate the divergence for the real rounds with unstructured\\n div_with_unstructured_by_round = []\\n\\n distro_by_round_unstructured = impose_limited_memory(data[\\\"distro_by_round_unstructured\\\"],\\n memory_length=memory_length)\\n for game_round in range(1,26):\\n\\n # a new list of names needs to be truncated to induce some memory\\n seen_distro_with_unstructured, true_distro_2 = create_continuity_and_probabilities(\\n distro_by_round_unstructured[game_round],\\n true_distro_by_round[game_round])\\n # divergence between real and distro with additional names\\n if divergence_type == \\\"JS\\\":\\n div_with_unstructured_by_round.append(JS(seen_distro_with_unstructured, true_distro_2))\\n else:\\n div_with_unstructured_by_round.append(KL(seen_distro_with_unstructured, true_distro_2))\\n\\n names_to_add_by_round = defaultdict(list)\\n for new_alter in weakest_links[participant]:\\n # We get the name played by the partic. and append it to lists of names for each round\\n for round, name in enumerate(participant_data[new_alter][\\\"names_played\\\"]):\\n names_to_add_by_round[round].append(name)\\n\\n # We go through round by round and add in the newly visible names\\n simulated_distro_by_round = {}\\n\\n for game_round in range(1,26):\\n no_unstructured = list(data[\\\"distro_by_round_no_unstructured\\\"][game_round])\\n no_unstructured.extend(names_to_add_by_round[game_round])\\n simulated_distro_by_round[game_round] = no_unstructured\\n\\n # That new list of names needs to be truncated to induce some memory\\n distro_by_round_weakest_link = impose_limited_memory(simulated_distro_by_round,\\n memory_length=memory_length)\\n\\n divergence_weakest_by_round = []\\n for game_round in range(1,26):\\n\\n seen_distro_weakest_link, true_distro = create_continuity_and_probabilities(\\n distro_by_round_weakest_link[game_round],\\n true_distro_by_round[game_round])\\n\\n\\n # Then we calculate the divergence from distro with weakest link to true distro\\n if divergence_type == \\\"JS\\\":\\n div_with_weakest_link = JS(seen_distro_weakest_link, true_distro)\\n else:\\n div_with_weakest_link = KL(seen_distro_weakest_link, true_distro)\\n divergence_weakest_by_round.append(div_with_weakest_link)\\n\\n game_diffs = [i-j for i, j in zip(divergence_weakest_by_round,div_with_unstructured_by_round)]\\n\\n\\n\\n divergence_ratio = [1 - actual/total if total !=0 else 0 for actual, total in zip(div_with_unstructured_by_round, div_no_unstructured_by_round)]\\n\\n #print(\\\"comparison:\\\", divergence_weakest_by_round)\\n #print(\\\"base_diff:\\\", div_no_unstructured_by_round)\\n #print(\\\"ratio:\\\", divergence_ratio)\\n\\n participant_differences[participant] = (game_diffs,\\n weakest_links[participant],\\n div_no_unstructured_by_round,\\n divergence_ratio)\\n\\n return participant_differences\",\n \"def test_using_ego_graph(self):\\n assert_equal(nx.local_efficiency(self.G3), 7 / 12)\",\n \"def build_graphs_each_team(df_all_stats, curr_year, curr_team):\\n idx = (df_all_stats[curr_year]['Tm'] == curr_team) & (df_all_stats[curr_year]['MP_adv'] > 200)\\n Team_df = df_all_stats[curr_year][['Player', 'AST', 'PS/G', 'Pos', 'MP']][idx]\\n # can't keep everyone bc some rosters bigger than others so will mess up stats - taking the top 8 players\\n Team_df = Team_df.sort_values(['MP'], ascending=False)\\n Team_df = Team_df.iloc[0:8]\\n curr_team_ast_pts = Team_df[['AST', 'PS/G']].values\\n summed_ast_pts = curr_team_ast_pts.sum(axis=0)\\n # lets make a matrix of all pairwise comparisons\\n all_pairwise_edges = np.ndarray(shape= (np.shape(curr_team_ast_pts)[0], np.shape(curr_team_ast_pts)[0]))\\n # build the ratio for edges = (100 * AST for a person / AST total) * (100 * PTS for a person / PTS total)\\n for i in range(0, np.shape(curr_team_ast_pts)[0]):\\n for j in range(0, np.shape(curr_team_ast_pts)[0]):\\n# all_pairwise_edges[i,j] = (100 * curr_team_ast_pts[i][0]/summed_ast_pts[0])\\n# * (100 * curr_team_ast_pts[j][1]/summed_ast_pts[1])\\n all_pairwise_edges[i, j] = (curr_team_ast_pts[i][0]) * (curr_team_ast_pts[j][1])\\n # for the nodes lets use player names\\n pnames = Team_df['Player'].tolist()\\n curr_positions = Team_df['Pos'].tolist()\\n minutes_played = Team_df['MP'].tolist()\\n ast_given = Team_df['AST'].tolist()\\n node_size_use = Team_df['PS/G']\\n node_size_use = node_size_use.as_matrix()\\n G = nx.DiGraph()\\n G.add_nodes_from(pnames)\\n # to save the PS/G for node size later\\n points_per_game = {}\\n pos_ = {}\\n mp_ = {}\\n ast_ = {}\\n for i in range(0, len(pnames)):\\n points_per_game[pnames[i]] = node_size_use[i]\\n pos_[pnames[i]] = curr_positions[i]\\n mp_[pnames[i]] = minutes_played[i]\\n ast_[pnames[i]] = ast_given[i]\\n nx.set_node_attributes(G, points_per_game, 'ppg')\\n nx.set_node_attributes(G, pos_, 'pos')\\n nx.set_node_attributes(G, mp_, 'mp')\\n nx.set_node_attributes(G, ast_, 'ast')\\n labels_use = {}\\n outward_vs_inward_direction = []\\n for i in range(0, np.shape(curr_team_ast_pts)[0]):\\n labels_use[pnames[i]] = pnames[i]\\n# for j in range(0,np.shape(curr_team_ast_pts)[0]):\\n# G.add_edge(pnames[i],pnames[j], weight= all_pairwise_edges[i,j])\\n# G.add_edge(pnames[j],pnames[i], weight= all_pairwise_edges[j,i])\\n for j in range(i+1, np.shape(curr_team_ast_pts)[0]):\\n if (all_pairwise_edges[i, j] > all_pairwise_edges[j, i]) & (all_pairwise_edges[i, j] > 5):\\n G.add_edge(pnames[i], pnames[j], weight=all_pairwise_edges[i, j])\\n outward_vs_inward_direction.append('k')\\n elif (all_pairwise_edges[j, i] > all_pairwise_edges[i, j]) & (all_pairwise_edges[j, i] > 5):\\n G.add_edge(pnames[j], pnames[i], weight=all_pairwise_edges[j, i])\\n outward_vs_inward_direction.append('k')\\n return G\",\n \"def match_detections(self, ground_truths, detections):\\n\\t\\tif not ground_truths or not detections:\\n\\t\\t\\treturn (0.,0.,(0.,len(detections)), (0., len(ground_truths)))\\n\\n\\t\\tground_truths, detections = ObjectAreaEvaluator.prune_and_polygon(ground_truths, detections)\\n\\t\\tground_truth_count = len(ground_truths)\\n\\t\\tdetection_count = len(detections)\\n\\t\\tif ground_truth_count == 0 or detection_count == 0:\\n\\t\\t\\treturn (0., 0., (0., float(detection_count)), (0., float(ground_truth_count)))\\n\\n\\t\\tprecision_matrix, recall_matrix = self.build_matrices(ground_truths, detections)\\n\\t\\tground_truth_count = precision_matrix.shape[0]\\n\\t\\tdetection_count = precision_matrix.shape[1]\\n\\t\\tground_truth_sets_precision = defaultdict(set) # number of ground truth items that match a particular detection in the precision matrix\\n\\t\\tdetection_sets_precision = defaultdict(set) # number of detection items that match a particular ground truth in the precision matrix\\n\\t\\tground_truth_sets_recall = defaultdict(set) # number of ground truth items that match a particular detection in the recall matrix\\n\\t\\tdetection_sets_recall = defaultdict(set) # number of detection items that match a particular ground truth in the recall matrix\\n\\n\\t\\tfor gt_index in range(ground_truth_count):\\n\\t\\t\\tfor det_index in range(detection_count):\\n\\t\\t\\t\\tif precision_matrix[gt_index, det_index] >= self.precision_threshold:\\n\\t\\t\\t\\t\\tground_truth_sets_precision[det_index].add(gt_index)\\n\\t\\t\\t\\t\\tdetection_sets_precision[gt_index].add(det_index)\\n\\t\\t\\t\\tif recall_matrix[gt_index, det_index] >= self.recall_threshold:\\n\\t\\t\\t\\t\\tground_truth_sets_recall[det_index].add(gt_index)\\n\\t\\t\\t\\t\\tdetection_sets_recall[gt_index].add(det_index)\\n\\n\\t\\tmatch_ground_truth = [[] for number in xrange(ground_truth_count)]\\n\\t\\tmatch_detection = [[] for number in xrange(detection_count)]\\n\\n\\t\\tfor gt_index in detection_sets_precision:\\n\\t\\t\\tmatching_detections_precision = detection_sets_precision[gt_index]\\n\\t\\t\\tif len(matching_detections_precision) == 1:\\n\\t\\t\\t\\t(detection_precision, ) = matching_detections_precision\\n\\t\\t\\t\\tif len(ground_truth_sets_precision[detection_precision]) == 1:\\n\\t\\t\\t\\t\\tmatch_ground_truth[gt_index].append(detection_precision)\\n\\t\\t\\telse:\\n\\t\\t\\t\\t# one-to-many (one ground truth to many detections)\\n\\t\\t\\t\\tgt_sum = 0.\\n\\t\\t\\t\\tfor detection_precision in matching_detections_precision:\\n\\t\\t\\t\\t\\tgt_sum += recall_matrix[gt_index, detection_precision]\\n\\t\\t\\t\\tif gt_sum >= self.recall_threshold:\\n\\t\\t\\t\\t\\tfor detection_precision in matching_detections_precision:\\n\\t\\t\\t\\t\\t\\tmatch_ground_truth[gt_index].append(detection_precision)\\n\\t\\t\\t\\t\\t\\tmatch_detection[detection_precision].append(gt_index)\\n\\t\\tfor det_index in ground_truth_sets_recall:\\n\\t\\t\\tmatching_ground_truths_recall = ground_truth_sets_recall[det_index]\\n\\t\\t\\tif len(matching_ground_truths_recall) == 1:\\n\\t\\t\\t\\t(ground_truth_recall, ) = matching_ground_truths_recall\\n\\t\\t\\t\\tif len(detection_sets_recall[ground_truth_recall]) == 1:\\n\\t\\t\\t\\t\\tmatch_detection[det_index].append(ground_truth_recall)\\n\\t\\t\\telse:\\n\\t\\t\\t\\t# many-to-one (many ground truths covered by one detection)\\n\\t\\t\\t\\tdet_sum = 0\\n\\t\\t\\t\\tfor ground_truth_recall in matching_ground_truths_recall:\\n\\t\\t\\t\\t\\tdet_sum += precision_matrix[ground_truth_recall, det_index]\\n\\t\\t\\t\\tif det_sum >= self.precision_threshold:\\n\\t\\t\\t\\t\\tfor ground_truth_recall in matching_ground_truths_recall:\\n\\t\\t\\t\\t\\t\\tdet_sum += precision_matrix[ground_truth_recall, det_index]\\n\\t\\t\\t\\t\\t\\tmatch_detection[det_index].append(ground_truth_recall)\\n\\t\\t\\t\\t\\t\\tmatch_ground_truth[ground_truth_recall].append(det_index)\\n\\t\\treturn match_ground_truth, match_detection\",\n \"def no_match():\\n S1=Spectrum.Spectrum()\\n S1.add_peak(50.7,234)\\n S1.add_peak(54.6,585)\\n S1.add_peak(60.7,773)\\n S1.add_peak(65.6,387)\\n S1.add_peak(87.7,546)\\n S1.add_peak(104.6,598)\\n S1.pep_mass=100\\n S1.euclidean_scale()\\n\\n S2=Spectrum.Spectrum()\\n S2.add_peak(50.2,234)\\n S2.add_peak(53.8,585)\\n S2.add_peak(61.3,773)\\n S2.add_peak(66.2,387)\\n S2.add_peak(88.1,546)\\n S2.add_peak(103.9,598)\\n S2.pep_mass=100\\n S2.euclidean_scale()\\n\\n score,peaks=similarity.cosine_score_max(S1,S2)\\n assert peaks==0, \\\"Incorrect number of peaks matched with greedy method\\\"\\n assert score==0, \\\"Incorrect score with greedy method\\\"\\n \\n\\n score,peaks=similarity.cosine_score_greedy(S1,S2)\\n assert peaks==0, \\\"Incorrect number of peaks matched with maximum weighted method\\\"\\n assert score==0, \\\"Incorrect score with maximum weighted method\\\"\",\n \"def main():\\n with open(sys.argv[1], 'r') as test_cases:\\n\\n # Initialize possible pairs, pairs, and social graph Graph\\n possible_pairs = set()\\n pairs = set()\\n social_graph = Graph()\\n\\n # Find true pairs of sender, recipient and vice versa for graph\\n for test in test_cases:\\n # Parse line into sender, recipient\\n parsed_line = test.rstrip().split('\\\\t')\\n sender, recipient = parsed_line[1], parsed_line[2]\\n\\n # Determine which sender, recipient reciprocal pairs exist\\n # Candidates are tested against possible pairs\\n # True pairs are stored in pairs\\n if (recipient, sender) in possible_pairs:\\n pairs.add(frozenset({x for x in (sender, recipient)}))\\n else:\\n possible_pairs.add((sender, recipient))\\n\\n # From pairs, add to social graph\\n for pair in pairs:\\n u, v = pair\\n social_graph.add_pair(u, v)\\n\\n # Compute maximal cliques of size >= 3 only\\n max_cliques_gt_3 = [\\n clique\\n for clique in social_graph.max_cliques()\\n if len(clique) >= 3]\\n\\n # Sort maximal cliques, ascending, and pretty print\\n for cluster in sorted(map(\\n lambda x: \\\", \\\".join(sorted(x)),\\n max_cliques_gt_3)):\\n print cluster\",\n \"def test_grovers_minimal_basis_gates(self):\\n shots = 2000\\n circuits = ref_algorithms.grovers_circuit(final_measure=True,\\n allow_sampling=True)\\n targets = ref_algorithms.grovers_counts(shots)\\n job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='U,CX')\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)\",\n \"def score(tmp_dir, locusList, ranges):\\r\\n\\t\\r\\n\\tloc = ''\\r\\n\\tpos = 1\\r\\n\\tcount_indel = 0\\r\\n\\tholes = 0\\r\\n\\tsnps = 0\\r\\n\\tcovMax=combined_covMax=covSum=covSum2= 0 \\r\\n\\tcovMin = combined_covMin =99999\\r\\n\\tpercentage_coverages =[]\\r\\n\\tsnpList = []\\r\\n\\tindelList = []\\r\\n\\tresults = {} \\r\\n\\t\\r\\n\\tpileup_file = os.path.join(tmp_dir, 'all.pileup')\\r\\n\\tfor l in open(pileup_file):\\r\\n\\t\\tt = l.split()\\r\\n\\t\\tif loc == '':\\r\\n\\t\\t\\tloc = t[0] \\r\\n\\t\\t\\tpos = ranges[loc][0] + 1 \\r\\n\\t\\tif t[0] != loc:\\r\\n\\t\\t\\tresults =GenerateResult(ranges,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tholes, locusList,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tloc,snps,count_indel,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tsnpList, indelList,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tpercentage_coverages,combined_covMin,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcombined_covMax, covMin, covMax,covSum, results)\\r\\n\\t\\t\\t# reset locus vars\\r\\n\\t\\t\\tloc = t[0] \\r\\n\\t\\t\\tpos = ranges[loc][0] + 1 \\r\\n\\t\\t\\tcount_indel = 0\\r\\n\\t\\t\\tholes =snps=covMax=combined_covMax=covSum=covSum2= 0 \\r\\n\\t\\t\\tcovMin =combined_covMin= 99999\\r\\n\\t snpList = []\\r\\n\\t\\t\\tindelList = []\\r\\n\\t\\t\\tpercentage_coverages =[]\\r\\n\\t\\there = int(t[1])\\r\\n\\t\\tif here - 1 < ranges[loc][0]: \\r\\n\\t\\t\\tcontinue\\r\\n\\t\\telif here - 1 >= ranges[loc][1]: \\r\\n\\t\\t\\tcontinue\\r\\n\\t\\twhile pos < here: \\r\\n\\t\\t\\tholes += 1 \\r\\n\\t\\t\\tpos += 1\\r\\n\\r\\n\\t\\tv, indel, array_of_all_indels,most_common_indel = pile(t[2], t[4])\\r\\n\\t\\tx = v.items()\\r\\n\\t\\tx.sort(lambda a,b: compGreater(t[2], a, b))\\r\\n\\t\\t\\r\\n\\t\\tif x[0][0] != t[2].lower():\\r\\n\\t\\t\\tsnps += 1\\r\\n\\t\\t\\tsnpList.append((pos,t[2],v));\\r\\n\\t\\tc = x[0][1] \\r\\n\\t\\tcov= int(most_common_indel)/float(t[3]) \\r\\n\\t\\tif cov > 0.5: \\r\\n count_indel += 1\\r\\n indel_type = Counter(array_of_all_indels) \\r\\n indel_type = indel_type.items()\\r\\n indelList.append((int(pos),t[2], indel_type))\\r\\n\\t\\tcovSum += c \\r\\n\\t\\tcovSum2 += c * c\\r\\n\\t\\tif c > covMax:\\r\\n\\t\\t\\tcovMax = c\\r\\n\\t\\tif c < covMin:\\r\\n\\t\\t\\tcovMin = c\\r\\n\\t\\tcombined_c = x[0][1] + x[1][1] + x[2][1] + x[3][1] \\r\\n\\t\\tif combined_c > combined_covMax:\\r\\n\\t\\t\\tcombined_covMax = c \\r\\n\\t\\tif combined_c < combined_covMin:\\r\\n\\t\\t\\tcombined_covMin = c \\r\\n\\t\\t\\r\\n\\t\\tn = int(t[3]) \\r\\n\\t\\tjs = []\\r\\n\\t\\tfor (_,j) in x[1:]: \\r\\n\\t\\t\\tjs.append(j) \\r\\n\\t\\tpercentage_coverage = sum(js)/float(n)*100 \\r\\n\\t\\tpercentage_coverages.append(round(float(percentage_coverage),2))\\r\\n\\t\\tpos = here + 1\\r\\n\\tresults =GenerateResult(ranges,\\r\\n\\t\\t\\t\\t\\t\\t\\tholes,\\r\\n\\t\\t\\t\\t\\t\\t\\tlocusList,loc,\\r\\n\\t\\t\\t\\t\\t\\t\\tsnps,count_indel,\\r\\n\\t\\t\\t\\t\\t\\t\\tsnpList,indelList,\\r\\n\\t\\t\\t\\t\\t\\t\\tpercentage_coverages,combined_covMin,\\r\\n\\t\\t\\t\\t\\t\\t\\tcombined_covMax, covMin, covMax,\\r\\n\\t\\t\\t\\t\\t\\t\\tcovSum, results)\\r\\n\\t\\r\\n\\treturn results\",\n \"def pc_edge_q_figure(tasks = ['REST','WM','GAMBLING','RELATIONAL','MOTOR','LANGUAGE','SOCIAL']):\\n\\tdriver = 'PC'\\n\\tproject='hcp'\\n\\ttasks = ['REST','WM','GAMBLING','RELATIONAL','MOTOR','LANGUAGE','SOCIAL']\\n\\tatlas = 'power'\\n\\trun_version = 'fz'\\n\\tknown_membership,network_names,num_nodes,name_int_dict = network_labels(atlas)\\n\\tq_corr_matrix = []\\n\\tpc_corr_matrix = []\\n\\t#order by primary versus secondary networks. \\n\\tnetwork_order = ['Auditory','Sensory/somatomotor Hand','Sensory/somatomotor Mouth','Visual','Dorsal attention','Ventral attention',\\n\\t'Cingulo-opercular Task Control','Salience','Fronto-parietal Task Control','Default mode','Cerebellar','Subcortical','Memory retrieval?','Uncertain']\\n\\tcolors = np.array(pd.read_csv('%smodularity/Consensus264.csv'%(homedir),header=None)[34].values)\\n\\tcolors[colors=='Pale blue'] = '#ADD8E6'\\n\\tcolors[colors=='Teal'] = '#008080'\\n\\tswap_indices = []\\n\\tfor nn in network_order:\\n\\t\\toriginal_idx = np.where(network_names == nn)\\n\\t\\tfor i in range(len(original_idx[0])):\\n\\t\\t\\tswap_indices.append(original_idx[0][i])\\n\\tlocality_df = pd.DataFrame()\\n\\tstats = []\\n\\tfor task in tasks:\\n\\t\\tprint task\\n\\t\\tsubjects = np.load('%sdynamic_mod/results/%s_%s_%s_subs_%s.npy' %(homedir,project,task,atlas,run_version))\\n\\t\\tstatic_results = graph_metrics(subjects,task,atlas,run_version)\\n\\t\\tsubject_pcs = static_results['subject_pcs']\\n\\t\\tsubject_mods = static_results['subject_mods']\\n\\t\\tsubject_wmds = static_results['subject_wmds']\\n\\t\\tmatrices = static_results['matrices']\\n\\t\\tassert subject_pcs.shape[0] == len(subjects)\\n\\t\\tmean_pc = np.nanmean(subject_pcs,axis=0)\\n\\t\\tmean_wmd = np.nanmean(subject_wmds,axis=0)\\n\\t\\tmod_pc_corr = np.zeros(subject_pcs.shape[1])\\n\\t\\tfor i in range(subject_pcs.shape[1]):\\n\\t\\t\\tmod_pc_corr[i] = nan_pearsonr(subject_mods,subject_pcs[:,i])[0]\\n\\t\\tmod_wmd_corr = np.zeros(subject_wmds.shape[1])\\n\\t\\tfor i in range(subject_wmds.shape[1]):\\n\\t\\t\\tmod_wmd_corr[i] = nan_pearsonr(subject_mods,subject_wmds[:,i])[0]\\n\\t\\tif driver == 'PC': m = np.load('%s/dynamic_mod/results/full_med_matrix_new_%s.npy'%(homedir,task))\\n\\t\\telse: m = np.load('%s/dynamic_mod/results/full_med_matrix_new_%s_wmds.npy'%(homedir,task))\\n\\t\\tmean_conn = np.nanmean(matrices,axis=0)\\n\\t\\te_tresh = np.percentile(mean_conn,85)\\n\\t\\tfor i in range(264):\\n\\t\\t\\treal_t = scipy.stats.ttest_ind(np.abs(m)[i][np.argwhere(mean_conn[i]>=e_tresh)][:,:,np.arange(264)!=i].reshape(-1),np.abs(m)[i][np.argwhere(mean_conn[i]<e_tresh)][:,:,np.arange(264)!=i].reshape(-1))[0]\\n\\t\\t\\t# real_t = scipy.stats.ttest_ind(m[i][np.argwhere(mean_conn[i]>=e_tresh)][:,:,np.arange(264)!=i].reshape(-1),m[i][np.argwhere(mean_conn[i]<e_tresh)][:,:,np.arange(264)!=i].reshape(-1))[0]\\n\\t\\t\\tif mod_pc_corr[i] > 0.0:\\n\\t\\t\\t\\tlocality_df = locality_df.append({\\\"Node Type\\\":'Connector Hub','t':real_t,'Task':task.capitalize()},ignore_index=True)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tlocality_df = locality_df.append({\\\"Node Type\\\":'Local Node','t':real_t,'Task':task.capitalize()},ignore_index=True)\\n\\t\\tlocality_df.dropna(inplace=True)\\n\\t\\tif driver == 'PC':\\n\\t\\t\\tpredict_nodes = np.where(mod_pc_corr>0.0)[0]\\n\\t\\t\\tlocal_predict_nodes = np.where(mod_pc_corr<0.0)[0]\\n\\t\\t\\tpc_edge_corr = np.arctanh(pc_edge_correlation(subject_pcs,matrices,path='%s/dynamic_mod/results/%s_%s_%s_pc_edge_corr_z.npy' %(homedir,project,task,atlas)))\\n\\t\\tif driver == 'WMD':\\n\\t\\t\\tpredict_nodes = np.where(mod_wmd_corr>0.0)[0]\\n\\t\\t\\tlocal_predict_nodes = np.where(mod_wmd_corr<0.0)[0]\\n\\t\\t\\tpc_edge_corr = np.arctanh(pc_edge_correlation(subject_wmds,matrices,path='%s/dynamic_mod/results/%s_%s_%s_wmd_edge_corr_z.npy' %(homedir,project,task,atlas)))\\n\\t\\tn_nodes = pc_edge_corr.shape[0]\\n\\t\\tq_edge_corr = np.zeros((n_nodes,n_nodes))\\n\\t\\tperf_edge_corr = np.zeros((n_nodes,n_nodes))\\n\\t\\tfor i,j in combinations(range(n_nodes),2):\\n\\t\\t\\tijqcorr = nan_pearsonr(matrices[:,i,j],subject_mods)[0]\\n\\t\\t\\tq_edge_corr[i,j] = ijqcorr\\n\\t\\t\\tq_edge_corr[j,i] = ijqcorr\\n\\t\\t# \\tcontinue\\n\\t\\t# \\tif task not in ['WM','RELATIONAL','SOCIAL','LANGUAGE']:\\n\\t\\t# \\t\\tcontinue\\n\\t\\t# \\tijqcorr = nan_pearsonr(matrices[:,i,j],task_perf)[0]\\n\\t\\t# \\tperf_edge_corr[i,j] = ijqcorr\\n\\t\\t# \\tperf_edge_corr[j,i] = ijqcorr\\n\\t\\tpc_corr_matrix.append(np.nanmean(pc_edge_corr[predict_nodes,:,:],axis=0))\\n\\t\\tq_corr_matrix.append(q_edge_corr)\\n\\t\\t# if task in ['WM','RELATIONAL','SOCIAL','LANGUAGE']:\\n\\t\\t\\t# print nan_pearsonr(perf_edge_corr.reshape(-1),np.nanmean(pc_edge_corr[predict_nodes,:,:],axis=0).reshape(-1))\\n\\t\\t\\t# plot_corr_matrix(perf_edge_corr[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file='%s/dynamic_mod/figures/%s_%s_edge_perf_corr_matrix.pdf'%(homedir,task,run_version),reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\\n\\t\\t# plot_corr_matrix(np.nanmean(m[predict_nodes,:,:],axis=0)[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file='%s/dynamic_mod/figures/%s_%s_%s_mediation_matrix.pdf'%(homedir,task,driver,run_version),reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\\n\\t\\t# plot_corr_matrix(np.nanmean(pc_edge_corr[predict_nodes],axis=0)[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file='%s/dynamic_mod/figures/%s_%s_pcedge__corr_matrix.pdf'%(homedir,task,run_version),reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\\n\\t\\t# plot_corr_matrix(q_edge_corr[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file='%s/dynamic_mod/figures/%s_%s_%s_qedgecorr_matrix.pdf'%(homedir,task,driver,run_version),reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\\n\\tplot_corr_matrix(np.nanmean(q_corr_matrix,axis=0)[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file='%s/dynamic_mod/figures/%s_mean_q_corr_matrix.pdf'%(homedir,run_version),reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\\n\\tplot_corr_matrix(np.nanmean(pc_corr_matrix,axis=0)[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file='%s/dynamic_mod/figures/%s_mean_pc_corr_matrix.pdf'%(homedir,run_version),reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\\n\\tplot_corr_matrix(np.nanmean(m[predict_nodes,:,:],axis=0)[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file='%s/dynamic_mod/figures/%s_%s_mean_mediation_matrix_withbar.pdf'%(homedir,driver,run_version),reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\\t\\n\\t# plot_corr_matrix(np.nanmean(pc_corr_matrix,axis=0)[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file=None,reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\\n\\tf = sns.plt.figure(figsize=(18,6))\\n\\tsns.set_style(\\\"white\\\")\\n\\tsns.set_style(\\\"ticks\\\")\\n\\tsns.set(context=\\\"paper\\\",font='Helvetica',font_scale=1.2)\\n\\tsns.violinplot(data=locality_df[locality_df['Node Type']=='Connector Hub'],x='Task',y='t',hue='Task',inner='quartile',palette=sns.palettes.color_palette('Paired',7))\\n\\tsns.plt.ylabel(\\\"T Test Values, mediation values of node's nieghbors \\\\n versus mediation of node's non-neighbors\\\")\\n\\tsns.plt.legend(bbox_to_anchor=[1,1.05],ncol=7,columnspacing=10)\\n\\tsns.plt.savefig('%s/dynamic_mod/figures/%s_mediation_t_test.pdf'%(homedir,run_version))\\n\\tsns.plt.show()\\n\\n\\t# plot_corr_matrix(mean_conn[:,swap_indices][swap_indices],network_names[swap_indices].copy(),out_file=None,reorder=False,colors=colors[swap_indices],line=True,draw_legend=True,rectangle=False)\",\n \"def minimumTeachings(self, n: int, languages: List[List[int]], friendships: List[List[int]]) -> int:\\n def dfs(p):\\n if p == m + 1:\\n return 0\\n candi = set()\\n for q in f_edges[p]:\\n if q > p and not l_edges[p] & l_edges[q]:\\n candi |= l_edges[q]\\n if not candi:\\n return dfs(p + 1)\\n res = float('inf')\\n for lang in candi:\\n # l_edges[p].add(lang)\\n res = min(res, 1 + dfs(p + 1))\\n # l_edges[p].remove(lang)\\n # print(p, candi, res, l_edges)\\n return res\\n\\n f_edges = defaultdict(set)\\n m = len(languages)\\n for p, q in friendships:\\n f_edges[p].add(q)\\n f_edges[q].add(p)\\n l_edges = defaultdict(set)\\n\\n for i, lst in enumerate(languages, 1):\\n l_edges[i] = set(lst)\\n print('f_edges', f_edges)\\n print('l_edges', l_edges)\\n return dfs(1)\",\n \"def check_stats(mc, div_ratio, max_depth, num_iters=1000, num_cpus=1, plot=False):\\n a_samples, b_samples = (int(mc.num_a / div_ratio), int(mc.num_b / div_ratio))\\n div = (30, 10) # num_samples / x per region\\n new_mc = mc.subsample(a_samples, b_samples)\\n new_mc.create_connections()\\n args_dict = new_mc.compute_stats()\\n print_args_dict(args_dict, out=True)\\n\\n num_samples = np.ceil([a_samples / div[0], b_samples / div[1]]).astype(np.int32)\\n print(\\\"Sampling {}\\\".format(num_samples))\\n\\n if plot:\\n nx_graph = nx_create_graph(new_mc.graph)\\n start, end = new_mc.gen_random_samples(num_samples, zeroed=False)\\n os.makedirs(os.path.join(here, \\\"..\\\", \\\"figures\\\"), exist_ok=True)\\n nx_vis_force(\\n nx_graph,\\n new_mc.a_indices,\\n new_mc.num_a + new_mc.b_indices,\\n start,\\n end,\\n name=os.path.join(here, \\\"..\\\", \\\"figures\\\", \\\"mouse_graph_small.png\\\"),\\n )\\n\\n def random_var_gen(iter_val):\\n start, end = new_mc.gen_random_samples(num_samples, zeroed=False)\\n return start, end\\n\\n def fn_to_eval(start, end):\\n reachable = find_connected_limited(\\n new_mc.graph, start, end, max_depth=max_depth\\n )\\n return (len(reachable),)\\n\\n # Stats check\\n args_dict[\\\"max_depth\\\"] = max_depth\\n args_dict[\\\"total_samples\\\"] = num_samples[0]\\n args_dict[\\\"static_verbose\\\"] = False\\n cp = CombProb(\\n new_mc.num_a,\\n float(num_samples[0]),\\n new_mc.num_senders,\\n new_mc.num_b,\\n float(num_samples[1]),\\n MatrixConnectivity.static_expected_connections,\\n verbose=False,\\n **args_dict,\\n )\\n result_mpf = {\\n \\\"expected\\\": cp.expected_connections(),\\n \\\"total\\\": cp.get_all_prob(),\\n }\\n\\n result = monte_carlo(fn_to_eval, random_var_gen, num_iters, num_cpus=num_cpus)\\n df = list_to_df(\\n result,\\n [\\\"Connections\\\"],\\n )\\n result = summarise_monte_carlo(\\n df,\\n plot=False,\\n )\\n ordered_dist = get_distribution(df, \\\"Connections\\\", num_iters)\\n\\n return {\\n \\\"full_results\\\": df,\\n \\\"summary_stats\\\": result,\\n \\\"dist\\\": ordered_dist,\\n \\\"mpf\\\": result_mpf,\\n \\\"difference\\\": dist_difference(result_mpf[\\\"total\\\"], ordered_dist),\\n }\",\n \"def test_count_neighbors(self):\\n m, n = 5, 5\\n k, p = 0.2, 0.7\\n agents = [ConwayAgent(ii, ii & 0x1 == 1) for ii in range(m * n)]\\n C = ConwayModel(m, n, k, p, agents)\\n\\n to_count = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]])\\n expected = np.array([[1, 1, 2], [2, 3, 1], [0, 2, 1]])\\n result = C.count_neighbors(to_count)\\n self.assertTrue(np.all(expected == result))\",\n \"def rule154_network():\\n # fmt: off\\n tpm = np.array([\\n [0, 0, 0, 0, 0],\\n [0, 1, 0, 0, 1],\\n [1, 0, 1, 0, 0],\\n [1, 0, 1, 0, 1],\\n [0, 1, 0, 1, 0],\\n [0, 0, 0, 1, 1],\\n [1, 1, 0, 1, 0],\\n [1, 1, 0, 1, 1],\\n [0, 0, 1, 0, 1],\\n [0, 1, 1, 0, 0],\\n [1, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0],\\n [0, 1, 1, 0, 1],\\n [0, 0, 1, 0, 0],\\n [1, 1, 1, 0, 1],\\n [1, 1, 1, 0, 0],\\n [1, 0, 0, 1, 0],\\n [0, 1, 0, 1, 1],\\n [0, 0, 1, 1, 0],\\n [1, 0, 1, 1, 1],\\n [1, 1, 0, 0, 0],\\n [0, 0, 0, 0, 1],\\n [0, 1, 0, 0, 0],\\n [1, 1, 0, 0, 1],\\n [1, 0, 1, 1, 0],\\n [0, 1, 1, 1, 1],\\n [0, 0, 0, 1, 0],\\n [1, 0, 0, 1, 1],\\n [1, 1, 1, 1, 0],\\n [0, 0, 1, 1, 1],\\n [0, 1, 1, 1, 0],\\n [1, 1, 1, 1, 1],\\n ])\\n cm = np.array([\\n [1, 1, 0, 0, 1],\\n [1, 1, 1, 0, 0],\\n [0, 1, 1, 1, 0],\\n [0, 0, 1, 1, 1],\\n [1, 0, 0, 1, 1],\\n ])\\n # fmt: on\\n return Network(tpm, cm=cm, node_labels=LABELS[:tpm.shape[1]])\",\n \"def calc_skill_clusters(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, SOM_clusters_block, seas):\\r\\n ds_arr_ones = []\\r\\n for clus in SOM_clusters_block:\\r\\n node_cluster_set_test = [clus]\\r\\n node_cluster_set_test_str = [str(clus).replace(',', '') for clus in node_cluster_set_test]\\r\\n #calculate the blocked days which the new cluster determines\\r\\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\\r\\n #define as DataArray and select JJA to remove the extended days included for classifying blocks\\r\\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \\\"blocking\\\", dims={\\\"time\\\": GTD['time']})\\r\\n blocked_days_clus_xr['time'] = GTD['time']\\r\\n blocked_days_clus_seas = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\\r\\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_seas)\\r\\n #calculate precision, recall and F1\\r\\n if len(str(node_cluster_set_test)) == 1:\\r\\n comb_str = f\\\"{node_cluster_set_test[0]}\\\".replace(\\\"'\\\", \\\"\\\")\\r\\n else:\\r\\n comb_str = f\\\"{str(node_cluster_set_test)[1:-1]}\\\".replace(\\\"'\\\", \\\"\\\") \\r\\n ds=xr.Dataset({'precision': prec, 'recall': recall, 'F1': F1, 'clus_num': int(len(node_cluster_set_test)), 'set': str(comb_str)})\\r\\n ds_arr_ones.append(ds)\\r\\n blocks_one_clusnum = xr.concat(ds_arr_ones, dim = \\\"set\\\")\\r\\n return blocks_one_clusnum\",\n \"def make_set_cover_pos(gRNA_hits, num_sets = 1, target_ids = [], algorithm = \\\"LAR\\\",\\n id_key = lambda x: x, tie_breaker = tie_break_first, suppress_warning = False):\\n # exclude_seqs = set(str(s).upper() for s in exclude_seqs)\\n # gRNA_coverage = {seq: hits for seq, hits in gRNA_hits.hits.items()\\n # if str(seq).upper() not in exclude_seqs}\\n gRNA_coverage = gRNA_hits.hits\\n eliminated_gRNA = {}\\n ## prepare target ids\\n if not target_ids:\\n target_ids = set(hit.target_id for hit in gRNA_hits.flatten_hits())\\n else:\\n target_ids = set(target_ids)\\n ## selected set cover algorithm\\n if algorithm in (\\\"LAR\\\", \\\"greedy\\\"):\\n set_cover_algo = set_cover_LAR if algorithm == \\\"LAR\\\" else set_cover_greedy\\n else:\\n raise Exception(f\\\"Invalid algorithm name: '{algorithm}'\\\")\\n def coverage_possible():\\n return set(id_key(hit) for hits in gRNA_coverage.values() for hit in hits) >= set(target_ids)\\n ## function to generate set covers\\n def make_set_cover(restore = []):\\n for grna in restore:\\n gRNA_coverage[grna.seq] = eliminated_gRNA[grna.seq]\\n if not coverage_possible():\\n if not suppress_warning:\\n print((\\\"\\\\nError: The provided gRNA sequences cannot cover all target sequences\\\"\\n \\\" at least once.\\\\n\\\"))\\n return []\\n selected_grnas = set_cover_algo(gRNA_coverage, target_ids, id_key = id_key, tie_breaker = tie_breaker)\\n ## remove selected gRNA from candidates, and covert to gRNA object\\n output = []\\n for grna_seq in selected_grnas:\\n ## remove\\n eliminated_gRNA[grna_seq] = gRNA_coverage[grna_seq]\\n del gRNA_coverage[grna_seq]\\n ## convert gRNA sequences to gRNA object\\n grna_seq_obj = gRNA_hits.get_gRNAseq_by_seq(grna_seq)\\n output.append(gRNA(grna_seq_obj.id, grna_seq_obj))\\n return output\\n return make_set_cover\",\n \"def Test_NumNodes(Graph_MD):\\n N_Knoten = Graph_MD.number_of_nodes()\\n \\n return N_Knoten\",\n \"def compute_small_worldness(G, metric, niter=100, nrand=5, seed=None):\\n G = max(nx.connected_component_subgraphs(G), key=len)\\n\\n if metric == 'omega':\\n small_worldness = nx.algorithms.smallworld.omega(G,\\n niter=niter,\\n nrand=nrand,\\n seed=seed)\\n elif metric == 'sigma':\\n small_worldness = nx.algorithms.smallworld.sigma(G,\\n niter=niter,\\n nrand=nrand,\\n seed=seed)\\n else:\\n raise ValueError('Small world metric not available.')\\n return small_worldness\",\n \"def dissimilarity(clusters):\\n totDist = 0\\n for c in clusters:\\n totDist += c.variability()\\n return totDist\",\n \"def is_modern(self):\\n G = self.poset().hasse_diagram()\\n for x in G:\\n nx = list(G.neighbors_in(x))\\n nx.append(x)\\n if min(nx) < x and max(nx) > x:\\n return False\\n return True\",\n \"def distance_score(vertex1, board, player_id): #implement preference for closer settlements\\n num_buildings = 0\\n total_dist = 0\\n player_buildings = board.get_player_settlements(player_id) + board.get_player_cities(player_id)\\n\\n if len(player_buildings) == 0: #if it is our first turn\\n return 0\\n\\n player_roads = board.get_player_roads(player_id)\\n accessible_vertices = list(set(player_buildings+ [vertex for pair in player_roads for vertex in pair]))\\n get_distance = lambda v: manhattan_distance(v, vertex1, board)\\n min_distance = min(map(get_distance, accessible_vertices))\\n\\n enemy_buildings = [v for v in board.settlements if board.settlements[v] != player_id]\\n enemy_roads = [r for r in board.roads if board.roads[r] != player_id]\\n\\n\\n \\\"\\\"\\\"\\n for s in board.settlements:\\n if board.settlements[s] != player_id:\\n vertex2 = s\\n total_dist_enemies += manhattan_distance(vertex1, vertex2, board)\\n num_buildings+=1\\n\\n for c in board.cities:\\n if board.cities[c] != player_id:\\n vertex2 = c\\n total_dist_enemies += manhattan_distance(vertex1, vertex2, board)\\n num_buildings+=1\\n\\n \\\"\\\"\\\"\\n return min_distance\",\n \"def test_all_used(self):\\n # diagram:\\n # \\n # c1\\n # c3\\n # c2\\n n = self._process(\\\"\\\"\\\"\\nclass c1 \\\"C1\\\"\\nclass c2 \\\"C2\\\"\\nclass c3 \\\"C3\\\"\\n\\n:layout:\\n right g1: c1 c3\\n left g2: c3 c2\\n\\\"\\\"\\\")\\n c1 = find_style(n, 'c1')\\n c2 = find_style(n, 'c2')\\n c3 = find_style(n, 'c3')\\n\\n self._check_c_not(MiddleEq, c1, c3)\\n self._check_c_not(MinHDist, c1, c3)\",\n \"def evaluate(model, graph, test_set, true_triples, num_nodes, batch_size=16, hits_at_k=[1, 3, 10], filter_candidates=True, verbose=True):\\n\\n device = 'cuda' if torch.cuda.is_available() else 'cpu'\\n\\n rng = tqdm.trange if verbose else range\\n\\n ranks = []\\n for head in [True, False]: # head or tail prediction\\n\\n for fr in rng(0, len(test_set), batch_size):\\n to = min(fr + batch_size, len(test_set))\\n\\n batch = test_set[fr:to, :].to(device=device)\\n bn, _ = batch.size()\\n\\n # compute the full score matrix (filter later)\\n bases = batch[:, 1:] if head else batch[:, :2]\\n targets = batch[:, 0] if head else batch[:, 2]\\n\\n # collect the triples for which to compute scores\\n bexp = bases.view(bn, 1, 2).expand(bn, num_nodes, 2)\\n ar = torch.arange(num_nodes, device=device).view(1, num_nodes, 1).expand(bn, num_nodes, 1)\\n toscore = torch.cat([ar, bexp] if head else [bexp, ar], dim=2)\\n assert toscore.size() == (bn, num_nodes, 3)\\n\\n scores, _ = model(graph, toscore)\\n assert scores.size() == (bn, num_nodes)\\n\\n # filter out the true triples that aren't the target\\n if filter_candidates:\\n filter_scores(scores, batch, true_triples, head=head)\\n\\n # Select the true scores, and count the number of values larger than than\\n true_scores = scores[torch.arange(bn, device=device), targets]\\n raw_ranks = torch.sum(scores > true_scores.view(bn, 1), dim=1, dtype=torch.long)\\n # -- This is the \\\"optimistic\\\" rank (assuming it's sorted to the front of the ties)\\n num_ties = torch.sum(scores == true_scores.view(bn, 1), dim=1, dtype=torch.long)\\n\\n # Account for ties (put the true example halfway down the ties)\\n branks = raw_ranks + (num_ties - 1) // 2\\n\\n ranks.extend((branks + 1).tolist())\\n\\n mrr = sum([1.0/rank for rank in ranks])/len(ranks)\\n\\n hits = []\\n for k in hits_at_k:\\n hits.append(sum([1.0 if rank <= k else 0.0 for rank in ranks]) / len(ranks))\\n\\n return mrr, tuple(hits), ranks\",\n \"def cal_pn(grams_set, grams, candidate, reference):\\n count = 0\\n for gram in grams_set:\\n # print(gram)\\n count += count_clip(gram, grams, reference)\\n # calculate log() for p, so '+10**-8' avoid 'p==0'\\n p = count / len(grams) + 10**-8 \\n return p\",\n \"def part1c_0():\\n xs = exampleInput\\n T = submission.computeEdgeMarginals(simpleCRF, xs)\\n for t in T:\\n grader.requireIsEqual( 1.0, sum(t.values()) )\",\n \"def test_is_gsp_satisfied(self):\\n mask_conv = MaskConv2d(32, 32, 3)\\n\\n self.assertTrue(is_gsp_satisfied(mask_conv, 1))\\n self.assertFalse(is_gsp_satisfied(mask_conv, 2))\\n\\n mask_conv.mask.data[:16, :16] = 0\\n mask_conv.mask.data[16:, 16:] = 0\\n self.assertTrue(is_gsp_satisfied(mask_conv, 2))\\n\\n mask_conv.mask.data[15, 15] = 1\\n mask_conv.mask.data[15, 16] = 0\\n mask_conv.mask.data[16, 15] = 1\\n mask_conv.mask.data[16, 16] = 0\\n self.assertFalse(is_gsp_satisfied(mask_conv, 2))\\n self.assertIsNone(get_group_allocation(mask_conv.mask, 2)[0])\\n self.assertIsNone(get_group_allocation(mask_conv.mask, 2)[1])\",\n \"def worst_atom(self, g_u, g_v, active_set):\\n\\n max_w = None\\n max_m_w = None\\n max_n_w = None\\n max_score = -float('inf')\\n\\n for w in active_set:\\n m_w, n_w = self.polytope.vertex(w)\\n score_w = np.sum(g_u * m_w) + np.sum(g_v * n_w)\\n\\n if score_w > max_score:\\n max_w = w\\n max_m_w = m_w\\n max_n_w = n_w\\n max_score = score_w\\n\\n return max_w, max_m_w, max_n_w\",\n \"def cost(graph, gates_qubits_pairs):\\n for allowed, gate in enumerate(gates_qubits_pairs):\\n if gate not in graph.edges():\\n break\\n return len(gates_qubits_pairs) - allowed\",\n \"def testSameRMSEWhenPairsAreSpecifiedOrNot(self):\\n test_class1 = TrimmedMatchGeoXDesign(\\n GeoXType.HEAVY_UP,\\n pretest_data=self.nontrivial_data,\\n time_window_for_design=self.design_window,\\n time_window_for_eval=self.evaluation_window,\\n matching_metrics={'response': 1.0},\\n pairs=None)\\n\\n for geox_type in GeoXType:\\n if geox_type == GeoXType.CONTROL:\\n continue\\n\\n test_class1._geox_type = geox_type\\n _, expected_detailed_results = test_class1.report_candidate_designs(\\n budget_list=[30, 40],\\n iroas_list=[0, 2],\\n use_cross_validation=True,\\n num_simulations=10)\\n\\n test_class2 = TrimmedMatchGeoXDesign(\\n geox_type,\\n pretest_data=self.nontrivial_data,\\n time_window_for_design=self.design_window,\\n time_window_for_eval=self.evaluation_window,\\n matching_metrics={'response': 1.0},\\n pairs=test_class1.pairs)\\n _, detailed_results = test_class2.report_candidate_designs(\\n budget_list=[30, 40],\\n iroas_list=[0, 2],\\n use_cross_validation=True,\\n num_simulations=10)\\n\\n for key in detailed_results.keys():\\n self.assertTrue(\\n np.array_equal(detailed_results[key]['estimate'],\\n expected_detailed_results[key]['estimate']))\",\n \"def check_consistency(precision, index_calls, father_calls, mother_calls):\\n\\n def to_str(hla):\\n return hla.prec_str(precision)\\n\\n mismatches = 0\\n for gene in 'ABC':\\n summand = 0\\n index_set = set(map(to_str, index_calls[gene]))\\n father_set = set(map(to_str, father_calls[gene]))\\n mother_set = set(map(to_str, mother_calls[gene]))\\n if father_calls and mother_calls:\\n # have both mother and father calls, more complex\\n # print('index', index_set, 'father', father_set, 'mother',\\n # mother_set)\\n if not index_set & father_set:\\n summand = 1\\n if not index_set & mother_set:\\n summand = max(summand, 1)\\n if len(index_set) == 1:\\n if not index_set & father_set or not index_set & mother_set:\\n summand = 2\\n else:\\n summand = 2 - len(index_set & (mother_set | father_set))\\n # print('gene {} summand {}'.format(gene, summand),\\n # file=sys.stdout)\\n else:\\n # have only one calls, easier\\n either_set = father_set or mother_set\\n if not either_set & index_set:\\n summand = 1\\n mismatches += summand\\n return mismatches\",\n \"def find_progenitors_at_z(self, SH, mtree, z1, z2):\\n \\n for ss in range(z1, z2):\\n # nodes at redshift ss\\n ss_indx = np.where(mtree.data.snapshotNumber.values == ss)\\n nodeID = mtree.data.index.values[ss_indx]\\n nodeID_desc = mtree.data.descendantIndex.values[ss_indx]\\n \\n # find number of progenitors for nodes at redshift ss\\n if ss != z1:\\n _progcounts = np.zeros(len(nodeID))\\n for ii in range(len(nodeID_past_desc)):\\n if nodeID_past_desc[ii] in nodeID:\\n indx = np.where(nodeID == nodeID_past_desc[ii])\\n _progcounts[indx] = count[ii]\\n\\n nodeID_desc_unique, count = np.unique(nodeID_desc, return_counts=True)\\n nodeID_desc_unique=nodeID_desc_unique[1:]; count=count[1:]\\n \\n nodeID_past = nodeID\\n nodeID_past_desc = nodeID_desc_unique\\n if ss != z1:\\n _progcounts_past = _progcounts\\n print('_progcounts', _progcounts)\",\n \"def compare_graphs(self):\\n\\t\\tpass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63994","0.58635193","0.5778622","0.5743064","0.55880827","0.555476","0.53169554","0.52722627","0.52660155","0.52518225","0.52481997","0.52412534","0.5223429","0.5208664","0.5191661","0.5173846","0.51651204","0.51604426","0.51279247","0.51213825","0.5113577","0.51023996","0.5090531","0.50895363","0.50890976","0.5086639","0.50231844","0.5019312","0.50101745","0.50064147","0.5005015","0.4998147","0.49923363","0.49813893","0.49745005","0.4969558","0.49639815","0.49625313","0.4960051","0.4949852","0.49427414","0.49332392","0.49243972","0.4914816","0.4910336","0.4908574","0.4908439","0.49065763","0.49035132","0.48923996","0.48915306","0.4889271","0.48843876","0.48835286","0.48804694","0.48796907","0.48782215","0.48777816","0.48777816","0.48777816","0.48777074","0.48672056","0.48639783","0.48585272","0.48512346","0.48261994","0.48259205","0.48226237","0.480752","0.4804976","0.47959363","0.47951534","0.4793282","0.47892717","0.47880587","0.47851253","0.47836894","0.4781128","0.47799104","0.47765929","0.47756165","0.47750705","0.47724754","0.4770673","0.47704625","0.47696704","0.47674787","0.47634763","0.4761067","0.47571746","0.4756899","0.47558257","0.47516957","0.47505218","0.4749183","0.47425443","0.47425288","0.4742372","0.47405276","0.47396955"],"string":"[\n \"0.63994\",\n \"0.58635193\",\n \"0.5778622\",\n \"0.5743064\",\n \"0.55880827\",\n \"0.555476\",\n \"0.53169554\",\n \"0.52722627\",\n \"0.52660155\",\n \"0.52518225\",\n \"0.52481997\",\n \"0.52412534\",\n \"0.5223429\",\n \"0.5208664\",\n \"0.5191661\",\n \"0.5173846\",\n \"0.51651204\",\n \"0.51604426\",\n \"0.51279247\",\n \"0.51213825\",\n \"0.5113577\",\n \"0.51023996\",\n \"0.5090531\",\n \"0.50895363\",\n \"0.50890976\",\n \"0.5086639\",\n \"0.50231844\",\n \"0.5019312\",\n \"0.50101745\",\n \"0.50064147\",\n \"0.5005015\",\n \"0.4998147\",\n \"0.49923363\",\n \"0.49813893\",\n \"0.49745005\",\n \"0.4969558\",\n \"0.49639815\",\n \"0.49625313\",\n \"0.4960051\",\n \"0.4949852\",\n \"0.49427414\",\n \"0.49332392\",\n \"0.49243972\",\n \"0.4914816\",\n \"0.4910336\",\n \"0.4908574\",\n \"0.4908439\",\n \"0.49065763\",\n \"0.49035132\",\n \"0.48923996\",\n \"0.48915306\",\n \"0.4889271\",\n \"0.48843876\",\n \"0.48835286\",\n \"0.48804694\",\n \"0.48796907\",\n \"0.48782215\",\n \"0.48777816\",\n \"0.48777816\",\n \"0.48777816\",\n \"0.48777074\",\n \"0.48672056\",\n \"0.48639783\",\n \"0.48585272\",\n \"0.48512346\",\n \"0.48261994\",\n \"0.48259205\",\n \"0.48226237\",\n \"0.480752\",\n \"0.4804976\",\n \"0.47959363\",\n \"0.47951534\",\n \"0.4793282\",\n \"0.47892717\",\n \"0.47880587\",\n \"0.47851253\",\n \"0.47836894\",\n \"0.4781128\",\n \"0.47799104\",\n \"0.47765929\",\n \"0.47756165\",\n \"0.47750705\",\n \"0.47724754\",\n \"0.4770673\",\n \"0.47704625\",\n \"0.47696704\",\n \"0.47674787\",\n \"0.47634763\",\n \"0.4761067\",\n \"0.47571746\",\n \"0.4756899\",\n \"0.47558257\",\n \"0.47516957\",\n \"0.47505218\",\n \"0.4749183\",\n \"0.47425443\",\n \"0.47425288\",\n \"0.4742372\",\n \"0.47405276\",\n \"0.47396955\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75630814"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":146,"numItemsPerPage":100,"numTotalItems":95772,"offset":14600,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjA2MDgxNSwianRpIjoiNjlmNDk2ODEtZDIzMi00NzZiLTlmYTUtNzlmNTAxN2Y3ZjJiIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwNjQ0MTUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.d8hUu96sN67b8XASZUAsqeFDjqWBNKLiyLmplQQLZpmKhKRUZo5DCboBZO50F3rUuBBoxRJnny1_M6dvkVA8Cw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
calculates beam xy and other parameters. | def calculate_beam_xy(self):
info = []
# Import relevant info
pixel_size = self.info.pixel_size
for i in [j.final for j in self.final_objects]:
try:
info.append(
[
i,
i["beamX"],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xy(self):\n ...",
"def beam(xb,yb,zb,wx,wy,wavelen):\n\n zRx = np.pi * wx**2 / wavelen\n zRy = np.pi * wy**2 / wavelen \n \n sqrtX = np.sqrt( 1 + np.power(zb/zRx,2) ) \n sqrtY = np.sqrt( 1 + np.power(zb/zRy,2) ) \n intensity = np.exp( -2.*( np.power(xb/(wx*sqrtX ),2) \\\n ... | [
"0.6129466",
"0.60761815",
"0.6049173",
"0.5987054",
"0.59085387",
"0.58142376",
"0.58065397",
"0.5801077",
"0.5798147",
"0.57459855",
"0.57192415",
"0.57188255",
"0.5706152",
"0.5704091",
"0.5699249",
"0.5691896",
"0.5674206",
"0.5672045",
"0.5594236",
"0.5586325",
"0.556433... | 0.73167294 | 0 |
Plot beam center coordinates and a histogram of distances from the median of beam center coordinates to each set of coordinates. Superpose a predicted misindexing shift by L +/ 1 (calculated for each axis). | def plot_beam_xy(self, write_files=False, return_values=False, threeD=False):
import matplotlib.pyplot as plt
# Get values
(
beamX,
beamY,
cbeamX,
cbeamY,
obeamX,
obeamY,
beam_dist,
distances,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_averaged_amplitude(self):\r\n\r\n tremap = np.arange(0, self.period, 1./self.framerate)\r\n\r\n ipy_offset = -2\r\n\r\n # find center of image\r\n\r\n self.ipx = int(self.imageData.shape[1]/2.)\r\n\r\n self.ipy = int(self.imageData.shape[2]/2.)\r\n\r\n posx = rang... | [
"0.59229296",
"0.58711404",
"0.5804657",
"0.57857805",
"0.57540417",
"0.57117033",
"0.5675799",
"0.56658244",
"0.5662011",
"0.5661819",
"0.5587553",
"0.5554073",
"0.5548557",
"0.5535812",
"0.5503324",
"0.5486324",
"0.54851836",
"0.54742026",
"0.54716635",
"0.54662895",
"0.546... | 0.5422894 | 24 |
Prints diagnostics from the final integration run. | def print_results(self, final_table=None):
assert self.info
if not final_table:
final_table = ["\n\n{:-^80}\n".format("ANALYSIS OF RESULTS")]
if not self.info.categories["integrated"]:
final_table.append("NO IMAGES INTEGRATED!")
else:
label_lens = [... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def report(self):\r\n print(\"\".join(self.memory), self.error, self.steps)",
"def print_results(self):\n pass",
"def printReport(self):\n\t\tself.app.printflush('Fetched: ' + str(self.fetched_count), self.app.IGNORE_EXIT_FLAG)\n\t\tself.app.printflush('Processes: ' + str(self.processes), self.ap... | [
"0.6404051",
"0.62685865",
"0.61496735",
"0.6147585",
"0.60939384",
"0.60691977",
"0.60293907",
"0.59640324",
"0.5960282",
"0.59163845",
"0.5895703",
"0.58707947",
"0.5852592",
"0.5839212",
"0.5830497",
"0.581424",
"0.5782676",
"0.57226",
"0.57172406",
"0.5713037",
"0.5702594... | 0.55977476 | 29 |
Calls unit cell analysis module, which uses hierarchical clustering (Zeldin, et al, Acta D, 2015) to split integration results according to detected morphological groupings (if any). Most useful with preliminary integration without target unit cell specified. | def unit_cell_analysis(self):
# Will not run clustering if only one integration result found or if turned off
if not self.info.categories["integrated"]:
util.main_log(
self.info.logfile, "\n\n{:-^80}\n".format(" UNIT CELL ANALYSIS "), True
)
util.main... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(argv):\n args = process_command_line(argv)\n name = job_string(args)\n #That feel when no torison ;_;\n if args.dihed:\n raise Exception(\"Dihed is not supported right now\")\n #SDFS!\n if args.sdf:\n handle_sdf(args)\n #Conversion, pruning\n pybel_mols = convert_to_p... | [
"0.5610221",
"0.5556858",
"0.5512909",
"0.546379",
"0.54304254",
"0.5370964",
"0.536435",
"0.53357214",
"0.5281515",
"0.5277882",
"0.52746207",
"0.5239652",
"0.52363443",
"0.5225614",
"0.52088296",
"0.52050596",
"0.5199139",
"0.5171439",
"0.5166146",
"0.51584786",
"0.51337284... | 0.75939274 | 0 |
Prints summary and appends to general log file. Also outputs some of it on stdout. Also writes out output list files. | def print_summary(self, write_files=True):
assert self.info
if not self.info.categories["integrated"]:
util.main_log(
self.info.logfile,
"NO IMAGES SUCCESSFULLY PROCESSSED!",
(not self.gui_mode),
)
return
summ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def summarise(thislog):\n\n # Logfile name\n print(\"Summary for \" + thislog.filename() + \"\\n\")\n # Was it from CCP4i?\n if thislog.isccp4i():\n print(\"This is a CCP4i logfile\\n\")\n # Number of programs or pseudo-programs\n print(str(thislog.nfragments()) + \" logfile fragments\\n\"... | [
"0.6720507",
"0.657472",
"0.6511565",
"0.64218163",
"0.63418883",
"0.6279946",
"0.62183446",
"0.6165553",
"0.6113296",
"0.60181886",
"0.60126966",
"0.6002401",
"0.5998294",
"0.5992156",
"0.5933482",
"0.591959",
"0.5911536",
"0.5901738",
"0.5840104",
"0.5839231",
"0.5829121",
... | 0.6430065 | 3 |
Imports default PRIME input parameters, modifies correct entries and prints out a starting PHIL file to be used with PRIME. | def make_prime_input(self, filename="prime.phil", run_zero=False):
assert self.info
pixel_size = self.info.pixel_size
hres = self.info.stats["res"]
lres = self.info.stats["lres"]
# If symmetry / unit cell were not overridden from GUI, set from INFO
if not self.best_pg:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Usage():\r\n print \"Correct Usage:\"\r\n print \"python primesBelow.py <integer>\"",
"def pr(form, *args):\n # variables\n global lPr, lMaPr\n\n if lPr < lMaPr:\n for l in range(lPr + 1):\n sys.stdout.write('-')\n if len(args) == 0:\n print form\n ... | [
"0.57706285",
"0.5497428",
"0.5485556",
"0.5466297",
"0.54553556",
"0.542836",
"0.5421417",
"0.53975254",
"0.53920454",
"0.53487873",
"0.5346001",
"0.5343639",
"0.53339195",
"0.5314539",
"0.53113174",
"0.5310713",
"0.5290864",
"0.52821314",
"0.52764744",
"0.5268802",
"0.52430... | 0.6344126 | 0 |
Get range obj by float | def float_range(start, stop, step):
while start < stop:
yield float(start)
start += decimal.Decimal(step) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def range(self):\n lower, upper = sorted((self.y1, self.y2))\n return FloatRange(lower=lower, upper=upper)",
"def _rangeQueryFloatFeature(self):\n\n # create args\n minToGet = c_double()\n maxToGet = c_double()\n\n errorCode = VimbaDLL.featureFloatRangeQuery(self._handle... | [
"0.71502924",
"0.68753797",
"0.64868176",
"0.64425915",
"0.642538",
"0.64180946",
"0.62441003",
"0.62220085",
"0.621806",
"0.6217645",
"0.6143057",
"0.6125329",
"0.6125329",
"0.6114536",
"0.6097614",
"0.6091006",
"0.606575",
"0.6055309",
"0.6042241",
"0.60320693",
"0.6020189"... | 0.62341285 | 7 |
Get S&P500 current price and current time | def get_sp500():
sp500 = si.get_live_price("^GSPC")
sp500_trim = "%.2f" % sp500
_time = datetime.datetime.now().timetuple()
_time = time.mktime(tuple(_time))
_time_label = f"test"
return float(sp500_trim), int(_time) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getprice():\n\n print(\"Get price\")\n latest_price = get_latest_price(item_code)\n return latest_price",
"def getCurrentPrice(self,primary,secondary):\n pair = self.getTradedPair(primary,secondary)\n uri = \"https://www.bitstamp.net/api/v2/ticker/\"\n requestUrl = uri + pair\n jsonRespo... | [
"0.7215502",
"0.7165495",
"0.7139455",
"0.71224046",
"0.705337",
"0.693749",
"0.6831584",
"0.680008",
"0.67942756",
"0.6649967",
"0.65492207",
"0.64216787",
"0.6361455",
"0.6216685",
"0.6193378",
"0.6148163",
"0.611725",
"0.6070562",
"0.60117114",
"0.6002141",
"0.59859204",
... | 0.6827049 | 7 |
Start app instance with proper exit | def main():
app = QtWidgets.QApplication(sys.argv)
main = MainWindow()
main.show()
sys.exit(app.exec_()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def startapp():",
"def start(self):\n\n self.app.go()",
"def start():\n app.run()",
"def launch_instance(cls, argv=None, **kwargs):\n try:\n return super(JupyterApp, cls).launch_instance(argv=argv, **kwargs)\n except NoStart:\n return",
"def create_and_run():\n... | [
"0.77904356",
"0.699691",
"0.66588265",
"0.66432637",
"0.6597644",
"0.65634286",
"0.65507096",
"0.6539924",
"0.65029126",
"0.65029126",
"0.65009236",
"0.6488637",
"0.64699376",
"0.6443841",
"0.643096",
"0.6416083",
"0.6415801",
"0.6352434",
"0.63469565",
"0.63384414",
"0.6306... | 0.0 | -1 |
Function to fetch the chain from a blockchain node, parse the data, and store it locally. | def fetch_posts():
get_chain_address = F"{CONNECTED_NODE_ADDRESS}/chain"
response = requests.get(get_chain_address)
if response.status_code == 200:
content = []
chain = json.loads(response.content)
for block in chain["chain"]:
for tx in block["transactions"]:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_chain():\n response = {\n 'chain': blockchain.chain,\n 'length':len(blockchain.chain)\n }\n\n return jsonify(response), 200",
"def get_chain(self):\n app_process = sqlite3.connect('app_process::memory:', check_same_thread=False)\n app_process_cursor = app_process.curs... | [
"0.60987407",
"0.5816403",
"0.56391543",
"0.56332684",
"0.54955184",
"0.5480293",
"0.54046446",
"0.5368525",
"0.5321379",
"0.5166924",
"0.51448447",
"0.5138189",
"0.5032647",
"0.5009114",
"0.50053024",
"0.50045025",
"0.49803552",
"0.49783364",
"0.49729702",
"0.49098444",
"0.4... | 0.4319509 | 81 |
Endpoint to create a new transaction via our application | def submit_textarea():
post_content = request.form["content"]
author = request.form["author"]
post_object = {
'author': author,
'content': post_content
}
# Submit a tx
new_tx_address = f"{CONNECTED_NODE_ADDRESS}/new_transaction"
request.post(new_tx_address,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def CreateTransaction(self, request, context):\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)",
"def new_transaction():\n\n data = request.get_json()\n\n if not data:\n return \"No transation data passed\", 400\n\n required = ['sender', 'recipient', 'amount']\n\n if not (list(data... | [
"0.7857358",
"0.7536667",
"0.70489585",
"0.69542104",
"0.69542104",
"0.6864688",
"0.6804625",
"0.67751205",
"0.67617077",
"0.67547923",
"0.6747514",
"0.6549574",
"0.6468893",
"0.64249974",
"0.63687646",
"0.63659436",
"0.6288597",
"0.6283322",
"0.61438334",
"0.6090528",
"0.605... | 0.0 | -1 |
This function uses a numpy expression to evaluate the derivatives in the Laplacian, and calculates u[i,j] based on ui[i,j]. | def evolve_ts(u, ui, a, dx, dy, dx2, dy2, dt):
u[1:-1, 1:-1] = ui[1:-1, 1:-1] + a*dt*( (ui[2:, 1:-1] - 2*ui[1:-1, 1:-1] + ui[:-2, 1:-1])/dx2 + (ui[1:-1, 2:] - 2*ui[1:-1, 1:-1] + ui[1:-1, :-2])/dy2 ) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def laplacian(expr):\n\n delop = Del()\n if expr.is_Vector:\n return (gradient(divergence(expr)) - curl(curl(expr))).doit()\n return delop.dot(delop(expr)).doit()",
"def grad(X, u):\r\n Jshape = list(u.shape)\r\n Jshape[1] -= 4 #subtract ghost cell count from shape\r\n Jshape.insert(0,3... | [
"0.6449859",
"0.62042266",
"0.60069555",
"0.58933336",
"0.57898957",
"0.57525456",
"0.5555429",
"0.5512935",
"0.5491546",
"0.54524994",
"0.54423004",
"0.5431733",
"0.5403716",
"0.53978837",
"0.5390353",
"0.53868294",
"0.53855324",
"0.53829813",
"0.5378176",
"0.535542",
"0.535... | 0.0 | -1 |
Initializes the command line argument parser. | def init_parser():
parser = argparse.ArgumentParser(
description='Backup application code and data.')
parser.add_argument('-a', '--app-id', required=True,
help='the application ID to run the backup for')
parser.add_argument('--source-code', action='store_true',
default=False, help='backup the source c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n self.parser = command_line.get_args()",
"def init_args():\n parser = argparse.ArgumentParser(\n description=\"DeltaSherlock Client software.\")\n parser.add_argument('-v', '--version', action='version', version=VERSION)\n parser.add_argument('-c', '--config', action='sto... | [
"0.7601347",
"0.7528685",
"0.73878586",
"0.7250815",
"0.70950997",
"0.7083153",
"0.70421267",
"0.6973221",
"0.6948589",
"0.6945047",
"0.6919792",
"0.6907576",
"0.6905947",
"0.69001305",
"0.68913364",
"0.6868113",
"0.6822481",
"0.6813597",
"0.6809166",
"0.6791391",
"0.6789211"... | 0.67097956 | 27 |
This main function allows you to run the backup manually. | def main():
parser = init_parser()
args = parser.parse_args()
# Set up logging.
level = logging.INFO
if args.debug:
level = logging.DEBUG
logging.basicConfig(format='%(asctime)s %(levelname)s %(filename)s:' \
'%(lineno)s %(message)s ', level=level)
logging.info("Logging started")
message = "B... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_backup():\n host = re.search(\"([\\w.-]+)[:]?\", env.host).group()\n date = time.strftime('%Y%m%d%H%M%S')\n fname = '%(host)s-backup-%(date)s.gz' % {'date': date, 'host': host}\n green(\"Ingrese la contraseña de la clave privada local.\")\n sudo(\"pg_dump kine | gzip > /tmp/%s\" % fname, use... | [
"0.7348714",
"0.7322273",
"0.72442436",
"0.71869266",
"0.7080326",
"0.7026621",
"0.6823129",
"0.6735388",
"0.66656953",
"0.6550088",
"0.6538847",
"0.6439064",
"0.63912153",
"0.6356379",
"0.63234514",
"0.6314879",
"0.6291406",
"0.6277249",
"0.62609226",
"0.6228204",
"0.6194076... | 0.7343254 | 1 |
coregisters two images and returns the moving image warped to fit target_img and the respective transform matrix | def register_imgs(moving_img, target_img, rigid=True, rotation=False, warn_angle_deg=1, min_match_count=10,
flann_index_kdtree = 0, flann_trees=5, flann_checks=50):
if len(target_img.shape) > 2:
target_img = cv2.cvtColor(target_img, cv2.COLOR_BGR2GRAY)
if len(moving_img.shape) > 2:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transform_images(img1,img2):",
"def warp(img1, img2, M):\n\n # Get width and height of input images \n w1,h1 = img1.shape[:2]\n w2,h2 = img2.shape[:2]\n\n # Get the canvas dimesions\n img2_dims = np.float32([ [0,0], [0,w2], [h2, w2], [h2,0] ]).reshape(-1,1,2)\n img1_dims_temp = np.float32([... | [
"0.683274",
"0.65072864",
"0.6387012",
"0.62673867",
"0.6196402",
"0.61312056",
"0.5996735",
"0.5901546",
"0.5831172",
"0.582552",
"0.5818565",
"0.580519",
"0.5793256",
"0.5696396",
"0.5688733",
"0.56839305",
"0.56782573",
"0.56660324",
"0.5644482",
"0.5641259",
"0.5622318",
... | 0.6298054 | 3 |
Root Route Landing page that allows users to login or register | def root(request):
return render(request, 'users/index.html') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def home():\n\n if not current_user.is_authenticated:\n return redirect(url_for('login'))\n else:\n return redirect(url_for('show_registrations'))",
"def index(self):\n\n # try and pull the user's data\n user = get_active_user_data()\n\n if not user:\n # they a... | [
"0.76603013",
"0.7635915",
"0.745675",
"0.73755187",
"0.7304202",
"0.7227848",
"0.72207665",
"0.71749485",
"0.7169285",
"0.7164671",
"0.7160158",
"0.7159827",
"0.7140134",
"0.70964354",
"0.7082033",
"0.70733595",
"0.7016662",
"0.7015615",
"0.69886833",
"0.69692624",
"0.693994... | 0.6867386 | 27 |
Returns a function which takes Paths into the user data and returns csums. | def reverser(num_segs=3):
r = re.compile("((\/([0-9]|[a-f])+){%d})$" % (num_segs+1))
def checksum_from_link(link):
"""Takes a path into the userdata, returns the matching csum."""
m = r.search(safetype(link))
if (m):
csum_slash = m.group()[1:]
csum = _remove_sep_(csum_slash)
return csu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate(d):\r\n\r\n # Set correct slashes for the OS\r\n if sys.platform == 'windows':\r\n slash = '\\\\'\r\n elif sys.platform == 'linux':\r\n slash = '/'\r\n else:\r\n print('#Error. Unknown platform.')\r\n return\r\n\r\n print('Files in the current directory and ... | [
"0.5616519",
"0.5510596",
"0.54699963",
"0.5451842",
"0.54407364",
"0.53760487",
"0.5368446",
"0.53618073",
"0.5279357",
"0.52358234",
"0.52341944",
"0.5196225",
"0.5176148",
"0.51656383",
"0.51610726",
"0.5154971",
"0.5148992",
"0.5138188",
"0.5128646",
"0.51273227",
"0.5117... | 0.59194446 | 0 |
Takes a path into the userdata, returns the matching csum. | def checksum_from_link(link):
m = r.search(safetype(link))
if (m):
csum_slash = m.group()[1:]
csum = _remove_sep_(csum_slash)
return csum
else:
raise ValueError("link %s checksum didn't parse" %(link)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checksum(path):\n with open(path, 'r') as f:\n return md5(f.read()).digest()",
"def ukey(self, path):\n out = self._call(\"GETFILECHECKSUM\", path=path, redirect=False)\n if \"Location\" in out.headers:\n location = self._apply_proxy(out.headers[\"Location\"])\n ... | [
"0.66359466",
"0.6454005",
"0.6149527",
"0.6055664",
"0.60017765",
"0.5985765",
"0.59681016",
"0.59512496",
"0.59177786",
"0.59155154",
"0.58767915",
"0.58560187",
"0.580235",
"0.5780485",
"0.5724725",
"0.5703685",
"0.56968105",
"0.5696304",
"0.5692348",
"0.5671426",
"0.55878... | 0.5860333 | 11 |
Return string name of link relative to root | def _csum_to_name(self, csum):
#TODO someday when csums are parameterized, we inject the has params here.
return _checksum_to_path(csum) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def relName(self, cwd=None, root=None):\n return relName(self.path, cwd, root)",
"def getRootURL():",
"def get_filename(link):\r\n return link[link.rfind(\"/\") + 1:]",
"def link_prefix(request):\n return request.application_url",
"def relative_link(current_module: str, target_module: str) -> ... | [
"0.71634877",
"0.68998414",
"0.68714714",
"0.6773158",
"0.66814035",
"0.665135",
"0.66316783",
"0.66170126",
"0.65630275",
"0.6537999",
"0.6514251",
"0.64748186",
"0.64625055",
"0.643648",
"0.641618",
"0.6411852",
"0.6411852",
"0.6408901",
"0.6393389",
"0.6387245",
"0.6387178... | 0.0 | -1 |
Return absolute Path to a blob given a csum | def csum_to_path(self, csum):
#TODO remove callers so we can make internal.
return Path(self._csum_to_name(csum), self.root) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def link_to_blob(self, path, csum):\n new_link = self.csum_to_path(csum)\n ensure_symlink(path, new_link)\n ensure_readonly(path)",
"def _csum_to_name(self, csum):\n #TODO someday when csums are parameterized, we inject the has params here.\n return _checksum_to_path(csum)",
... | [
"0.6760842",
"0.6556648",
"0.64958185",
"0.6435036",
"0.62205434",
"0.58019423",
"0.5726288",
"0.55842215",
"0.5583444",
"0.5474924",
"0.5454985",
"0.5429763",
"0.5375666",
"0.5375143",
"0.5340256",
"0.5335034",
"0.5317139",
"0.53109914",
"0.5301503",
"0.5301253",
"0.5236432"... | 0.7445334 | 0 |
Takes a csum, and removes it from the blobstore | def delete_blob(self, csum):
blob_path = self.csum_to_path(csum)
blob_path.unlink(clean=self.root) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove():",
"def remove(self, data):\n data_hash = hashlib.sha256(data).digest()\n self.denominator = (self.denominator * data_to_num3072(data_hash)) % self.MODULUS",
"def __do_binary_delete(item):\n\n file_path = DTF_BINARIES_DIR + item.install_name\n\n if utils.delete_file(file_path) ... | [
"0.5757154",
"0.5642187",
"0.5564729",
"0.5475264",
"0.5464008",
"0.5457136",
"0.53968495",
"0.5358681",
"0.5354388",
"0.5342333",
"0.53273803",
"0.5321266",
"0.5296075",
"0.52734",
"0.5217147",
"0.5210733",
"0.5208237",
"0.5182357",
"0.5178936",
"0.5171412",
"0.5165453",
"... | 0.78742325 | 0 |
Adds a file to a blobstore via a hard link. | def import_via_link(self, path, csum):
blob = self.csum_to_path(csum)
duplicate = blob.exists()
if not duplicate:
ensure_link(blob, path)
ensure_readonly(blob)
return duplicate | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def link_to_blob(self, path, csum):\n new_link = self.csum_to_path(csum)\n ensure_symlink(path, new_link)\n ensure_readonly(path)",
"def add_file(self, path):\n pass",
"def add(self, link):\n # if path.exists(self.cachefile):\n with open(self.cachefile, 'a') as cache:\n ... | [
"0.6423228",
"0.6287557",
"0.61771405",
"0.615078",
"0.6123352",
"0.6082482",
"0.5928465",
"0.59196544",
"0.5893714",
"0.5856453",
"0.5776597",
"0.57732725",
"0.5737285",
"0.5707831",
"0.5680261",
"0.5672629",
"0.5669991",
"0.5660367",
"0.56599265",
"0.5635269",
"0.562064",
... | 0.5209071 | 97 |
Forces path into a symlink to csum | def link_to_blob(self, path, csum):
new_link = self.csum_to_path(csum)
ensure_symlink(path, new_link)
ensure_readonly(path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def relink(f):\n if os.path.islink(f):\n linkto = os.path.join(NEW_LINK_BASE, os.path.basename(os.readlink(f)))\n #print 'Relinking %s-> %s from \\n %s' % (f, linkto, os.readlink(f))\n #print 'removing %s' % f\n os.remove(f)\n os.symlink(linkto, f)",
"def symlink(self, req, li... | [
"0.6718929",
"0.66228133",
"0.6465445",
"0.6442848",
"0.6344745",
"0.6339009",
"0.6291033",
"0.625382",
"0.62475646",
"0.62025553",
"0.6126322",
"0.61046165",
"0.6099585",
"0.6029164",
"0.5990421",
"0.5971646",
"0.59707147",
"0.5963814",
"0.5950644",
"0.5917308",
"0.58955467"... | 0.72160524 | 0 |
Iterator across all blobs | def blobs(self):
blobs = pipeline(
ftype_selector([FILE]),
fmap(first),
fmap(self.reverser),
)(self.root.entries())
return blobs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def blob_generator(self):\n for blob in self.data:\n yield blob",
"def blobs(self):\n def blob_iterator():\n with s3conn(self.access_id, self.secret) as s3:\n key_iter = s3.list_bucket(self.bucket, prefix=self.prefix+\"/\")\n for key in key_iter:\... | [
"0.7579303",
"0.7229534",
"0.6972601",
"0.64345145",
"0.6410156",
"0.62850124",
"0.6241016",
"0.61964935",
"0.6173275",
"0.61723167",
"0.61494774",
"0.6100578",
"0.60827994",
"0.6061901",
"0.6057329",
"0.60366875",
"0.60343045",
"0.6032287",
"0.5957977",
"0.5957977",
"0.59544... | 0.6484718 | 3 |
Returns a file like object which has the blob's contents | def read_handle(self):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _blob(self):\n return self._load_blob",
"def read_blob(blob):\r\n if blob.hexsha != Diff.NULL_HEX_SHA:\r\n return blob.data_stream.read()\r\n else:\r\n with open(blob.path) as fp:\r\n return fp.read()",
"def get_blob(file_path):\n f = open(file_path)\n article = f.read().decode('u... | [
"0.73875207",
"0.734218",
"0.7219361",
"0.7122439",
"0.7076649",
"0.6893296",
"0.6844561",
"0.6710282",
"0.6600551",
"0.65756655",
"0.65630215",
"0.6554439",
"0.65501714",
"0.6519594",
"0.65081966",
"0.6476856",
"0.64485663",
"0.6427532",
"0.6406273",
"0.63686407",
"0.6358167... | 0.0 | -1 |
Returns True when the blob's checksum matches. Returns False when there is a checksum corruption. | def verify_blob_checksum(self, blob):
path = self.csum_to_path(blob)
csum = path.checksum()
return csum != blob | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_checksum(self):\n return self.calculate_checksum() == self.checksum()",
"def verify_checksum(self):\n return self.generate_header_checksum(omit_checksum=False) == 0",
"def _verify_checksum(data, checksum):\n sha256_hash = hashlib.sha256(data).hexdigest().encode()\n return to_bi... | [
"0.7736474",
"0.7485926",
"0.74634707",
"0.7280268",
"0.71696",
"0.71337336",
"0.71063906",
"0.7051834",
"0.69469905",
"0.6904954",
"0.6893968",
"0.68395376",
"0.6808126",
"0.6773289",
"0.67445666",
"0.673051",
"0.6638136",
"0.6498566",
"0.6496091",
"0.63991594",
"0.6348812",... | 0.8861687 | 0 |
Returns True when the blob's permissions is read only. Returns False when the blob is mutable. | def verify_blob_permissions(self, blob):
path = self.csum_to_path(blob)
return is_readonly(path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_only(self):\n return bool(self.__read_only)",
"def is_read_only(self):\n\t\treturn bool(call_sdk_function('PrlShare_IsReadOnly', self.handle))",
"def is_read_only(self) -> pulumi.Output[Optional[bool]]:\n return pulumi.get(self, \"is_read_only\")",
"def get_can_read(self):\n\t\tif not ... | [
"0.74087244",
"0.7357655",
"0.7207462",
"0.7194548",
"0.718061",
"0.7174269",
"0.7069815",
"0.70423627",
"0.70013654",
"0.70013654",
"0.6821539",
"0.6797577",
"0.67828053",
"0.67828053",
"0.67828053",
"0.67828053",
"0.6748725",
"0.65980434",
"0.65751696",
"0.65058196",
"0.650... | 0.7997186 | 0 |
Iterator across all blobs | def blobs(self):
def blob_iterator():
with s3conn(self.access_id, self.secret) as s3:
key_iter = s3.list_bucket(self.bucket, prefix=self.prefix+"/")
for key in key_iter:
blob = key[len(self.prefix)+1:]
yield blob
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def blob_generator(self):\n for blob in self.data:\n yield blob",
"def blob_stats(self):\n def blob_iterator():\n with s3conn(self.access_id, self.secret) as s3:\n key_iter = s3.list_bucket2(self.bucket, prefix=self.prefix+\"/\")\n for head in key... | [
"0.7579303",
"0.6972601",
"0.6484718",
"0.64345145",
"0.6410156",
"0.62850124",
"0.6241016",
"0.61964935",
"0.6173275",
"0.61723167",
"0.61494774",
"0.6100578",
"0.60827994",
"0.6061901",
"0.6057329",
"0.60366875",
"0.60343045",
"0.6032287",
"0.5957977",
"0.5957977",
"0.59544... | 0.7229534 | 1 |
Iterator across all blobs, retaining the listing information | def blob_stats(self):
def blob_iterator():
with s3conn(self.access_id, self.secret) as s3:
key_iter = s3.list_bucket2(self.bucket, prefix=self.prefix+"/")
for head in key_iter:
blob = head[LIST_BUCKET_KEY][len(self.prefix)+1:]
h... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def blobs(self):\n def blob_iterator():\n with s3conn(self.access_id, self.secret) as s3:\n key_iter = s3.list_bucket(self.bucket, prefix=self.prefix+\"/\")\n for key in key_iter:\n blob = key[len(self.prefix)+1:]\n yield blob\n ... | [
"0.68466896",
"0.6780061",
"0.6164148",
"0.6107229",
"0.60251284",
"0.60030335",
"0.5962732",
"0.5953068",
"0.58656806",
"0.58382636",
"0.5753683",
"0.5752837",
"0.5747022",
"0.57239527",
"0.57012093",
"0.56974304",
"0.56971043",
"0.56695175",
"0.56648165",
"0.56566805",
"0.5... | 0.72505546 | 0 |
Returns a file like object which has the blob's contents | def read_handle(self):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _blob(self):\n return self._load_blob",
"def read_blob(blob):\r\n if blob.hexsha != Diff.NULL_HEX_SHA:\r\n return blob.data_stream.read()\r\n else:\r\n with open(blob.path) as fp:\r\n return fp.read()",
"def get_blob(file_path):\n f = open(file_path)\n article = f.read().decode('u... | [
"0.7388198",
"0.7342988",
"0.72202396",
"0.7122696",
"0.70757747",
"0.68937564",
"0.6845509",
"0.6711367",
"0.65987545",
"0.6575547",
"0.6563041",
"0.6554713",
"0.65501213",
"0.6518357",
"0.65070355",
"0.64762455",
"0.64488935",
"0.64276737",
"0.64051425",
"0.63666874",
"0.63... | 0.0 | -1 |
try to create animate function to plot mechanisms | def plot_animate(self, A):
fig = plt.figure()
fig.set_tight_layout(False)
ax = plt.axes(projection='3d')
global cnt
cnt = ax
global cur_A
global cur_B
cur_A = A[0]
cur_B = self.B[0]
def steps(count=1):
for i in range(count):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_animated(self,val):\n self.XP_Plotter.set_animated(val)\n # theoretical lines \n for line in self.lines_theory:\n line.set_animated(val)",
"def animate(i):\r\n plot_x.set_data(history_samples[i][:, 0], history_samples[i][:, 1])",
"def _animate(foo):\n si... | [
"0.6990524",
"0.6984434",
"0.68571776",
"0.6801392",
"0.6801392",
"0.6801392",
"0.6801392",
"0.6801392",
"0.6801392",
"0.6801392",
"0.6801392",
"0.6801392",
"0.6801392",
"0.6801392",
"0.67780936",
"0.6755396",
"0.67217463",
"0.664098",
"0.6625555",
"0.6625555",
"0.66246885",
... | 0.6405008 | 38 |
reload a module, either larch or python | def _reload(mod,larch=None,**kw):
if isinstance(mod, str):
return larch.import_module(mod, do_reload=True)
for k,v in chain(larch.symtable._sys.modules.iteritems(), sys.modules.iteritems()):
if v == mod:
modname = k
break
try:
return larch.import_module(modn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reload_module(module_name):\n try:\n reload(eval(module_name))\n except:\n pass",
"def reloadModule(module):\n\ttry:\n\t\treload # Python 2.7\n\texcept NameError:\n\t\ttry:\n\t\t\tfrom importlib import reload # Python 3.4+\n\t\texcept ImportError:\n\t\t\tfrom imp import reload # Python... | [
"0.80148953",
"0.7742815",
"0.7427528",
"0.73654693",
"0.7348668",
"0.7205982",
"0.7027763",
"0.6984617",
"0.69592416",
"0.69405115",
"0.6676888",
"0.6640121",
"0.6631857",
"0.65679514",
"0.655727",
"0.6529555",
"0.647623",
"0.64265627",
"0.639218",
"0.6344517",
"0.63303524",... | 0.8660127 | 0 |
show lines of text in the style of more | def show_more(text,filename=None,writer=None,pagelength=30,prefix=''): # pragma: no cover
pager(text) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def abbrev_help_more_text(self):\n pass",
"def generate_excerpt():",
"def echo(self):\n new_paragraph = True\n for line in self.msg.splitlines():\n if not line.strip():\n new_paragraph = True\n click.echo()\n elif new_paragraph:\n ... | [
"0.6258086",
"0.61826456",
"0.6127772",
"0.5877098",
"0.5868962",
"0.5836664",
"0.5801012",
"0.57793504",
"0.5729908",
"0.57035375",
"0.5700666",
"0.5665235",
"0.56474644",
"0.56377524",
"0.5631425",
"0.56087565",
"0.5605236",
"0.5601699",
"0.55921155",
"0.55473125",
"0.55454... | 0.6663092 | 0 |
class that maintains all data related to the regulatory on the FContact | def __init__(self, contact = None):
try:
self.__contact = contact
if not self.__contact:
FRegulatoryLogger.ERROR(logger, "The name on the contact is the unique identifier of the contact. Kindly provide a valid acm.FContact object")
return None
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def RegulatoryInfo(self):\n conactRegInfo = FContactRegulatoryInfo(self)\n return conactRegInfo",
"def Attributes(self):\n return FRegulatoryUtils.log_attributes('FContactRegulatoryInfo', self)",
"def __init__(self):\n\n\t\tself.__contacts = None\n\t\tself.__accounts = None\n\t\tself.__deals = Non... | [
"0.7621419",
"0.6440766",
"0.6052107",
"0.58735913",
"0.58644634",
"0.56104106",
"0.55951077",
"0.55670434",
"0.5546189",
"0.5410019",
"0.53739226",
"0.5360233",
"0.53541",
"0.53510576",
"0.52669334",
"0.5263579",
"0.5242533",
"0.52414125",
"0.521908",
"0.5218182",
"0.5214554... | 0.6573449 | 1 |
returns the contact for which this wrapper has all the addinfo/column values | def Contact(self):
return self.__contact | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def contact_info(self):\n return self._contact_info",
"def contact(self):\n return self._contact",
"def contact(self):\n return self._contact",
"def get_contacts(self):\n\n\t\treturn self.__contacts",
"def get_contacts(self):\n contacts = Membership.objects.filter(entity = self,... | [
"0.69202983",
"0.65962774",
"0.65962774",
"0.63626295",
"0.6341426",
"0.6326005",
"0.6319983",
"0.60924613",
"0.60568964",
"0.60556304",
"0.60275143",
"0.5960803",
"0.59009695",
"0.58950126",
"0.5835306",
"0.5797833",
"0.571309",
"0.57005405",
"0.5682633",
"0.5680372",
"0.567... | 0.64397454 | 3 |
Date of birth of the concerned natural person | def DateOfBirth(self, reg_date_of_birth = VALUE_NOT_SET):
ael_reg_dob = None
if reg_date_of_birth != VALUE_NOT_SET:
try:
ael_reg_dob = ael.date_from_string(reg_date_of_birth)
except:
if reg_date_of_birth not in ['', None]:
msg =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def date_of_birth(self):\n return self.__date_of_birth",
"def date_of_birth(self) -> str:\n return self._date_of_birth.strftime('%Y-%m-%d')",
"def birth_date(self) -> str:\n return self._birth_date",
"def birthdate_date(self):\n\n bday = self.birthdate\n if bday:\n ... | [
"0.8200823",
"0.8171922",
"0.8120067",
"0.7951198",
"0.79246074",
"0.765754",
"0.7473447",
"0.745579",
"0.7108592",
"0.70574725",
"0.6949984",
"0.6891937",
"0.68498445",
"0.68213457",
"0.6803174",
"0.6754443",
"0.6736698",
"0.6733992",
"0.6618441",
"0.656881",
"0.6553082",
... | 0.71364975 | 8 |
First name of the concerned natural person | def FirstName(self, reg_first_name = VALUE_NOT_SET):
if reg_first_name != VALUE_NOT_SET:
self.__reg_first_name = reg_first_name
try:
self.__contact.AdditionalInfo().FirstName(self.__reg_first_name)
except:
pass
else:
if not ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_first_name(self) -> str:\n return self.first_name",
"def first_name(self) -> str:\n return self._first_name",
"def pref_first_name(self):\n return self.known_as if self.known_as else self.first_name",
"def get_first_name(self):\n return self._first_name",
"def first_name... | [
"0.7882423",
"0.7805149",
"0.77341115",
"0.7712801",
"0.7661111",
"0.7661111",
"0.7661111",
"0.76325965",
"0.7625189",
"0.7625189",
"0.7606487",
"0.75807947",
"0.75807947",
"0.7543393",
"0.75275517",
"0.7521005",
"0.7509602",
"0.7509602",
"0.7509602",
"0.7509602",
"0.7509602"... | 0.711053 | 59 |
Last name of the concerned natural person | def LastName(self, reg_last_name = VALUE_NOT_SET):
if reg_last_name != VALUE_NOT_SET:
self.__reg_last_name = reg_last_name
try:
self.__contact.AdditionalInfo().LastName(self.__reg_last_name)
except:
pass
else:
if not self.__... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def last_name():\r\n\r\n return surnames()",
"def get_last_name(self) -> str:\n return self.last_name",
"def getLastname(self):\n return self.lastname",
"def get_last_name(people, individual):\n surname = people[individual]['NAME'].split()\n return surname[1]",
"def lastname(self):\n... | [
"0.8193164",
"0.80822515",
"0.80346006",
"0.7993029",
"0.79857093",
"0.79683965",
"0.79683965",
"0.79683965",
"0.79683965",
"0.79683965",
"0.79646444",
"0.79491335",
"0.79422885",
"0.79334354",
"0.79334354",
"0.79180735",
"0.79180735",
"0.79180735",
"0.79180735",
"0.7912743",
... | 0.76919675 | 21 |
NationalId of the concerned natural person | def NationalId(self, reg_national_id = VALUE_NOT_SET):
if reg_national_id != VALUE_NOT_SET:
self.__reg_national_id = reg_national_id
try:
self.__contact.AdditionalInfo().NationalId(self.__reg_national_id)
except:
pass
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_NID():\n return NID",
"def government_id_number(self) -> str:\n return self._government_id_number",
"def get_person_id(person_data):\n person_ref = person_data['Casualty_Reference']\n veh_ref = person_data['Vehicle_Reference']\n acc_id = get_acc_id_from_data(person_data)\n person_... | [
"0.6752156",
"0.64024127",
"0.6256402",
"0.6193446",
"0.61844784",
"0.6149932",
"0.6149932",
"0.61367977",
"0.6133966",
"0.6050021",
"0.6030649",
"0.6021784",
"0.6012439",
"0.59253937",
"0.59218484",
"0.58435404",
"0.58401144",
"0.5793599",
"0.57825446",
"0.57644486",
"0.5758... | 0.73979646 | 0 |
CrmId of the concerned natural person | def CrmId(self, crm_id = VALUE_NOT_SET):
if crm_id != VALUE_NOT_SET:
self.__reg_crm_id = crm_id
try:
self.__contact.AdditionalInfo().RegContactCrmId(self.__reg_crm_id)
except:
pass
else:
if not self.__reg_crm_id:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_person_id(person_data):\n person_ref = person_data['Casualty_Reference']\n veh_ref = person_data['Vehicle_Reference']\n acc_id = get_acc_id_from_data(person_data)\n person_id = common.get_gb_person_id(acc_id, int(veh_ref), int(person_ref))\n return person_id",
"def get_orcid_id(self):\n ... | [
"0.6603497",
"0.6412004",
"0.6359146",
"0.62600315",
"0.6250896",
"0.61515063",
"0.614126",
"0.61211526",
"0.60835594",
"0.6075564",
"0.6075564",
"0.60001755",
"0.5949616",
"0.5896278",
"0.5895303",
"0.58926725",
"0.58770686",
"0.58716244",
"0.5861452",
"0.5861452",
"0.586145... | 0.61229914 | 7 |
The identifier used towards/by an exchange to identify a person or legal entity, before the actual national id or the LEI is divulged. | def ExchangeId(self, exchange_id = VALUE_NOT_SET):
if exchange_id != VALUE_NOT_SET:
if str(exchange_id).isdigit():
self.__reg_exchange_id = int(exchange_id)
elif str(exchange_id) in ['None', '']:
self.__reg_exchange_id = None
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ident():\n return -1",
"def party_id(self):\n pass",
"def getIdent (self) :\n return self.id",
"def get_identifier(self):",
"def government_id_number(self) -> str:\n return self._government_id_number",
"def identifier(self):\n return str(self._nfcid)",
"de... | [
"0.6787299",
"0.6757533",
"0.65951097",
"0.6572598",
"0.6549644",
"0.6535619",
"0.6466146",
"0.63963974",
"0.6385991",
"0.6370726",
"0.6351748",
"0.6342159",
"0.63358164",
"0.63045776",
"0.62974083",
"0.6294242",
"0.62912565",
"0.6278431",
"0.627394",
"0.62542075",
"0.6243608... | 0.0 | -1 |
An optional unique name, if specified there can only be one contact with this name for each party. | def UniqueName(self, unique_name = VALUE_NOT_SET):
if unique_name != VALUE_NOT_SET:
try:
if FIntegrationUtils.FIntegrationUtils.get_acm_version_override() >= 2017.2:
self.__contact.UniqueName(unique_name)
else:
is_unique, contac... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def contact_name(self) -> str:\n return pulumi.get(self, \"contact_name\")",
"def party_id(self):\n pass",
"def create_contact(contact, party_type, party):\n\tcontact = contact\t.split(\" \")\n\n\tcontact = frappe.get_doc({\n\t\t\"doctype\":\"Contact\",\n\t\t\"first_name\":contact[0],\n\t\t\"last... | [
"0.58776766",
"0.5617005",
"0.56108975",
"0.5571864",
"0.556685",
"0.556685",
"0.5513689",
"0.5500145",
"0.5463818",
"0.536946",
"0.5348271",
"0.53382397",
"0.53270036",
"0.5291315",
"0.52906907",
"0.5287689",
"0.52846396",
"0.52846396",
"0.52688885",
"0.52560043",
"0.5240531... | 0.70607924 | 0 |
returns the ClientType based on where the CrmId is found on the linked objects | def ClientType(self):
self.__client_type = FRegulatoryUtils.getClientType(self.__contact)
return self.__client_type | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def client_type(self) -> Optional[str]:\n return pulumi.get(self, \"client_type\")",
"def type(self):\n return _internals.CorrelationId_type(self)",
"def find_type(source, target):\n x = [r for r in source.synset_relations if r.target == target.id]\n if len(x) != 1:\n raise Exception... | [
"0.5487231",
"0.5164598",
"0.51574206",
"0.51353335",
"0.5011951",
"0.49763677",
"0.49734464",
"0.49716905",
"0.49659985",
"0.49616665",
"0.49428558",
"0.49414885",
"0.4923532",
"0.49094817",
"0.48822343",
"0.48643944",
"0.48532623",
"0.48462522",
"0.48260435",
"0.48219457",
... | 0.5837794 | 0 |
Another trader that jointly owns the account with this trader | def JointAccount(self):
joint_accounts = []
if self.IsGeneralPartner():
for contact in self.__contact.Party().Contacts():
if contact.AdditionalInfo().RegGeneralPartner():
joint_accounts.append(contact)
else:
F... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tribe(self, instance):\r\n return instance.user.profile.tribe",
"def transaction_to_player(self, origin, amount, receiver):\r\n print(\"Transfering\", amount, origin, \"->\", receiver)\r\n try:\r\n origin.transfer(-amount)\r\n except:\r\n # the origin will be... | [
"0.5814136",
"0.5709977",
"0.56947994",
"0.5616658",
"0.5561894",
"0.5512911",
"0.5500826",
"0.5494856",
"0.540658",
"0.53586686",
"0.53467846",
"0.53300697",
"0.5320134",
"0.53097206",
"0.5293968",
"0.5249603",
"0.5240867",
"0.5225998",
"0.52059394",
"0.5183462",
"0.5179566"... | 0.0 | -1 |
General partner has responsibility for the actions of the business, can legally bind the business and is personally liable for all the business's debts and obligations. | def IsGeneralPartner(self, is_general_partner = VALUE_NOT_SET):
if is_general_partner != VALUE_NOT_SET:
self.__is_general_partner = FRegulatoryUtils.get_bool(is_general_partner, 'IsGeneralPartner')
FRegulatoryLogger.DEBUG(logger, "The IsGeneralPartner is being set to <%s>."%(str(self.__i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_eligible(self):\n pass",
"def test_create_warranty(self):\n pass",
"def safeWithdrawal(self):\n if self._after_dead_line():\n # each contributor can withdraw the amount they contributed if the goal was not reached\n if not self._funding_goal_reached.get():\n ... | [
"0.62831205",
"0.6199623",
"0.5960634",
"0.5711672",
"0.5653453",
"0.56343335",
"0.5625102",
"0.5595211",
"0.5571533",
"0.55410933",
"0.5500753",
"0.54941815",
"0.5458377",
"0.5449559",
"0.5422104",
"0.54058695",
"0.5389889",
"0.53809947",
"0.53775984",
"0.5377101",
"0.534418... | 0.0 | -1 |
Committing this instance will automatically commit all the RegulatorySupport related attributes on the contact | def Commit(self):
try:
acm.BeginTransaction()
self.__contact.Commit()
if FIntegrationUtils.FIntegrationUtils.get_acm_version_override() < 2015.4:
self.__integration_utils.set_additional_info('DateOfBirth', self.__contact, self.__reg_date_of_birth)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def commit(self):\n self.cnx.commit()",
"def commit(self):\n pass",
"def commit(self):\n pass",
"def commit(self):\n pass",
"def commit(self):\n pass",
"def commit(self):\n pass",
"def commit(self):\n return",
"def commitChanges(self):\n \n ... | [
"0.6179308",
"0.6118413",
"0.6118413",
"0.6118413",
"0.6118413",
"0.6118413",
"0.60592747",
"0.6013804",
"0.59319466",
"0.5926993",
"0.5916751",
"0.5899212",
"0.58974123",
"0.5881195",
"0.5875204",
"0.5863884",
"0.58605444",
"0.5854823",
"0.5801967",
"0.5795815",
"0.57171786"... | 0.79224825 | 0 |
Deleting this instance automatically deletes all the attributes related to the reporting on the instrument or on the ContactRegulatoryInfo in the ADS | def Delete(self):
FRegulatoryUtils.Delete(self.__contact, "Contact")
FRegulatoryLogger.DEBUG(logger, "Deleted all AdditionalInfos on Contact related to Regulatory Reporting") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cleanup_aai(cls):\n logger.info(\"####################### Start to clean up AAI settings\")\n aai = Customer.get_by_global_customer_id(\"5GCustomer\")\n aai.delete()",
"def delete(self):\n self._instance.delete()\n self._instance = None\n self._data_defs = []",
"de... | [
"0.6274676",
"0.6151817",
"0.60736465",
"0.58964264",
"0.58367074",
"0.58200717",
"0.58007216",
"0.5781004",
"0.57804185",
"0.5743467",
"0.5707958",
"0.56463885",
"0.56211966",
"0.56100756",
"0.5555345",
"0.5555345",
"0.5555345",
"0.5555345",
"0.55472887",
"0.55391157",
"0.55... | 0.74394304 | 0 |
returns the attributes on the FContactRegulatoryInfoBase instance | def Attributes(self):
return FRegulatoryUtils.log_attributes('FContactRegulatoryInfo', self) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def RegulatoryInfo(self):\n conactRegInfo = FContactRegulatoryInfo(self)\n return conactRegInfo",
"def getAttributes(self):\n pass",
"def get_attributes(self):\n return self.attributes",
"def get_attributes(cls):\r\n return []",
"def get_attributes(self):\n _attributes = {... | [
"0.76906836",
"0.7054827",
"0.67832905",
"0.67631334",
"0.6749298",
"0.67152345",
"0.66815585",
"0.6680654",
"0.6680654",
"0.66506875",
"0.66434884",
"0.6618119",
"0.65413237",
"0.6490594",
"0.64605737",
"0.64063853",
"0.6323494",
"0.6309063",
"0.63062006",
"0.62716734",
"0.6... | 0.85865146 | 0 |
returns the FContactRegulatoryInfoBase instance for the given contact | def RegulatoryInfo(self):
conactRegInfo = FContactRegulatoryInfo(self)
return conactRegInfo | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, contact = None):\n try:\n self.__contact = contact\n if not self.__contact:\n FRegulatoryLogger.ERROR(logger, \"The name on the contact is the unique identifier of the contact. Kindly provide a valid acm.FContact object\")\n return None\... | [
"0.71412814",
"0.62537146",
"0.58082145",
"0.5799355",
"0.55888337",
"0.5545059",
"0.55302864",
"0.55302864",
"0.54784495",
"0.54784495",
"0.54784495",
"0.53763604",
"0.532584",
"0.5272704",
"0.52715975",
"0.52623534",
"0.5120345",
"0.51012933",
"0.50584227",
"0.50581264",
"0... | 0.76837945 | 0 |
Return a collection of FContactRegulatoryInfoBase instances matching constraint specified in the Select query | def Select(query):
party = None
if query.find('and party') != -1:#it means there is an additional condition added
pos = query.find('and party')
party_name = query[(pos + len('and party')):]
query = query[0:pos]
party_name = party_name.replace('=', '').replace("'", '')
p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def RegulatoryInfo(self):\n conactRegInfo = FContactRegulatoryInfo(self)\n return conactRegInfo",
"def get_contacts(self):\n contacts = Membership.objects.filter(entity = self, key_contact = True).order_by('importance_to_entity')\n return contacts",
"def Attributes(self):\n return FR... | [
"0.6478444",
"0.54798746",
"0.51769966",
"0.50363517",
"0.50300074",
"0.50044805",
"0.50035316",
"0.50017864",
"0.4927733",
"0.49109888",
"0.49109024",
"0.4889764",
"0.48388788",
"0.47877604",
"0.47697586",
"0.4741461",
"0.47025535",
"0.4675752",
"0.46756333",
"0.46720454",
"... | 0.5390563 | 2 |
Set up and parse commandline arguments. | def parse_args():
parser = argparse.ArgumentParser(description=__doc__)
return parser.parse_args() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def main():\n args = parse_args()\n process_args(args)",
"def setUp(self):\n self.parser = command_line.get_args()",
"def setup_args(cls, parser):\n pass",
"def _setup_arguments(self):\n\n self._parser.add_argument(\"-a\", \"--area-interest\",\n ... | [
"0.74570394",
"0.742756",
"0.7389333",
"0.73735505",
"0.72907114",
"0.7161568",
"0.7140092",
"0.7121027",
"0.71085113",
"0.710657",
"0.7088012",
"0.7032618",
"0.7017465",
"0.70092034",
"0.70074636",
"0.699794",
"0.69776225",
"0.69776225",
"0.69619316",
"0.6938218",
"0.6922756... | 0.0 | -1 |
Main function... makes 'forward declarations' of helper functions unnecessary | def main():
# Constants
groundstation_name = 'Wallops Antenna'
groundstation_address = 'Radar Road, Temperanceville, VA 23442'
satnum = 25544 # ISS = 25544
saturl="http://www.celestrak.com/NORAD/elements/stations.txt"
gs_minimum_elevation_angle = 10.0
# Alternate constants
gs_alt_lat =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n pass",
"def main() -> None:",
"def main() -> None:",
"def main() -> None:",
"def main() -> None:",
"def main():\n pass",
"def main():\n pass",
"def main():\n pass",
"def main():\n pass",
"def main():\n pass",
"def main():\n pass",
"def main():\n pass"... | [
"0.6937029",
"0.6773711",
"0.6773711",
"0.6773711",
"0.6773711",
"0.6758369",
"0.6758369",
"0.6758369",
"0.6758369",
"0.6758369",
"0.6758369",
"0.6758369",
"0.6758369",
"0.6758369",
"0.6758369",
"0.6758369",
"0.6758369",
"0.6758369",
"0.6758369",
"0.6758369",
"0.6758369",
"... | 0.0 | -1 |
Function to print a header with satellite info for the satellite number | def print_satellite_header(st):
# Retrieve TLE data
print "Satellite Number/Launch Year/Launch Number of Year: %s/20%s/%s" % \
(st.get_satellite_number(), st.get_launch_year(), \
st.get_launch_year_number())
year = 2000 + int(st.get_epoch_year())
fracyear = timedelta(float(st.get_ep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_header():\n print(\"STEM Center Temperature Project\")\n print(\"Shaotong Wen\")",
"def print_header_information():\n\t\tprint \"Elijah Molloy\"\n\t\tprint \"70-510 - Spring 1 - 2018\"\n\t\tprint \"PROGRAMMING ASSIGNMENT #4\\n\"",
"def print_the_header():\n print('-------------------')\n ... | [
"0.73586893",
"0.71547425",
"0.6722391",
"0.64073485",
"0.6397794",
"0.6378043",
"0.63605297",
"0.6274469",
"0.6251121",
"0.6184243",
"0.616818",
"0.6158332",
"0.61397535",
"0.61184627",
"0.6110125",
"0.6110125",
"0.6106982",
"0.60947645",
"0.60926664",
"0.608937",
"0.6087103... | 0.8453364 | 0 |
Function to print a header for the inview info | def print_inview_header(minimum_elevation_angle, now, gs):
print "Inviews (above %s degrees) on %s-%s-%s" % \
(minimum_elevation_angle, now.year, now.month, now.day)
print "At %s: Lat/Lon/El: %s/%s/%s" % \
(gs.get_name(), gs.get_latitude(), gs.get_longitude(),
gs.get_elevation_in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_header():\n return {};",
"def Show_Headers( self ):\r\n self.system.Change_Seq( \"Header\" )",
"def print_header_information():\n\t\tprint \"Elijah Molloy\"\n\t\tprint \"70-510 - Spring 1 - 2018\"\n\t\tprint \"PROGRAMMING ASSIGNMENT #4\\n\"",
"def print_the_header():\n print('----------... | [
"0.7747214",
"0.763318",
"0.761402",
"0.74126256",
"0.73512864",
"0.7330032",
"0.73006797",
"0.7244701",
"0.72426593",
"0.7112192",
"0.70161813",
"0.701025",
"0.6995395",
"0.6979925",
"0.69683486",
"0.6944731",
"0.6939936",
"0.6909849",
"0.6899858",
"0.68321836",
"0.6813634",... | 0.7582373 | 3 |
Function to print the inviews | def print_inviews(gs, inviews):
#print "Number of inviews from %s to %s: %d" % \
# (today_start.isoformat(), today_end.isoformat(),len(inviews))
for i in range(0, len(inviews)):
#print "%s to %s" % (inviews[i][0].isoformat(), inviews[i][1].isoformat())
print_inview(inviews[i][0], invi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_details(self):\n self.view.print_details()",
"def print(self):\r\n self.print_avec_separateur()",
"def print_out():\n pass",
"def _print_inwards(middleware_name):\n if _VERBOSE_MODE:\n print('{}--->'.format(middleware_name))",
"def pprint(self):\n # just here... | [
"0.67796624",
"0.6479328",
"0.6461996",
"0.6318401",
"0.63149685",
"0.61923224",
"0.61706716",
"0.61218095",
"0.6109504",
"0.6102467",
"0.6101652",
"0.6087358",
"0.60798454",
"0.6077613",
"0.60708314",
"0.6038918",
"0.60107464",
"0.6009129",
"0.5995637",
"0.59919393",
"0.5979... | 0.75969446 | 0 |
Function to print a table of time, azimuth, elevation for each inview | def print_azeltables(inviews, ic):
for i in range(0, len(inviews)):
print " "
print "Az/El for inview %s to %s" % (inviews[i][0], inviews[i][1])
azels = ic.compute_azels(inviews[i][0], inviews[i][1], 15)
for j in range(0, len(azels)):
print "At %s, azimuth=%8.2f, elevatio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_inview_header(minimum_elevation_angle, now, gs):\n print \"Inviews (above %s degrees) on %s-%s-%s\" % \\\n (minimum_elevation_angle, now.year, now.month, now.day)\n print \"At %s: Lat/Lon/El: %s/%s/%s\" % \\\n (gs.get_name(), gs.get_latitude(), gs.get_longitude(),\n gs.... | [
"0.7208172",
"0.67271405",
"0.6130861",
"0.61259687",
"0.59162146",
"0.5775518",
"0.57627594",
"0.5703854",
"0.56089044",
"0.5606912",
"0.56049377",
"0.5569098",
"0.5553486",
"0.5533526",
"0.54851115",
"0.5451577",
"0.54403365",
"0.5424925",
"0.54075736",
"0.5402264",
"0.5393... | 0.7502286 | 0 |
Function to print a single inview | def print_inview(rise, set, gs):
riselocal = rise + gs.get_utcoffset_ondate(rise.year, rise.month, rise.day)
setlocal = set + gs.get_utcoffset_ondate(set.year, set.month, set.day)
delta = set - rise
print "%2d:%02d:%02d to %2d:%02d:%02d (%3d seconds) %2d:%02d:%02d to %2d:%02d:%02d" % \
(ri... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_inviews(gs, inviews):\n #print \"Number of inviews from %s to %s: %d\" % \\\n # (today_start.isoformat(), today_end.isoformat(),len(inviews))\n\n for i in range(0, len(inviews)):\n #print \"%s to %s\" % (inviews[i][0].isoformat(), inviews[i][1].isoformat())\n print_inview(inv... | [
"0.6761885",
"0.64787924",
"0.6355465",
"0.6279782",
"0.6215807",
"0.61902606",
"0.61406785",
"0.61145645",
"0.61145645",
"0.61145645",
"0.61145645",
"0.59689873",
"0.5934436",
"0.59211826",
"0.5917059",
"0.59007823",
"0.58670545",
"0.5810057",
"0.5791739",
"0.5789504",
"0.57... | 0.5826345 | 17 |
We list all notebooks here, even those that are not | def _tested_notebooks():
all_notebooks = _list_all_notebooks()
skipped_notebooks = functools.reduce(
lambda a, b: a.union(b),
list(set(glob.glob(g, recursive=True)) for g in SKIP_NOTEBOOKS),
)
return sorted(
os.path.abspath(n) for n in all_notebooks.difference(skipped_notebooks... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_notebooks(command):\n namespace = app.main(command)\n assert namespace.command == 'l' or namespace.command == \"list\"",
"def listNotebooks(self, authenticationToken):\r\n pass",
"def listLinkedNotebooks(self, authenticationToken):\r\n pass",
"def GetNotebooks(self):\r\n\r\n if se... | [
"0.72980744",
"0.7263471",
"0.6903213",
"0.6728304",
"0.6664313",
"0.65559214",
"0.6496395",
"0.64076346",
"0.6331407",
"0.6271838",
"0.6045749",
"0.5983143",
"0.5825484",
"0.5712624",
"0.5645208",
"0.56238604",
"0.5619144",
"0.55256057",
"0.5506115",
"0.547778",
"0.5438583",... | 0.68560046 | 3 |
Returns a pretty much unique 32bit hash for pretty much any python object. | def hashIt(*args):
total = int(0)
for x in args:
if isinstance(x, dict):
for k, key in enumerate(sorted(x.keys())):
total += hashIt(k, key, x[key])
elif isinstance(x, (list, tuple)):
for k, value in enumerate(x):
total += hashIt(k, value)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hash(obj):\n \n import hashlib\n import pickle\n \n sha = hashlib.sha256()\n sha.update(pickle.dumps(obj))\n \n return sha.hexdigest()",
"def hashkey(obj, salt=0):\n if isinstance(obj, str):\n return zlib.adler32(obj.encode(), salt) & 0xffffffff\n elif isinstance(obj, byt... | [
"0.7476817",
"0.73924834",
"0.71622837",
"0.7141496",
"0.71407014",
"0.7067109",
"0.70340466",
"0.70264083",
"0.7020463",
"0.69946253",
"0.69786173",
"0.6912701",
"0.6904169",
"0.6882359",
"0.68673223",
"0.6846751",
"0.68304324",
"0.6830188",
"0.6830188",
"0.68252647",
"0.681... | 0.0 | -1 |
Use as a decorator to print info about the function and its result. Follows deferred results. | def showResult(f):
def substitute(self, *args, **kw):
def msg(result, callInfo):
resultInfo = str(result)
if len(callInfo) + len(resultInfo) > 70:
callInfo += "\n"
print("\n{} -> {}".format(callInfo, resultInfo))
return result
SR_STUFF... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_result(func):\n def new_func(*args, **kwargs):\n result = func(*args, **kwargs)\n print(result)\n return result\n return new_func",
"def print_log(func):\n @wraps(func)\n def wrapper(*args, **kwargs):\n n = func.__name__\n print('{} has started with argume... | [
"0.7564186",
"0.69486636",
"0.68396944",
"0.67687505",
"0.6661167",
"0.6646779",
"0.6636007",
"0.6607297",
"0.65720874",
"0.6512646",
"0.6510811",
"0.65025723",
"0.64824915",
"0.6458015",
"0.6400681",
"0.639704",
"0.63808566",
"0.6372295",
"0.6261466",
"0.62549406",
"0.622034... | 0.78961205 | 0 |
Use as a decorator (after showResult) to include the current thread in the info about the function. | def whichThread(f):
SR_STUFF[2] = True
return f | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def showResult(f):\n def substitute(self, *args, **kw):\n def msg(result, callInfo):\n resultInfo = str(result)\n if len(callInfo) + len(resultInfo) > 70:\n callInfo += \"\\n\"\n print(\"\\n{} -> {}\".format(callInfo, resultInfo))\n return result... | [
"0.67912334",
"0.6404033",
"0.6282374",
"0.6252713",
"0.616354",
"0.61556727",
"0.6084007",
"0.6083681",
"0.60718924",
"0.6068543",
"0.60177517",
"0.6006008",
"0.5985451",
"0.59275067",
"0.59253156",
"0.5914145",
"0.58757865",
"0.5848576",
"0.5832424",
"0.5822284",
"0.5812835... | 0.5666411 | 31 |
Returns the fully qualified name of the supplied string if it can be imported and then reflected back into the FQN, or C{None} if not. | def strToFQN(self, x):
try:
obj = reflect.namedObject(x)
fqn = reflect.fullyQualifiedName(obj)
except:
return
return fqn | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def try_import(import_str, default=None):\r\n try:\r\n return import_module(import_str)\r\n except ImportError:\r\n return default",
"def get_qualified_class_name(o):\n module = o.__class__.__module__\n module = '' if module in IGNORABLE_MODULES else module\n module = module + '.' if... | [
"0.6144014",
"0.6059056",
"0.60289675",
"0.6027369",
"0.5973197",
"0.5959286",
"0.5954686",
"0.58813894",
"0.5866241",
"0.5862896",
"0.58329266",
"0.58159465",
"0.58044475",
"0.5801065",
"0.57967067",
"0.5795597",
"0.5794225",
"0.57900107",
"0.5770697",
"0.57595575",
"0.57583... | 0.610944 | 1 |
Returns a string of the pickled object or C{None} if it couldn't be pickled and unpickled back again. | def objToPickle(self, x):
try:
xp = pickle.dumps(x)
pickle.loads(xp)
except:
return
return xp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def serialize(obj):\n serial = repr(obj)\n try:\n if eval(serial) == obj:\n return serial\n except:\n pass\n try:\n serial = pickle.dumps(obj)\n return 'pickle.loads(%s)' % repr(serial)\n except:\n raise Exception #unable to serialize",
"def try_pickle... | [
"0.70065063",
"0.6877049",
"0.68509924",
"0.66886413",
"0.6565445",
"0.64063543",
"0.6293955",
"0.62600654",
"0.62112856",
"0.61454225",
"0.6095842",
"0.6067861",
"0.60203993",
"0.60195476",
"0.5951163",
"0.59425896",
"0.5937268",
"0.59203345",
"0.58836335",
"0.5877021",
"0.5... | 0.5900885 | 18 |
Returns the fully qualified name of the supplied object if it can be reflected into an FQN and back again, or C{None} if not. | def objToFQN(self, x):
try:
fqn = reflect.fullyQualifiedName(x)
reflect.namedObject(fqn)
except:
return
return fqn | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def full_object_name(obj):\n\n try:\n module = obj.__module__\n if module is None or module == str.__class__.__module__:\n return obj.__name__ # Avoid reporting __builtin__\n else:\n return module + '.' + obj.__name__\n except Exception:\n return None",
"d... | [
"0.720825",
"0.68506885",
"0.68197757",
"0.6692258",
"0.669201",
"0.66850084",
"0.6678043",
"0.6637933",
"0.655427",
"0.6363912",
"0.6304597",
"0.62705034",
"0.6256707",
"0.6187803",
"0.6154",
"0.6152605",
"0.612782",
"0.6108689",
"0.603036",
"0.60212445",
"0.60132855",
"0.... | 0.6943579 | 1 |
Attempts to convert the supplied object to a pickle and, failing that, to a fully qualified name. | def processObject(self, x):
pickled = self.objToPickle(x)
if pickled:
return pickled
return self.objToFQN(x) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def try_pickle_dumps(obj):\n try:\n return cloudpickle.dumps(obj)\n except Exception:\n pass\n\n try:\n return pickle.dumps(obj)\n except Exception:\n raise",
"def pickle_object(obj, ofname: \"Path|str\"):\n ofname = Path(ofname)\n maybe_make_output_dir(ofname)\n ... | [
"0.7063126",
"0.64876986",
"0.60792595",
"0.5974439",
"0.58921015",
"0.58882225",
"0.58367944",
"0.57654095",
"0.5750935",
"0.57494664",
"0.5721882",
"0.56769556",
"0.5674027",
"0.5642555",
"0.56334174",
"0.5625167",
"0.5624294",
"0.560091",
"0.560091",
"0.5558587",
"0.555558... | 0.6659083 | 1 |
Sets my current fargskw tuple, returning a reference to myself to allow easy method chaining. The function I{f} must be an actual callable object if you want to use L{nn}. Otherwise it can also be a string depicting a callable. You can specify I{args} with a second argument (as a list or tuple), and I{kw} with a third ... | def setCall(self, *metaArgs, **kw):
if metaArgs:
equiv = True
if self.lastMetaArgs is None:
equiv = False
elif len(metaArgs) != len(self.lastMetaArgs):
equiv = False
else:
for k, arg in enumerate(metaArgs):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, func, *args, **kwargs):\n self._func = func\n self._args = args\n self._kwargs = kwargs\n self._fully_bound = None",
"def set_func_args(self, *args, **kwargs):\n self._func_args = args \n self._func_kw_args = kwargs",
"def call(f):\n def g(*args, **kwds):\n ... | [
"0.5703724",
"0.56538165",
"0.55401057",
"0.5524479",
"0.54307365",
"0.5427452",
"0.54265815",
"0.5302647",
"0.52991205",
"0.5291197",
"0.5282004",
"0.5254453",
"0.5248723",
"0.523779",
"0.52307767",
"0.52307767",
"0.52307767",
"0.52307767",
"0.52307767",
"0.52307767",
"0.523... | 0.6287769 | 0 |
Returns a unique ID for my current callable. | def ID(self):
if hasattr(self, 'currentID'):
return self.currentID
if hasattr(self, 'callDict'):
thisID = hashIt(self.callDict)
if hasattr(self, 'pastInfo'):
self.pastInfo[thisID] = {'callDict': self.callDict}
else:
thisID = None
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_id(self): # real signature unknown; restored from __doc__\n return \"\"",
"def _get_unique_id(self):\n now = datetime.now()\n\n u_id = now.second + 60*(now.minute + 60*(now.hour + 24*(now.day + 31*(now.month + 366*(now.year)))))\n return \"instance\" + str(u_id)",
"def gener... | [
"0.7378038",
"0.70565146",
"0.7052797",
"0.69692785",
"0.6922952",
"0.685859",
"0.68508834",
"0.6849531",
"0.6843613",
"0.68147796",
"0.68109673",
"0.68109673",
"0.68109673",
"0.68109673",
"0.6809885",
"0.67909235",
"0.67909235",
"0.67909235",
"0.67909235",
"0.67909235",
"0.6... | 0.7128812 | 1 |
Use this whenever info won't be needed anymore for the specified call ID, to avoid memory leaks. | def forgetID(self, ID):
if ID in getattr(self, 'pastInfo', {}):
del self.pastInfo[ID] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _validate_call_id(self, call_id):\n\n self._validate_required_data(call_id, self.CALL_ID)\n\n query = CallRecord.objects.filter(call_id=call_id)\n\n if query.exists():\n raise NotAcceptable(\n detail='Call id is already in use. Please, choose another')",
"def _s... | [
"0.5423897",
"0.53597885",
"0.5170545",
"0.51276785",
"0.5111587",
"0.5107926",
"0.50829285",
"0.5059674",
"0.50555295",
"0.49963364",
"0.49642846",
"0.495139",
"0.4910475",
"0.48489508",
"0.47891104",
"0.4779412",
"0.47645634",
"0.47535005",
"0.47411475",
"0.4731908",
"0.469... | 0.59721094 | 0 |
Context manager for setting and getting call info. Call this context manager method with info about a particular call (same format as L{setCall} uses) and it yields an L{InfoHolder} object keyed to that call. It lets you get info about the call inside the context, without worrying about the ID or calling L{forgetID}, e... | def context(self, *metaArgs, **kw):
if not hasattr(self, 'pastInfo'):
raise Exception(
"Can't use a context manager without saving call info")
ID = self.setCall(*metaArgs, **kw).ID
yield InfoHolder(self, ID)
self.forgetID(ID) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def aboutCall(self, ID=None, nowForget=False):\n if ID:\n pastInfo = self.getInfo(ID, 'aboutCall', nowForget)\n if pastInfo:\n return pastInfo\n callDict = self.getInfo(ID, 'callDict')\n if not callDict:\n return \"\"\n func, args, kw = [c... | [
"0.6116589",
"0.5598187",
"0.55867136",
"0.5528214",
"0.53109026",
"0.5237054",
"0.51175916",
"0.51127905",
"0.50732195",
"0.5064161",
"0.5057853",
"0.50216436",
"0.50200754",
"0.5004932",
"0.50042874",
"0.49915943",
"0.4979725",
"0.49719357",
"0.49228385",
"0.4916614",
"0.49... | 0.7960227 | 0 |
Provides info about a call. If the supplied name is 'callDict', returns the fargskwinstance dict for my current callable. The value of I{ID} is ignored in such case. Otherwise, returns the named information attribute for the previous call identified with the supplied ID. | def getInfo(self, ID, name, nowForget=False):
def getCallDict():
if hasattr(self, 'callDict'):
result = self.callDict
if nowForget:
del self.callDict
else:
result = None
return result
if hasa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def aboutCall(self, ID=None, nowForget=False):\n if ID:\n pastInfo = self.getInfo(ID, 'aboutCall', nowForget)\n if pastInfo:\n return pastInfo\n callDict = self.getInfo(ID, 'callDict')\n if not callDict:\n return \"\"\n func, args, kw = [c... | [
"0.6510412",
"0.5486511",
"0.5346446",
"0.52030444",
"0.5146749",
"0.5081739",
"0.5034171",
"0.50240844",
"0.50165373",
"0.4871073",
"0.48639536",
"0.48548323",
"0.4849726",
"0.48485854",
"0.48369116",
"0.48026302",
"0.47847903",
"0.4784088",
"0.4783681",
"0.47752234",
"0.476... | 0.6836767 | 0 |
Namespacename parser. For my current callable or a previous one identified by I{ID}, returns a 2tuple suitable for sending to a process worker via C{pickle}. | def nn(self, ID=None, raw=False):
if ID:
pastInfo = self.getInfo(ID, 'wireVersion')
if pastInfo:
return pastInfo
result = None, None
callDict = self.getInfo(ID, 'callDict')
if not callDict:
# No callable set
return result
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _name(self):\n return self.arguments[0].split('(')[0]",
"def _name(self):\n return self._arguments[0].split('(')[0]",
"def _get_name(name):\n if \"::\" in name:\n return name.split(\"::\")[1]\n return name",
"def _get_name(name):\n if \"::\" in name:\n ... | [
"0.6336964",
"0.62239903",
"0.59742975",
"0.59742975",
"0.5957465",
"0.5944445",
"0.5893739",
"0.5789447",
"0.57749027",
"0.5652084",
"0.561324",
"0.56079495",
"0.55954885",
"0.5570692",
"0.55608606",
"0.55608606",
"0.55608606",
"0.55608606",
"0.55608606",
"0.55608606",
"0.55... | 0.0 | -1 |
Returns an informative string describing my current function call or a previous one identified by ID. | def aboutCall(self, ID=None, nowForget=False):
if ID:
pastInfo = self.getInfo(ID, 'aboutCall', nowForget)
if pastInfo:
return pastInfo
callDict = self.getInfo(ID, 'callDict')
if not callDict:
return ""
func, args, kw = [callDict[x] for ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _function_name(func):\n return \"Calling the function: def {}()\".format(func.__name__)",
"def get_call_string(self) -> Optional[str]: # noqa\n call_repr = get_call_string(self.func_name, self.args, self.kwargs, max_length=75)\n return call_repr",
"def __repr__(self):\n\t\treturn self.fun... | [
"0.6560909",
"0.6306112",
"0.6107266",
"0.6059423",
"0.6059423",
"0.6059423",
"0.6059423",
"0.6059423",
"0.6059423",
"0.6059423",
"0.6059423",
"0.6041999",
"0.6041999",
"0.6041999",
"0.6029351",
"0.6029351",
"0.6029351",
"0.6029351",
"0.6029351",
"0.60204625",
"0.6013816",
... | 0.71258074 | 0 |
Returns an informative string describing an exception raised from my function call or a previous one identified by ID, or one you supply (as an instance, not a class). | def aboutException(self, ID=None, exception=None, nowForget=False):
if ID:
pastInfo = self.getInfo(ID, 'aboutException', nowForget)
if pastInfo:
return pastInfo
if exception:
lineList = ["Exception '{}'".format(repr(exception))]
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ErrorString(self): # real signature unknown; restored from __doc__\n pass",
"def __str__(self):\n error = '{0} ({1}): {2}'.format(self.__class__.__name__, self.code,\n self.args)\n return error",
"def __str__(self):\n return \"Error: %s\"%s... | [
"0.64060336",
"0.63906485",
"0.62958705",
"0.62437165",
"0.6237594",
"0.62264633",
"0.61808884",
"0.61449856",
"0.6136974",
"0.613228",
"0.6131623",
"0.61072975",
"0.60843146",
"0.60669607",
"0.6061389",
"0.60569376",
"0.6030983",
"0.60280555",
"0.6019237",
"0.6018687",
"0.60... | 0.6514721 | 0 |
Returns an informative string describing a Twisted failure raised from my function call or a previous one identified by ID. You can use this as an errback. | def aboutFailure(self, failureObj, ID=None, nowForget=False):
if ID:
pastInfo = self.getInfo(ID, 'aboutFailure', nowForget)
if pastInfo:
return pastInfo
lineList = ["Failure '{}'".format(failureObj.getErrorMessage())]
callInfo = self.aboutCall()
if... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def repr_failure(self, excinfo):\n if excinfo.errisinstance(MypyError):\n return excinfo.value.args[0]\n return super().repr_failure(excinfo)",
"def error_str(rc):\n return f\"{rc}: {mqtt.error_string(rc)}\"",
"def fail(self, tup_id):\n pass",
"def error(self, correlation_id: O... | [
"0.61884654",
"0.6145118",
"0.6071848",
"0.6033766",
"0.6013761",
"0.5980293",
"0.59666383",
"0.5962902",
"0.5958477",
"0.5956995",
"0.5916905",
"0.5916794",
"0.5888485",
"0.5883418",
"0.5870615",
"0.583047",
"0.57956845",
"0.57738894",
"0.5769685",
"0.5768838",
"0.57651407",... | 0.5799822 | 16 |
Maps a string to a Python function, e.g., "relu" => `tf.nn.relu`. | def get_activation(self, activation_string):
act = activation_string.lower()
if act == "linear":
return None
elif act == "relu":
return tf.nn.relu
elif act == "gelu":
return self.gelu
elif act == "tanh":
return tf.tanh
else... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def map_string2func(funcname, clss, compute_capability):\n if \"_get_\" + funcname not in globals():\n raise AttributeError(\"kernel type '\" + funcname + \"' not understood\")\n return globals()[\"_get_\" + funcname](clss, compute_capability)",
"def get_activation(activation_string):\n\n # We as... | [
"0.74201083",
"0.66567653",
"0.6612086",
"0.6498102",
"0.64282113",
"0.6403409",
"0.6328271",
"0.6157566",
"0.6062532",
"0.60543394",
"0.60218483",
"0.60041183",
"0.6000147",
"0.59943116",
"0.59920865",
"0.5933514",
"0.5877585",
"0.5861618",
"0.5804753",
"0.57750344",
"0.5756... | 0.60603654 | 9 |
Gaussian Error Linear Unit. This is a smoother version of the RELU. | def gelu(self, input_tensor):
cdf = 0.5 * (1.0 + tf.erf(input_tensor / tf.sqrt(2.0)))
return input_tensor * cdf | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GaussianGaussianLoss(mu_kl, log_var_kl, const_var=None) :\n if const_var is None : # Heteroscedastic\n def ggl(x, mu_log_var) :\n N = K.int_shape(mu_log_var)[1]\n mu = mu_log_var[:,:,0]\n log_var = mu_log_var[:,:,1]\n mu = mu[:,:,np.newaxis]\n lo... | [
"0.62770605",
"0.6188238",
"0.6133913",
"0.6133913",
"0.6133913",
"0.6133913",
"0.6133913",
"0.6133913",
"0.6133913",
"0.6133913",
"0.60705507",
"0.60285944",
"0.6002351",
"0.600141",
"0.58997333",
"0.5882227",
"0.58777744",
"0.58719957",
"0.5832293",
"0.5832208",
"0.5827699"... | 0.5394218 | 89 |
Save model to disk under specified name | def save_model(name, model):
# Load path
project_dir = Path(__file__).resolve().parents[2]
model_path = os.path.join(project_dir, 'models', name + '.h5')
# Save model
model.save(model_path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_model(self, filename):\r\n pass",
"def save_model(self, model_path: str):",
"def model_save(model, name):\n extension = \".pickle\"\n\n save_model_name = os.path.join(MODEL_SAVE_DIR, name + extension)\n pk.dump(model, save_model_name)",
"def save_model(model, file_name):\n with open(f... | [
"0.82611257",
"0.8217925",
"0.8182584",
"0.8132696",
"0.80981237",
"0.799449",
"0.79939955",
"0.79629564",
"0.79477155",
"0.7947683",
"0.79133636",
"0.7908407",
"0.7908407",
"0.7806509",
"0.78042966",
"0.78005236",
"0.7797508",
"0.7795719",
"0.77806854",
"0.7769967",
"0.77401... | 0.81213886 | 4 |
Load model from disk at specified path | def load_model(name):
# Load path
project_dir = Path(__file__).resolve().parents[2]
model_path = os.path.join(project_dir, 'models', name + '.h5')
# Load model
model = tf.keras.models.load_model(model_path)
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_model(self, model_path: str):",
"def load_model(self, path):\n pass",
"def load(path_to_model):\n pass",
"def load(self, path):\n load_model(path, self)",
"def load_model(self, filename):\r\n pass",
"def load(\n self,\n modelLoadPath\n ):\n ... | [
"0.8960057",
"0.89284486",
"0.8905791",
"0.86008734",
"0.8230723",
"0.8202744",
"0.7990068",
"0.7990068",
"0.7990068",
"0.79732126",
"0.79470986",
"0.79335487",
"0.78644896",
"0.78357434",
"0.776193",
"0.77609074",
"0.7718646",
"0.7691855",
"0.76872164",
"0.7647909",
"0.76255... | 0.0 | -1 |
this method is invoked on the first turn. first player can puts only one stone on board. this method should return 2tuple, default is (10, 10) | def firstMove(self):
return (10, 10) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def firstMove(board):\r\n x = board.size / 2\r\n return (x, x)",
"def take_turn(self, board, other_player):\n\n # Always pick the middle box on the first round\n position = 4 if self.turn_count == 0 else None\n\n if self.turn_count == 1:\n # On the second turn, after the hum... | [
"0.75705034",
"0.65747726",
"0.65377414",
"0.6350882",
"0.6316932",
"0.6271466",
"0.61944956",
"0.61604035",
"0.61389923",
"0.6138155",
"0.61295015",
"0.61253476",
"0.6120447",
"0.6111359",
"0.61091137",
"0.610629",
"0.61005545",
"0.6098801",
"0.60883456",
"0.60808027",
"0.60... | 0.75002813 | 1 |
the structure of board is a 2d list (21x21) the surroundings of board is always filled with Edge. you can put (x, y) where the range of x and y is 1 to 19. x represents vertical axis y represents horizontal axis this method should return list which contains two 2tuple (e.g [(6, 17), (12, 15)]). | def move(self, board):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def board(self):\n board = []\n if self.flop:\n board.extend(self.flop)\n if self.turn:\n board.append(self.turn)\n if self.river:\n board.append(self.river)\n return tuple(board) if board else None",
"def make_board(row_... | [
"0.7138627",
"0.6863729",
"0.6824034",
"0.6652067",
"0.6637112",
"0.65947896",
"0.6561225",
"0.6458626",
"0.64301455",
"0.6420492",
"0.6367527",
"0.6358973",
"0.6356009",
"0.63284135",
"0.6282831",
"0.62593085",
"0.6249902",
"0.6245804",
"0.62330335",
"0.6230744",
"0.62263054... | 0.0 | -1 |
Initialize neural net and check output layer shape. | def test_init() -> None:
neural_net = NeuralNetwork()
assert neural_net.model.get_layer('output_layer').output_shape, (None, 4) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_init_net_simple(self):\n net = ecn.NeuralNet(2, (2,), 1)\n self.assertEqual(2, len(net.weights.keys()))\n self.assertEqual((2, 3), np.shape(net.weights['h0']))\n self.assertEqual((1, 3), np.shape(net.weights['y']))\n print('Finished testing simple neural net init\\n')",
... | [
"0.7603709",
"0.7023699",
"0.6976295",
"0.69317013",
"0.69186133",
"0.6909801",
"0.6901226",
"0.6877522",
"0.6854779",
"0.6819741",
"0.6771726",
"0.67149144",
"0.66965085",
"0.66904634",
"0.6672968",
"0.66600806",
"0.6655046",
"0.6619668",
"0.66193616",
"0.6618829",
"0.659733... | 0.8320543 | 0 |
Evalute should only output nonlethal move options, if they exist. | def test_evaluate(head_x: int, head_y: int, food: bool) -> None:
neural_net = NeuralNetwork()
snake = ParSnake(neural_net=neural_net,
grid_size_x=GRID_X, grid_size_y=GRID_Y, num_games=1)
food_x = head_x+1 if head_x == 0 else head_x-1
if food:
food_y = head_y
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def choose_move(self):\r\n \r\n return None",
"def make_random_move(self):\n choice = None\n options = []\n #generate full moves list\n for i in range(self.width):\n for j in range(self.height):\n #make sure move has not been made\n ... | [
"0.53914344",
"0.53807575",
"0.5276373",
"0.5265685",
"0.52453196",
"0.52405983",
"0.5215627",
"0.51845443",
"0.5165242",
"0.5162842",
"0.5154558",
"0.51299995",
"0.51283485",
"0.5083587",
"0.5081081",
"0.507274",
"0.503114",
"0.5014693",
"0.5007823",
"0.49944317",
"0.4944530... | 0.0 | -1 |
Calls remote pipeline via gRPC. | def __call__(self, *input_data):
pb_ann = Any()
pb_ann.Pack(annotation_to_protobuf.convert_annotation(input_data))
request = annotation_pb2.ProcessRequest(pipeline_name = self._pipeline_name,
input_annotations = pb_ann)
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self, pipeline: pipeline_pb2.Pipeline) -> Optional[Any]:\n pass",
"def pipeline(ctx):\n asyncio.run(pipeline_impl(ctx.obj[\"config\"]))",
"async def call_rpc(self, rpc_message: RpcMessage, options: dict, bus_client: \"BusClient\"):\n raise NotImplementedError()",
"def proc_exec_async(cmd... | [
"0.6544793",
"0.6321018",
"0.56702656",
"0.5618317",
"0.55825615",
"0.55604964",
"0.5502522",
"0.53786516",
"0.53683054",
"0.53434986",
"0.5316965",
"0.52956116",
"0.5292217",
"0.52873677",
"0.52846617",
"0.52833116",
"0.52823466",
"0.5257544",
"0.52436423",
"0.5242128",
"0.5... | 0.0 | -1 |
Funzione autogenerata al momento della creazione della classe a partire dal file .ui di QtDesigner Inizializza il contenuto testuale di tutti gli elementi inizializzati in setupUI | def retranslateUi(self, Dialog):
_translate = QtCore.QCoreApplication.translate
Dialog.setWindowTitle(_translate("Dialog", "Caricamento File Utilizzo"))
self.label_2.setText(_translate("Dialog", "CARICAMENTO FILE DI UTILIZZO"))
self.label_4.setText(_translate("Dialog",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepare_UI(self):",
"def init_ui(self):\n # Create GUI elements, set them in dict structure\n labelwidth = 150\n\n # Add parameter line edit for Factor Tm to Tp\n\n # Add line edit with browsebutton for swan result folder\n self.input_elements['hares folder'] = widgets.Exte... | [
"0.7513145",
"0.7482161",
"0.7362601",
"0.7208887",
"0.72026205",
"0.7198728",
"0.7198728",
"0.71846974",
"0.71774113",
"0.7128159",
"0.70827895",
"0.7071562",
"0.7046793",
"0.70268977",
"0.7019691",
"0.6999024",
"0.69660616",
"0.6924613",
"0.6892468",
"0.68913066",
"0.688663... | 0.0 | -1 |
update the list of d_bison_obs | def update_d_bison_obs(bison_i):
for i in range(obs_n):
d_bison_obs[i][bison_i] = calculate_d(bison_x[bison_i], bison_y[bison_i], obstacles[i][0], obstacles[i][1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, bsd):\n raise NotImplementedError()",
"def update_bison_obs(x_tan, y_tan, i, k):\n d_tan_bison = calculate_d(elude_bison[k][i][0], elude_bison[k][i][1], x_tan, y_tan)\n turn_v = math.sqrt(math.fabs(bison_v ** 2 - 10 * bison_v * (1 - math.cos(bison_angle[i]) ** 2) / math.cos(bison_an... | [
"0.6155102",
"0.5999859",
"0.59011286",
"0.5888638",
"0.58285916",
"0.5765711",
"0.5587305",
"0.5576261",
"0.5576261",
"0.5572444",
"0.55177706",
"0.54821646",
"0.54729325",
"0.54384035",
"0.54384035",
"0.54246837",
"0.54121697",
"0.54096115",
"0.53964806",
"0.53757375",
"0.5... | 0.69077736 | 0 |
if the distance between bison_i and obs_i less than 2.5, it should elude this obstacle | def elude_obstacles(bison_i, k):
# Ax+By+C=0
global predict_wolf
r = obstacles[k][2]
xk = obstacles[k][0]
yk = obstacles[k][1]
a = (bison_y[bison_i] - wolf_y[0]) / (bison_x[bison_i] - wolf_x[0])
b = -1
c = bison_y[bison_i] - (a * bison_x[bison_i])
d_obs_dir = math.fabs(a * xk + b * y... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_terminal(self,bump,DLightBump, AnalogBump, IR):\r\n terminal = False\r\n # signal returned from distance to obstacle /terminal 50 mm,5cm\r\n # by measurement, small obstacle (height = height of light bumper) in 2cm: signal 120 ~300\r\n # within 1cm >400\r\n # if big ob... | [
"0.62927634",
"0.6241226",
"0.620058",
"0.6018024",
"0.59719473",
"0.59486395",
"0.5917246",
"0.59119254",
"0.5910905",
"0.58528554",
"0.5772193",
"0.5666695",
"0.56637704",
"0.5658386",
"0.56462765",
"0.5594453",
"0.55852175",
"0.5563984",
"0.5561192",
"0.55316013",
"0.55280... | 0.7006195 | 0 |
when sheep i encounters an obstacle, the wolf will make prediction | def update_wolf_predict(x_tan, y_tan, i, k):
d_temp = math.sqrt((2 * x_tan - elude_bison[k][i][0] - predict_wolf[0][0]) ** 2 + (2 * y_tan - elude_bison[k][i][1]
- predict_wolf[0][1]) ** 2)
turn_v = math.sqrt(math.fabs(wolf_v ** ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def elude_obstacles(bison_i, k):\n # Ax+By+C=0\n global predict_wolf\n r = obstacles[k][2]\n xk = obstacles[k][0]\n yk = obstacles[k][1]\n a = (bison_y[bison_i] - wolf_y[0]) / (bison_x[bison_i] - wolf_x[0])\n b = -1\n c = bison_y[bison_i] - (a * bison_x[bison_i])\n d_obs_dir = math.fabs(... | [
"0.65113294",
"0.58036506",
"0.57595885",
"0.5693709",
"0.56864536",
"0.56776464",
"0.56260264",
"0.56131107",
"0.5607759",
"0.5607257",
"0.5589702",
"0.55828494",
"0.5573906",
"0.5571394",
"0.5564398",
"0.55640703",
"0.5563069",
"0.55479985",
"0.5524681",
"0.55181146",
"0.55... | 0.0 | -1 |
update position of sheep who is eluding an obstacle | def update_bison_obs(x_tan, y_tan, i, k):
d_tan_bison = calculate_d(elude_bison[k][i][0], elude_bison[k][i][1], x_tan, y_tan)
turn_v = math.sqrt(math.fabs(bison_v ** 2 - 10 * bison_v * (1 - math.cos(bison_angle[i]) ** 2) / math.cos(bison_angle[i])))
bison_x[i] = bison_x[i] + ((x_tan - elude_bison[k][i][0]) ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _update_environment(self):\n\n # compute a distance matrix\n distance_matrix = np.zeros((self.num_sheep,self.num_sheep))\n for i in range(self.num_sheep):\n for j in range(i):\n dist = np.linalg.norm(self.sheep_poses[i,:] - self.sheep_poses[j,:])\n ... | [
"0.6596403",
"0.6276996",
"0.6205589",
"0.619456",
"0.6150602",
"0.61237663",
"0.6109519",
"0.61021274",
"0.609728",
"0.6090564",
"0.60674024",
"0.6062633",
"0.6029504",
"0.5872343",
"0.58682066",
"0.58682066",
"0.5838082",
"0.5822439",
"0.5815109",
"0.5778401",
"0.57713646",... | 0.0 | -1 |
find the index of minimum distance in list of d | def find_min_distance():
return np.argmin(d) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __idx_of_minimum(cls, lst: list) -> int:\n\t\treturn lst.index(min(lst))",
"def _minimum_distance(self,arg):\n return min([abs(arg-e) for e in self if not e is arg])",
"def min_distance(distance, spt_set, self_nodes):\n minimum = sys.maxsize\n minimum_node = None\n f... | [
"0.7192563",
"0.71359694",
"0.70440257",
"0.7035856",
"0.70053023",
"0.69904137",
"0.6925225",
"0.6874505",
"0.6810732",
"0.67803216",
"0.6676719",
"0.66622704",
"0.66444784",
"0.6632789",
"0.6621095",
"0.66131043",
"0.6592418",
"0.6562787",
"0.6508623",
"0.649189",
"0.647867... | 0.8462347 | 0 |
Returns the streamfunction generated by a source/sink. | def get_stream_function(strength, x_source, y_source, X, Y):
if isinstance(x_source, list):
psi = [0.0] * len(x_source)
for i in range(0, len(x_source)):
psi[i] = strength[i] / (2 * numpy.pi) * numpy.arctan2((Y - y_source[i]), (X - x_source[i]))
psi = sum(psi)
else:
p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_function(self):\n return SSAFunction(self.get_graph())",
"def get_stream_function_sink(strength, xs, ys, X, Y):\r\n psi = strength / (2 * math.pi) * numpy.arctan2((Y - ys), (X - xs))\r\n \r\n return psi",
"def get_function(self):\n return subs(self.f.get_function(), self.sub_pre,... | [
"0.6196658",
"0.613481",
"0.6017871",
"0.5849812",
"0.58272237",
"0.5810706",
"0.5786503",
"0.5692548",
"0.56741154",
"0.55982894",
"0.5564781",
"0.5542864",
"0.5524242",
"0.5510607",
"0.546856",
"0.5460594",
"0.54391384",
"0.54083943",
"0.53916246",
"0.53803605",
"0.52523947... | 0.56563514 | 9 |
Returns the velocity field generated by a doublet. | def get_velocity_doublet(strength, xd, yd, X, Y):
if isinstance(xd, list):
u = [0.0] * len(xd)
v = [0.0] * len(yd)
for i in range(0, len(xd)):
u[i] = - strength[i] / (2 * math.pi) * ((X - xd[i]) ** 2 - (Y - yd[i]) ** 2) / ((X - xd[i]) ** 2 + (
Y - yd[i]) ** 2) ** ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getVelocity(self):\n return self.v",
"def velocity(self):\n return self._velocity",
"def velocity(self):\n return self._velocity",
"def getVelocity(self):\n\n return self.vel",
"def get_velocity(self):\n return self.momentum/self.mass",
"def velocity_model(self):\n ... | [
"0.7200456",
"0.6920105",
"0.6920105",
"0.6735759",
"0.66176605",
"0.66080326",
"0.6602164",
"0.6586435",
"0.6560289",
"0.64285827",
"0.6413392",
"0.62519425",
"0.62133986",
"0.6163308",
"0.6040189",
"0.60041803",
"0.59976274",
"0.5996631",
"0.59051406",
"0.58974963",
"0.5889... | 0.58727473 | 22 |
Returns the streamfunction generated by a doublet. | def get_stream_function_doublet(strength, xd, yd, X, Y):
psi = - strength / (2 * math.pi) * (Y - yd) / ((X - xd) ** 2 + (Y - yd) ** 2)
return psi | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_function(self):\n return subs(self.f.get_function(), self.sub_pre, self.sub_post)",
"def getFunction(self) -> ghidra.program.model.listing.Function:\n ...",
"def get_function(self):\n return SSAFunction(self.get_graph())",
"def function(self) -> pulumi.Input[str]:\n return... | [
"0.5901997",
"0.5898072",
"0.58108723",
"0.5600798",
"0.5600798",
"0.5600798",
"0.55771285",
"0.5531702",
"0.5443946",
"0.5401715",
"0.54015255",
"0.54015255",
"0.53834504",
"0.53663784",
"0.5349206",
"0.5320001",
"0.530694",
"0.5275393",
"0.5273589",
"0.52705175",
"0.5259918... | 0.5877548 | 2 |
Finds the max gap_score of the flanking reads. We use this value as the threshold for smith waterman filtering. | def compute_sw_threshold(flanking_reads, paf_dict, fasta_dict, window_size):
max_scores = []
for query, target in itertools.product(flanking_reads, flanking_reads):
if str(query + target) in paf_dict:
overlap_info = paf_dict[query+target]
elif str(target + query) in paf_dict:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max_gap(self):\n return self._max_gap",
"def max_score(self):\n return self.raw_possible",
"def max_score(self):\r\n max_score = None\r\n if self.check_if_done_and_scored():\r\n max_score = self._max_score\r\n return max_score",
"def max_score(self):\n ... | [
"0.65937996",
"0.6442271",
"0.6323267",
"0.6321066",
"0.62130624",
"0.6183801",
"0.6155798",
"0.6139358",
"0.61088455",
"0.60916436",
"0.60519683",
"0.6035053",
"0.6027988",
"0.5917933",
"0.59149694",
"0.5904565",
"0.5880489",
"0.5870277",
"0.586847",
"0.58620393",
"0.5844067... | 0.6311884 | 4 |
runs a community detection algorithm on graph and returns a coloring of the nodes based on the found communities | def node_community_colors(graph, communities):
colors = nx_helpers.generate_colors(len(communities))
def which_color(node):
"""finds which community node is in and returns
its corresponding color
"""
for i, com in enumerate(communities):
if node in com:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def community_detection(net_G):\r\n if list(nx.isolates(net_G)) == []:\r\n part = community.best_partition(net_G)\r\n #values = [part.get(node) for node in net_G.nodes()]\r\n #nx.draw_spring(net_G, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=False)\r\n ... | [
"0.7544369",
"0.67278713",
"0.67230785",
"0.6600129",
"0.6450803",
"0.62319934",
"0.62119263",
"0.6207066",
"0.62020797",
"0.61163753",
"0.61084396",
"0.6086533",
"0.5949669",
"0.591313",
"0.59082705",
"0.5903655",
"0.58992743",
"0.58878565",
"0.5877019",
"0.58694255",
"0.586... | 0.7250731 | 1 |
finds which community node is in and returns its corresponding color | def which_color(node):
for i, com in enumerate(communities):
if node in com:
return colors[i]
return nx_helpers.rgb_to_hex((0, 0, 0)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def node_community_colors(graph, communities):\n colors = nx_helpers.generate_colors(len(communities))\n\n def which_color(node):\n \"\"\"finds which community node is in and returns\n its corresponding color\n \"\"\"\n for i, com in enumerate(communities):\n if node in... | [
"0.75510806",
"0.69493985",
"0.66909236",
"0.66592944",
"0.6608618",
"0.64989406",
"0.6450056",
"0.64425915",
"0.64138216",
"0.6396164",
"0.6335987",
"0.6323094",
"0.62105125",
"0.6205423",
"0.61846185",
"0.617105",
"0.6087763",
"0.59781784",
"0.5975609",
"0.59191763",
"0.590... | 0.83000135 | 0 |
returns a list of colors for coloring nodes based on which set each node is in | def node_set_colors(nodes, spanset, gapset, preset, postset):
node_colors = []
for n in nodes:
if n in preset:
node_colors.append(nx_helpers.rgb_to_hex((255, 0, 0)))
elif n in postset:
node_colors.append(nx_helpers.rgb_to_hex((255, 255, 0)))
## reads now may be m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_groups(nodes):\n return list(set([node.color for node in nodes]))",
"def get_colors(self):\n colors = [\"#244486\", \"#A6A6A6\", \"#B12122\"]\n cmap = LinearSegmentedColormap.from_list(\"mycmap\", colors)\n\n color_palette=[cmap(i) for i in np.linspace(0, 1, len(set(self.nodes_lis... | [
"0.78957987",
"0.7514314",
"0.712716",
"0.69475394",
"0.6675967",
"0.66652167",
"0.66599905",
"0.66454685",
"0.64734924",
"0.6415016",
"0.64149046",
"0.6397059",
"0.63902277",
"0.63846207",
"0.63146603",
"0.6292402",
"0.627562",
"0.627562",
"0.62653184",
"0.62567157",
"0.6220... | 0.7795284 | 1 |
generates and returns overlap graph from .paf files | def generate_graph(params):
alignedreads = read_paf(params, should_filter_paf=True)
aligned = [(t, h) for t, h, _ in alignedreads]
graph = nx.Graph()
graph.add_edges_from(aligned)
return graph | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def overlap_graph(input, overlap):\n\n sequence_dict = {}\n seq_id_list = []\n\n for seq_record in SeqIO.parse(input, \"fasta\"): # change input variable.\n sequence_dict[seq_record.id] = seq_record.seq\n seq_id_list.append(seq_record.id)\n\n adjacency_list= []\n\n index = overlap\n\n ... | [
"0.6383634",
"0.61519605",
"0.60640895",
"0.5620521",
"0.54954714",
"0.5461694",
"0.5433732",
"0.54307693",
"0.5381156",
"0.53631675",
"0.5311818",
"0.5308905",
"0.52986294",
"0.52673423",
"0.5267266",
"0.52432793",
"0.52378273",
"0.52373457",
"0.5227681",
"0.5227558",
"0.522... | 0.64970756 | 0 |
removes nodes from graph in they are in communities smaller than n | def drop_small_communities(graph, communities, n=4):
for community in communities:
if len(community) < n:
nx_helpers.remove_nodes(graph, community)
communities = [c for c in communities if len(c) >= n]
return graph, communities | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keep_important_nodes(graph, number_of_nodes):\n sorted_dict = np.array(\n [\n [k, v]\n for k, v in sorted(\n dict(graph.degree()).items(),\n key=lambda item: item[1],\n )\n ]\n )\n use_nodes = sorted_dict[-number_of_nodes:, 0... | [
"0.69280136",
"0.68292296",
"0.67802733",
"0.66563076",
"0.6461734",
"0.64381963",
"0.64123416",
"0.63864523",
"0.6341436",
"0.62839335",
"0.6267461",
"0.6262071",
"0.6231139",
"0.61691225",
"0.6163174",
"0.6140132",
"0.61174977",
"0.61075747",
"0.61025345",
"0.60737944",
"0.... | 0.8111857 | 0 |
Determines the quality of the mapping (assignment of edges) based on the "ground truth" of spanset and gapset. Sums up number of edges between spanset and gapset. Assumes undirected graph see comments | def mapping_quality(graph, spanset, gapset):
the_sum = sum(sum(1 for edge in graph.edges(node) if edge[1] in gapset) for node in spanset)
# if directed graph, uncomment this:
#the_sum += sum(sum(1 for edge in graph.edges(node) if edge[1] in spanset) for node in gapset)
return the_sum | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def countEdges(self):\n n = 0\n for (hub, table) in self.totsupport.iteritems():\n n += len(table)\n return n",
"def community_quality(communities, spanset, gapset):\n if len(communities) != 2:\n return -1\n\n com_sets = [set(c) for c in communities]\n spanset = se... | [
"0.55912036",
"0.553591",
"0.5377618",
"0.53747284",
"0.53365",
"0.5324719",
"0.5322185",
"0.5320498",
"0.5284785",
"0.52796876",
"0.5255801",
"0.5249715",
"0.5231621",
"0.5206148",
"0.51990473",
"0.519828",
"0.51928836",
"0.51651835",
"0.51341033",
"0.5120622",
"0.511521",
... | 0.8308598 | 0 |
Determines the quality of the communities based on the "ground truth" of spanset and gapset. First, determines which community corresponds to gapset and spanset. Then, returns number of wrong nodes. | def community_quality(communities, spanset, gapset):
if len(communities) != 2:
return -1
com_sets = [set(c) for c in communities]
spanset = set(spanset)
gapset = set(gapset)
spanset_0 = len(com_sets[0].difference(spanset))
spanset_1 = len(com_sets[1].difference(spanset))
gapset_0 =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mapping_quality(graph, spanset, gapset):\n the_sum = sum(sum(1 for edge in graph.edges(node) if edge[1] in gapset) for node in spanset)\n # if directed graph, uncomment this:\n #the_sum += sum(sum(1 for edge in graph.edges(node) if edge[1] in spanset) for node in gapset)\n return the_sum",
"def c... | [
"0.63994",
"0.58635193",
"0.5778622",
"0.5743064",
"0.55880827",
"0.555476",
"0.53169554",
"0.52722627",
"0.52660155",
"0.52518225",
"0.52481997",
"0.52412534",
"0.5223429",
"0.5208664",
"0.5191661",
"0.5173846",
"0.51651204",
"0.51604426",
"0.51279247",
"0.51213825",
"0.5113... | 0.75630814 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.