Probability:\n ...","def calc_priors(self, prior_U, method='inverse'):\n if self.Pchance is None:\n raise IOError(\"Set Pchance before calling this method\")\n\n # TODO -- Move this into Bayesian\n if prior_U < 0.:\n self.prior_U = np.product(self.candidates['P_c'])\n else:\n self.prior_U = prior_U\n\n # Raw priors\n self.raw_prior_Oi = bayesian.raw_prior_Oi(method, self.candidates[self.filter].values,\n Pchance=self.Pchance,\n half_light=self.candidates.half_light.values)\n\n # Normalize\n self.prior_Oi = bayesian.renorm_priors(self.raw_prior_Oi, self.prior_U)\n\n # Add to table\n self.candidates['P_O'] = self.prior_Oi","def determineClasses(self, particles):\n\t\tapDisplay.printMsg(\"sorting refineparticledata into classes\")\n\t\tt0 = time.time()\n\t\tclasses={}\n\t\tclass_stats={}\n\t\tquality=numpy.zeros(len(particles))\n\t\tfor partnum in range(len(particles)):\n\t\t\tquality[partnum] = particles[partnum]['quality_factor']\n\t\t\tkey = (\"%.3f_%.3f\"%(particles[partnum]['euler1'], particles[partnum]['euler2']))\n\t\t\tif key not in classes.keys():\n\t\t\t\tclasses[key]={}\n\t\t\t\tclasses[key]['particles']=[]\n\t\t\t\tclasses[key]['euler1'] = particles[partnum]['euler1']\n\t\t\t\tclasses[key]['euler2'] = particles[partnum]['euler2']\n\t\t\t\t#classes have no inplane rotation\n\t\t\t\tclasses[key]['euler3'] = 0.0 #particles[partnum]['euler3']\n\t\t\tclasses[key]['particles'].append(particles[partnum])\n\t\tclass_stats['meanquality']=quality.mean()\n\t\tclass_stats['stdquality']=quality.std()\n\t\tclass_stats['max']=quality.max()\n\t\tclass_stats['min']=quality.min()\n\t\tapDisplay.printMsg(\"sorted %d particles into %d classes\"%(len(particles), len(classes)))\n\t\t### print stats\n\t\tprint \"-- quality factor stats --\"\n\t\tprint (\"mean/std :: \"+str(round(class_stats['meanquality'],2))+\" +/- \"\n\t\t\t+str(round(class_stats['stdquality'],2)))\n\t\tprint (\"min/max :: \"+str(round(class_stats['min'],2))+\" <> \"\n\t\t\t+str(round(class_stats['max'],2)))\n\t\tapDisplay.printMsg(\"finished sorting in \"+apDisplay.timeString(time.time()-t0))\n\t\treturn classes, class_stats","def carbon_prime(C,p,p0):\r\n \r\n if p > p0:\r\n return C\r\n else:\r\n return .03","def perplexity(self):\n raise NotImplementedError(\"To be implemented\")","def percent_to_class(prc, fair):\n assert len(prc) == 1, \"Should be only one column.\"\n prc = prc[0]\n\n # Threshold between fair and unfair.\n tsh_fair = 0.1\n # Threshold between unfair and very unfair.\n tsh_unfair = 0.4\n\n dif = (fair - prc) / fair\n if dif < -1 * tsh_unfair:\n # We are much higher than fair.\n cls = 4\n elif -1 * tsh_unfair <= dif < -1 * tsh_fair:\n # We are not that much higher than fair.\n cls = 3\n elif -1 * tsh_fair <= dif <= tsh_fair:\n # We are fair.\n cls = 2\n elif tsh_fair < dif <= tsh_unfair:\n # We are not that much lower than fair.\n cls = 1\n elif tsh_unfair < dif:\n # We are much lower than fair.\n cls = 0\n else:\n assert False, \"This should never happen.\"\n return cls","def detect_class_onpic(boxes, allowed_classes):\n object_class = \"all\"\n highest_prob = 0\n for box in boxes:\n box_prob = float(box[1].strip('%')) / 100.0\n if box[0] in allowed_classes and box_prob > highest_prob:\n highest_prob = box_prob\n object_class = box[0]\n return object_class, highest_prob","def decision(self, neighbors=None):\n if not neighbors:\n return sorted(self.class_prb.items(), key=lambda n: n[1],\n reverse=True)\n\n else:\n n = len(neighbors)\n prb = {}\n for label in self.labels:\n prb[label] = 0.0\n for kdnode, dist in neighbors:\n index = self.train_data.index(kdnode.data)\n prb[self.train_label[index]] += 1\n for label in self.labels:\n prb[label] = prb[label] / n\n return sorted(prb.items(), key=lambda n: n[1], reverse=True)","def proportion_of_primes(bound, **args):\n v = []\n k = 0.0\n for n in range(1, bound + 1):\n if is_prime(n):\n k += 1\n v.append((n, k / n))\n return plot_step_function(v, **args)","def prob(self, tple, class_counts, feature_counts):\n feats = self.dataset.input_features\n unnorm = [prod(feature_counts[i][feat(tple)][c]\n for (i,feat) in enumerate(feats))\n /(class_counts[c]**(len(feats)-1))\n for c in range(self.num_classes)]\n thesum = sum(unnorm)\n return [un/thesum for un in unnorm]","def ComparePriors():\n dataset = [60]\n high = 1000\n\n thinkplot.Clf()\n thinkplot.PrePlot(num=2)\n\n constructors = [Train, Train2, Train3]\n labels = ['uniform', 'power law', 'many companies']\n\n for constructor, label in zip(constructors, labels):\n suite = MakePosterior(high, dataset, constructor)\n suite.name = label\n thinkplot.Pmf(suite)\n\n thinkplot.Save(root='train4',\n xlabel='Number of trains',\n ylabel='Probability')","def sort_priors(self):\n return","def _get_model_priors(self):\n if self._alpha_model_priors:\n return self._alpha_model_priors\n # sample the variables from their corresponding distributions\n params = self._get_prior_params()\n self._alpha_model_priors = self._params2probs(params)\n return self._alpha_model_priors","def propose(self):\n\n p = type(self)(self.n, alpha=self.alpha)\n\n return p, p.compute_prior() - self.compute_prior()","def gini(rows):\n counts = class_counts(rows)\n print(counts)\n impurity = 1\n for lbl in counts:\n prob_of_lbl = counts[lbl] / float(len(rows))\n impurity -= prob_of_lbl**2\n return impurity","def GetNFactors(n, primes, n_pfactors, _):\n sqrtn = int(n ** 0.5) + 1\n\n for p in primes:\n if p > sqrtn:\n break\n if n % p == 0:\n n //= p\n if n % p == 0:\n return n_pfactors[n]\n else:\n return n_pfactors[n] + 1\n\n # n is primes\n primes.append(n)\n return 1","def pointPerClass(classMap):\n rand1 = 100 * pcr.uniform(pcr.boolean(classMap)) \n rand2 = 100 * pcr.uniform(pcr.boolean(classMap))\n rand3 = 100 * pcr.uniform(pcr.boolean(classMap))\n \n randomMap = pcr.scalar(classMap) * rand1 * rand2 * rand3\n pointMap = pcr.ifthen(randomMap == pcr.areaminimum(randomMap, classMap), classMap)\n nrPointsPerClass = pcr.areatotal(pcr.scalar(pcr.boolean(pointMap)), classMap)\n assert pcr.cellvalue(pcr.mapmaximum(nrPointsPerClass), 0)[0] == 1\n return pointMap","def filtro_probs(prediccion,p_min):\n clases = []\n for probabilidad in prediccion:\n if probabilidad[1]>=p_min:\n clases.append(probabilidad)\n else:\n clases.append(\"-\")\n return clases","def purity(clusters, classes):\n\n d = defaultdict(list)\n\n # Get a list of class numbers of all examples in a cluster.\n for k, v in zip(clusters, classes):\n d[k].append(v)\n\n mayority = 0\n\n # Count the mayority class number and add it up over all clusters.\n for k in d:\n mayority += Counter(d[k]).most_common(1)[0][1]\n\n return float(mayority) / len(clusters)","def computeNumClass(self):\n # Get the number of data\n n = len(self.data)\n # For IQR\n # First, compute the position of the first and third quartile\n fQPos = ( (n - 1) / 4 ) + 1\n tQPos = ( (3 * (n - 1)) / 4 ) + 1\n # Get the quartiles\n firstQ = 0.0\n thirdQ = 0.0\n if fQPos == round(fQPos):\n firstQ = self.data[int(fQPos)]\n else:\n up = round(fQPos)\n firstQ = self.data[up - 1] + ((self.data[up] - self.data[up - 1]) / 4.0)\n if tQPos == round(tQPos):\n thirdQ = self.data[int(tQPos)]\n else:\n up = round(tQPos)\n thirdQ = self.data[up - 1] + (3 * (self.data[up] - self.data[up - 1]) / 4.0)\n # Compute the IQR\n IQR = thirdQ - firstQ\n # Compute the number of classes and its length\n self.numBins = int(2 * IQR * m.pow(n, -1/3))\n self.computeBinWidth()","def class_distribution(y): \n # ===================== PLEASE WRITE HERE =====================\n \n bin_array = np.bincount(y)\n n_class1 = bin_array[1]\n n_class2 = bin_array[2]\n n_class3 = bin_array[3]\n \n # ===================== PLEASE WRITE HERE =====================\n \n print('Number of samples in class_1:', n_class1)\n print('Number of samples in class_2:', n_class2)\n print('Number of samples in class_3:', n_class3)","def count_prime():\n nums = []\n for i in range(2, 10000):\n if is_prime(i):\n nums.append(i)\n return nums","def prim_method(self):","def prim_method(self):","def get_probable_prime(n: int) -> [int]:\n return [6*n-1, 6*n+1]","def get_pc_per_range(model, class_name):\n class_total = model.class_counts[class_name]\n if model.num_runs is not None:\n class_total = model.num_runs * class_total * .33\n\n true_positives, totals = model.range_metrics_10[class_name]\n purities = [] # Accuracy per range (true positive/total)\n comps = []\n TP_count = 0\n total_count = 0\n\n for index in reversed(range(len(true_positives))):\n cur_p = 0 # Current purity\n cur_c = 0 # Current completeness\n TP_count += true_positives[index]\n total_count += totals[index]\n if total_count != 0:\n # positive class samples / totals # with prob in range\n cur_p = TP_count / total_count\n if class_total != 0:\n cur_c = TP_count / class_total\n\n purities.append(cur_p)\n comps.append(cur_c)\n purities.reverse()\n comps.reverse()\n return purities, comps","def _m(self):\n return self._k // self._n_classes","def _computeCondProb(self, testData, classValue):\n classAttrObj = self._classAttrs[classValue]\n frequencyDict = classAttrObj.frequencyDict\n totalDocsInClass = classAttrObj.totalDocsInClass\n\n result = (totalDocsInClass/self._totalTrainDocs) # P(c)\n # Compute P(t|c) for each t in d\n for word in testData:\n result *= ((frequencyDict.get(word, 0) + 1) / (sum(frequencyDict.values()) + self._sizeOfVocabulary))\n return result","def get_primes_in(self, grange):\n for n in grange:\n if self.is_prime(n):\n yield n","def _get_guide_priors(self):\n if not self._alpha_guide_prior_params:\n # create initial parameters\n params = self._get_prior_params()\n # register all parameters in pyro\n for p, v in iteritems(params):\n pyro.param(p, v)\n self._alpha_guide_prior_params = dict(\n self._param_store.named_parameters()\n )\n else:\n # register all parameters in pyro\n for p, v in iteritems(self._alpha_guide_prior_params):\n pyro.param(p, v)\n return self._params2probs(self._alpha_guide_prior_params)","def prior_of_priors(self, tt):\n for i in xrange(self.n_params): \n try: \n p_theta *= self.param_obj.prior()[i].pdf(tt[i]) \n\n except UnboundLocalError: \n p_theta = self.param_obj.prior()[i].pdf(tt[i]) \n\n return p_theta","def componeProbs(p,p_prime):\n return p + p_prime * (1-p)","def __convert_prob_into_class(self, probs):\n probs = T.set_subtensor(probs[probs > 0.5], 1)\n return T.set_subtensor(probs[probs <= 0.5], 0)","def percent_to_class(prc, fair):\n assert len(prc) == 1, \"Should be only one column.\"\n prc = prc[0]\n\n # Threshold between fair and unfair.\n tsh_fair = 0.1\n\n dif = (fair - prc) / fair\n if dif < -1 * tsh_fair:\n # We are much higher than fair.\n cls = 2\n elif -1 * tsh_fair <= dif <= tsh_fair:\n # We are fair.\n cls = 1\n elif tsh_fair < dif:\n # We are much lower than fair.\n cls = 0\n else:\n assert False, \"This should never happen.\"\n return cls","def class_size(self):\n if not self.is_mutation_finite():\n return infinity\n else:\n components = []\n multiplicities = []\n for x in self.irreducible_components():\n if components.count(x) == 0:\n components.append(x)\n multiplicities.append(1)\n else:\n y = components.index(x)\n multiplicities[y] = multiplicities[y]+1\n\n sizes = [ x.class_size() for x in components ]\n if NotImplemented in sizes:\n print(\"Size unknown\")\n return NotImplemented\n else:\n return prod( [binomial(sizes[i]+multiplicities[i]-1,\n multiplicities[i] ) for i in range (0,len(sizes))])","def getpriPridict(cls, instcls, stage):\n if not any(pridict):\n cls.initpridict()\n try:\n pri = pridict[instcls][stage]\n except AttributeError as err:\n print(\"Err\", err)\n return 0\n return pri","def reprime(self):\n self.__primed = 1","def primish(n):\n\n factors = set()\n for i in range(n, 1, -1):\n\n # Find the smallest divisor of i.\n smallest = 2\n while (i % smallest) != 0:\n smallest += 1\n\n # Divide by that divisor until we have 1 or something else.\n remainder = i\n while (remainder % smallest) == 0:\n remainder /= smallest\n\n # Keep it if needed.\n if remainder == 1:\n factors.add(i)\n\n return factors","def get_probs(self, a):\n with torch.no_grad():\n probabilities = (np.array(self.priorities) ** a) / sum(np.array(self.priorities) ** a)\n return probabilities","def get_priors(heuristic_lengthscales, use_priors=True, is_composite=False):\n # Determine if we use priors\n lengthscale_prior = None\n outputscale_prior = None\n if use_priors:\n lengthscale_prior = GammaPrior(0.01 * heuristic_lengthscales,\n 0.01 * torch.ones(heuristic_lengthscales.size()))\n print(\"LENGTHSCALE MEAN: \\n{}\".format(lengthscale_prior.mean))\n print(\"LENGTHSCALE VARIANCE: \\n{}\".format(lengthscale_prior.variance))\n\n if is_composite:\n return lengthscale_prior, lengthscale_prior, outputscale_prior\n\n else:\n return lengthscale_prior, outputscale_prior","def __init__(self,x,dof):\n self.x=x\n self.dof=dof\n numSeg=10\n p1=self.P(numSeg)\n p2=0\n while True:\n numSeg*=2\n p2=self.P(numSeg)\n if self.checarPs(p1,p2):\n break\n else:\n p1=p2\n print(round(p2,5))","def obtain_parametric_priors(resolution, num_actions):\n # maximum prior magnitude for any discritized state\n max_prior = 10\n \n priors = []\n \n for p in range(resolution):\n for v in range(resolution):\n for a in range(num_actions):\n priors.append(set_parametric_prior(resolution, p, v, a, max_prior))\n \n priors = np.array(priors).reshape(resolution,resolution,num_actions)\n #print(\"priors\", priors[5,5,0])\n return priors","def optimal_instances_per_class(df, factor=1.0, draw=False):\n # `bincount` returns the number of instances we have for each website\n counts = np.bincount(df.class_label.tolist())\n hist, bin_edges = np.histogram(counts)\n if draw:\n inst_counts = get_num_instances(df)\n inst_counts.hist(cumulative=-1, bins=100)\n plt.xlabel('Num of instances')\n plt.ylabel('Num of classes with x or more insts')\n plt.show()\n\n # scale the y-axis\n dx = bin_edges[1] - bin_edges[0]\n cum_hist = np.cumsum(hist) * dx\n\n # get the inverse cumulative sum\n inv_cum_hist = max(cum_hist) - cum_hist\n\n # compute the harmonic mean of tuples (y=f(x), x)\n hms = [harmonic_mean(x, y, factor) if y > 0 and x > 0 else 0\n for x, y in zip(bin_edges[1:], inv_cum_hist)]\n\n print(hms)\n\n # find index for max harmonic mean\n i = np.argmax(hms)\n\n # this is the optimal number of instances:\n opt_num_insts = int(bin_edges[i])\n\n # which leaves us with this number of classes:\n opt_num_classes = len(counts[counts >= opt_num_insts])\n\n if draw:\n print(\"Optimal number of instances:\", opt_num_insts)\n print(\"Optimal number of classes:\", opt_num_classes)\n\n return opt_num_insts, opt_num_classes","def fairness_discrepancy(props, n_classes, norm=0):\n # unique, freq = np.unique(data, return_counts=True)\n # props = freq / len(data) #Proportion of data that belongs to that data\n \n # #------------------Modification to correct the zero support problem------------------------------------------------\n # temp=np.zeros(n_classes)\n # temp[unique]=props\n # props=temp\n # #------------------------------------------------------------------------------\n \n # print (freq)\n truth = 1./n_classes\n\n\n # L2 and L1=================================================================================================\n #(Remove Normalisation)\n l2_fair_d = np.sqrt(((props - truth)**2).sum())\n l1_fair_d = abs(props - truth).sum()\n\n # q = props, p = truth\n # kl_fair_d = (props * (np.log(props) - np.log(truth))).sum()\n\n #Cross entropy\n p=np.ones(n_classes) \n # ce=cross_entropy(p,props,n_classes)-cross_entropy(p,p,n_classes)\n \n #information specificity=====================================================================================\n rank=np.linspace(1,n_classes-1,n_classes-1)\n rank[::-1].sort() #Descending order\n perc=np.array([i/np.sum(rank) for i in rank])\n \n \n props[::-1].sort()\n alpha=props[1:]\n specificity=abs(props[0]-np.sum(alpha*perc))\n info_spec=(l1_fair_d+specificity)/2\n \n #Wasstertein Distance\n wd=wasserstein_distance(props,np.ones(len(props))*truth)\n \n #Wassertein Specificity\n wds=(wd+specificity)/2\n if norm==0:\n return l2_fair_d, l1_fair_d,info_spec,specificity,wd,wds\n # return l2_fair_d, l1_fair_d,info_spec,specificity\n else:\n return l2_fair_d/metric_max(n_classes,\"L2\"), l1_fair_d/metric_max(n_classes,\"L1\"),info_spec/metric_max(n_classes,\"Is\"),specificity,wd/metric_max(n_classes,\"Wd\")\n # return l2_fair_d/metric_max(n_classes,\"l2\"), l1_fair_d/metric_max(n_classes,\"l1\"),info_spec/metric_max(n_classes,\"is\"),specificity","def factorize(n:int,primesDict:dict = primesDict):\r\n\r\n \r\n if isPrime(n,primesDict):\r\n return {n:1}\r\n\r\n factors = {}\r\n\r\n lastPrime = getLastPrime(primesDict)\r\n print (lastPrime,\"Lastprimes\")\r\n if lastPrime < n:\r\n print (\"Creating DictS\")\r\n\r\n prma(n,lastPrime,primesDict)\r\n\r\n for i in primesDict:\r\n if n%i == 0 :\r\n count = 0\r\n while n % i**(count+1) == 0 :\r\n count+=1 \r\n factors[i]= count\r\n\r\n return factors","def get_probs(self):\n\t\tprobArray = []\n\t\tfor combination in self.codepool:\n\t\t\tif self.feasible(combination):\n\t\t\t\tprobArray.append(self.get_probability(combination))\n\t\t\telse:\n\t\t\t\tprobArray.append(0)\n\t\tprobArray = np.array(probArray) / np.sum(probArray)\n\t\treturn probArray","def set_priors(parnames, limits, linenames, vsyst, nssps=1):\n priors = {}\n for parname in parnames:\n name = parname.split(\"_\")[0]\n if name in limits: #all the CvD ssp parameters\n vmin, vmax = limits[name]\n# print(parname,vmin,vmax)\n delta = vmax - vmin\n priors[parname] = stats.uniform(loc=vmin, scale=delta)\n elif parname in vsyst:\n priors[parname] = stats.norm(loc=vsyst[parname], scale=500)\n elif parname == \"eta\": #what does eta do?\n priors[\"eta\"] = stats.uniform(loc=1., scale=19)#uniform distribution in range [1,19]\n elif parname == \"nu\": #what does nu do?\n priors[\"nu\"] = stats.uniform(loc=2, scale=20)#uniform distribution in range [2,20]\n elif parname == \"sigma\":\n priors[\"sigma\"] = stats.uniform(loc=50, scale=300)#obtains the uniform distribution on [loc, loc + scale]. i.e. uniform in range [50,300]\n elif parname == \"sigma_gas\":\n priors[parname] = stats.uniform(loc=50, scale=100)#uniform between [50,100]km/s\n elif name == \"w\":\n priors[parname] = stats.uniform(loc=0, scale=1)#weights uniform between 0 and 1\n elif name in linenames:\n# priors[parname] = stats.expon(loc=0, scale=0.5)#favors low values>~0; make even stronger by decreasing scale. \n priors[parname] = stats.expon(loc=0, scale=0.2)#favors low values>~0; make even stronger by decreasing scale. \n elif name in [\"pred\", \"pblue\"]:\n porder = int(parname.split(\"_\")[1])\n if porder == 0:\n mu, sd = 1 / nssps, 1\n a, b = (0 - mu) / sd, (np.infty - mu) / sd\n priors[parname] = stats.truncnorm(a, b, mu, sd)\n else:\n priors[parname] = stats.norm(0, 0.05)\n else:\n print(f\"parameter without prior: {parname}\")\n return priors","def primes():\n yield 2\n candidate = 3\n while True:\n for i in range(3, int(sqrt(candidate)) + 1, 2):\n if (candidate % i) == 0:\n break\n else:\n yield candidate\n candidate += 2","def primes():\n yield 2\n candidate = 3\n while True:\n for i in range(3, int(sqrt(candidate)) + 1, 2):\n if (candidate % i) == 0:\n break\n else:\n yield candidate\n candidate += 2","def class_size(self):\n if not self.is_mutation_finite():\n return infinity\n\n # type A (finite and affine)\n if self._letter == 'A':\n # the formula is taken from Torkildsen - Counting\n # cluster-tilted algebras of type A\n if self.is_finite():\n n = self._rank\n a = binomial( 2*(n+1), n+1 ) // (n+2)\n if n % 2 == 1:\n a += binomial( n+1, (n+1)//2 )\n if n % 3 == 0:\n a += 2 * binomial( 2*n//3, n//3 )\n return a // (n+3)\n # the formula is taken from Bastian, Prellberg, Rubey, Stump\n elif self.is_affine():\n i,j = self._bi_rank\n i = ZZ(i)\n j = ZZ(j)\n n = i+j\n f = Euler_Phi()\n if i == j:\n return ( binomial( 2*i,i ) +\n sum( f(k) * binomial(2*i//k,i//k)**2\n for k in [k for k in i.divisors()\n if k in j.divisors()] ) // n ) // 4\n else:\n return sum( f(k) * binomial(2*i//k,i//k) *\n binomial(2*j//k,j//k)\n for k in [k for k in i.divisors()\n if k in j.divisors()] ) // ( 2 * n )\n\n # types B and C (finite and affine)\n elif self._letter in ['B', 'C']:\n # this formula is proven but nowhere published correctness\n # is clear enough that I don't think a warning is needed\n if self.is_finite():\n n = self._rank\n return binomial(2 * n, n) // (n + 1)\n\n elif self._letter in ['BB','CC']:\n # these two formulas are not yet proven\n print(Warning(\"Warning: This method uses a formula \"\n \"which has not been proved correct.\"))\n if self.is_affine():\n if self._twist == 1:\n n = self._rank - 1\n if n%2==1:\n return binomial( 2*n-1, n-1 )\n else:\n return binomial( 2*n-1, n-1 ) + binomial( n-1, n//2 -1 )\n\n # type BC (affine)\n elif self._letter == 'BC':\n # this formula is not yet proven\n print(Warning(\"Warning: This method uses a formula \"\n \"which has not been proved correct.\"))\n if self.is_affine():\n if self._twist == 1:\n n = self._rank - 1\n return binomial( 2*n, n )\n\n # types BD and CD (affine)\n elif self._letter in ['BD','CD']:\n # this formula is not yet proven\n print(Warning(\"Warning: This method uses a formula \"\n \"which has not been proved correct.\"))\n if self.is_affine():\n if self._twist == 1:\n n = self._rank - 2\n return 2*binomial( 2*n, n )\n\n # type D (finite and affine)\n elif self._letter == 'D':\n # the formula is taken from Bastian, Prellberg, Rubey, Stump\n if self.is_finite():\n if self._rank == 4:\n return 6\n else:\n f = Euler_Phi()\n n = ZZ(self._rank)\n return sum( f( n//k ) * binomial( 2*k, k )\n for k in n.divisors() ) // (2*n)\n # this formula is not yet proven\n elif self.is_affine():\n n = self._rank - 3\n if n == 2:\n return 9\n else:\n print(Warning (\"Warning: This method uses a formula \"\n \"which has not been proved correct.\"))\n if n%2==1:\n return 2*binomial(2*n,n)\n else:\n return 2*binomial(2*n,n) + binomial(n, n//2)\n\n # the exceptional types are hard-coded\n # type E (finite, affine and elliptic)\n elif self._letter == 'E':\n if self.is_finite():\n if self._rank == 6:\n return 67\n elif self._rank == 7:\n return 416\n elif self._rank == 8:\n return 1574\n elif self.is_affine():\n if self._rank == 7:\n return 132\n elif self._rank == 8:\n return 1080\n elif self._rank == 9:\n return 7560\n elif self.is_elliptic():\n if self._rank == 8:\n return 49\n elif self._rank == 9:\n return 506\n elif self._rank == 10:\n return 5739\n\n # type F\n elif self._letter == 'F':\n if self.is_finite():\n return 15\n elif self.is_affine():\n return 60\n elif self.is_elliptic():\n if self._twist == [1,2]:\n return 90\n if self._twist == [1,1] or self._twist == [2,2]:\n return 35\n\n # type G\n elif self._letter == 'G':\n if self.is_finite():\n return 2\n elif self.is_affine():\n return 6\n elif self.is_elliptic():\n if self._twist == [1,3]:\n return 7\n if self._twist == [1,1] or self._twist == [3,3]:\n return 2\n\n # type X\n elif self._letter == 'X':\n if self._rank == 6:\n return 5\n elif self._rank == 7:\n return 2\n\n # otherwise the size is returned to be unknown\n else:\n print(\"Size unknown\")\n return NotImplemented","def gen_primes(N):\n primes = set()\n for n in range(2, N):\n if all(n % p > 0 for p in primes):\n primes.add(n)\n yield n","def non_maxima_suppression(boxes, probs, classes_num, thr=0.2):\n for i, box in enumerate(boxes):\n if probs[i] == 0:\n continue\n for j in range(i+1, len(boxes)):\n if classes_num[i] == classes_num[j] and iou(box, boxes[j]) > thr:\n probs[j] = 0.0\n\n return probs","def factors(n, primes):\n\n for p in takewhile(lambda p: p*p < n, primes):\n exponent = 0\n\n while n % p == 0:\n exponent += 1\n n /= p\n\n if exponent > 0:\n yield p, exponent\n\n if n > 1:\n yield n, 1","def set_priors(self,alpha):\n\n\t\tassert type(alpha) == float\n\t\tself.alpha = alpha","def start_prime_test():","def return_class_probas(pnode, pY):\n\n nof_objects = pY.shape[0]\n nof_classes = pY.shape[1]\n class_probas = numpy.zeros(nof_classes)\n\n for i in range(nof_objects):\n class_probas += pnode[i] * pY[i, :]\n\n # class_probas = class_probas/numpy.sum(pnode)\n class_probas = class_probas / len(pnode)\n # class_probas = pY\n\n return class_probas","def __init__(self) :\n self.probabilities_ = None","def __init__(self) :\n self.probabilities_ = None","def __init__(self) :\n self.probabilities_ = None","def get_num_classes(self):","def get_prime(self):\n return self.prime","def primes(n):\n primfac = {}\n primfac = defaultdict(lambda: 0, primfac)\n while (n % 2) == 0:\n primfac[2] += 1 \n n //= 2\n d = 3\n while d*d <= n:\n while (n % d) == 0:\n primfac[d] += 1 # supposing you want multiple factors repeated\n n //= d\n d += 2\n if n > 1:\n primfac[n] = 1\n return primfac","def calculate_class_apriori_probability(self, class_name):\n unique, counts = np.unique(self.class_data, return_counts=True)\n frequency_dict = dict(zip(unique, counts))\n return float(frequency_dict[class_name])/len(self.class_data)","def __init__(self, count):\n assert count >= 0\n self.is_proportion = count < 1.0\n self.cutoff = count","def classes(self):\n #print \"making classes again!\"\n l = []\n for p in self.marks:\n l.append(psi_class(self,p))\n for d in range(1, self.dimension + 1):\n l.append(kappa_class(self,d))\n for i in range(1, self.genus+1):\n l.append(chern_char(self, 2*i-1))\n if True:#self.genus != 0:\n l.append(irreducible_boundary(self))\n marks = set(self.marks)\n reducible_boundaries = []\n if self.n != 0:\n first_mark_list = [marks.pop()] \n for g1 in range(0, self.genus + 1):\n for p in subsets(marks):\n r_marks = set(first_mark_list + p)\n if 3*g1 - 3 + len(r_marks) + 1 >= 0 and 3*(self.genus-g1) - 3 + self.n - len(r_marks) + 1 >= 0:\n reducible_boundaries.append( reducible_boundary(self, Mgn(g1, r_marks)) )\n \n reducible_boundaries.sort(key = lambda b: sorted(list(b.component1.marks)))\n reducible_boundaries.sort(key = lambda b: len(b.component1.marks))\n reducible_boundaries.sort(key = lambda b: b.component1.genus)\n \n else: #self.n == 0\n for g1 in range(1, floor(self.genus/2.0)+1):\n reducible_boundaries.append(reducible_boundary(self, Mgn(g1, []))) \n \n \n l += reducible_boundaries \n \n for i in range(1,self.genus+1):\n l.append(lambda_class(self,i))\n return l","def setpriPridict(cls, instcls, stage, pri):\n if not any(pridict):\n cls.initpridict()\n try:\n pridict[instcls][stage] = pri\n except AttributeError as err:\n print(\"Err\", err)\n return 0\n return pridict[instcls][stage]","def solution(resources, args):\n largest_prime_factor = 1\n number = args.number\n prime_generator = primes.get_prime_generator()\n\n while number > 1:\n prime = next(prime_generator)\n if number % prime == 0:\n number /= prime\n largest_prime_factor = prime\n\n if largest_prime_factor == 1:\n largest_prime_factor = args.number\n\n return largest_prime_factor","def __init__(self, N, S, students, leaders):\n self.N = N\n self.S = S\n self.G = int(math.ceil(N/S))\n self.partitions = []\n self.students = students\n self.leaders = leaders","def primal_problem(\n states: list[np.ndarray], probs: list[float] = None, dist_method=\"min-error\"\n) -> float:\n dim_x, _ = states[0].shape\n\n obj_func = []\n meas = []\n constraints = []\n\n dim = int(np.log2(dim_x))\n dim_list = [2] * int(np.log2(dim_x))\n\n sys_list = list(range(1, dim, 2))\n\n # Unambiguous consists of k + 1 operators, where the outcome of the k+1^st corresponds to the\n # inconclusive answer.\n if dist_method == \"unambiguous\":\n for i in range(len(states) + 1):\n meas.append(cvxpy.Variable((dim_x, dim_x), PSD=True))\n constraints.append(partial_transpose(meas[i], sys_list, dim_list) >> 0)\n\n for i, _ in enumerate(states):\n for j, _ in enumerate(states):\n if i != j:\n constraints.append(probs[j] * cvxpy.trace(states[j].conj().T @ meas[i]) == 0)\n\n # Minimize error of distinguishing via PPT measurements.\n elif dist_method == \"min-error\":\n for i, _ in enumerate(states):\n meas.append(cvxpy.Variable((dim_x, dim_x), PSD=True))\n constraints.append(partial_transpose(meas[i], sys_list, dim_list) >> 0)\n\n for i, _ in enumerate(states):\n obj_func.append(probs[i] * cvxpy.trace(states[i].conj().T @ meas[i]))\n\n constraints.append(sum(meas) == np.identity(dim_x))\n\n objective = cvxpy.Maximize(sum(obj_func))\n problem = cvxpy.Problem(objective, constraints)\n sol_default = problem.solve()\n\n return sol_default","def is_prime(self):\n pass","def prob4():\n#raise NotImplementedError(\"Problem 4 Incomplete\")\n h = lambda x : x[0] < -1 and x[1] > 1\n f = lambda x : stats.multivariate_normal.pdf(x,mean=np.array([0,0]),cov=np.eye(2))\n g = lambda x : stats.multivariate_normal.pdf(x,mean=np.array([-1,1]),cov=np.eye(2))\n X = np.random.multivariate_normal(mean=np.array([-1,1]),cov=np.eye(2),size=10000)\n return 1./10000*np.sum(np.apply_along_axis(h,1,X)*np.apply_along_axis(f,1,X)/np.apply_along_axis(g,1,X))","def gini(self, rows):\n counts = self.class_counts(rows)\n impurity = 1\n for lbl in counts:\n prob_of_lbl = counts[lbl] / float(len(rows))\n impurity -= prob_of_lbl**2\n return impurity","def _calc_train_class_prb(self, labels_list=None):\n if not labels_list:\n return {}\n\n n = len(labels_list)\n label_num = len(self.labels)\n prb = {}\n for l in self.labels:\n # tmp = (l, sum(1 if v == l else 0 for k, v in train_data)/n)\n prb[l] = (labels_list.count(l) + 1.0) / (n + label_num)\n return prb","def probs(self) -> List:\n return self._probs","def classify_proba(self, X):\n return self._expectation(X)","def __init__(self, prim):\n self.actual = prim","def __init__(self, n, e):\n\t\tself.known_primes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,\n\t\t\t103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,\n\t\t\t199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,\n\t\t\t313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,\n\t\t\t433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,\n\t\t\t563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,\n\t\t\t673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,\n\t\t\t811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,\n\t\t\t941,947,953,967,971,977,983,991,997,1009,1013,1019,1021,1031,1033,1039,1049,\n\t\t\t1051,1061,1063,1069,1087,1091,1093,1097,1103,1109,1117,1123,1129,1151,1153,\n\t\t\t1163,1171,1181,1187,1193,1201,1213,1217,1223,1229,1231,1237,1249,1259,1277,\n\t\t\t1279,1283,1289,1291,1297,1301,1303,1307,1319,1321,1327,1361,1367,1373,1381,\n\t\t\t1399,1409,1423,1427,1429,1433,1439,1447,1451,1453,1459,1471,1481,1483,1487,\n\t\t\t1489,1493,1499,1511,1523,1531,1543,1549,1553,1559,1567,1571,1579,1583,1597,\n\t\t\t1601,1607,1609,1613,1619,1621,1627,1637,1657,1663,1667,1669,1693,1697,1699,\n\t\t\t1709,1721,1723,1733,1741,1747,1753,1759,1777,1783,1787,1789,1801,1811,1823,\n\t\t\t1831,1847,1861,1867,1871,1873,1877,1879,1889,1901,1907,1913,1931,1933,1949,\n\t\t\t1951,1973,1979,1987,1993,1997,1999,2003,2011,2017,2027,2029,2039,2053,2063]\n\t\tself.hidden_primes_product = n\n\t\tself.public_key = e\n\t\tself.private_key = None","def classifier(x):\n return x[0] - x[1] + 4 < 0","def primes():\n yield 2\n found = []\n for i in itertools.count(start=3, step=2):\n for p in found:\n if i % p == 0:\n break\n else:\n yield i\n found.append(i)","def getPrimeFactors(num):\n n = num\n primes = {}\n\n p = 2\n sqrt = math.sqrt(num)\n\n def checkAndUpdate(inc):\n nonlocal n\n nonlocal p\n nonlocal primes\n if n % p == 0:\n if str(p) in primes.keys():\n primes[str(p)] += 1\n else:\n primes[str(p)] = 1\n n /= p\n else:\n p += inc\n \n while p == 2 and p <= n:\n checkAndUpdate(1)\n while p <= n and p <= sqrt:\n checkAndUpdate(2)\n if len(primes.keys()) == 0:\n primes[str(num)] = 1\n elif n != 1:\n primes[str(n)] = 1\n return primes","def classify(cls, i):\r\n sums = [0,0]\r\n sums[int(WekaClassifier_0.classify(i))] += 1.2134644010075073\r\n sums[int(WekaClassifier_1.classify(i))] += 0.57177685574344\r\n sums[int(WekaClassifier_2.classify(i))] += 0.40154496884580815\r\n sums[int(WekaClassifier_3.classify(i))] += 0.35999934750119333\r\n sums[int(WekaClassifier_4.classify(i))] += 0.36937329276984643\r\n sums[int(WekaClassifier_5.classify(i))] += 0.16351990613377496\r\n sums[int(WekaClassifier_6.classify(i))] += 0.1396078832952814\r\n sums[int(WekaClassifier_7.classify(i))] += 0.15882943193304253\r\n sums[int(WekaClassifier_8.classify(i))] += 0.1284505298097081\r\n sums[int(WekaClassifier_9.classify(i))] += 0.09903161346969916\r\n sums[int(WekaClassifier_10.classify(i))] += 0.19672733155497407\r\n sums[int(WekaClassifier_11.classify(i))] += 0.17672847093616786\r\n sums[int(WekaClassifier_12.classify(i))] += 0.18729151620386228\r\n sums[int(WekaClassifier_13.classify(i))] += 0.24810462685136855\r\n sums[int(WekaClassifier_14.classify(i))] += 0.23706555932983922\r\n sums[int(WekaClassifier_15.classify(i))] += 0.14276017880034322\r\n sums[int(WekaClassifier_16.classify(i))] += 0.2655207144416779\r\n sums[int(WekaClassifier_17.classify(i))] += 0.24759035974335297\r\n sums[int(WekaClassifier_18.classify(i))] += 0.14255881855351965\r\n sums[int(WekaClassifier_19.classify(i))] += 0.1181101393342422 \r\n return float(sums[0] - sums[1])","def classify(self, instance):\n numerator = 0\n denominator = 0\n for training_instance in self.training_data:\n h_value = self._h_function(instance, training_instance[0])\n numerator = numerator + h_value*training_instance[1]\n denominator = denominator + h_value\n return numerator/denominator","def init_probability_dict(self):\n for x in xrange(0,10):\n self.class_probabilities[x] = self.init_probability_2d()","def factor_in_multiple_professors(self):\n professors = [professor for professor in self.course.professors if professor.lower() != \"none\"]\n number_professors = len(set(professors))\n if number_professors > 1:\n self.score = self.score + number_professors"],"string":"[\n \"def classProbs(observation, tree, classes):\\n res = classify(observation, tree) #res = results\\n total = sum(res.values())\\n probs = []\\n for c in classes:\\n if c in res.keys():\\n probs.append(float(res[c])/total)\\n else:\\n probs.append(0)\\n return probs\",\n \"def priors(self):\\n\\n return self._priors\",\n \"def get_pred_class_probs(self, pred_mu, pred_sigma):\",\n \"def __init__(self, classes, data_size):\\r\\n self.classes = classes\\r\\n self.data_size = data_size\\r\\n self.conditional_prob = {class_:{} for class_ in classes} # Conditional Probability Table for storing parameters useful to compute P(feat|class_)\\r\\n self.class_prob = {} # Stores the priors\\r\",\n \"def checkPriors(para):\\n\\t\\n\\t# extract parameters\\n\\tA = para[0]\\n\\tw = para[1]\\n\\tp = para[2]\\n\\t\\n\\t# check them\\n\\tif (A<0.01 or A>10.0): A = s.uniform.rvs(0.01,10.)\\n\\t\\n\\tif (w<0.01 or w>10.0): w = s.uniform.rvs(0.01,10.)\\n\\t\\t\\n\\tif ( p<0. or p>2*np.pi): p = s.uniform.rvs(0.0,2*np.pi)\\n\\t\\n\\treturn np.array([A,w,p])\",\n \"def classify(priors, likelihoods, testData, classes):\\r\\n results = []\\r\\n for document in testData:\\r\\n bestClass = None\\r\\n bestProb = None\\r\\n currentProb = 0.0\\r\\n for cls in classes:\\r\\n prior = priors[cls]\\r\\n currentProb = log(prior)\\r\\n lhoods = likelihoods[cls]\\r\\n for (word, count) in document:\\r\\n if word in lhoods:\\r\\n currentProb += log(lhoods[word])\\r\\n else:\\r\\n currentProb += log(lhoods[None])\\r\\n if currentProb > bestProb or bestClass == None:\\r\\n bestProb = currentProb\\r\\n bestClass = cls\\r\\n results.append(bestClass)\\r\\n return results\",\n \"def class_probability(self, x):\\n # permutation before softmax b x a x c x spatial dims --> b x c x a x spatial dims\\n # as expected by PyTorch Softmax the class axis = 1 \\n return self._class_prob(x.permute([0, 2, 1, 3, 4]))\",\n \"def _estimate_priors(self):\\n\\n # Estimate the log UMI count turning point between cells and 'empties'.\\n self.priors['log_counts_crossover'] = \\\\\\n np.mean(np.log1p([self.priors['cell_counts'],\\n self.priors['empty_counts']])).item()\\n\\n # Estimate prior for the scale param of LogNormal for d.\\n if self.model_name != \\\"simple\\\":\\n self.priors['d_std'] = (np.log1p(self.priors['cell_counts'])\\n - self.priors['log_counts_crossover']) / 5\\n else:\\n self.priors['d_std'] = 0.2 # This is a reasonable prior in log space.\\n\\n # Priors for models that include empty droplets:\\n if self.model_name != \\\"simple\\\":\\n # Estimate fraction of trimmed dataset that contains cells.\\n # cell_prob = self.priors['n_cells'] / self.analyzed_barcode_inds.size\\n cell_prob = (1 - self.fraction_empties) \\\\\\n * (self.priors['n_cells'] / self.analyzed_barcode_inds.size)\\n self.priors['cell_prob'] = cell_prob\\n\\n assert cell_prob > 0, f\\\"Fraction of trimmed dataset \\\" \\\\\\n f\\\"containing cells should be > 0, \\\" \\\\\\n f\\\"but is {cell_prob}.\\\"\\n\\n assert cell_prob <= 1, f\\\"Fraction of trimmed dataset \\\" \\\\\\n f\\\"containing cells should be at most 1, \\\" \\\\\\n f\\\"but is {cell_prob}.\\\"\\n\\n # Turn cell probability into logit.\\n self.priors['cell_logit'] = np.log(cell_prob / (1 - cell_prob)).item()\\n\\n # Estimate the ambient gene expression profile.\\n self.priors['chi_ambient'], self.priors['chi_bar'] = \\\\\\n estimate_chi_from_dataset(self)\",\n \"def calc_priors(categories, data):\\n counts = np.zeros(categories)\\n for val in range(categories):\\n counts[val] = np.count_nonzero(data.labels == val)\\n return counts / len(data.labels)\",\n \"def classes_calculations(input):\\n counts, _ = np.histogram(input, bins=int(\\n input.max() + 1), range=(0, int(input.max())))\\n return np.nonzero(counts)[0]\",\n \"def __init__(self, N=40):\\n self._primes = []\\n self.find_primes(N)\",\n \"def make_priors(self):\\r\\n if self.last_img_size != (self.target_size, self.target_size):\\r\\n prior_data = []\\r\\n\\r\\n for conv_w, conv_h, scale in zip(self.conv_ws, self.conv_hs, self.scales):\\r\\n for i in range(conv_h):\\r\\n for j in range(conv_w):\\r\\n # +0.5 because priors are in center-size notation\\r\\n cx = (j + 0.5) / conv_w\\r\\n cy = (i + 0.5) / conv_h\\r\\n\\r\\n for ar in self.aspect_ratios:\\r\\n ar = np.sqrt(ar)\\r\\n\\r\\n w = scale * ar / self.target_size\\r\\n h = scale / ar / self.target_size\\r\\n\\r\\n # This is for backward compatability with a bug where I made everything square by accident\\r\\n h = w\\r\\n\\r\\n prior_data += [cx, cy, w, h]\\r\\n\\r\\n self.priors = np.array(prior_data).reshape(-1, 4)\\r\\n self.last_img_size = (self.target_size, self.target_size)\\r\\n return self.priors\",\n \"def __init__(self, num_class):\\n self.sum_hit_at_one = 0.0\\n self.sum_perr = 0.0\\n self.sum_f1score = 0.0\\n self.sum_f2score = 0.0\\n self.sum_loss = 0.0\\n self.num_examples = 0\",\n \"def generate_probabilities(self):\\n k = 1\\n v= 10\\n for g in self.class_probabilities:\\n curr_list = self.class_probabilities[g]\\n for l in range(0,28):\\n for w in range(0,28):\\n total = float(curr_list[l][w][0] + curr_list[l][w][1] + curr_list[l][w][2])\\n curr_list[l][w][0] = (float(curr_list[l][w][0])+k)/(total + k*v) \\n curr_list[l][w][1] = (float(curr_list[l][w][1])+k)/(total + k*v)\\n curr_list[l][w][2] = (float(curr_list[l][w][2])+k)/(total + k*v)\\n curr_list[l][w][3] = curr_list[l][w][0] + curr_list[l][w][1] + curr_list[l][w][2]\",\n \"def probabilities(self):\\n raise NotImplementedError\",\n \"def _class_distribution(y):\\n unique, counts = np.unique(y, return_counts = True)\\n\\n percentages = counts / np.sum(counts)\\n\\n return unique, counts, percentages\",\n \"def p(self) -> Probability:\\n ...\",\n \"def calc_priors(self, prior_U, method='inverse'):\\n if self.Pchance is None:\\n raise IOError(\\\"Set Pchance before calling this method\\\")\\n\\n # TODO -- Move this into Bayesian\\n if prior_U < 0.:\\n self.prior_U = np.product(self.candidates['P_c'])\\n else:\\n self.prior_U = prior_U\\n\\n # Raw priors\\n self.raw_prior_Oi = bayesian.raw_prior_Oi(method, self.candidates[self.filter].values,\\n Pchance=self.Pchance,\\n half_light=self.candidates.half_light.values)\\n\\n # Normalize\\n self.prior_Oi = bayesian.renorm_priors(self.raw_prior_Oi, self.prior_U)\\n\\n # Add to table\\n self.candidates['P_O'] = self.prior_Oi\",\n \"def determineClasses(self, particles):\\n\\t\\tapDisplay.printMsg(\\\"sorting refineparticledata into classes\\\")\\n\\t\\tt0 = time.time()\\n\\t\\tclasses={}\\n\\t\\tclass_stats={}\\n\\t\\tquality=numpy.zeros(len(particles))\\n\\t\\tfor partnum in range(len(particles)):\\n\\t\\t\\tquality[partnum] = particles[partnum]['quality_factor']\\n\\t\\t\\tkey = (\\\"%.3f_%.3f\\\"%(particles[partnum]['euler1'], particles[partnum]['euler2']))\\n\\t\\t\\tif key not in classes.keys():\\n\\t\\t\\t\\tclasses[key]={}\\n\\t\\t\\t\\tclasses[key]['particles']=[]\\n\\t\\t\\t\\tclasses[key]['euler1'] = particles[partnum]['euler1']\\n\\t\\t\\t\\tclasses[key]['euler2'] = particles[partnum]['euler2']\\n\\t\\t\\t\\t#classes have no inplane rotation\\n\\t\\t\\t\\tclasses[key]['euler3'] = 0.0 #particles[partnum]['euler3']\\n\\t\\t\\tclasses[key]['particles'].append(particles[partnum])\\n\\t\\tclass_stats['meanquality']=quality.mean()\\n\\t\\tclass_stats['stdquality']=quality.std()\\n\\t\\tclass_stats['max']=quality.max()\\n\\t\\tclass_stats['min']=quality.min()\\n\\t\\tapDisplay.printMsg(\\\"sorted %d particles into %d classes\\\"%(len(particles), len(classes)))\\n\\t\\t### print stats\\n\\t\\tprint \\\"-- quality factor stats --\\\"\\n\\t\\tprint (\\\"mean/std :: \\\"+str(round(class_stats['meanquality'],2))+\\\" +/- \\\"\\n\\t\\t\\t+str(round(class_stats['stdquality'],2)))\\n\\t\\tprint (\\\"min/max :: \\\"+str(round(class_stats['min'],2))+\\\" <> \\\"\\n\\t\\t\\t+str(round(class_stats['max'],2)))\\n\\t\\tapDisplay.printMsg(\\\"finished sorting in \\\"+apDisplay.timeString(time.time()-t0))\\n\\t\\treturn classes, class_stats\",\n \"def carbon_prime(C,p,p0):\\r\\n \\r\\n if p > p0:\\r\\n return C\\r\\n else:\\r\\n return .03\",\n \"def perplexity(self):\\n raise NotImplementedError(\\\"To be implemented\\\")\",\n \"def percent_to_class(prc, fair):\\n assert len(prc) == 1, \\\"Should be only one column.\\\"\\n prc = prc[0]\\n\\n # Threshold between fair and unfair.\\n tsh_fair = 0.1\\n # Threshold between unfair and very unfair.\\n tsh_unfair = 0.4\\n\\n dif = (fair - prc) / fair\\n if dif < -1 * tsh_unfair:\\n # We are much higher than fair.\\n cls = 4\\n elif -1 * tsh_unfair <= dif < -1 * tsh_fair:\\n # We are not that much higher than fair.\\n cls = 3\\n elif -1 * tsh_fair <= dif <= tsh_fair:\\n # We are fair.\\n cls = 2\\n elif tsh_fair < dif <= tsh_unfair:\\n # We are not that much lower than fair.\\n cls = 1\\n elif tsh_unfair < dif:\\n # We are much lower than fair.\\n cls = 0\\n else:\\n assert False, \\\"This should never happen.\\\"\\n return cls\",\n \"def detect_class_onpic(boxes, allowed_classes):\\n object_class = \\\"all\\\"\\n highest_prob = 0\\n for box in boxes:\\n box_prob = float(box[1].strip('%')) / 100.0\\n if box[0] in allowed_classes and box_prob > highest_prob:\\n highest_prob = box_prob\\n object_class = box[0]\\n return object_class, highest_prob\",\n \"def decision(self, neighbors=None):\\n if not neighbors:\\n return sorted(self.class_prb.items(), key=lambda n: n[1],\\n reverse=True)\\n\\n else:\\n n = len(neighbors)\\n prb = {}\\n for label in self.labels:\\n prb[label] = 0.0\\n for kdnode, dist in neighbors:\\n index = self.train_data.index(kdnode.data)\\n prb[self.train_label[index]] += 1\\n for label in self.labels:\\n prb[label] = prb[label] / n\\n return sorted(prb.items(), key=lambda n: n[1], reverse=True)\",\n \"def proportion_of_primes(bound, **args):\\n v = []\\n k = 0.0\\n for n in range(1, bound + 1):\\n if is_prime(n):\\n k += 1\\n v.append((n, k / n))\\n return plot_step_function(v, **args)\",\n \"def prob(self, tple, class_counts, feature_counts):\\n feats = self.dataset.input_features\\n unnorm = [prod(feature_counts[i][feat(tple)][c]\\n for (i,feat) in enumerate(feats))\\n /(class_counts[c]**(len(feats)-1))\\n for c in range(self.num_classes)]\\n thesum = sum(unnorm)\\n return [un/thesum for un in unnorm]\",\n \"def ComparePriors():\\n dataset = [60]\\n high = 1000\\n\\n thinkplot.Clf()\\n thinkplot.PrePlot(num=2)\\n\\n constructors = [Train, Train2, Train3]\\n labels = ['uniform', 'power law', 'many companies']\\n\\n for constructor, label in zip(constructors, labels):\\n suite = MakePosterior(high, dataset, constructor)\\n suite.name = label\\n thinkplot.Pmf(suite)\\n\\n thinkplot.Save(root='train4',\\n xlabel='Number of trains',\\n ylabel='Probability')\",\n \"def sort_priors(self):\\n return\",\n \"def _get_model_priors(self):\\n if self._alpha_model_priors:\\n return self._alpha_model_priors\\n # sample the variables from their corresponding distributions\\n params = self._get_prior_params()\\n self._alpha_model_priors = self._params2probs(params)\\n return self._alpha_model_priors\",\n \"def propose(self):\\n\\n p = type(self)(self.n, alpha=self.alpha)\\n\\n return p, p.compute_prior() - self.compute_prior()\",\n \"def gini(rows):\\n counts = class_counts(rows)\\n print(counts)\\n impurity = 1\\n for lbl in counts:\\n prob_of_lbl = counts[lbl] / float(len(rows))\\n impurity -= prob_of_lbl**2\\n return impurity\",\n \"def GetNFactors(n, primes, n_pfactors, _):\\n sqrtn = int(n ** 0.5) + 1\\n\\n for p in primes:\\n if p > sqrtn:\\n break\\n if n % p == 0:\\n n //= p\\n if n % p == 0:\\n return n_pfactors[n]\\n else:\\n return n_pfactors[n] + 1\\n\\n # n is primes\\n primes.append(n)\\n return 1\",\n \"def pointPerClass(classMap):\\n rand1 = 100 * pcr.uniform(pcr.boolean(classMap)) \\n rand2 = 100 * pcr.uniform(pcr.boolean(classMap))\\n rand3 = 100 * pcr.uniform(pcr.boolean(classMap))\\n \\n randomMap = pcr.scalar(classMap) * rand1 * rand2 * rand3\\n pointMap = pcr.ifthen(randomMap == pcr.areaminimum(randomMap, classMap), classMap)\\n nrPointsPerClass = pcr.areatotal(pcr.scalar(pcr.boolean(pointMap)), classMap)\\n assert pcr.cellvalue(pcr.mapmaximum(nrPointsPerClass), 0)[0] == 1\\n return pointMap\",\n \"def filtro_probs(prediccion,p_min):\\n clases = []\\n for probabilidad in prediccion:\\n if probabilidad[1]>=p_min:\\n clases.append(probabilidad)\\n else:\\n clases.append(\\\"-\\\")\\n return clases\",\n \"def purity(clusters, classes):\\n\\n d = defaultdict(list)\\n\\n # Get a list of class numbers of all examples in a cluster.\\n for k, v in zip(clusters, classes):\\n d[k].append(v)\\n\\n mayority = 0\\n\\n # Count the mayority class number and add it up over all clusters.\\n for k in d:\\n mayority += Counter(d[k]).most_common(1)[0][1]\\n\\n return float(mayority) / len(clusters)\",\n \"def computeNumClass(self):\\n # Get the number of data\\n n = len(self.data)\\n # For IQR\\n # First, compute the position of the first and third quartile\\n fQPos = ( (n - 1) / 4 ) + 1\\n tQPos = ( (3 * (n - 1)) / 4 ) + 1\\n # Get the quartiles\\n firstQ = 0.0\\n thirdQ = 0.0\\n if fQPos == round(fQPos):\\n firstQ = self.data[int(fQPos)]\\n else:\\n up = round(fQPos)\\n firstQ = self.data[up - 1] + ((self.data[up] - self.data[up - 1]) / 4.0)\\n if tQPos == round(tQPos):\\n thirdQ = self.data[int(tQPos)]\\n else:\\n up = round(tQPos)\\n thirdQ = self.data[up - 1] + (3 * (self.data[up] - self.data[up - 1]) / 4.0)\\n # Compute the IQR\\n IQR = thirdQ - firstQ\\n # Compute the number of classes and its length\\n self.numBins = int(2 * IQR * m.pow(n, -1/3))\\n self.computeBinWidth()\",\n \"def class_distribution(y): \\n # ===================== PLEASE WRITE HERE =====================\\n \\n bin_array = np.bincount(y)\\n n_class1 = bin_array[1]\\n n_class2 = bin_array[2]\\n n_class3 = bin_array[3]\\n \\n # ===================== PLEASE WRITE HERE =====================\\n \\n print('Number of samples in class_1:', n_class1)\\n print('Number of samples in class_2:', n_class2)\\n print('Number of samples in class_3:', n_class3)\",\n \"def count_prime():\\n nums = []\\n for i in range(2, 10000):\\n if is_prime(i):\\n nums.append(i)\\n return nums\",\n \"def prim_method(self):\",\n \"def prim_method(self):\",\n \"def get_probable_prime(n: int) -> [int]:\\n return [6*n-1, 6*n+1]\",\n \"def get_pc_per_range(model, class_name):\\n class_total = model.class_counts[class_name]\\n if model.num_runs is not None:\\n class_total = model.num_runs * class_total * .33\\n\\n true_positives, totals = model.range_metrics_10[class_name]\\n purities = [] # Accuracy per range (true positive/total)\\n comps = []\\n TP_count = 0\\n total_count = 0\\n\\n for index in reversed(range(len(true_positives))):\\n cur_p = 0 # Current purity\\n cur_c = 0 # Current completeness\\n TP_count += true_positives[index]\\n total_count += totals[index]\\n if total_count != 0:\\n # positive class samples / totals # with prob in range\\n cur_p = TP_count / total_count\\n if class_total != 0:\\n cur_c = TP_count / class_total\\n\\n purities.append(cur_p)\\n comps.append(cur_c)\\n purities.reverse()\\n comps.reverse()\\n return purities, comps\",\n \"def _m(self):\\n return self._k // self._n_classes\",\n \"def _computeCondProb(self, testData, classValue):\\n classAttrObj = self._classAttrs[classValue]\\n frequencyDict = classAttrObj.frequencyDict\\n totalDocsInClass = classAttrObj.totalDocsInClass\\n\\n result = (totalDocsInClass/self._totalTrainDocs) # P(c)\\n # Compute P(t|c) for each t in d\\n for word in testData:\\n result *= ((frequencyDict.get(word, 0) + 1) / (sum(frequencyDict.values()) + self._sizeOfVocabulary))\\n return result\",\n \"def get_primes_in(self, grange):\\n for n in grange:\\n if self.is_prime(n):\\n yield n\",\n \"def _get_guide_priors(self):\\n if not self._alpha_guide_prior_params:\\n # create initial parameters\\n params = self._get_prior_params()\\n # register all parameters in pyro\\n for p, v in iteritems(params):\\n pyro.param(p, v)\\n self._alpha_guide_prior_params = dict(\\n self._param_store.named_parameters()\\n )\\n else:\\n # register all parameters in pyro\\n for p, v in iteritems(self._alpha_guide_prior_params):\\n pyro.param(p, v)\\n return self._params2probs(self._alpha_guide_prior_params)\",\n \"def prior_of_priors(self, tt):\\n for i in xrange(self.n_params): \\n try: \\n p_theta *= self.param_obj.prior()[i].pdf(tt[i]) \\n\\n except UnboundLocalError: \\n p_theta = self.param_obj.prior()[i].pdf(tt[i]) \\n\\n return p_theta\",\n \"def componeProbs(p,p_prime):\\n return p + p_prime * (1-p)\",\n \"def __convert_prob_into_class(self, probs):\\n probs = T.set_subtensor(probs[probs > 0.5], 1)\\n return T.set_subtensor(probs[probs <= 0.5], 0)\",\n \"def percent_to_class(prc, fair):\\n assert len(prc) == 1, \\\"Should be only one column.\\\"\\n prc = prc[0]\\n\\n # Threshold between fair and unfair.\\n tsh_fair = 0.1\\n\\n dif = (fair - prc) / fair\\n if dif < -1 * tsh_fair:\\n # We are much higher than fair.\\n cls = 2\\n elif -1 * tsh_fair <= dif <= tsh_fair:\\n # We are fair.\\n cls = 1\\n elif tsh_fair < dif:\\n # We are much lower than fair.\\n cls = 0\\n else:\\n assert False, \\\"This should never happen.\\\"\\n return cls\",\n \"def class_size(self):\\n if not self.is_mutation_finite():\\n return infinity\\n else:\\n components = []\\n multiplicities = []\\n for x in self.irreducible_components():\\n if components.count(x) == 0:\\n components.append(x)\\n multiplicities.append(1)\\n else:\\n y = components.index(x)\\n multiplicities[y] = multiplicities[y]+1\\n\\n sizes = [ x.class_size() for x in components ]\\n if NotImplemented in sizes:\\n print(\\\"Size unknown\\\")\\n return NotImplemented\\n else:\\n return prod( [binomial(sizes[i]+multiplicities[i]-1,\\n multiplicities[i] ) for i in range (0,len(sizes))])\",\n \"def getpriPridict(cls, instcls, stage):\\n if not any(pridict):\\n cls.initpridict()\\n try:\\n pri = pridict[instcls][stage]\\n except AttributeError as err:\\n print(\\\"Err\\\", err)\\n return 0\\n return pri\",\n \"def reprime(self):\\n self.__primed = 1\",\n \"def primish(n):\\n\\n factors = set()\\n for i in range(n, 1, -1):\\n\\n # Find the smallest divisor of i.\\n smallest = 2\\n while (i % smallest) != 0:\\n smallest += 1\\n\\n # Divide by that divisor until we have 1 or something else.\\n remainder = i\\n while (remainder % smallest) == 0:\\n remainder /= smallest\\n\\n # Keep it if needed.\\n if remainder == 1:\\n factors.add(i)\\n\\n return factors\",\n \"def get_probs(self, a):\\n with torch.no_grad():\\n probabilities = (np.array(self.priorities) ** a) / sum(np.array(self.priorities) ** a)\\n return probabilities\",\n \"def get_priors(heuristic_lengthscales, use_priors=True, is_composite=False):\\n # Determine if we use priors\\n lengthscale_prior = None\\n outputscale_prior = None\\n if use_priors:\\n lengthscale_prior = GammaPrior(0.01 * heuristic_lengthscales,\\n 0.01 * torch.ones(heuristic_lengthscales.size()))\\n print(\\\"LENGTHSCALE MEAN: \\\\n{}\\\".format(lengthscale_prior.mean))\\n print(\\\"LENGTHSCALE VARIANCE: \\\\n{}\\\".format(lengthscale_prior.variance))\\n\\n if is_composite:\\n return lengthscale_prior, lengthscale_prior, outputscale_prior\\n\\n else:\\n return lengthscale_prior, outputscale_prior\",\n \"def __init__(self,x,dof):\\n self.x=x\\n self.dof=dof\\n numSeg=10\\n p1=self.P(numSeg)\\n p2=0\\n while True:\\n numSeg*=2\\n p2=self.P(numSeg)\\n if self.checarPs(p1,p2):\\n break\\n else:\\n p1=p2\\n print(round(p2,5))\",\n \"def obtain_parametric_priors(resolution, num_actions):\\n # maximum prior magnitude for any discritized state\\n max_prior = 10\\n \\n priors = []\\n \\n for p in range(resolution):\\n for v in range(resolution):\\n for a in range(num_actions):\\n priors.append(set_parametric_prior(resolution, p, v, a, max_prior))\\n \\n priors = np.array(priors).reshape(resolution,resolution,num_actions)\\n #print(\\\"priors\\\", priors[5,5,0])\\n return priors\",\n \"def optimal_instances_per_class(df, factor=1.0, draw=False):\\n # `bincount` returns the number of instances we have for each website\\n counts = np.bincount(df.class_label.tolist())\\n hist, bin_edges = np.histogram(counts)\\n if draw:\\n inst_counts = get_num_instances(df)\\n inst_counts.hist(cumulative=-1, bins=100)\\n plt.xlabel('Num of instances')\\n plt.ylabel('Num of classes with x or more insts')\\n plt.show()\\n\\n # scale the y-axis\\n dx = bin_edges[1] - bin_edges[0]\\n cum_hist = np.cumsum(hist) * dx\\n\\n # get the inverse cumulative sum\\n inv_cum_hist = max(cum_hist) - cum_hist\\n\\n # compute the harmonic mean of tuples (y=f(x), x)\\n hms = [harmonic_mean(x, y, factor) if y > 0 and x > 0 else 0\\n for x, y in zip(bin_edges[1:], inv_cum_hist)]\\n\\n print(hms)\\n\\n # find index for max harmonic mean\\n i = np.argmax(hms)\\n\\n # this is the optimal number of instances:\\n opt_num_insts = int(bin_edges[i])\\n\\n # which leaves us with this number of classes:\\n opt_num_classes = len(counts[counts >= opt_num_insts])\\n\\n if draw:\\n print(\\\"Optimal number of instances:\\\", opt_num_insts)\\n print(\\\"Optimal number of classes:\\\", opt_num_classes)\\n\\n return opt_num_insts, opt_num_classes\",\n \"def fairness_discrepancy(props, n_classes, norm=0):\\n # unique, freq = np.unique(data, return_counts=True)\\n # props = freq / len(data) #Proportion of data that belongs to that data\\n \\n # #------------------Modification to correct the zero support problem------------------------------------------------\\n # temp=np.zeros(n_classes)\\n # temp[unique]=props\\n # props=temp\\n # #------------------------------------------------------------------------------\\n \\n # print (freq)\\n truth = 1./n_classes\\n\\n\\n # L2 and L1=================================================================================================\\n #(Remove Normalisation)\\n l2_fair_d = np.sqrt(((props - truth)**2).sum())\\n l1_fair_d = abs(props - truth).sum()\\n\\n # q = props, p = truth\\n # kl_fair_d = (props * (np.log(props) - np.log(truth))).sum()\\n\\n #Cross entropy\\n p=np.ones(n_classes) \\n # ce=cross_entropy(p,props,n_classes)-cross_entropy(p,p,n_classes)\\n \\n #information specificity=====================================================================================\\n rank=np.linspace(1,n_classes-1,n_classes-1)\\n rank[::-1].sort() #Descending order\\n perc=np.array([i/np.sum(rank) for i in rank])\\n \\n \\n props[::-1].sort()\\n alpha=props[1:]\\n specificity=abs(props[0]-np.sum(alpha*perc))\\n info_spec=(l1_fair_d+specificity)/2\\n \\n #Wasstertein Distance\\n wd=wasserstein_distance(props,np.ones(len(props))*truth)\\n \\n #Wassertein Specificity\\n wds=(wd+specificity)/2\\n if norm==0:\\n return l2_fair_d, l1_fair_d,info_spec,specificity,wd,wds\\n # return l2_fair_d, l1_fair_d,info_spec,specificity\\n else:\\n return l2_fair_d/metric_max(n_classes,\\\"L2\\\"), l1_fair_d/metric_max(n_classes,\\\"L1\\\"),info_spec/metric_max(n_classes,\\\"Is\\\"),specificity,wd/metric_max(n_classes,\\\"Wd\\\")\\n # return l2_fair_d/metric_max(n_classes,\\\"l2\\\"), l1_fair_d/metric_max(n_classes,\\\"l1\\\"),info_spec/metric_max(n_classes,\\\"is\\\"),specificity\",\n \"def factorize(n:int,primesDict:dict = primesDict):\\r\\n\\r\\n \\r\\n if isPrime(n,primesDict):\\r\\n return {n:1}\\r\\n\\r\\n factors = {}\\r\\n\\r\\n lastPrime = getLastPrime(primesDict)\\r\\n print (lastPrime,\\\"Lastprimes\\\")\\r\\n if lastPrime < n:\\r\\n print (\\\"Creating DictS\\\")\\r\\n\\r\\n prma(n,lastPrime,primesDict)\\r\\n\\r\\n for i in primesDict:\\r\\n if n%i == 0 :\\r\\n count = 0\\r\\n while n % i**(count+1) == 0 :\\r\\n count+=1 \\r\\n factors[i]= count\\r\\n\\r\\n return factors\",\n \"def get_probs(self):\\n\\t\\tprobArray = []\\n\\t\\tfor combination in self.codepool:\\n\\t\\t\\tif self.feasible(combination):\\n\\t\\t\\t\\tprobArray.append(self.get_probability(combination))\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprobArray.append(0)\\n\\t\\tprobArray = np.array(probArray) / np.sum(probArray)\\n\\t\\treturn probArray\",\n \"def set_priors(parnames, limits, linenames, vsyst, nssps=1):\\n priors = {}\\n for parname in parnames:\\n name = parname.split(\\\"_\\\")[0]\\n if name in limits: #all the CvD ssp parameters\\n vmin, vmax = limits[name]\\n# print(parname,vmin,vmax)\\n delta = vmax - vmin\\n priors[parname] = stats.uniform(loc=vmin, scale=delta)\\n elif parname in vsyst:\\n priors[parname] = stats.norm(loc=vsyst[parname], scale=500)\\n elif parname == \\\"eta\\\": #what does eta do?\\n priors[\\\"eta\\\"] = stats.uniform(loc=1., scale=19)#uniform distribution in range [1,19]\\n elif parname == \\\"nu\\\": #what does nu do?\\n priors[\\\"nu\\\"] = stats.uniform(loc=2, scale=20)#uniform distribution in range [2,20]\\n elif parname == \\\"sigma\\\":\\n priors[\\\"sigma\\\"] = stats.uniform(loc=50, scale=300)#obtains the uniform distribution on [loc, loc + scale]. i.e. uniform in range [50,300]\\n elif parname == \\\"sigma_gas\\\":\\n priors[parname] = stats.uniform(loc=50, scale=100)#uniform between [50,100]km/s\\n elif name == \\\"w\\\":\\n priors[parname] = stats.uniform(loc=0, scale=1)#weights uniform between 0 and 1\\n elif name in linenames:\\n# priors[parname] = stats.expon(loc=0, scale=0.5)#favors low values>~0; make even stronger by decreasing scale. \\n priors[parname] = stats.expon(loc=0, scale=0.2)#favors low values>~0; make even stronger by decreasing scale. \\n elif name in [\\\"pred\\\", \\\"pblue\\\"]:\\n porder = int(parname.split(\\\"_\\\")[1])\\n if porder == 0:\\n mu, sd = 1 / nssps, 1\\n a, b = (0 - mu) / sd, (np.infty - mu) / sd\\n priors[parname] = stats.truncnorm(a, b, mu, sd)\\n else:\\n priors[parname] = stats.norm(0, 0.05)\\n else:\\n print(f\\\"parameter without prior: {parname}\\\")\\n return priors\",\n \"def primes():\\n yield 2\\n candidate = 3\\n while True:\\n for i in range(3, int(sqrt(candidate)) + 1, 2):\\n if (candidate % i) == 0:\\n break\\n else:\\n yield candidate\\n candidate += 2\",\n \"def primes():\\n yield 2\\n candidate = 3\\n while True:\\n for i in range(3, int(sqrt(candidate)) + 1, 2):\\n if (candidate % i) == 0:\\n break\\n else:\\n yield candidate\\n candidate += 2\",\n \"def class_size(self):\\n if not self.is_mutation_finite():\\n return infinity\\n\\n # type A (finite and affine)\\n if self._letter == 'A':\\n # the formula is taken from Torkildsen - Counting\\n # cluster-tilted algebras of type A\\n if self.is_finite():\\n n = self._rank\\n a = binomial( 2*(n+1), n+1 ) // (n+2)\\n if n % 2 == 1:\\n a += binomial( n+1, (n+1)//2 )\\n if n % 3 == 0:\\n a += 2 * binomial( 2*n//3, n//3 )\\n return a // (n+3)\\n # the formula is taken from Bastian, Prellberg, Rubey, Stump\\n elif self.is_affine():\\n i,j = self._bi_rank\\n i = ZZ(i)\\n j = ZZ(j)\\n n = i+j\\n f = Euler_Phi()\\n if i == j:\\n return ( binomial( 2*i,i ) +\\n sum( f(k) * binomial(2*i//k,i//k)**2\\n for k in [k for k in i.divisors()\\n if k in j.divisors()] ) // n ) // 4\\n else:\\n return sum( f(k) * binomial(2*i//k,i//k) *\\n binomial(2*j//k,j//k)\\n for k in [k for k in i.divisors()\\n if k in j.divisors()] ) // ( 2 * n )\\n\\n # types B and C (finite and affine)\\n elif self._letter in ['B', 'C']:\\n # this formula is proven but nowhere published correctness\\n # is clear enough that I don't think a warning is needed\\n if self.is_finite():\\n n = self._rank\\n return binomial(2 * n, n) // (n + 1)\\n\\n elif self._letter in ['BB','CC']:\\n # these two formulas are not yet proven\\n print(Warning(\\\"Warning: This method uses a formula \\\"\\n \\\"which has not been proved correct.\\\"))\\n if self.is_affine():\\n if self._twist == 1:\\n n = self._rank - 1\\n if n%2==1:\\n return binomial( 2*n-1, n-1 )\\n else:\\n return binomial( 2*n-1, n-1 ) + binomial( n-1, n//2 -1 )\\n\\n # type BC (affine)\\n elif self._letter == 'BC':\\n # this formula is not yet proven\\n print(Warning(\\\"Warning: This method uses a formula \\\"\\n \\\"which has not been proved correct.\\\"))\\n if self.is_affine():\\n if self._twist == 1:\\n n = self._rank - 1\\n return binomial( 2*n, n )\\n\\n # types BD and CD (affine)\\n elif self._letter in ['BD','CD']:\\n # this formula is not yet proven\\n print(Warning(\\\"Warning: This method uses a formula \\\"\\n \\\"which has not been proved correct.\\\"))\\n if self.is_affine():\\n if self._twist == 1:\\n n = self._rank - 2\\n return 2*binomial( 2*n, n )\\n\\n # type D (finite and affine)\\n elif self._letter == 'D':\\n # the formula is taken from Bastian, Prellberg, Rubey, Stump\\n if self.is_finite():\\n if self._rank == 4:\\n return 6\\n else:\\n f = Euler_Phi()\\n n = ZZ(self._rank)\\n return sum( f( n//k ) * binomial( 2*k, k )\\n for k in n.divisors() ) // (2*n)\\n # this formula is not yet proven\\n elif self.is_affine():\\n n = self._rank - 3\\n if n == 2:\\n return 9\\n else:\\n print(Warning (\\\"Warning: This method uses a formula \\\"\\n \\\"which has not been proved correct.\\\"))\\n if n%2==1:\\n return 2*binomial(2*n,n)\\n else:\\n return 2*binomial(2*n,n) + binomial(n, n//2)\\n\\n # the exceptional types are hard-coded\\n # type E (finite, affine and elliptic)\\n elif self._letter == 'E':\\n if self.is_finite():\\n if self._rank == 6:\\n return 67\\n elif self._rank == 7:\\n return 416\\n elif self._rank == 8:\\n return 1574\\n elif self.is_affine():\\n if self._rank == 7:\\n return 132\\n elif self._rank == 8:\\n return 1080\\n elif self._rank == 9:\\n return 7560\\n elif self.is_elliptic():\\n if self._rank == 8:\\n return 49\\n elif self._rank == 9:\\n return 506\\n elif self._rank == 10:\\n return 5739\\n\\n # type F\\n elif self._letter == 'F':\\n if self.is_finite():\\n return 15\\n elif self.is_affine():\\n return 60\\n elif self.is_elliptic():\\n if self._twist == [1,2]:\\n return 90\\n if self._twist == [1,1] or self._twist == [2,2]:\\n return 35\\n\\n # type G\\n elif self._letter == 'G':\\n if self.is_finite():\\n return 2\\n elif self.is_affine():\\n return 6\\n elif self.is_elliptic():\\n if self._twist == [1,3]:\\n return 7\\n if self._twist == [1,1] or self._twist == [3,3]:\\n return 2\\n\\n # type X\\n elif self._letter == 'X':\\n if self._rank == 6:\\n return 5\\n elif self._rank == 7:\\n return 2\\n\\n # otherwise the size is returned to be unknown\\n else:\\n print(\\\"Size unknown\\\")\\n return NotImplemented\",\n \"def gen_primes(N):\\n primes = set()\\n for n in range(2, N):\\n if all(n % p > 0 for p in primes):\\n primes.add(n)\\n yield n\",\n \"def non_maxima_suppression(boxes, probs, classes_num, thr=0.2):\\n for i, box in enumerate(boxes):\\n if probs[i] == 0:\\n continue\\n for j in range(i+1, len(boxes)):\\n if classes_num[i] == classes_num[j] and iou(box, boxes[j]) > thr:\\n probs[j] = 0.0\\n\\n return probs\",\n \"def factors(n, primes):\\n\\n for p in takewhile(lambda p: p*p < n, primes):\\n exponent = 0\\n\\n while n % p == 0:\\n exponent += 1\\n n /= p\\n\\n if exponent > 0:\\n yield p, exponent\\n\\n if n > 1:\\n yield n, 1\",\n \"def set_priors(self,alpha):\\n\\n\\t\\tassert type(alpha) == float\\n\\t\\tself.alpha = alpha\",\n \"def start_prime_test():\",\n \"def return_class_probas(pnode, pY):\\n\\n nof_objects = pY.shape[0]\\n nof_classes = pY.shape[1]\\n class_probas = numpy.zeros(nof_classes)\\n\\n for i in range(nof_objects):\\n class_probas += pnode[i] * pY[i, :]\\n\\n # class_probas = class_probas/numpy.sum(pnode)\\n class_probas = class_probas / len(pnode)\\n # class_probas = pY\\n\\n return class_probas\",\n \"def __init__(self) :\\n self.probabilities_ = None\",\n \"def __init__(self) :\\n self.probabilities_ = None\",\n \"def __init__(self) :\\n self.probabilities_ = None\",\n \"def get_num_classes(self):\",\n \"def get_prime(self):\\n return self.prime\",\n \"def primes(n):\\n primfac = {}\\n primfac = defaultdict(lambda: 0, primfac)\\n while (n % 2) == 0:\\n primfac[2] += 1 \\n n //= 2\\n d = 3\\n while d*d <= n:\\n while (n % d) == 0:\\n primfac[d] += 1 # supposing you want multiple factors repeated\\n n //= d\\n d += 2\\n if n > 1:\\n primfac[n] = 1\\n return primfac\",\n \"def calculate_class_apriori_probability(self, class_name):\\n unique, counts = np.unique(self.class_data, return_counts=True)\\n frequency_dict = dict(zip(unique, counts))\\n return float(frequency_dict[class_name])/len(self.class_data)\",\n \"def __init__(self, count):\\n assert count >= 0\\n self.is_proportion = count < 1.0\\n self.cutoff = count\",\n \"def classes(self):\\n #print \\\"making classes again!\\\"\\n l = []\\n for p in self.marks:\\n l.append(psi_class(self,p))\\n for d in range(1, self.dimension + 1):\\n l.append(kappa_class(self,d))\\n for i in range(1, self.genus+1):\\n l.append(chern_char(self, 2*i-1))\\n if True:#self.genus != 0:\\n l.append(irreducible_boundary(self))\\n marks = set(self.marks)\\n reducible_boundaries = []\\n if self.n != 0:\\n first_mark_list = [marks.pop()] \\n for g1 in range(0, self.genus + 1):\\n for p in subsets(marks):\\n r_marks = set(first_mark_list + p)\\n if 3*g1 - 3 + len(r_marks) + 1 >= 0 and 3*(self.genus-g1) - 3 + self.n - len(r_marks) + 1 >= 0:\\n reducible_boundaries.append( reducible_boundary(self, Mgn(g1, r_marks)) )\\n \\n reducible_boundaries.sort(key = lambda b: sorted(list(b.component1.marks)))\\n reducible_boundaries.sort(key = lambda b: len(b.component1.marks))\\n reducible_boundaries.sort(key = lambda b: b.component1.genus)\\n \\n else: #self.n == 0\\n for g1 in range(1, floor(self.genus/2.0)+1):\\n reducible_boundaries.append(reducible_boundary(self, Mgn(g1, []))) \\n \\n \\n l += reducible_boundaries \\n \\n for i in range(1,self.genus+1):\\n l.append(lambda_class(self,i))\\n return l\",\n \"def setpriPridict(cls, instcls, stage, pri):\\n if not any(pridict):\\n cls.initpridict()\\n try:\\n pridict[instcls][stage] = pri\\n except AttributeError as err:\\n print(\\\"Err\\\", err)\\n return 0\\n return pridict[instcls][stage]\",\n \"def solution(resources, args):\\n largest_prime_factor = 1\\n number = args.number\\n prime_generator = primes.get_prime_generator()\\n\\n while number > 1:\\n prime = next(prime_generator)\\n if number % prime == 0:\\n number /= prime\\n largest_prime_factor = prime\\n\\n if largest_prime_factor == 1:\\n largest_prime_factor = args.number\\n\\n return largest_prime_factor\",\n \"def __init__(self, N, S, students, leaders):\\n self.N = N\\n self.S = S\\n self.G = int(math.ceil(N/S))\\n self.partitions = []\\n self.students = students\\n self.leaders = leaders\",\n \"def primal_problem(\\n states: list[np.ndarray], probs: list[float] = None, dist_method=\\\"min-error\\\"\\n) -> float:\\n dim_x, _ = states[0].shape\\n\\n obj_func = []\\n meas = []\\n constraints = []\\n\\n dim = int(np.log2(dim_x))\\n dim_list = [2] * int(np.log2(dim_x))\\n\\n sys_list = list(range(1, dim, 2))\\n\\n # Unambiguous consists of k + 1 operators, where the outcome of the k+1^st corresponds to the\\n # inconclusive answer.\\n if dist_method == \\\"unambiguous\\\":\\n for i in range(len(states) + 1):\\n meas.append(cvxpy.Variable((dim_x, dim_x), PSD=True))\\n constraints.append(partial_transpose(meas[i], sys_list, dim_list) >> 0)\\n\\n for i, _ in enumerate(states):\\n for j, _ in enumerate(states):\\n if i != j:\\n constraints.append(probs[j] * cvxpy.trace(states[j].conj().T @ meas[i]) == 0)\\n\\n # Minimize error of distinguishing via PPT measurements.\\n elif dist_method == \\\"min-error\\\":\\n for i, _ in enumerate(states):\\n meas.append(cvxpy.Variable((dim_x, dim_x), PSD=True))\\n constraints.append(partial_transpose(meas[i], sys_list, dim_list) >> 0)\\n\\n for i, _ in enumerate(states):\\n obj_func.append(probs[i] * cvxpy.trace(states[i].conj().T @ meas[i]))\\n\\n constraints.append(sum(meas) == np.identity(dim_x))\\n\\n objective = cvxpy.Maximize(sum(obj_func))\\n problem = cvxpy.Problem(objective, constraints)\\n sol_default = problem.solve()\\n\\n return sol_default\",\n \"def is_prime(self):\\n pass\",\n \"def prob4():\\n#raise NotImplementedError(\\\"Problem 4 Incomplete\\\")\\n h = lambda x : x[0] < -1 and x[1] > 1\\n f = lambda x : stats.multivariate_normal.pdf(x,mean=np.array([0,0]),cov=np.eye(2))\\n g = lambda x : stats.multivariate_normal.pdf(x,mean=np.array([-1,1]),cov=np.eye(2))\\n X = np.random.multivariate_normal(mean=np.array([-1,1]),cov=np.eye(2),size=10000)\\n return 1./10000*np.sum(np.apply_along_axis(h,1,X)*np.apply_along_axis(f,1,X)/np.apply_along_axis(g,1,X))\",\n \"def gini(self, rows):\\n counts = self.class_counts(rows)\\n impurity = 1\\n for lbl in counts:\\n prob_of_lbl = counts[lbl] / float(len(rows))\\n impurity -= prob_of_lbl**2\\n return impurity\",\n \"def _calc_train_class_prb(self, labels_list=None):\\n if not labels_list:\\n return {}\\n\\n n = len(labels_list)\\n label_num = len(self.labels)\\n prb = {}\\n for l in self.labels:\\n # tmp = (l, sum(1 if v == l else 0 for k, v in train_data)/n)\\n prb[l] = (labels_list.count(l) + 1.0) / (n + label_num)\\n return prb\",\n \"def probs(self) -> List:\\n return self._probs\",\n \"def classify_proba(self, X):\\n return self._expectation(X)\",\n \"def __init__(self, prim):\\n self.actual = prim\",\n \"def __init__(self, n, e):\\n\\t\\tself.known_primes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,\\n\\t\\t\\t103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,\\n\\t\\t\\t199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,\\n\\t\\t\\t313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,\\n\\t\\t\\t433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,\\n\\t\\t\\t563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,\\n\\t\\t\\t673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,\\n\\t\\t\\t811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,\\n\\t\\t\\t941,947,953,967,971,977,983,991,997,1009,1013,1019,1021,1031,1033,1039,1049,\\n\\t\\t\\t1051,1061,1063,1069,1087,1091,1093,1097,1103,1109,1117,1123,1129,1151,1153,\\n\\t\\t\\t1163,1171,1181,1187,1193,1201,1213,1217,1223,1229,1231,1237,1249,1259,1277,\\n\\t\\t\\t1279,1283,1289,1291,1297,1301,1303,1307,1319,1321,1327,1361,1367,1373,1381,\\n\\t\\t\\t1399,1409,1423,1427,1429,1433,1439,1447,1451,1453,1459,1471,1481,1483,1487,\\n\\t\\t\\t1489,1493,1499,1511,1523,1531,1543,1549,1553,1559,1567,1571,1579,1583,1597,\\n\\t\\t\\t1601,1607,1609,1613,1619,1621,1627,1637,1657,1663,1667,1669,1693,1697,1699,\\n\\t\\t\\t1709,1721,1723,1733,1741,1747,1753,1759,1777,1783,1787,1789,1801,1811,1823,\\n\\t\\t\\t1831,1847,1861,1867,1871,1873,1877,1879,1889,1901,1907,1913,1931,1933,1949,\\n\\t\\t\\t1951,1973,1979,1987,1993,1997,1999,2003,2011,2017,2027,2029,2039,2053,2063]\\n\\t\\tself.hidden_primes_product = n\\n\\t\\tself.public_key = e\\n\\t\\tself.private_key = None\",\n \"def classifier(x):\\n return x[0] - x[1] + 4 < 0\",\n \"def primes():\\n yield 2\\n found = []\\n for i in itertools.count(start=3, step=2):\\n for p in found:\\n if i % p == 0:\\n break\\n else:\\n yield i\\n found.append(i)\",\n \"def getPrimeFactors(num):\\n n = num\\n primes = {}\\n\\n p = 2\\n sqrt = math.sqrt(num)\\n\\n def checkAndUpdate(inc):\\n nonlocal n\\n nonlocal p\\n nonlocal primes\\n if n % p == 0:\\n if str(p) in primes.keys():\\n primes[str(p)] += 1\\n else:\\n primes[str(p)] = 1\\n n /= p\\n else:\\n p += inc\\n \\n while p == 2 and p <= n:\\n checkAndUpdate(1)\\n while p <= n and p <= sqrt:\\n checkAndUpdate(2)\\n if len(primes.keys()) == 0:\\n primes[str(num)] = 1\\n elif n != 1:\\n primes[str(n)] = 1\\n return primes\",\n \"def classify(cls, i):\\r\\n sums = [0,0]\\r\\n sums[int(WekaClassifier_0.classify(i))] += 1.2134644010075073\\r\\n sums[int(WekaClassifier_1.classify(i))] += 0.57177685574344\\r\\n sums[int(WekaClassifier_2.classify(i))] += 0.40154496884580815\\r\\n sums[int(WekaClassifier_3.classify(i))] += 0.35999934750119333\\r\\n sums[int(WekaClassifier_4.classify(i))] += 0.36937329276984643\\r\\n sums[int(WekaClassifier_5.classify(i))] += 0.16351990613377496\\r\\n sums[int(WekaClassifier_6.classify(i))] += 0.1396078832952814\\r\\n sums[int(WekaClassifier_7.classify(i))] += 0.15882943193304253\\r\\n sums[int(WekaClassifier_8.classify(i))] += 0.1284505298097081\\r\\n sums[int(WekaClassifier_9.classify(i))] += 0.09903161346969916\\r\\n sums[int(WekaClassifier_10.classify(i))] += 0.19672733155497407\\r\\n sums[int(WekaClassifier_11.classify(i))] += 0.17672847093616786\\r\\n sums[int(WekaClassifier_12.classify(i))] += 0.18729151620386228\\r\\n sums[int(WekaClassifier_13.classify(i))] += 0.24810462685136855\\r\\n sums[int(WekaClassifier_14.classify(i))] += 0.23706555932983922\\r\\n sums[int(WekaClassifier_15.classify(i))] += 0.14276017880034322\\r\\n sums[int(WekaClassifier_16.classify(i))] += 0.2655207144416779\\r\\n sums[int(WekaClassifier_17.classify(i))] += 0.24759035974335297\\r\\n sums[int(WekaClassifier_18.classify(i))] += 0.14255881855351965\\r\\n sums[int(WekaClassifier_19.classify(i))] += 0.1181101393342422 \\r\\n return float(sums[0] - sums[1])\",\n \"def classify(self, instance):\\n numerator = 0\\n denominator = 0\\n for training_instance in self.training_data:\\n h_value = self._h_function(instance, training_instance[0])\\n numerator = numerator + h_value*training_instance[1]\\n denominator = denominator + h_value\\n return numerator/denominator\",\n \"def init_probability_dict(self):\\n for x in xrange(0,10):\\n self.class_probabilities[x] = self.init_probability_2d()\",\n \"def factor_in_multiple_professors(self):\\n professors = [professor for professor in self.course.professors if professor.lower() != \\\"none\\\"]\\n number_professors = len(set(professors))\\n if number_professors > 1:\\n self.score = self.score + number_professors\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66456854","0.6316928","0.6273953","0.60905004","0.6055876","0.60154176","0.5993265","0.59645927","0.59377426","0.5896327","0.58948433","0.58720356","0.58248436","0.5820803","0.58123535","0.5798083","0.57771003","0.5732761","0.5723448","0.57202864","0.5715706","0.5703063","0.56836087","0.5680424","0.5671575","0.56651324","0.5663909","0.56608474","0.56446904","0.5637236","0.5617636","0.56107754","0.55928665","0.55895376","0.5584581","0.55804324","0.558003","0.5571902","0.55660063","0.55660063","0.55646574","0.5563585","0.5558303","0.555732","0.55518746","0.55453765","0.55426174","0.55395937","0.5531384","0.5530471","0.5526897","0.55211365","0.55190337","0.5517503","0.55029136","0.5498567","0.54968536","0.5494666","0.5491102","0.5487706","0.5476384","0.54709655","0.54648423","0.54599553","0.54599553","0.5453153","0.54331565","0.54284537","0.54120564","0.5408297","0.54081017","0.5401262","0.54005796","0.54005796","0.54005796","0.539656","0.53965586","0.5394005","0.53828895","0.53787965","0.5373641","0.53709143","0.5368248","0.5368218","0.53597236","0.53572786","0.5355978","0.5345065","0.5343879","0.5341475","0.53407586","0.53341544","0.5326323","0.5320414","0.5312234","0.5311984","0.5311955","0.53067887","0.5300547","0.5292743"],"string":"[\n \"0.66456854\",\n \"0.6316928\",\n \"0.6273953\",\n \"0.60905004\",\n \"0.6055876\",\n \"0.60154176\",\n \"0.5993265\",\n \"0.59645927\",\n \"0.59377426\",\n \"0.5896327\",\n \"0.58948433\",\n \"0.58720356\",\n \"0.58248436\",\n \"0.5820803\",\n \"0.58123535\",\n \"0.5798083\",\n \"0.57771003\",\n \"0.5732761\",\n \"0.5723448\",\n \"0.57202864\",\n \"0.5715706\",\n \"0.5703063\",\n \"0.56836087\",\n \"0.5680424\",\n \"0.5671575\",\n \"0.56651324\",\n \"0.5663909\",\n \"0.56608474\",\n \"0.56446904\",\n \"0.5637236\",\n \"0.5617636\",\n \"0.56107754\",\n \"0.55928665\",\n \"0.55895376\",\n \"0.5584581\",\n \"0.55804324\",\n \"0.558003\",\n \"0.5571902\",\n \"0.55660063\",\n \"0.55660063\",\n \"0.55646574\",\n \"0.5563585\",\n \"0.5558303\",\n \"0.555732\",\n \"0.55518746\",\n \"0.55453765\",\n \"0.55426174\",\n \"0.55395937\",\n \"0.5531384\",\n \"0.5530471\",\n \"0.5526897\",\n \"0.55211365\",\n \"0.55190337\",\n \"0.5517503\",\n \"0.55029136\",\n \"0.5498567\",\n \"0.54968536\",\n \"0.5494666\",\n \"0.5491102\",\n \"0.5487706\",\n \"0.5476384\",\n \"0.54709655\",\n \"0.54648423\",\n \"0.54599553\",\n \"0.54599553\",\n \"0.5453153\",\n \"0.54331565\",\n \"0.54284537\",\n \"0.54120564\",\n \"0.5408297\",\n \"0.54081017\",\n \"0.5401262\",\n \"0.54005796\",\n \"0.54005796\",\n \"0.54005796\",\n \"0.539656\",\n \"0.53965586\",\n \"0.5394005\",\n \"0.53828895\",\n \"0.53787965\",\n \"0.5373641\",\n \"0.53709143\",\n \"0.5368248\",\n \"0.5368218\",\n \"0.53597236\",\n \"0.53572786\",\n \"0.5355978\",\n \"0.5345065\",\n \"0.5343879\",\n \"0.5341475\",\n \"0.53407586\",\n \"0.53341544\",\n \"0.5326323\",\n \"0.5320414\",\n \"0.5312234\",\n \"0.5311984\",\n \"0.5311955\",\n \"0.53067887\",\n \"0.5300547\",\n \"0.5292743\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.699718"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":8199,"cells":{"query":{"kind":"string","value":"Calculate the likelihoods for multinomial"},"document":{"kind":"string","value":"def calculate_likelihoods_multinomial(data, labels, vocab):\r\n likelihoods = {}\r\n counts = {}\r\n words = {}\r\n classes = set(labels)\r\n vocabLen = len(vocab)\r\n for cls in classes:\r\n # Initialize\r\n counts[cls] = {}\r\n words[cls] = 0\r\n # Perform counts\r\n line = 0\r\n for doc in data:\r\n cls = labels[line]\r\n wordCounts = counts[cls]\r\n for (word, count) in doc:\r\n if word not in wordCounts:\r\n wordCounts[word] = 0\r\n wordCounts[word] += count\r\n words[cls] += count\r\n line += 1\r\n # Compute likliehoods\r\n for cls in counts:\r\n wordCounts = counts[cls]\r\n likelihoods[cls] = {}\r\n wordsInClass = words[cls]\r\n for word in wordCounts:\r\n likelihoods[cls][word] = laplace_smooth(wordCounts[word], wordsInClass, vocabLen)\r\n # Add all training words:\r\n for word in vocab:\r\n if word not in likelihoods[cls]:\r\n likelihoods[cls][word] = laplace_smooth(0, wordsInClass, vocabLen)\r\n # Special laplace smoothing for words not found in training data\r\n likelihoods[cls][None] = laplace_smooth(0, wordsInClass, vocabLen)\r\n return likelihoods"},"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 multinomial_likelihood(m_true, alpha, alpha0, m_probs):\n\n ll = tf.reduce_sum(input_tensor=m_true * (tf.math.log(alpha0) - tf.math.log(alpha)), axis=1, keepdims=True)\n ll = tf.reduce_mean(input_tensor=ll)\n return ll","def multinomial_nll(true_counts, logits):\n counts_per_example = tf.reduce_sum(true_counts, axis=-1)\n dist = tfp.distributions.Multinomial(total_count=counts_per_example,\n logits=logits)\n return (-tf.reduce_sum(dist.log_prob(true_counts)) / \n tf.cast(tf.shape(true_counts)[0], dtype=tf.float32))","def log_multinomial_coefficient(n, x):\n return gammaln(n + 1) - gammaln(x + 1).sum()","def calculate_log_p_multinomial(self, n_counts, nbins, batch_size):\n\n n_counts = tf.cast(n_counts, tf.float32)\n nbins = tf.cast(nbins, tf.float32)\n batch_size = tf.cast(batch_size, tf.float32)\n\n term_a = tf.lgamma(batch_size + 1)\n term_b = tf.reduce_sum(tf.lgamma(n_counts + 1))\n term_c = batch_size * tf.log(nbins)\n\n return term_a - term_b - term_c","def log_marginal_likelihood(X_train,y_train,phi,tau=1.,Ve=1.e-10):","def _compute_likelihood(self, mus, pmfs):\n expected_counts = pmfs.copy()\n for mu, _p_bin_source in zip(mus, expected_counts):\n _p_bin_source *= mu # Works because of numpy view magic...\n expected_total = np.sum(expected_counts, axis=0)\n\n observed_counts = self.data_events_per_bin.histogram\n\n ret = observed_counts * np.log(expected_total) - expected_total - gammaln(observed_counts + 1.).real\n return np.sum(ret)","def likelihood(params,data):\n spec, isnflux, igalflux = data\n chi2=0\n modflux = (params[0]*isnflux + params[1]*igalflux)\n chi2 += sum((spec.flux - modflux)**2)/((0.05*sum(spec.var)**2)/2.0)\n return np.exp(-chi2/2.0)","def likelihood(self):\n \n raise NotImplementedError()","def likelihood_prediction():\n # Get info\n selected_word = prompt_tech_selection()\n article_json = get_json_from_file()\n\n # Calculate results\n total_word_counter, selected_word_counter = count_occurrences(article_json, selected_word)\n probability = selected_word_counter / total_word_counter\n total_time = article_json[-1]['time'] - article_json[0]['time'] # unix subtraction = seconds\n months_in_train_set = total_time / SECONDS_IN_MONTH\n expected_posts_per_month = int(total_word_counter / months_in_train_set)\n\n # Show results\n print_text_results(expected_posts_per_month, probability, selected_word)\n plot_likelihood(expected_posts_per_month, probability)","def regularized_multinomial_likelihood(m_true, alpha, alpha0, m_probs, global_step, annealing_step=1000, max_lambda=1.0):\n\n ll = multinomial_likelihood(m_true, alpha, alpha0, m_probs)\n kl = kullback_leibler_dirichlet(m_true, alpha)\n lamb = tf.cast(tf.minimum(max_lambda, global_step / annealing_step), dtype=tf.float32)\n loss = ll + lamb * kl\n return loss","def likelihood(self, data, hypo):\n tagged, n, k = data\n if hypo < tagged + n - k:\n return 0\n\n p = tagged / hypo\n like = thinkbayes.eval_binomial_pmf(k, n, p)\n return like","def log_likelihood(data, probs):\n # Assume data is given as counts\n return _np.sum([nlogp(n, p) for n, p in zip(data, probs) if n > 0])","def multinomial_prob(counts, probs):\n return nCkarray(*counts.values) * (probs ** counts).prod()","def GSM_log_likelihood(X, model):\n D, M = X.shape\n k = model.mix.shape[0]\n log_likelihood = 0\n for i in range(M):\n logpdf_X = 0\n for j in range(k):\n mvn = multivariate_normal(cov=model.cov[j, :])\n logpdf_X = mvn.logpdf(x=X[:, i]) * model.mix[j]\n log_likelihood += logpdf_X\n return log_likelihood","def calculate_likelihoods_bernoulli(data, labels, vocab):\r\n classes = set(labels)\r\n likelihoods = {}\r\n # Calculate likelihood for each class\r\n for cls in classes:\r\n documentsInClass = [set(map(lambda y: y[0], data[x])) for x in range(len(data)) if labels[x] == cls]\r\n numDocsInClass = len(documentsInClass)\r\n results = {}\r\n for word in vocab:\r\n numDocsWithWordInClass = len(filter(lambda x: word in x, documentsInClass))\r\n # Binary variable-- either present or not present\r\n results[word] = laplace_smooth(numDocsWithWordInClass, numDocsInClass, 2)\r\n # Special laplace smoothing for words not found in training data\r\n results[None] = laplace_smooth(0, numDocsInClass, 2)\r\n likelihoods[cls] = results\r\n return likelihoods","def multinomial(rng, logits, num_samples):\n # NOTE(tycai): Currently, tf.multinomial uses CDF for non-XLA CPU only.\n # We may want to switch to the Gumbel trick as used in XLA.\n if len(logits.shape) > 2 or not logits.shape:\n raise ValueError(\"Logits must be rank-1 or rank-2.\")\n probs = jax.nn.softmax(logits)\n probs = jnp.cumsum(probs, axis=-1)\n # Special-case num_samples == 1 due to TPU padding, as in TF2XLA.\n # https://github.com/tensorflow/tensorflow/blob/b1608511d5a50d05825c4025b0c347e8689a241f/tensorflow/compiler/tf2xla/kernels/categorical_op.cc#L79\n if num_samples == 1:\n a = jax.random.uniform(rng, logits.shape[:-1] + (1,))\n out = jnp.argmin(a > probs, axis=-1)\n return out[..., None]\n else:\n a = jax.random.uniform(rng, (num_samples,) + logits.shape[:-1] + (1,))\n out = jnp.argmin(a > probs, axis=-1)\n return jnp.transpose(out)","def log_likelihood(X, Z, variable_types):\n\tk = Z['pi_unconstrained'].shape[1]+1 # the number of mixture components\n\t## We gather the log probabilities of each indiv in batch for each mixture component into\n\t## a matrix of size (B x k), where B is the batch size.\n\tlogps = torch.zeros([len(X), k])\n\t## First insert the mixture weight contribution to the array\n\tlogps += logsoftmax(Z['pi_unconstrained'], dim=-1)\n\t## Next loop over the features and sum the contributions to logps\n\tfor i, (key, z) in enumerate(Z.items()):\n\t\tif key not in ['pi_unconstrained']:\n\t\t\tdata = torch.Tensor(X[key].values).unsqueeze(-1)\n\t\t\tdist = variable_types[key]\n\t\t\tif dist == 'Categorical':\n\t\t\t\talpha = softmax(z, dim=-1, additional=-50.)\n\t\t\t\tlogps += Categorical(probs = alpha).log_prob(data)\n\t\t\telif dist == 'Bernoulli':\n\t\t\t\ttheta = z\n\t\t\t\tlogps += Bernoulli(logits = theta).log_prob(data)\n\t\t\telif dist == 'Beta':\n\t\t\t\talpha, beta = torch.exp(z).transpose(0,1)\n\t\t\t\tlogps += Beta(alpha, beta).log_prob(data)\n\t## Compute logsumexp over the mixture components and return the sum over data elements.\n\tlogp = torch.logsumexp(logps, dim=-1)\n\treturn logp.sum()","def calculateLogJointProbabilities(self, datum):\n\tlogJoint = util.Counter()\n\t#want to calculate log(P(y)) + log(sum(P(fi|y)))\n\t#where y is a label\n\tfor label in self.legalLabels:\n\t\tlogJoint[label] = math.log(self.prior_distribution_prob[label])\n\t\tfor feature, value in datum.items():\n\t\t\tcp = self.conditional_prob[label][feature][value]\n\t\t\tif cp > 0: #condition check for values < 0 because log(0) is undefined and math domain error occurs\n\t\t\t\tlogJoint[label] += math.log(cp) #summing up\n\t\t\t\t\n\treturn logJoint","def get_log_likelihood(phi, pred, t, dot_product, weight, reg= 1):\n prior = -0.5* np.sum(np.multiply(weight, weight))\n likelihood = np.multiply(t, np.log(pred+TOLERANCE)) + np.multiply(1.0- t, np.log(1.0-pred+TOLERANCE))\n likelihood = np.sum(likelihood)\n\n return prior + likelihood","def likelihoods(self, alleles):\n\n models = self.models_dict[len(alleles)]\n\n F = self.joint_frequencies_combo(alleles)\n\n ### BPH ###\n (((A0, A1),((B0,),)),) = models['BPH'][1].items()\n\n BPH = (A0 / A1) * F[B0]\n\n\n BPH += sum( sum(F[B0] * F[B1] for (B0, B1) in C) * A0 / A1\n for (A0, A1), C in models['BPH'][2].items())\n\n if len(alleles)>2:\n BPH += sum( sum(F[B0] * sum( F[B1] * F[B2] for (B1, B2) in C[B0]) for B0 in C) * A0 / A1\n for (A0, A1), C in models['BPH'][3].items())\n\n ### SPH ###\n (((A0, A1),((B0,),)),) = models['SPH'][1].items()\n SPH = (A0 / A1) * F[B0]\n\n SPH += sum( sum(F[B0] * F[B1] for (B0, B1) in C) * A0 / A1\n for (A0, A1), C in models['SPH'][2].items())\n\n ### DIPLOIDY ###\n (((A0, A1),((B0,),)),) = models['DISOMY'][1].items()\n DISOMY = (A0 / A1) * F[B0]\n\n DISOMY += sum( sum( F[B0] * F[B1] for (B0, B1) in C) * A0 / A1\n for (A0, A1), C in models['DISOMY'][2].items())\n\n ### MONOSOMY ###\n ((B0,),) = models['MONOSOMY'][1][(1,1)]\n MONOSOMY = F[B0]\n\n result = likelihoods_tuple(MONOSOMY, DISOMY, SPH, BPH)\n return result","def calculateLogJointProbabilities(self, datum):\n logJoint = util.Counter()\n \n \"*** YOUR CODE HERE ***\"\n \n # -- OUR CODE HERE\n \n \n import math\n for label in self.legalLabels:\n sumThing = 0.0\n for pixel in self.conditionalProb[label]:\n if datum[pixel] is 1:\n #assert self.conditionalProb[label][pixel] < 1.0 # -- sanity check that the probability is valid\n sumThing += math.log((self.conditionalProb[label][pixel]*1.0))\n else:\n sumThing+=math.log(1-self.conditionalProb[label][pixel]*1.0)\n logJoint[label] = math.log(self.prior[label]*1.0) + sumThing*1.0\n \n\n \n \n import time\n #print \"logJoint is :: \", logJoint\n #time.sleep(2)\n \n \n # -- uses the conditional probability tables computed in the current iteration\n # -- in train and tune\n \n return logJoint","def calculateLogJointProbabilities(self, datum):\n logJoint = util.Counter()\n \"*** YOUR CODE HERE ***\"\n\t#Adds log(P(y)) to calculate P(y|f1,f2...)\n for label in self.legalLabels:\n\t\tlogJoint[label] += math.log(self.prior[label])\n\t#Adds log(P(f1|y)), log(P(f2|y))... to calculate P(y|f1, f2...)\n for key in datum:\n\t\t#if key == (7, 3):\n\t\t\t#print self.condprobs[key, 0]\n\t\tfor label in self.legalLabels:\n\t\t\t#print str(key) + str(datum[key])\n\t\t\tlogJoint[label] += math.log(self.condprobs[key, label][datum[key]])\n return logJoint","def _learn_global_mixture_weights(alpha, multinomials, val_data, num_em_iter=100, tol=0.001):\n num_comp = len(multinomials)\n if np.any(alpha <= 1):\n raise ValueError('alpha values have to be bigger than 1')\n\n for i, mult in enumerate(multinomials):\n if np.any(np.abs(np.sum(mult, axis=1) - 1) > 0.001):\n raise ValueError('component %d param is not a proper multinomial -- all rows must sum to 1' % i)\n\n if type(alpha) == float or type(alpha) == int:\n alpha = np.ones(num_comp) * alpha * 1.\n\n # Creating responsibility matrix and initializing it hard assignment on random\n log_like_tracker = [-np.inf]\n pi = np.ones(num_comp) / num_comp\n start = time.time()\n em_iter = 0\n for em_iter in xrange(1, num_em_iter + 1):\n # Evey 5 iteration we will compute the posterior log probability to see if we converged.\n if em_iter % 2 == 0:\n\n event_prob = _data_prob(pi, multinomials, val_data)\n event_prob = np.sum(event_prob, axis=0) # prob\n\n # The data likelihood was computed for each location, but it should be in the power of the number\n # of observations there, or a product in the log space.\n data_likelihood = np.log(np.array(event_prob)) * val_data[:, 2]\n\n prior_probability = dirichlet.logpdf(pi, alpha=alpha)\n log_likelihood = np.sum(data_likelihood + prior_probability) / np.sum(val_data[:, 2])\n\n if np.abs(log_likelihood - log_like_tracker[-1]) < tol:\n log.debug('[iter %d] [Reached convergence.]' % em_iter)\n break\n\n log.debug('[iter %d] [Likelihood: [%.4f -> %.4f]]' % (em_iter, log_like_tracker[-1], log_likelihood))\n log_like_tracker.append(log_likelihood)\n\n # E-Step\n\n resp = _data_prob(pi, multinomials, val_data)\n\n if np.all(resp == 0):\n raise ValueError('0 mix probability')\n\n resp = np.array(resp).T\n resp = normalize(resp, 'l1', axis=1)\n\n resp = np.multiply(resp, val_data[:, 2][:, np.newaxis])\n pi = np.sum(resp, axis=0)\n pi += alpha - 1\n pi /= np.sum(pi)\n\n total_time = time.time() - start\n log.debug('Finished EM. Total time = %d secs -- %.3f per iteration' % (total_time, total_time / em_iter))\n\n data_log_like = _data_prob(pi, multinomials, val_data)\n data_log_like = np.sum(data_log_like, axis=0)\n ll = np.sum(np.log(np.array(data_log_like)) * val_data[:, 2]) / np.sum(val_data[:, 2])\n return pi, ll","def likelihood(self, w, class_words):\n return log((class_words.count(w) + 1)/(len(class_words) + self.N))","def log_prob(self):","def __calc_likelihood(self, *args):\n params = {}\n for i, p in enumerate(self._par_names):\n if self._par_islog[p]:\n params[p] = np.power(10., args[i])\n else:\n params[p] = args[i]\n return self.return_likelihood(params)","def likelihood_ratio(cls, *marginals):\n cont = cls._contingency(*marginals)\n return (cls._n *\n sum(obs * _ln(float(obs) / (exp + _SMALL) + _SMALL)\n for obs, exp in zip(cont, cls._expected_values(cont))))","def test_multinomial(self):\r\n # Check over two calls to see if the random state is correctly updated.\r\n random = RandomStreams(utt.fetch_seed())\r\n fn = function([], random.multinomial((4,4), 1, [0.1]*10), updates=random.updates())\r\n\r\n fn_val0 = fn()\r\n fn_val1 = fn()\r\n\r\n rng_seed = numpy.random.RandomState(utt.fetch_seed()).randint(2**30)\r\n rng = numpy.random.RandomState(int(rng_seed)) #int() is for 32bit\r\n numpy_val0 = rng.multinomial(1, [0.1]*10, size=(4,4))\r\n numpy_val1 = rng.multinomial(1, [0.1]*10, size=(4,4))\r\n\r\n assert numpy.all(fn_val0 == numpy_val0)\r\n assert numpy.all(fn_val1 == numpy_val1)","def _LL(state, effects, observed_frequencies) -> float:\n observed_frequencies = np.array(observed_frequencies)\n predicted_probs = np.array([np.real(np.trace(state.dot(effect))) for effect in effects])\n return sum(np.log10(predicted_probs) * observed_frequencies)","def log_likelihood(self, x):\n # set nuisance parameters to their central values!\n predictions = self.get_predictions(self.shortarray_to_array(x), nuisance=False)\n m_obj = flavio.Measurement['Pseudo-measurement for FastFit instance: ' + self.name]\n m_obs = m_obj.all_parameters\n prob_dict = m_obj.get_logprobability_all(predictions)\n ll = sum(prob_dict.values())\n return ll","def __log_likelihood(self, params, *args):\n\t\tX, y, feature_set, lambda_reg, empirical_weights, verbose, sign = args\n\n\t\tno_example = len(X)\n\t\ttotal_logZ = 0\n\t\ttotal_logProb = 0\n\t\texpected_weights = np.zeros(len(feature_set))\n\t\tfor t in range(len(X)):\n\t\t\t# example_features = X[t], example_labels = y[t]\n\n\t\t\tpotential = np.zeros(len(X[t]))\n\t\t\tfor i in range(len(X[t])):\n\t\t\t\t#candidate_features = X[t][i], candidate_label = y[t][i]\n\t\t\t\tpotential[i] = feature_set.calc_inner_product(X[t][i], params)\n\n\t\t\t#scaling\n\t\t\tpotential = potential - np.max(potential, keepdims=True)\n\n\t\t\tfor i in range(len(X[t])):\n\t\t\t\ttotal_logProb += potential[i] * y[t][i]\n\n\t\t\tpotential, Z = self.__softmax(potential)\n\n\t\t\tfor i in range(len(X[t])):\n\t\t\t\tfeature_set.calc_inner_sum(expected_weights, X[t][i], potential[i])\n\n\t\t\ttotal_logZ += log(Z)\n\n\t\t# _params = feature_set.get_regularized_params(params, 'bias')\n\t\t_params = params\n\t\tlog_likelihood = total_logProb - total_logZ - (lambda_reg/2) * np.sum(np.multiply(_params,_params))\n\t\tgradients = empirical_weights - expected_weights - lambda_reg * _params\n\n\t\tglobal SUB_ITERATION_NUM\n\t\tif verbose:\n\t\t\tsub_iteration_str = ' '\n\t\t\tif SUB_ITERATION_NUM > 0:\n\t\t\t\tsub_iteration_str = '(' + '{0:02d}'.format(SUB_ITERATION_NUM) + ')'\n\t\t\tprint(' ', '{0:03d}'.format(ITERATION_NUM), sub_iteration_str, ':', log_likelihood * sign)\n\n\t\tSUB_ITERATION_NUM += 1\n\n\t\treturn sign * log_likelihood, sign * gradients","def log_likelihood(self,samples,times):\n prior_mu = np.ones(2*len(self.A)+1) \n prior_var = np.eye(2*len(self.A)+1)*0.7\n prior_p = np.log(self.prior_pdf())\n #prior_p = np.log(self.normal_prior(prior_mu,prior_var))\n xform = [self.sum_exp(t) for t in times]\n lp = scipy.stats.norm(xform,np.sqrt(self.var)).pdf(samples)\n sample_p =np.sum(np.log(lp))\n ll = prior_p + sample_p\n\n if np.isnan(ll):\n return -np.infty\n return ll","def _build_multinomial_weights(self) -> None:\n weights_obs = ramp_up_weights(\n len(self.obs), self.tpe.full_weight_num, self.tpe.equal_weight\n )\n counts_obs = numpy.bincount(\n self.obs, minlength=len(self.choices), weights=weights_obs\n )\n counts_obs = counts_obs + self.tpe.prior_weight\n self.weights = counts_obs / counts_obs.sum()","def calculate_likelihood(self, number_of_topics):\n print(\"Start of calculate_likelihood...\")\n maxNumberOfWrd = 0\n for docValue in range(0,self.number_of_documents):\n for wordValue in range(0,self.vocabulary_size):\n maxTopicVal = 0\n for topicValue in range(0,number_of_topics):\n maxTopicVal = maxTopicVal + ((self.document_topic_prob[docValue][topicValue]*self.topic_word_prob[topicValue][wordValue]))\n if maxTopicVal > 0:\n maxNumberOfWrd = maxNumberOfWrd + (np.log(maxTopicVal) * self.term_doc_matrix[docValue][wordValue])\n\t\t#print(\"Value of maxNumberOfWrd >>> \"+maxNumberOfWrd)\n self.likelihoods.append(maxNumberOfWrd)\n\t\t#print(\"End of calculate_likelihood...\")\n return","def test_multinomial(self):\r\n # Check over two calls to see if the random state is correctly updated.\r\n m = Module()\r\n m.random = RandomStreams(utt.fetch_seed())\r\n m.fn = Method([], m.random.multinomial((20,20), 1, [0.1]*10))\r\n\r\n made = m.make()\r\n made.random.initialize()\r\n fn_val0 = made.fn()\r\n fn_val1 = made.fn()\r\n\r\n rng_seed = numpy.random.RandomState(utt.fetch_seed()).randint(2**30)\r\n rng = numpy.random.RandomState(int(rng_seed)) #int() is for 32bit\r\n numpy_val0 = rng.multinomial(1, [0.1]*10, size=(20,20))\r\n numpy_val1 = rng.multinomial(1, [0.1]*10, size=(20,20))\r\n\r\n assert numpy.all(fn_val0 == numpy_val0)\r\n assert numpy.all(fn_val1 == numpy_val1)","def evaluate_GMM_log_likelihood(model, x, y):\n y_pred = model.predict(x)\n \n num_datapoints = len(x)\n output_dim = y.shape[-1]\n num_comp = int(y_pred.shape[-1] / (3*output_dim))\n\n mix_comp_logits = y_pred[:, :num_comp]\n mus = y_pred[:, num_comp:(1+output_dim)*num_comp]\n sigmas = y_pred[:, (1+output_dim)*num_comp:]\n \n # convert logits to categorical distribution - need to itterate through all points\n mix_comp = np.zeros((num_datapoints, num_comp))\n for i in range(num_datapoints):\n mix_comp[i,:] = get_mixture_dist(mix_comp_logits[i,:], num_comp)\n \n log_likelihood = 0\n for i in range(num_comp):\n for j in range(output_dim):\n mse = -0.5*np.sum(mix_comp[:,i]*np.square((y[:,j]-mus[:,(i*output_dim)+j])/sigmas[:,(i*output_dim)+j]))\n sigma_trace = -np.sum(mix_comp[:,i]*np.log(sigmas[:,(i*output_dim)+j]))\n log2pi = -np.sum(mix_comp[:,i]*0.5*output_dim*np.log(2*np.pi))\n\n log_likelihood += mse + sigma_trace + log2pi\n \n avg_log_likelihood = np.round(log_likelihood / num_datapoints, 2)\n print(f'Log likelihood: {avg_log_likelihood}')\n return avg_log_likelihood","def compute_movie_rating_likelihood(M):\n\n # define the size to begin with\n likelihood = np.zeros((M, M))\n\n # -------------------------------------------------------------------------\n # YOUR CODE GOES HERE FOR PART (c)\n #\n # Remember to normalize the likelihood, so that each column is a\n # probability distribution.\n \n for i in range(M):\n for j in range(M):\n if i == j:\n likelihood[i][j] = 2\n else:\n likelihood[i][j] = 1/abs(j-i)\n \n likelihood = likelihood / likelihood.sum(axis = 1)\n \n #\n # END OF YOUR CODE FOR PART (c)\n # -------------------------------------------------------------------------\n\n return likelihood","def _compute_log_likelihood(self, X, S):\n log_likelihood = 0\n for n in range(self.n_col):\n likelihood = 1\n for k in range(self.n_components):\n likelihood *= self.weights[k] \\\n * multivariate_normal(self.means[k], self.covs[k]).pdf(X[n]) \\\n * poisson(self.rates[k]).pmf(S[n])\n log_likelihood += np.log(likelihood)\n\n return log_likelihood","def test_LM(self):\n\t\t\n\t\tprecision = 10**-8\n\t\t\t\t \n\t\tif self.n == 1:\n\t\t\t\t \n\t\t\tP_sum = sum(self.estimate_prob('', w) for w in self.vocab)\n\t\t\t\n\t\t\tassert abs(1.0 - P_sum) < precision, 'Probability mass does not sum up to one.'\n\t\t\t\t \n\t\telif self.n == 2:\n\t\t\thistories = ['the', 'in', 'at', 'blue', 'white']\n\t\t\t\t \n\t\t\tfor h in histories:\n\t\t\t\t \n\t\t\t\tP_sum = sum(self.estimate_prob(h, w) for w in self.vocab)\n\t\t\t\t\n\t\t\t\tassert abs(1.0 - P_sum) < precision, 'Probability mass does not sum up to one for history' + h\n\t\t\t\t\t \n\t\tprint('TEST SUCCESSFUL!')","def log_likelihood(mu, sigma, y, T):\n ll = 0.\n for yi, Ti in zip(y, T):\n d = yi.size\n log_det_cov = np.linalg.slogdet(sigma[Ti])[1]\n y_minus_mean = yi - mu[Ti]\n term3 = np.dot(y_minus_mean.T.ravel(),\n np.linalg.solve(sigma[Ti], y_minus_mean.T).ravel())\n ll += (-0.5 * d * np.log(2 * np.pi) - 0.5 * log_det_cov - 0.5 * term3)\n return ll","def log_likelihood_exp(self, x):\n predictions = self.get_predictions(x)\n ll = 0.\n for measurement in self.get_measurements:\n m_obj = flavio.Measurement[measurement]\n m_obs = m_obj.all_parameters\n exclude_observables = set(m_obs) - set(self.observables)\n prob_dict = m_obj.get_logprobability_all(predictions, exclude_parameters=exclude_observables)\n ll += sum(prob_dict.values())\n return ll","def MVN_log_likelihood(X, model):\n D, M = X.shape\n X_normalized = normalize_log_likelihoods(X.copy())\n mvn = multivariate_normal(mean=model.mean, cov=model.cov)\n return mvn.logpdf(X_normalized.T).sum()\n # log_2pi = D * np.log(2 * np.pi)\n # log_det = np.log(np.linalg.det(model.cov))\n # residuals = calc_residuals(X_normalized, model.mean, \"minus\")\n # mahalanobis_distance = np.dot(np.dot(residuals.T, np.linalg.inv(model.cov)), residuals)\n # return -0.5 * (log_2pi + log_det + mahalanobis_distance).sum()","def compute_likelihood(self, corpus: str, test_corpus: str, n: int):\n probs_per_ngram = self.compute_probabilities_per_word(corpus, n)\n test_corpus_tokens = self.tokenize(test_corpus, n)\n test_corpus_ngrams = ()\n end_i = len(test_corpus_tokens) - 1\n for i in range(end_i):\n if i - (n - 1) < 0:\n continue\n test_corpus_ngrams = test_corpus_ngrams + (self._make_ngrams(test_corpus_tokens, i, n), )\n likelihood_of_test_corpus = 1\n for test_corpus_ngram in test_corpus_ngrams:\n likelihood_of_test_corpus = likelihood_of_test_corpus * probs_per_ngram[test_corpus_ngram]\n return likelihood_of_test_corpus","def test_posterior_logprobs(self):\n x = list(product([True, False], repeat=2))\n xs = list(e for e in product(x, repeat=3))\n all_obs = list(o for o in xs\n if all(any(e) and not all(e) for e in o))\n total = logsumexp(list(posterior_logprobs(np.array(obs), self.S, self.A, self.E)[1]\n for obs in all_obs))\n assert_allclose(total, np.log(1))","def log_likelihood(self, data, reward_model, bias_params):","def compute_log_likelihood(self, indicators, weights, l2):\n scores, _ = self.predict_probability(self.train_feature_x, weights)\n probs = self.predict_probability(self.train_feature_x, weights)\n lp = np.sum((indicators-1)*scores + np.log(probs)) - l2* np.sum(weights[1:]**2)\n return lp","def log_likelihood(X, mu, sigma, phi):\n ll = None\n\n #######################################################################\n # TODO: #\n # Compute the log-likelihood of the data under the current model. #\n # This is used to check for convergnence of the algorithm. #\n #######################################################################\n\n ll = np.zeros((X.shape[0], 1))\n k = mu.shape[0]\n\n for i in range(k):\n ll += multivariate_normal(mu[i, :], sigma[i]).pdf(X)[:, np.newaxis]*phi[i]\n\n ll = sum(np.log(ll))\n\n #######################################################################\n # END OF YOUR CODE #\n #######################################################################\n\n return ll","def get_log_likelihood(response_probability, response):\n pass","def likelihood(self,x,params = None,**kwargs):\n return np.exp(self.log_likelihood(x,params=params,**kwargs))","def likelihood(ts,w,Phi):\n a = Phi.dot(w)\n return np.exp(a*ts)*sigmoid(-a)","def loglikelihood(self, y):\n raise NotImplementedError","def multinomial_accuracy(distribution_or_probs: tfd.Distribution,\n data: jnp.DeviceArray) -> jnp.DeviceArray:\n return jnp.mean(\n jnp.sum(multinomial_mode(distribution_or_probs) * data, axis=1))","def lnprob(theta, observables):\n prior = lnprior(theta)\n if not np.isfinite(prior):\n return -inf\n return prior + lnlike(theta, observables)","def likelihood_genotype(genotype, bases_all_reads, error_rates):\n likelihood = 1\n for observed_base in bases_all_reads:\n p = 0\n for base in \"ACGT-\":\n l = prob_t_N(genotype, base) * error_rates[base][observed_base]\n p += l\n likelihood *= p\n\n return likelihood","def test_marginal_likelihood(self):\n data = np.repeat([1, 0], [50, 50])\n marginals = []\n a_prior_0, b_prior_0 = 1.0, 1.0\n a_prior_1, b_prior_1 = 20.0, 20.0\n\n for alpha, beta in ((a_prior_0, b_prior_0), (a_prior_1, b_prior_1)):\n with pm.Model() as model:\n a = pm.Beta(\"a\", alpha, beta)\n y = pm.Bernoulli(\"y\", a, observed=data)\n trace = pm.sample_smc(2000, chains=2, return_inferencedata=False)\n # log_marginal_likelihood is found in the last value of each chain\n lml = np.mean([chain[-1] for chain in trace.report.log_marginal_likelihood])\n marginals.append(lml)\n\n # compare to the analytical result\n assert abs(np.exp(marginals[1] - marginals[0]) - 4.0) <= 1","def pmi(cls, *marginals):\n return (_log2(marginals[NGRAM] * marginals[TOTAL] ** (cls._n - 1)) -\n _log2(_product(marginals[UNIGRAMS])))","def loglikelihood(self):\n raise NotImplementedError(\"To be implemented\")","def likelihood(mean, logs, x):\n return -0.5 * (logs * 2. + ((x - mean) ** 2) / np.exp(logs * 2.) + GaussianDiag.Log2PI)","def naivebayesPXY_mle(x,y):\n pos_denom = x[y==1].sum()\n neg_denom = x[y==-1].sum()\n posprob = x[y==1].sum(axis = 0)/pos_denom\n negprob = x[y==-1].sum(axis = 0)/neg_denom\n return posprob, negprob","def log_likelihood_function(self, instance) -> float:\n return self.prior.factor(instance[0])","def calc_likelihood(par_num, par_rng):\n\n likelihoods = np.zeros(np.size(par_rng))\n\n trivial_prior = trivial_prior_class()\n\n pipe = pipeline(observables_generator=hammu12,\n likelihood=likelihood,\n prior=trivial_prior,\n optimizer_class=Hamiltonian_Monte_Carlo)\n\n parameters = [0]*hammu12.get_parameter_dimension()\n for par_val in par_rng:\n parameters[par_num] = par_val\n likelihoods[par_val-par_rng[0]] = pipe._calc_posterior(parameters)\n\n np.save('data%s_RM' % (par_num), likelihoods)","def calculate_log_perplexity(self, output, flat_labels): #completed, expensive, should be compiled\n return -np.sum(np.log2(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])","def Ls(GTn:torch.tensor, Mn:torch.tensor) -> torch.tensor:\n return (-(GTn * torch.log(Mn+1e-15) + (1- GTn) * torch.log((1- Mn)+1e-15))).sum()","def likelihood_function(X, taus, mus, sigmas):\n N = X.shape[0] # number of data points\n get_component_prob = lambda x: component_pdfs(x, mus, sigmas)\n T = np.apply_along_axis(arr=X, func1d=get_component_prob, axis=1) # gaussian component probabilities in row format (NxK)\n taus_rep = np.tile(taus, reps=(N, 1)) # repeat tau along N-axis so elementwise product can work\n\n return np.sum(T*taus_rep, axis=1)","def log_marginal(self):\n #\n # Predictive covariance of x is sum of covariance of phi a and covariance of x|a\n x_Sigma = self.phi @ self.phi.T + np.diag(self.sigma_n**2 * np.ones(self.M))\n #\n # Predictive mean is 0 by symmetry\n # so given that x is distributed as a MVN, the exact marginal is\n lp_exact = st.multivariate_normal.logpdf(self.x, cov=x_Sigma)\n #\n return lp_exact","def nll_logprobs(self, input, target_idx):\n raise NotImplementedError()","def likelihood(alphas, sigmas, mus, x):\n if len(alphas.shape) == 0:\n alphas = np.expand_dims(alphas, 1)\n sigmas = np.expand_dims(sigmas, 1)\n k = alphas.shape[0]\n t_dim = int(mus.shape[0] / k)\n\n likelihood_ = 0.0\n\n for i in range(k):\n likelihood_t = gaussian_np(x, mus[i*t_dim:(i+1)*t_dim], sigmas[i])\n likelihood_ += alphas[i] * likelihood_t\n\n return likelihood_","def eml_use_pseudowords_and_mle(xi, yi, deml):\n if xi not in deml[yi]:\n xi = pw(xi) # use pseudo-word instead\n\n return (deml[yi][xi]) / (sum(deml[yi].values()))","def likelihood(\n self,\n observation: np.ndarray,\n state: np.ndarray,\n control_z: Optional[np.ndarray] = None\n ) -> np.matrix:\n pass","def joint_logpdf(self, x1, x2 = None):\n dists = self.conditionalMVNs\n joint_pdfs = np.array([d.joint_pdf(x1, x2) for d in dists])\n return np.log(np.sum(self.weights * joint_pdfs))","def compute_prob_mle(X: np.ndarray, n: int) -> float:\n\n assert n > 1, \"for n = 1 use Bernoulli distribution.\"\n Binomial._check_input_data(X=X)\n Binomial._check_support(X=X, n=n)\n\n prob = X.mean() / n\n return prob","def test_multinomial(self):\r\n # Check over two calls to see if the random state is correctly updated.\r\n rng_R = random_state_type()\r\n post_r, out = multinomial(rng_R, (7, 3), 6, [0.2] * 5)\r\n\r\n f = compile.function(\r\n [compile.In(rng_R,\r\n value=numpy.random.RandomState(utt.fetch_seed()),\r\n update=post_r, mutable=True)],\r\n [out], accept_inplace=True)\r\n\r\n numpy_rng = numpy.random.RandomState(utt.fetch_seed())\r\n val0, = f()\r\n val1, = f()\r\n numpy_val0 = numpy_rng.multinomial(6, [0.2] * 5, (7, 3))\r\n numpy_val1 = numpy_rng.multinomial(6, [0.2] * 5, (7, 3))\r\n print val0\r\n print numpy_val0\r\n print val1\r\n print numpy_val1\r\n self.assertTrue(numpy.all(val0 == numpy_val0))\r\n self.assertTrue(numpy.all(val1 == numpy_val1))\r\n\r\n self.assertTrue(val0.shape == (7, 3, 5))\r\n self.assertTrue(val1.shape == (7, 3, 5))","def naiveBayesMixture(train_set, train_labels, dev_set, bigram_lambda,unigram_smoothing_parameter, bigram_smoothing_parameter, pos_prior):\n\n # TODO: Write your code here\n # return predicted labels of development set\n\n # counters for Training Phase\n ham = Counter()\n ham_bi = Counter()\n spam = Counter()\n spam_bi = Counter()\n\n for string, label in zip(train_set, train_labels):\n for i in range(len(string)):\n word = string[i]\n if i != len(string)-1:\n word_bi = string[i] + ' ' + string[i+1]\n if label == 1:\n ham_bi.update({word_bi:1})\n else:\n spam_bi.update({word_bi:1})\n if label == 1:\n ham.update({word:1})\n else:\n spam.update({word:1})\n\n ham_len = 0\n for w in ham:\n ham_len += ham[w]\n spam_len = 0\n for w in spam:\n spam_len += spam[w]\n \n hambi_len = 0\n for w in ham_bi:\n hambi_len += ham_bi[w]\n spambi_len = 0\n for w in spam_bi:\n spambi_len += spam_bi[w]\n\n # labels for Development Phase\n dev_labels = []\n # dicts for P(word|ham) and P(word|spam)\n p_ham = {}\n p_spam = {}\n p_hambi = {}\n p_spambi = {}\n\n # develop likelihoods based on dev_set\n for word in ham:\n numerator = ham[word] + unigram_smoothing_parameter\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\n p_ham[word] = numerator / denominator\n for word in spam:\n numerator = spam[word] + unigram_smoothing_parameter\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\n p_spam[word] = numerator / denominator\n\n for word_bi in ham_bi:\n numerator = ham_bi[word_bi] + bigram_smoothing_parameter\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\n p_hambi[word_bi] = numerator / denominator\n for word_bi in spam_bi:\n numerator = spam_bi[word_bi] + bigram_smoothing_parameter\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\n p_spambi[word_bi] = numerator / denominator\n \n numerator = unigram_smoothing_parameter\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\n p_ham_zero = numerator / denominator\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\n p_spam_zero = numerator / denominator\n\n numerator = bigram_smoothing_parameter\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\n p_hambi_zero = numerator / denominator\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\n p_spambi_zero = numerator / denominator\n\n for string in dev_set:\n p_words_ham = math.log(pos_prior)\n p_words_spam = math.log(1 - pos_prior)\n\n p_words_hambi = math.log(pos_prior)\n p_words_spambi = math.log(1 - pos_prior)\n \n for i in range(len(string)):\n word = string[i]\n if word in p_ham:\n p_words_ham += math.log(p_ham[word])\n else:\n p_words_ham += math.log(p_ham_zero)\n if word in p_spam:\n p_words_spam += math.log(p_spam[word])\n else:\n p_words_spam += math.log(p_spam_zero)\n\n if i != len(string)-1:\n word_bi = string[i] + ' ' + string[i+1]\n if word_bi in p_hambi:\n p_words_hambi += math.log(p_hambi[word_bi])\n else:\n p_words_hambi += math.log(p_hambi_zero)\n if word_bi in p_spambi:\n p_words_spambi += math.log(p_spambi[word_bi])\n else:\n p_words_spambi += math.log(p_spambi_zero)\n\n p_ham_mix = p_words_ham*(1-bigram_lambda) + p_words_hambi*bigram_lambda\n p_spam_mix = p_words_spam*(1-bigram_lambda) + p_words_spambi*bigram_lambda\n\n dev_labels.append(p_ham_mix >= p_spam_mix)\n\n return dev_labels","def log_likelihood(self, params):\n # extract the parameters\n m1 = params['m1']\n m2 = params['m2']\n DL = params['DL']\n Tc = params['Tc']\n iota = params['iota']\n phic = params['phic']\n psi = params['psi']\n thetaS = params['thetaS']\n phiS = params['phiS']\n\n # calculate the model\n model = self._model(time, m1, m2, DL, Tc, iota, phic, psi, thetaS, phiS)\n\n# # normalisation\n# norm = -0.5*self._ndata*LN2PI - self._ndata*self._logsigma\n\n# # chi-squared\n# chisq = np.sum(((self._data - model)/(self._sigma))**2)\n\n return -np.vdot(self._data - model,self._data - model)","def _compute_log_likelihood(self, parameters):\n raise NotImplementedError('')","def perplexity(sentences: List[Tuple[List[int], List[int]]], model: Seq2SeqAttentionModel) -> float:\n LL_Total = torch.tensor(0, dtype=torch.float)\n total_words = torch.tensor(0, dtype=torch.float)\n for i, (source_sentence, target_sentence) in enumerate(sentences):\n LL_Total += log_likelihood(source_sentence, target_sentence, model)\n total_words += len(target_sentence)\n\n return torch.exp(-LL_Total / total_words)","def MLE(ngram, freqs):\n\tn = len(ngram)\n\tif ngram in freqs[n]:\n\t\tnumerator = freqs[n][ngram]\n\telse:\n\t\treturn 0.0\n\tif n == 1:\n\t\tdenominator = sum(freqs[1].values()) # unigram probability (unconditional): f(x) / corpus_size\n\telse:\n\t\thistory = ngram[0:n-1] # conditional ngram probability: f(x_1 .. x_n) / f(x_1 .. x_{n-1})\n\t\tif history in freqs[n-1]:\n\t\t\tdenominator = freqs[n-1][history]\n\t\telse:\n\t\t\treturn 0.0\n\treturn float(numerator)/denominator","def get_total_log_likelihood(self, x, **kwargs):\n pass","def log_likelihood(self, y_list):\n if self.lambda_mat is None:\n raise ValueError(\"Can't compute model likelihood before fitting!\")\n\n # precision prior distribution given precision hyper-parameters\n prec_distr = stats.gamma(a=self.prec_distr[0],\n scale=self.prec_distr[1] ** -1.0)\n\n # likelihood of projection matrix precision priors given\n # precision hyper-parameters\n lambda_logl = np.sum(\n prec_distr.logpdf(self.lambda_mat['alpha']\n / self.lambda_mat['beta'])\n )\n\n # likelihood of projection matrix values given their precision priors\n a_logl = np.sum(\n stats.norm(loc=0, scale=(self.lambda_mat['beta']\n / self.lambda_mat['alpha']))\n .logpdf(self.A_mat['mu'])\n )\n\n # likelihood of latent feature matrix given kernel matrix,\n # projection matrix, and standard deviation hyper-parameter\n h_logl = np.sum(\n stats.norm(loc=self.A_mat['mu'].transpose() @ self.kernel_mat,\n scale=self.sigma_h)\n .logpdf(self.H_mat['mu'])\n )\n\n # likelihood of bias parameter precision priors given\n # precision hyper-parameters\n weight_prior_logl = np.sum(\n prec_distr.logpdf(np.array(self.weight_priors['alpha'])\n / np.array(self.weight_priors['beta']))\n )\n\n # likelihood of bias parameters given their precision priors\n weight_logl = np.sum(\n stats.norm(loc=0, scale=(np.array(self.weight_priors['beta'])\n / np.array(self.weight_priors['alpha'])))\n .logpdf(self.weight_mat['mu'])\n )\n\n # likelihood of predicted outputs given latent features, bias\n # parameters, and latent feature weight parameters\n f_logl = np.sum(\n stats.norm(\n loc=(self.weight_mat['mu'][1:, :].transpose()\n @ self.H_mat['mu']\n + np.vstack(self.weight_mat['mu'][0, :])),\n scale=1).logpdf(self.output_mat['mu'])\n )\n\n # likelihood of actual output labels given class separation margin\n # and predicted output labels\n y_logl = np.sum(self.get_y_logl(y_list))\n\n return (lambda_logl + a_logl + h_logl\n + weight_prior_logl + weight_logl + f_logl + y_logl)","def gmmloglik(log_emlik, weights):","def gmmloglik(log_emlik, weights):","def log_likelihood(self, theta=None, phi=None):\n theta = theta if theta is not None else self.theta\n phi = phi if phi is not None else self.phi\n ret = 0.\n for m, dm in enumerate(self.corpus):\n for n, w_mn in enumerate(dm):\n tp = 0.\n for k in range(self.n_components):\n tp += theta[m, k] * phi[k, w_mn]\n ret += np.log(tp)\n return ret","def get_likelihoods(self, alleles):\n\n l = len(alleles)\n if l==2:\n result = self.likelihoods2(alleles)\n elif l==3:\n result = self.likelihoods3(alleles)\n elif l==4:\n result = self.likelihoods4(alleles)\n elif l==5:\n result = self.likelihoods5(alleles)\n else:\n result = self.likelihoods(alleles)\n return result","def prob_m_of_n(m, n, T, l):\n PFD_one_unit = l*T\n m_of_n = binom(n, m) * (PFD_one_unit)**(n-m) * (1-PFD_one_unit)**m\n return m_of_n","def log_likelihood(y_true, y_pred):\n ll = np.sum(y_true * np.log(y_pred) - y_pred)\n return ll","def loglikelihood(model, data, q):\n\tph, pvh = model\n\tnPeople, nQuestions = data.shape\n\tlogL = 0\n\tfor i in range(nPeople):\n\t\tanswers = data[i,:]\n\t\tfor k in range(nQuestions):\n\t\t\tlogL += np.log(sum(pvh[:, k, int(answers[k] - 1)] * q[i,:].T))\n\treturn logL","def lnlike(theta, dtarray, dmagarray, sigmaarray):\n gamma, A = theta\n\n aux=np.sum(np.log(like_one(theta,dtarray,dmagarray,sigmaarray)))\n\n return aux","def compute_prob_mle(X: np.ndarray) -> float:\n\n Geometric._check_input_data(X=X)\n Geometric._check_support(X=X)\n\n prob = 1 / X.mean()\n return prob","def log_marginal_likelihood(self) -> tf.Tensor:\n X, Y = self.data\n Y = Y[..., :-1]\n K = self.kernel(X)\n ks = self._add_noise_cov(K)\n L = tf.linalg.cholesky(ks)\n m = self.mean_function(X)\n\n # [R,] log-likelihoods for each independent dimension of Y\n log_prob = gpflow.logdensities.multivariate_normal(Y, m, L)\n return tf.reduce_sum(log_prob)","def likelihood(x, n, P):\n if not isinstance(n, int) or (n <= 0):\n raise ValueError('n must be a positive integer')\n if not isinstance(x, int) or (x < 0):\n raise ValueError(\n 'x must be an integer that is greater than or equal to 0')\n if x > n:\n raise ValueError('x cannot be greater than n')\n if not isinstance(P, np.ndarray) or len(P.shape) != 1:\n raise TypeError('P must be a 1D numpy.ndarray')\n if not np.all((P >= 0) & (P <= 1)):\n raise ValueError('All values in P must be in the range [0, 1]')\n nume = np.math.factorial(n)\n deno = (np.math.factorial(x) * (np.math.factorial(n - x)))\n fact = nume / deno\n P_likelihood = fact * (np.power(P, x)) * (np.power((1 - P), (n - x)))\n return P_likelihood","def likelihood(self):\n\n # assert the Gaussian process is up to date\n self._gp_up_to_date()\n\n noise_penalization_term = -1 / 2 * np.log(\n np.linalg.det(self.cov_matrix))\n\n y = np.linalg.solve(self.cov_matrix, self.list_y)\n y = np.array(self.list_y) @ y\n data_fidelity_term = -1 / 2 * y\n\n nbr_obs_term = - self.n_observation * np.log(2 * np.pi)\n likelihood = (\n noise_penalization_term + data_fidelity_term + nbr_obs_term\n )\n return likelihood","def bayesian_info_criterion(log_likelihood, n_params, n_samples):\n return n_params * np.log(n_samples) - 2.0 * log_likelihood","def log_likelihood_bernoulli(mu, target):\n # init\n batch_size = mu.size(0)\n mu = mu.view(batch_size, -1)\n target = target.view(batch_size, -1)\n\n # log_likelihood_bernoulli\n log_bernoulli = torch.sum(target * torch.log(mu) + (1. - target) * torch.log(1. - mu), dim=1)\n return log_bernoulli","def calculateLogJointProbabilities(self, datum):\n logJoint = util.Counter()\n for cls in self.classes:\n class_probability = self.prior_prob[cls]\n for key, value in datum.items():\n relative_feature_values = self.likelihoods[cls][key]\n class_probability += math.log(relative_feature_values.get(datum[key], 0.01))\n\n logJoint[cls] = class_probability\n\n return logJoint","def perplexity(self, corpus):\n sum_pro = 0.0\n total_words = 0\n for sentence in corpus:\n sen_pro = self.sentence_logprob(sentence)\n sum_pro += sen_pro\n total_words += len(sentence)\n\n \n\n l = sum_pro/total_words\n w = 0.0\n w = 2**(-l)\n\n return w","def Likelihood(self, data, hypo):\n p_correct = hypo\n score = data\n\n k = self.exam.Reverse(score)\n n = self.exam.max_score\n like = thinkbayes2.EvalBinomialPmf(k, n, p_correct)\n return like","def compute_prob_mle(X: np.ndarray) -> float:\n\n Bernoulli._check_input_data(X=X)\n Bernoulli._check_support(X=X)\n\n prob = X.mean()\n return prob","def log_likelihood(self, X, Y):\n\t\tr,c = twod(Y).shape\n\t\tif r == 1 and c != 1:\n\t\t\tY = twod(Y).T\n\n\t\tsoft = self.predict_soft(X)\n\t\treturn np.mean(np.sum(np.log(np.power(soft, Y, )), 1), 0)","def marginal_ln_likelihood(samples, prior, data):\n n_samples = len(samples)\n n_linear = len(prior._linear_equiv_units)\n mu = np.zeros(n_linear)\n\n marg_ll = np.zeros(n_samples)\n for n, M, Lambda, ivar, *_ in get_M_Lambda_ivar(samples, prior, data):\n try:\n marg_ll[n], *_ = likelihood_worker(data.rv.value, ivar, M,\n mu, np.diag(Lambda),\n make_aA=False)\n except np.linalg.LinAlgError as e:\n raise e\n\n return marg_ll","def log_m_probs(self):\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\n return self._prob_inverse_transform(m)"],"string":"[\n \"def multinomial_likelihood(m_true, alpha, alpha0, m_probs):\\n\\n ll = tf.reduce_sum(input_tensor=m_true * (tf.math.log(alpha0) - tf.math.log(alpha)), axis=1, keepdims=True)\\n ll = tf.reduce_mean(input_tensor=ll)\\n return ll\",\n \"def multinomial_nll(true_counts, logits):\\n counts_per_example = tf.reduce_sum(true_counts, axis=-1)\\n dist = tfp.distributions.Multinomial(total_count=counts_per_example,\\n logits=logits)\\n return (-tf.reduce_sum(dist.log_prob(true_counts)) / \\n tf.cast(tf.shape(true_counts)[0], dtype=tf.float32))\",\n \"def log_multinomial_coefficient(n, x):\\n return gammaln(n + 1) - gammaln(x + 1).sum()\",\n \"def calculate_log_p_multinomial(self, n_counts, nbins, batch_size):\\n\\n n_counts = tf.cast(n_counts, tf.float32)\\n nbins = tf.cast(nbins, tf.float32)\\n batch_size = tf.cast(batch_size, tf.float32)\\n\\n term_a = tf.lgamma(batch_size + 1)\\n term_b = tf.reduce_sum(tf.lgamma(n_counts + 1))\\n term_c = batch_size * tf.log(nbins)\\n\\n return term_a - term_b - term_c\",\n \"def log_marginal_likelihood(X_train,y_train,phi,tau=1.,Ve=1.e-10):\",\n \"def _compute_likelihood(self, mus, pmfs):\\n expected_counts = pmfs.copy()\\n for mu, _p_bin_source in zip(mus, expected_counts):\\n _p_bin_source *= mu # Works because of numpy view magic...\\n expected_total = np.sum(expected_counts, axis=0)\\n\\n observed_counts = self.data_events_per_bin.histogram\\n\\n ret = observed_counts * np.log(expected_total) - expected_total - gammaln(observed_counts + 1.).real\\n return np.sum(ret)\",\n \"def likelihood(params,data):\\n spec, isnflux, igalflux = data\\n chi2=0\\n modflux = (params[0]*isnflux + params[1]*igalflux)\\n chi2 += sum((spec.flux - modflux)**2)/((0.05*sum(spec.var)**2)/2.0)\\n return np.exp(-chi2/2.0)\",\n \"def likelihood(self):\\n \\n raise NotImplementedError()\",\n \"def likelihood_prediction():\\n # Get info\\n selected_word = prompt_tech_selection()\\n article_json = get_json_from_file()\\n\\n # Calculate results\\n total_word_counter, selected_word_counter = count_occurrences(article_json, selected_word)\\n probability = selected_word_counter / total_word_counter\\n total_time = article_json[-1]['time'] - article_json[0]['time'] # unix subtraction = seconds\\n months_in_train_set = total_time / SECONDS_IN_MONTH\\n expected_posts_per_month = int(total_word_counter / months_in_train_set)\\n\\n # Show results\\n print_text_results(expected_posts_per_month, probability, selected_word)\\n plot_likelihood(expected_posts_per_month, probability)\",\n \"def regularized_multinomial_likelihood(m_true, alpha, alpha0, m_probs, global_step, annealing_step=1000, max_lambda=1.0):\\n\\n ll = multinomial_likelihood(m_true, alpha, alpha0, m_probs)\\n kl = kullback_leibler_dirichlet(m_true, alpha)\\n lamb = tf.cast(tf.minimum(max_lambda, global_step / annealing_step), dtype=tf.float32)\\n loss = ll + lamb * kl\\n return loss\",\n \"def likelihood(self, data, hypo):\\n tagged, n, k = data\\n if hypo < tagged + n - k:\\n return 0\\n\\n p = tagged / hypo\\n like = thinkbayes.eval_binomial_pmf(k, n, p)\\n return like\",\n \"def log_likelihood(data, probs):\\n # Assume data is given as counts\\n return _np.sum([nlogp(n, p) for n, p in zip(data, probs) if n > 0])\",\n \"def multinomial_prob(counts, probs):\\n return nCkarray(*counts.values) * (probs ** counts).prod()\",\n \"def GSM_log_likelihood(X, model):\\n D, M = X.shape\\n k = model.mix.shape[0]\\n log_likelihood = 0\\n for i in range(M):\\n logpdf_X = 0\\n for j in range(k):\\n mvn = multivariate_normal(cov=model.cov[j, :])\\n logpdf_X = mvn.logpdf(x=X[:, i]) * model.mix[j]\\n log_likelihood += logpdf_X\\n return log_likelihood\",\n \"def calculate_likelihoods_bernoulli(data, labels, vocab):\\r\\n classes = set(labels)\\r\\n likelihoods = {}\\r\\n # Calculate likelihood for each class\\r\\n for cls in classes:\\r\\n documentsInClass = [set(map(lambda y: y[0], data[x])) for x in range(len(data)) if labels[x] == cls]\\r\\n numDocsInClass = len(documentsInClass)\\r\\n results = {}\\r\\n for word in vocab:\\r\\n numDocsWithWordInClass = len(filter(lambda x: word in x, documentsInClass))\\r\\n # Binary variable-- either present or not present\\r\\n results[word] = laplace_smooth(numDocsWithWordInClass, numDocsInClass, 2)\\r\\n # Special laplace smoothing for words not found in training data\\r\\n results[None] = laplace_smooth(0, numDocsInClass, 2)\\r\\n likelihoods[cls] = results\\r\\n return likelihoods\",\n \"def multinomial(rng, logits, num_samples):\\n # NOTE(tycai): Currently, tf.multinomial uses CDF for non-XLA CPU only.\\n # We may want to switch to the Gumbel trick as used in XLA.\\n if len(logits.shape) > 2 or not logits.shape:\\n raise ValueError(\\\"Logits must be rank-1 or rank-2.\\\")\\n probs = jax.nn.softmax(logits)\\n probs = jnp.cumsum(probs, axis=-1)\\n # Special-case num_samples == 1 due to TPU padding, as in TF2XLA.\\n # https://github.com/tensorflow/tensorflow/blob/b1608511d5a50d05825c4025b0c347e8689a241f/tensorflow/compiler/tf2xla/kernels/categorical_op.cc#L79\\n if num_samples == 1:\\n a = jax.random.uniform(rng, logits.shape[:-1] + (1,))\\n out = jnp.argmin(a > probs, axis=-1)\\n return out[..., None]\\n else:\\n a = jax.random.uniform(rng, (num_samples,) + logits.shape[:-1] + (1,))\\n out = jnp.argmin(a > probs, axis=-1)\\n return jnp.transpose(out)\",\n \"def log_likelihood(X, Z, variable_types):\\n\\tk = Z['pi_unconstrained'].shape[1]+1 # the number of mixture components\\n\\t## We gather the log probabilities of each indiv in batch for each mixture component into\\n\\t## a matrix of size (B x k), where B is the batch size.\\n\\tlogps = torch.zeros([len(X), k])\\n\\t## First insert the mixture weight contribution to the array\\n\\tlogps += logsoftmax(Z['pi_unconstrained'], dim=-1)\\n\\t## Next loop over the features and sum the contributions to logps\\n\\tfor i, (key, z) in enumerate(Z.items()):\\n\\t\\tif key not in ['pi_unconstrained']:\\n\\t\\t\\tdata = torch.Tensor(X[key].values).unsqueeze(-1)\\n\\t\\t\\tdist = variable_types[key]\\n\\t\\t\\tif dist == 'Categorical':\\n\\t\\t\\t\\talpha = softmax(z, dim=-1, additional=-50.)\\n\\t\\t\\t\\tlogps += Categorical(probs = alpha).log_prob(data)\\n\\t\\t\\telif dist == 'Bernoulli':\\n\\t\\t\\t\\ttheta = z\\n\\t\\t\\t\\tlogps += Bernoulli(logits = theta).log_prob(data)\\n\\t\\t\\telif dist == 'Beta':\\n\\t\\t\\t\\talpha, beta = torch.exp(z).transpose(0,1)\\n\\t\\t\\t\\tlogps += Beta(alpha, beta).log_prob(data)\\n\\t## Compute logsumexp over the mixture components and return the sum over data elements.\\n\\tlogp = torch.logsumexp(logps, dim=-1)\\n\\treturn logp.sum()\",\n \"def calculateLogJointProbabilities(self, datum):\\n\\tlogJoint = util.Counter()\\n\\t#want to calculate log(P(y)) + log(sum(P(fi|y)))\\n\\t#where y is a label\\n\\tfor label in self.legalLabels:\\n\\t\\tlogJoint[label] = math.log(self.prior_distribution_prob[label])\\n\\t\\tfor feature, value in datum.items():\\n\\t\\t\\tcp = self.conditional_prob[label][feature][value]\\n\\t\\t\\tif cp > 0: #condition check for values < 0 because log(0) is undefined and math domain error occurs\\n\\t\\t\\t\\tlogJoint[label] += math.log(cp) #summing up\\n\\t\\t\\t\\t\\n\\treturn logJoint\",\n \"def get_log_likelihood(phi, pred, t, dot_product, weight, reg= 1):\\n prior = -0.5* np.sum(np.multiply(weight, weight))\\n likelihood = np.multiply(t, np.log(pred+TOLERANCE)) + np.multiply(1.0- t, np.log(1.0-pred+TOLERANCE))\\n likelihood = np.sum(likelihood)\\n\\n return prior + likelihood\",\n \"def likelihoods(self, alleles):\\n\\n models = self.models_dict[len(alleles)]\\n\\n F = self.joint_frequencies_combo(alleles)\\n\\n ### BPH ###\\n (((A0, A1),((B0,),)),) = models['BPH'][1].items()\\n\\n BPH = (A0 / A1) * F[B0]\\n\\n\\n BPH += sum( sum(F[B0] * F[B1] for (B0, B1) in C) * A0 / A1\\n for (A0, A1), C in models['BPH'][2].items())\\n\\n if len(alleles)>2:\\n BPH += sum( sum(F[B0] * sum( F[B1] * F[B2] for (B1, B2) in C[B0]) for B0 in C) * A0 / A1\\n for (A0, A1), C in models['BPH'][3].items())\\n\\n ### SPH ###\\n (((A0, A1),((B0,),)),) = models['SPH'][1].items()\\n SPH = (A0 / A1) * F[B0]\\n\\n SPH += sum( sum(F[B0] * F[B1] for (B0, B1) in C) * A0 / A1\\n for (A0, A1), C in models['SPH'][2].items())\\n\\n ### DIPLOIDY ###\\n (((A0, A1),((B0,),)),) = models['DISOMY'][1].items()\\n DISOMY = (A0 / A1) * F[B0]\\n\\n DISOMY += sum( sum( F[B0] * F[B1] for (B0, B1) in C) * A0 / A1\\n for (A0, A1), C in models['DISOMY'][2].items())\\n\\n ### MONOSOMY ###\\n ((B0,),) = models['MONOSOMY'][1][(1,1)]\\n MONOSOMY = F[B0]\\n\\n result = likelihoods_tuple(MONOSOMY, DISOMY, SPH, BPH)\\n return result\",\n \"def calculateLogJointProbabilities(self, datum):\\n logJoint = util.Counter()\\n \\n \\\"*** YOUR CODE HERE ***\\\"\\n \\n # -- OUR CODE HERE\\n \\n \\n import math\\n for label in self.legalLabels:\\n sumThing = 0.0\\n for pixel in self.conditionalProb[label]:\\n if datum[pixel] is 1:\\n #assert self.conditionalProb[label][pixel] < 1.0 # -- sanity check that the probability is valid\\n sumThing += math.log((self.conditionalProb[label][pixel]*1.0))\\n else:\\n sumThing+=math.log(1-self.conditionalProb[label][pixel]*1.0)\\n logJoint[label] = math.log(self.prior[label]*1.0) + sumThing*1.0\\n \\n\\n \\n \\n import time\\n #print \\\"logJoint is :: \\\", logJoint\\n #time.sleep(2)\\n \\n \\n # -- uses the conditional probability tables computed in the current iteration\\n # -- in train and tune\\n \\n return logJoint\",\n \"def calculateLogJointProbabilities(self, datum):\\n logJoint = util.Counter()\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\t#Adds log(P(y)) to calculate P(y|f1,f2...)\\n for label in self.legalLabels:\\n\\t\\tlogJoint[label] += math.log(self.prior[label])\\n\\t#Adds log(P(f1|y)), log(P(f2|y))... to calculate P(y|f1, f2...)\\n for key in datum:\\n\\t\\t#if key == (7, 3):\\n\\t\\t\\t#print self.condprobs[key, 0]\\n\\t\\tfor label in self.legalLabels:\\n\\t\\t\\t#print str(key) + str(datum[key])\\n\\t\\t\\tlogJoint[label] += math.log(self.condprobs[key, label][datum[key]])\\n return logJoint\",\n \"def _learn_global_mixture_weights(alpha, multinomials, val_data, num_em_iter=100, tol=0.001):\\n num_comp = len(multinomials)\\n if np.any(alpha <= 1):\\n raise ValueError('alpha values have to be bigger than 1')\\n\\n for i, mult in enumerate(multinomials):\\n if np.any(np.abs(np.sum(mult, axis=1) - 1) > 0.001):\\n raise ValueError('component %d param is not a proper multinomial -- all rows must sum to 1' % i)\\n\\n if type(alpha) == float or type(alpha) == int:\\n alpha = np.ones(num_comp) * alpha * 1.\\n\\n # Creating responsibility matrix and initializing it hard assignment on random\\n log_like_tracker = [-np.inf]\\n pi = np.ones(num_comp) / num_comp\\n start = time.time()\\n em_iter = 0\\n for em_iter in xrange(1, num_em_iter + 1):\\n # Evey 5 iteration we will compute the posterior log probability to see if we converged.\\n if em_iter % 2 == 0:\\n\\n event_prob = _data_prob(pi, multinomials, val_data)\\n event_prob = np.sum(event_prob, axis=0) # prob\\n\\n # The data likelihood was computed for each location, but it should be in the power of the number\\n # of observations there, or a product in the log space.\\n data_likelihood = np.log(np.array(event_prob)) * val_data[:, 2]\\n\\n prior_probability = dirichlet.logpdf(pi, alpha=alpha)\\n log_likelihood = np.sum(data_likelihood + prior_probability) / np.sum(val_data[:, 2])\\n\\n if np.abs(log_likelihood - log_like_tracker[-1]) < tol:\\n log.debug('[iter %d] [Reached convergence.]' % em_iter)\\n break\\n\\n log.debug('[iter %d] [Likelihood: [%.4f -> %.4f]]' % (em_iter, log_like_tracker[-1], log_likelihood))\\n log_like_tracker.append(log_likelihood)\\n\\n # E-Step\\n\\n resp = _data_prob(pi, multinomials, val_data)\\n\\n if np.all(resp == 0):\\n raise ValueError('0 mix probability')\\n\\n resp = np.array(resp).T\\n resp = normalize(resp, 'l1', axis=1)\\n\\n resp = np.multiply(resp, val_data[:, 2][:, np.newaxis])\\n pi = np.sum(resp, axis=0)\\n pi += alpha - 1\\n pi /= np.sum(pi)\\n\\n total_time = time.time() - start\\n log.debug('Finished EM. Total time = %d secs -- %.3f per iteration' % (total_time, total_time / em_iter))\\n\\n data_log_like = _data_prob(pi, multinomials, val_data)\\n data_log_like = np.sum(data_log_like, axis=0)\\n ll = np.sum(np.log(np.array(data_log_like)) * val_data[:, 2]) / np.sum(val_data[:, 2])\\n return pi, ll\",\n \"def likelihood(self, w, class_words):\\n return log((class_words.count(w) + 1)/(len(class_words) + self.N))\",\n \"def log_prob(self):\",\n \"def __calc_likelihood(self, *args):\\n params = {}\\n for i, p in enumerate(self._par_names):\\n if self._par_islog[p]:\\n params[p] = np.power(10., args[i])\\n else:\\n params[p] = args[i]\\n return self.return_likelihood(params)\",\n \"def likelihood_ratio(cls, *marginals):\\n cont = cls._contingency(*marginals)\\n return (cls._n *\\n sum(obs * _ln(float(obs) / (exp + _SMALL) + _SMALL)\\n for obs, exp in zip(cont, cls._expected_values(cont))))\",\n \"def test_multinomial(self):\\r\\n # Check over two calls to see if the random state is correctly updated.\\r\\n random = RandomStreams(utt.fetch_seed())\\r\\n fn = function([], random.multinomial((4,4), 1, [0.1]*10), updates=random.updates())\\r\\n\\r\\n fn_val0 = fn()\\r\\n fn_val1 = fn()\\r\\n\\r\\n rng_seed = numpy.random.RandomState(utt.fetch_seed()).randint(2**30)\\r\\n rng = numpy.random.RandomState(int(rng_seed)) #int() is for 32bit\\r\\n numpy_val0 = rng.multinomial(1, [0.1]*10, size=(4,4))\\r\\n numpy_val1 = rng.multinomial(1, [0.1]*10, size=(4,4))\\r\\n\\r\\n assert numpy.all(fn_val0 == numpy_val0)\\r\\n assert numpy.all(fn_val1 == numpy_val1)\",\n \"def _LL(state, effects, observed_frequencies) -> float:\\n observed_frequencies = np.array(observed_frequencies)\\n predicted_probs = np.array([np.real(np.trace(state.dot(effect))) for effect in effects])\\n return sum(np.log10(predicted_probs) * observed_frequencies)\",\n \"def log_likelihood(self, x):\\n # set nuisance parameters to their central values!\\n predictions = self.get_predictions(self.shortarray_to_array(x), nuisance=False)\\n m_obj = flavio.Measurement['Pseudo-measurement for FastFit instance: ' + self.name]\\n m_obs = m_obj.all_parameters\\n prob_dict = m_obj.get_logprobability_all(predictions)\\n ll = sum(prob_dict.values())\\n return ll\",\n \"def __log_likelihood(self, params, *args):\\n\\t\\tX, y, feature_set, lambda_reg, empirical_weights, verbose, sign = args\\n\\n\\t\\tno_example = len(X)\\n\\t\\ttotal_logZ = 0\\n\\t\\ttotal_logProb = 0\\n\\t\\texpected_weights = np.zeros(len(feature_set))\\n\\t\\tfor t in range(len(X)):\\n\\t\\t\\t# example_features = X[t], example_labels = y[t]\\n\\n\\t\\t\\tpotential = np.zeros(len(X[t]))\\n\\t\\t\\tfor i in range(len(X[t])):\\n\\t\\t\\t\\t#candidate_features = X[t][i], candidate_label = y[t][i]\\n\\t\\t\\t\\tpotential[i] = feature_set.calc_inner_product(X[t][i], params)\\n\\n\\t\\t\\t#scaling\\n\\t\\t\\tpotential = potential - np.max(potential, keepdims=True)\\n\\n\\t\\t\\tfor i in range(len(X[t])):\\n\\t\\t\\t\\ttotal_logProb += potential[i] * y[t][i]\\n\\n\\t\\t\\tpotential, Z = self.__softmax(potential)\\n\\n\\t\\t\\tfor i in range(len(X[t])):\\n\\t\\t\\t\\tfeature_set.calc_inner_sum(expected_weights, X[t][i], potential[i])\\n\\n\\t\\t\\ttotal_logZ += log(Z)\\n\\n\\t\\t# _params = feature_set.get_regularized_params(params, 'bias')\\n\\t\\t_params = params\\n\\t\\tlog_likelihood = total_logProb - total_logZ - (lambda_reg/2) * np.sum(np.multiply(_params,_params))\\n\\t\\tgradients = empirical_weights - expected_weights - lambda_reg * _params\\n\\n\\t\\tglobal SUB_ITERATION_NUM\\n\\t\\tif verbose:\\n\\t\\t\\tsub_iteration_str = ' '\\n\\t\\t\\tif SUB_ITERATION_NUM > 0:\\n\\t\\t\\t\\tsub_iteration_str = '(' + '{0:02d}'.format(SUB_ITERATION_NUM) + ')'\\n\\t\\t\\tprint(' ', '{0:03d}'.format(ITERATION_NUM), sub_iteration_str, ':', log_likelihood * sign)\\n\\n\\t\\tSUB_ITERATION_NUM += 1\\n\\n\\t\\treturn sign * log_likelihood, sign * gradients\",\n \"def log_likelihood(self,samples,times):\\n prior_mu = np.ones(2*len(self.A)+1) \\n prior_var = np.eye(2*len(self.A)+1)*0.7\\n prior_p = np.log(self.prior_pdf())\\n #prior_p = np.log(self.normal_prior(prior_mu,prior_var))\\n xform = [self.sum_exp(t) for t in times]\\n lp = scipy.stats.norm(xform,np.sqrt(self.var)).pdf(samples)\\n sample_p =np.sum(np.log(lp))\\n ll = prior_p + sample_p\\n\\n if np.isnan(ll):\\n return -np.infty\\n return ll\",\n \"def _build_multinomial_weights(self) -> None:\\n weights_obs = ramp_up_weights(\\n len(self.obs), self.tpe.full_weight_num, self.tpe.equal_weight\\n )\\n counts_obs = numpy.bincount(\\n self.obs, minlength=len(self.choices), weights=weights_obs\\n )\\n counts_obs = counts_obs + self.tpe.prior_weight\\n self.weights = counts_obs / counts_obs.sum()\",\n \"def calculate_likelihood(self, number_of_topics):\\n print(\\\"Start of calculate_likelihood...\\\")\\n maxNumberOfWrd = 0\\n for docValue in range(0,self.number_of_documents):\\n for wordValue in range(0,self.vocabulary_size):\\n maxTopicVal = 0\\n for topicValue in range(0,number_of_topics):\\n maxTopicVal = maxTopicVal + ((self.document_topic_prob[docValue][topicValue]*self.topic_word_prob[topicValue][wordValue]))\\n if maxTopicVal > 0:\\n maxNumberOfWrd = maxNumberOfWrd + (np.log(maxTopicVal) * self.term_doc_matrix[docValue][wordValue])\\n\\t\\t#print(\\\"Value of maxNumberOfWrd >>> \\\"+maxNumberOfWrd)\\n self.likelihoods.append(maxNumberOfWrd)\\n\\t\\t#print(\\\"End of calculate_likelihood...\\\")\\n return\",\n \"def test_multinomial(self):\\r\\n # Check over two calls to see if the random state is correctly updated.\\r\\n m = Module()\\r\\n m.random = RandomStreams(utt.fetch_seed())\\r\\n m.fn = Method([], m.random.multinomial((20,20), 1, [0.1]*10))\\r\\n\\r\\n made = m.make()\\r\\n made.random.initialize()\\r\\n fn_val0 = made.fn()\\r\\n fn_val1 = made.fn()\\r\\n\\r\\n rng_seed = numpy.random.RandomState(utt.fetch_seed()).randint(2**30)\\r\\n rng = numpy.random.RandomState(int(rng_seed)) #int() is for 32bit\\r\\n numpy_val0 = rng.multinomial(1, [0.1]*10, size=(20,20))\\r\\n numpy_val1 = rng.multinomial(1, [0.1]*10, size=(20,20))\\r\\n\\r\\n assert numpy.all(fn_val0 == numpy_val0)\\r\\n assert numpy.all(fn_val1 == numpy_val1)\",\n \"def evaluate_GMM_log_likelihood(model, x, y):\\n y_pred = model.predict(x)\\n \\n num_datapoints = len(x)\\n output_dim = y.shape[-1]\\n num_comp = int(y_pred.shape[-1] / (3*output_dim))\\n\\n mix_comp_logits = y_pred[:, :num_comp]\\n mus = y_pred[:, num_comp:(1+output_dim)*num_comp]\\n sigmas = y_pred[:, (1+output_dim)*num_comp:]\\n \\n # convert logits to categorical distribution - need to itterate through all points\\n mix_comp = np.zeros((num_datapoints, num_comp))\\n for i in range(num_datapoints):\\n mix_comp[i,:] = get_mixture_dist(mix_comp_logits[i,:], num_comp)\\n \\n log_likelihood = 0\\n for i in range(num_comp):\\n for j in range(output_dim):\\n mse = -0.5*np.sum(mix_comp[:,i]*np.square((y[:,j]-mus[:,(i*output_dim)+j])/sigmas[:,(i*output_dim)+j]))\\n sigma_trace = -np.sum(mix_comp[:,i]*np.log(sigmas[:,(i*output_dim)+j]))\\n log2pi = -np.sum(mix_comp[:,i]*0.5*output_dim*np.log(2*np.pi))\\n\\n log_likelihood += mse + sigma_trace + log2pi\\n \\n avg_log_likelihood = np.round(log_likelihood / num_datapoints, 2)\\n print(f'Log likelihood: {avg_log_likelihood}')\\n return avg_log_likelihood\",\n \"def compute_movie_rating_likelihood(M):\\n\\n # define the size to begin with\\n likelihood = np.zeros((M, M))\\n\\n # -------------------------------------------------------------------------\\n # YOUR CODE GOES HERE FOR PART (c)\\n #\\n # Remember to normalize the likelihood, so that each column is a\\n # probability distribution.\\n \\n for i in range(M):\\n for j in range(M):\\n if i == j:\\n likelihood[i][j] = 2\\n else:\\n likelihood[i][j] = 1/abs(j-i)\\n \\n likelihood = likelihood / likelihood.sum(axis = 1)\\n \\n #\\n # END OF YOUR CODE FOR PART (c)\\n # -------------------------------------------------------------------------\\n\\n return likelihood\",\n \"def _compute_log_likelihood(self, X, S):\\n log_likelihood = 0\\n for n in range(self.n_col):\\n likelihood = 1\\n for k in range(self.n_components):\\n likelihood *= self.weights[k] \\\\\\n * multivariate_normal(self.means[k], self.covs[k]).pdf(X[n]) \\\\\\n * poisson(self.rates[k]).pmf(S[n])\\n log_likelihood += np.log(likelihood)\\n\\n return log_likelihood\",\n \"def test_LM(self):\\n\\t\\t\\n\\t\\tprecision = 10**-8\\n\\t\\t\\t\\t \\n\\t\\tif self.n == 1:\\n\\t\\t\\t\\t \\n\\t\\t\\tP_sum = sum(self.estimate_prob('', w) for w in self.vocab)\\n\\t\\t\\t\\n\\t\\t\\tassert abs(1.0 - P_sum) < precision, 'Probability mass does not sum up to one.'\\n\\t\\t\\t\\t \\n\\t\\telif self.n == 2:\\n\\t\\t\\thistories = ['the', 'in', 'at', 'blue', 'white']\\n\\t\\t\\t\\t \\n\\t\\t\\tfor h in histories:\\n\\t\\t\\t\\t \\n\\t\\t\\t\\tP_sum = sum(self.estimate_prob(h, w) for w in self.vocab)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tassert abs(1.0 - P_sum) < precision, 'Probability mass does not sum up to one for history' + h\\n\\t\\t\\t\\t\\t \\n\\t\\tprint('TEST SUCCESSFUL!')\",\n \"def log_likelihood(mu, sigma, y, T):\\n ll = 0.\\n for yi, Ti in zip(y, T):\\n d = yi.size\\n log_det_cov = np.linalg.slogdet(sigma[Ti])[1]\\n y_minus_mean = yi - mu[Ti]\\n term3 = np.dot(y_minus_mean.T.ravel(),\\n np.linalg.solve(sigma[Ti], y_minus_mean.T).ravel())\\n ll += (-0.5 * d * np.log(2 * np.pi) - 0.5 * log_det_cov - 0.5 * term3)\\n return ll\",\n \"def log_likelihood_exp(self, x):\\n predictions = self.get_predictions(x)\\n ll = 0.\\n for measurement in self.get_measurements:\\n m_obj = flavio.Measurement[measurement]\\n m_obs = m_obj.all_parameters\\n exclude_observables = set(m_obs) - set(self.observables)\\n prob_dict = m_obj.get_logprobability_all(predictions, exclude_parameters=exclude_observables)\\n ll += sum(prob_dict.values())\\n return ll\",\n \"def MVN_log_likelihood(X, model):\\n D, M = X.shape\\n X_normalized = normalize_log_likelihoods(X.copy())\\n mvn = multivariate_normal(mean=model.mean, cov=model.cov)\\n return mvn.logpdf(X_normalized.T).sum()\\n # log_2pi = D * np.log(2 * np.pi)\\n # log_det = np.log(np.linalg.det(model.cov))\\n # residuals = calc_residuals(X_normalized, model.mean, \\\"minus\\\")\\n # mahalanobis_distance = np.dot(np.dot(residuals.T, np.linalg.inv(model.cov)), residuals)\\n # return -0.5 * (log_2pi + log_det + mahalanobis_distance).sum()\",\n \"def compute_likelihood(self, corpus: str, test_corpus: str, n: int):\\n probs_per_ngram = self.compute_probabilities_per_word(corpus, n)\\n test_corpus_tokens = self.tokenize(test_corpus, n)\\n test_corpus_ngrams = ()\\n end_i = len(test_corpus_tokens) - 1\\n for i in range(end_i):\\n if i - (n - 1) < 0:\\n continue\\n test_corpus_ngrams = test_corpus_ngrams + (self._make_ngrams(test_corpus_tokens, i, n), )\\n likelihood_of_test_corpus = 1\\n for test_corpus_ngram in test_corpus_ngrams:\\n likelihood_of_test_corpus = likelihood_of_test_corpus * probs_per_ngram[test_corpus_ngram]\\n return likelihood_of_test_corpus\",\n \"def test_posterior_logprobs(self):\\n x = list(product([True, False], repeat=2))\\n xs = list(e for e in product(x, repeat=3))\\n all_obs = list(o for o in xs\\n if all(any(e) and not all(e) for e in o))\\n total = logsumexp(list(posterior_logprobs(np.array(obs), self.S, self.A, self.E)[1]\\n for obs in all_obs))\\n assert_allclose(total, np.log(1))\",\n \"def log_likelihood(self, data, reward_model, bias_params):\",\n \"def compute_log_likelihood(self, indicators, weights, l2):\\n scores, _ = self.predict_probability(self.train_feature_x, weights)\\n probs = self.predict_probability(self.train_feature_x, weights)\\n lp = np.sum((indicators-1)*scores + np.log(probs)) - l2* np.sum(weights[1:]**2)\\n return lp\",\n \"def log_likelihood(X, mu, sigma, phi):\\n ll = None\\n\\n #######################################################################\\n # TODO: #\\n # Compute the log-likelihood of the data under the current model. #\\n # This is used to check for convergnence of the algorithm. #\\n #######################################################################\\n\\n ll = np.zeros((X.shape[0], 1))\\n k = mu.shape[0]\\n\\n for i in range(k):\\n ll += multivariate_normal(mu[i, :], sigma[i]).pdf(X)[:, np.newaxis]*phi[i]\\n\\n ll = sum(np.log(ll))\\n\\n #######################################################################\\n # END OF YOUR CODE #\\n #######################################################################\\n\\n return ll\",\n \"def get_log_likelihood(response_probability, response):\\n pass\",\n \"def likelihood(self,x,params = None,**kwargs):\\n return np.exp(self.log_likelihood(x,params=params,**kwargs))\",\n \"def likelihood(ts,w,Phi):\\n a = Phi.dot(w)\\n return np.exp(a*ts)*sigmoid(-a)\",\n \"def loglikelihood(self, y):\\n raise NotImplementedError\",\n \"def multinomial_accuracy(distribution_or_probs: tfd.Distribution,\\n data: jnp.DeviceArray) -> jnp.DeviceArray:\\n return jnp.mean(\\n jnp.sum(multinomial_mode(distribution_or_probs) * data, axis=1))\",\n \"def lnprob(theta, observables):\\n prior = lnprior(theta)\\n if not np.isfinite(prior):\\n return -inf\\n return prior + lnlike(theta, observables)\",\n \"def likelihood_genotype(genotype, bases_all_reads, error_rates):\\n likelihood = 1\\n for observed_base in bases_all_reads:\\n p = 0\\n for base in \\\"ACGT-\\\":\\n l = prob_t_N(genotype, base) * error_rates[base][observed_base]\\n p += l\\n likelihood *= p\\n\\n return likelihood\",\n \"def test_marginal_likelihood(self):\\n data = np.repeat([1, 0], [50, 50])\\n marginals = []\\n a_prior_0, b_prior_0 = 1.0, 1.0\\n a_prior_1, b_prior_1 = 20.0, 20.0\\n\\n for alpha, beta in ((a_prior_0, b_prior_0), (a_prior_1, b_prior_1)):\\n with pm.Model() as model:\\n a = pm.Beta(\\\"a\\\", alpha, beta)\\n y = pm.Bernoulli(\\\"y\\\", a, observed=data)\\n trace = pm.sample_smc(2000, chains=2, return_inferencedata=False)\\n # log_marginal_likelihood is found in the last value of each chain\\n lml = np.mean([chain[-1] for chain in trace.report.log_marginal_likelihood])\\n marginals.append(lml)\\n\\n # compare to the analytical result\\n assert abs(np.exp(marginals[1] - marginals[0]) - 4.0) <= 1\",\n \"def pmi(cls, *marginals):\\n return (_log2(marginals[NGRAM] * marginals[TOTAL] ** (cls._n - 1)) -\\n _log2(_product(marginals[UNIGRAMS])))\",\n \"def loglikelihood(self):\\n raise NotImplementedError(\\\"To be implemented\\\")\",\n \"def likelihood(mean, logs, x):\\n return -0.5 * (logs * 2. + ((x - mean) ** 2) / np.exp(logs * 2.) + GaussianDiag.Log2PI)\",\n \"def naivebayesPXY_mle(x,y):\\n pos_denom = x[y==1].sum()\\n neg_denom = x[y==-1].sum()\\n posprob = x[y==1].sum(axis = 0)/pos_denom\\n negprob = x[y==-1].sum(axis = 0)/neg_denom\\n return posprob, negprob\",\n \"def log_likelihood_function(self, instance) -> float:\\n return self.prior.factor(instance[0])\",\n \"def calc_likelihood(par_num, par_rng):\\n\\n likelihoods = np.zeros(np.size(par_rng))\\n\\n trivial_prior = trivial_prior_class()\\n\\n pipe = pipeline(observables_generator=hammu12,\\n likelihood=likelihood,\\n prior=trivial_prior,\\n optimizer_class=Hamiltonian_Monte_Carlo)\\n\\n parameters = [0]*hammu12.get_parameter_dimension()\\n for par_val in par_rng:\\n parameters[par_num] = par_val\\n likelihoods[par_val-par_rng[0]] = pipe._calc_posterior(parameters)\\n\\n np.save('data%s_RM' % (par_num), likelihoods)\",\n \"def calculate_log_perplexity(self, output, flat_labels): #completed, expensive, should be compiled\\n return -np.sum(np.log2(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])\",\n \"def Ls(GTn:torch.tensor, Mn:torch.tensor) -> torch.tensor:\\n return (-(GTn * torch.log(Mn+1e-15) + (1- GTn) * torch.log((1- Mn)+1e-15))).sum()\",\n \"def likelihood_function(X, taus, mus, sigmas):\\n N = X.shape[0] # number of data points\\n get_component_prob = lambda x: component_pdfs(x, mus, sigmas)\\n T = np.apply_along_axis(arr=X, func1d=get_component_prob, axis=1) # gaussian component probabilities in row format (NxK)\\n taus_rep = np.tile(taus, reps=(N, 1)) # repeat tau along N-axis so elementwise product can work\\n\\n return np.sum(T*taus_rep, axis=1)\",\n \"def log_marginal(self):\\n #\\n # Predictive covariance of x is sum of covariance of phi a and covariance of x|a\\n x_Sigma = self.phi @ self.phi.T + np.diag(self.sigma_n**2 * np.ones(self.M))\\n #\\n # Predictive mean is 0 by symmetry\\n # so given that x is distributed as a MVN, the exact marginal is\\n lp_exact = st.multivariate_normal.logpdf(self.x, cov=x_Sigma)\\n #\\n return lp_exact\",\n \"def nll_logprobs(self, input, target_idx):\\n raise NotImplementedError()\",\n \"def likelihood(alphas, sigmas, mus, x):\\n if len(alphas.shape) == 0:\\n alphas = np.expand_dims(alphas, 1)\\n sigmas = np.expand_dims(sigmas, 1)\\n k = alphas.shape[0]\\n t_dim = int(mus.shape[0] / k)\\n\\n likelihood_ = 0.0\\n\\n for i in range(k):\\n likelihood_t = gaussian_np(x, mus[i*t_dim:(i+1)*t_dim], sigmas[i])\\n likelihood_ += alphas[i] * likelihood_t\\n\\n return likelihood_\",\n \"def eml_use_pseudowords_and_mle(xi, yi, deml):\\n if xi not in deml[yi]:\\n xi = pw(xi) # use pseudo-word instead\\n\\n return (deml[yi][xi]) / (sum(deml[yi].values()))\",\n \"def likelihood(\\n self,\\n observation: np.ndarray,\\n state: np.ndarray,\\n control_z: Optional[np.ndarray] = None\\n ) -> np.matrix:\\n pass\",\n \"def joint_logpdf(self, x1, x2 = None):\\n dists = self.conditionalMVNs\\n joint_pdfs = np.array([d.joint_pdf(x1, x2) for d in dists])\\n return np.log(np.sum(self.weights * joint_pdfs))\",\n \"def compute_prob_mle(X: np.ndarray, n: int) -> float:\\n\\n assert n > 1, \\\"for n = 1 use Bernoulli distribution.\\\"\\n Binomial._check_input_data(X=X)\\n Binomial._check_support(X=X, n=n)\\n\\n prob = X.mean() / n\\n return prob\",\n \"def test_multinomial(self):\\r\\n # Check over two calls to see if the random state is correctly updated.\\r\\n rng_R = random_state_type()\\r\\n post_r, out = multinomial(rng_R, (7, 3), 6, [0.2] * 5)\\r\\n\\r\\n f = compile.function(\\r\\n [compile.In(rng_R,\\r\\n value=numpy.random.RandomState(utt.fetch_seed()),\\r\\n update=post_r, mutable=True)],\\r\\n [out], accept_inplace=True)\\r\\n\\r\\n numpy_rng = numpy.random.RandomState(utt.fetch_seed())\\r\\n val0, = f()\\r\\n val1, = f()\\r\\n numpy_val0 = numpy_rng.multinomial(6, [0.2] * 5, (7, 3))\\r\\n numpy_val1 = numpy_rng.multinomial(6, [0.2] * 5, (7, 3))\\r\\n print val0\\r\\n print numpy_val0\\r\\n print val1\\r\\n print numpy_val1\\r\\n self.assertTrue(numpy.all(val0 == numpy_val0))\\r\\n self.assertTrue(numpy.all(val1 == numpy_val1))\\r\\n\\r\\n self.assertTrue(val0.shape == (7, 3, 5))\\r\\n self.assertTrue(val1.shape == (7, 3, 5))\",\n \"def naiveBayesMixture(train_set, train_labels, dev_set, bigram_lambda,unigram_smoothing_parameter, bigram_smoothing_parameter, pos_prior):\\n\\n # TODO: Write your code here\\n # return predicted labels of development set\\n\\n # counters for Training Phase\\n ham = Counter()\\n ham_bi = Counter()\\n spam = Counter()\\n spam_bi = Counter()\\n\\n for string, label in zip(train_set, train_labels):\\n for i in range(len(string)):\\n word = string[i]\\n if i != len(string)-1:\\n word_bi = string[i] + ' ' + string[i+1]\\n if label == 1:\\n ham_bi.update({word_bi:1})\\n else:\\n spam_bi.update({word_bi:1})\\n if label == 1:\\n ham.update({word:1})\\n else:\\n spam.update({word:1})\\n\\n ham_len = 0\\n for w in ham:\\n ham_len += ham[w]\\n spam_len = 0\\n for w in spam:\\n spam_len += spam[w]\\n \\n hambi_len = 0\\n for w in ham_bi:\\n hambi_len += ham_bi[w]\\n spambi_len = 0\\n for w in spam_bi:\\n spambi_len += spam_bi[w]\\n\\n # labels for Development Phase\\n dev_labels = []\\n # dicts for P(word|ham) and P(word|spam)\\n p_ham = {}\\n p_spam = {}\\n p_hambi = {}\\n p_spambi = {}\\n\\n # develop likelihoods based on dev_set\\n for word in ham:\\n numerator = ham[word] + unigram_smoothing_parameter\\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\\n p_ham[word] = numerator / denominator\\n for word in spam:\\n numerator = spam[word] + unigram_smoothing_parameter\\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\\n p_spam[word] = numerator / denominator\\n\\n for word_bi in ham_bi:\\n numerator = ham_bi[word_bi] + bigram_smoothing_parameter\\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\\n p_hambi[word_bi] = numerator / denominator\\n for word_bi in spam_bi:\\n numerator = spam_bi[word_bi] + bigram_smoothing_parameter\\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\\n p_spambi[word_bi] = numerator / denominator\\n \\n numerator = unigram_smoothing_parameter\\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\\n p_ham_zero = numerator / denominator\\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\\n p_spam_zero = numerator / denominator\\n\\n numerator = bigram_smoothing_parameter\\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\\n p_hambi_zero = numerator / denominator\\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\\n p_spambi_zero = numerator / denominator\\n\\n for string in dev_set:\\n p_words_ham = math.log(pos_prior)\\n p_words_spam = math.log(1 - pos_prior)\\n\\n p_words_hambi = math.log(pos_prior)\\n p_words_spambi = math.log(1 - pos_prior)\\n \\n for i in range(len(string)):\\n word = string[i]\\n if word in p_ham:\\n p_words_ham += math.log(p_ham[word])\\n else:\\n p_words_ham += math.log(p_ham_zero)\\n if word in p_spam:\\n p_words_spam += math.log(p_spam[word])\\n else:\\n p_words_spam += math.log(p_spam_zero)\\n\\n if i != len(string)-1:\\n word_bi = string[i] + ' ' + string[i+1]\\n if word_bi in p_hambi:\\n p_words_hambi += math.log(p_hambi[word_bi])\\n else:\\n p_words_hambi += math.log(p_hambi_zero)\\n if word_bi in p_spambi:\\n p_words_spambi += math.log(p_spambi[word_bi])\\n else:\\n p_words_spambi += math.log(p_spambi_zero)\\n\\n p_ham_mix = p_words_ham*(1-bigram_lambda) + p_words_hambi*bigram_lambda\\n p_spam_mix = p_words_spam*(1-bigram_lambda) + p_words_spambi*bigram_lambda\\n\\n dev_labels.append(p_ham_mix >= p_spam_mix)\\n\\n return dev_labels\",\n \"def log_likelihood(self, params):\\n # extract the parameters\\n m1 = params['m1']\\n m2 = params['m2']\\n DL = params['DL']\\n Tc = params['Tc']\\n iota = params['iota']\\n phic = params['phic']\\n psi = params['psi']\\n thetaS = params['thetaS']\\n phiS = params['phiS']\\n\\n # calculate the model\\n model = self._model(time, m1, m2, DL, Tc, iota, phic, psi, thetaS, phiS)\\n\\n# # normalisation\\n# norm = -0.5*self._ndata*LN2PI - self._ndata*self._logsigma\\n\\n# # chi-squared\\n# chisq = np.sum(((self._data - model)/(self._sigma))**2)\\n\\n return -np.vdot(self._data - model,self._data - model)\",\n \"def _compute_log_likelihood(self, parameters):\\n raise NotImplementedError('')\",\n \"def perplexity(sentences: List[Tuple[List[int], List[int]]], model: Seq2SeqAttentionModel) -> float:\\n LL_Total = torch.tensor(0, dtype=torch.float)\\n total_words = torch.tensor(0, dtype=torch.float)\\n for i, (source_sentence, target_sentence) in enumerate(sentences):\\n LL_Total += log_likelihood(source_sentence, target_sentence, model)\\n total_words += len(target_sentence)\\n\\n return torch.exp(-LL_Total / total_words)\",\n \"def MLE(ngram, freqs):\\n\\tn = len(ngram)\\n\\tif ngram in freqs[n]:\\n\\t\\tnumerator = freqs[n][ngram]\\n\\telse:\\n\\t\\treturn 0.0\\n\\tif n == 1:\\n\\t\\tdenominator = sum(freqs[1].values()) # unigram probability (unconditional): f(x) / corpus_size\\n\\telse:\\n\\t\\thistory = ngram[0:n-1] # conditional ngram probability: f(x_1 .. x_n) / f(x_1 .. x_{n-1})\\n\\t\\tif history in freqs[n-1]:\\n\\t\\t\\tdenominator = freqs[n-1][history]\\n\\t\\telse:\\n\\t\\t\\treturn 0.0\\n\\treturn float(numerator)/denominator\",\n \"def get_total_log_likelihood(self, x, **kwargs):\\n pass\",\n \"def log_likelihood(self, y_list):\\n if self.lambda_mat is None:\\n raise ValueError(\\\"Can't compute model likelihood before fitting!\\\")\\n\\n # precision prior distribution given precision hyper-parameters\\n prec_distr = stats.gamma(a=self.prec_distr[0],\\n scale=self.prec_distr[1] ** -1.0)\\n\\n # likelihood of projection matrix precision priors given\\n # precision hyper-parameters\\n lambda_logl = np.sum(\\n prec_distr.logpdf(self.lambda_mat['alpha']\\n / self.lambda_mat['beta'])\\n )\\n\\n # likelihood of projection matrix values given their precision priors\\n a_logl = np.sum(\\n stats.norm(loc=0, scale=(self.lambda_mat['beta']\\n / self.lambda_mat['alpha']))\\n .logpdf(self.A_mat['mu'])\\n )\\n\\n # likelihood of latent feature matrix given kernel matrix,\\n # projection matrix, and standard deviation hyper-parameter\\n h_logl = np.sum(\\n stats.norm(loc=self.A_mat['mu'].transpose() @ self.kernel_mat,\\n scale=self.sigma_h)\\n .logpdf(self.H_mat['mu'])\\n )\\n\\n # likelihood of bias parameter precision priors given\\n # precision hyper-parameters\\n weight_prior_logl = np.sum(\\n prec_distr.logpdf(np.array(self.weight_priors['alpha'])\\n / np.array(self.weight_priors['beta']))\\n )\\n\\n # likelihood of bias parameters given their precision priors\\n weight_logl = np.sum(\\n stats.norm(loc=0, scale=(np.array(self.weight_priors['beta'])\\n / np.array(self.weight_priors['alpha'])))\\n .logpdf(self.weight_mat['mu'])\\n )\\n\\n # likelihood of predicted outputs given latent features, bias\\n # parameters, and latent feature weight parameters\\n f_logl = np.sum(\\n stats.norm(\\n loc=(self.weight_mat['mu'][1:, :].transpose()\\n @ self.H_mat['mu']\\n + np.vstack(self.weight_mat['mu'][0, :])),\\n scale=1).logpdf(self.output_mat['mu'])\\n )\\n\\n # likelihood of actual output labels given class separation margin\\n # and predicted output labels\\n y_logl = np.sum(self.get_y_logl(y_list))\\n\\n return (lambda_logl + a_logl + h_logl\\n + weight_prior_logl + weight_logl + f_logl + y_logl)\",\n \"def gmmloglik(log_emlik, weights):\",\n \"def gmmloglik(log_emlik, weights):\",\n \"def log_likelihood(self, theta=None, phi=None):\\n theta = theta if theta is not None else self.theta\\n phi = phi if phi is not None else self.phi\\n ret = 0.\\n for m, dm in enumerate(self.corpus):\\n for n, w_mn in enumerate(dm):\\n tp = 0.\\n for k in range(self.n_components):\\n tp += theta[m, k] * phi[k, w_mn]\\n ret += np.log(tp)\\n return ret\",\n \"def get_likelihoods(self, alleles):\\n\\n l = len(alleles)\\n if l==2:\\n result = self.likelihoods2(alleles)\\n elif l==3:\\n result = self.likelihoods3(alleles)\\n elif l==4:\\n result = self.likelihoods4(alleles)\\n elif l==5:\\n result = self.likelihoods5(alleles)\\n else:\\n result = self.likelihoods(alleles)\\n return result\",\n \"def prob_m_of_n(m, n, T, l):\\n PFD_one_unit = l*T\\n m_of_n = binom(n, m) * (PFD_one_unit)**(n-m) * (1-PFD_one_unit)**m\\n return m_of_n\",\n \"def log_likelihood(y_true, y_pred):\\n ll = np.sum(y_true * np.log(y_pred) - y_pred)\\n return ll\",\n \"def loglikelihood(model, data, q):\\n\\tph, pvh = model\\n\\tnPeople, nQuestions = data.shape\\n\\tlogL = 0\\n\\tfor i in range(nPeople):\\n\\t\\tanswers = data[i,:]\\n\\t\\tfor k in range(nQuestions):\\n\\t\\t\\tlogL += np.log(sum(pvh[:, k, int(answers[k] - 1)] * q[i,:].T))\\n\\treturn logL\",\n \"def lnlike(theta, dtarray, dmagarray, sigmaarray):\\n gamma, A = theta\\n\\n aux=np.sum(np.log(like_one(theta,dtarray,dmagarray,sigmaarray)))\\n\\n return aux\",\n \"def compute_prob_mle(X: np.ndarray) -> float:\\n\\n Geometric._check_input_data(X=X)\\n Geometric._check_support(X=X)\\n\\n prob = 1 / X.mean()\\n return prob\",\n \"def log_marginal_likelihood(self) -> tf.Tensor:\\n X, Y = self.data\\n Y = Y[..., :-1]\\n K = self.kernel(X)\\n ks = self._add_noise_cov(K)\\n L = tf.linalg.cholesky(ks)\\n m = self.mean_function(X)\\n\\n # [R,] log-likelihoods for each independent dimension of Y\\n log_prob = gpflow.logdensities.multivariate_normal(Y, m, L)\\n return tf.reduce_sum(log_prob)\",\n \"def likelihood(x, n, P):\\n if not isinstance(n, int) or (n <= 0):\\n raise ValueError('n must be a positive integer')\\n if not isinstance(x, int) or (x < 0):\\n raise ValueError(\\n 'x must be an integer that is greater than or equal to 0')\\n if x > n:\\n raise ValueError('x cannot be greater than n')\\n if not isinstance(P, np.ndarray) or len(P.shape) != 1:\\n raise TypeError('P must be a 1D numpy.ndarray')\\n if not np.all((P >= 0) & (P <= 1)):\\n raise ValueError('All values in P must be in the range [0, 1]')\\n nume = np.math.factorial(n)\\n deno = (np.math.factorial(x) * (np.math.factorial(n - x)))\\n fact = nume / deno\\n P_likelihood = fact * (np.power(P, x)) * (np.power((1 - P), (n - x)))\\n return P_likelihood\",\n \"def likelihood(self):\\n\\n # assert the Gaussian process is up to date\\n self._gp_up_to_date()\\n\\n noise_penalization_term = -1 / 2 * np.log(\\n np.linalg.det(self.cov_matrix))\\n\\n y = np.linalg.solve(self.cov_matrix, self.list_y)\\n y = np.array(self.list_y) @ y\\n data_fidelity_term = -1 / 2 * y\\n\\n nbr_obs_term = - self.n_observation * np.log(2 * np.pi)\\n likelihood = (\\n noise_penalization_term + data_fidelity_term + nbr_obs_term\\n )\\n return likelihood\",\n \"def bayesian_info_criterion(log_likelihood, n_params, n_samples):\\n return n_params * np.log(n_samples) - 2.0 * log_likelihood\",\n \"def log_likelihood_bernoulli(mu, target):\\n # init\\n batch_size = mu.size(0)\\n mu = mu.view(batch_size, -1)\\n target = target.view(batch_size, -1)\\n\\n # log_likelihood_bernoulli\\n log_bernoulli = torch.sum(target * torch.log(mu) + (1. - target) * torch.log(1. - mu), dim=1)\\n return log_bernoulli\",\n \"def calculateLogJointProbabilities(self, datum):\\n logJoint = util.Counter()\\n for cls in self.classes:\\n class_probability = self.prior_prob[cls]\\n for key, value in datum.items():\\n relative_feature_values = self.likelihoods[cls][key]\\n class_probability += math.log(relative_feature_values.get(datum[key], 0.01))\\n\\n logJoint[cls] = class_probability\\n\\n return logJoint\",\n \"def perplexity(self, corpus):\\n sum_pro = 0.0\\n total_words = 0\\n for sentence in corpus:\\n sen_pro = self.sentence_logprob(sentence)\\n sum_pro += sen_pro\\n total_words += len(sentence)\\n\\n \\n\\n l = sum_pro/total_words\\n w = 0.0\\n w = 2**(-l)\\n\\n return w\",\n \"def Likelihood(self, data, hypo):\\n p_correct = hypo\\n score = data\\n\\n k = self.exam.Reverse(score)\\n n = self.exam.max_score\\n like = thinkbayes2.EvalBinomialPmf(k, n, p_correct)\\n return like\",\n \"def compute_prob_mle(X: np.ndarray) -> float:\\n\\n Bernoulli._check_input_data(X=X)\\n Bernoulli._check_support(X=X)\\n\\n prob = X.mean()\\n return prob\",\n \"def log_likelihood(self, X, Y):\\n\\t\\tr,c = twod(Y).shape\\n\\t\\tif r == 1 and c != 1:\\n\\t\\t\\tY = twod(Y).T\\n\\n\\t\\tsoft = self.predict_soft(X)\\n\\t\\treturn np.mean(np.sum(np.log(np.power(soft, Y, )), 1), 0)\",\n \"def marginal_ln_likelihood(samples, prior, data):\\n n_samples = len(samples)\\n n_linear = len(prior._linear_equiv_units)\\n mu = np.zeros(n_linear)\\n\\n marg_ll = np.zeros(n_samples)\\n for n, M, Lambda, ivar, *_ in get_M_Lambda_ivar(samples, prior, data):\\n try:\\n marg_ll[n], *_ = likelihood_worker(data.rv.value, ivar, M,\\n mu, np.diag(Lambda),\\n make_aA=False)\\n except np.linalg.LinAlgError as e:\\n raise e\\n\\n return marg_ll\",\n \"def log_m_probs(self):\\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\\n return self._prob_inverse_transform(m)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7405791","0.71270245","0.6805791","0.67948574","0.6551636","0.6476551","0.64614797","0.6425553","0.6342785","0.63420993","0.6332708","0.633066","0.6330074","0.6298897","0.62908417","0.62799925","0.62471","0.62063324","0.61783415","0.6177655","0.61492676","0.6103034","0.60990226","0.60570467","0.60409313","0.601715","0.6015817","0.6010898","0.6003754","0.59715736","0.5967609","0.5958885","0.595258","0.59231687","0.5919504","0.591918","0.5914721","0.5896283","0.5895937","0.5888113","0.58879983","0.58612007","0.5860122","0.58575034","0.58549076","0.58512044","0.58423156","0.58388513","0.58324647","0.582239","0.5817351","0.58041096","0.5795078","0.5785493","0.57818705","0.577473","0.57710975","0.57705635","0.5764597","0.57593507","0.5759117","0.5750386","0.5747177","0.57456315","0.57406026","0.5738948","0.5736493","0.5727552","0.5726234","0.572506","0.5724687","0.5717582","0.5714601","0.5713584","0.5708932","0.5706694","0.56997716","0.56929654","0.5683291","0.568157","0.568157","0.5670652","0.56700927","0.5665721","0.5665466","0.5665378","0.566428","0.566097","0.5653138","0.56483","0.56473124","0.5637153","0.5629207","0.5628895","0.56273615","0.562719","0.56244504","0.56168896","0.56152666","0.5609881"],"string":"[\n \"0.7405791\",\n \"0.71270245\",\n \"0.6805791\",\n \"0.67948574\",\n \"0.6551636\",\n \"0.6476551\",\n \"0.64614797\",\n \"0.6425553\",\n \"0.6342785\",\n \"0.63420993\",\n \"0.6332708\",\n \"0.633066\",\n \"0.6330074\",\n \"0.6298897\",\n \"0.62908417\",\n \"0.62799925\",\n \"0.62471\",\n \"0.62063324\",\n \"0.61783415\",\n \"0.6177655\",\n \"0.61492676\",\n \"0.6103034\",\n \"0.60990226\",\n \"0.60570467\",\n \"0.60409313\",\n \"0.601715\",\n \"0.6015817\",\n \"0.6010898\",\n \"0.6003754\",\n \"0.59715736\",\n \"0.5967609\",\n \"0.5958885\",\n \"0.595258\",\n \"0.59231687\",\n \"0.5919504\",\n \"0.591918\",\n \"0.5914721\",\n \"0.5896283\",\n \"0.5895937\",\n \"0.5888113\",\n \"0.58879983\",\n \"0.58612007\",\n \"0.5860122\",\n \"0.58575034\",\n \"0.58549076\",\n \"0.58512044\",\n \"0.58423156\",\n \"0.58388513\",\n \"0.58324647\",\n \"0.582239\",\n \"0.5817351\",\n \"0.58041096\",\n \"0.5795078\",\n \"0.5785493\",\n \"0.57818705\",\n \"0.577473\",\n \"0.57710975\",\n \"0.57705635\",\n \"0.5764597\",\n \"0.57593507\",\n \"0.5759117\",\n \"0.5750386\",\n \"0.5747177\",\n \"0.57456315\",\n \"0.57406026\",\n \"0.5738948\",\n \"0.5736493\",\n \"0.5727552\",\n \"0.5726234\",\n \"0.572506\",\n \"0.5724687\",\n \"0.5717582\",\n \"0.5714601\",\n \"0.5713584\",\n \"0.5708932\",\n \"0.5706694\",\n \"0.56997716\",\n \"0.56929654\",\n \"0.5683291\",\n \"0.568157\",\n \"0.568157\",\n \"0.5670652\",\n \"0.56700927\",\n \"0.5665721\",\n \"0.5665466\",\n \"0.5665378\",\n \"0.566428\",\n \"0.566097\",\n \"0.5653138\",\n \"0.56483\",\n \"0.56473124\",\n \"0.5637153\",\n \"0.5629207\",\n \"0.5628895\",\n \"0.56273615\",\n \"0.562719\",\n \"0.56244504\",\n \"0.56168896\",\n \"0.56152666\",\n \"0.5609881\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7152682"},"document_rank":{"kind":"string","value":"1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":81,"numItemsPerPage":100,"numTotalItems":95772,"offset":8100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NDE2OTg3NCwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzQxNzM0NzQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.xwN9splp53ppCl-6lq0oX9IbXkXEi_1X3PEGEGg71gfDF6NsrOhCBQcXgcgEmzTNfYD5lKGCqPscXXo9RFiHDA","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 |
|---|---|---|---|---|---|---|
import data from file asset = Only import for the asset that you want searchAndReplace = Change any part of the objects name to another word | def importData( self, asset = '', searchAndReplace = ['',''] ):
pickleData = pickle.load( open( self.dataPath.path, "rb" ) )
layers = [RenderLayerData(l,d) for l,d in pickleData.items() if not ':' in l]
for l in layers:
if not searchAndReplace [0]== '' or not searchAndReplace[1] == '':
l.filterMe( asset, searchAndReplace )
l.create()
l.addObjects()
l.makeOverrides()
l.makeOverrideConnections()
l.makeShaderOverride() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replace(name, newobject):",
"def renameAssetObjects(self):\n\t\tfor i,o in enumerate( self.objects ):\n\t\t\tmn.Node( o ).name = self.name + '%i'%i",
"def loadAssetTypeSpecialCaseFromFile(file):\n\tstringToTuple = compose(\n\t\ttuple\n\t , partial(map, lambda s: s.strip())\n\t , lambda s: s.split(',')\n\... | [
"0.61271197",
"0.5805997",
"0.5651167",
"0.5605872",
"0.5587787",
"0.5498569",
"0.54969203",
"0.53437096",
"0.53432715",
"0.5332981",
"0.532139",
"0.53159696",
"0.5253007",
"0.52161473",
"0.52138823",
"0.51546794",
"0.5153983",
"0.5098517",
"0.5057885",
"0.5048195",
"0.504511... | 0.67480993 | 0 |
import master settings from data file | def importMasterSettings(self):
pickleData = pickle.load( open( self.masterPath.path, "rb" ) )
master = rlayer.RenderLayer( 'defaultRenderLayer' )
master.makeCurrent()
for a in pickleData.keys():
try:
a.v = pickleData[a]
except:
continue | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_settings(self, config):\n user = config.get(self.bot.client.host, 'master')\n # Replace old master\n if ':master' in self.users and user != self.users[':master']:\n self.users[self.users[':master']]['rank'] = 'none'\n if not user in self.users:\n self.user... | [
"0.62687576",
"0.6112625",
"0.60982084",
"0.599278",
"0.59767",
"0.5931371",
"0.5877606",
"0.58080935",
"0.5805709",
"0.58034456",
"0.57821137",
"0.57619953",
"0.57555234",
"0.5754049",
"0.5751691",
"0.57266325",
"0.5715067",
"0.5707333",
"0.5681978",
"0.56536126",
"0.5650209... | 0.7781248 | 0 |
return the objects in the layer | def dataObjects(self):
return self._objects | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetObjects(self): \r\n return self.model.GetObjects()",
"def objects(self):",
"def objects(self):\n\t\treturn self._objects",
"def objects(self):\r\n return self._objects",
"def getAllLayers(self):\n jobItem = self.item(0, 0)\n layerObjects = [jobItem.child(row, 0).da... | [
"0.76588994",
"0.7365626",
"0.7147258",
"0.69459087",
"0.69181466",
"0.6739161",
"0.670558",
"0.6694696",
"0.65370286",
"0.6459321",
"0.6447105",
"0.64106923",
"0.63908225",
"0.6376006",
"0.6317398",
"0.63025784",
"0.63025784",
"0.63025784",
"0.63025784",
"0.63025784",
"0.630... | 0.6658779 | 8 |
return the overrides in the layer | def dataOverrides(self):
return self._overrides | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def overrides(self) -> ConfigNodePropertyArray:\n return self._overrides",
"def default_binding_overrides(self):\n return self.__default_binding_overrides",
"def ComponentOverrides(self):\n return tuple(self._json_obj.get('component_overrides', {}).items())",
"def makeOverrides(self):\n\t\tself.... | [
"0.6976614",
"0.6493725",
"0.6390087",
"0.6375561",
"0.6312835",
"0.6241755",
"0.60139596",
"0.59983903",
"0.5893521",
"0.5878425",
"0.5835658",
"0.5816514",
"0.5811458",
"0.58073103",
"0.5771545",
"0.5764795",
"0.57407266",
"0.5684022",
"0.5561158",
"0.5544201",
"0.55372936"... | 0.72761494 | 0 |
return the overrided connections | def dataOverconns(self):
return self._overconns | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_connections(self) -> _ConnectionsMap:\n seen: Dict[int, Any] = {}\n for parent in self.target.ancestors:\n if not isinstance(parent, NodeInstance):\n continue\n if parent is self.target.root:\n break\n if self.operation_host:\n ... | [
"0.72107756",
"0.719677",
"0.71520996",
"0.71520996",
"0.71160644",
"0.6827614",
"0.68155587",
"0.67435443",
"0.6729093",
"0.66902184",
"0.6677647",
"0.66670907",
"0.6593339",
"0.6425765",
"0.639215",
"0.63865095",
"0.6366969",
"0.63638633",
"0.63590074",
"0.6348137",
"0.6316... | 0.6257197 | 23 |
return the overrided shader | def dataShader(self):
return self._shader | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getFragmentShader(self):\n return self.fshader",
"def convert_shaders(self):\n raise NotImplementedError()",
"def setShader(self, *args):\n return _osgAnimation.RigTransformHardware_setShader(self, *args)",
"def get_shader_codes(self):\n vs = VS_TEMPLATE\n fs = FS_TEMPL... | [
"0.71515524",
"0.6992073",
"0.65359896",
"0.64718676",
"0.6368677",
"0.63054544",
"0.62507594",
"0.59390277",
"0.59311384",
"0.5861681",
"0.584541",
"0.5813607",
"0.5793342",
"0.5786723",
"0.5785204",
"0.578408",
"0.57676625",
"0.57501054",
"0.57129234",
"0.5711793",
"0.57105... | 0.6786076 | 2 |
filter data based on asset name and searchAndReplace data | def filterMe(self, asset = '', sAr = ['', ''] ):
if self._objects:
self._objects = [ mn.Node( o.name.replace( sAr[0], sAr[1] ) ) for o in self._objects ]
if self._overrides:
self._overrides = dict( [ (mn.Node( a.name.replace( sAr[0], sAr[1] )), self._overrides[a] ) for a in self._overrides.keys() ] )
if self._overconns:
self._overconns = dict( [(mn.Node(a.name.replace( sAr[0], sAr[1] )), mn.Node(self._overconns[a].name.replace( sAr[0], sAr[1] ))) for a in self._overconns.keys() ] ) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def healthcare_filter(df_all): \n #get requested assets under healthcare tag \n df_filtered = pandas.DataFrame(columns=['osm_id','asset','geometry']) #create df for saving data\n for row in range(len(df_all.index)): \n if 'healthcare' in df_all[\"asset\"][row]: #check if healthcare key ... | [
"0.6367185",
"0.59256476",
"0.5885273",
"0.5829923",
"0.5723036",
"0.5712686",
"0.5658041",
"0.55008304",
"0.5442001",
"0.543063",
"0.5343348",
"0.53341204",
"0.5302959",
"0.5286173",
"0.52814966",
"0.5254674",
"0.5248854",
"0.5234224",
"0.5183874",
"0.5160617",
"0.51445144",... | 0.52709234 | 15 |
make the overrdies based on data | def makeOverrides(self):
self.overridesWithValues = self.dataOverrides | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def crossover(p1, p2):\n genotype = []\n \n #Your code here\n \n return {'genotype': genotype, 'fitness': None}",
"def crossover(x1,x2):\n for chromo in x1.chromosomes:\n result_chromos = [np.zeros((chromo.shape))]\n #result_chromos = [np.zeros((chromo.shape)) for chromo in x1.chromos... | [
"0.5584811",
"0.55532134",
"0.5427016",
"0.5426902",
"0.53494334",
"0.53424084",
"0.5334913",
"0.52737105",
"0.5264165",
"0.52625084",
"0.52520084",
"0.5175564",
"0.51129985",
"0.5108802",
"0.5096884",
"0.5085431",
"0.50571185",
"0.50070727",
"0.5000612",
"0.49764836",
"0.497... | 0.0 | -1 |
When the user posts the find_org_to_create_account form, redirect to that page | def find_org_to_create_account(request):
if request.method != 'POST' or not request.POST.get('organization_slug'):
return HttpResponseRedirect(reverse('home'))
else:
org_slug = request.POST.get('organization_slug')
return HttpResponseRedirect(reverse('create_org_account', args=[org_slug])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def oauth_start_flow():\n # Have to do authentication!\n rest.default_user_authentication()\n\n account_type = flask.request.args.get('type')\n if account_type is None:\n flask.abort(400)\n\n cls = ACCOUNT_TYPES.get(account_type, None)\n if cls is None:\n flask.about(400)\n\n key = str(uuid.uuid4())\n... | [
"0.603463",
"0.6004999",
"0.5971245",
"0.5959396",
"0.5919654",
"0.58651173",
"0.58611304",
"0.58471966",
"0.582282",
"0.57899594",
"0.578932",
"0.57571214",
"0.57511485",
"0.574679",
"0.57035786",
"0.56987613",
"0.56865185",
"0.5668221",
"0.5650241",
"0.5633905",
"0.5633754"... | 0.81982374 | 0 |
runs gradient descent to find a minimum of x^2 + y^2 | def run_gradient_descent(seed=0):
random.seed(seed)
colors = [color for color in matplotlib.colors.cnames]
def random_point():
return (2 * random.random() - 1, 2 * random.random() - 1)
def df(x_i):
"""this is the gradient of x^2 + y^2"""
return [2 * x_ij for x_ij in x_i]
for color in random.sample(colors, 50):
path = take(10, gradient_descent(df, random_point()))
for i, (x, y) in enumerate(path):
plt.plot(x, y, color=color, marker='*', markersize=20-2*i)
plt.show() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gradient_descent(self, x, y):\n # Initialize weights vector\n self.weights = np.zeros(len(x[0]))\n\n # Storing number of training example in a variable \n n = len(x)\n\n # Initiate variables to keep track of the current and smallest loss recorded\n lowest_loss = sys.fl... | [
"0.6790553",
"0.66664946",
"0.6630496",
"0.64925885",
"0.6476258",
"0.64171803",
"0.6405911",
"0.6358458",
"0.63555044",
"0.6333278",
"0.6325413",
"0.62547517",
"0.62520844",
"0.624353",
"0.6242326",
"0.62349296",
"0.62339544",
"0.622683",
"0.62201583",
"0.61891985",
"0.61857... | 0.5771183 | 93 |
this is the gradient of x^2 + y^2 | def df(x_i):
return [2 * x_ij for x_ij in x_i] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gradient(self, x):\n pass",
"def compute_gradient (w, x, y):\n (n,d) = x.shape\n g = np.zeros(d)\n for i in range(0,d):\n g[i] = (w*x-y)*np.transpose(x[i])\n g += 0.5*w\n return g",
"def gradient(self, x):\n return 0.0",
"def calculate_gradient(... | [
"0.8220284",
"0.7768869",
"0.7596814",
"0.7590641",
"0.7536355",
"0.7535873",
"0.7492485",
"0.74524486",
"0.74460936",
"0.74246055",
"0.7422228",
"0.73773456",
"0.7359993",
"0.73566616",
"0.73448485",
"0.7335415",
"0.7270468",
"0.72532976",
"0.7230785",
"0.7145674",
"0.711091... | 0.0 | -1 |
this is the gradient of x^2 + y^2 | def df(x_i):
return [2 * x_ij for x_ij in x_i] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gradient(self, x):\n pass",
"def compute_gradient (w, x, y):\n (n,d) = x.shape\n g = np.zeros(d)\n for i in range(0,d):\n g[i] = (w*x-y)*np.transpose(x[i])\n g += 0.5*w\n return g",
"def gradient(self, x):\n return 0.0",
"def calculate_gradient(... | [
"0.8220871",
"0.7769543",
"0.7597072",
"0.7590164",
"0.75366026",
"0.7535663",
"0.7492575",
"0.7453598",
"0.7445228",
"0.7424073",
"0.74229896",
"0.73769474",
"0.73603284",
"0.735691",
"0.73446774",
"0.7335506",
"0.727039",
"0.7253472",
"0.7231205",
"0.7145222",
"0.71104634",... | 0.0 | -1 |
runs gradient descent to find a minimum of exp(x^3 / 3 + x y^2) | def run_gradient_descent2(seed=0):
colors = [color for color in matplotlib.colors.cnames]
def random_point():
return (3 * random.random() - 1, 3 * random.random() - 1)
def f(x):
"""has min at (1,0), saddle point at (-1,0)"""
return -math.exp(x[0]**3/-3 + x[0] - x[1]**2)
def df(x):
return ((1 - x[0]**2) * f(x), -2 * x[1] * f(x))
for color in random.sample(colors, 50):
path = take(100, gradient_descent(df, random_point()))
for i, (x, y) in enumerate(path):
plt.plot(x, y, color=color, marker='*', markersize=25-i/4)
plt.show() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gradient_ascent(self, w, X, y, lr):\r\n # INSERT YOUR CODE HERE\r\n #raise Exception('Function not yet implemented!')\r\n # gradient = x_j*(y-σ(wTX))\r\n return np.dot(X.T, y-self.sigmoid(np.dot(X, w)))",
"def gradient_descent(self, x, y):\n # Initialize weights vector\n ... | [
"0.69871354",
"0.683685",
"0.68088645",
"0.6712275",
"0.6709997",
"0.66748154",
"0.664998",
"0.66304016",
"0.6604216",
"0.6590052",
"0.65628034",
"0.655809",
"0.65575576",
"0.647663",
"0.64651537",
"0.6445425",
"0.64412385",
"0.6429857",
"0.64228696",
"0.64162236",
"0.6411271... | 0.5987452 | 75 |
has min at (1,0), saddle point at (1,0) | def f(x):
return -math.exp(x[0]**3/-3 + x[0] - x[1]**2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saddle_point(self):\n\n maxmin_value, maxmin_strategy_set = self.maxmin(0)\n minmax_value, minmax_strategy_set = self.minmax(1)\n\n if maxmin_value == minmax_value:\n return maxmin_strategy_set.intersection(minmax_strategy_set)\n return None",
"def exact_saddle(V,X,Y,Z,... | [
"0.71217895",
"0.6409307",
"0.6010213",
"0.58238053",
"0.5752256",
"0.57095367",
"0.56663626",
"0.5627546",
"0.55863583",
"0.5570218",
"0.55443054",
"0.55192417",
"0.54011667",
"0.53589064",
"0.5356541",
"0.53509325",
"0.5303866",
"0.5300293",
"0.52988297",
"0.5297635",
"0.52... | 0.0 | -1 |
has min at (1,0), saddle point at (1,0) | def f(x):
return -math.exp(x[0]**3/-3 + x[0] - x[1]**2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saddle_point(self):\n\n maxmin_value, maxmin_strategy_set = self.maxmin(0)\n minmax_value, minmax_strategy_set = self.minmax(1)\n\n if maxmin_value == minmax_value:\n return maxmin_strategy_set.intersection(minmax_strategy_set)\n return None",
"def exact_saddle(V,X,Y,Z,... | [
"0.712052",
"0.6408869",
"0.60100293",
"0.5823926",
"0.57521075",
"0.5708044",
"0.56659967",
"0.5627963",
"0.5585765",
"0.5570389",
"0.5544212",
"0.5519314",
"0.5401504",
"0.5359145",
"0.53573614",
"0.5350745",
"0.5303898",
"0.53009754",
"0.5297841",
"0.529778",
"0.5294022",
... | 0.0 | -1 |
df is a function of x_i, y_i, beta | def sgd_step(df, alpha, prev_beta, xy_i):
x_i, y_i = xy_i
gradient = df(x_i, y_i, prev_beta)
return [beta_j + alpha * df_j
for beta_j, df_j in zip(prev_beta, gradient)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_beta(self,df,tick,ind):\n cov = get_cov(df,tick,ind)\n var = df[ind].var()\n beta = cov / var\n return beta",
"def create_beta_posteriors(df):\n goods = df.num_matured - df.fpd\n df['alpha_p'] = df.alpha + df.fpd\n df['beta_p'] = df.beta + goods\n return df",
"de... | [
"0.68780404",
"0.6571103",
"0.65438884",
"0.6472203",
"0.62649596",
"0.622851",
"0.6134441",
"0.6110367",
"0.6021685",
"0.5859265",
"0.5851953",
"0.5832189",
"0.57926506",
"0.5776251",
"0.5776251",
"0.5743775",
"0.56781954",
"0.56520283",
"0.5651162",
"0.5608268",
"0.5604049"... | 0.66248494 | 1 |
Just a simple decorator to make the process of generating tests easier. | def Generatable(cls):
if hasattr(cls, 'generate_tests') and callable(cls.generate_tests):
def create_test_func(name, test_func):
setattr(cls, 'test_' + name.replace(' ', '_').lower(), test_func)
cls.generate_tests(create_test_func)
return cls | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spec_tests():\n pass",
"def test_something():",
"def unitary_test():",
"def test_dummy():",
"def tests():",
"def test_generate_all_testing(self):\n pass",
"def test_1():",
"def test_func():\n pass",
"def test_dummy_test():\n pass",
"def test_T1():",
"def test_T1():",
"def ... | [
"0.78306496",
"0.76522076",
"0.76440585",
"0.7547918",
"0.7521638",
"0.73572",
"0.7326144",
"0.7307783",
"0.7230892",
"0.7225894",
"0.7225894",
"0.7212739",
"0.7207286",
"0.71436405",
"0.7143635",
"0.71356994",
"0.71356994",
"0.71143264",
"0.711168",
"0.7106708",
"0.7092831",... | 0.6944086 | 34 |
Get the color of the mask at position. Using 2 bits as a color. | def get_color(mask: int, position: int):
return (mask >> (position << 1)) & 3 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mask_color(self):\n return self._mask_color",
"def set_color(mask: int, position: int, color: int):\n return mask | (color << (position << 1))",
"def get_color(self, point):\n \n d = point - self._origin\n dist = int(d.dot(d) ** 0.5) % 2\n if dist == 0:\n ... | [
"0.6762996",
"0.6617752",
"0.6400042",
"0.6352335",
"0.6179756",
"0.607116",
"0.60303086",
"0.5943762",
"0.59284455",
"0.58960706",
"0.58665735",
"0.58665735",
"0.58594924",
"0.5858215",
"0.58338976",
"0.57897294",
"0.5776139",
"0.5772793",
"0.5763152",
"0.5751781",
"0.574337... | 0.8632774 | 0 |
Set the color of the mask at position. Using 2 bits as a color. | def set_color(mask: int, position: int, color: int):
return mask | (color << (position << 1)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_color(mask: int, position: int):\n return (mask >> (position << 1)) & 3",
"def SetMaskColour(*args, **kwargs):\n return _gdi_.Bitmap_SetMaskColour(*args, **kwargs)",
"def setColorIndex(idx):\n dislin.setclr(idx)",
"def set_pixel(framebuf, x, y, color):\n index = (y >> 3) *... | [
"0.67938983",
"0.67375386",
"0.6516931",
"0.6429108",
"0.64179796",
"0.6417907",
"0.63744414",
"0.6285334",
"0.61303943",
"0.6114359",
"0.61034447",
"0.6082238",
"0.6080526",
"0.6059235",
"0.60527635",
"0.6043658",
"0.60351825",
"0.59847206",
"0.5964086",
"0.5936446",
"0.5918... | 0.8528009 | 0 |
Create a new ir.Set instance with given attributes. Absolutely all ir.Set instances must be created using this constructor. | def new_set(*, ctx: context.ContextLevel, **kwargs) -> irast.Set:
ir_set = irast.Set(**kwargs)
ctx.all_sets.append(ir_set)
return ir_set | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, **attributes):\n self.set(**attributes)",
"def __init__(self,\n *,\n attributes: List['Attribute'] = None) -> None:\n self.attributes = attributes",
"def newChemAtomSet(self, **attrlinks):\n return ChemAtomSet(self, **attrlinks)",
"def __ini... | [
"0.7283344",
"0.6427488",
"0.64081055",
"0.621952",
"0.620814",
"0.6190213",
"0.6113432",
"0.6045844",
"0.600017",
"0.600017",
"0.59091234",
"0.59091234",
"0.59091234",
"0.58970034",
"0.584854",
"0.5807153",
"0.5795997",
"0.5795997",
"0.579595",
"0.57853985",
"0.57681274",
... | 0.7015722 | 1 |
Create a new ir.Set from another ir.Set. The new Set inherits source Set's scope, schema item, expression, and, if preserve_scope_ns is set, path_id. If preserve_scope_ns is False, the new Set's path_id will be namespaced with the currently active scope namespace. | def new_set_from_set(
ir_set: irast.Set, *,
preserve_scope_ns: bool=False,
path_id: typing.Optional[irast.PathId]=None,
stype: typing.Optional[s_types.Type]=None,
ctx: context.ContextLevel) -> irast.Set:
if path_id is None:
path_id = ir_set.path_id
if not preserve_scope_ns:
path_id = path_id.merge_namespace(ctx.path_id_namespace)
if stype is None:
stype = ir_set.stype
result = new_set(
path_id=path_id,
path_scope_id=ir_set.path_scope_id,
stype=stype,
expr=ir_set.expr,
ctx=ctx
)
result.rptr = ir_set.rptr
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_set(*, ctx: context.ContextLevel, **kwargs) -> irast.Set:\n ir_set = irast.Set(**kwargs)\n ctx.all_sets.append(ir_set)\n return ir_set",
"def create_set(self, setname='new_set', based_on='data file', included=None,\n excluded=None, strings='keep', arrays='masks', replace=None,\... | [
"0.6440217",
"0.58299524",
"0.56834817",
"0.53686655",
"0.5344023",
"0.5315017",
"0.52834666",
"0.5264932",
"0.5153018",
"0.50790906",
"0.5055263",
"0.5012567",
"0.49638426",
"0.49290437",
"0.49098164",
"0.4880802",
"0.48652387",
"0.4844571",
"0.48155996",
"0.48035938",
"0.47... | 0.85868055 | 0 |
Create an ir.Set representing the given EdgeQL path expression. | def compile_path(expr: qlast.Path, *, ctx: context.ContextLevel) -> irast.Set:
anchors = ctx.anchors
path_tip = None
if expr.partial:
if ctx.partial_path_prefix is not None:
path_tip = ctx.partial_path_prefix
else:
raise errors.QueryError(
'could not resolve partial path ',
context=expr.context)
extra_scopes = {}
computables = []
path_sets = []
for i, step in enumerate(expr.steps):
if isinstance(step, qlast.Source):
# 'self' can only appear as the starting path label
# syntactically and is a known anchor
path_tip = anchors[step.__class__]
elif isinstance(step, qlast.Subject):
# '__subject__' can only appear as the starting path label
# syntactically and is a known anchor
path_tip = anchors[step.__class__]
elif isinstance(step, qlast.ObjectRef):
if i > 0:
raise RuntimeError(
'unexpected ObjectRef as a non-first path item')
refnode = None
if not step.module and step.name not in ctx.aliased_views:
# Check if the starting path label is a known anchor
refnode = anchors.get(step.name)
if refnode is not None:
path_tip = new_set_from_set(
refnode, preserve_scope_ns=True, ctx=ctx)
else:
stype = schemactx.get_schema_type(
step, item_types=(s_objtypes.ObjectType,), ctx=ctx)
if (stype.get_view_type(ctx.env.schema) is not None and
stype.get_name(ctx.env.schema) not in ctx.view_nodes):
# This is a schema-level view, as opposed to
# a WITH-block or inline alias view.
stype = stmtctx.declare_view_from_schema(stype, ctx=ctx)
path_tip = class_set(stype, ctx=ctx)
view_set = ctx.view_sets.get(stype)
if view_set is not None:
path_tip = new_set_from_set(view_set, ctx=ctx)
path_scope = ctx.path_scope_map.get(view_set)
extra_scopes[path_tip] = path_scope.copy()
view_scls = ctx.class_view_overrides.get(
stype.get_name(ctx.env.schema))
if view_scls is not None:
path_tip.stype = view_scls
elif isinstance(step, qlast.Ptr):
# Pointer traversal step
ptr_expr = step
ptr_target = None
direction = (ptr_expr.direction or
s_pointers.PointerDirection.Outbound)
if ptr_expr.target:
# ... link [IS Target]
ptr_target = schemactx.get_schema_type(
ptr_expr.target.maintype, ctx=ctx)
if not isinstance(ptr_target, s_objtypes.ObjectType):
raise errors.QueryError(
f'invalid type filter operand: '
f'{ptr_target.get_name(ctx.env.schema)} '
f'is not an object type',
context=ptr_expr.target.context)
ptr_name = ptr_expr.ptr.name
if ptr_expr.type == 'property':
# Link property reference; the source is the
# link immediately preceding this step in the path.
source = path_tip.rptr.ptrcls
else:
source = path_tip.stype
with ctx.newscope(fenced=True, temporary=True) as subctx:
if isinstance(source, s_abc.Tuple):
path_tip = tuple_indirection_set(
path_tip, source=source, ptr_name=ptr_name,
source_context=step.context, ctx=subctx)
else:
path_tip = ptr_step_set(
path_tip, source=source, ptr_name=ptr_name,
direction=direction, ptr_target=ptr_target,
ignore_computable=True,
source_context=step.context, ctx=subctx)
ptrcls = path_tip.rptr.ptrcls
if _is_computable_ptr(ptrcls, ctx=ctx):
computables.append(path_tip)
else:
# Arbitrary expression
if i > 0:
raise RuntimeError(
'unexpected expression as a non-first path item')
with ctx.newscope(fenced=True, temporary=True) as subctx:
path_tip = ensure_set(
dispatch.compile(step, ctx=subctx), ctx=subctx)
if path_tip.path_id.is_type_indirection_path(ctx.env.schema):
scope_set = path_tip.rptr.source
else:
scope_set = path_tip
extra_scopes[scope_set] = subctx.path_scope
for key_path_id in path_tip.path_id.iter_weak_namespace_prefixes():
mapped = ctx.view_map.get(key_path_id)
if mapped is not None:
path_tip = new_set(
path_id=mapped.path_id,
stype=path_tip.stype,
expr=mapped.expr,
rptr=mapped.rptr,
ctx=ctx)
break
path_sets.append(path_tip)
path_tip.context = expr.context
pathctx.register_set_in_scope(path_tip, ctx=ctx)
for ir_set in computables:
scope = ctx.path_scope.find_descendant(ir_set.path_id)
if scope is None:
# The path is already in the scope, no point
# in recompiling the computable expression.
continue
with ctx.new() as subctx:
subctx.path_scope = scope
comp_ir_set = computable_ptr_set(ir_set.rptr, ctx=subctx)
i = path_sets.index(ir_set)
if i != len(path_sets) - 1:
path_sets[i + 1].rptr.source = comp_ir_set
else:
path_tip = comp_ir_set
path_sets[i] = comp_ir_set
for ir_set, scope in extra_scopes.items():
node = ctx.path_scope.find_descendant(ir_set.path_id)
if node is None:
# The path portion not being a descendant means
# that is is already present in the scope above us,
# along with the view scope.
continue
fuse_scope_branch(ir_set, node, scope, ctx=ctx)
if ir_set.path_scope_id is None:
pathctx.assign_set_scope(ir_set, node, ctx=ctx)
return path_tip | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_set_from_set(\n ir_set: irast.Set, *,\n preserve_scope_ns: bool=False,\n path_id: typing.Optional[irast.PathId]=None,\n stype: typing.Optional[s_types.Type]=None,\n ctx: context.ContextLevel) -> irast.Set:\n if path_id is None:\n path_id = ir_set.path_id\n if... | [
"0.5790698",
"0.5771053",
"0.5408858",
"0.5098475",
"0.50746995",
"0.49623165",
"0.4907437",
"0.48602664",
"0.48467776",
"0.48467776",
"0.48342997",
"0.4825272",
"0.48136362",
"0.4735757",
"0.47344112",
"0.47056362",
"0.47041735",
"0.46564844",
"0.46460888",
"0.4642975",
"0.4... | 0.5753197 | 2 |
Return a Set node representing the new path tip. | def extend_path(
source_set: irast.Set,
ptrcls: s_pointers.Pointer,
direction: PtrDir=PtrDir.Outbound,
target: typing.Optional[s_nodes.Node]=None, *,
ignore_computable: bool=False,
force_computable: bool=False,
unnest_fence: bool=False,
same_computable_scope: bool=False,
ctx: context.ContextLevel) -> irast.Set:
if ptrcls.is_link_property(ctx.env.schema):
src_path_id = source_set.path_id.ptr_path()
else:
if direction != s_pointers.PointerDirection.Inbound:
source = ptrcls.get_near_endpoint(ctx.env.schema, direction)
if not source_set.stype.issubclass(ctx.env.schema, source):
# Polymorphic link reference
source_set = class_indirection_set(
source_set, source, optional=True, ctx=ctx)
src_path_id = source_set.path_id
if target is None:
target = ptrcls.get_far_endpoint(ctx.env.schema, direction)
path_id = src_path_id.extend(ptrcls, direction, target,
ns=ctx.path_id_namespace,
schema=ctx.env.schema)
target_set = new_set(stype=target, path_id=path_id, ctx=ctx)
ptr = irast.Pointer(
source=source_set,
target=target_set,
ptrcls=ptrcls,
direction=direction
)
target_set.rptr = ptr
if (not ignore_computable and _is_computable_ptr(
ptrcls, force_computable=force_computable, ctx=ctx)):
target_set = computable_ptr_set(
ptr, unnest_fence=unnest_fence,
same_computable_scope=same_computable_scope, ctx=ctx)
return target_set | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xpathNewNodeSet(self):\n ret = libxml2mod.xmlXPathNewNodeSet(self._o)\n if ret is None:raise xpathError('xmlXPathNewNodeSet() failed')\n return xpathObjectRet(ret)",
"def make_set(node):\n node.parent = node\n node.rank = 0",
"def visit_Set(self, node):\n self.generic_visi... | [
"0.62189937",
"0.5731682",
"0.5512014",
"0.55116665",
"0.5465013",
"0.5457394",
"0.5436884",
"0.5389255",
"0.53820276",
"0.5347002",
"0.52735144",
"0.52636284",
"0.5250073",
"0.5236279",
"0.51947445",
"0.51905155",
"0.5184115",
"0.5166615",
"0.5112369",
"0.510633",
"0.5062499... | 0.46827704 | 60 |
Return ir.Set for a pointer defined as a computable. | def computable_ptr_set(
rptr: irast.Pointer, *,
unnest_fence: bool=False,
same_computable_scope: bool=False,
ctx: context.ContextLevel) -> irast.Set:
ptrcls = rptr.ptrcls
source_set = rptr.source
source_scls = source_set.stype
# process_view() may generate computable pointer expressions
# in the form "self.linkname". To prevent infinite recursion,
# self must resolve to the parent type of the view NOT the view
# type itself. Similarly, when resolving computable link properties
# make sure that we use rptr.ptrcls.derived_from.
if source_scls.is_view(ctx.env.schema):
source_set = new_set_from_set(
source_set, preserve_scope_ns=True, ctx=ctx)
source_set.stype = source_scls.peel_view(ctx.env.schema)
source_set.shape = []
if source_set.rptr is not None:
schema = ctx.env.schema
derived_from = source_set.rptr.ptrcls.get_derived_from(schema)
if (derived_from is not None and
not derived_from.generic(schema) and
derived_from.get_derived_from(schema) is not None and
ptrcls.is_link_property(schema)):
source_set.rptr.ptrcls = derived_from
try:
qlexpr, qlctx, inner_source_path_id, path_id_ns = \
ctx.source_map[ptrcls]
except KeyError:
ptrcls_default = ptrcls.get_default(ctx.env.schema)
if not ptrcls_default:
ptrcls_sn = ptrcls.get_shortname(ctx.env.schema)
raise ValueError(
f'{ptrcls_sn!r} is not a computable pointer')
if isinstance(ptrcls_default, s_expr.ExpressionText):
qlexpr = astutils.ensure_qlstmt(qlparser.parse(ptrcls_default))
else:
qlexpr = qlast.BaseConstant.from_python(ptrcls_default)
qlctx = None
inner_source_path_id = None
path_id_ns = None
if qlctx is None:
# Schema-level computable, completely detached context
newctx = ctx.detached
else:
newctx = _get_computable_ctx(
rptr=rptr,
source=source_set,
source_scls=source_scls,
inner_source_path_id=inner_source_path_id,
path_id_ns=path_id_ns,
same_scope=same_computable_scope,
qlctx=qlctx,
ctx=ctx)
if ptrcls.is_link_property(ctx.env.schema):
source_path_id = rptr.source.path_id.ptr_path()
else:
source_path_id = rptr.target.path_id.src_path()
path_id = source_path_id.extend(
ptrcls,
s_pointers.PointerDirection.Outbound,
ptrcls.get_target(ctx.env.schema),
ns=ctx.path_id_namespace,
schema=ctx.env.schema)
with newctx() as subctx:
subctx.view_scls = ptrcls.get_target(ctx.env.schema)
subctx.view_rptr = context.ViewRPtr(
source_scls, ptrcls=ptrcls, rptr=rptr)
subctx.anchors[qlast.Source] = source_set
subctx.empty_result_type_hint = ptrcls.get_target(ctx.env.schema)
if isinstance(qlexpr, qlast.Statement) and unnest_fence:
subctx.stmt_metadata[qlexpr] = context.StatementMetadata(
is_unnest_fence=True)
comp_ir_set = dispatch.compile(qlexpr, ctx=subctx)
if ptrcls in ctx.pending_cardinality:
comp_ir_set_copy = copy.copy(comp_ir_set)
specified_card, source_ctx = ctx.pending_cardinality[ptrcls]
stmtctx.get_pointer_cardinality_later(
ptrcls=ptrcls, irexpr=comp_ir_set_copy,
specified_card=specified_card, source_ctx=source_ctx,
ctx=ctx)
def _check_cardinality(ctx):
if ptrcls.singular(ctx.env.schema):
stmtctx.enforce_singleton_now(comp_ir_set_copy, ctx=ctx)
stmtctx.at_stmt_fini(_check_cardinality, ctx=ctx)
comp_ir_set.stype = ptrcls.get_target(ctx.env.schema)
comp_ir_set.path_id = path_id
comp_ir_set.rptr = rptr
rptr.target = comp_ir_set
return comp_ir_set | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSet(unique_name):",
"def getSet(unique_name):",
"def set():",
"def visit_Set(self, node):\n self.generic_visit(node)\n return to_call(to_attribute(self.operator, '__set__'), node.elts)",
"def set_of(element: Type) -> SetType:\n return SetType(element)",
"def __rxor__(self, other: ... | [
"0.63821733",
"0.63821733",
"0.6101638",
"0.60650355",
"0.5940626",
"0.5939873",
"0.5794654",
"0.5785868",
"0.5782201",
"0.5721857",
"0.5620131",
"0.55960476",
"0.559237",
"0.55909944",
"0.55824697",
"0.5576209",
"0.55492747",
"0.5549152",
"0.55308235",
"0.551",
"0.5487735",
... | 0.69799614 | 0 |
Requests should have a section of the config file and variable/field in that section to be returned in the response body. | def on_get(self, req, resp, section, field):
resp.content_type = 'text/text'
resp.body = self.direct_get(field, section) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, request, format=None):\n return Response({k: getattr(config, k) for k in list(dir(config))})",
"def output_config() -> Response:\n c = dict(config)\n c['password'] = \"*********\"\n return jsonify(c)",
"def get_config(req):\n #try:\n # user_id = req.user\n ... | [
"0.6424139",
"0.610865",
"0.6059112",
"0.5978963",
"0.5865252",
"0.577705",
"0.56624496",
"0.55671096",
"0.5566648",
"0.55476516",
"0.5478806",
"0.54480094",
"0.5438941",
"0.5410219",
"0.54032665",
"0.5333807",
"0.5330522",
"0.53133196",
"0.5285215",
"0.5283924",
"0.5283706",... | 0.5230246 | 26 |
read the maps and get the set of unique rs | def getLCD(lbase=[]):
listmf = []
rsdict = {}
for i,basename in enumerate(lbase): # for each basename to be included
mf = file('%s.map' % basename,'r').readlines()
lmap = [x.strip().split() for x in mf]
rslist = [x[1] for x in lmap] # chrom rs gendist physdist
for x in lmap:
rsdict[x[1]] = (x[0],int(x[3]),x[1]) # key by chrom,offset,rs
setrs = set(rslist)
listmf.append(setrs) # list of map lines for processing
lcd = listmf.pop(0) # start with first - order doesn't matter
for setrs in listmf:
lcd = lcd & setrs # intersection
lcd = list(lcd) # now have lowest common denom as a list of rs
lcdmap = [rsdict[rs] for rs in lcd] # restore chrom,offset,rs for rs to keep
lcdmap.sort() # now in genomic order
print 'got lcdmap=',lcdmap[:10]
return lcdmap # sorted common map
| {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSet(unique_name):",
"def getSet(unique_name):",
"def getSets(unique_name=None):",
"def _findUniqueMappingValues(mapping):\n uniqueMappingValues = set()\n for entries in viewvalues(mapping):\n if len(entries) == 1:\n uniqueMappingValues.update(entries)\n return uniqueMappingV... | [
"0.65541935",
"0.65541935",
"0.63683355",
"0.6343676",
"0.60978246",
"0.6096743",
"0.6089678",
"0.595537",
"0.58867276",
"0.5861434",
"0.577347",
"0.57008076",
"0.56791395",
"0.5647053",
"0.56417656",
"0.5591158",
"0.5569142",
"0.5543664",
"0.5527229",
"0.5526804",
"0.550279"... | 0.0 | -1 |
return founder and offspring subset of basename.ped containing only the markers in lcd lcd contains a sorted list of (chrom,offset,rs) for the common snps in all maps we need to keep genotypes all in the same column order | def subsetPed(basename="",lcdmap = [],faff='1', ofaff='2'):
mf = file('%s.map' % basename,'r').readlines()
lmap = [x.strip().split() for x in mf]
rscols = {} # lookup marker table
colrs = [] # lookup rs from column
for i,m in enumerate(lmap): # get columns to keep in the order we want them
rscols[m[1]] = i # keep track of where each rs is in this map
colrs.append(m[1]) # and keep the list of rs for tracking alleles
wewant = [rscols[x[2]] for x in lcdmap] # columns we want to keep
print '#Subsetped faff=%s ofaff=%s keeping %d (%s) of potential lcd %d for %s' % \
(faff,ofaff,len(wewant),wewant[:20],len(lcdmap),basename)
pf = file('%s.ped' % basename,'r')
ogeno = [] # offspring new lines
fgeno = [] # founders
oped = [] # for pedigrees
fped = []
rsadict = {} # keep a count of alleles - seems to be a problem
for i,l in enumerate(pf):
if (i+1) % 500 == 0:
print '%s at line %d' % (basename,i+1)
ll = l.strip().split()
ped = ll[:6]
founder = (ll[2] == '0' and ll[3] == '0')
aff = faff
if not founder:
aff = ofaff
ped[5] = aff # adjust as needed
if founder:
fped.append(ped)
else:
oped.append(ped)
gt = ll[6:]
geno = []
for snp in wewant: # columns in order
thisrs = colrs[snp]
base = snp*2
g1 = gt[base]
g2 = gt[base+1]
geno.append(g1)
geno.append(g2)
if not rsadict.get(thisrs,None):
rsadict[thisrs] = {}
if g1 <> '0':
if not rsadict[thisrs].get(g1,None):
rsadict[thisrs][g1] = 1
else:
rsadict[thisrs][g1] += 1
if g2 <> '0':
if not rsadict[thisrs].get(g2,None):
rsadict[thisrs][g2] = 1
else:
rsadict[thisrs][g2] += 1
keepgt = array.array('c',geno)
if founder:
fgeno.append(keepgt)
else:
ogeno.append(keepgt)
print '#Subsetped %s %d fgeno %d ogeno' % (basename,len(fgeno),len(ogeno))
return fped,oped,fgeno,ogeno,rsadict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getLCD(lbase=[]):\r\n listmf = []\r\n rsdict = {}\r\n for i,basename in enumerate(lbase): # for each basename to be included\r\n mf = file('%s.map' % basename,'r').readlines()\r\n lmap = [x.strip().split() for x in mf] \r\n rslist = [x[1] for x in lmap] # chrom rs gendist physdist... | [
"0.6327156",
"0.61232364",
"0.56347793",
"0.56296253",
"0.5618694",
"0.5515025",
"0.54627013",
"0.5458853",
"0.538327",
"0.53801644",
"0.53717375",
"0.52709544",
"0.5267916",
"0.52162147",
"0.5175573",
"0.5166157",
"0.51569754",
"0.5155961",
"0.51448816",
"0.5137253",
"0.5111... | 0.675231 | 0 |
take a list of basenames, get lcd and merge set founder affection according to faff flag and offspring according to ofaff flag | def mergePed(bnlist=[],faff=[],ofaff=[],newbasename='newped',fo=0):
lcdmap = getLCD(bnlist) # list of chr,offset,rs for all snp common to all files
print 'got %d lcd snps-%s' % (len(lcdmap),lcdmap[:5])
cfped = []
coped = []
cfgeno = []
cogeno = []
allrsa = {}
ignorers = {}
for i,basename in enumerate(bnlist):
fped,oped,fgeno,ogeno,trsadict = subsetPed(basename,lcdmap,faff[i],ofaff[i])
print '%s gave %d fgeno' % (basename,len(fgeno))
for rs in trsadict.keys():
tk = trsadict[rs].keys()
if len(tk) > 2:
print 'for %s, rs %s has alleles %s' % (basename, rs, trsadict[rs])
if not allrsa.get(rs,None):
allrsa[rs] = {}
for a in tk:
if not allrsa[rs].get(a,None):
allrsa[rs][a] = trsadict[rs][a]
else:
allrsa[rs][a] += trsadict[rs][a]
tk = allrsa[rs].keys()
if len(tk) > 2 and not ignorers.get(rs,None): # new
#print 'After merge basename %s, rs %s has alleles %s' % (basename, rs,allrsa[rs])
ignorers[rs] = rs
cfped += fped
coped += oped
cfgeno += fgeno
cogeno += ogeno
print 'after merge all have %d fgeno and %d ogeno' % (len(cfgeno),len(cogeno))
# now have offspring and founder rows in lcdmap order
# write map file
print '### found %d markers > 2 alleles' % (len(ignorers.keys()))
keepmarkers = [x for x in range(len(lcdmap)) if not ignorers.get(lcdmap[x][2],None)]
newmap = ['\t'.join((lcdmap[x][0],lcdmap[x][2],'0','%d' % lcdmap[x][1])) for x in keepmarkers] # chrom,offset,rs
f = file('%s.map' % newbasename,'w')
f.write('%s\n' % '\n'.join(newmap))
f.close()
for i,geno in enumerate(cfgeno): # convert each array into a list and keep the good markers
gs = ''.join(['%s%s' % (geno[2*x],geno[2*x + 1]) for x in keepmarkers])
g = array.array('c',gs) # good ones
cfgeno[i] = g # replace
print 'cfgeno converted'
if not fo: # not founders only - note arrays are not lists!
cfped += copy.copy(coped) #
del coped
for i,geno in enumerate(cogeno): # convert each array into a list and keep the good markers
gs = ''.join(['%s%s' % (geno[2*x],geno[2*x + 1]) for x in keepmarkers])
g = array.array('c',gs) # good ones
cfgeno.append(g) # extend founders
del cogeno
print 'after if not fo now have %d cfgeno' % (len(cfgeno))
f = file('%s.ped' % newbasename,'w')
for n,ped in enumerate(cfped):
l = ' '.join(ped + list(cfgeno[n]))
if n % 100 == 0 and n > 0:
print 'writing line %d' % n
f.write(l)
f.write('\n')
f.close()
print 'wrote %d map rows and %d ped rows to %s' % (len(newmap),len(cfped),newbasename) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def autocontext_forests(dirname):\n rf_files = []\n for filename in os.listdir(dirname):\n fullname = os.path.join(dirname, filename)\n if os.path.isfile(fullname) and len(filename) >= 8:\n base, middle, end = filename[:3], filename[3:-4], filename[-4:]\n if base == \"rf_\... | [
"0.58278376",
"0.569089",
"0.5623684",
"0.56120443",
"0.5441088",
"0.53539836",
"0.5308381",
"0.5256427",
"0.52116",
"0.51895374",
"0.5147063",
"0.5108449",
"0.51060414",
"0.5100264",
"0.5047533",
"0.5038564",
"0.5021236",
"0.5014878",
"0.50056285",
"0.49947405",
"0.49672922"... | 0.64975625 | 0 |
Test list secrets when not connected to any cluster. | def test_secrets_list_server_not_reachable():
message = "REANA client is not connected to any REANA cluster."
reana_token = "000000"
runner = CliRunner()
result = runner.invoke(cli, ["secrets-list", "-t", reana_token])
assert result.exit_code == 1
assert message in result.output | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def list_secrets(self):\n pass",
"def test_read_namespaced_secret_list_secrets(self):\n pass",
"def test_secrets_list_server_no_token():\n message = \"Please provide your access token\"\n env = {\"REANA_SERVER_URL\": \"localhost\"}\n runner = CliRunner(env=env)\n result = runner... | [
"0.7848596",
"0.77356535",
"0.73634505",
"0.71850795",
"0.7145914",
"0.6926122",
"0.674381",
"0.655007",
"0.64121014",
"0.639309",
"0.6267915",
"0.6263949",
"0.6144681",
"0.61244977",
"0.6104293",
"0.6090162",
"0.6053545",
"0.60486376",
"0.601324",
"0.59840655",
"0.59817785",... | 0.77385426 | 1 |
Test list secrets when access token is not set. | def test_secrets_list_server_no_token():
message = "Please provide your access token"
env = {"REANA_SERVER_URL": "localhost"}
runner = CliRunner(env=env)
result = runner.invoke(cli, ["secrets-list"])
assert result.exit_code == 1
assert message in result.output | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_read_namespaced_secret_list_secrets(self):\n pass",
"def test_check_secrets(self):\n secrets.check_secrets([], argparse.Namespace())",
"def test_secrets_list_server_not_reachable():\n message = \"REANA client is not connected to any REANA cluster.\"\n reana_token = \"000000\"\n ... | [
"0.71583724",
"0.697432",
"0.6764023",
"0.6734302",
"0.657616",
"0.6429628",
"0.63544613",
"0.6260767",
"0.6180775",
"0.61721295",
"0.61655974",
"0.6159696",
"0.6127158",
"0.6099549",
"0.60978544",
"0.60681677",
"0.60320014",
"0.60044026",
"0.59975713",
"0.59924906",
"0.59404... | 0.77104926 | 0 |
Test list secrets successfull. | def test_secrets_list_ok():
status_code = 200
response = [{"name": "password", "type": "env"}]
env = {"REANA_SERVER_URL": "localhost"}
mock_http_response, mock_response = Mock(), Mock()
mock_http_response.status_code = status_code
mock_response = response
reana_token = "000000"
runner = CliRunner(env=env)
with runner.isolation():
with patch(
"reana_client.api.client.current_rs_api_client",
make_mock_api_client("reana-server")(mock_response, mock_http_response),
):
result = runner.invoke(cli, ["secrets-list", "-t", reana_token])
assert result.exit_code == 0
assert "password" in result.output
assert "env" in result.output | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def list_secrets(self):\n pass",
"def test_read_namespaced_secret_list_secrets(self):\n pass",
"def test_secrets_list_server_no_token():\n message = \"Please provide your access token\"\n env = {\"REANA_SERVER_URL\": \"localhost\"}\n runner = CliRunner(env=env)\n result = runner... | [
"0.7842545",
"0.7786088",
"0.7250055",
"0.7128142",
"0.70077723",
"0.69276756",
"0.6661624",
"0.6632881",
"0.64265823",
"0.640965",
"0.64062554",
"0.6279332",
"0.6268154",
"0.6260419",
"0.6230832",
"0.6193241",
"0.6184802",
"0.6167017",
"0.6167011",
"0.6167011",
"0.6139364",
... | 0.74387324 | 2 |
Test adding secrets with wrong format. | def test_secrets_add_wrong_format(secret):
reana_token = "000000"
env = {"REANA_SERVER_URL": "localhost"}
runner = CliRunner(env=env)
message = 'For literal strings use "SECRET_NAME=VALUE" format'
result = runner.invoke(cli, ["secrets-add", "-t", reana_token, "--env", secret])
assert result.exit_code == 1
assert message in result.output | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_check_secrets(self):\n secrets.check_secrets([], argparse.Namespace())",
"def test_generate_secret(self):\n random_secret = ef_password.generate_secret(24)\n self.assertEqual(len(random_secret), 24)\n assert not set('[~!@#$%^&*()_+{}\":;\\']+$').intersection(random_secret)",
"def test_... | [
"0.75044936",
"0.707541",
"0.70254934",
"0.6977966",
"0.67734826",
"0.67173374",
"0.6702236",
"0.66481084",
"0.6610407",
"0.6495734",
"0.642665",
"0.6363775",
"0.63510156",
"0.6331783",
"0.6269925",
"0.6216668",
"0.6207249",
"0.61964357",
"0.61894506",
"0.6124794",
"0.6116386... | 0.8482589 | 0 |
Test adding secrets when they already exist. | def test_secrets_add_already_exist():
status_code = 409
reana_token = "000000"
env = {"REANA_SERVER_URL": "localhost"}
message = "One of the secrets already exists. No secrets were added."
mock_http_response = Mock(
status_code=status_code,
reason="Conflict",
json=Mock(return_value={"message": "Conflict"}),
)
rs_api_client_mock = Mock()
rs_api_client_mock.api.add_secrets = Mock(side_effect=HTTPError(mock_http_response))
runner = CliRunner(env=env)
with runner.isolation():
with patch("reana_client.api.client.current_rs_api_client", rs_api_client_mock):
result = runner.invoke(
cli, ["secrets-add", "-t", reana_token, "--env", "USER=reanauser"]
)
assert message in result.output
assert result.exit_code == 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_check_secrets(self):\n secrets.check_secrets([], argparse.Namespace())",
"def test_secret(self, env: yaenv.Env):\n assert env.secret() == 'notsosecret'\n assert 'NEW_SECRET_KEY' not in env\n _secret = env.secret('NEW_SECRET_KEY')\n assert _secret is not None\n a... | [
"0.7291631",
"0.7147517",
"0.6715984",
"0.6684597",
"0.66473454",
"0.66376173",
"0.6494984",
"0.6443271",
"0.6437272",
"0.6393369",
"0.629985",
"0.6255083",
"0.62139803",
"0.61440545",
"0.602208",
"0.5996874",
"0.5979041",
"0.5953571",
"0.59042215",
"0.58320487",
"0.58229697"... | 0.7203451 | 1 |
Optimized version of the generic paginate_query_across_partitioned_databases for case schedules queue_schedule_instances uses a lock to ensure that the same case_id cannot be queued within one hour of another instance The celery tasks handle_case_alert_schedule_instance and handle_case_timed_schedule_instance both use locks to ensure only one taks is operating on a case at one time. Each task also checks if the schedule is still valid on this case before processing it further Assumes that q_expression includes active = True | def _paginate_query_across_partitioned_databases(model_class, q_expression, load_source):
from corehq.messaging.scheduling.scheduling_partitioned.models import (
CaseAlertScheduleInstance,
CaseTimedScheduleInstance,
)
if model_class not in (CaseAlertScheduleInstance, CaseTimedScheduleInstance):
raise TypeError("Expected CaseAlertScheduleInstance or CaseTimedScheduleInstance")
db_names = get_db_aliases_for_partitioned_query()
for db_name in db_names:
for row in _paginate_query(db_name, model_class, q_expression, load_source):
yield row | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scheduling_method(self, cur_time, es, es_dict):\n dispatching_plan = []\n\n resource_types = self.resource_manager.resource_types\n avl_resources = self.resource_manager.current_availability\n system_capacity = self.resource_manager.system_capacity('nodes')\n\n # ============... | [
"0.5548428",
"0.5151464",
"0.48518416",
"0.47420847",
"0.46796945",
"0.46776414",
"0.4667777",
"0.4659418",
"0.46430779",
"0.46141425",
"0.45946392",
"0.45765543",
"0.4571356",
"0.45686328",
"0.45587033",
"0.45582697",
"0.4556789",
"0.45445147",
"0.454312",
"0.4534792",
"0.45... | 0.62616307 | 0 |
Exponential Linear Unit function. | def elu(x, alpha=1.0):
# https://github.com/muupan/chainer-elu
return ELU(alpha=alpha)(x) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exponential(value):\n return math.exp(value)",
"def calculate_exponent():\n pass",
"def exp(x):\n raise NotImplementedError",
"def inverse_exponential(x):\n return math.exp(-x)",
"def exponential(self) -> np.ndarray:\n if self.is_real():\n return np.array([1.0,... | [
"0.6901193",
"0.68407923",
"0.6819991",
"0.6726578",
"0.667672",
"0.66451716",
"0.66354614",
"0.6521205",
"0.6373172",
"0.6362633",
"0.6341832",
"0.6321374",
"0.6235829",
"0.6235829",
"0.6159893",
"0.6137865",
"0.61260146",
"0.6114578",
"0.61126935",
"0.60865015",
"0.6084545"... | 0.6120061 | 17 |
Rearrange Array Elements so as to form two number such that their sum is maximum. | def rearrange_digits(input_list):
## Corner cases:
if len(input_list) == 0:
return [0, 0]
elif len(input_list) == 1:
return [input_list[0], 0]
# Sort an array using merge-sort
sorted_list = merge_sort(input_list)
# Create two empty array and pop largest number from an sorted_list
# and push into each empty array one by one
# This also ensures that the number of digits in both the numbers cannot differ by more than 1
first_num_list = list()
second_num_list = list()
while sorted_list:
first_num_list.append(sorted_list.pop())
# Break the while loop if array is empty
if not sorted_list:
break
second_num_list.append(sorted_list.pop())
first_num = int("".join(str(i) for i in first_num_list))
second_num = int("".join(str(i) for i in second_num_list))
# Create an output array of two nums
out_list = []
out_list.append(first_num)
out_list.append(second_num)
return out_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max_pairwise_product_sort(array):\n if len(array) <= 1:\n return 0\n\n array.sort()\n\n return array[-1] * array[-2]",
"def max_pairwise_product_linear(array):\n\n if len(array) <= 1:\n return 0\n\n two_biggest_values = [0, 0]\n\n for element in array:\n if element > tw... | [
"0.714988",
"0.6825663",
"0.65861666",
"0.65528435",
"0.6125746",
"0.61184865",
"0.611382",
"0.60502493",
"0.6019517",
"0.5999914",
"0.5950047",
"0.5939359",
"0.58605045",
"0.5847725",
"0.5821236",
"0.58049685",
"0.57983345",
"0.576433",
"0.57470614",
"0.574322",
"0.5742154",... | 0.56220305 | 31 |
This method is used to terminate a job with the specified or a group of jobs job_id or job_name in a given cluster | def delete(cls, cluster, job, group=None):
try:
if group is not None:
# get the job ids from the db
arguments = {'cluster': cluster,
'group': group}
db_jobs = cls.cm.find('batchjob',
**arguments)
list1 = []
for i in db_jobs:
list1.append(db_jobs[i]['job_id'])
# read active jobs
active_jobs = json.loads(cls.queue(cluster))
list2 = []
for i in active_jobs:
list2.append(active_jobs[i]['jobid'])
# find intersection
res = set(list1).intersection(set(list2))
if res is not None:
for j in res:
cmd = 'scancel {}'.format(str(j))
Shell.ssh(cluster, cmd)
print("Deleted {}".format(j))
return "All jobs for group {} killed successfully".format(group)
else:
args = 'scancel '
if job.isdigit():
args += job
else:
args += "-n {}".format(job)
Shell.ssh(cluster, args)
return "Job {} killed successfully".format(job)
except Exception as ex:
print("in exceptio")
print(ex)
return ex | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def terminate(ctx):\n ctl = ctx.ctl\n jobs = ctl('list-avail', '--partition', 'main', flatten=False)\n\n for job in jobs:\n jobid = job['id']\n click.echo('Terminating {}'.format(jobid))\n ctl('terminate', '--jobid', jobid)",
"def kill_job(self, job):\n\n if job.status == Job... | [
"0.69394773",
"0.6439822",
"0.6429004",
"0.63975894",
"0.6377325",
"0.6343466",
"0.6278735",
"0.62779915",
"0.62628543",
"0.61729574",
"0.6161055",
"0.61369205",
"0.6120452",
"0.61027503",
"0.60934454",
"0.60848886",
"0.60653436",
"0.6043757",
"0.5999601",
"0.5956319",
"0.595... | 0.7375492 | 0 |
Constructor to create instance of the Line object. | def __init__(self, p1=None, p2=None, tolerance=None, l=None):
if l is None:
p1_arr = np.array(p1, dtype=float)
p2_arr = np.array(p2, dtype=float)
delta = p2_arr - p1_arr
norm2 = delta[0] ** 2 + delta[1] ** 2 + delta[2] ** 2
norm1 = np.math.sqrt(norm2)
if norm2 == 0:
raise Exception("Norm is zero!")
# Line direction.
self.direction = delta / norm1
# Line point closest to the origin.
self.zero = p1_arr - np.dot(p1_arr, delta) / norm2
# Tolerance below which points are considered identical.
self.tolerance = 1e-10 if tolerance is None else tolerance
else:
# Tolerance below which points are considered identical.
self.tolerance = l.tolerance
# Line direction.
self.direction = l.direction
# Line point closest to the origin.
self.zero = l.zero | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, vertices, **kwargs):\n super(Line, self).__init__(vertices, **kwargs)\n self._geotype = \"Line\"\n return",
"def __init__(self, start, end, oldLine = None):\n self.__start = start\n self.__end = end\n if(self.__start == self.__end):\n \"\"\"... | [
"0.80231184",
"0.7601697",
"0.7555074",
"0.74823064",
"0.74259686",
"0.73953325",
"0.7313491",
"0.6963556",
"0.69590884",
"0.6912488",
"0.69103134",
"0.68802094",
"0.6859208",
"0.6848757",
"0.68076146",
"0.6779403",
"0.674837",
"0.674837",
"0.6747915",
"0.6672266",
"0.6634589... | 0.65474164 | 23 |
Function to set the tolerance. | def set_tolerance(self, tol):
self.tolerance = tol | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tolerance(self, tolerance: float) -> None:\n self._tolerance = tolerance",
"def set_tolerance(self, value):\n\n self._tolerance = value",
"def set_tolerance(self, tol):\n self.precision = tol\n return",
"def tol(self, value):\n self._tol = value",
"def set_tol(self, t... | [
"0.8269015",
"0.81052655",
"0.79584485",
"0.7956575",
"0.78157336",
"0.7737034",
"0.7723517",
"0.76122135",
"0.7429519",
"0.7174162",
"0.71566623",
"0.7126722",
"0.7088782",
"0.68695533",
"0.6833426",
"0.676617",
"0.66971606",
"0.668103",
"0.66773707",
"0.665312",
"0.6650963"... | 0.8542296 | 0 |
Function to get the tolerance. Returns | def get_tolerance(self):
return self.tolerance | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tolerance(self):\n return self.params['tolerance']",
"def tolerance(self):\n return self._tolerance",
"def tolerance(self) -> float:\n return self._tolerance",
"def tol(self):\n return self._tol",
"def get_tolerance(self):\n\n if Test.global_tolerance is None:\n ... | [
"0.8676137",
"0.8571045",
"0.84762627",
"0.8150256",
"0.8027628",
"0.80256224",
"0.7848701",
"0.7472672",
"0.73756516",
"0.7373416",
"0.71266186",
"0.69214386",
"0.6822433",
"0.6734726",
"0.6684235",
"0.6613367",
"0.6550089",
"0.6541348",
"0.6453469",
"0.63813984",
"0.6317363... | 0.8477005 | 2 |
Function to revert the direction of the current line. Returns | def revert(self):
reverted = Line(l=self)
reverted.direction *= -1.0
return reverted | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fliped(self):\n return Line(self.end, self.start, self)",
"def reversed(self):\n return LINE(*self.elems,**{'reverse':(not self.reverse)})",
"def _inverse_lines(self):\n pass",
"def revert(self, *args, **kwargs):",
"def _backup_line(self):\n if self._orig_line is None:\n ... | [
"0.68525314",
"0.6473832",
"0.64653385",
"0.64345104",
"0.64087176",
"0.6327431",
"0.6293631",
"0.6287279",
"0.62672716",
"0.6193143",
"0.6137352",
"0.61128193",
"0.6102303",
"0.60842335",
"0.60765207",
"0.6057564",
"0.60540533",
"0.60380507",
"0.6030797",
"0.60029155",
"0.59... | 0.85526377 | 0 |
Function to get the direction of the line. Returns | def get_direction(self):
return self.direction | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_direction(self):\n return self.actual_coordinates[2]",
"def get_direction(self):\r\n return self.__direction",
"def direction(self):\n return atan2d(self.y, self.x)",
"def getDirection(self):\n return self.ray.direction",
"def direction(self):\r\n return 180 - ata... | [
"0.7764746",
"0.74921775",
"0.74461246",
"0.7236827",
"0.7222495",
"0.7183815",
"0.7064334",
"0.7050146",
"0.7007524",
"0.69288164",
"0.69204354",
"0.69024444",
"0.6901476",
"0.6863641",
"0.6818004",
"0.67975605",
"0.67823666",
"0.6723684",
"0.6717148",
"0.67071515",
"0.66958... | 0.7374277 | 3 |
Get the line point closest to the origin. Returns | def get_origin(self):
return self.zero | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def closest(self, x):\n # http://www.ahinson.com/algorithms_general/Sections/Geometry/PluckerLine.pdf\n # has different equation for moment, the negative\n\n x = arg.getvector(x, 3)\n\n lam = np.dot(x - self.pp, self.uw)\n p = self.point(lam) # is the closest point on the line\n... | [
"0.752301",
"0.741795",
"0.73585206",
"0.7312732",
"0.7232914",
"0.71674716",
"0.71045464",
"0.69818723",
"0.6970222",
"0.69567466",
"0.6912792",
"0.6912227",
"0.68720096",
"0.67963266",
"0.67862755",
"0.6759423",
"0.67402595",
"0.6738672",
"0.67113775",
"0.67095816",
"0.6697... | 0.0 | -1 |
Function to get the abscissa of a point with respect to a line. The abscissa is 0 if the projection of the point and the projection of the frame origin on the line are the same point. | def get_abscissa(self, p):
return np.dot(p - self.zero, self.direction) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_line_to(self, point):\n\n b = ((self.x - point.x)*point.y - (self.y - point.y)*point.x)/(self.x - point.x)\n\n a = (self.y - point.y)/(self.x - point.x)\n\n return a, b",
"def _dist_point2line(self, point: ndarray,\n line: Tuple[ndarray, ndarray]) -> ndarray:\... | [
"0.659462",
"0.6087625",
"0.6012542",
"0.59856695",
"0.58890575",
"0.58882195",
"0.5846869",
"0.5727574",
"0.57215995",
"0.57181567",
"0.57152516",
"0.56363255",
"0.5614506",
"0.5601204",
"0.55724233",
"0.55630857",
"0.55362034",
"0.5515001",
"0.5511656",
"0.55000144",
"0.548... | 0.6117362 | 1 |
Function to get one point from the line. | def point_at(self, abscissa):
return self.zero + abscissa * self.direction | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pick_point_not_on_line(line: Line):\n return line.point1 + line.get_perpendicular_at_point(line.point1).get_direction_vector()",
"def get_line_to(self, point):\n\n b = ((self.x - point.x)*point.y - (self.y - point.y)*point.x)/(self.x - point.x)\n\n a = (self.y - point.y)/(self.x - point.... | [
"0.7592827",
"0.7068464",
"0.6940365",
"0.6910205",
"0.6897533",
"0.68894476",
"0.6816368",
"0.6789263",
"0.67315537",
"0.6678987",
"0.66766155",
"0.66728306",
"0.66517955",
"0.66410375",
"0.663569",
"0.6616116",
"0.6613046",
"0.65880394",
"0.6556479",
"0.6535376",
"0.6529306... | 0.0 | -1 |
Function to check if the instance contains a point. | def contains(self, p):
return self.distance(p=p) < self.tolerance | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __contains__(self, point: Point[Scalar]) -> bool:\n return point in self._points_set",
"def __contains__(self, point: Point2D) -> bool:\n raise NotImplementedError",
"def contains_point(self, point) -> bool:\n return (self.pos.x <= point[0] <= self.pos.x + self.size.x and\n ... | [
"0.80940896",
"0.79766035",
"0.7874318",
"0.7752589",
"0.77207327",
"0.76728505",
"0.7655251",
"0.7603095",
"0.7503402",
"0.7494675",
"0.7432554",
"0.740622",
"0.74035716",
"0.73980653",
"0.73448753",
"0.72807014",
"0.7261856",
"0.7195358",
"0.7172193",
"0.7149684",
"0.712169... | 0.0 | -1 |
Function to compute the distance between the instance and a point or the shortest distance between the instance and another line. | def distance(self, p=None, l=None):
if l is None:
d = p - self.zero
n = np.zeros(3)
# try:
# n = d - np.dot(d, self.direction) * self.direction
# except RuntimeWarning:
# print(d, self.direction)
# return norm(n)
with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
n = d - np.dot(d, self.direction) * self.direction
# print(n, norm(n))
if len(w) > 0 and issubclass(w[-1].category, RuntimeWarning):
# Todo: check w/ Ram if this is what he meant to do when catch a warning: n = np.zeros(3)
# n = np.zeros(3)
# print(d, self.direction)
pass
return norm(n)
else:
normal = np.cross(self.direction, l.direction)
n = norm(normal)
if n < sys.float_info.min:
# Lines are parallel.
return self.distance(p=l.zero)
offset = np.dot(l.zero - self.zero, normal) / n
return np.abs(offset) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _distance(point, line_point1, line_point2):\n vec1 = line_point1 - point\n vec2 = line_point2 - point\n distance = np.abs(np.cross(vec1,vec2)) / np.linalg.norm(line_point1-line_point2)\n return distance",
"def _distance_to_line(begin, end, point):\n return _vec_... | [
"0.7641407",
"0.7141231",
"0.70598394",
"0.7000537",
"0.6959461",
"0.69434446",
"0.6942349",
"0.68482417",
"0.6793337",
"0.6758447",
"0.67557317",
"0.67258215",
"0.6696894",
"0.6693597",
"0.6688431",
"0.66852915",
"0.6680149",
"0.6679827",
"0.6665373",
"0.6638376",
"0.6632367... | 0.63587475 | 62 |
Function to compute the distance squared between the instance and a point. | def distance_sq(self, p):
d = p - self.zero
n = d - np.dot(d, self.direction) * self.direction
return n[0] ** 2 + n[1] ** 2 + n[2] ** 2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def squared_distance(self, point: List[int]) -> int:\n return point[0] ** 2 + point[1] ** 2",
"def squaredDistanceTo(self,other):\n if not isinstance(other,Point):\n return \n return (self.longitude - other.getLongitude())**2 +(self.latitude - other.getLatitude())**2",
"def eucl... | [
"0.78861135",
"0.7388568",
"0.7332369",
"0.7102426",
"0.7052089",
"0.70430666",
"0.703139",
"0.6993221",
"0.69181925",
"0.6889745",
"0.6863204",
"0.6794171",
"0.6785468",
"0.6758498",
"0.67438406",
"0.6737052",
"0.67257434",
"0.6707908",
"0.6706913",
"0.67060155",
"0.67053574... | 0.6738073 | 15 |
Function to the compute the point of the instance closest to another line. | def closest_point(self, l):
cos = np.dot(self.direction, l.direction)
n = 1 - cos ** 2
if n < sys.float_info.epsilon:
# Lines are parallel.
return self.zero
d0 = l.zero - self.zero
a = np.dot(d0, self.direction)
b = np.dot(d0, l.direction)
return self.zero + self.direction * ( a - b * cos) / n | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def closest_point_on_line(point, line):\n a, b = line\n ab = subtract_vectors(b, a)\n ap = subtract_vectors(point, a)\n c = vector_component(ap, ab)\n return add_vectors(a, c)",
"def closest(self, x):\n # http://www.ahinson.com/algorithms_general/Sections/Geometry/PluckerLine.pdf\n #... | [
"0.79727983",
"0.7753009",
"0.7605306",
"0.7497314",
"0.7443135",
"0.7417121",
"0.7388166",
"0.7367654",
"0.71200454",
"0.71104366",
"0.7108977",
"0.7068614",
"0.7057041",
"0.7001261",
"0.6992348",
"0.6936836",
"0.6908155",
"0.6904385",
"0.6875017",
"0.6862292",
"0.6801013",
... | 0.7502959 | 3 |
Function to compute the intersection point of the instance and another line. | def intersection(self, l):
closest = self.closest_point(l)
return closest if l.contains(closest) else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _lines_intersection(self, other):\n\n the_slope, the_y_intercept = False, False\n\n # parallel?\n if self.slope == other.slope:\n return (\n self.y_intercept == other.y_intercept and\n self.x_value == other.x_value\n )\n\n if self.is_vertical():\n ... | [
"0.7900334",
"0.78217113",
"0.7766068",
"0.7715372",
"0.76640767",
"0.7580761",
"0.7566446",
"0.7503989",
"0.7500533",
"0.7499418",
"0.74659604",
"0.7449178",
"0.74213684",
"0.7360603",
"0.734246",
"0.7337199",
"0.7291764",
"0.7291017",
"0.71756595",
"0.7140106",
"0.7113183",... | 0.0 | -1 |
Call the Translation API hosted on the micropayments server. | def cli(text):
#click.echo("Welcome to the Instant Translation Command Line Tool.\n")
sel_url = server_url+'translate?text={0}&payout_address={1}'
response = requests.get(url=sel_url.format(text, wallet.get_payout_address()))
#click.echo("The following is the translation of the text you input.\n")
click.echo(response.text) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def machine_translation(request):\n log.debug(\"Get translation from machine translation service.\")\n\n try:\n text = request.GET['text']\n locale = request.GET['locale']\n check = request.GET['check']\n except MultiValueDictKeyError as e:\n log.error(str(e))\n return H... | [
"0.704143",
"0.69701964",
"0.6816958",
"0.66153824",
"0.642939",
"0.63775456",
"0.62047935",
"0.61574394",
"0.6141896",
"0.61338365",
"0.60861075",
"0.6081854",
"0.6030524",
"0.5947659",
"0.5792178",
"0.5742774",
"0.57173043",
"0.56933045",
"0.56787753",
"0.56550264",
"0.5653... | 0.6338963 | 6 |
Makes a new account and adds it into the database. | def create_account():
if not request.json or not 'name' in request.json:
abort(400)
account = {
'id': accounts[-1]['id'] + 1, #last id + 1
'name': request.json['name'],
'surname': request.json['surname'],
'product': request.json.get('product', ""),
'balance': request.json.get('balance', 0.00)
}
accounts.append(account)
return json.dumps({'New Account': account}, ensure_ascii=False), 201, {'Content-Type': 'text/css; charset=utf-8'} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_user(self) -> None:\n # update when the account was created\n self.account_created = datetime.now().date()\n self.insert_to_db()\n log(f\"An account for User:{self.id} has been created.\")",
"def create(self, account):\n model = models.load('Account', account)\n\n ... | [
"0.8021572",
"0.750744",
"0.74803704",
"0.7311251",
"0.72799855",
"0.724296",
"0.72236335",
"0.71949494",
"0.7147477",
"0.7138259",
"0.7131161",
"0.7060654",
"0.704185",
"0.6993125",
"0.6962196",
"0.6949189",
"0.6949064",
"0.6937117",
"0.6913708",
"0.68980956",
"0.6873912",
... | 0.7375597 | 3 |
Makes deposit/withdrawal from an account and updates balance. | def make_transaction():
account_id = request.json['account_id']
aux_account = [account for account in accounts if account['id'] == account_id]
if len(aux_account) == 0:
abort(404)
account_balance = Decimal(aux_account[0].get('balance')).quantize(Decimal('0.00'))
transaction = request.json['transaction']
transaction_amount = Decimal(abs(request.json['amount'])).quantize(Decimal('0.00'))
if not request.json:
abort(400)
if transaction not in ['withdrawal', 'deposit']:
abort(400, f'Invalid transaction name: {transaction}')
if transaction == 'withdrawal':
transaction_amount = transaction_amount*-1
# the user can't withdraw more than the account has
validation_sum = (account_balance + transaction_amount).quantize(Decimal('.01'), rounding=ROUND_DOWN)
if validation_sum >= 0:
for real_account in accounts:
if real_account.get('id') == account_id:
real_account['balance'] = round(float(validation_sum),2)
else:
abort(400, {'error':'Not enough funds for this transaction'})
return json.dumps({f'{transaction.capitalize()} Done. New balance': str(validation_sum)}, ensure_ascii=False), 200 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deposit(account, amount):\n pass",
"def deposit(self, amount):\n self.balance += amount",
"def deposit(self, amount):\n self.balance += amount",
"def deposit(self, deposit_money):\r\n self.balance += deposit_money",
"def deposit(self, amount):\n self.balance += amount\n ... | [
"0.7868934",
"0.7839314",
"0.7839314",
"0.7767801",
"0.7667896",
"0.75666636",
"0.75089145",
"0.75089145",
"0.75089145",
"0.74225825",
"0.7420341",
"0.741208",
"0.7388114",
"0.7388107",
"0.73456854",
"0.72894204",
"0.7286367",
"0.72752404",
"0.7254404",
"0.72427124",
"0.72236... | 0.6433212 | 81 |
Gets the details from an account. | def get_account():
account_id = request.json['id']
account = [account for account in accounts if account['id'] == account_id]
if len(account) == 0:
abort(404, 'Account not found')
return json.dumps(account[0], ensure_ascii=False), 200, {'Content-Type': 'text/css; charset=utf-8'} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_account_details(self):\n pass",
"def get_account_info(self):\n resp = requests.get(\n self.URL + 'info/',\n headers={'Authorization': 'Token ' + self.api_key}\n )\n\n return self.__handle_response(resp)",
"def get_account_details(account_id, writer, key... | [
"0.8391992",
"0.7705361",
"0.76916474",
"0.76766896",
"0.7665401",
"0.7580927",
"0.7388152",
"0.7283165",
"0.6980997",
"0.6968043",
"0.6938249",
"0.6916687",
"0.6901691",
"0.6892927",
"0.6841231",
"0.6769148",
"0.6728201",
"0.67043024",
"0.6670262",
"0.6635612",
"0.6632791",
... | 0.6153258 | 42 |
Checks the availability of the service. | def health_check():
now = datetime.datetime.now()
return make_response(jsonify({'Alive': f'{now.strftime("%Y-%m-%d %H:%M")}'}), 200) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_availability(self):\n pass",
"def print_service_available():\n if WithingsDataManager.service_available is not True:\n _LOGGER.info(\"Looks like the service is available again\")\n WithingsDataManager.service_available = True\n return True",
"def is_avai... | [
"0.7628735",
"0.74451256",
"0.7004689",
"0.6775977",
"0.67273784",
"0.66786855",
"0.6657399",
"0.65845925",
"0.6574978",
"0.65488654",
"0.6541251",
"0.6489893",
"0.6482576",
"0.64753973",
"0.63969254",
"0.63804036",
"0.6367508",
"0.6347607",
"0.6273594",
"0.62443465",
"0.6236... | 0.0 | -1 |
Handles errors from the requests gotten from clients | def not_found(error):
return make_response(jsonify({'error': 'Resource not found'}), 404) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_error(self, request_handler, client_address):\n logger.debug('handle_error(%s:%s)' % client_address)",
"def handle_error(self, request, client_address):\n\t\tprint '-'*40\n\t\tprint 'Exception happened during processing of request from',\n\t\tprint client_address\n\t\timport traceback\n\t\ttrac... | [
"0.71784735",
"0.71308863",
"0.71102184",
"0.70657563",
"0.7006739",
"0.6947597",
"0.68516433",
"0.6658565",
"0.6613221",
"0.65786",
"0.6538273",
"0.6400244",
"0.63673776",
"0.6355248",
"0.63404506",
"0.63398343",
"0.63361794",
"0.6322117",
"0.6317077",
"0.63164055",
"0.63140... | 0.0 | -1 |
Upload File on Streamlit Code | def run(self):
st.title('Acne Classifier')
st.markdown(STYLE, unsafe_allow_html=True)
file = st.file_uploader("Upload file", type=self.fileTypes)
show_file = st.empty()
if not file:
show_file.info("Please upload a file of type: " + ", ".join(["png", "jpg"]))
return
file_bytes = np.asarray(bytearray(file.read()), dtype=np.uint8)
opencv_image = cv2.imdecode(file_bytes, 1)
cv2.imwrite('out.jpg', opencv_image)
df = get_score()
df2 = df.set_index('Issue')
st.dataframe(df2)
st.bar_chart(df2)
if isinstance(file, BytesIO):
show_file.image(file)
else:
data = pd.read_csv(file)
st.dataframe(data.head(10))
file.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def upload():\n\treturn render_template(\"upload.html\", title=\"Upload a file\")",
"def upload_file(self, file_path, file_name, output_path):",
"def upload():\n\n file = request.files['query']\n filepath = upload_filepath(secure_filename(file.filename))\n file.save(filepath)\n classification = cla... | [
"0.6423938",
"0.63981605",
"0.63896406",
"0.6386179",
"0.6256276",
"0.62473285",
"0.62320954",
"0.62008077",
"0.6166157",
"0.61652756",
"0.6073021",
"0.5995549",
"0.59897304",
"0.5989222",
"0.5944204",
"0.59314686",
"0.5905269",
"0.5904682",
"0.5895401",
"0.5894111",
"0.58836... | 0.0 | -1 |
Denormalizes image tensors using mean and std | def denormalize(tensors):
if len(tensors.shape) < 4:
for c in range(3):
tensors[c, ...].mul_(std[c]).add_(mean[c])
else:
for c in range(3):
tensors[:, c].mul_(std[c]).add_(mean[c])
return torch.clamp(tensors, 0, 255) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def un_normalize(tensor, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]):\n mean = torch.FloatTensor(mean).view(1,3,1,1)\n std = torch.FloatTensor(std).view(1,3,1,1)\n \n image = tensor.cpu().detach()\n image = image*std+mean\n image = image.numpy()\n \n image = np.transpose(image, (... | [
"0.78944635",
"0.7882652",
"0.7882652",
"0.78073585",
"0.7707587",
"0.75766003",
"0.75766003",
"0.75701815",
"0.7559962",
"0.75194675",
"0.75118655",
"0.74785763",
"0.73548406",
"0.7345986",
"0.73086804",
"0.72494674",
"0.72197634",
"0.71848446",
"0.7110974",
"0.7100263",
"0.... | 0.765841 | 5 |
Get the status code as per ttype and it's status_val | def get_status_code(self, ttype, status_val) -> str:
# get the status code from __status_code or __default_code
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def status_code(self):\n return int(self.status.split()[1])",
"def get_status_code(status):\n return dict(const.STATUS_CODES).get(status)",
"def status_code(self):\r\n return int(self._status[:3])",
"def status_code(self):\n return int(self._status[:3])",
"def _parse_status(self... | [
"0.7202656",
"0.71696675",
"0.7097821",
"0.6938727",
"0.68742913",
"0.68445003",
"0.68133837",
"0.6747887",
"0.67144114",
"0.6705535",
"0.662726",
"0.6622442",
"0.6621217",
"0.66081154",
"0.6606708",
"0.6606708",
"0.6598715",
"0.65756345",
"0.65702355",
"0.65538526",
"0.65501... | 0.86103326 | 0 |
To check if payload to be processed with this lambda | def apply_filter(self, payload: dict, ainfos) -> (dict, dict):
# check if needs to process by this lambda
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def verify_payload():\n return True",
"def process(self, payload, status_code=0):",
"def has_payload(self):\n\n if self._payload:\n return True\n return False",
"def __should_payload_execute(self, queue_item):\n\n soup = queue_item.get_soup_response()\n\n ng_app_... | [
"0.6974256",
"0.6329951",
"0.6317524",
"0.5889682",
"0.58806306",
"0.5717963",
"0.57109547",
"0.56970483",
"0.56970483",
"0.56906414",
"0.566029",
"0.55937403",
"0.5567957",
"0.5565435",
"0.5472518",
"0.5453765",
"0.5410358",
"0.54089427",
"0.53794",
"0.5371008",
"0.53691435"... | 0.66218215 | 1 |
Process Kinesis Record and save to Redis Cache | def enrich_payload(self, payload) -> None:
filtered_payloads = self.apply_filter(payload)
enriched = self.enrich(filtered_payloads)
return enriched | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handler(kinesis_records, context):\n data = kinesis_records[0].parse()\n detail = data.get('detail')\n return publish({\n \"eventSource\": data['source'],\n \"awsRegion\": data['region'],\n \"eventTime\": data['time'],\n \"eventName\": detail['eventName'],\n \"userId... | [
"0.60701543",
"0.60549337",
"0.58346707",
"0.58061445",
"0.57601625",
"0.56928015",
"0.5668168",
"0.56287974",
"0.5627504",
"0.55000585",
"0.54971075",
"0.545186",
"0.5447746",
"0.5404357",
"0.5392328",
"0.5323944",
"0.5304658",
"0.52952385",
"0.52630335",
"0.52459717",
"0.52... | 0.0 | -1 |
Use ansi code on 'string' if the output is the terminal of a not Windows platform | def isSpecial(ansiCode,string):
if IS_TERMINAL and not IS_WIN32: return ansiCode+string+ANSI_END
else: return string | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def b(string):\n return \"\\033[94m{0}\\033[0m\".format(string)",
"def ansi(color, text):\r\n code = COLOR_CODES[color]\r\n return '\\033[1;{0}m{1}{2}'.format(code, text, RESET_TERM)",
"def ansi_escape(text: object) -> str:\n return str(text).replace(\"\\x1b\", \"?\").replace(\"\\b\", \"?\")",
... | [
"0.698737",
"0.6955122",
"0.68967116",
"0.6775408",
"0.67163545",
"0.6666538",
"0.6612062",
"0.6594532",
"0.6576787",
"0.6540611",
"0.6525283",
"0.6465225",
"0.6419213",
"0.6390745",
"0.6369478",
"0.63463056",
"0.6337062",
"0.6330112",
"0.6313778",
"0.6313092",
"0.6297528",
... | 0.771174 | 0 |
Sort list of TKey by their names ignoring the case | def keyListSort(keyList):
keyList.sort(key=lambda y: y.GetName().lower()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sortCaseInsensitive(*args, **kwargs)->List[AnyStr]:\n pass",
"def sort_by_name(list_to_sort):\n return sorted(\n list_to_sort,\n key=lambda k: k['Name'].lower()\n )",
"def natsort_icase(lst: List[str]) -> None:\n lst.sort(key=natsort_key_icase)",
"def human_sort(l):\n l.sort(... | [
"0.7360461",
"0.7314273",
"0.6833507",
"0.67649287",
"0.66534966",
"0.6629779",
"0.6619612",
"0.6566453",
"0.65517783",
"0.6549519",
"0.6549519",
"0.65458226",
"0.65365845",
"0.65276384",
"0.6501143",
"0.64999694",
"0.64592296",
"0.6409549",
"0.6385534",
"0.6382833",
"0.63771... | 0.818581 | 0 |
Sort list of tuple by their first elements ignoring the case | def tupleListSort(tupleList):
tupleList.sort(key=lambda y: y[0].lower()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _mySort(self, alist):\n return sorted(alist, key=lambda x: (x[0].isdigit(), x.lower()))",
"def sort_list_of_tuples(list):\n list.sort(key=lambda x: x[0])\n return list",
"def sortCaseInsensitive(*args, **kwargs)->List[AnyStr]:\n pass",
"def natsort_case_insensitive(seq):\r\n return nat... | [
"0.70666724",
"0.6958094",
"0.6883425",
"0.68414825",
"0.6625755",
"0.65509486",
"0.64947134",
"0.64417565",
"0.6294914",
"0.62795585",
"0.6264345",
"0.6251216",
"0.6234281",
"0.62279594",
"0.62186223",
"0.62157",
"0.6190618",
"0.6180634",
"0.6172756",
"0.61627626",
"0.615647... | 0.8253932 | 0 |
Use sys.stdout.write to write the string with an indentation equal to indent and specifying the end character | def write(string,indent=0,end=""):
sys.stdout.write(" "*indent+string+end) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def indentOut_ (stream, indent) :\r\n if indent == 0 :\r\n return\r\n else :\r\n stream.write(\" \"*indent)",
"def out_indent(indent, *args):\n s = \"\"\n s += indent * \" \"\n s += \" \".join(args)\n return s",
"def try_print_indent(self):\n if self.lasttoken[0] != lex.T... | [
"0.7758625",
"0.6414926",
"0.6342674",
"0.6169035",
"0.6082922",
"0.59543496",
"0.5942104",
"0.5933664",
"0.58904225",
"0.5866938",
"0.5845034",
"0.5830857",
"0.5830536",
"0.5825642",
"0.5822062",
"0.58123285",
"0.58008015",
"0.5715586",
"0.5666716",
"0.5651807",
"0.56485546"... | 0.8376877 | 0 |
Print recursively tree informations | def recursifTreePrinter(tree,indent):
listOfBranches = tree.GetListOfBranches()
if len(listOfBranches) > 0: # Width informations
maxCharName = max([len(branch.GetName()) \
for branch in listOfBranches])
maxCharTitle = max([len(branch.GetTitle()) \
for branch in listOfBranches])
dic = { \
"nameWidth":maxCharName+2, \
"titleWidth":maxCharTitle+4, \
"memoryWidth":1}
for branch in listOfBranches: # Print loop
rec = \
[branch.GetName(), \
"\""+branch.GetTitle()+"\"", \
str(branch.GetTotBytes())]
write(TREE_TEMPLATE.format(*rec,**dic),indent,end="\n")
recursifTreePrinter(branch,indent+2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_tree(self):\n\t\tprint(self.__print_tree('', True, ''))",
"def print_tree(self):\n\t\tself.root.print_recursive(0)",
"def printTree(self):\n print(printTreeF(self, 0, self))",
"def print_tree(node):\n print tree(node)",
"def print_tree(self):\n return \"\"",
"def print_tree(sel... | [
"0.8600898",
"0.8487803",
"0.8312677",
"0.8166421",
"0.80248964",
"0.8010252",
"0.7947379",
"0.7931171",
"0.7874574",
"0.78502697",
"0.7842588",
"0.7769115",
"0.7767501",
"0.7752166",
"0.77449286",
"0.7713288",
"0.77115613",
"0.7703568",
"0.7699183",
"0.76673025",
"0.76467204... | 0.7243111 | 39 |
Get time in the proper shape | def prepareTime(time):
time = str(time)
time = '000000'+time
time = time[len(time)-6:]
return time | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def time(self):\n return self.time_array",
"def get_time(self) -> float:\n raise NotImplementedError()",
"def get_time(self):\n start=''\n end=''\n time=''\n times=self.times\n print(times[self.istep])\n if self.istep > 0:\n start=ncEarth.begin... | [
"0.7274171",
"0.70513386",
"0.7026728",
"0.69944495",
"0.68678916",
"0.68556535",
"0.68395287",
"0.68395287",
"0.6821601",
"0.679285",
"0.67860985",
"0.6783213",
"0.6751718",
"0.6702506",
"0.66815585",
"0.66815585",
"0.66815585",
"0.66792035",
"0.6662519",
"0.66364765",
"0.66... | 0.0 | -1 |
Print a list of Tkey in columns | def roolsPrintLongLs(keyList,optDict,indent):
if len(keyList) > 0: # Width informations
maxCharClass = max([len(key.GetClassName()) for key in keyList])
maxCharTime = 12
maxCharName = max([len(key.GetName()) for key in keyList])
dic = { \
"classWidth":maxCharClass+2, \
"timeWidth":maxCharTime+2, \
"nameWidth":maxCharName+2, \
"titleWidth":1}
date = ROOT.Long(0)
for key in keyList:
time = ROOT.Long(0)
key.GetDatime().GetDateTime(key.GetDatime().Get(),date,time)
time = prepareTime(time)
rec = \
[key.GetClassName(), \
MONTH[int(str(date)[4:6])]+" " +str(date)[6:]+ \
" "+time[:2]+":"+time[2:4], \
key.GetName(), \
"\""+key.GetTitle()+"\""]
write(LONG_TEMPLATE.format(*rec,**dic),indent,end="\n")
if optDict['tree'] and isTreeKey(key):
tree = key.ReadObj()
recursifTreePrinter(tree,indent+2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_table(data):\n for key in sorted(data):\n print \"%s: %s\" % (key.rjust(16), data[key])",
"def show_table(self, keys=None, sort_keys_function=None):\n rows = []\n output_keys = keys or self.keys\n\n for item in self.__get_items(sort_keys_function):\n ro... | [
"0.69297874",
"0.6871086",
"0.6832247",
"0.655662",
"0.64423645",
"0.63084143",
"0.6236635",
"0.6138035",
"0.60768145",
"0.6069733",
"0.60688424",
"0.60679513",
"0.6044288",
"0.60366815",
"0.60195136",
"0.59938",
"0.5990676",
"0.5981191",
"0.59755695",
"0.5975386",
"0.5961205... | 0.0 | -1 |
getTerminalSize() get width and height of console works on linux,os x,windows,cygwin(windows) | def getTerminalSize():
current_os = platform.system()
tuple_xy = None
if current_os == 'Windows':
tuple_xy = _get_terminal_size_windows()
if tuple_xy is None:
tuple_xy = _get_terminal_size_tput()
# needed for window's python in cygwin's xterm!
if current_os in ['Linux', 'Darwin'] or current_os.startswith('CYGWIN'):
tuple_xy = _get_terminal_size_linux()
if tuple_xy is None:
#print "default"
#_get_terminal_size_windows() or _get_terminal_size_tput don't work
tuple_xy = (80, 25) # default value
return tuple_xy | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_terminal_size_windows():\r\n\r\n\r\n #from https://gist.github.com/jtriley/1108174, thank you very much for this hard to produce code!\r\n\r\n # stdin handle is -10\r\n # stdout handle is -11\r\n # stderr handle is -12\r\n h = windll.kernel32.GetStdHandle(-12)\r\n csbi = create_string_bu... | [
"0.8626077",
"0.8466061",
"0.83579844",
"0.82661015",
"0.8189961",
"0.8158154",
"0.8115553",
"0.8110067",
"0.8009353",
"0.79788095",
"0.7913624",
"0.78884804",
"0.787112",
"0.78315413",
"0.7774899",
"0.77129865",
"0.7648327",
"0.7609278",
"0.760888",
"0.7603599",
"0.7578715",... | 0.7640822 | 17 |
Print list of strings in columns blue for directories green for trees | def roolsPrintSimpleLs(keyList,indent):
# This code is adaptated from the pprint_list function here :
# http://stackoverflow.com/questions/25026556/output-list-like-ls
# Thanks hawkjo !!
if len(keyList) == 0: return
(term_width, term_height) = getTerminalSize()
term_width = term_width - indent
min_chars_between = 2
min_element_width = min( len(key.GetName()) for key in keyList ) \
+ min_chars_between
max_element_width = max( len(key.GetName()) for key in keyList ) \
+ min_chars_between
if max_element_width >= term_width: ncol,col_widths = 1,[1]
else:
# Start with max possible number of columns and reduce until it fits
ncol = min( len(keyList), term_width / min_element_width )
while True:
col_widths = \
[ max( len(key.GetName()) + min_chars_between \
for j, key in enumerate(keyList) if j % ncol == i ) \
for i in range(ncol) ]
if sum( col_widths ) <= term_width: break
else: ncol -= 1
for i, key in enumerate(keyList):
if i%ncol == 0: write("",indent) # indentation
# Don't add spaces after the last element of the line or of the list
if (i+1)%ncol != 0 and i != len(keyList)-1:
if not IS_TERMINAL: write( \
key.GetName().ljust(col_widths[i%ncol]))
elif isDirectoryKey(keyList[i]): write( \
isSpecial(ANSI_BLUE,key.GetName()).ljust( \
col_widths[i%ncol] + ANSI_BLUE_LENGTH))
elif isTreeKey(keyList[i]): write( \
isSpecial(ANSI_GREEN,key.GetName()).ljust( \
col_widths[i%ncol] + ANSI_GREEN_LENGTH))
else: write(key.GetName().ljust(col_widths[i%ncol]))
else: # No spaces after the last element of the line or of the list
if not IS_TERMINAL: write(key.GetName())
elif isDirectoryKey(keyList[i]):
write(isSpecial(ANSI_BLUE, key.GetName()))
elif isTreeKey(keyList[i]):
write(isSpecial(ANSI_GREEN, key.GetName()))
else: write(key.GetName())
write('\n') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_directory_table(self):\n for row in range(self.directory_table.shape[0]):\n for column in range(self.directory_table.shape[1]):\n if column == self.directory_table.shape[1] - 1:\n print(self.directory_table[row][column])\n else:\n ... | [
"0.68927115",
"0.62558967",
"0.6205917",
"0.611956",
"0.5990437",
"0.59898376",
"0.59636194",
"0.5947244",
"0.5935697",
"0.5933059",
"0.59189725",
"0.58366364",
"0.58359617",
"0.58307904",
"0.5817027",
"0.58034277",
"0.579429",
"0.577492",
"0.5759573",
"0.5752997",
"0.5740480... | 0.55308056 | 36 |
Print informations given by keyList with a rools style choosen with optDict | def roolsPrint(keyList,optDict,indent=0):
if optDict['long'] or optDict['tree']: \
roolsPrintLongLs(keyList,optDict,indent)
else: roolsPrintSimpleLs(keyList,indent) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def printDict(myDict):\n for key in myDict:\n print(f\"Version: --> {myDict[key]['version']} \")\n print(f\"Accuracy: --> {myDict[key]['accuracy']}\")\n print(f\"Time --> {myDict[key]['time_per_target']}\")\n print(f\"Penalty --> {myDict[key]['target_w_penalt... | [
"0.6518504",
"0.6352941",
"0.63204557",
"0.6319985",
"0.62665594",
"0.61978984",
"0.6115929",
"0.6110398",
"0.60612506",
"0.59930515",
"0.5966976",
"0.59666437",
"0.59666437",
"0.59537727",
"0.5947354",
"0.59427744",
"0.5914536",
"0.5914091",
"0.582117",
"0.5819495",
"0.58194... | 0.7562387 | 0 |
Call back function which checks if two rectangles have collided with each other | def collide_hit_rect(first, second):
return first.hit_rect.colliderect(second.hit_rect) or first.hit_rect.colliderect(second.hit_rect) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_overlapping(self, region):\n if self.x2 < region.x1:\n return False # this box is left the other\n if self.x1 > region.x2:\n return False # this box is right the other\n if self.y2 < region.y1:\n return False # this box is above the other\n if ... | [
"0.703403",
"0.70215464",
"0.7011669",
"0.69918287",
"0.69465554",
"0.6939659",
"0.6890335",
"0.6829306",
"0.68109834",
"0.6809146",
"0.679998",
"0.67945856",
"0.6788503",
"0.67841524",
"0.66956073",
"0.66782784",
"0.6669898",
"0.6662063",
"0.6662063",
"0.66499317",
"0.663539... | 0.64797306 | 39 |
Checks where the sprite has collided with an obstacle direction is needed to allow a sprite that collides horizontally to continue moving vertically if its movement was in a diagonal. Same goes for blocked vertical movement and continued horizontal movement. | def collide_with_obstacles(sprite, group, direction):
collided = False
if direction == 'x':
collided = True
hits = pg.sprite.spritecollide(sprite, group, False, collide_hit_rect)
if hits:
# If the sprite is moving right, stop it and
# set its right face on the left side of the object it collided with.
if hits[0].rect.centerx > sprite.hit_rect.centerx:
sprite.pos.x = hits[0].rect.left - sprite.hit_rect.width / 2
# If the sprite is moving right, stop it and
# set its left face on the left side of the object it collided with.
if hits[0].rect.centerx < sprite.hit_rect.centerx:
sprite.pos.x = hits[0].rect.right + sprite.hit_rect.width / 2
# Completely stop the sprite
sprite.vel.x = -sprite.vel.x
# Update the sprite's center to the new position
sprite.hit_rect.centerx = sprite.pos.x
if direction == 'y':
collided = True
hits = pg.sprite.spritecollide(sprite, group, False, collide_hit_rect)
if hits:
# If the sprite is moving upwards, then
# set its top to the bottom of the sprite it collided with.
if hits[0].rect.centery < sprite.hit_rect.centery:
sprite.pos.y = hits[0].rect.bottom + sprite.hit_rect.height / 2
# If the sprite is moving downwards, then
# set its bottom to the top of the sprite it collided with.
if hits[0].rect.centery > sprite.hit_rect.centery:
sprite.pos.y = hits[0].rect.top - sprite.hit_rect.height / 2
# Completely stop the sprite
sprite.vel.y = -sprite.vel.y
sprite.hit_rect.centery = sprite.pos.y
return collided | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_collisions(self, offset, index, obstacles):\n unaltered = True\n self.rect.move_ip(offset)\n while pygame.sprite.spritecollideany(self, obstacles):\n\n # First of all, check if it is a motile transparent block.\n # if so, do nothin\n col_spr = pygame... | [
"0.67670953",
"0.66960996",
"0.663591",
"0.6418021",
"0.6344243",
"0.63345575",
"0.6334223",
"0.6327699",
"0.6312439",
"0.63031816",
"0.62835157",
"0.6234458",
"0.6216627",
"0.6159888",
"0.6156384",
"0.61506426",
"0.6149324",
"0.61447644",
"0.61446947",
"0.6136143",
"0.608260... | 0.655872 | 3 |
Get a Producer queue instance | def getProducer():
# get the config and a producer
config = ecommerce.config.getConfig()
return ecommerce.queue.queue(config, queuePrefix) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_queue():\n\n return multiprocessing.Queue()",
"def get(queue_name: str, **kwargs) -> Queue:\n return Queue(queue_name, **kwargs)",
"def _get_queue(self):\n return self.__queue",
"def _get_queue(self):\n return self.__queue",
"def _get_queue(self):\n return self.__queue",
"def _... | [
"0.7450264",
"0.7052122",
"0.69740534",
"0.69740534",
"0.69740534",
"0.69740534",
"0.69740534",
"0.69740534",
"0.69740534",
"0.69740534",
"0.69740534",
"0.69740534",
"0.69740534",
"0.69740534",
"0.69740534",
"0.69740534",
"0.69740534",
"0.69648343",
"0.69545984",
"0.6784196",
... | 0.8324251 | 0 |
Get the list of all entities of a given type from DB | def getEntityIds(type, subtype = None):
# get a cursor
conn = ecommerce.db.getConnection()
cursor = conn.cursor()
# decide the query to execute
if type not in entityQueries:
return [ ]
# execute the query
qparams = (type, )
if subtype is not None:
qparams = (type, subtype)
cursor.execute(entityQueries[type], qparams)
# fetch the ids
elist = [ ]
row = cursor.fetchone()
while row is not None:
elist.append(int(row[0]))
row = cursor.fetchone()
cursor.close()
return elist | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query_all(cls)->List:\n database.cursor.execute(\"SELECT * FROM {}\".format(cls.table_name))\n items = database.cursor.fetchall()\n return [cls.to_object(item) for item in items]",
"def get_all(cls):\n return db_session.query(cls).order_by(cls.name).all()",
"def get_entities(sel... | [
"0.7030536",
"0.6770714",
"0.66363615",
"0.6616682",
"0.6602713",
"0.6575097",
"0.64512324",
"0.6423671",
"0.64117724",
"0.6411315",
"0.63493234",
"0.634775",
"0.63454515",
"0.6322174",
"0.62615913",
"0.6218871",
"0.6200281",
"0.61640894",
"0.6134082",
"0.613314",
"0.6114528"... | 0.6784044 | 1 |
Puts generate commands into the queue | def cmd_add(arguments):
# build the list of entities
entities = { type : [ ] for type in entityTypes }
type = ""
param = 1 # skip "add" command
while param < len(arguments):
# get an entity type and check it's valid
fullType = arguments[param]
type = fullType
subtype = None
if "/" in type:
(type, waste, subtype) = fullType.partition("/")
param += 1
if type not in entityTypes:
print "ERROR: entity type [%s] is not valid" % type
return -1
if subtype is not None and subtype not in subtypes[type]:
print "ERROR: entity subtype [%s] for type [%s] is not valid" % (subtype, type)
return -1
# build the list of values
eList = [ ]
if arguments[param] == "*":
# if the entity has subtypes and we have no subtype, iterate
if subtype is None and subtypes[type]:
# iterate subtypes
for subtype in subtypes[type]:
# set the fullType
fullType = type + "/" + subtype
# get the list of (ALL) ids from the database
eList = getEntityIds(type, subtype)
param += 1
# attach the list to the type
entities[fullType] = eList
else:
# no subtypes or subtype specified
# get the list of (ALL) ids from the database
eList = getEntityIds(type, subtype)
param += 1
# attach the list to the type
entities[fullType] = eList
else:
# process the params
while param < len(arguments):
try:
eList.append(int(arguments[param]))
param += 1
except ValueError:
break
# attach the list to the type
entities[fullType] = eList
# get a producer
producer = getProducer()
# start creating jobs
jobCount = 0
for fullType in entities:
# separate type/subtype
type = fullType
if "/" in type:
(type, waste, subtype) = fullType.partition("/")
# get the list
elist = entities[fullType]
# build jobs of up to 64 entries
partialJobCount = generateJobs(producer, type, elist)
# report
if partialJobCount > 0:
print "added %5d jobs for entity %s" % (partialJobCount, fullType)
jobCount += partialJobCount
# report the number of jobs created
print ""
print "Added a total of %5d jobs in queue" % jobCount
print ""
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate():\n PackCommandExecutor().pack()\n GenerateCommandExecutor().generate()",
"def _manager_main(self, queue):\r\n for task in self._task_generator():\r\n queue.put(task)",
"def enqueue(self, cmd) -> None:\n self.general_queue.append(cmd)",
"def send_command_queue(com... | [
"0.65800864",
"0.6378465",
"0.61124223",
"0.60805756",
"0.60594606",
"0.60329777",
"0.5986247",
"0.5985811",
"0.58339554",
"0.58075696",
"0.5778677",
"0.5776468",
"0.5760314",
"0.57391536",
"0.57391536",
"0.5685093",
"0.56670094",
"0.56434864",
"0.5631529",
"0.56295687",
"0.5... | 0.0 | -1 |
Get the LastUpdateDate for this type of entity | def max_entity_date(entity_type):
# assume empty date
max_date = None
try:
# get a cursor
conn = ecommerce.db.getConnection()
cursor = conn.cursor()
# execute the query
cursor.execute("""
SELECT TO_CHAR(LastUpdateDate, 'YYYY-MM-DD HH24:MI:SS')
FROM Stage0_DeltaControl
WHERE EntityType = ?
""", (entity_type, ) )
# fetch the max date
row = cursor.fetchone()
if row is not None:
max_date = row[0]
cursor.close()
except:
pass
return max_date | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dt_last_update(self):\n return self.last_update",
"def get_last_updated_at(self):\n return self.last_updated",
"def get_last_update_time(self):\n return self.last_update_time",
"def last_update_datetime(self):\n return datetime.strptime(self.last_update, \"%Y-%m-%d %H:%M:%S.%f... | [
"0.7807228",
"0.7612656",
"0.75777316",
"0.74499947",
"0.74499947",
"0.7426561",
"0.73883593",
"0.73883593",
"0.721249",
"0.721249",
"0.7182299",
"0.7182299",
"0.71680653",
"0.71449316",
"0.7084291",
"0.70218515",
"0.69548345",
"0.6950892",
"0.6945901",
"0.686151",
"0.6858256... | 0.0 | -1 |
Get the list of modified entities before a specified date | def list_modified_entities(entity_type, max_date):
# get a cursor
conn = ecommerce.db.getConnection()
cursor = conn.cursor()
# execute the query
cursor.execute("""
SELECT EntityId
FROM Stage0_Delta
WHERE EntityType = ? AND
FlagUpdated = 1 AND
LastUpdate <= TO_DATE(?, 'YYYY-MM-DD HH24:MI:SS')
""", (entity_type, max_date) )
# fetch the ids
elist = [ ]
row = cursor.fetchone()
while row is not None:
elist.append(int(row[0]))
row = cursor.fetchone()
cursor.close()
return elist | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def created_before(self, date: datetime):\n return self.created_search(date, search_type=\"before\")",
"def is_before(self,other_date):",
"def getListModifiedDates(self):\n return _libsbml.ModelHistory_getListModifiedDates(self)",
"def get_records_created_before(self, when):\n return self.... | [
"0.6760683",
"0.59212226",
"0.58793044",
"0.58698404",
"0.573927",
"0.5540924",
"0.5527508",
"0.5492065",
"0.5454459",
"0.5417637",
"0.5409974",
"0.53736883",
"0.5361394",
"0.5243023",
"0.52254313",
"0.5220781",
"0.5217296",
"0.5216376",
"0.51910895",
"0.51544005",
"0.5142516... | 0.5889012 | 2 |
Mark the entities modified before a specific date as processed | def mark_processed_entities(entity_type, max_date):
try:
# get a connection and cursor
conn = ecommerce.db.getConnection()
cursor = conn.cursor()
# execute the query
cursor.execute("""
UPDATE Stage0_Delta
SET FlagUpdated = 0
WHERE EntityType = ? AND
FlagUpdated = 1 AND
LastUpdate <= TO_DATE(?, 'YYYY-MM-DD HH24:MI:SS')
""", (entity_type, max_date) )
# commit changes
conn.commit()
except:
conn.rollback()
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visitBefore(self, date):\n raise NotImplementedError()",
"def is_before(self,other_date):",
"def modified(self):\r\n\t\treturn self.last_modified > self.last_processed",
"def modified(self):\n\t\treturn self.last_modified > self.last_processed",
"def _update_modified_since(self, timestamp):\n ... | [
"0.6026466",
"0.60223776",
"0.6005824",
"0.58785576",
"0.5820918",
"0.5775946",
"0.5775946",
"0.57705164",
"0.56849986",
"0.5605239",
"0.5544186",
"0.55204594",
"0.54331017",
"0.54331017",
"0.54331017",
"0.54331017",
"0.54331017",
"0.54331017",
"0.54331017",
"0.5399244",
"0.5... | 0.6365167 | 0 |
Process the Stage0_Delta table and create queue commands to process each record that has FlagUpdated = 1 | def cmd_delta(arguments):
cmd_delta.entities = [
# each entry is a 2-uple, stating the EntityType and
# wheter if queue jobs must be generated or not
( "CONT", False ),
( "IMPR", False ),
( "_DSP", False ),
( "SUBJ", True ),
( "PROD", True ),
( "PAGE", True )
]
# iterate each entity type
for e in range(len(cmd_delta.entities)):
# get handy values
entity_type = cmd_delta.entities[e][0]
generate = cmd_delta.entities[e][1]
print "Processing Entity %s" % (entity_type),
logger.info("Processing Entity %s" % (entity_type))
# get the max date
max_date = max_entity_date(entity_type)
if max_date is not None:
# get the list of modified entities (if we need to generate)
entities = [ ]
if generate:
# get the list of entities
entities = list_modified_entities(entity_type, max_date)
# generate queue jobs
producer = getProducer()
partialJobCount = generateJobs(producer, entity_type, entities)
# mark entities as processed
if max_date is not None:
mark_processed_entities(entity_type, max_date)
print "- DONE (%d entities)" % len(entities)
logger.info("Processed Entity %s OK (%d entities)" % (entity_type, len(entities)))
else:
print "- ERROR"
logger.info("Processed Entity %s with ERROR" % (entity_type))
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def queueUpdate(self):\n packts = 1\n self.ueLst = list(self.ues.keys())\n self.resAlloc(self.nrbUEmax)\n sym = 0\n if self.nrbUEmax == 0:\n self.sm_lim = 0\n else:\n if self.mimomd == 'MU':\n self.sm_lim = self.symMax*self.nlayers\n ... | [
"0.57603353",
"0.5615798",
"0.5543773",
"0.5470545",
"0.5338651",
"0.52531934",
"0.5228426",
"0.5206048",
"0.5201316",
"0.51806426",
"0.51614136",
"0.51220685",
"0.50776464",
"0.50263834",
"0.4995501",
"0.49954292",
"0.4989829",
"0.49809688",
"0.4969443",
"0.4967038",
"0.4962... | 0.5197049 | 9 |
List the job queue | def cmd_list(arguments):
# get a producer
producer = getProducer()
# get the list of pending jobs
jobs = producer.list()
# print que list size and the entries
print "Number of jobs: %d" % len(jobs)
for j in range(len(jobs)):
print " job %06d - %s" % (j, jobs[j])
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ls(self):\n server = jenkins_server.get_jenkins_server()\n queue = server.get_queue_info()\n print('任务ID\\t%s\\t原因' % '任务链接'.ljust(50))\n for q in queue:\n print('%d\\t%s\\t%s' % (q['id'], q['task']['url'].ljust(50), q['why']))",
"def list_jobs():\n\n name_to_job_det... | [
"0.7661594",
"0.7647107",
"0.762154",
"0.75825155",
"0.74639344",
"0.7404997",
"0.71474695",
"0.7096951",
"0.7051303",
"0.69853973",
"0.69715",
"0.69715",
"0.69136894",
"0.68906635",
"0.6835532",
"0.683014",
"0.6773141",
"0.6738064",
"0.6734032",
"0.6690407",
"0.6667332",
"... | 0.7498685 | 4 |
List the job queue | def cmd_sitemap(arguments):
# create a sitemap job
job = jobs.encode(jobs.sitemap())
# get a producer
producer = getProducer()
# get an item, set content and make it ready
item = producer.item()
item.content = job
producer.ready(item)
print "Sitemap command put in queue"
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ls(self):\n server = jenkins_server.get_jenkins_server()\n queue = server.get_queue_info()\n print('任务ID\\t%s\\t原因' % '任务链接'.ljust(50))\n for q in queue:\n print('%d\\t%s\\t%s' % (q['id'], q['task']['url'].ljust(50), q['why']))",
"def list_jobs():\n\n name_to_job_det... | [
"0.7661594",
"0.7647107",
"0.762154",
"0.75825155",
"0.7498685",
"0.74639344",
"0.7404997",
"0.71474695",
"0.7096951",
"0.7051303",
"0.69853973",
"0.69715",
"0.69715",
"0.69136894",
"0.68906635",
"0.6835532",
"0.683014",
"0.6773141",
"0.6738064",
"0.6734032",
"0.6690407",
"... | 0.0 | -1 |
A generator that can be used to iterate over all of the message handlers that belong to this instance. | def iter_message_handlers(self):
for name in dir(self):
attr = getattr(self, name)
if isinstance(attr, MessageHandler):
yield attr | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_message_handlers(self):\n\t\treturn self.message_handlers",
"def get_handlers(self):\n\n # Get handlers \n logger.debug(\"%s: Returned %d handlers.\" % \\\n (self.__class__.__name__, len(self._handlers)))\n return self._handlers[:]",
"def __iter__(self):\n ... | [
"0.75313586",
"0.7092574",
"0.689368",
"0.6885732",
"0.6611093",
"0.64954853",
"0.6490498",
"0.6438109",
"0.6379151",
"0.6324771",
"0.6322066",
"0.62982225",
"0.62764996",
"0.6234379",
"0.6224543",
"0.62200075",
"0.61538786",
"0.60254633",
"0.6023188",
"0.60213643",
"0.594284... | 0.86009705 | 0 |
Adds the given service's message handlers to our managed message handlers. | def register_service(self, service):
for message_handler in service.iter_message_handlers():
self.message_handlers[message_handler.name] = message_handler | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect(self, service, handler):\n self.partyline.setdefault(service, []).append(handler)",
"def register_websock_handlers(self, service, new_client, new_message, close_client):\n if service in self.websock_handlers:\n L.error(\"Error: service:\" + service + \" is already registered\... | [
"0.6415957",
"0.63830936",
"0.60461724",
"0.6046069",
"0.6006367",
"0.58971536",
"0.5866512",
"0.5834788",
"0.5806009",
"0.5753481",
"0.5696065",
"0.5631438",
"0.56120425",
"0.5598932",
"0.55874574",
"0.55768156",
"0.55757207",
"0.55562836",
"0.5551294",
"0.5539715",
"0.55364... | 0.8374331 | 0 |
Invokes the correct message handler for the given message. | def handle_message(self, sender, message):
self.logger.debug('handle_message(%r, %r)', sender, message.handler)
message_handler = self.message_handlers.get(message.handler)
if message_handler is None:
self.logger.warning("sender=%r, No handler found: '%s'",
sender, message.handler)
return
message_handler(sender, message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_message(self, message):\n\n\t\tself.log.debug(\"%s handle_message %s\", self.name, message)\n\n\t\tif message[\"Type\"] == \"command\":\n\t\t\ttry:\n\t\t\t\tcommand_callable = \"command_%s\" % message[\"Message\"][\"command\"]\n\t\t\t\tif hasattr(self, command_callable) and callable(getattr(self, comman... | [
"0.7761963",
"0.72658277",
"0.7105738",
"0.7102408",
"0.7060995",
"0.7036604",
"0.70310044",
"0.7029397",
"0.699162",
"0.69913566",
"0.698211",
"0.6949379",
"0.69273627",
"0.6888938",
"0.68215775",
"0.6818507",
"0.67997396",
"0.6774335",
"0.67683744",
"0.6749502",
"0.6715756"... | 0.73108006 | 1 |
Do not return anything, modify matrix inplace instead. | def setZeroes(self, matrix):
for i in range(len(matrix)):
for j in range(len(matrix[i])):
if matrix[i][j] == 0 and (i, j) not in self.visited:
for neighbor in self.setter(matrix, i, j):
matrix[neighbor[0]][neighbor[1]] = 0
self.visited.add((neighbor[0], neighbor[1]))
print(matrix) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __update_matrix(self, old_matrix_view):\n # if we've cleaned dirt - we will see it on our next move, so we substitute only unseen cells\n # which are marked with \"o\"\n new_matrix_view = []\n for row in range(self.matrix_rows):\n new_matrix_view.append([char for char in ... | [
"0.7066283",
"0.6845453",
"0.6360038",
"0.62143975",
"0.6191982",
"0.61279464",
"0.6040232",
"0.59938055",
"0.5967881",
"0.59397227",
"0.59288263",
"0.5918774",
"0.58981085",
"0.5853208",
"0.58428276",
"0.58091146",
"0.57997805",
"0.5791091",
"0.57368064",
"0.57231134",
"0.57... | 0.0 | -1 |
This function prints and plots the confusion matrix. Normalization can be applied by setting `normalize=True`. | def plot_confusion_matrix(cm, classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues):
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
print("Normalized confusion matrix")
else:
print('Confusion matrix, without normalization')
print(cm)
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
fmt = '.2f' if normalize else 'd'
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, format(cm[i, j], fmt),
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_confusion_matrix(cm, classes=[0,1], normalize=False, title='Confusion matrix', print_matrix=False):\n\n if normalize:\n cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n print(\"Normalized confusion matrix\")\n else:\n print('Confusion matrix, without normalization')\n\n... | [
"0.8194862",
"0.80949175",
"0.8029915",
"0.8019153",
"0.79941195",
"0.7991258",
"0.7980955",
"0.7976606",
"0.79610753",
"0.79590565",
"0.79378676",
"0.7934962",
"0.7934504",
"0.79313844",
"0.7926313",
"0.7924577",
"0.79241234",
"0.7923211",
"0.7923023",
"0.7921931",
"0.791787... | 0.0 | -1 |
Export ECU data to excel format | def extract_ecu(self, vin_list=None):
corvets = Corvet.objects.filter(vin__in=vin_list)
self.header, self.fields = self.get_header_fields(CORVET_DICT.get("extract_ecu", []))
values_list = corvets.values_list(*self.fields).distinct()
return values_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_excel(self, filename):\n self.data.to_excel(filename)",
"def export_excel(self, filename):\n # convert table to array of rows\n rows = [self.headings]\n for y in range(self.rowcount):\n row = []\n for h in self.headings:\n row.append(self.ta... | [
"0.6653394",
"0.6451767",
"0.643158",
"0.63429654",
"0.6334339",
"0.6333897",
"0.6286794",
"0.62807244",
"0.6235302",
"0.62333274",
"0.6191427",
"0.6170842",
"0.60931844",
"0.60574377",
"0.605236",
"0.6052189",
"0.6044034",
"0.60123223",
"0.6012149",
"0.6002858",
"0.5997272",... | 0.0 | -1 |
Export CORVET data to excel format | def extract_corvet(self, *args, **kwargs):
self._product_filter(**kwargs)
self._vehicle_filter(**kwargs)
self._select_columns(**kwargs)
queryset = self.queryset.annotate(
date_debut_garantie=Cast(TruncSecond('donnee_date_debut_garantie', DateTimeField()), CharField()))
if kwargs.get('tag', None):
queryset = queryset.filter(opts__tag=kwargs.get('tag'))
if kwargs.get('vins', None):
vin_list = kwargs.get('vins').split('\r\n')
queryset = queryset.filter(vin__in=vin_list)
if kwargs.get('xelon_model', None):
queryset = queryset.select_related().filter(xelon__modele_produit__startswith=kwargs.get('xelon_model'))
if kwargs.get('xelon_vehicle', None):
queryset = queryset.select_related().filter(xelon__modele_vehicule__startswith=kwargs.get('xelon_vehicle'))
if kwargs.get('start_date', None):
queryset = queryset.filter(donnee_date_debut_garantie__gte=kwargs.get('start_date'))
if kwargs.get('end_date', None):
queryset = queryset.filter(donnee_date_debut_garantie__lte=kwargs.get('end_date'))
values_list = queryset.values_list(*self.fields).distinct()
return values_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_excel(self, filename):\n self.data.to_excel(filename)",
"def export_to_file(final_data_fetch):\r\n\r\n # Column names for data\r\n header_fields = ['Course', 'University', 'GPA', 'GRE', 'TOEFL', 'Work Experience', 'UG Course', 'UG College','Admit Status']\r\n with xlsxwriter.Workbook('yock... | [
"0.6996788",
"0.6588683",
"0.65867573",
"0.6548197",
"0.6542862",
"0.6455031",
"0.63961285",
"0.6389617",
"0.632453",
"0.6319494",
"0.628004",
"0.62699443",
"0.6260905",
"0.6237417",
"0.62198824",
"0.62193406",
"0.6173042",
"0.6167193",
"0.61626554",
"0.6151517",
"0.61514807"... | 0.0 | -1 |
Get a yacs CfgNode object with default values for my_project. | def get_cfg_defaults():
# Return a clone so that the defaults will not be altered
# This is for the "local variable" use pattern
return _C.clone() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_default_config(project):\n return {\n \"breathe_projects\": {\n project: \"./_doxygen/xml\"\n },\n \"breathe_default_project\": project,\n \"exhale_args\": {\n # required arguments\n \"containmentFolder\": \"./api\",\n \"rootFileNa... | [
"0.6206752",
"0.60061955",
"0.59438497",
"0.5857599",
"0.5857599",
"0.58438694",
"0.5837966",
"0.58032465",
"0.5682998",
"0.5640771",
"0.55415815",
"0.5538713",
"0.5535621",
"0.5531356",
"0.5446284",
"0.54307395",
"0.5405538",
"0.5367158",
"0.535104",
"0.5333277",
"0.5309475"... | 0.5848163 | 6 |
Convert a time.struct_time as returned by feedparser into a | def _convert_struct_time_to_dt(stime):
return date.fromtimestamp(mktime(stime)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def time_struct_to_datetime(struct_time_object):\n return datetime.datetime(*struct_time_object[:6])",
"def _convert_struct_time_to_dt(stime):\n\n dt = datetime.datetime.fromtimestamp(mktime(stime))\n\n return dt.date()",
"def unmarshall_time(tyme):\r\n return datetime.datetime(day=tyme['day'],\r\n... | [
"0.7229315",
"0.67260563",
"0.6565747",
"0.6513471",
"0.63544554",
"0.6352278",
"0.63428724",
"0.62921166",
"0.6273469",
"0.6266583",
"0.62201977",
"0.62145513",
"0.6209023",
"0.61696506",
"0.6159586",
"0.61529684",
"0.61013764",
"0.608812",
"0.59947324",
"0.5987127",
"0.5983... | 0.7049241 | 1 |
Use feedparser to parse PyBites RSS feed. Return a list of Entry namedtuples (date = date, drop time part) | def get_feed_entries(feed=FEED) -> list:
f = feedparser.parse(feed)
entry_list = []
for entry in f.entries:
date = _convert_struct_time_to_dt(entry["published_parsed"])
title = entry["title"]
link = entry["link"]
tags = [tag["term"].lower() for tag in entry["tags"]]
entry_list.append(Entry(date=date, title=title, link=link, tags=tags))
return entry_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_feed_entries(feed=FEED):\n d = feedparser.parse(feed)\n entries = d.entries\n \n all_entries =[]\n for entry in entries:\n title = entry.title\n link = entry.link\n date = entry.published_parsed\n tags = entry.tags\n tags = [t.get('term').lower() for t in t... | [
"0.7831155",
"0.729255",
"0.7232448",
"0.67960274",
"0.674423",
"0.6664003",
"0.66603625",
"0.6557846",
"0.6554401",
"0.65351653",
"0.65075",
"0.64848477",
"0.647246",
"0.6385361",
"0.63827616",
"0.63343084",
"0.6323492",
"0.6318049",
"0.6304754",
"0.6304091",
"0.62566954",
... | 0.7714306 | 1 |
Check if search matches any tags as stored in the Entry namedtuple (case insensitive, only whole, not partial string matches). | def filter_entries_by_tag(search, entry) -> bool:
tags = entry.tags
search_words = search.strip().translate(str.maketrans("&|", " ")).split()
if "&" in search:
search_type = "AND"
else:
search_type = "OR"
for word in search_words:
if word.lower() in tags:
if search_type == "OR":
return True
elif search_type == "AND":
return False
if search_type == "OR":
return False
else:
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_entries_by_tag(search, entry):\n \n entry_tags = entry.tags\n if '&' in search:\n splits = search.split('&')\n\n return all(split.lower() in entry_tags for split in splits)\n elif '|' in search:\n splits = search.split('|')\n return any(split.lower() in entry_... | [
"0.7962715",
"0.72779536",
"0.6499833",
"0.62624013",
"0.62382317",
"0.6214999",
"0.6140391",
"0.6119588",
"0.6078616",
"0.60098",
"0.59635174",
"0.5918138",
"0.5911922",
"0.58637714",
"0.5848267",
"0.5831237",
"0.5806548",
"0.5795138",
"0.57761455",
"0.57537323",
"0.57031983... | 0.75187373 | 1 |
Entry point to the program 1. Call get_feed_entries and store them in entries 2. Initiate an infinite loop | def main():
entries = get_feed_entries()
while True:
response = input("What you you like to search for? ")
if not response:
print("Please provide a search term")
continue
if response.lower() == "q":
print("Bye")
break
matches = [
entry
for entry in list(
filter(lambda x: filter_entries_by_tag(response.lower(), x), entries)
)
]
if matches:
for entry in sorted(matches, key=lambda x: x.date):
print(entry.title)
print(f"{len(matches)} {'entry' if len(matches) == 1 else 'entries'} matched") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_feed_entries_task():\n get_feed_entries()\n logger.info(\"Entries for Feed\")",
"def main():\n feed_db, entry_db = openDBs(FEED_DB_FN, ENTRY_DB_FN)\n\n feeds = [ x.strip() for x in open(FEEDS_FN, \"r\").readlines() ]\n \n entries = getNewFeedEntries(feeds, feed_db, entry_db)\n \n ... | [
"0.67926604",
"0.6669436",
"0.66450924",
"0.66018087",
"0.63761574",
"0.63712484",
"0.63650745",
"0.6307002",
"0.62871724",
"0.61856663",
"0.6142305",
"0.6107129",
"0.61045074",
"0.61003304",
"0.60493374",
"0.6042528",
"0.6004268",
"0.59982747",
"0.59332794",
"0.59283483",
"0... | 0.65567255 | 4 |
Gather the top 10 words by highest (descending) likelihoods for each class | def top10_likelihoods(likelihoods, vocab, classes):
resultDict = {}
for cls in classes:
results = []
for word in vocab:
results.append((word, likelihoods[cls][word]))
resultDict[cls] = results
# Sort and return top 10 for each class
for key in resultDict:
results = resultDict[key]
resultDict[key] = map(lambda x: x[0], sorted(results, key=lambda x: x[1], reverse=True))[:10]
return resultDict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def top10_odds_ratio(likelihoods, vocab, classes):\r\n results = []\r\n for word in vocab:\r\n highestOddsRatio = None\r\n for c1 in classes:\r\n for c2 in classes:\r\n # Skip self TODO: Is this right?\r\n # if c1 == c2:\r\n # continue... | [
"0.7205802",
"0.70088744",
"0.6974292",
"0.6939049",
"0.68271315",
"0.67730814",
"0.6618862",
"0.66091466",
"0.64232916",
"0.6413391",
"0.639833",
"0.63636",
"0.6353295",
"0.63519716",
"0.6349507",
"0.63440084",
"0.6335887",
"0.63027114",
"0.6243625",
"0.623767",
"0.6233897",... | 0.7892108 | 0 |
Gather the top 10 words by highest (descending) odds ratios | def top10_odds_ratio(likelihoods, vocab, classes):
results = []
for word in vocab:
highestOddsRatio = None
for c1 in classes:
for c2 in classes:
# Skip self TODO: Is this right?
# if c1 == c2:
# continue
oddsRatio = odds_ratio(likelihoods, c1, c2, word)
if oddsRatio > highestOddsRatio or highestOddsRatio == None:
highestOddsRatio = oddsRatio
results.append((word, highestOddsRatio))
# Sort and return top 10
return map(lambda x: x[0], sorted(results, key=lambda x: x[1], reverse=True))[:10] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_top_n_words(total_count__of_words, n): # Considering n=10 here as specified in the requirements\n return sorted(total_count__of_words.items(), key=lambda i: i[1], reverse=True)[:n]",
"def get_top_words(self, label, n):\n score_list = []\n if('sod' in label):\n for term i... | [
"0.7232739",
"0.6893036",
"0.67285866",
"0.6680685",
"0.66617835",
"0.66482335",
"0.6614465",
"0.6595784",
"0.6562109",
"0.645501",
"0.64387554",
"0.6425363",
"0.63707566",
"0.6370042",
"0.6349563",
"0.6348198",
"0.6341136",
"0.6331591",
"0.63161516",
"0.6312066",
"0.6284538"... | 0.7499493 | 0 |
Calculate the accuracy of our predicated vs. actual | def evaluate(predicted, actual):
assert(len(predicted) == len(actual))
total = len(actual)
correct = len([x for x in range(total) if predicted[x] == actual[x]])
return (float(correct) / float(total)) * 100.0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def accuracy(self):\n total_predictions = self.tp + self.fp + self.tn + self.fn;\n return float(self.tp + self.tn) / total_predictions if total_predictions != 0 else 1",
"def get_accuracy(self) -> float:\n self.network.load_data()\n self.network.train()\n\n n = len(self.network... | [
"0.83784646",
"0.82262033",
"0.822042",
"0.8146395",
"0.8089007",
"0.8089007",
"0.80558175",
"0.8008387",
"0.80057275",
"0.79616034",
"0.79590094",
"0.79344165",
"0.7930567",
"0.78854644",
"0.78593326",
"0.7858755",
"0.7850988",
"0.7762686",
"0.7759415",
"0.7753433",
"0.77095... | 0.0 | -1 |
Classify data based on bernoulli model | def classify(priors, likelihoods, testData, classes):
results = []
for document in testData:
bestClass = None
bestProb = None
currentProb = 0.0
for cls in classes:
prior = priors[cls]
currentProb = log(prior)
lhoods = likelihoods[cls]
for (word, count) in document:
if word in lhoods:
currentProb += log(lhoods[word])
else:
currentProb += log(lhoods[None])
if currentProb > bestProb or bestClass == None:
bestProb = currentProb
bestClass = cls
results.append(bestClass)
return results | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_Bernoulli_NB_estimators():",
"def fit_and_predict_BernoulliNB(X_train, Y_train, X_test):\n\n # Import the package\n from sklearn.naive_bayes import BernoulliNB \n\n ### YOUR SOLUTION STARTS HERE### \n #referenced to sklearn documentation \n # fit the model... \n clf = BernoulliNB(bi... | [
"0.6858228",
"0.68162215",
"0.6734391",
"0.6612314",
"0.65618414",
"0.64322984",
"0.64175165",
"0.64140654",
"0.6396146",
"0.63302946",
"0.6329519",
"0.62704647",
"0.62355125",
"0.6218283",
"0.6174795",
"0.6173328",
"0.6168497",
"0.61587894",
"0.61451745",
"0.61435205",
"0.61... | 0.0 | -1 |
Estimate the priors for a class | def calculate_priors(trainingLabels):
sum = 0
priors = {}
totalSamples = len(trainingLabels)
classes = set(trainingLabels)
for cls in classes:
numCls = len(filter(lambda x: x == cls, trainingLabels))
sum += numCls
priors[cls] = float(numCls) / float(totalSamples)
# Sanity check: valid partitioning
assert(sum == totalSamples)
return priors | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def classProbs(observation, tree, classes):\n res = classify(observation, tree) #res = results\n total = sum(res.values())\n probs = []\n for c in classes:\n if c in res.keys():\n probs.append(float(res[c])/total)\n else:\n probs.append(0)\n return probs",
"def ... | [
"0.66456854",
"0.6316928",
"0.6273953",
"0.60905004",
"0.6055876",
"0.60154176",
"0.5993265",
"0.59645927",
"0.59377426",
"0.5896327",
"0.58948433",
"0.58720356",
"0.58248436",
"0.5820803",
"0.58123535",
"0.5798083",
"0.57771003",
"0.5732761",
"0.5723448",
"0.57202864",
"0.57... | 0.699718 | 0 |
Calculate the likelihoods for multinomial | def calculate_likelihoods_multinomial(data, labels, vocab):
likelihoods = {}
counts = {}
words = {}
classes = set(labels)
vocabLen = len(vocab)
for cls in classes:
# Initialize
counts[cls] = {}
words[cls] = 0
# Perform counts
line = 0
for doc in data:
cls = labels[line]
wordCounts = counts[cls]
for (word, count) in doc:
if word not in wordCounts:
wordCounts[word] = 0
wordCounts[word] += count
words[cls] += count
line += 1
# Compute likliehoods
for cls in counts:
wordCounts = counts[cls]
likelihoods[cls] = {}
wordsInClass = words[cls]
for word in wordCounts:
likelihoods[cls][word] = laplace_smooth(wordCounts[word], wordsInClass, vocabLen)
# Add all training words:
for word in vocab:
if word not in likelihoods[cls]:
likelihoods[cls][word] = laplace_smooth(0, wordsInClass, vocabLen)
# Special laplace smoothing for words not found in training data
likelihoods[cls][None] = laplace_smooth(0, wordsInClass, vocabLen)
return likelihoods | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def multinomial_likelihood(m_true, alpha, alpha0, m_probs):\n\n ll = tf.reduce_sum(input_tensor=m_true * (tf.math.log(alpha0) - tf.math.log(alpha)), axis=1, keepdims=True)\n ll = tf.reduce_mean(input_tensor=ll)\n return ll",
"def multinomial_nll(true_counts, logits):\n counts_per_example = tf.reduce_... | [
"0.7405791",
"0.71270245",
"0.6805791",
"0.67948574",
"0.6551636",
"0.6476551",
"0.64614797",
"0.6425553",
"0.6342785",
"0.63420993",
"0.6332708",
"0.633066",
"0.6330074",
"0.6298897",
"0.62908417",
"0.62799925",
"0.62471",
"0.62063324",
"0.61783415",
"0.6177655",
"0.61492676... | 0.7152682 | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.