= 0)][:, np.newaxis]\\n return np.sum(\\n binom(self.p, ks)\\n * (-1) ** ks\\n * x[np.newaxis, :] ** (2 * (self.p - ks) - d)\\n * perm(2 * (self.p - ks), d),\\n axis=0,\\n )\",\n \"def phi_t(self):\\n\\t\\tdim = self.dim\\n\\t\\ttim_all = self.tim_all \\n\\t\\tphi_all = np.zeros((tim_all+1,dim,1),dtype = complex)\\n\\t\\tphi_all[0,:,:] = self.phi_i[:]\\n\\t\\tu_all = self.u_t()\\n\\n\\t\\tfor tim in xrange(tim_all):\\n\\t\\t\\tphi_all[tim+1,:,:] = np.dot(u_all[tim+1,:,:], phi_all[0,:,:])\\n\\t\\t\\n\\t\\treturn phi_all\",\n \"def phi_poly(self,x,i):\\n return x**i\",\n \"def gen_phi_wrt_yt(z_div_L, phiw, fcn_D, vw_div_vw0, y_div_R_arr, phi_arr, cond_GT):\\n phi_b = cond_GT['phi_bulk']\\n ed = cond_GT['epsilon_d']\\n \\n phi_arr[0] = phiw\\n int_INV_D_pre = 0.\\n Ny = size(y_div_R_arr)\\n for i in range(1, Ny):\\n y2 = y_div_R_arr[i]; y1 = y_div_R_arr[i-1]\\n dy = y2 - y1 \\n yh = y1 + dy/2. # for RK4 method \\n \\n\\n phi_1 = phi_arr[i-1]\\n k1 = dy * cal_f_RK(y1, 0., phi_1, 0., int_INV_D_pre, vw_div_vw0, fcn_D, cond_GT)\\n k2 = dy * cal_f_RK(y1, dy/2., phi_1, k1/2., int_INV_D_pre, vw_div_vw0, fcn_D, cond_GT)\\n k3 = dy * cal_f_RK(y1, dy/2., phi_1, k2/2., int_INV_D_pre, vw_div_vw0, fcn_D, cond_GT)\\n k4 = dy * cal_f_RK(y1, dy, phi_1, k3, int_INV_D_pre, vw_div_vw0, fcn_D, cond_GT)\\n phi_2 = phi_1 + (1./6.)*(k1 + 2.*k2 + 2.*k3 + k4)\\n phi_arr[i] = phi_2\\n\\n int_INV_D_pre += (dy/2.) * (1./fcn_D(phi_2, cond_GT) + 1./fcn_D(phi_1, cond_GT))\\n\\n return 0\",\n \"def phi(self):\\n return np.arctan2(np.sqrt(self.x**2 + self.y**2), self.z)\",\n \"def f(z, t):\\n zout = np.zeros_like(z)\\n zout[:] = [z[1], -dpdx]\\n return zout\",\n \"def phi_function(alpha, pk, xk):\\n x = xk + alpha * pk\\n return rosenbock2Nd(x, 0)\",\n \"def real(z):\",\n \"def rewofz_nonvector(x,y):\\n ncut=27\\n xy=x*y\\n xyp=xy/jnp.pi\\n exx=jnp.exp(-x*x)\\n f=exx*erfcx(y)*jnp.cos(2.0*xy)+x*jnp.sin(xy)/jnp.pi*exx*jnp.sinc(xyp)\\n n=jnp.arange(1,ncut+1)\\n n2=n*n\\n vec0=1.0/(0.25*n2+ y*y)\\n vec1=jnp.exp(-(0.25*n2+x*x))\\n vec2=jnp.exp(-(0.5*n+x)*(0.5*n+x))\\n vec3=jnp.exp(-(0.5*n-x)*(0.5*n-x))\\n Sigma1=jnp.dot(vec0,vec1)\\n Sigma2=jnp.dot(vec0,vec2)\\n Sigma3=jnp.dot(vec0,vec3)\\n f = f + 1.0/jnp.pi*(-y*jnp.cos(2.0*xy)*Sigma1 + 0.5*y*Sigma2 + 0.5*y*Sigma3)\\n return f\",\n \"def phi(self, x:int):\\n dimension = self.M + 1 # We are including a constant here.\\n p = [0] * dimension\\n for i in range(dimension):\\n p[i] += pow(x, i)\\n p = np.array(p)\\n p = p.reshape(p.shape + (1,))\\n return p\",\n \"def zerodegree_pol(dim):\\n\\n out = zeros(dim)\\n out[0] = 1\\n\\n return out\",\n \"def tan_inplace(a):\",\n \"def theta_phi_of_complex(z):\\n return np.stack([theta_of_complex(z), phi_of_complex(z)], axis=1)\",\n \"def tanh_inplace(a):\",\n \"def toeplitz_inverse_multiplication(u, x_0, phi, psi, D_phi, D_psi, Lambda_1, Lambda_2, Lambda_3, Lambda_4):\\n\\n y = fft(D_phi*u)\\n a = Lambda_1*fft(D_psi*(1/D_phi)*ifft(Lambda_2*y))\\n b = Lambda_3*fft(D_psi*(1/D_phi)*ifft(Lambda_4*y))\\n y = (1/D_psi)*real(ifft(a-b))/(x_0*(phi-psi))\\n \\n return y\",\n \"def Phi(v, p, q):\\n \\n return np.sum([Y(t,p,q) for t in v])\",\n \"def compute_hessian_vector_product(self, function, arguments):\",\n \"def TR_algo3(h, vd=2):\\n ve = 0\\n vd = 2\\n p = [0]*N\\n for i in range(M-1, -1, -1):\\n w = [bit_component(h, i*N+ii) for ii in range(N)]\\n #print(i, w)\\n w = sum( [wx*2**j for j, wx in enumerate(w)] )\\n #print(i, w, gc(w))\\n l = gc(w)\\n l = T_inv(ve, vd, l)\\n for j in range(N):\\n p[j] += bit_component(l, j) << i\\n ve = ve ^ rotate_left(e(w), vd+1)\\n vd = (vd + d(w) + 1) % N\\n return p\",\n \"def V_phi(self, x):\\n\\n x = self.featureExtractor.getFeatures(x)\\n\\n x = torch.tensor(x).float()\\n\\n x = F.relu(self.linear(x))\\n\\n v = self.linear_v(x)\\n\\n return v\",\n \"def CR(phi):\\n return (np.kron(P0,s0) + np.kron(P1,R(phi)))\",\n \"def _TODOStepsScipy(z, nstep, refr, Fin):\\n\\n if Fin._curvature != 0.0:\\n raise ValueError('Cannot operate on spherical coords.'\\n + 'Use Convert() first')\\n Fout = Field.copy(Fin)\\n N = Fout.N\\n lam = Fout.lam\\n size = Fout.siz\\n dtype = Fout._dtype\\n \\n legacy = True\\n if legacy:\\n Pi = 3.141592654 #to compare Cpp results accurately\\n else:\\n Pi = _np.pi\\n K = 2.*Pi/lam\\n z = z/2.\\n Pi4lz = 4.*Pi/lam/z\\n imPi4lz = 1j * Pi4lz\\n \\n delta = size/(N-1.) #dx\\n delta2 = delta*delta\\n \\n n = 100\\n c = 1\\n # n = N\\n # c = delta**2\\n def f(u, ):\\n return u**3\\n \\n def f_prime(u):\\n return 3 * u**2\\n \\n def fun(u, n, f, f_prime, c, **kwargs):\\n v = _np.zeros((n + 2, n + 2))\\n u = u.reshape((n, n))\\n v[1:-1, 1:-1] = u\\n y = v[:-2, 1:-1] + v[2:, 1:-1] + v[1:-1, :-2] + v[1:-1, 2:] - 4 * u + c * f(u)\\n return y.ravel()\\n\\n def compute_jac_indices(n):\\n i = _np.arange(n)\\n jj, ii = _np.meshgrid(i, i)\\n \\n ii = ii.ravel()\\n jj = jj.ravel()\\n \\n ij = _np.arange(n**2)\\n \\n jac_rows = [ij]\\n jac_cols = [ij]\\n \\n mask = ii > 0\\n ij_mask = ij[mask]\\n jac_rows.append(ij_mask)\\n jac_cols.append(ij_mask - n)\\n \\n mask = ii < n - 1\\n ij_mask = ij[mask]\\n jac_rows.append(ij_mask)\\n jac_cols.append(ij_mask + n)\\n \\n mask = jj > 0\\n ij_mask = ij[mask]\\n jac_rows.append(ij_mask)\\n jac_cols.append(ij_mask - 1)\\n \\n mask = jj < n - 1\\n ij_mask = ij[mask]\\n jac_rows.append(ij_mask)\\n jac_cols.append(ij_mask + 1)\\n \\n return _np.hstack(jac_rows), _np.hstack(jac_cols)\\n jac_rows, jac_cols = compute_jac_indices(N)\\n # u0 = np.ones(n**2) * 0.5\\n u0 = Fin.field.ravel() #initial guess is old field\\n \\n def jac(u, n, f, f_prime, c, jac_rows=None, jac_cols=None):\\n jac_values = _np.ones_like(jac_cols, dtype=float)\\n jac_values[:n**2] = -4 + c * f_prime(u)\\n return coo_matrix((jac_values, (jac_rows, jac_cols)),\\n shape=(n**2, n**2))\\n \\n res_1 = least_squares(fun, u0.real, jac=jac, gtol=1e-3,\\n args=(N, f, f_prime, c),\\n kwargs={'jac_rows': jac_rows,\\n 'jac_cols': jac_cols},\\n verbose=0)\\n # print(res_1)\\n Fout.field = res_1.x.reshape((N, N))\\n Fout._IsGauss=False\\n return Fout\",\n \"def pz_fn(self, z):\\n pass\",\n \"def helmholtz(X, u):\\r\\n ud = _np.zeros_like(u)\\r\\n copy = _np.ascontiguousarray\\r\\n\\r\\n theta = div(X, u)\\r\\n gth = scl_grad(X, theta)\\r\\n\\r\\n for i in range(3):\\r\\n poly1 = _interp(X[0], gth[i,:,:,:], axis=0)\\r\\n poly2 = poly1.antiderivative(nu=2)\\r\\n ud[i,...] += poly2(X[0])\\r\\n\\r\\n poly1 = _interp(X[1], gth[i,:,:,:], axis=1)\\r\\n poly2 = poly1.antiderivative(nu=2)\\r\\n ud[i,...] += poly2(X[1])\\r\\n\\r\\n poly1 = _interp(X[2], gth[i,:,:,:], axis=2)\\r\\n poly2 = poly1.antiderivative(nu=2)\\r\\n ud[i,...] += poly2(X[2])\\r\\n\\r\\n return ud\",\n \"def _phi_int(self, x, d, p):\\n ks = np.arange(self.p + 1)\\n ks = ks[np.where(2 * (self.p - ks) - d >= 0)][:, np.newaxis]\\n return np.sum(\\n binom(self.p, ks)\\n * (-1) ** ks\\n * x[np.newaxis, :] ** (2 * (self.p - ks) - d + 1)\\n * perm(2 * (self.p - ks), d)\\n / (2 * (self.p - ks) - d + 1),\\n axis=0,\\n )\",\n \"def lfun(z, lparams):\\n W, b = unpack(lparams)\\n return np.tanh(np.dot(z, W) + b)\",\n \"def Tanh(z):\\n return 1.7159 * np.tanh(2 / 3.0 * z)\",\n \"def homogeneous_Z( zTheta , pos ):\\r\\n return np.vstack( ( np.hstack( ( z_rot( zTheta ) , [ [ pos[0] ] , [ pos[1] ] , [ pos[2] ] ] ) ) ,\\r\\n np.hstack( ( [ 0 , 0 , 0 ] , [ 1 ] ) ) ) )\",\n \"def rz(self, phi, q): # pylint: disable=invalid-name\\n return self.append(RZGate(phi), [q], [])\",\n \"def lherzolite():\\n\\n rho = 3270.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 187.4; C[0,1] = 63.71; C[0,2] = 63.87; C[0,3] = 0.78; C[0,4] = 2.02; C[0,5] = -3.2\\n C[1,0] = C[0,1]; C[1,1] = 211.25; C[1,2] = 64.5; C[1,3] = -3.07; C[1,4] = 0.87; C[1,5] = -5.78\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 190.; C[2,3] = 0.38; C[2,4] = 2.38; C[2,5] = -0.12\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 67.9; C[3,4] = -2.12; C[3,5] = 1.6\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 63.12; C[4,5] = -0.55\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 66.83\\n\\n return C, rho\",\n \"def tf(xp, yp, zp, prisms, inc, dec, pmag=None):\\n if xp.shape != yp.shape != zp.shape:\\n raise ValueError(\\\"Input arrays xp, yp, and zp must have same shape!\\\")\\n # Calculate the 3 components of the unit vector in the direction of the\\n # regional field\\n fx, fy, fz = giutils.dircos(inc, dec)\\n res = 0\\n for prism in prisms:\\n if prism is None:\\n continue\\n if 'magnetization' not in prism.props and pmag is None:\\n continue\\n if pmag is None:\\n mx, my, mz = prism.props['magnetization']\\n else:\\n mx, my, mz = pmag\\n v1 = kernelxx(xp, yp, zp, prism)\\n v2 = kernelxy(xp, yp, zp, prism)\\n v3 = kernelxz(xp, yp, zp, prism)\\n v4 = kernelyy(xp, yp, zp, prism)\\n v5 = kernelyz(xp, yp, zp, prism)\\n v6 = kernelzz(xp, yp, zp, prism)\\n bx = v1*mx + v2*my + v3*mz\\n by = v2*mx + v4*my + v5*mz\\n bz = v3*mx + v5*my + v6*mz\\n res += fx*bx + fy*by + fz*bz\\n res *= CM * T2NT\\n return res\",\n \"def yz_rotation(vector,theta):\\r\\n R = np.array([[1,0,0],\\r\\n [0, np.cos(theta),-np.sin(theta)],\\r\\n [0, np.sin(theta), np.cos(theta)]\\r\\n ])\\r\\n return np.dot(R,vector)\",\n \"def anglor_phi(infile, sequence):\\n return anglor(infile, sequence)\",\n \"def func2(y, j, h, add_u = 0):\\n y_temp = y[j] + add_u\\n N = xsize\\n k = np.zeros(xsize)\\n for i in range(xsize):\\n k[i] = -(1/4.)*(1./h)*(y_temp[(i+1)%N]**2-y_temp[(i-1)%N]**2)\\n return k\",\n \"def phi(t, *args):\\n # Unpacking data\\n mu_1, pi_mu_2, distance, affine_transfo = args\\n A, b = get_Ab(t)\\n N = len(mu_1)\\n assert len(mu_1) == len(pi_mu_2)\\n # Computing value of objective function\\n r = 0.\\n for i in np.arange(N):\\n r += distance(affine_transfo(A, b, mu_1[i]), pi_mu_2[i]) ** 2\\n return r\",\n \"def f_inv(self, y, psi, iterations = 10):\\r\\n\\r\\n y = y.copy()\\r\\n z = np.ones_like(y)\\r\\n\\r\\n for i in range(iterations):\\r\\n z -= (self.f(z, psi) - y)/self.fgrad_y(z,psi)\\r\\n\\r\\n return z\",\n \"def get_z(theta, w, r=1):\\n return np.sin(theta) * r * np.sin(w)\",\n \"def __Vs__(self, z):\\r\\n return -np.array(I(z > self.psi), dtype=int)\",\n \"def phi(x):\\n # constants\\n a1 = 0.254829592\\n a2 = -0.284496736\\n a3 = 1.421413741\\n a4 = -1.453152027\\n a5 = 1.061405429\\n p = 0.3275911\\n\\n # Save the sign of x\\n sign = 1\\n if x < 0:\\n sign = -1\\n x = abs(x) / math.sqrt(2.0)\\n\\n # A&S formula 7.1.26\\n t = 1.0 / (1.0 + p * x)\\n y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * math.exp(-x * x)\\n\\n return 0.5 * (1.0 + sign * y)\",\n \"def zernike(m, n, rho, phi):\\n if (m > 0): return zernike_rad(m, n, rho) * np.cos(m * phi)\\n if (m < 0): return zernike_rad(-m, n, rho) * np.sin(-m * phi)\\n return zernike_rad(0, n, rho)\",\n \"def __truediv__(self, o): \\n return self * o.inv()\",\n \"def init_axis(self):\\n # Shorthand:\\n nphi = self.nphi\\n nfp = self.nfp\\n\\n phi = np.linspace(0, 2 * np.pi / nfp, nphi, endpoint=False)\\n d_phi = phi[1] - phi[0]\\n R0 = np.zeros(nphi)\\n Z0 = np.zeros(nphi)\\n R0p = np.zeros(nphi)\\n Z0p = np.zeros(nphi)\\n R0pp = np.zeros(nphi)\\n Z0pp = np.zeros(nphi)\\n R0ppp = np.zeros(nphi)\\n Z0ppp = np.zeros(nphi)\\n for jn in range(0, self.nfourier):\\n n = jn * nfp\\n sinangle = np.sin(n * phi)\\n cosangle = np.cos(n * phi)\\n R0 += self.rc[jn] * cosangle + self.rs[jn] * sinangle\\n Z0 += self.zc[jn] * cosangle + self.zs[jn] * sinangle\\n R0p += self.rc[jn] * (-n * sinangle) + self.rs[jn] * (n * cosangle)\\n Z0p += self.zc[jn] * (-n * sinangle) + self.zs[jn] * (n * cosangle)\\n R0pp += self.rc[jn] * (-n * n * cosangle) + self.rs[jn] * (-n * n * sinangle)\\n Z0pp += self.zc[jn] * (-n * n * cosangle) + self.zs[jn] * (-n * n * sinangle)\\n R0ppp += self.rc[jn] * (n * n * n * sinangle) + self.rs[jn] * (-n * n * n * cosangle)\\n Z0ppp += self.zc[jn] * (n * n * n * sinangle) + self.zs[jn] * (-n * n * n * cosangle)\\n\\n d_l_d_phi = np.sqrt(R0 * R0 + R0p * R0p + Z0p * Z0p)\\n d2_l_d_phi2 = (R0 * R0p + R0p * R0pp + Z0p * Z0pp) / d_l_d_phi\\n B0_over_abs_G0 = nphi / np.sum(d_l_d_phi)\\n abs_G0_over_B0 = 1 / B0_over_abs_G0\\n self.d_l_d_varphi = abs_G0_over_B0\\n G0 = self.sG * abs_G0_over_B0 * self.B0\\n\\n # For these next arrays, the first dimension is phi, and the 2nd dimension is (R, phi, Z).\\n d_r_d_phi_cylindrical = np.array([R0p, R0, Z0p]).transpose()\\n d2_r_d_phi2_cylindrical = np.array([R0pp - R0, 2 * R0p, Z0pp]).transpose()\\n d3_r_d_phi3_cylindrical = np.array([R0ppp - 3 * R0p, 3 * R0pp - R0, Z0ppp]).transpose()\\n\\n tangent_cylindrical = np.zeros((nphi, 3))\\n d_tangent_d_l_cylindrical = np.zeros((nphi, 3))\\n for j in range(3):\\n tangent_cylindrical[:,j] = d_r_d_phi_cylindrical[:,j] / d_l_d_phi\\n d_tangent_d_l_cylindrical[:,j] = (-d_r_d_phi_cylindrical[:,j] * d2_l_d_phi2 / d_l_d_phi \\\\\\n + d2_r_d_phi2_cylindrical[:,j]) / (d_l_d_phi * d_l_d_phi)\\n\\n curvature = np.sqrt(d_tangent_d_l_cylindrical[:,0] * d_tangent_d_l_cylindrical[:,0] + \\\\\\n d_tangent_d_l_cylindrical[:,1] * d_tangent_d_l_cylindrical[:,1] + \\\\\\n d_tangent_d_l_cylindrical[:,2] * d_tangent_d_l_cylindrical[:,2])\\n\\n axis_length = np.sum(d_l_d_phi) * d_phi * nfp\\n rms_curvature = np.sqrt((np.sum(curvature * curvature * d_l_d_phi) * d_phi * nfp) / axis_length)\\n mean_of_R = np.sum(R0 * d_l_d_phi) * d_phi * nfp / axis_length\\n mean_of_Z = np.sum(Z0 * d_l_d_phi) * d_phi * nfp / axis_length\\n standard_deviation_of_R = np.sqrt(np.sum((R0 - mean_of_R) ** 2 * d_l_d_phi) * d_phi * nfp / axis_length)\\n standard_deviation_of_Z = np.sqrt(np.sum((Z0 - mean_of_Z) ** 2 * d_l_d_phi) * d_phi * nfp / axis_length)\\n\\n normal_cylindrical = np.zeros((nphi, 3))\\n for j in range(3):\\n normal_cylindrical[:,j] = d_tangent_d_l_cylindrical[:,j] / curvature\\n self.normal_cylindrical = normal_cylindrical\\n self._determine_helicity()\\n\\n # b = t x n\\n binormal_cylindrical = np.zeros((nphi, 3))\\n binormal_cylindrical[:,0] = tangent_cylindrical[:,1] * normal_cylindrical[:,2] - tangent_cylindrical[:,2] * normal_cylindrical[:,1]\\n binormal_cylindrical[:,1] = tangent_cylindrical[:,2] * normal_cylindrical[:,0] - tangent_cylindrical[:,0] * normal_cylindrical[:,2]\\n binormal_cylindrical[:,2] = tangent_cylindrical[:,0] * normal_cylindrical[:,1] - tangent_cylindrical[:,1] * normal_cylindrical[:,0]\\n\\n # We use the same sign convention for torsion as the\\n # Landreman-Sengupta-Plunk paper, wikipedia, and\\n # mathworld.wolfram.com/Torsion.html. This sign convention is\\n # opposite to Garren & Boozer's sign convention!\\n torsion_numerator = (d_r_d_phi_cylindrical[:,0] * (d2_r_d_phi2_cylindrical[:,1] * d3_r_d_phi3_cylindrical[:,2] - d2_r_d_phi2_cylindrical[:,2] * d3_r_d_phi3_cylindrical[:,1]) \\\\\\n + d_r_d_phi_cylindrical[:,1] * (d2_r_d_phi2_cylindrical[:,2] * d3_r_d_phi3_cylindrical[:,0] - d2_r_d_phi2_cylindrical[:,0] * d3_r_d_phi3_cylindrical[:,2]) \\n + d_r_d_phi_cylindrical[:,2] * (d2_r_d_phi2_cylindrical[:,0] * d3_r_d_phi3_cylindrical[:,1] - d2_r_d_phi2_cylindrical[:,1] * d3_r_d_phi3_cylindrical[:,0]))\\n\\n torsion_denominator = (d_r_d_phi_cylindrical[:,1] * d2_r_d_phi2_cylindrical[:,2] - d_r_d_phi_cylindrical[:,2] * d2_r_d_phi2_cylindrical[:,1]) ** 2 \\\\\\n + (d_r_d_phi_cylindrical[:,2] * d2_r_d_phi2_cylindrical[:,0] - d_r_d_phi_cylindrical[:,0] * d2_r_d_phi2_cylindrical[:,2]) ** 2 \\\\\\n + (d_r_d_phi_cylindrical[:,0] * d2_r_d_phi2_cylindrical[:,1] - d_r_d_phi_cylindrical[:,1] * d2_r_d_phi2_cylindrical[:,0]) ** 2\\n\\n torsion = torsion_numerator / torsion_denominator\\n\\n self.etabar_squared_over_curvature_squared = self.etabar * self.etabar / (curvature * curvature)\\n\\n self.d_d_phi = spectral_diff_matrix(self.nphi, xmax=2 * np.pi / self.nfp)\\n self.d_varphi_d_phi = B0_over_abs_G0 * d_l_d_phi\\n self.d_d_varphi = np.zeros((nphi, nphi))\\n for j in range(nphi):\\n self.d_d_varphi[j,:] = self.d_d_phi[j,:] / self.d_varphi_d_phi[j]\\n\\n # Compute the Boozer toroidal angle:\\n self.varphi = np.zeros(nphi)\\n for j in range(1, nphi):\\n # To get toroidal angle on the full mesh, we need d_l_d_phi on the half mesh.\\n self.varphi[j] = self.varphi[j-1] + (d_l_d_phi[j-1] + d_l_d_phi[j])\\n self.varphi = self.varphi * (0.5 * d_phi * 2 * np.pi / axis_length)\\n\\n # Add all results to self:\\n self.phi = phi\\n self.d_phi = d_phi\\n self.R0 = R0\\n self.Z0 = Z0\\n self.R0p = R0p\\n self.Z0p = Z0p\\n self.R0pp = R0pp\\n self.Z0pp = Z0pp\\n self.R0ppp = R0ppp\\n self.Z0ppp = Z0ppp\\n self.G0 = G0\\n self.d_l_d_phi = d_l_d_phi\\n self.axis_length = axis_length\\n self.curvature = curvature\\n self.torsion = torsion\\n self.X1s = np.zeros(nphi)\\n self.X1c = self.etabar / curvature\\n self.min_R0 = fourier_minimum(self.R0)\\n self.tangent_cylindrical = tangent_cylindrical\\n self.normal_cylindrical = normal_cylindrical \\n self.binormal_cylindrical = binormal_cylindrical\\n self.Bbar = self.spsi * self.B0\\n self.abs_G0_over_B0 = abs_G0_over_B0\\n\\n # The output is not stellarator-symmetric if (1) R0s is nonzero,\\n # (2) Z0c is nonzero, (3) sigma_initial is nonzero, or (B2s is\\n # nonzero and order != 'r1')\\n self.lasym = np.max(np.abs(self.rs)) > 0 or np.max(np.abs(self.zc)) > 0 \\\\\\n or self.sigma0 != 0 or (self.order != 'r1' and self.B2s != 0)\\n\\n # Functions that converts a toroidal angle phi0 on the axis to the axis radial and vertical coordinates\\n self.R0_func = self.convert_to_spline(sum([self.rc[i]*np.cos(i*self.nfp*self.phi) +\\\\\\n self.rs[i]*np.sin(i*self.nfp*self.phi) \\\\\\n for i in range(len(self.rc))]))\\n self.Z0_func = self.convert_to_spline(sum([self.zc[i]*np.cos(i*self.nfp*self.phi) +\\\\\\n self.zs[i]*np.sin(i*self.nfp*self.phi) \\\\\\n for i in range(len(self.zs))]))\\n\\n # Spline interpolants for the cylindrical components of the Frenet-Serret frame:\\n self.normal_R_spline = self.convert_to_spline(self.normal_cylindrical[:,0])\\n self.normal_phi_spline = self.convert_to_spline(self.normal_cylindrical[:,1])\\n self.normal_z_spline = self.convert_to_spline(self.normal_cylindrical[:,2])\\n self.binormal_R_spline = self.convert_to_spline(self.binormal_cylindrical[:,0])\\n self.binormal_phi_spline = self.convert_to_spline(self.binormal_cylindrical[:,1])\\n self.binormal_z_spline = self.convert_to_spline(self.binormal_cylindrical[:,2])\\n self.tangent_R_spline = self.convert_to_spline(self.tangent_cylindrical[:,0])\\n self.tangent_phi_spline = self.convert_to_spline(self.tangent_cylindrical[:,1])\\n self.tangent_z_spline = self.convert_to_spline(self.tangent_cylindrical[:,2])\\n\\n # Spline interpolant for nu = varphi - phi, used for plotting\\n self.nu_spline = self.convert_to_spline(self.varphi - self.phi)\",\n \"def func3(y, j, h, add_u = 0):\\n y_temp = y[j] + add_u\\n N = xsize\\n k = np.zeros(xsize)\\n for i in range(xsize):\\n k[i] = -(1/4.)*(1./h)*(y_temp[(i+1)%N]**2-y_temp[(i-1)%N]**2) + (1/2.)*(1./h**2)*(y_temp[(i+1)%N]-2*y_temp[i%N]+y_temp[(i-1)%N])\\n return k\",\n \"def Psi(l,m,theta,phi):\\n if numpy.isscalar(theta): \\n theta=numpy.array([[theta]])\\n phi=numpy.array([[phi]])\\n Psilm_th=numpy.zeros(theta.shape,dtype=complex)\\n Psilm_ph=numpy.zeros(theta.shape,dtype=complex)\\n x=numpy.cos(theta)\\n thetaNonZerosIdx=numpy.where(theta!=0.0)\\n if len(thetaNonZerosIdx[0]) != 0:\\n Ylm=scipy.special.sph_harm(m,l,phi[thetaNonZerosIdx],theta[thetaNonZerosIdx])\\n #Compute derivative of sphrHarm function w.r.t. theta:\\n if l>=numpy.abs(m):\\n Plmpo=legendreLM(l,m+1,x[thetaNonZerosIdx])\\n YlmPmpo=math.sqrt((2*l+1)/(4*math.pi)*math.factorial(l-m)/float(math.factorial(l+m)))*Plmpo*numpy.exp(1j*m*phi[thetaNonZerosIdx])\\n #YlmPmpo=sqrt((l-m)*(l+m+1))*spharm(l,m+1,theta,phi)*exp(-i*phi) %Should be equivalent to above formula.\\n dtYlm=+YlmPmpo+m*x[thetaNonZerosIdx]*Ylm/numpy.sin(theta[thetaNonZerosIdx])\\n # thetZerInd=[find(theta==0); find(theta==pi)]\\n # dtYlm(thetZerInd)=0; %This is a fudge to remove NaNs\\n else:\\n dtYlm=numpy.zeros(theta[thetaNonZerosIdx].shape,dtype=complex)\\n\\n #dtYlm=spharmDtheta(l,m,theta,phi)\\n\\n Psilm_ph[thetaNonZerosIdx]=+1j*m/numpy.sin(theta[thetaNonZerosIdx])*Ylm\\n Psilm_th[thetaNonZerosIdx]=+dtYlm\\n #Ref: http://mathworld.wolfram.com/VectorSphericalHarmonic.html\\n\\n thetaZerosIdx=numpy.where(theta==0.0)\\n if len(thetaZerosIdx[0]) != 0:\\n if numpy.abs(m)==1:\\n Yl1B=math.sqrt((2*l+1)/(4*math.pi)*math.factorial(l-m)/math.factorial(l+m))*PBl1(l,m)*numpy.exp(1j*m*phi[thetaZerosIdx])\\n Plmpo=legendreLM(l,m+1,x[thetaZerosIdx])\\n YlmPmpo=math.sqrt((2*l+1)/(4*math.pi)*math.factorial(l-m)/math.factorial(l+m))*Plmpo*numpy.exp(1j*m*phi[thetaZerosIdx])\\n dtYlm=+YlmPmpo+m*Yl1B\\n Psilm_ph[thetaZerosIdx]=+1j*m*Yl1B\\n Psilm_th[thetaZerosIdx]=+dtYlm\\n else:\\n Plmpo=legendreLM(l,m+1,x[thetaZerosIdx])\\n YlmPmpo=math.sqrt((2*l+1)/(4*math.pi)*math.factorial(l-m)/math.factorial(l+m))*Plmpo*numpy.exp(1j*m*phi[thetaZerosIdx])\\n dtYlm=+YlmPmpo+0\\n Psilm_ph[thetaZerosIdx]=0\\n Psilm_th[thetaZerosIdx]=+dtYlm\\n return Psilm_th,Psilm_ph\",\n \"def zernikel(j, rho, phi):\\n n = 0\\n while (j > n):\\n n += 1\\n j -= n\\n m = -n+2*j\\n return zernike(m, n, rho, phi)\",\n \"def _make_phi(self, F):\\n scaled_bins_left = tf.concat(\\n [self.bin_edges / self.sigma,\\n np.array([np.inf])], 0)\\n scaled_bins_right = tf.concat(\\n [np.array([-np.inf]), self.bin_edges / self.sigma], 0)\\n return inv_probit(scaled_bins_left - tf.reshape(F, (-1, 1)) / self.sigma) \\\\\\n - inv_probit(scaled_bins_right - tf.reshape(F, (-1, 1)) / self.sigma)\",\n \"def lorentzian2d(p, x, y):\\n #2012-02-04 11:38 IJMC: Created\\n \\n x = array(x, dtype=float).copy()\\n y = array(y, dtype=float).copy()\\n p = array(p).copy()\\n\\n if len(p)==5:\\n p = concatenate((p, [0, 0]))\\n elif len(p)==6:\\n p = concatenate((p, [0]))\\n\\n z = ((x - p[3]) / p[1])**2 + ((y - p[4]) / p[2])**2 + p[5] * (x - p[3]) * (y - p[4])\\n \\n return p[6] + p[0]/(1. + z)\",\n \"def dphi(x):\\n return grad(phi)(x)\",\n \"def triangleFunction(self):\\n \\n w = np.zeros((self.N))\\n l = self.l\\n for i in range(self.r.shape[0]):\\n r = np.abs(self.r[i])\\n if r <= l:\\n tf = lambda r,l : 1 - r/l\\n w[i] = tf(r,l)\\n else:\\n w[i] = 0\\n self.w = w\",\n \"def zernike_poly(m, n, rho, phi):\\n\\t\\n\\tif (m > 0): return zernike_rad(m, n, rho) * np.cos(m * phi)\\n\\tif (m < 0): return zernike_rad(-m, n, rho) * np.sin(-m * phi)\\n\\n\\treturn zernike_rad(0, n, rho)\",\n \"def imag(z):\",\n \"def arcsinh_inplace(a):\",\n \"def phi0(self, x):\\n return (1-(1-x)**(4/3))**(3/2)/(2*np.sqrt(2))\",\n \"def tangent_map_integrand(phi, RZU, field):\\n R = RZU[0]\\n Z = RZU[1]\\n u00 = RZU[2]\\n u01 = RZU[3]\\n u10 = RZU[4]\\n u11 = RZU[5]\\n #print('tangent_map_integrand called at R={}, phi={}, Z={}'.format(R, phi, Z))\\n BR, Bphi, BZ = field.BR_Bphi_BZ(R, phi, Z)\\n grad_B = field.grad_B(R, phi, Z)\\n # VR = R * BR / Bphi\\n # VZ = R * BZ / Bphi\\n d_VR_d_R = BR / Bphi + R * grad_B[0, 0] / Bphi - R * BR / (Bphi * Bphi) * grad_B[1, 0]\\n d_VR_d_Z = R * grad_B[0, 2] / Bphi - R * BR / (Bphi * Bphi) * grad_B[1, 2]\\n d_VZ_d_R = BZ / Bphi + R * grad_B[2, 0] / Bphi - R * BZ / (Bphi * Bphi) * grad_B[1, 0]\\n d_VZ_d_Z = R * grad_B[2, 2] / Bphi - R * BZ / (Bphi * Bphi) * grad_B[1, 2]\\n \\n dydt = [R * BR / Bphi,\\n R * BZ / Bphi,\\n d_VR_d_R * u00 + d_VR_d_Z * u10,\\n d_VR_d_R * u01 + d_VR_d_Z * u11,\\n d_VZ_d_R * u00 + d_VZ_d_Z * u10,\\n d_VZ_d_R * u01 + d_VZ_d_Z * u11]\\n return dydt\",\n \"def phi(self):\\n return (np.sum(self.diameters**self.ndim)*np.pi / (2*self.ndim))\",\n \"def _q_z(self):\\n D = self.latt_par['D'].value\\n lambda_r = self.latt_par['lambda_r'].value\\n gamma = self.latt_par['gamma'].value\\n return 2*np.pi*(self.h/D - self.k/lambda_r/np.tan(gamma))\",\n \"def euler(func, z0, time):\\r\\n\\r\\n z = np.zeros((np.size(time), np.size(z0)))\\r\\n z[0,:] = z0\\r\\n\\r\\n for i in range(len(time)-1):\\r\\n dt = time[i+1] - time[i]\\r\\n z[i+1,:]=z[i,:] + np.asarray(func(z[i,:], time[i]))*dt\\r\\n\\r\\n return z\",\n \"def generate_phi(self):\\n self.phi = np.empty((100, self.K))\\n for i, point in enumerate(self.X):\\n for j, center in enumerate(self.centers):\\n self.phi[i][j] = np.exp(-self.gamma * distance.euclidean(point, center) ** 2)\\n self.phi = np.concatenate((self.phi, np.ones((100, 1))), axis=1)\",\n \"def rewofzs1(x,y):\\n z=x+y*(1j)\\n a=1.0/(2.0*z*z)\\n q=(1j)/(z*jnp.sqrt(jnp.pi))*(1.0 + a*(1.0 + a*3.0))\\n return jnp.real(q)\",\n \"def z_eq(self):\\n theta = self.T_cmb/2.7\\n return 25000.*self.Omega_m*self.h**2.*theta**-4.\",\n \"def imwofz_vectorized(x, y):\\n ncut=27\\n xy=x*y\\n xyp=2.0*xy/jnp.pi\\n exx=jnp.exp(-x*x)\\n f=-exx*erfcx(y)*jnp.sin(2.0*xy)+x/jnp.pi*exx*jnp.sinc(xyp)\\n n=jnp.arange(1,ncut+1)\\n n2=n*n\\n x2=x*x\\n y2=y*y\\n vec0=0.5*n/(0.25*n2+y2)\\n vec1=jnp.exp(-(0.25*n2[None,:]+x2[:,None]))\\n vec4=jnp.exp(-(0.5*n[None,:]+x[:,None])*(0.5*n[None,:]+x[:,None]))\\n vec5=jnp.exp(-(0.5*n[None,:]-x[:,None])*(0.5*n[None,:]-x[:,None]))\\n Sigma1=jnp.sum(vec0*vec1,axis=1)\\n Sigma4=jnp.sum(vec0*vec4,axis=1)\\n Sigma5=jnp.sum(vec0*vec5,axis=1)\\n f = f + 1.0/jnp.pi*(y*jnp.sin(2.0*xy)*Sigma1 + 0.5*(Sigma5-Sigma4))\\n\\n return f\",\n \"def calculate_phi_vals(self) -> None:\\n for point in self.points:\\n point.phi = - (point.psi + point.theta)\",\n \"def Z_hipass(C, L, R_L, f):\\n return 1/(1/Xind(L,f) + 1/Z_high(C, R_L, f))\",\n \"def _derZ(self, x, y, z):\\n if _isscalar(x):\\n y_pos = max(min(np.searchsorted(self.y_list, y), self.y_n - 1), 1)\\n z_pos = max(min(np.searchsorted(self.z_list, z), self.z_n - 1), 1)\\n alpha = (y - self.y_list[y_pos - 1]) / (\\n self.y_list[y_pos] - self.y_list[y_pos - 1]\\n )\\n dfdz = (\\n (\\n (1 - alpha) * self.xInterpolators[y_pos - 1][z_pos](x)\\n + alpha * self.xInterpolators[y_pos][z_pos](x)\\n )\\n - (\\n (1 - alpha) * self.xInterpolators[y_pos - 1][z_pos - 1](x)\\n + alpha * self.xInterpolators[y_pos][z_pos - 1](x)\\n )\\n ) / (self.z_list[z_pos] - self.z_list[z_pos - 1])\\n else:\\n m = len(x)\\n y_pos = np.searchsorted(self.y_list, y)\\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\\n y_pos[y_pos < 1] = 1\\n z_pos = np.searchsorted(self.z_list, z)\\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\\n z_pos[z_pos < 1] = 1\\n dfdz = np.zeros(m) + np.nan\\n for i in range(1, self.y_n):\\n for j in range(1, self.z_n):\\n c = np.logical_and(i == y_pos, j == z_pos)\\n if np.any(c):\\n alpha = (y[c] - self.y_list[i - 1]) / (\\n self.y_list[i] - self.y_list[i - 1]\\n )\\n dfdz[c] = (\\n (\\n (1 - alpha) * self.xInterpolators[i - 1][j](x[c])\\n + alpha * self.xInterpolators[i][j](x[c])\\n )\\n - (\\n (1 - alpha) * self.xInterpolators[i - 1][j - 1](x[c])\\n + alpha * self.xInterpolators[i][j - 1](x[c])\\n )\\n ) / (self.z_list[j] - self.z_list[j - 1])\\n return dfdz\",\n \"def fun_decay_inv(p,r):\\n return (p[1]*r0 / r) * np.cos(p[0]*r + p[2])\",\n \"def phi_of_complex(z):\\n theta = theta_of_complex(z)\\n return np.arccos(np.real(z/np.sin(theta/2.0)))\",\n \"def z_rotmat(theta):\\n cos_t = np.cos(theta)\\n sin_t = np.sin(theta)\\n return np.array([[cos_t, -sin_t, 0],\\n [sin_t, cos_t, 0],\\n [0, 0, 1]])\",\n \"def OAVolterra_FrauenhoferZone_inverse(pz,wD,dt,Nt):\\n p0 = np.zeros(Nt)\\n cumSum = 0.\\n for i in range(1,Nt-1):\\n cumSum += 0.5*(pz[i-1]+pz[i+1])\\n p0[i] = cumSum \\n return p0*2.*dt*wD\",\n \"def f(p, phi, phib, df):\\n\\treturn -log(p) - df + (p-1)*phi + \\\\\\n\\t ( phi*(1-p) + phib + \\\\\\n\\t 5./4*alpha*(phi*p)**(9./4)-(9./4)*alpha*(p*phi)**(5./4) - \\\\\\n\\t (1./2)(1-p*phi)**2 - (phib/Nb)-5./4*alpha*(phi+phib)**(9./4) + \\\\\\n\\t (9./4)*alpha*(phi+phib)**(5.4) + \\\\\\n\\t 1./2*(1-phi-phib)**2 ) * Ns\",\n \"def zx_rotation(vector,theta):\\r\\n R = np.array([[np.cos(theta),0,np.sin(theta)],\\r\\n [0,1,0],\\r\\n [-np.sin(theta),0,np.cos(theta)]\\r\\n ])\\r\\n return np.dot(R,vector)\",\n \"def proyZ1(u, v, t2):\\n den = u ** 2 + v ** 2 + 4\\n x = u - t2 * (u - 4 * u / den)\\n y = v - t2 * (v - 4 * v / den)\\n z = 1 - t2 * (2 - 8 / den)\\n return (x, y, z)\",\n \"def lizardite():\\n\\n rho = 2610.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 245.; C[0,1] = 50.; C[0,2] = 31.; C[0,3] = 0.; C[0,4] = 0.; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = 245.; C[1,2] = 31.; C[1,3] = 0.; C[1,4] = 0.; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 23.; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 11.6; C[3,4] = 0.; C[3,5] = 0.\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 11.6; C[4,5] = 0.\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 97.5\\n\\n return C, rho\",\n \"def tanh(a):\",\n \"def phiprime_phi(phi):\\n f = 0.0022927\\n phiprime = np.arctan2(np.tan(phi*np.pi/180.),(1.-f)**2.)*180./np.pi\\n return phiprime\",\n \"def diriv(x, params):\\n return np.array([x,1])\",\n \"def get_fc_inv(fc):\\n return scipy.linalg.pinvh(fc.T @ fc) @ fc.T\",\n \"def euler_phi(n):\\n\\n if n == 1:\\n return 1\\n\\n phi = n\\n for p, a in factorize(n):\\n phi -= phi // p\\n\\n return phi\",\n \"def get_lz(self):\\r\\n return self.dz * self.nz - self.oz\",\n \"def _derZ(self, w, x, y, z):\\n if _isscalar(x):\\n y_pos = max(min(np.searchsorted(self.y_list, y), self.y_n - 1), 1)\\n z_pos = max(min(np.searchsorted(self.z_list, z), self.z_n - 1), 1)\\n alpha = (y - self.y_list[y_pos - 1]) / (\\n self.y_list[y_pos] - self.y_list[y_pos - 1]\\n )\\n dfdz = (\\n (\\n (1 - alpha) * self.wxInterpolators[y_pos - 1][z_pos](w, x)\\n + alpha * self.wxInterpolators[y_pos][z_pos](w, x)\\n )\\n - (\\n (1 - alpha) * self.wxInterpolators[y_pos - 1][z_pos - 1](w, x)\\n + alpha * self.wxInterpolators[y_pos][z_pos - 1](w, x)\\n )\\n ) / (self.z_list[z_pos] - self.z_list[z_pos - 1])\\n else:\\n m = len(x)\\n y_pos = np.searchsorted(self.y_list, y)\\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\\n y_pos[y_pos < 1] = 1\\n z_pos = np.searchsorted(self.z_list, z)\\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\\n z_pos[z_pos < 1] = 1\\n dfdz = np.zeros(m) + np.nan\\n for i in range(1, self.y_n):\\n for j in range(1, self.z_n):\\n c = np.logical_and(i == y_pos, j == z_pos)\\n if np.any(c):\\n alpha = (y[c] - self.y_list[i - 1]) / (\\n self.y_list[i] - self.y_list[i - 1]\\n )\\n dfdz[c] = (\\n (\\n (1 - alpha) * self.wxInterpolators[i - 1][j](w[c], x[c])\\n + alpha * self.wxInterpolators[i][j](w[c], x[c])\\n )\\n - (\\n (1 - alpha)\\n * self.wxInterpolators[i - 1][j - 1](w[c], x[c])\\n + alpha * self.wxInterpolators[i][j - 1](w[c], x[c])\\n )\\n ) / (self.z_list[j] - self.z_list[j - 1])\\n return dfdz\",\n \"def Rz(q):\\n sin_q, cos_q = sin(q), cos(q)\\n return numpy.matrix([\\n [cos_q, sin_q, 0, 0],\\n [-sin_q, cos_q, 0, 0],\\n [0, 0, 1, 0],\\n [0, 0, 0, 1],\\n ])\",\n \"def V_magUranus(alpha,a_p,d,phi=-82.):\\n V = 5.*np.log10(a_p*d) - 7.110 - 8.4e-04*phiprime_phi(phi) + 6.587e-3*alpha + 1.045e-4*alpha**2.\\n return V\",\n \"def e_z(self, z):\\n onez = 1+z \\n onez2 = onez*onez \\n onez3 = onez*onez2 \\n arg = self.m0*onez3 + self.k0*onez2 + self.q0 \\n return(np.sqrt(arg))\",\n \"def fun(_, y):\\n return np.array([-self.r * self.beta * y[1] * y[0] / self.N,\\n self.r * self.beta * y[1] * y[0] / self.N - self.gamma * y[1],\\n self.gamma * y[1]])\",\n \"def grad_phi_mesh(self):\\n fy = -0.5 * (np.roll(self.phi, 1, axis = 1) - np.roll(self.phi, -1, axis=1)) \\n fx = -0.5 * (np.roll(self.phi, 1, axis = 0) - np.roll(self.phi, -1, axis=0))\\n return fx,fy\",\n \"def cal_phi(self):\\n\\n if not self.check_def(['E','px','py','pz']):\\n sys.exit('Particle error: Quadri impulsion not define (error for phi routine)')\\n\\n if(self.px>0):\\n self.phi=math.atan(self.py/self.px)\\n elif(self.px<0):\\n self.phi=math.atan(self.py/self.px)+math.pi\\n elif(self.py>0): #remind that p(1)=0\\n self.phi=math.pi/2.0\\n elif(self.py<0): # remind that p(1)=0\\n self.phi=-math.pi/2.0\\n else:\\n print \\\"Warning self.phi not properly defined put value to 0\\\"\\n self.phi=0\\n \\n if(self.phi<0):\\n self.phi=self.phi+2*math.pi\\n\\n return self.phi\",\n \"def f(z, X, Y, _lambda):\\r\\n w = z[:-1]\\r\\n beta = np.squeeze(z[-1])\\r\\n term_1_d = (X * (Y[:, np.newaxis] - g(X.dot(w) + beta))).sum(axis=0)\\r\\n term_d_1 = (Y[:, np.newaxis] - g(X.dot(w) + beta)).sum() + 2 * _lambda * beta\\r\\n return np.hstack((term_1_d, term_d_1))[:, np.newaxis]\",\n \"def SSHZ(L, teff):\\n return [np.sqrt(L/seffi(teff)), np.sqrt(L/seffo(teff))]\",\n \"def mxz(mXZ,P_dot_Dj,P_times_Dj):\\n return np.divide(np.multiply(P_times_Dj, mXZ), P_dot_Dj)\",\n \"def ftlan_E1c(hop, v0, T, m=50, Min_b=10e-10, Min_m=5, kB=1, norm = np.linalg.norm):\\n# def Tri_diag(a1, b1):\\n# mat = np.diag(b1, -1) + np.diag(a1, 0) + np.diag(b1, 1)\\n# e, w = np.linalg.eigh(mat)\\n# return e, w\\n\\n beta = 1./(T * kB)\\n E = 0.\\n a, b = [], []\\n v0 = v0/norm(v0)\\n Hv = hop(v0)\\n a.append(v0.dot(Hv))\\n v1 = Hv - a[0] * v0\\n b.append(norm(v1))\\n if b[0] < Min_b:\\n return 0\\n\\n v1 = v1/b[0]\\n Hv = hop(v1)\\n a.append(v1.dot(Hv))\\n\\n for i in range(1, m - 1):\\n v2 = Hv - b[i - 1] * v0 - a[i] * v1\\n b.append(norm(v2))\\n if abs(b[i]) < Min_b:\\n b.pop()\\n break\\n\\n v2 = v2/b[i]\\n Hv = hop(v2)\\n a.append(v2.dot(Hv))\\n v0 = v1.copy()\\n v1 = v2.copy()\\n \\n a = np.asarray(a)\\n b = np.asarray(b)\\n\\n eps, phi = Tri_diag(a, b)\\n l = len(eps)\\n# Eo = eps[0]\\n# eps = eps-Eo\\n exp_eps = np.exp(-beta * eps)\\n E = np.sum(exp_eps * eps * phi[0, :]**2.)\\n Z = np.sum(exp_eps * phi[0, :]**2.)\\n# for i in range(len(eps)):\\n# E += exp_eps[i] * eps[i] * phi[0, i]**2\\n\\n# E = E + Eo\\n# de = eps[:, np.newaxis] - eps\\n# for i in range(l):\\n# E += eps[i] * phi[0, i]**2./np.sum(np.exp(-beta*de[:l, i])*(phi[0, :l]**2.))\\n return E, Z\",\n \"def f(z):\\n a=1./(1.+z)\\n #da=0.01\\n da=0.01*a\\n #da=1e-7\\n gp,g,gm=[D(1./ia-1.) for ia in [a+da,a,a-da]]\\n f=a*(gp-gm)/(2*g*da)\\n #dz=0.01\\n #gp,g,gm=[D(zi) for zi in [z+dz,z,z-dz]]\\n #f=(z)*(gp-gm)/(2.*g*dz)\\n return f\",\n \"def phi(x,n):\\n return 1/(np.sqrt(2**n*np.math.factorial(n))) * (1/np.pi)**0.25 * \\\\\\n np.exp(-x**2/2)*sp.special.eval_hermite(n,x)\",\n \"def phi(self, img):\\n indexes = np.arange(self.top - self.phi_length + 1, self.top)\\n\\n phi = np.empty((self.phi_length, self.height,\\n self.width), dtype='float32')\\n phi[0:self.phi_length -\\n 1] = self.imgs.take(indexes, axis=2, mode='wrap')\\n phi[-1] = img\\n return phi\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7914443","0.65681076","0.6435109","0.6432777","0.62693334","0.6253677","0.62178755","0.6203702","0.6139488","0.6075881","0.60546553","0.5954539","0.594207","0.5890718","0.58856523","0.58819497","0.58702683","0.5864873","0.5826224","0.5771205","0.57692486","0.5762415","0.575716","0.5756936","0.57362086","0.5734347","0.57286227","0.57271063","0.5713164","0.5698121","0.5690941","0.5663719","0.5657095","0.5652684","0.56485885","0.5645758","0.5639001","0.562103","0.5613828","0.5608404","0.5601355","0.5591942","0.5585476","0.5583377","0.5570004","0.5569383","0.5561754","0.5550649","0.55346376","0.5532494","0.5522971","0.55217373","0.55132985","0.5512573","0.5507964","0.5506335","0.5504777","0.55036247","0.55023515","0.5499587","0.5499076","0.5493152","0.5488725","0.54861075","0.54859143","0.5484509","0.54771304","0.54713464","0.5469353","0.5468154","0.5467495","0.5465005","0.545343","0.5451196","0.54505104","0.54497105","0.5443676","0.54427564","0.5440639","0.54344845","0.5426439","0.54258084","0.54241216","0.5420712","0.5407844","0.5403032","0.5398455","0.53959894","0.5391648","0.5381267","0.5375161","0.5373141","0.5370579","0.536942","0.5369169","0.5364181","0.53639495","0.53610724","0.53574497","0.53569466"],"string":"[\n \"0.7914443\",\n \"0.65681076\",\n \"0.6435109\",\n \"0.6432777\",\n \"0.62693334\",\n \"0.6253677\",\n \"0.62178755\",\n \"0.6203702\",\n \"0.6139488\",\n \"0.6075881\",\n \"0.60546553\",\n \"0.5954539\",\n \"0.594207\",\n \"0.5890718\",\n \"0.58856523\",\n \"0.58819497\",\n \"0.58702683\",\n \"0.5864873\",\n \"0.5826224\",\n \"0.5771205\",\n \"0.57692486\",\n \"0.5762415\",\n \"0.575716\",\n \"0.5756936\",\n \"0.57362086\",\n \"0.5734347\",\n \"0.57286227\",\n \"0.57271063\",\n \"0.5713164\",\n \"0.5698121\",\n \"0.5690941\",\n \"0.5663719\",\n \"0.5657095\",\n \"0.5652684\",\n \"0.56485885\",\n \"0.5645758\",\n \"0.5639001\",\n \"0.562103\",\n \"0.5613828\",\n \"0.5608404\",\n \"0.5601355\",\n \"0.5591942\",\n \"0.5585476\",\n \"0.5583377\",\n \"0.5570004\",\n \"0.5569383\",\n \"0.5561754\",\n \"0.5550649\",\n \"0.55346376\",\n \"0.5532494\",\n \"0.5522971\",\n \"0.55217373\",\n \"0.55132985\",\n \"0.5512573\",\n \"0.5507964\",\n \"0.5506335\",\n \"0.5504777\",\n \"0.55036247\",\n \"0.55023515\",\n \"0.5499587\",\n \"0.5499076\",\n \"0.5493152\",\n \"0.5488725\",\n \"0.54861075\",\n \"0.54859143\",\n \"0.5484509\",\n \"0.54771304\",\n \"0.54713464\",\n \"0.5469353\",\n \"0.5468154\",\n \"0.5467495\",\n \"0.5465005\",\n \"0.545343\",\n \"0.5451196\",\n \"0.54505104\",\n \"0.54497105\",\n \"0.5443676\",\n \"0.54427564\",\n \"0.5440639\",\n \"0.54344845\",\n \"0.5426439\",\n \"0.54258084\",\n \"0.54241216\",\n \"0.5420712\",\n \"0.5407844\",\n \"0.5403032\",\n \"0.5398455\",\n \"0.53959894\",\n \"0.5391648\",\n \"0.5381267\",\n \"0.5375161\",\n \"0.5373141\",\n \"0.5370579\",\n \"0.536942\",\n \"0.5369169\",\n \"0.5364181\",\n \"0.53639495\",\n \"0.53610724\",\n \"0.53574497\",\n \"0.53569466\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78623563"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":91789,"cells":{"query":{"kind":"string","value":"Predicts normalized kvector for given proportion of tokens."},"document":{"kind":"string","value":"def formula(self, x: np.ndarray, dim: int) -> np.ndarray:\n\n # coerce into dimensionless array\n x = np.array(x).reshape(-1)\n\n # apply kn formula to each value of n\n k_frac = np.array([self.formula_n(n, x) for n in range(dim)])\n k_frac = k_frac.T\n\n # return proportions\n return k_frac"},"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 predict_k(\n self,\n m_tokens: np.ndarray,\n dim: int,\n normalize: bool = False,\n nearest_int: bool = True,\n ) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # retrieve fitting parameters\n M_z, N_z = self.params\n\n # scale down to normalized log formula\n x = m_tokens / M_z\n k_frac = self.formula(x, dim)\n\n # normalize, or don't\n if normalize:\n # predicted counts as a proportion of predicted types\n y_types_omitted = k_frac[:, 0]\n y_types_selected = 1 - y_types_omitted\n y_types_selected = y_types_selected[:, np.newaxis]\n k = k_frac / y_types_selected\n else:\n # predicted counts\n k = N_z * k_frac\n\n # roundoff\n if nearest_int:\n k = np.round(k)\n\n # allow scalar\n if return_scalar:\n assert len(k) == 1\n k = k.squeeze()\n\n # return n-legomena counts\n return k","def predictability(self):\n temp = self.probs\n for n in range(10):\n temp = temp.dot(temp)\n final = temp[0,:]\n #Let's assume that all words have unique initial letters\n probs = map(len, self.words)\n probs = array(probs)\n probs = (probs + self.probs.max(1)-1)/probs\n return sum(final*probs)","def test_predict_func(self):\n ve = VariogramEstimator(n_lags=15, normalize=False).fit(self.c, self.v)\n v = ve.variogram\n\n x = np.linspace(0, ve.range_, 100)\n\n assert_array_almost_equal(ve.predict(x), v.transform(x), decimal=6)","def unigram(tokens):\n model = collections.defaultdict(lambda: 0.01)\n for token in tokens:\n try:\n model[token] += 1\n except KeyError:\n model[token] = 1\n continue\n for word in model:\n model[word] = model[word]/float(sum(model.values()))\n return model","def predict(self, kf):\n self.mean, self.covariance = kf.predict(self.mean, self.covariance)","def predict_tokens(self, tokens):\n return","def unigram_model(list_of_words, unigram_count, N=count_token()):\n d = pd.read_csv(unigram_count)\n proba_dict = {list_of_words[i]: (d[el].values[0] / float(N)) if el in d.columns.values else 0.0 for i, el in enumerate(list_of_words) }\n return proba_dict","def predict(self, X_test):\n if self.basis_func is not None:\n X_transformed = self.basis_func(X_test)\n else:\n X_transformed = X_test\n\n # Marginalise predictions over hyperparameters\n mu = np.zeros([len(self.hypers), X_transformed.shape[0]])\n var = np.zeros([len(self.hypers), X_transformed.shape[0]])\n\n for i, h in enumerate(self.hypers):\n mu[i] = np.dot(self.models[i][0].T, X_transformed.T)\n var[i] = 1. / h[1] + np.diag(np.dot(np.dot(X_transformed, self.models[i][1]), X_transformed.T))\n\n m = mu.mean(axis=0)\n v = var.mean(axis=0)\n # Clip negative variances and set them to the smallest\n # positive float value\n if v.shape[0] == 1:\n v = np.clip(v, np.finfo(v.dtype).eps, np.inf)\n else:\n v = np.clip(v, np.finfo(v.dtype).eps, np.inf)\n v[np.where((v < np.finfo(v.dtype).eps) & (v > -np.finfo(v.dtype).eps))] = 0\n\n return m, v","def predict(self, X):\n\n X = np.asarray(X)\n if X.ndim == 1:\n# X = np.asarray([X]).T\n # Data has a single feature\n X = X.reshape(-1, 1)\n\n # Indexes of support vectors\n ind_sv = self.ind_sv()\n\n # Compute kernels\n if self.kernel == 'rbf':\n Din = dist.cdist(self.X[ind_sv, :], X, 'sqeuclidean')\n Kin = np.exp(-self.gamma_in * Din)\n else: # Linear kernel\n Kin = np.dot(self.X[ind_sv, :], self.D.dot(X.T))\n\n Dout = dist.pdist(np.asarray([self.probs]).T, 'sqeuclidean')\n Kout = np.exp(-self.gamma_out * dist.squareform(Dout)) \\\n if self.gamma_out != np.inf else np.eye(np.size(self.probs))\n\n pred = np.dot(np.dot(Kout, self.coefs[:, ind_sv]), Kin).T\n pred += self.intercept\n return pred.T","def predict(self, X_test, V = None):\n\t\tif X_test.ndim == 1:\n\t\t\tX_test = X_test[:,np.newaxis]\n\t\tif X_test.shape[1] == self.D:\n\t\t\tX_test = np.concatenate((np.ones((X_test.shape[0],1)), X_test), axis = 1) #adding dummy variable for the bias\n\t\tif V is None:\n\t\t\tV = self.V\n\t\tres = np.matmul(X_test,V) #(N,K)\n\t\tres = np.exp(res) + 1e-5 #(N,K)\n\t\tres = np.divide(res.T, np.sum(res, axis = 1)).T #(N,K) normalizing\n\n\t\treturn res","def predict(self, x, k, MC_samples=20):\n distr = self.get_predictive(x.to(self.device), k)\n\n def likelihood(y): #currently hardcoded for binary classification\n return 1./ (1 + torch.exp(-y))\n\n predicted = 0\n for i in range(MC_samples):\n sample = distr.sample()\n predicted += likelihood(sample)\n predicted /= MC_samples\n return predicted","def predict(self):\n RV = np.zeros((self.N,self.P))\n for term_i in range(self.n_terms):\n RV+=np.dot(self.Fstar()[term_i],np.dot(self.B()[term_i],self.Astar()[term_i]))\n return RV","def predict_for_items(self, norm=True):\n pred = self.item_vectors.dot(self.item_vectors.T)\n if norm:\n norms = np.array([np.sqrt(np.diagonal(pred))])\n pred = pred / norms / norms.T\n return pred","def score(self, sentence):\n # TODO your code here\n\n # initialize count with trained data\n unigram_count = self.count.copy()\n N = self.total\n\n # make a new key for UNK, add-one later\n for token in sentence:\n if token not in unigram_count:\n unigram_count[token] = 0\n\n # calcutate lopP(<s>) + logP(w1) + logP(w2) + ...\n score = 0.0 # P(<s>) = 1\n V = len(unigram_count) # the number of vocab including UNK\n for word in sentence:\n prob = float((unigram_count[word] + 1) / (N + V)) # c(w) + 1 / N + V\n score += math.log(prob)\n\n return score","def get_average_vec(tokens_list, vector, generate_missing=False, k=300):\r\n if len(tokens_list)<1:\r\n return np.zeros(k)\r\n \r\n if generate_missing:\r\n vectorized = [vector[word] if word in vector else np.random.rand(k) for word in tokens_list]\r\n else:\r\n vectorized = [vector[word] if word in vector else np.zeros(k) for word in tokens_list]\r\n \r\n length = len(vectorized)\r\n summed = np.sum(vectorized, axis=0)\r\n averaged = np.divide(summed, length)\r\n return averaged","def precision(gt, pred, k):\n k = min(len(pred), k)\n den = min(len(gt), k)\n return sum([int(pred[i] in gt) for i in range(k)]) / den","def predict(self, X):\n if X.ndim==1: X = X[None,:]\n m, v = self.model.predict(X)\n v = np.clip(v, 1e-10, np.inf)\n return m, np.sqrt(v)","def normalize(knot_vector, decimals=18):\n try:\n if knot_vector is None or len(knot_vector) == 0:\n raise ValueError(\"Input knot vector cannot be empty\")\n except TypeError as e:\n print(\"An error occurred: {}\".format(e.args[-1]))\n raise TypeError(\"Knot vector must be a list or tuple\")\n except Exception:\n raise\n\n first_knot = float(knot_vector[0])\n last_knot = float(knot_vector[-1])\n denominator = last_knot - first_knot\n\n knot_vector_out = [float((\"{:.\" + str(decimals) + \"f}\").format((float(kv) - first_knot) / denominator))\n for kv in knot_vector]\n\n return knot_vector_out","def predict(self, reviews):\n self.vect_rev = self.vectorizer.transform(reviews)\n self.dmat = xgb.DMatrix(self.vect_rev)\n self.probs = self.bst.predict(self.dmat)\n\n # Get tough on reviews by requiring 0.6 probability threshold\n self.preds = 1 * (self.probs > 0.6)","def predict(self, text):\r\n vectorizer = CountVectorizer(ngram_range=(1, 2), lowercase=True, vocabulary=self.voc)\r\n vector = vectorizer.fit_transform([text])\r\n return self.model.predict(vector)[0]","def predict_for_customers(self,):\n return self.user_vectors.dot(self.item_vectors.T)","def predict(self, X):\r\n from math import log\r\n result = []\r\n choise_dict = dict()\r\n for sentence in X:\r\n for key in self.ver_cls.keys():\r\n choise_dict[key] = log(self.ver_cls[key])\r\n for word in sentence.split():\r\n if word in self.ver_dict.keys():\r\n for key in self.ver_cls.keys():\r\n choise_dict[key] += log(self.ver_dict[word][key])\r\n v = list(choise_dict.values())\r\n k = list(choise_dict.keys())\r\n result.append(k[v.index(max(v))])\r\n return result\r\n pass","def predict(self, sentence, smoothing=None):\n words = sentence.split()\n words.append(\"STOP\")\n probability = 1.0\n\n words = [self.START_SYMBOL, self.START_SYMBOL] + words\n ###################\n # Compute the probability of a sentence under the trigram model\n # p(x1,..,xn)= \\prod {q(x_i| x_{i-2}x_{i-1}}\n for i in xrange(len(words)-2):\n probability *= self.trigram_prob(words[i], words[i+1], words[i+2])\n\n return probability","def estimate_probability(word, previous_n_gram, \r\n n_gram_counts, n_plus1_gram_counts, vocabulary_size, k=1.0):\r\n # Note : 1 . Here we are actually not considering the end token or start token as a part of a vocabulary.\r\n # 2 . Although the literature says we need to prepend the n-1 SOS tokens but in reality we are prepending n SOS tokens\r\n \r\n # convert list to tuple to use it as a dictionary key\r\n previous_n_gram = tuple(previous_n_gram)\r\n\r\n previous_n_gram_count = n_gram_counts.get(previous_n_gram, 0)\r\n \r\n\r\n denominator = float(previous_n_gram_count + (k*vocabulary_size))\r\n\r\n n_plus1_gram = previous_n_gram + (word,)\r\n \r\n\r\n n_plus1_gram_count = n_plus1_gram_counts.get(n_plus1_gram, 0)\r\n \r\n\r\n numerator = float(n_plus1_gram_count + k)\r\n\r\n probability = float(numerator/denominator)\r\n \r\n \r\n return probability","def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # sum over legomena coefficients k\n x = m_tokens / self.M\n exponents = range(len(self.k))\n terms = np.array([np.power(1 - x, n) for n in exponents])\n k_0 = np.dot(self.k, terms)\n n_types = self.N - k_0\n\n # roundoff\n if nearest_int:\n n_types = np.round(n_types)\n\n # allow scalar\n if return_scalar:\n assert len(n_types) == 1\n n_types = n_types[0]\n\n # return\n return n_types","def precision_at_k(model, ratings, k, relevance_func):\n predictions = model.predict_all()\n np.place(predictions, ratings == 0, -np.Inf)\n recommended = predictions.argsort(1)[::, :-k-1:-1]\n \n relevance_per_user = np.take_along_axis(ratings, recommended, 1)\n max_relevance_per_user = (relevance_per_user > 0).sum(1)\n relevance_per_user = relevance_func(relevance_per_user).sum(1)\n\n precision = np.divide(relevance_per_user, max_relevance_per_user)\n \n return np.nanmean(precision)","def vectorize_sentence(sentence, model):\n final_vec = np.zeros(300, )\n count = 0\n for word in sentence:\n count += 1\n dummy_vec = np.zeros(300, )\n try:\n temp_vec = get_vector(word, model)\n final_vec += temp_vec\n except:\n final_vec += dummy_vec\n return final_vec / count","def predict(x):\n file_train = open('trains.pkl', \"rb\")\n train = pkl.load(file_train)\n y = []\n k = 5\n x_train = train[0]\n y_train = train[1]\n for q in range(100):\n distance = []\n for i in range(800):\n distance.append(np.linalg.norm(x[q] - x_train[i]))\n\n # distance.append(np.sqrt(sum((x[q] - x_train[i]) ** 2)))\n # u = (x[0] - x_train) ** 2\n # print(distance)\n # distance = np.sqrt([sum(b) for b in u])\n # print(distance)\n minarg = np.argsort(distance)\n i = np.array(np.zeros(10))\n j = 0\n while k not in i:\n i[y_train[minarg[j]]] += 1\n j += 1\n y.append(np.argmax(i))\n return y","def getSigma(self, pred_vects):\n sigma = tf.matmul(pred_vects, pred_vects, transpose_a=True)\n # Divide by m to normalise sigma invariant of number of input vectors\n sigma = sigma / pred_vects.shape[-2]\n # Add epsilon to sigma to avoid zeros\n sigma = tf.add(sigma, tf.eye(sigma.shape[-1], batch_shape=sigma.shape[:0])*\\\n tf.keras.backend.epsilon())\n return sigma","def predict(self, key):\n return self.counts.get(key, 1.0)","def post_processing_4_train(clf, X, indexes, k=5):\n\n predictions = []\n all_scores = []\n for idx, line_input in tqdm(enumerate(X)):\n # line_input = np.asarray(line_input,np.str)\n scores = clf.predict(line_input)\n scores = np.asarray(np.reshape(scores, newshape=(-1,)))\n orders = np.argsort(scores, axis=-1)[::-1]\n scores = scores[orders]\n sents_indexes = np.asarray(indexes[idx])\n predictions.append(sents_indexes[orders][:k])\n all_scores.append(scores[:5])\n return predictions, all_scores","def precision_at_k(r, k):\n assert k >= 1\n r = np.asarray(r)[:k] != 0\n if r.size != k:\n raise ValueError('Relevance score length < k')\n return np.mean(r)","def prediction(self,x):\n if self.x is None:\n mean = np.zeros(len(x))\n cov = self.k(x,x)\n else:\n kVec = self.k(self.x,x)\n mean = np.dot(kVec.T,self.scaled_data)\n schurFactor = la.solve(self.Kchol,kVec)\n cov = self.k(x,x) - np.dot(schurFactor.T,schurFactor)\n return mean,cov","def predict(self, X):","def predict(self, X):","def _postprocess(self, preds):\n ntok = preds.pop(\"ntok\")\n ids = preds.pop(\"input_ids\")[:ntok]\n preds[\"tokens\"] = self._detokenize(ids)\n\n # Decode predicted top-k tokens.\n # token_topk_preds will be a List[List[(word, prob)]]\n # Initialize prediction for 0th token as N/A.\n token_topk_preds = [[(\"N/A\", 1.)]]\n pred_ids = preds.pop(\"top_k_indices\")[:ntok] # <int>[num_tokens, k]\n pred_probs = preds.pop(\"top_k_probs\")[:ntok] # <float32>[num_tokens, k]\n for token_pred_ids, token_pred_probs in zip(pred_ids, pred_probs):\n token_pred_words = self._detokenize(token_pred_ids)\n token_topk_preds.append(list(zip(token_pred_words, token_pred_probs)))\n preds[\"pred_tokens\"] = token_topk_preds\n\n # Process attention.\n for key in preds:\n if not re.match(r\"layer_(\\d+)/attention\", key):\n continue\n # Select only real tokens, since most of this matrix is padding.\n # <float32>[num_heads, max_seq_length, max_seq_length]\n # -> <float32>[num_heads, num_tokens, num_tokens]\n preds[key] = preds[key][:, :ntok, :ntok].transpose((0, 2, 1))\n # Make a copy of this array to avoid memory leaks, since NumPy otherwise\n # keeps a pointer around that prevents the source array from being GCed.\n preds[key] = preds[key].copy()\n\n return preds","def predict(self, X):\n words = X.split()\n chance = []\n for cur_label in self.model[\"labels\"]:\n probability = self.model[\"labels\"][cur_label][\"probability\"]\n total_grade = math.log(probability, math.e)\n for word in words:\n word_dict = self.model[\"words\"].get(word, None)\n if word_dict:\n total_grade += math.log(word_dict[cur_label], math.e)\n chance.append((total_grade, cur_label))\n _, prediction = max(chance)\n return prediction","def predict(self, kf):\n self.mean, self.covariance = kf.predict(self.mean, self.covariance)\n self.age += 1\n self.time_since_update += 1","def predict(self, kf):\n self.mean, self.covariance = kf.predict(self.mean, self.covariance)\n self.age += 1\n self.time_since_update += 1","def predict(self, X, k=1):\n dists = self.compute_distances(X)\n return self.predict_labels(dists, k=k)","def precision_at_k(r, k):\n assert k >= 1\n r = np.asarray(r)[:k] != 0\n if r.size != k:\n raise ValueError('Relevance score length < k')\n return np.mean(r)","def apk(actual, predicted, k=10):\n if len(predicted)>k:\n predicted = predicted[:k]\n\n score = 0.0\n num_hits = 0.0\n\n for i,p in enumerate(predicted):\n if p in actual and p not in predicted[:i]:\n num_hits += 1.0\n score += num_hits / (i+1.0)\n\n if not actual:\n return 0.0\n\n return score / min(len(actual), k)","def apk(actual, predicted, k=3):\n\n actual = set(actual)\n predicted = list(predicted)\n\n if len(predicted) > k:\n predicted = predicted[:k]\n\n score = 0.0\n num_hits = 0.0\n\n for i, p in enumerate(predicted):\n if p in actual and p not in set(predicted[:i]):\n num_hits += 1.0\n score += num_hits / (i + 1.0)\n\n if not actual:\n return 0.0\n\n return score / min(len(actual), k)","def mapk(actual, predicted, k):\n return round(np.mean([apk(a,p,k) for a,p in zip(actual, predicted)]), 4) * 100","def apk(actual, predicted, k=10):\n if len(predicted) > k:\n predicted = predicted[:k]\n\n score = 0.0\n num_hits = 0.0\n\n for i, p in enumerate(predicted):\n if p in actual and p not in predicted[:i]:\n num_hits += 1.0\n score += num_hits / (i + 1.0)\n\n # if not actual:\n # return 0.0\n\n return score / min(len(actual), k)","def predict(self):\n for track in self.tracks:\n track.predict(self.kf)\n #track.du_doan(self.kf_test)","def predict(self, X):\n predictions = [c.predict(X) for c in self.classifiers]\n votes = np.zeros((len(X),self.label_count), dtype='i8')\n for row in xrange(len(X)):\n for model in xrange(self.model_count):\n for label in xrange(len(self.label_sets[model])):\n votes[row,self.label_sets[model][label]] += predictions[model][row][label]\n\n voters = np.zeros(self.label_count, dtype='i8')\n for label_set in self.label_sets:\n voters[label_set] += 1\n\n for row in xrange(len(X)):\n for label in xrange(self.label_count):\n votes[row, label] = int(float(votes[row, label]) / float(voters[label]) > 0.5)\n\n return votes","def fit_predict(self, X):\n MyKMedoids.fit(self, X)\n return MyKMedoids.predict(self, X)\n pass","def predict(self):\n for track in self.tracks:\n track.predict(self.kf)","def predict(self):\n for track in self.tracks:\n track.predict(self.kf)","def predict(self):\n for track in self.tracks:\n track.predict(self.kf)","def predict(self):\n input_item_vector = self.item_embeddings(self.input_item)\n input_user_vector = self.user_embeddings(self.input_user)\n input_item_vector_reshaped = tf.keras.layers.Reshape(\n (self.item_dim, 1))(input_item_vector)\n input_user_vector_reshaped = tf.keras.layers.Reshape(\n (self.user_dim, 1))(input_user_vector)\n\n dot_product = tf.keras.layers.dot(\n [input_item_vector_reshaped, input_user_vector_reshaped], axes=2)\n predicted_rating = tf.keras.layers.Dense(\n 1, activation='linear')(dot_product)\n return predicted_rating","def gkern(mx, my, kernlen):\n x, y = np.mgrid[0:kernlen:1, 0:kernlen:1]\n pos = np.empty(x.shape + (2,))\n pos[:, :, 0] = x; pos[:, :, 1] = y\n rv = multivariate_normal([mx*kernlen, my*kernlen], [[3.0, 0.0], [0.0, 3.0]])\n array = rv.pdf(pos).reshape([kernlen*kernlen])\n array = array/max(array)\n\n return array","def metric_precision_at_k(pred: list, echt: list, k: int):\n echt_keys = [key for key, _ in echt[:k]]\n return sum([1.0 for key, _ in pred[:k] if key in echt_keys]) / float(k)","def predict(self, user: torch.tensor, k: int):\n pass","def computesvd(train, K):\n mean = global_mean(train)\n train = standardize(train, mean)\n std = compute_std(train)\n train = div_std(train)\n\n U, s, Vt = sp.linalg.svds(train, k=K)\n\n dim = (len(s), len(s))\n S = np.zeros(dim)\n for i in range(len(s)):\n S[i, i] = mt.sqrt(s[i])\n\n U = sp.lil_matrix(U, dtype=np.float32) # dim(M,k)\n S = sp.lil_matrix(S, dtype=np.float32) # dim(k,k)\n Vt = sp.lil_matrix(Vt, dtype=np.float32) # dim(k,N)\n\n user_features = S.dot(Vt)\n item_features = np.transpose(U.dot(S))\n\n return user_features, item_features, mean, std","def apk(actual, predicted, k):\n\n if len(predicted)>k:\n predicted = predicted[:k]\n \n score = 0.0\n num_hits = 0.0\n\n for i,p in enumerate(predicted):\n if p in actual and p not in predicted[:i]:\n num_hits += 1.0\n score += num_hits / (i+1.0)\n\n if not actual:\n return 0.0\n\n return round(score / min(len(actual), k), 5)","def normalize(self):\n for key in self.corpus.keys():\n sum_count = 0\n words = []\n counts = []\n for k, v in self.corpus[key].items():\n sum_count += v\n words.append(k)\n counts.append(v)\n prob = [float(count)/sum_count for count in counts]\n\n self.corpus[key] = [words, prob]","def avg_sentence_vector(words, model, num_features, index2word_set):\n featureVec = np.zeros((num_features,), dtype=\"float32\")\n nwords = 0\n\n for word in words:\n if word in index2word_set:\n nwords = nwords+1\n featureVec = np.add(featureVec, model.wv[word])\n # featureVec = np.add(featureVec, model.wv.__getitem__(word))\n\n if nwords>0:\n featureVec = np.divide(featureVec, nwords)\n return featureVec","def estimate_probabilities(previous_n_gram, n_gram_counts, n_plus1_gram_counts, vocabulary, k=1.0):\r\n \r\n previous_n_gram = tuple(previous_n_gram)\r\n \r\n # add <e> <unk> to the vocabulary\r\n # <s> is not needed since it should not appear as the next word\r\n vocabulary = vocabulary + [\"<e>\", \"<unk>\"]\r\n vocabulary_size = len(vocabulary)\r\n \r\n probabilities = {}\r\n for word in vocabulary:\r\n probability = estimate_probability(word, previous_n_gram, \r\n n_gram_counts, n_plus1_gram_counts, \r\n vocabulary_size, k=k)\r\n probabilities[word] = probability\r\n\r\n return probabilities","def _predict_doc(self, x, flag):\n\n if flag == 1:\n denom = self.X.num_positive()\n else:\n denom = self.X.num_negative()\n denom += self.X.vocab_size()\n\n # multiply word probabilities for all words in x\n words = tokenize(x)\n # prob = 1.0\n # for word in words:\n # wi = self._doc_count_for_word(word, flag=flag)\n # # utilize the Laplace Smooth\n # prob *= ((float(wi)+1.0) / (float(denom)+2.0))\n\n prob = math.log(self.X.priors[str(flag)])\n for word in words:\n wi = self._doc_count_for_word(word, flag=flag)\n # utilize the Laplace Smooth\n prob += math.log((float(wi)+1.0) / (float(denom)+2.0))\n\n # prob *= math.log(self.X.priors[str(flag)])\n\n return prob","def clf1_predict(self):\n self._pred_clf_1 = self._clf1.predict(self._vectorized_input)[0]","def predict(self, X):\n\n stuff = self._vectorizer.transform(X)\n result = self._classifier.predict(stuff)\n return result\n pass","def prediction(self, v, imu_meas):\n # YOUR CODE HERE\n pass","def apk(actual, predicted, k=10):\n if len(predicted) > k:\n predicted = predicted[:k]\n score = 0.0\n num_hits = 0.0\n\n for i, p in enumerate(predicted):\n if p in actual and p not in predicted[:i]:\n num_hits += 1.0\n score += num_hits / (i + 1.0)\n\n return score / min(len(actual), k)","def predict(self, x):\n pred_labels = np.zeros((x.shape[0], 10))\n\n N = len(self.NET)\n for i in range(N):\n\n inputs = self.apply_dct_permutation(x.copy(), self.permutation[i])\n pred_labels += self.NET[i].model.predict(inputs)\n\n return pred_labels","def predict(self, \n\t\t\t\tvdf, \n\t\t\t\tname: str = \"\"):\n\t\tcheck_types([\n\t\t\t(\"name\", name, [str], False)],\n\t\t\tvdf = [\"vdf\", vdf])\n\t\tname = \"KMeans_\" + ''.join(ch for ch in self.name if ch.isalnum()) if not (name) else name\n\t\treturn (vdf.eval(name, self.deploySQL()))","def predict(term):\n if len(accept_doc) == 0 and len(reject_doc) == 0:\n return 0.5\n # Use spaCy's .similarity() method to compare the term to the\n # accepted and rejected Doc\n if len(accept_doc) and accept_doc.vector_norm != 0.0:\n accept_score = max(term.similarity(accept_doc), 0.0)\n else:\n accept_score = 0.0\n if len(reject_doc) and reject_doc.vector_norm != 0:\n reject_score = max(term.similarity(reject_doc), 0.0)\n else:\n reject_score = 0.0\n score = accept_score / (accept_score + reject_score + 0.2)\n return max(score, 0.0)","def predict(self, review):\n raise NotImplementedError","def _minimal_predict(Classifier, vector, threshold):\n return Classifier.predict(array([vector.tolist()]), threshold)","def score(self, sentence):\n score = 0.0\n V = len(self.f1) # vocabulary size\n for token in sentence:\n if token in self.f1: score += self.f1[token]\n else: score -= math.log10(self.total + V)\t\t # OOV \n return score","def score(self, predictions):\n return 0.","def predict(self, X):\n\t\tif X.ndim ==1:\n\t\t\tX = X[:,np.newaxis]\n\t\t\n\t\tpi = self.gating.predict(X) #p(z_i = k|x_i) (N,K)\n\n\t\t#indices = np.argmax(pi, axis =1)\n\t\t#for i in range(pi.shape[0]):\n\t\t#\tpi[i,indices[i]] = 1.\n\n\t\tpi = np.divide(pi.T, np.sum(pi, axis = 1)).T\n\t\tres = np.multiply(pi, self.experts_predictions(X))\n\t\treturn np.sum(res, axis = 1)","def MillerNormalVectors_100():\r\n k_100 = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])\r\n return np.array([k_100[0, :], k_100[1, :], k_100[2, :],\r\n -k_100[0, :], -k_100[1, :], -k_100[2, :]])","def predict(self, X):\n\t\tn_samples = np.size(X, 0)\n\t\ty = np.hstack((np.ones((n_samples, 1)), (X-np.mean(X, 0)) \\\n / np.std(X, 0))) @ self.weights","def predict(self, X):\n N, D = X.shape\n\n # init prediction array\n prediction = np.array([-1] * N)\n\n # retrieve the probability of predicting fraud for each model (K models)\n predict_proba_fraud = [-1] * self.K\n\n # we do the computation for all input test examples\n for i, instance in enumerate(X):\n sum_weight = 0\n F_k = 0\n\n # for k in= {1,2.....K} do\n k = -1\n for model in self.models.islice(start=0, stop=self.K, reverse=True):\n k += 1\n clf = model.clf\n sum_weight += model.weight\n\n # (1) compute the corresponding Fk(x)\n # compute one part of Fk(y) with the weights (be careful: sum_weight may be 0)\n F_k = (F_k * sum_weight) / sum_weight if sum_weight != 0 else 0\n\n # if the probability is not initialized we call the predict proba method\n if (type(predict_proba_fraud[k]) is int and predict_proba_fraud[k] == -1) \\\n or (predict_proba_fraud[k].shape[0] != self.S):\n predict_proba_fraud[k] = clf.predict_proba(self.X_chunk)\n\n # if we don't have the probability of predicting fraud --> p = 0, do nothing\n if len(predict_proba_fraud[k][i]) == 2:\n F_k += (model.weight * predict_proba_fraud[k][i][1]) / sum_weight\n\n # (2) we assign Fk value to a bin j\n t_y = instance[-1] # amount of the transaction (in the last column of the features)\n found = False # found: if a label has been decided (deal with 2 for's break)\n j = 0\n eps = len(self.bins)\n\n # while we haven't found the bin AND no prediction has not yet been given\n while j < eps and not found:\n stat = self.bins[j][k]\n\n # find the bin i y belongs to\n if (j / eps) <= F_k < ((j + 1) / eps):\n # (3) apply rule (10) for this bin (What if the amount is 0 ?)\n if t_y != 0:\n if F_k - stat['mean'] - self.t * stat['var'] > (self.cost / t_y): # FRAUD\n found = True\n prediction[i] = 1\n elif F_k + stat['mean'] + self.t * stat['var'] <= (self.cost / t_y): # NON-FRAUD\n found = True\n prediction[i] = 0\n else:\n found = True\n prediction[i] = 0\n\n j = j + 1\n\n if found: # if we found a value we go to the next example\n break\n\n # (4) if no classifier left i.e. we have consulted every classifier without having an answer\n # --> prediction[i] is not yet given\n if prediction[i] == -1:\n if instance[-1] != 0 and F_k > self.cost / instance[-1]: # instance[-1] is just t(y)\n prediction[i] = 1\n else:\n prediction[i] = 0\n\n return prediction","def predict(self, X):\n ...","def predict(self, X):\n ...","def predict(self, X):\n ...","def _raw_predict(self, _Xnew, which_parts='all', full_cov=False, stop=False):\r\n Kx = self.kern.K(_Xnew, self.X, which_parts=which_parts).T\r\n # KiKx = np.dot(self.Ki, Kx)\r\n KiKx, _ = dpotrs(self.L, np.asfortranarray(Kx), lower=1)\r\n mu = np.dot(KiKx.T, self.likelihood.Y)\r\n if full_cov:\r\n Kxx = self.kern.K(_Xnew, which_parts=which_parts)\r\n var = Kxx - np.dot(KiKx.T, Kx)\r\n else:\r\n Kxx = self.kern.Kdiag(_Xnew, which_parts=which_parts)\r\n var = Kxx - np.sum(np.multiply(KiKx, Kx), 0)\r\n var = var[:, None]\r\n if stop:\r\n debug_this # @UndefinedVariable\r\n return mu, var","def predictClusters(self, df, k):\n self.models.fitModels(df)\n return self.models.predict()","def nmse(gt, pred):\n return np.linalg.norm(gt - pred) ** 2 / np.linalg.norm(gt) ** 2","def nmse(gt, pred):\n return np.linalg.norm(gt - pred) ** 2 / np.linalg.norm(gt) ** 2","def compute_scaled_predictions(raw_predictions):\n return expit(raw_predictions)","def predict(net, query, context, graph, tokenizer, sentence_lengths, fb_passes=1):\n\n # (M,2), (1,M), (1,M), (1,3)\n o_sup, o_start, o_end, o_type = net(query, context, graph, fb_passes=fb_passes)\n\n # =========== GET ANSWERS\n answer_start = o_start.argmax() #TODO make sure that these tensors are all only containing one number!\n answer_end = o_end.argmax()\n answer_type = o_type.argmax()\n if answer_type == 0:\n answer = \"yes\"\n elif answer_type == 1:\n answer = \"no\"\n elif answer_type == 2 and answer_end >= answer_start:\n answer = tokenizer.decode(graph.tokens[answer_start: answer_end + 1])\n else:\n answer = \"noanswer\"\n\n # =========== GET SUPPORTING FACTS\n pos = 0\n sup_fact_pairs = []\n for para, s_lens in zip(context, sentence_lengths):\n for j, s_len in enumerate(s_lens):\n #score = round(sum(o_sup.argmax([pos: pos + s_len])) / s_len)\n # take avg of token-wise scores and round to 0 or 1\n try:\n score = round(float(sum([x.argmax() for x in o_sup.T[pos: pos + s_len]]) / float(s_len)))\n except ZeroDivisionError:\n score = 0\n if score == 1:\n sup_fact_pairs.append([para[0], j])\n pos += s_len\n\n return answer, sup_fact_pairs","def metric_recall_at_k(pred: list, echt: list, k: int):\n echt_keys = [key for key, _ in echt]\n return sum([1.0 for key, _ in pred[:k] if key in echt_keys]) / len(echt)","def predict(self, X):\n\n Xn = np.copy(X)\n\n preds = []\n # compute distance from all points\n for x1 in Xn:\n dist = self._euclidian_distance(self.X_data, x1)\n dist = np.vstack((dist, self.y)).T\n dist = dist[dist[:, 0].argsort(axis=0)][:,-1]\n # get a vote from top k\n pred = sts.mode(dist[0:self.k])[0][0]\n preds.append(pred)\n\n return np.array(preds)","def predict_proba(self):\n ...","def accuracy_sentence_level(dataset, beta, d2v_model):\r\n \r\n prediction_right = 0\r\n \r\n for row in dataset:\r\n sentence_vec = numpy.reshape(d2v_model.infer_vector(row[0].split(), alpha=0.1, steps=20), newshape=(200,-1))\r\n prediction = (1 / (1 + numpy.exp(-numpy.dot(numpy.transpose(sentence_vec), beta))))\r\n prediction = 1 if prediction>0.5 else 0\r\n if int(row[1]) == prediction:\r\n prediction_right += 1\r\n \r\n return prediction_right / len(dataset)","def get_score(predictions_df: pd.DataFrame,\n real_df: pd.DataFrame,\n k: int = 5) -> float:\n y_pred = predictions_df.genres.apply(lambda x: x.split(\" \"))\n y_real = real_df.genres.apply(lambda x: x.split(\" \"))\n return mapk(y_real, y_pred, k)","def get_pretrained_vectors(vocab, vec_fname, normed=True, trim=False):\n # load in vectors in vocab\n token2vec = {}\n if trim:\n trim_fname = '/'.join(vec_fname.split('/')[:-1]+['trimmed_'+vec_fname.split('/')[-1]])\n trim_f = open(trim_fname, 'w')\n for line in open(vec_fname, 'r'):\n if line: # sometime they're empty\n split = line.split()\n token, vec = split[0], np.array([float(s) for s in split[1:]], dtype=np.float32)\n if token in vocab.vocabset:\n token2vec[token] = vec\n if trim:\n trim_f.write(line)\n if trim:\n trim_f.close()\n\n # put them in a matrix\n d = token2vec.values()[0].shape[0]\n e = npr.normal(size=(vocab.v, d))\n for token, vec in token2vec.items():\n e[vocab.idx(token), :] = vec/np.linalg.norm(vec) if normed else vec\n print \"Pretrained coverage: {0}/{1} = {2:2.2f}%\".format(\n len(token2vec), vocab.v, float(len(token2vec))/vocab.v * 100.)\n return e","def predict(self, X):\r\n return 1 if self.predict_prob(X) > 0.5 else 0","def ap(gt, pred, k):\n if len(pred) > k:\n pred = pred[:k]\n\n score = 0.0\n num_hits = 0.0\n\n for i, p in enumerate(pred):\n if p in gt:\n num_hits += 1.0\n score += num_hits / (i + 1.0)\n\n if not gt:\n return 0.\n\n return score / min(len(gt), k)","def test_k_rank_approximate(corpus):\n return","def doPredict(self, data: StockData) -> float:\r\n pass","def predict_proba(self, X):\n\n preds = self.get_predictions(X)\n\n n_classifiers, n_instances = preds.shape\n\n global_votes = np.zeros((n_instances, self.n_classes), dtype=np.float32)\n\n for i in range(n_instances):\n for j in range(n_classifiers):\n global_votes[i, preds[j, i]] += self.voting_weights[j, preds[j, i]]\n\n _sum = np.sum(global_votes, axis=1)\n\n return global_votes / _sum[:, None]","def clf2_predict(self):\n self._pred_clf_2 = self._clf2.predict(self._vectorized_input)[0]","def predict_sentences(self, sents):\n tkw=self.tkw\n sents_attr=[]\n sent_samples={\n \"word_inputs\":[],\n \"predicate_inputs\":[],\n \"postags_inputs\":[]\n }\n print('prepare data')\n for sid,sent in enumerate(sents):\n if sid % (int(np.ceil(len(sents)/100))) == 0:\n print(sid / len(sents))\n sent_str = \" \".join(sent)\n preds = [(word.i, str(word))\n for word\n in tkw.parser(sent_str)\n if word.tag_.startswith(\"V\")]\n num_of_samples = int(np.ceil(float(len(sent)) / self.sent_maxlen) * self.sent_maxlen)\n pred_list=[]\n for ind, pred in preds:\n cur_sample=self.encode_inputs([self.create_sample(sent, ind)])\n for name in [\"word_inputs\", \"predicate_inputs\", \"postags_inputs\"]:\n sent_samples[name].append(cur_sample[name])\n pred_list.append((ind, pred))\n sents_attr.append((num_of_samples,pred_list,len(sent)))\n for key in sent_samples:\n sent_samples[key]=np.concatenate(sent_samples[key],axis=0)\n print('predict data')\n X = sent_samples\n Y=self.model.predict(X)\n # print(Y[0])\n # print(Y[2])\n res=[]\n p=0\n for attr in sents_attr:\n num_of_samples,pred_list,sent_len=attr\n sample_len=num_of_samples//self.sent_maxlen\n ret=[]\n for pid,(ind, pred) in enumerate(pred_list):\n ret.append(((ind, pred),\n [(self.consolidate_label(label), float(prob))\n for (label, prob) in\n self.transform_output_probs(Y[p+pid*sample_len:p+(pid+1)*sample_len], \n get_prob = True).reshape(num_of_samples,\n 2)[:sent_len]]))\n res.append(ret)\n p+=len(pred_list)*sample_len\n return res","def predict(self, X, k=1, norm2=True):\n if norm2:\n dists = self.compute_norm2_distances_no_loop(X)\n else:\n dists = self.compute_norm1_distances_one_loop(X)\n return self.predict_labels(dists, k=k)","def mapk(y_true, y_pred, k):\n \n # initialize empty list for apk values \n apk_values = []\n \n # loop over all samples\n for i in range(len(y_true)):\n # store apk values for every sample\n apk_values.append(\n apk(y_true[i], y_pred[i], k=k)\n )\n \n # return mean of apk values list\n return sum(apk_values) / len(apk_values)","def get_predictive(self, x, k):\n phi_x = self.base(x)\n phi_z = self.base(self.prev_tasks_tensors[k])\n k_xx = phi_x @ phi_x.T\n k_xz = phi_x @ phi_z.T\n k_zz = phi_z @ phi_z.T\n k_zz_ = torch.inverse(k_zz)\n mu_u = self.prev_tasks_distr[k].mean\n cov_u = self.prev_tasks_distr[k].covariance_matrix\n\n mu = phi_x @ phi_z.T @ k_zz_ @ mu_u\n sigma = k_xx + k_xz @ k_zz_ @ (cov_u - k_zz) @ k_zz_ @ k_xz.T\n sigma *= torch.eye(sigma.shape[0]).to(self.device) #we are interested only \n #in diagonal part for inference\n return MultivariateNormal(loc=mu, covariance_matrix=sigma)"],"string":"[\n \"def predict_k(\\n self,\\n m_tokens: np.ndarray,\\n dim: int,\\n normalize: bool = False,\\n nearest_int: bool = True,\\n ) -> np.ndarray:\\n\\n # allow scalar\\n return_scalar = np.isscalar(m_tokens)\\n m_tokens = np.array(m_tokens).reshape(-1)\\n\\n # retrieve fitting parameters\\n M_z, N_z = self.params\\n\\n # scale down to normalized log formula\\n x = m_tokens / M_z\\n k_frac = self.formula(x, dim)\\n\\n # normalize, or don't\\n if normalize:\\n # predicted counts as a proportion of predicted types\\n y_types_omitted = k_frac[:, 0]\\n y_types_selected = 1 - y_types_omitted\\n y_types_selected = y_types_selected[:, np.newaxis]\\n k = k_frac / y_types_selected\\n else:\\n # predicted counts\\n k = N_z * k_frac\\n\\n # roundoff\\n if nearest_int:\\n k = np.round(k)\\n\\n # allow scalar\\n if return_scalar:\\n assert len(k) == 1\\n k = k.squeeze()\\n\\n # return n-legomena counts\\n return k\",\n \"def predictability(self):\\n temp = self.probs\\n for n in range(10):\\n temp = temp.dot(temp)\\n final = temp[0,:]\\n #Let's assume that all words have unique initial letters\\n probs = map(len, self.words)\\n probs = array(probs)\\n probs = (probs + self.probs.max(1)-1)/probs\\n return sum(final*probs)\",\n \"def test_predict_func(self):\\n ve = VariogramEstimator(n_lags=15, normalize=False).fit(self.c, self.v)\\n v = ve.variogram\\n\\n x = np.linspace(0, ve.range_, 100)\\n\\n assert_array_almost_equal(ve.predict(x), v.transform(x), decimal=6)\",\n \"def unigram(tokens):\\n model = collections.defaultdict(lambda: 0.01)\\n for token in tokens:\\n try:\\n model[token] += 1\\n except KeyError:\\n model[token] = 1\\n continue\\n for word in model:\\n model[word] = model[word]/float(sum(model.values()))\\n return model\",\n \"def predict(self, kf):\\n self.mean, self.covariance = kf.predict(self.mean, self.covariance)\",\n \"def predict_tokens(self, tokens):\\n return\",\n \"def unigram_model(list_of_words, unigram_count, N=count_token()):\\n d = pd.read_csv(unigram_count)\\n proba_dict = {list_of_words[i]: (d[el].values[0] / float(N)) if el in d.columns.values else 0.0 for i, el in enumerate(list_of_words) }\\n return proba_dict\",\n \"def predict(self, X_test):\\n if self.basis_func is not None:\\n X_transformed = self.basis_func(X_test)\\n else:\\n X_transformed = X_test\\n\\n # Marginalise predictions over hyperparameters\\n mu = np.zeros([len(self.hypers), X_transformed.shape[0]])\\n var = np.zeros([len(self.hypers), X_transformed.shape[0]])\\n\\n for i, h in enumerate(self.hypers):\\n mu[i] = np.dot(self.models[i][0].T, X_transformed.T)\\n var[i] = 1. / h[1] + np.diag(np.dot(np.dot(X_transformed, self.models[i][1]), X_transformed.T))\\n\\n m = mu.mean(axis=0)\\n v = var.mean(axis=0)\\n # Clip negative variances and set them to the smallest\\n # positive float value\\n if v.shape[0] == 1:\\n v = np.clip(v, np.finfo(v.dtype).eps, np.inf)\\n else:\\n v = np.clip(v, np.finfo(v.dtype).eps, np.inf)\\n v[np.where((v < np.finfo(v.dtype).eps) & (v > -np.finfo(v.dtype).eps))] = 0\\n\\n return m, v\",\n \"def predict(self, X):\\n\\n X = np.asarray(X)\\n if X.ndim == 1:\\n# X = np.asarray([X]).T\\n # Data has a single feature\\n X = X.reshape(-1, 1)\\n\\n # Indexes of support vectors\\n ind_sv = self.ind_sv()\\n\\n # Compute kernels\\n if self.kernel == 'rbf':\\n Din = dist.cdist(self.X[ind_sv, :], X, 'sqeuclidean')\\n Kin = np.exp(-self.gamma_in * Din)\\n else: # Linear kernel\\n Kin = np.dot(self.X[ind_sv, :], self.D.dot(X.T))\\n\\n Dout = dist.pdist(np.asarray([self.probs]).T, 'sqeuclidean')\\n Kout = np.exp(-self.gamma_out * dist.squareform(Dout)) \\\\\\n if self.gamma_out != np.inf else np.eye(np.size(self.probs))\\n\\n pred = np.dot(np.dot(Kout, self.coefs[:, ind_sv]), Kin).T\\n pred += self.intercept\\n return pred.T\",\n \"def predict(self, X_test, V = None):\\n\\t\\tif X_test.ndim == 1:\\n\\t\\t\\tX_test = X_test[:,np.newaxis]\\n\\t\\tif X_test.shape[1] == self.D:\\n\\t\\t\\tX_test = np.concatenate((np.ones((X_test.shape[0],1)), X_test), axis = 1) #adding dummy variable for the bias\\n\\t\\tif V is None:\\n\\t\\t\\tV = self.V\\n\\t\\tres = np.matmul(X_test,V) #(N,K)\\n\\t\\tres = np.exp(res) + 1e-5 #(N,K)\\n\\t\\tres = np.divide(res.T, np.sum(res, axis = 1)).T #(N,K) normalizing\\n\\n\\t\\treturn res\",\n \"def predict(self, x, k, MC_samples=20):\\n distr = self.get_predictive(x.to(self.device), k)\\n\\n def likelihood(y): #currently hardcoded for binary classification\\n return 1./ (1 + torch.exp(-y))\\n\\n predicted = 0\\n for i in range(MC_samples):\\n sample = distr.sample()\\n predicted += likelihood(sample)\\n predicted /= MC_samples\\n return predicted\",\n \"def predict(self):\\n RV = np.zeros((self.N,self.P))\\n for term_i in range(self.n_terms):\\n RV+=np.dot(self.Fstar()[term_i],np.dot(self.B()[term_i],self.Astar()[term_i]))\\n return RV\",\n \"def predict_for_items(self, norm=True):\\n pred = self.item_vectors.dot(self.item_vectors.T)\\n if norm:\\n norms = np.array([np.sqrt(np.diagonal(pred))])\\n pred = pred / norms / norms.T\\n return pred\",\n \"def score(self, sentence):\\n # TODO your code here\\n\\n # initialize count with trained data\\n unigram_count = self.count.copy()\\n N = self.total\\n\\n # make a new key for UNK, add-one later\\n for token in sentence:\\n if token not in unigram_count:\\n unigram_count[token] = 0\\n\\n # calcutate lopP(<s>) + logP(w1) + logP(w2) + ...\\n score = 0.0 # P(<s>) = 1\\n V = len(unigram_count) # the number of vocab including UNK\\n for word in sentence:\\n prob = float((unigram_count[word] + 1) / (N + V)) # c(w) + 1 / N + V\\n score += math.log(prob)\\n\\n return score\",\n \"def get_average_vec(tokens_list, vector, generate_missing=False, k=300):\\r\\n if len(tokens_list)<1:\\r\\n return np.zeros(k)\\r\\n \\r\\n if generate_missing:\\r\\n vectorized = [vector[word] if word in vector else np.random.rand(k) for word in tokens_list]\\r\\n else:\\r\\n vectorized = [vector[word] if word in vector else np.zeros(k) for word in tokens_list]\\r\\n \\r\\n length = len(vectorized)\\r\\n summed = np.sum(vectorized, axis=0)\\r\\n averaged = np.divide(summed, length)\\r\\n return averaged\",\n \"def precision(gt, pred, k):\\n k = min(len(pred), k)\\n den = min(len(gt), k)\\n return sum([int(pred[i] in gt) for i in range(k)]) / den\",\n \"def predict(self, X):\\n if X.ndim==1: X = X[None,:]\\n m, v = self.model.predict(X)\\n v = np.clip(v, 1e-10, np.inf)\\n return m, np.sqrt(v)\",\n \"def normalize(knot_vector, decimals=18):\\n try:\\n if knot_vector is None or len(knot_vector) == 0:\\n raise ValueError(\\\"Input knot vector cannot be empty\\\")\\n except TypeError as e:\\n print(\\\"An error occurred: {}\\\".format(e.args[-1]))\\n raise TypeError(\\\"Knot vector must be a list or tuple\\\")\\n except Exception:\\n raise\\n\\n first_knot = float(knot_vector[0])\\n last_knot = float(knot_vector[-1])\\n denominator = last_knot - first_knot\\n\\n knot_vector_out = [float((\\\"{:.\\\" + str(decimals) + \\\"f}\\\").format((float(kv) - first_knot) / denominator))\\n for kv in knot_vector]\\n\\n return knot_vector_out\",\n \"def predict(self, reviews):\\n self.vect_rev = self.vectorizer.transform(reviews)\\n self.dmat = xgb.DMatrix(self.vect_rev)\\n self.probs = self.bst.predict(self.dmat)\\n\\n # Get tough on reviews by requiring 0.6 probability threshold\\n self.preds = 1 * (self.probs > 0.6)\",\n \"def predict(self, text):\\r\\n vectorizer = CountVectorizer(ngram_range=(1, 2), lowercase=True, vocabulary=self.voc)\\r\\n vector = vectorizer.fit_transform([text])\\r\\n return self.model.predict(vector)[0]\",\n \"def predict_for_customers(self,):\\n return self.user_vectors.dot(self.item_vectors.T)\",\n \"def predict(self, X):\\r\\n from math import log\\r\\n result = []\\r\\n choise_dict = dict()\\r\\n for sentence in X:\\r\\n for key in self.ver_cls.keys():\\r\\n choise_dict[key] = log(self.ver_cls[key])\\r\\n for word in sentence.split():\\r\\n if word in self.ver_dict.keys():\\r\\n for key in self.ver_cls.keys():\\r\\n choise_dict[key] += log(self.ver_dict[word][key])\\r\\n v = list(choise_dict.values())\\r\\n k = list(choise_dict.keys())\\r\\n result.append(k[v.index(max(v))])\\r\\n return result\\r\\n pass\",\n \"def predict(self, sentence, smoothing=None):\\n words = sentence.split()\\n words.append(\\\"STOP\\\")\\n probability = 1.0\\n\\n words = [self.START_SYMBOL, self.START_SYMBOL] + words\\n ###################\\n # Compute the probability of a sentence under the trigram model\\n # p(x1,..,xn)= \\\\prod {q(x_i| x_{i-2}x_{i-1}}\\n for i in xrange(len(words)-2):\\n probability *= self.trigram_prob(words[i], words[i+1], words[i+2])\\n\\n return probability\",\n \"def estimate_probability(word, previous_n_gram, \\r\\n n_gram_counts, n_plus1_gram_counts, vocabulary_size, k=1.0):\\r\\n # Note : 1 . Here we are actually not considering the end token or start token as a part of a vocabulary.\\r\\n # 2 . Although the literature says we need to prepend the n-1 SOS tokens but in reality we are prepending n SOS tokens\\r\\n \\r\\n # convert list to tuple to use it as a dictionary key\\r\\n previous_n_gram = tuple(previous_n_gram)\\r\\n\\r\\n previous_n_gram_count = n_gram_counts.get(previous_n_gram, 0)\\r\\n \\r\\n\\r\\n denominator = float(previous_n_gram_count + (k*vocabulary_size))\\r\\n\\r\\n n_plus1_gram = previous_n_gram + (word,)\\r\\n \\r\\n\\r\\n n_plus1_gram_count = n_plus1_gram_counts.get(n_plus1_gram, 0)\\r\\n \\r\\n\\r\\n numerator = float(n_plus1_gram_count + k)\\r\\n\\r\\n probability = float(numerator/denominator)\\r\\n \\r\\n \\r\\n return probability\",\n \"def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\\n\\n # allow scalar\\n return_scalar = np.isscalar(m_tokens)\\n m_tokens = np.array(m_tokens).reshape(-1)\\n\\n # sum over legomena coefficients k\\n x = m_tokens / self.M\\n exponents = range(len(self.k))\\n terms = np.array([np.power(1 - x, n) for n in exponents])\\n k_0 = np.dot(self.k, terms)\\n n_types = self.N - k_0\\n\\n # roundoff\\n if nearest_int:\\n n_types = np.round(n_types)\\n\\n # allow scalar\\n if return_scalar:\\n assert len(n_types) == 1\\n n_types = n_types[0]\\n\\n # return\\n return n_types\",\n \"def precision_at_k(model, ratings, k, relevance_func):\\n predictions = model.predict_all()\\n np.place(predictions, ratings == 0, -np.Inf)\\n recommended = predictions.argsort(1)[::, :-k-1:-1]\\n \\n relevance_per_user = np.take_along_axis(ratings, recommended, 1)\\n max_relevance_per_user = (relevance_per_user > 0).sum(1)\\n relevance_per_user = relevance_func(relevance_per_user).sum(1)\\n\\n precision = np.divide(relevance_per_user, max_relevance_per_user)\\n \\n return np.nanmean(precision)\",\n \"def vectorize_sentence(sentence, model):\\n final_vec = np.zeros(300, )\\n count = 0\\n for word in sentence:\\n count += 1\\n dummy_vec = np.zeros(300, )\\n try:\\n temp_vec = get_vector(word, model)\\n final_vec += temp_vec\\n except:\\n final_vec += dummy_vec\\n return final_vec / count\",\n \"def predict(x):\\n file_train = open('trains.pkl', \\\"rb\\\")\\n train = pkl.load(file_train)\\n y = []\\n k = 5\\n x_train = train[0]\\n y_train = train[1]\\n for q in range(100):\\n distance = []\\n for i in range(800):\\n distance.append(np.linalg.norm(x[q] - x_train[i]))\\n\\n # distance.append(np.sqrt(sum((x[q] - x_train[i]) ** 2)))\\n # u = (x[0] - x_train) ** 2\\n # print(distance)\\n # distance = np.sqrt([sum(b) for b in u])\\n # print(distance)\\n minarg = np.argsort(distance)\\n i = np.array(np.zeros(10))\\n j = 0\\n while k not in i:\\n i[y_train[minarg[j]]] += 1\\n j += 1\\n y.append(np.argmax(i))\\n return y\",\n \"def getSigma(self, pred_vects):\\n sigma = tf.matmul(pred_vects, pred_vects, transpose_a=True)\\n # Divide by m to normalise sigma invariant of number of input vectors\\n sigma = sigma / pred_vects.shape[-2]\\n # Add epsilon to sigma to avoid zeros\\n sigma = tf.add(sigma, tf.eye(sigma.shape[-1], batch_shape=sigma.shape[:0])*\\\\\\n tf.keras.backend.epsilon())\\n return sigma\",\n \"def predict(self, key):\\n return self.counts.get(key, 1.0)\",\n \"def post_processing_4_train(clf, X, indexes, k=5):\\n\\n predictions = []\\n all_scores = []\\n for idx, line_input in tqdm(enumerate(X)):\\n # line_input = np.asarray(line_input,np.str)\\n scores = clf.predict(line_input)\\n scores = np.asarray(np.reshape(scores, newshape=(-1,)))\\n orders = np.argsort(scores, axis=-1)[::-1]\\n scores = scores[orders]\\n sents_indexes = np.asarray(indexes[idx])\\n predictions.append(sents_indexes[orders][:k])\\n all_scores.append(scores[:5])\\n return predictions, all_scores\",\n \"def precision_at_k(r, k):\\n assert k >= 1\\n r = np.asarray(r)[:k] != 0\\n if r.size != k:\\n raise ValueError('Relevance score length < k')\\n return np.mean(r)\",\n \"def prediction(self,x):\\n if self.x is None:\\n mean = np.zeros(len(x))\\n cov = self.k(x,x)\\n else:\\n kVec = self.k(self.x,x)\\n mean = np.dot(kVec.T,self.scaled_data)\\n schurFactor = la.solve(self.Kchol,kVec)\\n cov = self.k(x,x) - np.dot(schurFactor.T,schurFactor)\\n return mean,cov\",\n \"def predict(self, X):\",\n \"def predict(self, X):\",\n \"def _postprocess(self, preds):\\n ntok = preds.pop(\\\"ntok\\\")\\n ids = preds.pop(\\\"input_ids\\\")[:ntok]\\n preds[\\\"tokens\\\"] = self._detokenize(ids)\\n\\n # Decode predicted top-k tokens.\\n # token_topk_preds will be a List[List[(word, prob)]]\\n # Initialize prediction for 0th token as N/A.\\n token_topk_preds = [[(\\\"N/A\\\", 1.)]]\\n pred_ids = preds.pop(\\\"top_k_indices\\\")[:ntok] # <int>[num_tokens, k]\\n pred_probs = preds.pop(\\\"top_k_probs\\\")[:ntok] # <float32>[num_tokens, k]\\n for token_pred_ids, token_pred_probs in zip(pred_ids, pred_probs):\\n token_pred_words = self._detokenize(token_pred_ids)\\n token_topk_preds.append(list(zip(token_pred_words, token_pred_probs)))\\n preds[\\\"pred_tokens\\\"] = token_topk_preds\\n\\n # Process attention.\\n for key in preds:\\n if not re.match(r\\\"layer_(\\\\d+)/attention\\\", key):\\n continue\\n # Select only real tokens, since most of this matrix is padding.\\n # <float32>[num_heads, max_seq_length, max_seq_length]\\n # -> <float32>[num_heads, num_tokens, num_tokens]\\n preds[key] = preds[key][:, :ntok, :ntok].transpose((0, 2, 1))\\n # Make a copy of this array to avoid memory leaks, since NumPy otherwise\\n # keeps a pointer around that prevents the source array from being GCed.\\n preds[key] = preds[key].copy()\\n\\n return preds\",\n \"def predict(self, X):\\n words = X.split()\\n chance = []\\n for cur_label in self.model[\\\"labels\\\"]:\\n probability = self.model[\\\"labels\\\"][cur_label][\\\"probability\\\"]\\n total_grade = math.log(probability, math.e)\\n for word in words:\\n word_dict = self.model[\\\"words\\\"].get(word, None)\\n if word_dict:\\n total_grade += math.log(word_dict[cur_label], math.e)\\n chance.append((total_grade, cur_label))\\n _, prediction = max(chance)\\n return prediction\",\n \"def predict(self, kf):\\n self.mean, self.covariance = kf.predict(self.mean, self.covariance)\\n self.age += 1\\n self.time_since_update += 1\",\n \"def predict(self, kf):\\n self.mean, self.covariance = kf.predict(self.mean, self.covariance)\\n self.age += 1\\n self.time_since_update += 1\",\n \"def predict(self, X, k=1):\\n dists = self.compute_distances(X)\\n return self.predict_labels(dists, k=k)\",\n \"def precision_at_k(r, k):\\n assert k >= 1\\n r = np.asarray(r)[:k] != 0\\n if r.size != k:\\n raise ValueError('Relevance score length < k')\\n return np.mean(r)\",\n \"def apk(actual, predicted, k=10):\\n if len(predicted)>k:\\n predicted = predicted[:k]\\n\\n score = 0.0\\n num_hits = 0.0\\n\\n for i,p in enumerate(predicted):\\n if p in actual and p not in predicted[:i]:\\n num_hits += 1.0\\n score += num_hits / (i+1.0)\\n\\n if not actual:\\n return 0.0\\n\\n return score / min(len(actual), k)\",\n \"def apk(actual, predicted, k=3):\\n\\n actual = set(actual)\\n predicted = list(predicted)\\n\\n if len(predicted) > k:\\n predicted = predicted[:k]\\n\\n score = 0.0\\n num_hits = 0.0\\n\\n for i, p in enumerate(predicted):\\n if p in actual and p not in set(predicted[:i]):\\n num_hits += 1.0\\n score += num_hits / (i + 1.0)\\n\\n if not actual:\\n return 0.0\\n\\n return score / min(len(actual), k)\",\n \"def mapk(actual, predicted, k):\\n return round(np.mean([apk(a,p,k) for a,p in zip(actual, predicted)]), 4) * 100\",\n \"def apk(actual, predicted, k=10):\\n if len(predicted) > k:\\n predicted = predicted[:k]\\n\\n score = 0.0\\n num_hits = 0.0\\n\\n for i, p in enumerate(predicted):\\n if p in actual and p not in predicted[:i]:\\n num_hits += 1.0\\n score += num_hits / (i + 1.0)\\n\\n # if not actual:\\n # return 0.0\\n\\n return score / min(len(actual), k)\",\n \"def predict(self):\\n for track in self.tracks:\\n track.predict(self.kf)\\n #track.du_doan(self.kf_test)\",\n \"def predict(self, X):\\n predictions = [c.predict(X) for c in self.classifiers]\\n votes = np.zeros((len(X),self.label_count), dtype='i8')\\n for row in xrange(len(X)):\\n for model in xrange(self.model_count):\\n for label in xrange(len(self.label_sets[model])):\\n votes[row,self.label_sets[model][label]] += predictions[model][row][label]\\n\\n voters = np.zeros(self.label_count, dtype='i8')\\n for label_set in self.label_sets:\\n voters[label_set] += 1\\n\\n for row in xrange(len(X)):\\n for label in xrange(self.label_count):\\n votes[row, label] = int(float(votes[row, label]) / float(voters[label]) > 0.5)\\n\\n return votes\",\n \"def fit_predict(self, X):\\n MyKMedoids.fit(self, X)\\n return MyKMedoids.predict(self, X)\\n pass\",\n \"def predict(self):\\n for track in self.tracks:\\n track.predict(self.kf)\",\n \"def predict(self):\\n for track in self.tracks:\\n track.predict(self.kf)\",\n \"def predict(self):\\n for track in self.tracks:\\n track.predict(self.kf)\",\n \"def predict(self):\\n input_item_vector = self.item_embeddings(self.input_item)\\n input_user_vector = self.user_embeddings(self.input_user)\\n input_item_vector_reshaped = tf.keras.layers.Reshape(\\n (self.item_dim, 1))(input_item_vector)\\n input_user_vector_reshaped = tf.keras.layers.Reshape(\\n (self.user_dim, 1))(input_user_vector)\\n\\n dot_product = tf.keras.layers.dot(\\n [input_item_vector_reshaped, input_user_vector_reshaped], axes=2)\\n predicted_rating = tf.keras.layers.Dense(\\n 1, activation='linear')(dot_product)\\n return predicted_rating\",\n \"def gkern(mx, my, kernlen):\\n x, y = np.mgrid[0:kernlen:1, 0:kernlen:1]\\n pos = np.empty(x.shape + (2,))\\n pos[:, :, 0] = x; pos[:, :, 1] = y\\n rv = multivariate_normal([mx*kernlen, my*kernlen], [[3.0, 0.0], [0.0, 3.0]])\\n array = rv.pdf(pos).reshape([kernlen*kernlen])\\n array = array/max(array)\\n\\n return array\",\n \"def metric_precision_at_k(pred: list, echt: list, k: int):\\n echt_keys = [key for key, _ in echt[:k]]\\n return sum([1.0 for key, _ in pred[:k] if key in echt_keys]) / float(k)\",\n \"def predict(self, user: torch.tensor, k: int):\\n pass\",\n \"def computesvd(train, K):\\n mean = global_mean(train)\\n train = standardize(train, mean)\\n std = compute_std(train)\\n train = div_std(train)\\n\\n U, s, Vt = sp.linalg.svds(train, k=K)\\n\\n dim = (len(s), len(s))\\n S = np.zeros(dim)\\n for i in range(len(s)):\\n S[i, i] = mt.sqrt(s[i])\\n\\n U = sp.lil_matrix(U, dtype=np.float32) # dim(M,k)\\n S = sp.lil_matrix(S, dtype=np.float32) # dim(k,k)\\n Vt = sp.lil_matrix(Vt, dtype=np.float32) # dim(k,N)\\n\\n user_features = S.dot(Vt)\\n item_features = np.transpose(U.dot(S))\\n\\n return user_features, item_features, mean, std\",\n \"def apk(actual, predicted, k):\\n\\n if len(predicted)>k:\\n predicted = predicted[:k]\\n \\n score = 0.0\\n num_hits = 0.0\\n\\n for i,p in enumerate(predicted):\\n if p in actual and p not in predicted[:i]:\\n num_hits += 1.0\\n score += num_hits / (i+1.0)\\n\\n if not actual:\\n return 0.0\\n\\n return round(score / min(len(actual), k), 5)\",\n \"def normalize(self):\\n for key in self.corpus.keys():\\n sum_count = 0\\n words = []\\n counts = []\\n for k, v in self.corpus[key].items():\\n sum_count += v\\n words.append(k)\\n counts.append(v)\\n prob = [float(count)/sum_count for count in counts]\\n\\n self.corpus[key] = [words, prob]\",\n \"def avg_sentence_vector(words, model, num_features, index2word_set):\\n featureVec = np.zeros((num_features,), dtype=\\\"float32\\\")\\n nwords = 0\\n\\n for word in words:\\n if word in index2word_set:\\n nwords = nwords+1\\n featureVec = np.add(featureVec, model.wv[word])\\n # featureVec = np.add(featureVec, model.wv.__getitem__(word))\\n\\n if nwords>0:\\n featureVec = np.divide(featureVec, nwords)\\n return featureVec\",\n \"def estimate_probabilities(previous_n_gram, n_gram_counts, n_plus1_gram_counts, vocabulary, k=1.0):\\r\\n \\r\\n previous_n_gram = tuple(previous_n_gram)\\r\\n \\r\\n # add <e> <unk> to the vocabulary\\r\\n # <s> is not needed since it should not appear as the next word\\r\\n vocabulary = vocabulary + [\\\"<e>\\\", \\\"<unk>\\\"]\\r\\n vocabulary_size = len(vocabulary)\\r\\n \\r\\n probabilities = {}\\r\\n for word in vocabulary:\\r\\n probability = estimate_probability(word, previous_n_gram, \\r\\n n_gram_counts, n_plus1_gram_counts, \\r\\n vocabulary_size, k=k)\\r\\n probabilities[word] = probability\\r\\n\\r\\n return probabilities\",\n \"def _predict_doc(self, x, flag):\\n\\n if flag == 1:\\n denom = self.X.num_positive()\\n else:\\n denom = self.X.num_negative()\\n denom += self.X.vocab_size()\\n\\n # multiply word probabilities for all words in x\\n words = tokenize(x)\\n # prob = 1.0\\n # for word in words:\\n # wi = self._doc_count_for_word(word, flag=flag)\\n # # utilize the Laplace Smooth\\n # prob *= ((float(wi)+1.0) / (float(denom)+2.0))\\n\\n prob = math.log(self.X.priors[str(flag)])\\n for word in words:\\n wi = self._doc_count_for_word(word, flag=flag)\\n # utilize the Laplace Smooth\\n prob += math.log((float(wi)+1.0) / (float(denom)+2.0))\\n\\n # prob *= math.log(self.X.priors[str(flag)])\\n\\n return prob\",\n \"def clf1_predict(self):\\n self._pred_clf_1 = self._clf1.predict(self._vectorized_input)[0]\",\n \"def predict(self, X):\\n\\n stuff = self._vectorizer.transform(X)\\n result = self._classifier.predict(stuff)\\n return result\\n pass\",\n \"def prediction(self, v, imu_meas):\\n # YOUR CODE HERE\\n pass\",\n \"def apk(actual, predicted, k=10):\\n if len(predicted) > k:\\n predicted = predicted[:k]\\n score = 0.0\\n num_hits = 0.0\\n\\n for i, p in enumerate(predicted):\\n if p in actual and p not in predicted[:i]:\\n num_hits += 1.0\\n score += num_hits / (i + 1.0)\\n\\n return score / min(len(actual), k)\",\n \"def predict(self, x):\\n pred_labels = np.zeros((x.shape[0], 10))\\n\\n N = len(self.NET)\\n for i in range(N):\\n\\n inputs = self.apply_dct_permutation(x.copy(), self.permutation[i])\\n pred_labels += self.NET[i].model.predict(inputs)\\n\\n return pred_labels\",\n \"def predict(self, \\n\\t\\t\\t\\tvdf, \\n\\t\\t\\t\\tname: str = \\\"\\\"):\\n\\t\\tcheck_types([\\n\\t\\t\\t(\\\"name\\\", name, [str], False)],\\n\\t\\t\\tvdf = [\\\"vdf\\\", vdf])\\n\\t\\tname = \\\"KMeans_\\\" + ''.join(ch for ch in self.name if ch.isalnum()) if not (name) else name\\n\\t\\treturn (vdf.eval(name, self.deploySQL()))\",\n \"def predict(term):\\n if len(accept_doc) == 0 and len(reject_doc) == 0:\\n return 0.5\\n # Use spaCy's .similarity() method to compare the term to the\\n # accepted and rejected Doc\\n if len(accept_doc) and accept_doc.vector_norm != 0.0:\\n accept_score = max(term.similarity(accept_doc), 0.0)\\n else:\\n accept_score = 0.0\\n if len(reject_doc) and reject_doc.vector_norm != 0:\\n reject_score = max(term.similarity(reject_doc), 0.0)\\n else:\\n reject_score = 0.0\\n score = accept_score / (accept_score + reject_score + 0.2)\\n return max(score, 0.0)\",\n \"def predict(self, review):\\n raise NotImplementedError\",\n \"def _minimal_predict(Classifier, vector, threshold):\\n return Classifier.predict(array([vector.tolist()]), threshold)\",\n \"def score(self, sentence):\\n score = 0.0\\n V = len(self.f1) # vocabulary size\\n for token in sentence:\\n if token in self.f1: score += self.f1[token]\\n else: score -= math.log10(self.total + V)\\t\\t # OOV \\n return score\",\n \"def score(self, predictions):\\n return 0.\",\n \"def predict(self, X):\\n\\t\\tif X.ndim ==1:\\n\\t\\t\\tX = X[:,np.newaxis]\\n\\t\\t\\n\\t\\tpi = self.gating.predict(X) #p(z_i = k|x_i) (N,K)\\n\\n\\t\\t#indices = np.argmax(pi, axis =1)\\n\\t\\t#for i in range(pi.shape[0]):\\n\\t\\t#\\tpi[i,indices[i]] = 1.\\n\\n\\t\\tpi = np.divide(pi.T, np.sum(pi, axis = 1)).T\\n\\t\\tres = np.multiply(pi, self.experts_predictions(X))\\n\\t\\treturn np.sum(res, axis = 1)\",\n \"def MillerNormalVectors_100():\\r\\n k_100 = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])\\r\\n return np.array([k_100[0, :], k_100[1, :], k_100[2, :],\\r\\n -k_100[0, :], -k_100[1, :], -k_100[2, :]])\",\n \"def predict(self, X):\\n\\t\\tn_samples = np.size(X, 0)\\n\\t\\ty = np.hstack((np.ones((n_samples, 1)), (X-np.mean(X, 0)) \\\\\\n / np.std(X, 0))) @ self.weights\",\n \"def predict(self, X):\\n N, D = X.shape\\n\\n # init prediction array\\n prediction = np.array([-1] * N)\\n\\n # retrieve the probability of predicting fraud for each model (K models)\\n predict_proba_fraud = [-1] * self.K\\n\\n # we do the computation for all input test examples\\n for i, instance in enumerate(X):\\n sum_weight = 0\\n F_k = 0\\n\\n # for k in= {1,2.....K} do\\n k = -1\\n for model in self.models.islice(start=0, stop=self.K, reverse=True):\\n k += 1\\n clf = model.clf\\n sum_weight += model.weight\\n\\n # (1) compute the corresponding Fk(x)\\n # compute one part of Fk(y) with the weights (be careful: sum_weight may be 0)\\n F_k = (F_k * sum_weight) / sum_weight if sum_weight != 0 else 0\\n\\n # if the probability is not initialized we call the predict proba method\\n if (type(predict_proba_fraud[k]) is int and predict_proba_fraud[k] == -1) \\\\\\n or (predict_proba_fraud[k].shape[0] != self.S):\\n predict_proba_fraud[k] = clf.predict_proba(self.X_chunk)\\n\\n # if we don't have the probability of predicting fraud --> p = 0, do nothing\\n if len(predict_proba_fraud[k][i]) == 2:\\n F_k += (model.weight * predict_proba_fraud[k][i][1]) / sum_weight\\n\\n # (2) we assign Fk value to a bin j\\n t_y = instance[-1] # amount of the transaction (in the last column of the features)\\n found = False # found: if a label has been decided (deal with 2 for's break)\\n j = 0\\n eps = len(self.bins)\\n\\n # while we haven't found the bin AND no prediction has not yet been given\\n while j < eps and not found:\\n stat = self.bins[j][k]\\n\\n # find the bin i y belongs to\\n if (j / eps) <= F_k < ((j + 1) / eps):\\n # (3) apply rule (10) for this bin (What if the amount is 0 ?)\\n if t_y != 0:\\n if F_k - stat['mean'] - self.t * stat['var'] > (self.cost / t_y): # FRAUD\\n found = True\\n prediction[i] = 1\\n elif F_k + stat['mean'] + self.t * stat['var'] <= (self.cost / t_y): # NON-FRAUD\\n found = True\\n prediction[i] = 0\\n else:\\n found = True\\n prediction[i] = 0\\n\\n j = j + 1\\n\\n if found: # if we found a value we go to the next example\\n break\\n\\n # (4) if no classifier left i.e. we have consulted every classifier without having an answer\\n # --> prediction[i] is not yet given\\n if prediction[i] == -1:\\n if instance[-1] != 0 and F_k > self.cost / instance[-1]: # instance[-1] is just t(y)\\n prediction[i] = 1\\n else:\\n prediction[i] = 0\\n\\n return prediction\",\n \"def predict(self, X):\\n ...\",\n \"def predict(self, X):\\n ...\",\n \"def predict(self, X):\\n ...\",\n \"def _raw_predict(self, _Xnew, which_parts='all', full_cov=False, stop=False):\\r\\n Kx = self.kern.K(_Xnew, self.X, which_parts=which_parts).T\\r\\n # KiKx = np.dot(self.Ki, Kx)\\r\\n KiKx, _ = dpotrs(self.L, np.asfortranarray(Kx), lower=1)\\r\\n mu = np.dot(KiKx.T, self.likelihood.Y)\\r\\n if full_cov:\\r\\n Kxx = self.kern.K(_Xnew, which_parts=which_parts)\\r\\n var = Kxx - np.dot(KiKx.T, Kx)\\r\\n else:\\r\\n Kxx = self.kern.Kdiag(_Xnew, which_parts=which_parts)\\r\\n var = Kxx - np.sum(np.multiply(KiKx, Kx), 0)\\r\\n var = var[:, None]\\r\\n if stop:\\r\\n debug_this # @UndefinedVariable\\r\\n return mu, var\",\n \"def predictClusters(self, df, k):\\n self.models.fitModels(df)\\n return self.models.predict()\",\n \"def nmse(gt, pred):\\n return np.linalg.norm(gt - pred) ** 2 / np.linalg.norm(gt) ** 2\",\n \"def nmse(gt, pred):\\n return np.linalg.norm(gt - pred) ** 2 / np.linalg.norm(gt) ** 2\",\n \"def compute_scaled_predictions(raw_predictions):\\n return expit(raw_predictions)\",\n \"def predict(net, query, context, graph, tokenizer, sentence_lengths, fb_passes=1):\\n\\n # (M,2), (1,M), (1,M), (1,3)\\n o_sup, o_start, o_end, o_type = net(query, context, graph, fb_passes=fb_passes)\\n\\n # =========== GET ANSWERS\\n answer_start = o_start.argmax() #TODO make sure that these tensors are all only containing one number!\\n answer_end = o_end.argmax()\\n answer_type = o_type.argmax()\\n if answer_type == 0:\\n answer = \\\"yes\\\"\\n elif answer_type == 1:\\n answer = \\\"no\\\"\\n elif answer_type == 2 and answer_end >= answer_start:\\n answer = tokenizer.decode(graph.tokens[answer_start: answer_end + 1])\\n else:\\n answer = \\\"noanswer\\\"\\n\\n # =========== GET SUPPORTING FACTS\\n pos = 0\\n sup_fact_pairs = []\\n for para, s_lens in zip(context, sentence_lengths):\\n for j, s_len in enumerate(s_lens):\\n #score = round(sum(o_sup.argmax([pos: pos + s_len])) / s_len)\\n # take avg of token-wise scores and round to 0 or 1\\n try:\\n score = round(float(sum([x.argmax() for x in o_sup.T[pos: pos + s_len]]) / float(s_len)))\\n except ZeroDivisionError:\\n score = 0\\n if score == 1:\\n sup_fact_pairs.append([para[0], j])\\n pos += s_len\\n\\n return answer, sup_fact_pairs\",\n \"def metric_recall_at_k(pred: list, echt: list, k: int):\\n echt_keys = [key for key, _ in echt]\\n return sum([1.0 for key, _ in pred[:k] if key in echt_keys]) / len(echt)\",\n \"def predict(self, X):\\n\\n Xn = np.copy(X)\\n\\n preds = []\\n # compute distance from all points\\n for x1 in Xn:\\n dist = self._euclidian_distance(self.X_data, x1)\\n dist = np.vstack((dist, self.y)).T\\n dist = dist[dist[:, 0].argsort(axis=0)][:,-1]\\n # get a vote from top k\\n pred = sts.mode(dist[0:self.k])[0][0]\\n preds.append(pred)\\n\\n return np.array(preds)\",\n \"def predict_proba(self):\\n ...\",\n \"def accuracy_sentence_level(dataset, beta, d2v_model):\\r\\n \\r\\n prediction_right = 0\\r\\n \\r\\n for row in dataset:\\r\\n sentence_vec = numpy.reshape(d2v_model.infer_vector(row[0].split(), alpha=0.1, steps=20), newshape=(200,-1))\\r\\n prediction = (1 / (1 + numpy.exp(-numpy.dot(numpy.transpose(sentence_vec), beta))))\\r\\n prediction = 1 if prediction>0.5 else 0\\r\\n if int(row[1]) == prediction:\\r\\n prediction_right += 1\\r\\n \\r\\n return prediction_right / len(dataset)\",\n \"def get_score(predictions_df: pd.DataFrame,\\n real_df: pd.DataFrame,\\n k: int = 5) -> float:\\n y_pred = predictions_df.genres.apply(lambda x: x.split(\\\" \\\"))\\n y_real = real_df.genres.apply(lambda x: x.split(\\\" \\\"))\\n return mapk(y_real, y_pred, k)\",\n \"def get_pretrained_vectors(vocab, vec_fname, normed=True, trim=False):\\n # load in vectors in vocab\\n token2vec = {}\\n if trim:\\n trim_fname = '/'.join(vec_fname.split('/')[:-1]+['trimmed_'+vec_fname.split('/')[-1]])\\n trim_f = open(trim_fname, 'w')\\n for line in open(vec_fname, 'r'):\\n if line: # sometime they're empty\\n split = line.split()\\n token, vec = split[0], np.array([float(s) for s in split[1:]], dtype=np.float32)\\n if token in vocab.vocabset:\\n token2vec[token] = vec\\n if trim:\\n trim_f.write(line)\\n if trim:\\n trim_f.close()\\n\\n # put them in a matrix\\n d = token2vec.values()[0].shape[0]\\n e = npr.normal(size=(vocab.v, d))\\n for token, vec in token2vec.items():\\n e[vocab.idx(token), :] = vec/np.linalg.norm(vec) if normed else vec\\n print \\\"Pretrained coverage: {0}/{1} = {2:2.2f}%\\\".format(\\n len(token2vec), vocab.v, float(len(token2vec))/vocab.v * 100.)\\n return e\",\n \"def predict(self, X):\\r\\n return 1 if self.predict_prob(X) > 0.5 else 0\",\n \"def ap(gt, pred, k):\\n if len(pred) > k:\\n pred = pred[:k]\\n\\n score = 0.0\\n num_hits = 0.0\\n\\n for i, p in enumerate(pred):\\n if p in gt:\\n num_hits += 1.0\\n score += num_hits / (i + 1.0)\\n\\n if not gt:\\n return 0.\\n\\n return score / min(len(gt), k)\",\n \"def test_k_rank_approximate(corpus):\\n return\",\n \"def doPredict(self, data: StockData) -> float:\\r\\n pass\",\n \"def predict_proba(self, X):\\n\\n preds = self.get_predictions(X)\\n\\n n_classifiers, n_instances = preds.shape\\n\\n global_votes = np.zeros((n_instances, self.n_classes), dtype=np.float32)\\n\\n for i in range(n_instances):\\n for j in range(n_classifiers):\\n global_votes[i, preds[j, i]] += self.voting_weights[j, preds[j, i]]\\n\\n _sum = np.sum(global_votes, axis=1)\\n\\n return global_votes / _sum[:, None]\",\n \"def clf2_predict(self):\\n self._pred_clf_2 = self._clf2.predict(self._vectorized_input)[0]\",\n \"def predict_sentences(self, sents):\\n tkw=self.tkw\\n sents_attr=[]\\n sent_samples={\\n \\\"word_inputs\\\":[],\\n \\\"predicate_inputs\\\":[],\\n \\\"postags_inputs\\\":[]\\n }\\n print('prepare data')\\n for sid,sent in enumerate(sents):\\n if sid % (int(np.ceil(len(sents)/100))) == 0:\\n print(sid / len(sents))\\n sent_str = \\\" \\\".join(sent)\\n preds = [(word.i, str(word))\\n for word\\n in tkw.parser(sent_str)\\n if word.tag_.startswith(\\\"V\\\")]\\n num_of_samples = int(np.ceil(float(len(sent)) / self.sent_maxlen) * self.sent_maxlen)\\n pred_list=[]\\n for ind, pred in preds:\\n cur_sample=self.encode_inputs([self.create_sample(sent, ind)])\\n for name in [\\\"word_inputs\\\", \\\"predicate_inputs\\\", \\\"postags_inputs\\\"]:\\n sent_samples[name].append(cur_sample[name])\\n pred_list.append((ind, pred))\\n sents_attr.append((num_of_samples,pred_list,len(sent)))\\n for key in sent_samples:\\n sent_samples[key]=np.concatenate(sent_samples[key],axis=0)\\n print('predict data')\\n X = sent_samples\\n Y=self.model.predict(X)\\n # print(Y[0])\\n # print(Y[2])\\n res=[]\\n p=0\\n for attr in sents_attr:\\n num_of_samples,pred_list,sent_len=attr\\n sample_len=num_of_samples//self.sent_maxlen\\n ret=[]\\n for pid,(ind, pred) in enumerate(pred_list):\\n ret.append(((ind, pred),\\n [(self.consolidate_label(label), float(prob))\\n for (label, prob) in\\n self.transform_output_probs(Y[p+pid*sample_len:p+(pid+1)*sample_len], \\n get_prob = True).reshape(num_of_samples,\\n 2)[:sent_len]]))\\n res.append(ret)\\n p+=len(pred_list)*sample_len\\n return res\",\n \"def predict(self, X, k=1, norm2=True):\\n if norm2:\\n dists = self.compute_norm2_distances_no_loop(X)\\n else:\\n dists = self.compute_norm1_distances_one_loop(X)\\n return self.predict_labels(dists, k=k)\",\n \"def mapk(y_true, y_pred, k):\\n \\n # initialize empty list for apk values \\n apk_values = []\\n \\n # loop over all samples\\n for i in range(len(y_true)):\\n # store apk values for every sample\\n apk_values.append(\\n apk(y_true[i], y_pred[i], k=k)\\n )\\n \\n # return mean of apk values list\\n return sum(apk_values) / len(apk_values)\",\n \"def get_predictive(self, x, k):\\n phi_x = self.base(x)\\n phi_z = self.base(self.prev_tasks_tensors[k])\\n k_xx = phi_x @ phi_x.T\\n k_xz = phi_x @ phi_z.T\\n k_zz = phi_z @ phi_z.T\\n k_zz_ = torch.inverse(k_zz)\\n mu_u = self.prev_tasks_distr[k].mean\\n cov_u = self.prev_tasks_distr[k].covariance_matrix\\n\\n mu = phi_x @ phi_z.T @ k_zz_ @ mu_u\\n sigma = k_xx + k_xz @ k_zz_ @ (cov_u - k_zz) @ k_zz_ @ k_xz.T\\n sigma *= torch.eye(sigma.shape[0]).to(self.device) #we are interested only \\n #in diagonal part for inference\\n return MultivariateNormal(loc=mu, covariance_matrix=sigma)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67134637","0.63493425","0.6230027","0.5937208","0.5922331","0.58700496","0.5865079","0.5854051","0.5802165","0.57681924","0.57678413","0.5766189","0.56813323","0.5665864","0.56399745","0.5591939","0.55886245","0.55843544","0.5583202","0.5550176","0.5549319","0.5546833","0.5540603","0.5531644","0.553101","0.55303323","0.5524726","0.5507059","0.5502562","0.5496853","0.54826784","0.54783475","0.5477431","0.54699385","0.54699385","0.54688174","0.54650956","0.54466623","0.54466623","0.5446326","0.54359114","0.5429057","0.5423517","0.5421656","0.5413816","0.54122776","0.54040086","0.5402933","0.5395061","0.5395061","0.5395061","0.5389677","0.5387747","0.538694","0.53845686","0.5373295","0.53694046","0.53682226","0.5352424","0.534939","0.534876","0.53475386","0.53467923","0.53430665","0.5342471","0.53362334","0.5331622","0.532261","0.53193814","0.5315977","0.53105855","0.53087276","0.53057665","0.5303244","0.5302253","0.5292341","0.5289494","0.5289494","0.5289494","0.5287489","0.5286523","0.52834535","0.52834535","0.5280829","0.52805465","0.5279203","0.5278812","0.52735424","0.52728534","0.52688575","0.526857","0.5259995","0.52591854","0.52566785","0.5255537","0.5255097","0.52515364","0.52502924","0.5249185","0.5249095","0.5247996"],"string":"[\n \"0.67134637\",\n \"0.63493425\",\n \"0.6230027\",\n \"0.5937208\",\n \"0.5922331\",\n \"0.58700496\",\n \"0.5865079\",\n \"0.5854051\",\n \"0.5802165\",\n \"0.57681924\",\n \"0.57678413\",\n \"0.5766189\",\n \"0.56813323\",\n \"0.5665864\",\n \"0.56399745\",\n \"0.5591939\",\n \"0.55886245\",\n \"0.55843544\",\n \"0.5583202\",\n \"0.5550176\",\n \"0.5549319\",\n \"0.5546833\",\n \"0.5540603\",\n \"0.5531644\",\n \"0.553101\",\n \"0.55303323\",\n \"0.5524726\",\n \"0.5507059\",\n \"0.5502562\",\n \"0.5496853\",\n \"0.54826784\",\n \"0.54783475\",\n \"0.5477431\",\n \"0.54699385\",\n \"0.54699385\",\n \"0.54688174\",\n \"0.54650956\",\n \"0.54466623\",\n \"0.54466623\",\n \"0.5446326\",\n \"0.54359114\",\n \"0.5429057\",\n \"0.5423517\",\n \"0.5421656\",\n \"0.5413816\",\n \"0.54122776\",\n \"0.54040086\",\n \"0.5402933\",\n \"0.5395061\",\n \"0.5395061\",\n \"0.5395061\",\n \"0.5389677\",\n \"0.5387747\",\n \"0.538694\",\n \"0.53845686\",\n \"0.5373295\",\n \"0.53694046\",\n \"0.53682226\",\n \"0.5352424\",\n \"0.534939\",\n \"0.534876\",\n \"0.53475386\",\n \"0.53467923\",\n \"0.53430665\",\n \"0.5342471\",\n \"0.53362334\",\n \"0.5331622\",\n \"0.532261\",\n \"0.53193814\",\n \"0.5315977\",\n \"0.53105855\",\n \"0.53087276\",\n \"0.53057665\",\n \"0.5303244\",\n \"0.5302253\",\n \"0.5292341\",\n \"0.5289494\",\n \"0.5289494\",\n \"0.5289494\",\n \"0.5287489\",\n \"0.5286523\",\n \"0.52834535\",\n \"0.52834535\",\n \"0.5280829\",\n \"0.52805465\",\n \"0.5279203\",\n \"0.5278812\",\n \"0.52735424\",\n \"0.52728534\",\n \"0.52688575\",\n \"0.526857\",\n \"0.5259995\",\n \"0.52591854\",\n \"0.52566785\",\n \"0.5255537\",\n \"0.5255097\",\n \"0.52515364\",\n \"0.52502924\",\n \"0.5249185\",\n \"0.5249095\",\n \"0.5247996\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":91790,"cells":{"query":{"kind":"string","value":"Uses scipy.optimize.curve_fit() to fit the log model to typetoken data."},"document":{"kind":"string","value":"def fit(self, m_tokens: np.ndarray, n_types: np.ndarray):\n\n # initial guess: naive fit\n M, N, H = max(m_tokens), max(n_types), max(n_types) / 2\n p0 = self.fit_naive(M, N, H).params\n\n # minimize MSE on random perturbations of M_z, N_z\n # NOTE: y(x) = 1 - k0(x) -> E(m)/Nz = 1 - k0(m/Mz)\n def func(m, M_z, N_z):\n return N_z * (1 - self.formula_0(m / M_z))\n\n xdata = np.array(m_tokens)\n ydata = np.array(n_types)\n params_, _ = curve_fit(func, xdata, ydata, p0)\n M_z, N_z = params_.astype(\"int\")\n self.params = (M_z, N_z)\n\n # return fitted model\n return self"},"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 fit_exp_data(x_vals, y_vals):\n log_vals = []\n for y in y_vals:\n log_vals.append(math.log(y, 2)) #get log base 2\n fit = np.polyfit(x_vals, log_vals, 1)\n return fit, 2","def fit(self, X):","def fit(self, X, y, **fit_params):\n ...","def _fit_gas_trend(cls, x, y, fit_type=None):\n fit_type = cls._max_trend_poly_deg if fit_type is None else fit_type\n if fit_type == 'exp':\n logger.debug('Using exponential fit to extrapolate {}'.format(cls._gas_name))\n fit = np.polynomial.polynomial.Polynomial.fit(x, np.log(y), 1, w=np.sqrt(y))\n return lambda t: np.exp(fit(t))\n\n else:\n logger.debug('Using order {} polynomial to extrapolate {}'.format(fit_type, cls._gas_name))\n fit = np.polynomial.polynomial.Polynomial.fit(x, y, deg=fit_type)\n return fit","def log_reg(x_train, y_train):\n\n log_reg_classifier = LogisticRegression(max_iter=1000, solver='lbfgs')\n log_reg_classifier.fit(x_train, y_train)\n return log_reg_classifier\n\n # log_reg_classifier.fit(x_train, y_train)","def fit(self, X, y=..., **fit_params):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, x):\n pass","def fit_data(self, data):\n d = log(-log(data))\n return dot(d, self._fit_matrix.T)","def fit(self, X, y):","def fit(self, X, y):","def fit(self, X, y):","def fit(self, x, y): \n # *** START CODE HERE ***\n y = y.reshape(y.shape[0], 1)\n y_0 = (1 - y).reshape(y.shape)\n m = y.shape[0]\n m_0 = np.asscalar(np.sum(y_0))\n m_1 = np.asscalar(np.sum(y))\n # Find phi, mu_0, mu_1, and sigma\n phi = np.sum(y) / m\n mu_0 = (np.sum(np.multiply(y_0, x), axis = 0, keepdims = True) / m_0) #.reshape(y.shape)\n mu_1 = np.sum(np.multiply(y, x), axis = 0, keepdims=True) / m_1\n sigma = getsigma(x, mu_0, mu_1, m, y, y_0)\n # Write theta in terms of the parameters\n sigma_inv = np.linalg.inv(sigma)\n log_phi = np.log(np.exp(-1 * np.log(phi)) - 1)\n theta_0 = (np.dot(np.dot(mu_0, sigma_inv), mu_0.T) - np.dot(np.dot(mu_1, sigma_inv), mu_1.T)) / 2 - log_phi\n self.theta = np.concatenate((theta_0, np.dot(sigma_inv, (mu_1 - mu_0).T)))\n # Compute cost\n x_0 = np.zeros((x.shape[0], 1)) + 1\n x_train = np.concatenate((x_0.T, x.T))\n h_theta = sigmoid(np.dot(self.theta.T, x_train)).T\n cost = - np.sum(np.dot(y.T, np.log(h_theta - (h_theta - 0.5) * self.eps)) + (np.dot(y_0.T, np.log(1 - h_theta + (h_theta - 0.5) * self.eps)))) / m\n if self.verbose:\n print(\"Cost: \" + str(cost))\n # *** END CODE HERE ***","def fit():\n pass","def fit(self, X, Y, **fit_params):\n ...","def fit(self, X, Y, **fit_params):\n ...","def fit(self, X,y):\n pass","def _fit(self, _X, _y):\n\n self.model = linear_model.LogisticRegression(penalty=self.penalty, random_state=self.seed,\n solver='saga', n_jobs=self.n_jobs)\n self.model.fit(_X, _y)","def fit(self, X):\n raise NotImplementedError","def fit(self, x, y, logger):\n history = self.model1.fit(x=x, y=y, batch_size=self.batch_size, epochs=self.epochs)\n logger.log({'ValFuncLoss': history.history['loss'][-1]})","def fit_experimental(self, m_tokens: np.ndarray, n_types: np.ndarray, gamma: float):\n\n # initial guess\n M = m_tokens.max()\n N = n_types.max()\n p0 = (M, N)\n\n # fix gamma, but fit M, N to the data\n xdata = np.array(m_tokens)\n ydata = np.array(n_types)\n\n def func(m, M, N):\n return N * self.formula(m / M, gamma)\n\n [M, N], _ = curve_fit(func, xdata, ydata, p0)\n M, N = int(M), int(N)\n self.params = (M, N, gamma)\n\n # return fitted model\n return self","def fit(self, X, Y):\n ...","def fit(self, x):\n raise NotImplementedError()","def fit_model(train_ts_dis, data, init_prior = [.5,.5], bias = True, mode = \"biasmodel\"):\r\n if mode == \"biasmodel\":\r\n #Fitting Functions\r\n def bias_fitfunc(rp, tsb, df):\r\n init_prior = [.5,.5]\r\n model = BiasPredModel(train_ts_dis, init_prior, ts_bias = tsb, recursive_prob = rp)\r\n model_likelihoods = []\r\n for i in df.index:\r\n c = df.context[i]\r\n trial_choice = df.subj_ts[i]\r\n conf = model.calc_posterior(c)\r\n model_likelihoods.append(conf[trial_choice])\r\n return np.array(model_likelihoods)\r\n \r\n def bias_errfunc(params,df):\r\n rp = params['rp']\r\n tsb = params['tsb']\r\n #minimize\r\n return abs(np.sum(np.log(bias_fitfunc(rp,tsb,df)))) #single value\r\n \r\n #Fit bias model\r\n #attempt to simplify:\r\n fit_params = lmfit.Parameters()\r\n fit_params.add('rp', value = .6, min = 0, max = 1)\r\n if bias == True:\r\n fit_params.add('tsb', value = 1, min = 0)\r\n else:\r\n fit_params.add('tsb', value = 1, vary = False, min = 0)\r\n out = lmfit.minimize(bias_errfunc,fit_params, method = 'lbfgsb', kws= {'df': data})\r\n lmfit.report_fit(out)\r\n return out.values\r\n \r\n elif mode == \"midline\":\r\n #Fitting Functions\r\n def midline_errfunc(params,df):\r\n eps = params['eps'].value\r\n context_sgn = np.array([max(i,0) for i in df.context_sign])\r\n choice = df.subj_ts\r\n #minimize\r\n return -np.sum(np.log(abs(abs(choice - (1-context_sgn))-eps)))\r\n \r\n #Fit bias model\r\n #attempt to simplify:\r\n fit_params = lmfit.Parameters()\r\n fit_params.add('eps', value = .1, min = 0, max = 1)\r\n midline_out = lmfit.minimize(midline_errfunc,fit_params, method = 'lbfgsb', kws= {'df': data})\r\n lmfit.report_fit(midline_out)\r\n return midline_out.values","def fit_logregL1(data, C=.01):\n from sklearn.linear_model import LogisticRegression\n n,m = data.shape\n \n # TODO: just build (sparse) L directly & construct with it\n # for each Xi, estimate the neighborhood of Xi using L1-reg logistic regression:\n nbrs,th_ij,th_i = [None]*n, [None]*n, np.zeros((n,))\n Xtr, Xtmp = toPM(data), toPM(data) # make two copies so we can modify\n for i in range(n): \n Xtmp[i,:] = 0. # remove ourselves\n lr = LogisticRegression(penalty='l1',C=C,solver='liblinear').fit(Xtmp.T,Xtr[i,:])\n nbrs[i] = np.where(np.abs(lr.coef_) > 1e-6)[1]\n th_ij[i]= lr.coef_[0,nbrs[i]]/2.\n th_i[i] = lr.intercept_/2.\n Xtmp[i,:] = Xtr[i,:]; # & restore after\n \n # Collect single-variable factors\n factors = [Factor(Var(i,2),[-t,t]).exp() for i,t in enumerate(th_i)]\n\n # Collect non-zero pairwise factors\n for i in range(n):\n for jj,j in enumerate(nbrs[i]):\n # TODO: FIX: double counts edges? use different combination methods?\n scope = [Var(i,2),Var(int(j),2)]\n t = th_ij[i][jj]\n factors.append( Factor(scope, [[t,-t],[-t,t]]).exp() )\n \n # Build a model from the factors\n return Ising(factors)","def fitfunc(x_unshifted, p=default()):\n x = x_unshifted+p[4]\n xtr, ytr, gradtr = logcontinuity(p)\n if x < xtr:\n return logpeak(x, p)\n else:\n return logpowerlaw(x, p)","def fit(\n self, m_tokens: np.ndarray, n_types: np.ndarray, M: int = None, N: int = None\n ):\n\n # fix M, N\n M = M or m_tokens.max()\n N = N or n_types.max()\n\n # initial guess\n p0 = 2.0\n\n # minimize MSE on random perturbations of gamma\n xdata = np.array(m_tokens) / M\n ydata = np.array(n_types) / N\n [gamma_], _ = curve_fit(self.formula, xdata, ydata, p0)\n self.params = (M, N, gamma_)\n\n # return fitted model\n return self","def _fit(self):\n\n\t\tclf = LogisticRegression()\n\t\tclf.fit(inputs, labels)\n\n\t\treturn clf","def fit(self, input):\n raise NotImplementedError()","def _model_fit_term(self):\n if self.likelihood.YYT is None:\n return -0.5*np.sum(np.square(np.dot(self.Li,self.likelihood.Y)))\n else:\n return -0.5*np.sum(np.multiply(self.Ki, self.likelihood.YYT))","def fit_logistic_regression():\n\n logger.debug(\"Running the fit_logistic_regression function now\")\n\n #Loading the configuration\n with open(os.path.join(\"config\",\"config.yml\"), \"r\") as f:\n config = yaml.safe_load(f)\n\n #Loading and pre processing the data\n logger.debug(\"Loading and pre processing the data\")\n train_df = load_data(config[\"load_data\"][\"train_file\"])\n train_df = pre_process_data(train_df, resample = True, resample_count = 500000)\n\n #Defining Pipeline\n pipeline = Pipeline([\n ('tfidf', TfidfVectorizer(analyzer='word', token_pattern=r'[A-Za-z0-9@-]+')),\n ('model', LogisticRegression(random_state=12345, verbose = 1, solver = 'saga')),\n ])\n\n #Defining parameters to vary\n parameters = {\n 'tfidf__max_df': (0.25, 0.5, 0.75),\n 'tfidf__max_features': (None, 5000, 10000, 50000),\n 'tfidf__ngram_range': ((1, 1), (1, 2)),\n 'model__C': (0.01, 1, 100)\n }\n\n scoring_list = [\"accuracy\", \"f1\", \"precision\", \"recall\", \"roc_auc\"]\n \n #Performing 5fold CV to determine best hyperparameters\n model = GridSearchCV(pipeline, parameters, cv=5,\n n_jobs=-1, verbose=1, scoring=scoring_list, refit='f1',)\n\n t0 = datetime.datetime.now()\n\n model.fit(train_df[\"Review\"].tolist(), train_df[\"Ratings\"].to_numpy())\n \n logger.info(\"Grid Search performed in {}\".format(str(datetime.datetime.now()-t0)))\n\n #Saving results\n res_df = pd.DataFrame(model.cv_results_)\n res_df.to_csv(os.path.join(config[\"summary_stats\"][\"save_location\"], \"LogisticRegressionResults.csv\"))\n \n #Saving the model\n pickle.dump(model, open(os.path.join(config[\"models\"][\"save_location\"], \"LogisticRegression.pkl\"),'wb'))\n\n return","def fit(model, input: str, output: str):\n print(f\"Fitting model of type: {model}\")\n\n # Define the model. Use a randomized search to efficiently explore the\n # hyperparameter space in a limited time.\n if model == \"logistic\":\n # Primal logistic regression\n param_dist = {\n 'C': loguniform(0.1, 100), 'max_iter': [250], 'fit_intercept': [True],\n 'intercept_scaling': [1], 'penalty': ['l2'], 'tol': loguniform(1e-6, 1e-4)\n }\n mdl_cv = RandomizedSearchCV(LogisticRegression(solver='lbfgs'), param_dist, cv=3, refit=True, verbose=2, n_iter=10)\n elif model == \"rand_forest\":\n # Random Forest classifier\n param_dist = {'max_depth': randint(3,8), 'max_features': randint(2,9), 'n_estimators': randint(50, 100),\n 'min_samples_split': randint(3, 7)}\n mdl_cv = RandomizedSearchCV(RandomForestClassifier(), param_dist, cv=3, refit=True, verbose=2, n_iter=10)\n elif model == \"gradient_boost\":\n # Extreme Gradient Boost classifier\n param_dist = {'max_depth': [3, 4], 'gamma': loguniform(1e-3, 1e-2), 'min_child_weight': randint(1, 10),\n 'learning_rate': loguniform(0.05, 0.3), 'n_estimators': randint(10, 40)}\n mdl_cv = RandomizedSearchCV(XGBClassifier(), param_dist, cv=3, refit=True, verbose=2, n_iter=10)\n else:\n raise NotImplementedError(f\"Don't know how to train model of type: {model}.\\nValid options are: logistic, rand_forest, gradient_boost.\")\n\n # Define x (input data) and y (target data)\n df = pd.read_csv(input)\n x = df.loc[:, df.columns != 'Exited']\n y = df.Exited\n print(f\"Data has x.shape = {x.shape} and y.shape = {y.shape}\")\n\n # Fit the model with randomized search\n mdl_cv.fit(x, y)\n\n # Print some results\n print(\"Best score:\", mdl_cv.best_score_)\n print(\"Best params:\", pprint.pformat(mdl_cv.best_params_))\n\n # Save to data store\n os.makedirs(os.path.dirname(output), exist_ok=True)\n with open(output, \"wb\") as f:\n joblib.dump(mdl_cv.best_estimator_, f)","def fit_transform(self, X, y=...):\n ...","def kentaDataTofLogRhoFit2():\n func = lambda lr: getTRollFunc(25.0, 0.0, 14.1875 - 0.07, .3125)(lr) \\\n + getTRollFunc(5.0, 0.01, 11.5, .25)(lr)\n return func","def fitexp(xdata,ydata,fitparams=None,domain=None,showfit=False,showstartfit=False,label=\"\"):\n if domain is not None:\n fitdatax,fitdatay = selectdomain(xdata,ydata,domain)\n else:\n fitdatax=xdata\n fitdatay=ydata\n if fitparams is None: \n fitparams=[0.,0.,0.,0.]\n fitparams[0]=fitdatay[-1]\n fitparams[1]=fitdatay[0]-fitdatay[-1]\n fitparams[1]=fitdatay[0]-fitdatay[-1]\n fitparams[2]=fitdatax[0]\n fitparams[3]=(fitdatax[-1]-fitdatax[0])/5.\n #print fitparams\n p1 = fitgeneral(fitdatax, fitdatay, expfunc, fitparams, domain=None, showfit=showfit, showstartfit=showstartfit,\n label=label)\n return p1","def fit(self, x, y):\n # Note Logistic Regression Runtime\n start_time = time.time()\n\n # Converting Pandas DataFrame to Numpy arrays\n if not type(x).__module__ == np.__name__:\n x = x.to_numpy()\n if not type(y).__module__ == np.__name__:\n y = y.to_numpy()\n\n # Insert a column of 1 in the feature vector X for the bias term in the weights\n x = np.insert(x,0,1,axis=1)\n \n # Verify dimension of input\n if len(x) != len(y):\n print(\"The number of input features vector must be to be the same as the number of target variables\")\n else:\n losses = self.gradient_descent(x,y)\n\n # Note end time\n end_time = time.time()\n\n # Log runtime\n print(\"Logistic Regression training time: {0:.2f}s\".format(end_time - start_time))\n \n return losses","def train_logistic_regression(x_train, y_train, learning_rate, fit_intercept=False, max_iter=500):\r\n if fit_intercept:\r\n intercept = np.ones(x_train.shape[0], 1)\r\n x_train = np.hstack((intercept, x_train)) # hstacks merges 2 arrays column wise\r\n weights = np.zeros(x_train.shape[1])\r\n for iteration in range(max_iter):\r\n weights = update_weights(x_train, y_train, weights, learning_rate)\r\n # printing cost for every 100 iterations\r\n if iteration % 100 == 0:\r\n print(calculate_cost(x_train, y_train, weights))\r\n return weights","def logistic_regression(y, tx, initial_w, max_iters, gamma):\n return least_squares_SGD(y, tx, initial_w, max_iters, gamma, loss_function=logistic_loss, gradient=logistic_grad)","def _model_fit_term(self):\r\n if self.likelihood.YYT is None:\r\n tmp, _ = dtrtrs(self.L, np.asfortranarray(self.likelihood.Y), lower=1)\r\n return -0.5 * np.sum(np.square(tmp))\r\n # return -0.5 * np.sum(np.square(np.dot(self.Li, self.likelihood.Y)))\r\n else:\r\n return -0.5 * np.sum(np.multiply(self.Ki, self.likelihood.YYT))","def add_fit_data(self, model: str, tab_line: dict, lums: dict, obs_order: dict):\n # Just headers that will always be present in tab_line that are not fit parameters\n not_par = ['MODEL', 'TOTAL_EXPOSURE', 'TOTAL_COUNT_RATE', 'TOTAL_COUNT_RATE_ERR',\n 'NUM_UNLINKED_THAWED_VARS', 'FIT_STATISTIC', 'TEST_STATISTIC', 'DOF']\n\n # Checking that we have the expected amount of data passed in\n if len(tab_line) != self._num_ann:\n raise ValueError(\"The dictionary passed in with the fit results in it does not have the same\"\n \" number of entries as there are annuli.\")\n elif len(lums) != self._num_ann:\n raise ValueError(\"The dictionary passed in with the luminosities in it does not have the same\"\n \" number of entries as there are annuli.\")\n\n for ai in range(0, self._num_ann):\n # Various global values of interest\n self._total_exp[ai] = float(tab_line[ai][\"TOTAL_EXPOSURE\"])\n self._total_count_rate[ai][model] = [float(tab_line[ai][\"TOTAL_COUNT_RATE\"]),\n float(tab_line[ai][\"TOTAL_COUNT_RATE_ERR\"])]\n self._test_stat[ai][model] = float(tab_line[ai][\"TEST_STATISTIC\"])\n self._dof[ai][model] = float(tab_line[ai][\"DOF\"])\n self._obs_order[ai][model] = obs_order[ai]\n\n # The parameters available will obviously be dynamic, so have to find out what they are and then\n # then for each result find the +- errors.\n par_headers = [n for n in tab_line[ai].dtype.names if n not in not_par]\n mod_res = {}\n for par in par_headers:\n # The parameter name and the parameter index used by XSPEC are separated by |\n par_info = par.split(\"|\")\n par_name = par_info[0]\n\n # The parameter index can also have an - or + after it if the entry in question is an uncertainty\n if par_info[1][-1] == \"-\":\n ident = par_info[1][:-1]\n pos = 1\n elif par_info[1][-1] == \"+\":\n ident = par_info[1][:-1]\n pos = 2\n else:\n ident = par_info[1]\n pos = 0\n\n # Sets up the dictionary structure for the results\n if par_name not in mod_res:\n mod_res[par_name] = {ident: [0, 0, 0]}\n elif ident not in mod_res[par_name]:\n mod_res[par_name][ident] = [0, 0, 0]\n\n mod_res[par_name][ident][pos] = float(tab_line[ai][par])\n\n # Storing the fit results\n self._fit_results[ai][model] = mod_res\n # And now storing the luminosity results\n self._luminosities[ai][model] = lums[ai]","def ts_fit(series: TimeSeries) -> TimeSeries:\n pass","def logreg_train(model, X, Y, batch=32, epochs=50, valid_split=0.2):\r\n\thistory = model.fit(\r\n\t\tX, Y,\t\t\t\t# inputs & labels\r\n\t\tbatch_size=batch,\r\n\t\tepochs=epochs,\r\n\t\tvalidation_split=0.2\r\n\t)\r\n\r\n\treturn history","def analysis(houses:pd.DataFrame) -> None:\n \n \"\"\"\n #Me just trying to fit the data without any outside influences\n f= f'SELLER_HOUSE ~ SQFT_PER + PRICE + C(LOCATION)' \n result= smf.logit(formula= str(f), data= houses).fit()\n print(result.summary2())\n y= ['SELLER_HOUSE']\n x= ['SQFT_PER', 'PRICE', 'LOC_699 - Not Defined', 'LOC_AA - Airport Area', 'LOC_CG - Columbus Grove',\n 'LOC_CV - Cypress Village', 'LOC_EASTW - Eastwood', 'LOC_EC - El Camino Real', 'LOC_GP - Great Park',\n 'LOC_IRSP - Irvine Spectrum', 'LOC_LGA - Laguna Altura', 'LOC_NK - Northpark', 'LOC_NW - Northwood', \n 'LOC_OC - Oak Creek', 'LOC_OH - Orchard Hills', 'LOC_OT - Orangetree', 'LOC_PS - Portola Springs', \n 'LOC_QH - Quail Hill', 'LOC_SH - Shady Canyon', 'LOC_SJ - Rancho San Joaquin', 'LOC_STG - Stonegate', \n 'LOC_Stonegate', 'LOC_TR - Turtle Rock', 'LOC_TRG - Turtle Ridge', 'LOC_UP - University Park',\n 'LOC_UT - University Town Center', 'LOC_WB - Woodbridge', 'LOC_WD - Woodbury', \n 'LOC_WI - West Irvine', 'LOC_WN - Walnut (Irvine)', 'LOC_WP - Westpark']\n x_train, x_test, y_train, y_test= train_test_split(houses[x], houses[y], test_size= 0.3, random_state= 500)\n logreg = LogisticRegression()\n logreg.fit(x_train, y_train.values.ravel())\n y_pred= logreg.predict(x_test)\n print('Accuracy of logistic regression classifier on test set:', round(logreg.score(x_test, y_test), 3))\n # This model is really bad\n \n \"\"\"\n \n \"\"\n houses= houses.drop(['DAYS_ON_MARKET', 'ADDRESS', 'LOCATION',\n 'STATUS', 'PROPERTY_TYPE', 'ZIP_CODE'], axis= 1)\n columns= houses.columns.values.tolist()\n y= ['SELLER_HOUSE']\n x= [i for i in columns if i not in y]\n \n # Over Sampling Using SMOTE \n x_train, _, y_train, _= train_test_split(houses[x], houses[y], test_size= 0.3, random_state= 500)\n x_columns= x_train.columns\n \n os= SMOTE(random_state= 0)\n os_x, os_y= os.fit_sample(x_train, y_train)\n os_x= pd.DataFrame(data= os_x, columns= x_columns)\n os_y= pd.DataFrame(data= os_y, columns= y)\n \n \n #Recursive Feature Elimination\n logreg= LogisticRegression(max_iter= 600)\n rfe= RFE(logreg, 20)\n rfe= rfe.fit(os_x, os_y.values.ravel())\n \n lst= [i for count, i in enumerate(x) if rfe.support_[count] == True]\n X= os_x[lst]\n Y= os_y['SELLER_HOUSE']\n \n \n #logit_model= sm.Logit(Y, X)\n #result= logit_model.fit()\n #print(result.summary2()) # Model choosen by RCE\n \n #These are features have a p-value less than 0.05\n final_x= ['BATHS', 'ZIP_92602.0', 'ZIP_92618.0', 'LOC_699 - Not Defined', 'LOC_TR - Turtle Rock', 'LOC_WD - Woodbury']\n #final_x= ['ZIP_92602.0', 'LOC_699 - Not Defined', 'LOC_TR - Turtle Rock', 'LOC_WD - Woodbury']\n X2= os_x[final_x]\n \n logit_model2= sm.Logit(Y, X2)\n result2= logit_model2.fit()\n print(result2.summary2()) # Final Model\n \n x_train2, x_test2, y_train2, y_test2= train_test_split(X2, Y, test_size= 0.3, random_state= 500)\n logreg = LogisticRegression()\n logreg.fit(x_train2, y_train2)\n \n y_pred= logreg.predict(x_test2)\n print('Accuracy of logistic regression classifier on test set:', round(logreg.score(x_test2, y_test2), 2))\n \n conf_matrix= confusion_matrix(y_test2, y_pred)\n print(conf_matrix)\n # So 22+61 correct predictions and 13+44 wrong predictions\n \n logit_roc_auc = roc_auc_score(y_test2, logreg.predict(x_test2))\n fpr, tpr, _ = roc_curve(y_test2, logreg.predict_proba(x_test2)[:,1])\n plt.figure()\n plt.plot(fpr, tpr, label='Logistic Regression (area = %0.2f)' % logit_roc_auc)\n plt.plot([0, 1], [0, 1],'r--')\n plt.xlim([0.0, 1.0])\n plt.ylim([0.0, 1.05])\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.title('Receiver operating characteristic')\n plt.legend(loc=\"lower right\")\n plt.show()\n \"\"","def fit(self, Y):\n raise NotImplementedError","def kentaDataTofLogRhoFit1():\n func = lambda lr: getTRollFunc(20.0, 0.0, 14.25 - 0.07, .25)(lr) \\\n + getTRollFunc(10.0, 0.01, 11.5, .25)(lr)\n return func","def my_loglike(theta, x, data, sigma):\n\n model = my_model(theta, x)\n\n return -0.5*len(x)*np.log(2*math.pi*sigma**2) - (0.5/sigma**2) * np.sum((data-model)**2)","def fit(self):\n # Initialize parameter estimates\n if self.estimator is not None:\n param_estimates = self.estimator(self.xf, self.yf)\n else: param_estimates = None\n self.popt, self.pcov = curve_fit(self.model, self.xf, self.yf, \n p0=param_estimates)\n self.fit_history.append({\"popt\" : self.popt, \"pcov\" : self.pcov})","def fit(self, X):\n self._fit_X = X","def sas_curve_fit(x, y, calc_type):\n\n result = {}\n\n n = len(x)\n\n if (n == 0) or (len(y) == 0):\n err = \"Error: No values to fit in \" + calc_type + \" calculation\\n\"\n raise Exception(err)\n #result['error'] = err\n else:\n # Linear fit to the input x and y values\n #fit_coeffs = np.polyfit(x, y, 1)\n fit_coeffs = sps.linregress(x, y)\n \n result['fit'] = fit_coeffs\n\n if (calc_type == 'rxs1') or (calc_type == 'rxs2'):\n # Cross section Rxs1/Rxs2 calculated from fits of q^2 vs ln(I*q)\n # Rxs?^2 = 2 * gradient\n result['r'] = np.sqrt(2 * abs(fit_coeffs[0]))\n #result['rerr'] = np.abs(np.sqrt(2 * abs(fit_coeffs[4]))-result['r'])\n result['rerr'] = np.abs(np.sqrt(2 * abs(fit_coeffs[0] + fit_coeffs[4])) - result['r'])\n result['i'] = None\n else:\n # Assume a standard Guinier fit of q^2 vs ln(I):\n # Rg^2 = 3 * gradient\n # Io = exp(intercept)\n std_err_fit = fit_coeffs[4]\n # Analysis below on the basis that scipt.stats.linregress\n # gives the std error on the slope rather than of the regression\n # This gives result inline with old SJP code - needs chacking as \n # seems odd\n result['r'] = np.sqrt(3 * abs(fit_coeffs[0]))\n result['rerr'] = np.abs(np.sqrt(3 * abs(fit_coeffs[0] + std_err_fit)) - result['r'])\n result['i'] = np.exp(fit_coeffs[1])\n result['ierr'] = np.exp(fit_coeffs[1] + (std_err_fit * np.sqrt(np.sum(x**2))/np.sqrt(n))) - result['i']\n\n return result","def fit(self, X, y, X_val=None, y_val=None):\n #Adding an extra column of 1s for constant term\n n_samples = X.shape[0]\n n_features = X.shape[1]\n temp = np.empty((n_samples, n_features+1), dtype=float) # adding extra 1s to X\n for i in range(n_samples):\n temp[i] = np.append(X[i], 1)\n X = temp\n y = y.reshape((-1,1)) # reshaping y \n\n try: # if validation set is present\n if X_val.all() != None and y_val.all() != None:\n # adding extra 1s and reshaping y\n val_n_samples = X_val.shape[0]\n val_n_features = X_val.shape[1]\n temp = np.empty((val_n_samples, val_n_features+1), dtype=float)\n for i in range(val_n_samples):\n temp[i] = np.append(X_val[i], 1)\n X_val = temp\n y_val = y_val.reshape((-1,1))\n except AttributeError:\n pass\n\n self.theta = np.zeros((n_features+1,1)) # these are the model parameters\n self.train_history = np.zeros(self.n_iterations) # initialising array store train loss history\n self.val_history = np.zeros(self.n_iterations) # initialising array store val loss history\n \n if self.cost_fn == 'RMSE':\n self.gradient_descent_rmse(X, y, X_val, y_val) # RMSE gradient call\n h_theta_of_x = np.dot(X, self.theta)\n cost = self.RMSE(n_samples, h_theta_of_x, y) # final RMSE loss\n # print('training_loss', cost)\n\n elif self.cost_fn == 'MAE':\n self.gradient_descent_mae(X, y, X_val, y_val) # MAE gradient call\n h_theta_of_x = np.dot(X, self.theta)\n cost = self.MAE(n_samples, h_theta_of_x, y) # final MSE loss\n # print('training_loss', cost)\n\n\n # fit function has to return an instance of itself or else it won't work with test.py\n return self","def fit_power_law(self, y, cut=0.6, interactive=True):\n\n self.fit_cut = cut\n\n start = np.where(y > 1e-6)[0][0] # find first non-zero value since we will take the log\n end = int(self.fit_cut * len(self.time_uniform)) # fit up until a fraction, cut, of the trajectory\n # print(y[start:end])\n # exit()\n\n # fit line to linear log plot\n A = Poly_fit.poly_fit(np.log(self.time_uniform[start:end]), np.log(y[start:end]), 1)[-1]\n\n return [np.exp(A[0]), A[1]]","def test_genextreme_fit(self):\n p = generic.fit(self.genextreme, \"genextreme\")\n np.testing.assert_allclose(p, (0.20949, 297.954091, 75.7911863), 1e-5)","def fit(self, x, y):\n def initiate_theta(dim):\n self.theta = np.zeros(dim)\n # print('self.theta initiated is {}'.format(self.theta))\n \n def implement_sigmoid(x):\n if self.theta is None:\n initiate_theta(x.shape[1])\n z = np.matmul(np.transpose(self.theta), np.transpose(x))\n return 1/(np.ones(x.shape[0]) + np.exp(-z))\n \n def implement_partial_loss(x, y):\n return -np.matmul(np.transpose(y - implement_sigmoid(x)), x)/x.shape[0]\n \n def implement_transposed_hess(x):\n sigmoid_hadamard = implement_sigmoid(x) * (np.ones(x.shape[0]) - implement_sigmoid(x))\n hess2 = np.diag(sigmoid_hadamard)\n hess = np.matmul(hess2,x)\n hess = np.matmul(np.transpose(x),hess)/x.shape[0]\n hess_inverse = np.linalg.inv(hess)\n return hess_inverse\n \n def train(x, y):\n count = 0\n if self.theta is None:\n initiate_theta(x.shape[1])\n while count < self.max_iter:\n if self.verbose:\n loss_y1 = np.matmul(np.transpose(y), np.log(implement_sigmoid(x)))\n loss_y0 = np.matmul(np.transpose(np.ones(x.shape[0]) - y), np.log(np.ones(x.shape[0]) - implement_sigmoid(x)))\n loss = -(loss_y1 + loss_y0 )/x.shape[0]\n print('Average empirical loss for step {} is {}'.format(count, loss))\n delta = np.matmul(implement_transposed_hess(x), implement_partial_loss(x, y))\n new_theta = self.theta - delta * self.step_size\n delta_theta = np.linalg.norm(new_theta - self.theta)\n # print('delta is {}'.format(delta_theta))\n if delta_theta < self.eps:\n return new_theta\n else:\n self.theta = new_theta\n count += 1\n return self.theta\n \n return train(x, y)","def fitting(x_value, target_value, model_function, fitting_method, type_of_fit):\n if len(target_value) != len(x_value):\n raise ValueError(\"Value length not match\")\n\n fig = plt.figure()\n\n parameters, _ = curve_fit(\n model_function, x_value, target_value, method=fitting_method)\n\n xspace = np.linspace(x_value[0], x_value[len(x_value) - 1], 100)\n if len(parameters) == 1:\n fit_A = parameters[0]\n fit_curve = model_function(xspace, fit_A)\n elif len(parameters) == 2:\n fit_A = parameters[0]\n fit_B = parameters[1]\n fit_curve = model_function(xspace, fit_A, fit_B)\n elif len(parameters) == 3:\n fit_A = parameters[0]\n fit_B = parameters[1]\n fit_C = parameters[2]\n fit_curve = model_function(xspace, fit_A, fit_B, fit_C)\n else:\n raise ValueError(\"Function do not support that Model\")\n\n # making plot\n plt.plot(x_value, target_value, 'o', label='cpu')\n plt.plot(xspace, fit_curve, '-', label='fit')\n plt.xlabel(\"cores_per_node\")\n plt.ylabel(\"time/s\")\n plt.title(type_of_fit + \"_Fitting Plot\")\n plt.legend()\n plt.savefig(type_of_fit + \"_fit.jpg\")\n plt.close()\n\n return parameters","def get_fit(self, space=False):\n\n if space:\n model_type = 'space'\n else:\n model_type = 'risk'\n\n fit_type = 'likelihood'\n\n fitter = self.fits[model_type].linear_fits[fit_type]\n\n return fitter","def logfit(N, err):\n import numpy as np\n\n if len(N) != len(err):\n raise ValueError('Convergence order args do not have same length')\n\n A = np.ones([len(err), 2])\n B = np.ones([len(err), 1])\n # ERR = A*N + B\n for i in range( len(N) ) :\n A[i,0] = np.log10(N[i])\n B[i] = np.log10(err[i])\n\n x, residuals, rank, singval = np.linalg.lstsq(A, B, rcond=None)\n\n return x","def fit(self,x):\n tokens = x['token'].to(self.device)\n attn_masks = x['attn_mask'].to(self.device)\n tags = x['label'].to(self.device).unsqueeze(dim=-1)\n\n tag_prob = self._bert_encoder(tokens, attn_masks)\n\n tag_prob_log = tag_prob.gather(-1,tags).squeeze(dim=-1)\n loss = -torch.mean(torch.sum(torch.log(tag_prob_log),dim=-1),dim=0)\n return loss","def get_investigation_data(self, gamma, dps, gamma_err=0, dps_err=0, fit_type='exponential'):\n if fit_type == 'exponential':\n coherence_length = 2 * np.log(2) / (gamma / dps)\n\n # fourier transform of an exponential decay with decay constant g = lorentzian with hwhm g\n # decay constant = 1/g\n # Fourier(exp(-2pi k0 x)) = (1/pi)(k0 / (k^2 + k0^2))\n # 2 pi k0 = g, k0 = hwhm = g / (2 pi)\n # fwhm = g / pi (*c)\n spectral_width_hz = (gamma / dps) / np.pi * constants.c\n\n elif fit_type == 'lorentzian':\n coherence_length_in_motor_steps = 2 * gamma\n coherence_length = coherence_length_in_motor_steps * dps # in metres\n # TODO: change this to in terms of the exponential decay.\n # but the lorentzian curve fit on the interferogram has no physical meaning anyway\n spectral_width_hz = constants.c / (np.pi * coherence_length)\n\n elif fit_type == 'gaussian':\n # gamma is actually sigma\n coherence_length_in_motor_steps = 2 * np.sqrt(2 * np.log(2)) * gamma\n coherence_length = coherence_length_in_motor_steps * dps # in metres\n\n # spectral_width_hz = constants.c / (np.pi * coherence_length)\n # new sigma is pi / sigma\n # idk why it's 1/ (pi * newsigma) and not pi / newsigma\n # TODO: Figure out why gaussian spec width is so narrow.\n spectral_width_hz = constants.c *2* np.sqrt(2 * np.log(2)) / (np.pi * gamma * dps)\n # print(\"%.4e, %.4e\" % (constants.c * 2 * np.sqrt(2 * np.log(2)) * np.pi / (gamma * dps), constants.c / (np.pi * coherence_length)))\n\n\n\n # steps between peaks = 1 wavelength = 1 / freq\n # dps = known_wavelength / (2 * 1 wavelength) = freq * known_wavelength / 2\n frequencies_per_motor_step, magnitudes = self.get_frequencies_with_fourier(fit=False)\n wavelengths = 2 * dps / frequencies_per_motor_step\n scipy_fit, calc_fit = self.find_best_fit_gaussian(x_y=(wavelengths, magnitudes))\n wavelengths_mean, wavelengths_std = scipy_fit[1], scipy_fit[2]\n mean_wavelength = wavelengths_mean\n spectral_width_m = mean_wavelength ** 2 / constants.c * spectral_width_hz\n\n frequencies = constants.c / wavelengths\n\n (amplitude, mean, gamma) = self.find_best_fit_lorentzian(x_y=(frequencies, magnitudes))\n scipy_fit = (amplitude, mean, gamma)\n frequencies_mean, frequencies_std = scipy_fit[1], scipy_fit[2]\n\n ## This section plots the fits to the FT\n # plt.plot(frequencies, magnitudes, '.')\n #\n # x_min, x_max = plt.xlim()\n # lorentzian_fit = lambda fit_params, x: fit_params[0] / (1 + ((x - fit_params[1]) / fit_params[2]) ** 2)\n # fit_x = np.linspace(x_min, x_max, 10000)\n # optimised_lorentzian_fit = lorentzian_fit(scipy_fit, fit_x)\n # fwhm = 2 * scipy_fit[2]\n # plt.plot(fit_x, optimised_lorentzian_fit, 'k', label='SciPy fit (Lorentzian)\\nFWHM: %.4e' % fwhm)\n #\n # gaussian_fit = lambda fit_params, x: fit_params[0] * np.exp(-(x - fit_params[1]) ** 2 / (2 * fit_params[2] ** 2))\n # scipy_fit, calc_fit = self.find_best_fit_gaussian(also_use_scipy=True, x_y=(frequencies, magnitudes))\n # optimised_gaussian_fit = gaussian_fit(scipy_fit, fit_x)\n # fwhm = 2 * np.sqrt(2 * np.log(2)) * scipy_fit[2]\n # plt.plot(fit_x, optimised_gaussian_fit, 'g', label='SciPy fit (G)\\nFWHM: %.4e' % fwhm)\n # plt.legend()\n #\n # plt.show()\n\n print('With Fourier:')\n print('Spectral Width (m): %.5e' % spectral_width_m)\n print('Coherence length: %.5e' % coherence_length)\n print('Mean frequencies: %.5e pm %.5e' % (frequencies_mean, frequencies_std))\n print('Mean wavelength: %.5e pm %.5e' % (mean_wavelength, wavelengths_std))\n\n\n\n steps, unique_steps_between_peaks, unique_steps_counts = self.get_steps_between_peaks()\n distances = dps * steps\n # distances_mean, distances_std = np.mean(distances), np.std(distances)\n wavelengths = distances * 2\n wavelengths_mean, wavelengths_std = np.mean(wavelengths), np.std(wavelengths)\n\n mean_wavelength = wavelengths_mean\n\n frequencies = constants.c / wavelengths\n frequencies_mean, frequencies_std = np.mean(frequencies), np.std(frequencies)\n\n spectral_width_m = mean_wavelength ** 2 / constants.c * spectral_width_hz\n print(\"With Step calculation\")\n print('Spectral Width (Hz): %.5e' % spectral_width_hz)\n print('Spectral Width (m): %.5e' % spectral_width_m)\n\n if gamma_err == 0 and dps_err == 0:\n print('Coherence length: %.5e' % coherence_length)\n print('Spectral width (Hz): %.5e' % spectral_width_hz)\n print('Mean frequencies: %.5e pm %.5e' % (frequencies_mean, frequencies_std))\n print('Mean wavelength: %.5e pm %.5e' % (mean_wavelength, wavelengths_std))\n else:\n print(dps_err, 'asdasdasfaegsegeg')\n coherence_length_err = dps_err / dps * coherence_length\n spectral_width_err = np.sqrt((coherence_length_err / (constants.c * mean_wavelength ** 2)) ** 2 +\n (2 * coherence_length / (constants.c * mean_wavelength ** 3)) ** 2)\n print(mean_wavelength ** 2 / coherence_length, 'dlambda')\n print('Coherence length: %.5e pm %.5e' % (coherence_length, coherence_length_err))\n print('Spectral width (Hz): %.5e pm %.5e' % (spectral_width_hz, spectral_width_err))\n print('Mean frequencies: %.5e pm %.5e' % (frequencies_mean, frequencies_std))\n print('Mean wavelength: %.5e pm %.5e' % (mean_wavelength, wavelengths_std))\n\n data = {'coherence_length': coherence_length,\n 'spectral_width_hz': spectral_width_hz,\n 'spectral_width_m': spectral_width_m,\n 'mean_wavelength': mean_wavelength,\n 'mean_frequency': frequencies_mean,\n }\n return data","def fit(self, x):\n tokens = x['token'].to(self.device)\n attn_masks = x['attn_mask'].to(self.device)\n label = x['label'].to(self.device)\n\n output = self.bert(tokens, attention_mask=attn_masks, labels=label)\n loss = output['loss']\n # logits = output['logits']\n # tag_prob = self.Softmax(logits)\n \n return loss","def fit(self, X, y, X_val=None, y_val=None):\n\n # fit function has to return an instance of itself or else it won't work with test.py\n # adding extra 1s and reshaping y\n n_samples = X.shape[0]\n n_features = X.shape[1]\n temp = np.empty((n_samples, n_features+1), dtype=float)\n for i in range(n_samples):\n temp[i] = np.append(X[i], 1)\n X = temp\n\n try: # if validation set is present\n if X_val.all() != None and y_val.all() != None:\n # adding extra 1s and reshaping y\n val_n_samples = X_val.shape[0]\n val_n_features = X_val.shape[1]\n temp = np.empty((val_n_samples, val_n_features+1), dtype=float)\n for i in range(val_n_samples):\n temp[i] = np.append(X_val[i], 1)\n X_val = temp\n except AttributeError:\n pass\n\n self.theta = np.zeros((n_features+1,1)) # these are the model parameters\n self.train_history = np.zeros(self.n_iterations)\n self.val_history = np.zeros(self.n_iterations)\n y = y.reshape((-1,1))\n\n if self.cost_fn == 'Batch':\n self.batch_gradient_descent(X, y, X_val, y_val) # Batch\n elif self.cost_fn == 'Stochastic':\n self.stochastic_gradient_descent(X, y, X_val, y_val) # Stochastic\n\n h_theta_of_x = self.sigmoid(np.dot(X, self.theta)) # predicted value\n predicted = np.around(h_theta_of_x) # rounding off according to 0.5\n accuracy = (predicted == y).all(axis=1).mean() # calculating accuracy of model\n train_cost = self.log_loss(n_samples, h_theta_of_x, y)\n\n print('training loss', train_cost)\n print('training accuracy:', accuracy)\n\n # fit function has to return an instance of itself or else it won't work with test.py\n return self","def _train(self, log_prob):\n raise NotImplementedError","def fit_DTI_signal(sig, x, weighted=False, x_pinv=None, is_log_sig=False, h_hat=None, inv_levs=None):\n if is_log_sig:\n y = sig\n else:\n #log SIGNAL\n #this assumes that sig is strictly positive!!!!\n try:\n y = np.log(sig)\n except RuntimeWarning as rw:\n print 'ERROR FIT: non-positive value in signal'\n print rw, '\\nsignal', sig\n raise rw\n #beta0=np.linalg.lstsq(DESIGNMATRIX,y)[0]\n #pseudo inverse z = (DESIGNMATRIX*xT)^(-1)*xT\n if x_pinv is None:\n z = designmatrix_pseudoinverse(x)\n else:\n z = x_pinv\n #compute hat matrix H diagonal, H = DESIGNMATRIX*z\n #in whitcher et al 2008 the H_diagonal is computed from the OLS regression\n if h_hat is None:\n H_diag = np.diagonal(np.dot(x, z))\n else:\n H_diag = h_hat\n #beta0 is the least squares fit result, beta0 = z*y\n beta0 = np.dot(z, y)\n if weighted:\n #generate synthetic SIGNAL\n try:\n Sg = np.exp(np.dot(x, beta0))\n except RuntimeWarning as rw:\n print 'ERROR FIT: generating synthetic signal'\n print rw, '\\ndesign matrix',x, '\\ntensor OLS fit' , beta0\n raise rw\n \n #compute weight matrix W\n try:\n W = generate_weights(Sg)\n except RuntimeWarning as rw:\n print 'ERROR FIT: generating weights'\n print rw, '\\nsynthetic signal', Sg\n raise rw\n #do IS_WEIGHTED fit \n #z = designmatrix_pseudoinverse(x, W) #np.dot(np.dot(np.linalg.inv(np.dot(DESIGNMATRIX.T,np.dot(W,DESIGNMATRIX))),DESIGNMATRIX.T),W)\n #beta is the final IS_WEIGHTED matrix\n #beta = np.dot(z, y)\n #linalg.lstsq wraps the function lapack_lite.dgelsd see some information on lapack dgelsd... That explains why the linalg calls the routine twice\n# LWORK (input) INTEGER\n# The dimension of the array WORK. LWORK must be at least 1. \n# The exact minimum amount of workspace needed depends on M, N and NRHS. \n# As long as LWORK is at least 12*N + 2*N*SMLSIZ + 8*N*NLVL + N*NRHS + (SMLSIZ+1)**2, \n# if M is greater than or equal to N or 12*M + 2*M*SMLSIZ + 8*M*NLVL + M*NRHS + (SMLSIZ+1)**2, \n# if M is less than N, the code will execute correctly. \n# SMLSIZ is returned by ILAENV and is equal to the maximum size of the subproblems at \n# the bottom of the computation tree (usually about 25), and NLVL = MAX( 0, INT( LOG_2( MIN( M,N )/(SMLSIZ+1) ) ) + 1 ) \n# For good performance, LWORK should generally be larger. \n# If LWORK = -1, then a workspace query is assumed; \n# the routine only calculates the optimal size of the WORK array, returns this value as the first entry of \n# the WORK array, and no error message related to LWORK is issued by XERBLA. \n# IWORK (workspace) INTEGER array, dimension (MAX(1,LIWORK)) LIWORK >= 3 * MINMN * NLVL + 11 * MINMN, where MINMN = MIN( M,N ). \n #tfit = np.linalg.lstsq(np.dot(x.T, np.dot(W,x)), np.dot(x.T, np.dot(W, y)))[0]\n #use faster diagonal matrix mul routine\n tmpfac = mult_diag(W, x.T, False)\n# tfit = np.linalg.lstsq(np.dot(tmpfac, x), np.dot(tmpfac, y))[0]\n try:\n tfit = np.linalg.solve(np.dot(tmpfac, x), np.dot(tmpfac, y))\n except np.linalg.LinAlgError as e:\n tfit = np.linalg.lstsq(np.dot(tmpfac, x), np.dot(tmpfac, y))[0]\n print 'fit_DTI_signal: Warning using lstsq', e\n# print e, '\\ntensor fit', f_s[0]\n else:\n tfit = beta0\n #compute hat matrix H diagonal, H = DESIGNMATRIX*z\n #in whitcher et al 2008 the H_diagonal is computed from the OLS regression\n #H_diag = np.diagonal(np.dot(x, z))\n #compute MU\n mu = np.dot(x, tfit)\n #compute log residuals\n errors = y-mu\n if inv_levs is None:\n try:\n \n #the resampling is only done on the gradient directions, not on the logS component!\n inv_levs = np.ones(errors.shape)\n inv_levs[1:] = 1./np.sqrt(1.-H_diag[1:]) \n \n except RuntimeWarning as rw2:\n print 'ERROR FIT: leveraged errors'\n print rw2, '\\nHat matrix diagonal', H_diag\n inv_levs = np.ones(errors.shape)\n raise rw2\n lev_errors = errors*inv_levs \n return (tfit, mu, errors, H_diag, lev_errors)","def train_logisticRegression(data: np.array, labels: np.array)->None:\n\n n_examples = np.size(data, 0)\n n_features = np.size(data, 1)\n n_categories = np.size(labels, 1)\n\n data = np.hstack((np.ones((n_examples, 1)), data))\n\n print(data[0:5, :])\n\n X_train, X_test, y_train, y_test, idx_test = split_data(data, labels, 0.7)\n\n convergence_goal = 1e-3\n learning_rate = 0.01\n\n theta = np.random.uniform(size=((n_features+1, n_categories)))\n\n for i in range(n_categories):\n\n cost_var = 1\n\n previous_cost = 1e6\n iterations = 0\n cost_to_plot = []\n\n while cost_var > convergence_goal:\n iterations += 1\n cost, grad = costFunction(X_train, y_train[:, i], theta[:, i])\n theta[:, i] = update_theta(theta[:, i], grad, learning_rate)\n cost_var = previous_cost - cost\n previous_cost = cost\n if iterations == 1: cost_var = 1\n cost_to_plot.append(cost)\n # print(cost)\n\n plt.plot(range(iterations), cost_to_plot, 'g-', label = 'cost')\n plt.xlabel('iterations')\n plt.ylabel('cost')\n # plt.show()\n\n predictions = lrPredict(theta, X_test)\n\n print(predictions[0:5, :])\n print(y_test[0:5, :])\n\n accuracy = np.mean([p == l for p, l in zip(predictions, y_test)])\n print(\"Accuracy = {}\".format(accuracy))\n\n pass","def fit_transform(self, X: TransformType, y=None, **fit_params) -> TransformType:\n X = self._validate_datafold_data(\n X,\n array_kwargs=dict(ensure_min_samples=max(2, self.n_kernel_eigenvectors)),\n tsc_kwargs=dict(ensure_min_samples=max(2, self.n_kernel_eigenvectors)),\n )\n self.fit(X=X, y=y, **fit_params)\n\n return self._jointly_smooth_functions_","def fit_model(self):\r\n\t\tself.mu = np.mean(self.x, axis = 0)\r\n\t\tself.sig = np.std(self.x, axis = 0)","def add_fit_data(self, model: str, tab_line, plot_data: hdu.table.TableHDU):\n # This stores the exposure time that XSPEC uses for this specific spectrum.\n if self._exp is None:\n self._exp = float(tab_line[\"EXPOSURE\"])\n\n # This is the count rate and error for this spectrum.\n self._count_rate[model] = [float(tab_line[\"COUNT_RATE\"]), float(tab_line[\"COUNT_RATE_ERR\"])]\n\n # Searches for column headers with 'Lx' in them (this has to be dynamic as the user can calculate\n # luminosity in as many bands as they like)\n lx_inds = np.where(np.char.find(tab_line.dtype.names, \"Lx\") == 0)[0]\n lx_cols = np.array(tab_line.dtype.names)[lx_inds]\n\n # Constructs a dictionary of luminosities and their errors for the different energy bands\n # in this XSPEC fit.\n lx_dict = {}\n for col in lx_cols:\n lx_info = col.split(\"_\")\n if lx_info[2][-1] == \"-\" or lx_info[2][-1] == \"+\":\n en_band = \"bound_{l}-{u}\".format(l=lx_info[1], u=lx_info[2][:-1])\n err_type = lx_info[-1][-1]\n else:\n en_band = \"bound_{l}-{u}\".format(l=lx_info[1], u=lx_info[2])\n err_type = \"\"\n\n if en_band not in lx_dict:\n lx_dict[en_band] = [0, 0, 0]\n\n if err_type == \"\":\n lx_dict[en_band][0] = Quantity(float(tab_line[col])*(10**44), \"erg s^-1\")\n elif err_type == \"-\":\n lx_dict[en_band][1] = Quantity(float(tab_line[col])*(10**44), \"erg s^-1\")\n elif err_type == \"+\":\n lx_dict[en_band][2] = Quantity(float(tab_line[col])*(10**44), \"erg s^-1\")\n\n self._luminosities[model] = lx_dict\n\n self._plot_data[model] = {\"x\": plot_data[\"X\"][:], \"x_err\": plot_data[\"XERR\"][:],\n \"y\": plot_data[\"Y\"][:], \"y_err\": plot_data[\"YERR\"][:],\n \"model\": plot_data[\"YMODEL\"][:]}","def _fit_point_lens(self):\n\n def chi2_fun(theta, event, parameters_to_fit):\n \"\"\"\n for a given event set attributes from parameters_to_fit\n (list of str) to values from theta list\n \"\"\"\n for (key, val) in enumerate(parameters_to_fit):\n setattr(event.model.parameters, val, theta[key])\n chi2 = event.get_chi2()\n if chi2 < chi2_fun.best_chi2:\n chi2_fun.best_chi2 = chi2\n return chi2\n chi2_fun.best_chi2 = 1.e10\n\n def jacobian(theta, event, parameters_to_fit):\n \"\"\"\n Calculate chi^2 gradient (also called Jacobian).\n \"\"\"\n for (key, val) in enumerate(parameters_to_fit):\n setattr(event.model.parameters, val, theta[key])\n return event.chi2_gradient(parameters_to_fit)\n\n if self._event_PSPL is None:\n self._set_event_PSPL()\n\n parameters_to_fit = [\"t_0\", \"u_0\", \"t_E\"]\n initial_guess = [self._parameters[p] for p in parameters_to_fit]\n\n failed = False\n try:\n result = op.minimize(\n chi2_fun, x0=initial_guess,\n args=(self._event_PSPL, parameters_to_fit),\n method='Newton-CG', jac=jacobian, tol=3.e-4)\n except:\n failed = True\n\n if failed:\n try:\n result = op.minimize(\n chi2_fun, x0=initial_guess,\n args=(self._event_PSPL, parameters_to_fit),\n method='Newton-CG', jac=jacobian, tol=3.e-4)\n except:\n pass\n# XXX what if fit failed (i.e., .success is False)?\n\n self._LSST_PSPL_chi2 = chi2_fun.best_chi2","def set_fit_params(self):\n\n self.p0 = np.array([self.A_arr, self.T_a])\n # initial guess at A_arr and T_a\n\n self.popt, self.pcov = curve_fit(\n self.get_eta_fit, self.T_exp, self.eta_exp, p0=self.p0\n )\n\n self.A_arr = self.popt[0]\n self.T_a = self.popt[1]\n\n self.T_array = self.T_model","def add_X_NNLO_fit(axe, xran, values, errors, fill=False, save=False):\n B = values[\"B\"]\n F_0 = values[\"F_0\"]\n\n LAMBDA4 = values[\"Lambda4\"]\n LAMBDA3 = values[\"Lambda3\"]\n # LAMBDA12 = values[\"Lambda12\"]\n km = values[\"km\"]\n kf = values[\"kf\"]\n\n x = np.linspace(xran[0], xran[1], num=500)\n\n Msqr = x * (8 * (np.pi**2) * (F_0**2))\n arg4 = LAMBDA4**2 / Msqr\n arg3 = LAMBDA3**2 / Msqr\n # arg12 = LAMBDA12**2 / Msqr\n\n l1 = -0.4\n l2 = 4.3\n\n Lambda1sqr = (phys_pion**2) * np.exp(l1)\n Lambda2sqr = (phys_pion**2) * np.exp(l2)\n\n lnLambda12sqr = (7.0 * np.log(Lambda1sqr) + 8.0 * np.log(Lambda2sqr)) / 15.0\n lambda12sqr = np.exp(lnLambda12sqr)\n\n arg12 = lambda12sqr / Msqr\n\n lm = 1.0 / 51.0 * (60.0 * np.log(arg12) - 9.0 * np.log(arg3) + 49.0)\n lf = 1.0 / 30.0 * (30.0 * np.log(arg12) + 6.0 * np.log(arg3) - 6.0 * np.log(arg4) + 23.0)\n\n y = F_0 * (1.0 + x * np.log(arg4) - 5.0 / 4.0 * (x**2) * (lf)**2 + kf * x**2)\n\n plots = []\n paramstring = \" \".join(\"${}={}$\".format(format_parameters(k), print_paren_error(float(v), float(errors[k])))\n for k, v in sorted(values.iteritems()))\n paramstring = \"$ M_\\pi<{}$\".format(values[\" M_\\pi<\"])\n plabel = \"NNLO {}\".format(paramstring)\n plabel = \"NNLO\"\n if \"cutoff\" in values:\n plabel += \" $M_\\pi < {}$\".format(values[\"cutoff\"])\n addplot(plots, axe, fill, save, x=x, y=y, params={\"label\":plabel, \"ls\":\"--\", \"lw\":4})\n\n return plots","def sklearn_model(train_data):\n X, y = train_data\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n model = LogisticRegression(\n multi_class=\"multinomial\", solver=\"lbfgs\", max_iter=1000\n )\n model.fit(X, y)\n return model","def _fit(self, X: TimeSeriesInstances, y=None) -> np.ndarray:\n raise NotImplementedError","def line_fit(x,y):\n\t# clean\n\tx = np.squeeze(x)\n\ty = np.squeeze(y)\n\t# concatenate\n\txy = np.concatenate((x[:,np.newaxis],y[:,np.newaxis]),1)\n\t# sort by x values\n\txy = xy[xy[:,0].argsort()]\n\t#print(xy)\n\tf = lambda x,m,b : m*x+b\n\tpars,_ = opt.curve_fit(f,xy[:,0],xy[:,1])\n\tm = pars[0]\n\tb = pars[1]\n\tpts = np.zeros((2,2))\n\tpts[0,0] = xy[0,0]\n\tpts[1,0] = xy[-1,0]\n\tpts[:,1] = pts[:,0]*m+b\n\tsig = np.std((xy[:,1]-f(xy[:,0],m,b)))\n\treturn pts, sig","def fit(self, X, y=None, **kwargs):\n raise NotImplementedError()","def fit(self, data):\n raise NotImplementedError(\"To be implemented in sub classes\")","def fit(\n self,\n X: FEATURES | None = None,\n y: TARGET | None = None,\n **fit_params,\n ):\n X, y = self._prepare_input(X, y)\n self._check_feature_names(X, reset=True)\n self._check_n_features(X, reset=True)\n\n self.log(f\"Fitting {self.__class__.__name__}...\", 1)\n\n return self","def do_fit(self):\n\n if (self._flag == 1):\n self._gf = [0.2]\n self._gf = self.par*(self._num_fu*len(self._sites)*2)\n x, F = self.read_from_file(\n self._sn, self._qn, self._path) # read data from the file\n # ,ftol=1.0e-7,xtol=1.0e-8)\n popt, pcov = curve_fit(\n self.modelfun, x, F, p0=self._gf, maxfev=5000)\n self._gf = popt\n\n elif (self._flag == 2):\n\n# par=[0.0]*(self._num_fu*5)\n# for j in range(self._num_fu):\n# par[j*5]=0.0*math.copysign(1,(pow(-1,j)))\n# self._gf[j*5]=0.1\n# par[j*5+1]=6.45\n# par[j*5+2]=0.0\n# par[j*5+3]=0.05\n# par[j*5+4]=1.0\n\n X, F = self.read_from_file(self._sn, self._qn, self._path) # read data from the file\n\n# height, xx, width=self.moments(F)\n# Tracer()()\n# par=[0.0]*(self._num_fu*5)\n# for j in range(self._num_fu):\n# par[j*5]=x[0,xx]\n# par[j*5]=X[0,xx]*math.copysign(1,(pow(-1,j)))\n# par[j*5+1]=X[1,xx]\n# par[j*5+2]=X[2,xx]\n# par[j*5+3]=0.007\n# par[j*5+4]=height*math.copysign(1,(pow(-1,j)))\n\n xi, yi, zi = np.mgrid[-6.5:6.5:160j, 4.0:8.9:160j, -7.5:7.5:160j]\n x, y, z = xi.flatten(), yi.flatten(), zi.flatten()\n XX = np.vstack((x, y, z))\n\n invdisttree = Invdisttree(X.T, F, leafsize=10, stat=1)\n AA = invdisttree(XX.T, nnear=130, eps=0, p=1)\n\n# aaa1,bbb1=self.detect_local_minima(-AA.reshape(xi.shape))\n# aaa2,bbb2=self.detect_local_maxima(-AA.reshape(xi.shape))\n if self.peaks==[]:\n print('\\n---------------------------------------------------------------------')\n print('Detecting maxima and minima of target function...',)\n\n peaks_min, min_coord, peaks_max, max_coord = self.detect_min_max(AA.reshape(xi.shape))\n print('done')\n print('Number of the min peaks: {}'.format(len(peaks_min)))\n print('Number of the max peaks: {}'.format(len(peaks_max)))\n print('---------------------------------------------------------------------\\n')\n # fig=plt.figure()\n # ax = fig.add_subplot(111, projection='3d')\n # ax.plot_surface(xi[:,:,60],yi[:,:,60],bbb2[:,:,60], cmap=cm.jet, linewidth=0.2)\n # plt.hold(True)\n # plt.show()\n\n if peaks_max==[]:\n peaks=np.insert(peaks_min, np.arange(len(peaks_max)), peaks_max)\n coords=np.insert(min_coord, np.arange(max_coord.shape[1]), max_coord, axis=1)\n else:\n peaks = np.insert(peaks_max, np.arange(len(peaks_min)), peaks_min)\n coords = np.insert(max_coord, np.arange(min_coord.shape[1]), min_coord, axis=1)\n\n self.peaks=peaks\n self.coords=coords\n\n par = [0.0]*(self._num_fu*5)\n j1 = 0\n aaaa = 1\n for j in range(self._num_fu):\n if (j > aaaa*self.coords.shape[1]-1):\n j1 = 0\n aaaa += 1\n par[j*5] = xi[self.coords[0, j1], self.coords[0, j1], self.coords[0, j1]]\n par[j*5+1] = yi[self.coords[1, j1], self.coords[1, j1], self.coords[1, j1]]\n par[j*5+2] = zi[self.coords[2, j1], self.coords[2, j1], self.coords[2, j1]]\n # par[j*5+3] = 0.1003+0.1000*math.copysign(1, (pow(-1, j)))\n par[j*5+3] = 0.0001\n# if j < 15:\n# par[j*5+3] = 0.00001\n# else:\n# par[j*5+3] = 0.0005\n par[j*5+4] = self.peaks[j1]\n# print(coords[0, j1], coords[1, j1], coords[2, j1])\n j1 += 1\n # popt, pcov = curve_fit(self.modelfun1, x[:,1:20000], F[1:20000],p0=par,maxfev=150000,xtol=1e-8,ftol=1e-8)\n popt, pcov = curve_fit(\n self.modelfun1, X, F, p0=par, maxfev=150000, xtol=1e-6,\n ftol=1e-8)\n # popt, pcov = curve_fit(self.modelfun1, XX, AA, p0=par)\n self._gf = popt\n# self.error=np.diagonal(pcov, offset=0)\n# print(pcov)\n else:\n # pass\n sys.exit(\"Wrong flag in do_fit\")","def fit_model(self):\n logger.info('Fitting model')\n if self.traj_dict is None:\n self.traj_dict = self.get_traj_dict()\n self.model.fit(self.traj_dict.values())","def parse_fitlog(fitlog):\n # imports\n import re\n import numpy as np\n from natsort import natsorted\n\n # initialize variables\n ingal = None\n expdisk = None\n nums = []\n\n # parse fit.log\n with open(fitlog, 'r') as f:\n # read all lines of fit.log\n for line in f:\n # get input galaxy name\n # # */galaxies/f606w_gal0.fits[1:601,1:601]\n if line.strip().startswith(\"Input\"):\n ingal = line[61:][0:-15]\n\n if '*' in line:\n bad = line\n num = re.search('(.+?)(\\d+)(\\.\\w*)', ingal).group(2)\n nums.append(num)\n write = ingal + bad\n\n # list of bad fitted galaxies\n bad = list(map(int, set(nums)))\n bad = natsort.natsorted(bad)\n\n # two groups\n bad100 = [i for i in bad if i <= 100]\n bad200 = [i for i in bad if i >= 101]\n return bad, bad100, bad200","def train_model(self):\r\n alpha, accuracy_rate = self.select_model()\r\n # Initialize logistic regression with alpha(learning rate)\r\n lg = logisticregression(C=alpha)\r\n # Train the model.\r\n lg.fit(self.training_data, self.target_data)\r\n # Save the trained model as .pkl file.\r\n joblib.dump(value=lg, filename=self.intention_id+'.pkl', compress=1)\r\n print \"Estimated Parameters of Logistic Regression\"\r\n # Estimated parameters of logistic regression.\r\n print lg.get_params()","def train_logistic_regression(train_x, train_y):\n\n logistic_regression_model = LogisticRegression(penalty='l2', C=1.0)\n logistic_regression_model.fit(train_x, train_y)\n return logistic_regression_model","def fit(self, X):\n raise NotImplementedError('Abstract method \"fit\" must be '\n 'specialised!')","def fit_model(func, xdata, ydata, yerrdata, p0):\n popt, pcov = curve_fit(func, xdata, ydata, p0=p0, sigma=yerrdata)\n # the function evaluated at the output parameters\n fvec = lambda x: func(x, *popt)\n # degree of freedom\n dof = len(xdata) - len(popt) - 1\n # chi squared\n chisq = np.sum(((ydata - fvec(xdata)) / yerrdata) ** 2)\n # one standard deviation errors on the parameters\n perr = np.sqrt(np.diag(pcov))\n infodict = {\n 'fvec': fvec,\n 'dof': dof,\n 'chisq': chisq,\n 'perr': perr\n }\n return (popt, infodict)","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def data_transformer(data, trafo, power=1.):\n\n tf = trafo.split('-')\n if tf[0] == 'NA': # only power transform\n return data\n elif tf[0] == 'pow': # log_10 transform\n return data ** power\n elif tf[0] == 'log': # log_10 transform\n return np.log10(data) ** power\n elif tf[0] == 'd1': # first difference over period dx\n i = int(tf[1])\n return (data[i:] - data[:-i]) ** power\n elif tf[0] == 'pch': # percentage change over period px\n i = int(tf[1])\n return (100. * (data[i:] - data[:-i]) / data[:-i]) ** power\n elif tf[0] == 'ld': # log difference (approx pch for small changes)\n i = int(tf[1])\n return (100 * np.log(data[i:] / data[:-i])) ** power\n else:\n raise ValueError(\"Invalid transformation value.\")","def test_loglike(dlm,Cl,noise,beam):\n lmax = Cl.shape[0]\n tt_exp = -1./2 * np.real(np.vdot(dlm.T,hp.almxfl(dlm,1/(beam[:lmax]**2*Cl[:,1]+noise[:lmax]))))\n #plt.plot(Cl[:,1])\n tt_det = - 1./2 *(np.arange(1,lmax+1)*np.log((noise[:lmax]+Cl[:,1]*beam[:lmax]**2))).sum() \n tt_f = tt_exp + tt_det\n return tt_exp,tt_det,tt_f#,Cl[:,1]","def _fit(self, dataset):\n raise NotImplementedError()","def do_stats_model(x, y):\n Xx = sm.add_constant(x)\n sm_logit = sm.Logit(y, Xx)\n result = sm_logit.fit()\n print result.summary()\n result.pred_table()\n # linear model\n print \"linear regression model:\\n\"\n sm_linear = sm.OLS(y, Xx)\n result = sm_linear.fit()\n print result.summary()"],"string":"[\n \"def fit_exp_data(x_vals, y_vals):\\n log_vals = []\\n for y in y_vals:\\n log_vals.append(math.log(y, 2)) #get log base 2\\n fit = np.polyfit(x_vals, log_vals, 1)\\n return fit, 2\",\n \"def fit(self, X):\",\n \"def fit(self, X, y, **fit_params):\\n ...\",\n \"def _fit_gas_trend(cls, x, y, fit_type=None):\\n fit_type = cls._max_trend_poly_deg if fit_type is None else fit_type\\n if fit_type == 'exp':\\n logger.debug('Using exponential fit to extrapolate {}'.format(cls._gas_name))\\n fit = np.polynomial.polynomial.Polynomial.fit(x, np.log(y), 1, w=np.sqrt(y))\\n return lambda t: np.exp(fit(t))\\n\\n else:\\n logger.debug('Using order {} polynomial to extrapolate {}'.format(fit_type, cls._gas_name))\\n fit = np.polynomial.polynomial.Polynomial.fit(x, y, deg=fit_type)\\n return fit\",\n \"def log_reg(x_train, y_train):\\n\\n log_reg_classifier = LogisticRegression(max_iter=1000, solver='lbfgs')\\n log_reg_classifier.fit(x_train, y_train)\\n return log_reg_classifier\\n\\n # log_reg_classifier.fit(x_train, y_train)\",\n \"def fit(self, X, y=..., **fit_params):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, x):\\n pass\",\n \"def fit_data(self, data):\\n d = log(-log(data))\\n return dot(d, self._fit_matrix.T)\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def fit(self, x, y): \\n # *** START CODE HERE ***\\n y = y.reshape(y.shape[0], 1)\\n y_0 = (1 - y).reshape(y.shape)\\n m = y.shape[0]\\n m_0 = np.asscalar(np.sum(y_0))\\n m_1 = np.asscalar(np.sum(y))\\n # Find phi, mu_0, mu_1, and sigma\\n phi = np.sum(y) / m\\n mu_0 = (np.sum(np.multiply(y_0, x), axis = 0, keepdims = True) / m_0) #.reshape(y.shape)\\n mu_1 = np.sum(np.multiply(y, x), axis = 0, keepdims=True) / m_1\\n sigma = getsigma(x, mu_0, mu_1, m, y, y_0)\\n # Write theta in terms of the parameters\\n sigma_inv = np.linalg.inv(sigma)\\n log_phi = np.log(np.exp(-1 * np.log(phi)) - 1)\\n theta_0 = (np.dot(np.dot(mu_0, sigma_inv), mu_0.T) - np.dot(np.dot(mu_1, sigma_inv), mu_1.T)) / 2 - log_phi\\n self.theta = np.concatenate((theta_0, np.dot(sigma_inv, (mu_1 - mu_0).T)))\\n # Compute cost\\n x_0 = np.zeros((x.shape[0], 1)) + 1\\n x_train = np.concatenate((x_0.T, x.T))\\n h_theta = sigmoid(np.dot(self.theta.T, x_train)).T\\n cost = - np.sum(np.dot(y.T, np.log(h_theta - (h_theta - 0.5) * self.eps)) + (np.dot(y_0.T, np.log(1 - h_theta + (h_theta - 0.5) * self.eps)))) / m\\n if self.verbose:\\n print(\\\"Cost: \\\" + str(cost))\\n # *** END CODE HERE ***\",\n \"def fit():\\n pass\",\n \"def fit(self, X, Y, **fit_params):\\n ...\",\n \"def fit(self, X, Y, **fit_params):\\n ...\",\n \"def fit(self, X,y):\\n pass\",\n \"def _fit(self, _X, _y):\\n\\n self.model = linear_model.LogisticRegression(penalty=self.penalty, random_state=self.seed,\\n solver='saga', n_jobs=self.n_jobs)\\n self.model.fit(_X, _y)\",\n \"def fit(self, X):\\n raise NotImplementedError\",\n \"def fit(self, x, y, logger):\\n history = self.model1.fit(x=x, y=y, batch_size=self.batch_size, epochs=self.epochs)\\n logger.log({'ValFuncLoss': history.history['loss'][-1]})\",\n \"def fit_experimental(self, m_tokens: np.ndarray, n_types: np.ndarray, gamma: float):\\n\\n # initial guess\\n M = m_tokens.max()\\n N = n_types.max()\\n p0 = (M, N)\\n\\n # fix gamma, but fit M, N to the data\\n xdata = np.array(m_tokens)\\n ydata = np.array(n_types)\\n\\n def func(m, M, N):\\n return N * self.formula(m / M, gamma)\\n\\n [M, N], _ = curve_fit(func, xdata, ydata, p0)\\n M, N = int(M), int(N)\\n self.params = (M, N, gamma)\\n\\n # return fitted model\\n return self\",\n \"def fit(self, X, Y):\\n ...\",\n \"def fit(self, x):\\n raise NotImplementedError()\",\n \"def fit_model(train_ts_dis, data, init_prior = [.5,.5], bias = True, mode = \\\"biasmodel\\\"):\\r\\n if mode == \\\"biasmodel\\\":\\r\\n #Fitting Functions\\r\\n def bias_fitfunc(rp, tsb, df):\\r\\n init_prior = [.5,.5]\\r\\n model = BiasPredModel(train_ts_dis, init_prior, ts_bias = tsb, recursive_prob = rp)\\r\\n model_likelihoods = []\\r\\n for i in df.index:\\r\\n c = df.context[i]\\r\\n trial_choice = df.subj_ts[i]\\r\\n conf = model.calc_posterior(c)\\r\\n model_likelihoods.append(conf[trial_choice])\\r\\n return np.array(model_likelihoods)\\r\\n \\r\\n def bias_errfunc(params,df):\\r\\n rp = params['rp']\\r\\n tsb = params['tsb']\\r\\n #minimize\\r\\n return abs(np.sum(np.log(bias_fitfunc(rp,tsb,df)))) #single value\\r\\n \\r\\n #Fit bias model\\r\\n #attempt to simplify:\\r\\n fit_params = lmfit.Parameters()\\r\\n fit_params.add('rp', value = .6, min = 0, max = 1)\\r\\n if bias == True:\\r\\n fit_params.add('tsb', value = 1, min = 0)\\r\\n else:\\r\\n fit_params.add('tsb', value = 1, vary = False, min = 0)\\r\\n out = lmfit.minimize(bias_errfunc,fit_params, method = 'lbfgsb', kws= {'df': data})\\r\\n lmfit.report_fit(out)\\r\\n return out.values\\r\\n \\r\\n elif mode == \\\"midline\\\":\\r\\n #Fitting Functions\\r\\n def midline_errfunc(params,df):\\r\\n eps = params['eps'].value\\r\\n context_sgn = np.array([max(i,0) for i in df.context_sign])\\r\\n choice = df.subj_ts\\r\\n #minimize\\r\\n return -np.sum(np.log(abs(abs(choice - (1-context_sgn))-eps)))\\r\\n \\r\\n #Fit bias model\\r\\n #attempt to simplify:\\r\\n fit_params = lmfit.Parameters()\\r\\n fit_params.add('eps', value = .1, min = 0, max = 1)\\r\\n midline_out = lmfit.minimize(midline_errfunc,fit_params, method = 'lbfgsb', kws= {'df': data})\\r\\n lmfit.report_fit(midline_out)\\r\\n return midline_out.values\",\n \"def fit_logregL1(data, C=.01):\\n from sklearn.linear_model import LogisticRegression\\n n,m = data.shape\\n \\n # TODO: just build (sparse) L directly & construct with it\\n # for each Xi, estimate the neighborhood of Xi using L1-reg logistic regression:\\n nbrs,th_ij,th_i = [None]*n, [None]*n, np.zeros((n,))\\n Xtr, Xtmp = toPM(data), toPM(data) # make two copies so we can modify\\n for i in range(n): \\n Xtmp[i,:] = 0. # remove ourselves\\n lr = LogisticRegression(penalty='l1',C=C,solver='liblinear').fit(Xtmp.T,Xtr[i,:])\\n nbrs[i] = np.where(np.abs(lr.coef_) > 1e-6)[1]\\n th_ij[i]= lr.coef_[0,nbrs[i]]/2.\\n th_i[i] = lr.intercept_/2.\\n Xtmp[i,:] = Xtr[i,:]; # & restore after\\n \\n # Collect single-variable factors\\n factors = [Factor(Var(i,2),[-t,t]).exp() for i,t in enumerate(th_i)]\\n\\n # Collect non-zero pairwise factors\\n for i in range(n):\\n for jj,j in enumerate(nbrs[i]):\\n # TODO: FIX: double counts edges? use different combination methods?\\n scope = [Var(i,2),Var(int(j),2)]\\n t = th_ij[i][jj]\\n factors.append( Factor(scope, [[t,-t],[-t,t]]).exp() )\\n \\n # Build a model from the factors\\n return Ising(factors)\",\n \"def fitfunc(x_unshifted, p=default()):\\n x = x_unshifted+p[4]\\n xtr, ytr, gradtr = logcontinuity(p)\\n if x < xtr:\\n return logpeak(x, p)\\n else:\\n return logpowerlaw(x, p)\",\n \"def fit(\\n self, m_tokens: np.ndarray, n_types: np.ndarray, M: int = None, N: int = None\\n ):\\n\\n # fix M, N\\n M = M or m_tokens.max()\\n N = N or n_types.max()\\n\\n # initial guess\\n p0 = 2.0\\n\\n # minimize MSE on random perturbations of gamma\\n xdata = np.array(m_tokens) / M\\n ydata = np.array(n_types) / N\\n [gamma_], _ = curve_fit(self.formula, xdata, ydata, p0)\\n self.params = (M, N, gamma_)\\n\\n # return fitted model\\n return self\",\n \"def _fit(self):\\n\\n\\t\\tclf = LogisticRegression()\\n\\t\\tclf.fit(inputs, labels)\\n\\n\\t\\treturn clf\",\n \"def fit(self, input):\\n raise NotImplementedError()\",\n \"def _model_fit_term(self):\\n if self.likelihood.YYT is None:\\n return -0.5*np.sum(np.square(np.dot(self.Li,self.likelihood.Y)))\\n else:\\n return -0.5*np.sum(np.multiply(self.Ki, self.likelihood.YYT))\",\n \"def fit_logistic_regression():\\n\\n logger.debug(\\\"Running the fit_logistic_regression function now\\\")\\n\\n #Loading the configuration\\n with open(os.path.join(\\\"config\\\",\\\"config.yml\\\"), \\\"r\\\") as f:\\n config = yaml.safe_load(f)\\n\\n #Loading and pre processing the data\\n logger.debug(\\\"Loading and pre processing the data\\\")\\n train_df = load_data(config[\\\"load_data\\\"][\\\"train_file\\\"])\\n train_df = pre_process_data(train_df, resample = True, resample_count = 500000)\\n\\n #Defining Pipeline\\n pipeline = Pipeline([\\n ('tfidf', TfidfVectorizer(analyzer='word', token_pattern=r'[A-Za-z0-9@-]+')),\\n ('model', LogisticRegression(random_state=12345, verbose = 1, solver = 'saga')),\\n ])\\n\\n #Defining parameters to vary\\n parameters = {\\n 'tfidf__max_df': (0.25, 0.5, 0.75),\\n 'tfidf__max_features': (None, 5000, 10000, 50000),\\n 'tfidf__ngram_range': ((1, 1), (1, 2)),\\n 'model__C': (0.01, 1, 100)\\n }\\n\\n scoring_list = [\\\"accuracy\\\", \\\"f1\\\", \\\"precision\\\", \\\"recall\\\", \\\"roc_auc\\\"]\\n \\n #Performing 5fold CV to determine best hyperparameters\\n model = GridSearchCV(pipeline, parameters, cv=5,\\n n_jobs=-1, verbose=1, scoring=scoring_list, refit='f1',)\\n\\n t0 = datetime.datetime.now()\\n\\n model.fit(train_df[\\\"Review\\\"].tolist(), train_df[\\\"Ratings\\\"].to_numpy())\\n \\n logger.info(\\\"Grid Search performed in {}\\\".format(str(datetime.datetime.now()-t0)))\\n\\n #Saving results\\n res_df = pd.DataFrame(model.cv_results_)\\n res_df.to_csv(os.path.join(config[\\\"summary_stats\\\"][\\\"save_location\\\"], \\\"LogisticRegressionResults.csv\\\"))\\n \\n #Saving the model\\n pickle.dump(model, open(os.path.join(config[\\\"models\\\"][\\\"save_location\\\"], \\\"LogisticRegression.pkl\\\"),'wb'))\\n\\n return\",\n \"def fit(model, input: str, output: str):\\n print(f\\\"Fitting model of type: {model}\\\")\\n\\n # Define the model. Use a randomized search to efficiently explore the\\n # hyperparameter space in a limited time.\\n if model == \\\"logistic\\\":\\n # Primal logistic regression\\n param_dist = {\\n 'C': loguniform(0.1, 100), 'max_iter': [250], 'fit_intercept': [True],\\n 'intercept_scaling': [1], 'penalty': ['l2'], 'tol': loguniform(1e-6, 1e-4)\\n }\\n mdl_cv = RandomizedSearchCV(LogisticRegression(solver='lbfgs'), param_dist, cv=3, refit=True, verbose=2, n_iter=10)\\n elif model == \\\"rand_forest\\\":\\n # Random Forest classifier\\n param_dist = {'max_depth': randint(3,8), 'max_features': randint(2,9), 'n_estimators': randint(50, 100),\\n 'min_samples_split': randint(3, 7)}\\n mdl_cv = RandomizedSearchCV(RandomForestClassifier(), param_dist, cv=3, refit=True, verbose=2, n_iter=10)\\n elif model == \\\"gradient_boost\\\":\\n # Extreme Gradient Boost classifier\\n param_dist = {'max_depth': [3, 4], 'gamma': loguniform(1e-3, 1e-2), 'min_child_weight': randint(1, 10),\\n 'learning_rate': loguniform(0.05, 0.3), 'n_estimators': randint(10, 40)}\\n mdl_cv = RandomizedSearchCV(XGBClassifier(), param_dist, cv=3, refit=True, verbose=2, n_iter=10)\\n else:\\n raise NotImplementedError(f\\\"Don't know how to train model of type: {model}.\\\\nValid options are: logistic, rand_forest, gradient_boost.\\\")\\n\\n # Define x (input data) and y (target data)\\n df = pd.read_csv(input)\\n x = df.loc[:, df.columns != 'Exited']\\n y = df.Exited\\n print(f\\\"Data has x.shape = {x.shape} and y.shape = {y.shape}\\\")\\n\\n # Fit the model with randomized search\\n mdl_cv.fit(x, y)\\n\\n # Print some results\\n print(\\\"Best score:\\\", mdl_cv.best_score_)\\n print(\\\"Best params:\\\", pprint.pformat(mdl_cv.best_params_))\\n\\n # Save to data store\\n os.makedirs(os.path.dirname(output), exist_ok=True)\\n with open(output, \\\"wb\\\") as f:\\n joblib.dump(mdl_cv.best_estimator_, f)\",\n \"def fit_transform(self, X, y=...):\\n ...\",\n \"def kentaDataTofLogRhoFit2():\\n func = lambda lr: getTRollFunc(25.0, 0.0, 14.1875 - 0.07, .3125)(lr) \\\\\\n + getTRollFunc(5.0, 0.01, 11.5, .25)(lr)\\n return func\",\n \"def fitexp(xdata,ydata,fitparams=None,domain=None,showfit=False,showstartfit=False,label=\\\"\\\"):\\n if domain is not None:\\n fitdatax,fitdatay = selectdomain(xdata,ydata,domain)\\n else:\\n fitdatax=xdata\\n fitdatay=ydata\\n if fitparams is None: \\n fitparams=[0.,0.,0.,0.]\\n fitparams[0]=fitdatay[-1]\\n fitparams[1]=fitdatay[0]-fitdatay[-1]\\n fitparams[1]=fitdatay[0]-fitdatay[-1]\\n fitparams[2]=fitdatax[0]\\n fitparams[3]=(fitdatax[-1]-fitdatax[0])/5.\\n #print fitparams\\n p1 = fitgeneral(fitdatax, fitdatay, expfunc, fitparams, domain=None, showfit=showfit, showstartfit=showstartfit,\\n label=label)\\n return p1\",\n \"def fit(self, x, y):\\n # Note Logistic Regression Runtime\\n start_time = time.time()\\n\\n # Converting Pandas DataFrame to Numpy arrays\\n if not type(x).__module__ == np.__name__:\\n x = x.to_numpy()\\n if not type(y).__module__ == np.__name__:\\n y = y.to_numpy()\\n\\n # Insert a column of 1 in the feature vector X for the bias term in the weights\\n x = np.insert(x,0,1,axis=1)\\n \\n # Verify dimension of input\\n if len(x) != len(y):\\n print(\\\"The number of input features vector must be to be the same as the number of target variables\\\")\\n else:\\n losses = self.gradient_descent(x,y)\\n\\n # Note end time\\n end_time = time.time()\\n\\n # Log runtime\\n print(\\\"Logistic Regression training time: {0:.2f}s\\\".format(end_time - start_time))\\n \\n return losses\",\n \"def train_logistic_regression(x_train, y_train, learning_rate, fit_intercept=False, max_iter=500):\\r\\n if fit_intercept:\\r\\n intercept = np.ones(x_train.shape[0], 1)\\r\\n x_train = np.hstack((intercept, x_train)) # hstacks merges 2 arrays column wise\\r\\n weights = np.zeros(x_train.shape[1])\\r\\n for iteration in range(max_iter):\\r\\n weights = update_weights(x_train, y_train, weights, learning_rate)\\r\\n # printing cost for every 100 iterations\\r\\n if iteration % 100 == 0:\\r\\n print(calculate_cost(x_train, y_train, weights))\\r\\n return weights\",\n \"def logistic_regression(y, tx, initial_w, max_iters, gamma):\\n return least_squares_SGD(y, tx, initial_w, max_iters, gamma, loss_function=logistic_loss, gradient=logistic_grad)\",\n \"def _model_fit_term(self):\\r\\n if self.likelihood.YYT is None:\\r\\n tmp, _ = dtrtrs(self.L, np.asfortranarray(self.likelihood.Y), lower=1)\\r\\n return -0.5 * np.sum(np.square(tmp))\\r\\n # return -0.5 * np.sum(np.square(np.dot(self.Li, self.likelihood.Y)))\\r\\n else:\\r\\n return -0.5 * np.sum(np.multiply(self.Ki, self.likelihood.YYT))\",\n \"def add_fit_data(self, model: str, tab_line: dict, lums: dict, obs_order: dict):\\n # Just headers that will always be present in tab_line that are not fit parameters\\n not_par = ['MODEL', 'TOTAL_EXPOSURE', 'TOTAL_COUNT_RATE', 'TOTAL_COUNT_RATE_ERR',\\n 'NUM_UNLINKED_THAWED_VARS', 'FIT_STATISTIC', 'TEST_STATISTIC', 'DOF']\\n\\n # Checking that we have the expected amount of data passed in\\n if len(tab_line) != self._num_ann:\\n raise ValueError(\\\"The dictionary passed in with the fit results in it does not have the same\\\"\\n \\\" number of entries as there are annuli.\\\")\\n elif len(lums) != self._num_ann:\\n raise ValueError(\\\"The dictionary passed in with the luminosities in it does not have the same\\\"\\n \\\" number of entries as there are annuli.\\\")\\n\\n for ai in range(0, self._num_ann):\\n # Various global values of interest\\n self._total_exp[ai] = float(tab_line[ai][\\\"TOTAL_EXPOSURE\\\"])\\n self._total_count_rate[ai][model] = [float(tab_line[ai][\\\"TOTAL_COUNT_RATE\\\"]),\\n float(tab_line[ai][\\\"TOTAL_COUNT_RATE_ERR\\\"])]\\n self._test_stat[ai][model] = float(tab_line[ai][\\\"TEST_STATISTIC\\\"])\\n self._dof[ai][model] = float(tab_line[ai][\\\"DOF\\\"])\\n self._obs_order[ai][model] = obs_order[ai]\\n\\n # The parameters available will obviously be dynamic, so have to find out what they are and then\\n # then for each result find the +- errors.\\n par_headers = [n for n in tab_line[ai].dtype.names if n not in not_par]\\n mod_res = {}\\n for par in par_headers:\\n # The parameter name and the parameter index used by XSPEC are separated by |\\n par_info = par.split(\\\"|\\\")\\n par_name = par_info[0]\\n\\n # The parameter index can also have an - or + after it if the entry in question is an uncertainty\\n if par_info[1][-1] == \\\"-\\\":\\n ident = par_info[1][:-1]\\n pos = 1\\n elif par_info[1][-1] == \\\"+\\\":\\n ident = par_info[1][:-1]\\n pos = 2\\n else:\\n ident = par_info[1]\\n pos = 0\\n\\n # Sets up the dictionary structure for the results\\n if par_name not in mod_res:\\n mod_res[par_name] = {ident: [0, 0, 0]}\\n elif ident not in mod_res[par_name]:\\n mod_res[par_name][ident] = [0, 0, 0]\\n\\n mod_res[par_name][ident][pos] = float(tab_line[ai][par])\\n\\n # Storing the fit results\\n self._fit_results[ai][model] = mod_res\\n # And now storing the luminosity results\\n self._luminosities[ai][model] = lums[ai]\",\n \"def ts_fit(series: TimeSeries) -> TimeSeries:\\n pass\",\n \"def logreg_train(model, X, Y, batch=32, epochs=50, valid_split=0.2):\\r\\n\\thistory = model.fit(\\r\\n\\t\\tX, Y,\\t\\t\\t\\t# inputs & labels\\r\\n\\t\\tbatch_size=batch,\\r\\n\\t\\tepochs=epochs,\\r\\n\\t\\tvalidation_split=0.2\\r\\n\\t)\\r\\n\\r\\n\\treturn history\",\n \"def analysis(houses:pd.DataFrame) -> None:\\n \\n \\\"\\\"\\\"\\n #Me just trying to fit the data without any outside influences\\n f= f'SELLER_HOUSE ~ SQFT_PER + PRICE + C(LOCATION)' \\n result= smf.logit(formula= str(f), data= houses).fit()\\n print(result.summary2())\\n y= ['SELLER_HOUSE']\\n x= ['SQFT_PER', 'PRICE', 'LOC_699 - Not Defined', 'LOC_AA - Airport Area', 'LOC_CG - Columbus Grove',\\n 'LOC_CV - Cypress Village', 'LOC_EASTW - Eastwood', 'LOC_EC - El Camino Real', 'LOC_GP - Great Park',\\n 'LOC_IRSP - Irvine Spectrum', 'LOC_LGA - Laguna Altura', 'LOC_NK - Northpark', 'LOC_NW - Northwood', \\n 'LOC_OC - Oak Creek', 'LOC_OH - Orchard Hills', 'LOC_OT - Orangetree', 'LOC_PS - Portola Springs', \\n 'LOC_QH - Quail Hill', 'LOC_SH - Shady Canyon', 'LOC_SJ - Rancho San Joaquin', 'LOC_STG - Stonegate', \\n 'LOC_Stonegate', 'LOC_TR - Turtle Rock', 'LOC_TRG - Turtle Ridge', 'LOC_UP - University Park',\\n 'LOC_UT - University Town Center', 'LOC_WB - Woodbridge', 'LOC_WD - Woodbury', \\n 'LOC_WI - West Irvine', 'LOC_WN - Walnut (Irvine)', 'LOC_WP - Westpark']\\n x_train, x_test, y_train, y_test= train_test_split(houses[x], houses[y], test_size= 0.3, random_state= 500)\\n logreg = LogisticRegression()\\n logreg.fit(x_train, y_train.values.ravel())\\n y_pred= logreg.predict(x_test)\\n print('Accuracy of logistic regression classifier on test set:', round(logreg.score(x_test, y_test), 3))\\n # This model is really bad\\n \\n \\\"\\\"\\\"\\n \\n \\\"\\\"\\n houses= houses.drop(['DAYS_ON_MARKET', 'ADDRESS', 'LOCATION',\\n 'STATUS', 'PROPERTY_TYPE', 'ZIP_CODE'], axis= 1)\\n columns= houses.columns.values.tolist()\\n y= ['SELLER_HOUSE']\\n x= [i for i in columns if i not in y]\\n \\n # Over Sampling Using SMOTE \\n x_train, _, y_train, _= train_test_split(houses[x], houses[y], test_size= 0.3, random_state= 500)\\n x_columns= x_train.columns\\n \\n os= SMOTE(random_state= 0)\\n os_x, os_y= os.fit_sample(x_train, y_train)\\n os_x= pd.DataFrame(data= os_x, columns= x_columns)\\n os_y= pd.DataFrame(data= os_y, columns= y)\\n \\n \\n #Recursive Feature Elimination\\n logreg= LogisticRegression(max_iter= 600)\\n rfe= RFE(logreg, 20)\\n rfe= rfe.fit(os_x, os_y.values.ravel())\\n \\n lst= [i for count, i in enumerate(x) if rfe.support_[count] == True]\\n X= os_x[lst]\\n Y= os_y['SELLER_HOUSE']\\n \\n \\n #logit_model= sm.Logit(Y, X)\\n #result= logit_model.fit()\\n #print(result.summary2()) # Model choosen by RCE\\n \\n #These are features have a p-value less than 0.05\\n final_x= ['BATHS', 'ZIP_92602.0', 'ZIP_92618.0', 'LOC_699 - Not Defined', 'LOC_TR - Turtle Rock', 'LOC_WD - Woodbury']\\n #final_x= ['ZIP_92602.0', 'LOC_699 - Not Defined', 'LOC_TR - Turtle Rock', 'LOC_WD - Woodbury']\\n X2= os_x[final_x]\\n \\n logit_model2= sm.Logit(Y, X2)\\n result2= logit_model2.fit()\\n print(result2.summary2()) # Final Model\\n \\n x_train2, x_test2, y_train2, y_test2= train_test_split(X2, Y, test_size= 0.3, random_state= 500)\\n logreg = LogisticRegression()\\n logreg.fit(x_train2, y_train2)\\n \\n y_pred= logreg.predict(x_test2)\\n print('Accuracy of logistic regression classifier on test set:', round(logreg.score(x_test2, y_test2), 2))\\n \\n conf_matrix= confusion_matrix(y_test2, y_pred)\\n print(conf_matrix)\\n # So 22+61 correct predictions and 13+44 wrong predictions\\n \\n logit_roc_auc = roc_auc_score(y_test2, logreg.predict(x_test2))\\n fpr, tpr, _ = roc_curve(y_test2, logreg.predict_proba(x_test2)[:,1])\\n plt.figure()\\n plt.plot(fpr, tpr, label='Logistic Regression (area = %0.2f)' % logit_roc_auc)\\n plt.plot([0, 1], [0, 1],'r--')\\n plt.xlim([0.0, 1.0])\\n plt.ylim([0.0, 1.05])\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.title('Receiver operating characteristic')\\n plt.legend(loc=\\\"lower right\\\")\\n plt.show()\\n \\\"\\\"\",\n \"def fit(self, Y):\\n raise NotImplementedError\",\n \"def kentaDataTofLogRhoFit1():\\n func = lambda lr: getTRollFunc(20.0, 0.0, 14.25 - 0.07, .25)(lr) \\\\\\n + getTRollFunc(10.0, 0.01, 11.5, .25)(lr)\\n return func\",\n \"def my_loglike(theta, x, data, sigma):\\n\\n model = my_model(theta, x)\\n\\n return -0.5*len(x)*np.log(2*math.pi*sigma**2) - (0.5/sigma**2) * np.sum((data-model)**2)\",\n \"def fit(self):\\n # Initialize parameter estimates\\n if self.estimator is not None:\\n param_estimates = self.estimator(self.xf, self.yf)\\n else: param_estimates = None\\n self.popt, self.pcov = curve_fit(self.model, self.xf, self.yf, \\n p0=param_estimates)\\n self.fit_history.append({\\\"popt\\\" : self.popt, \\\"pcov\\\" : self.pcov})\",\n \"def fit(self, X):\\n self._fit_X = X\",\n \"def sas_curve_fit(x, y, calc_type):\\n\\n result = {}\\n\\n n = len(x)\\n\\n if (n == 0) or (len(y) == 0):\\n err = \\\"Error: No values to fit in \\\" + calc_type + \\\" calculation\\\\n\\\"\\n raise Exception(err)\\n #result['error'] = err\\n else:\\n # Linear fit to the input x and y values\\n #fit_coeffs = np.polyfit(x, y, 1)\\n fit_coeffs = sps.linregress(x, y)\\n \\n result['fit'] = fit_coeffs\\n\\n if (calc_type == 'rxs1') or (calc_type == 'rxs2'):\\n # Cross section Rxs1/Rxs2 calculated from fits of q^2 vs ln(I*q)\\n # Rxs?^2 = 2 * gradient\\n result['r'] = np.sqrt(2 * abs(fit_coeffs[0]))\\n #result['rerr'] = np.abs(np.sqrt(2 * abs(fit_coeffs[4]))-result['r'])\\n result['rerr'] = np.abs(np.sqrt(2 * abs(fit_coeffs[0] + fit_coeffs[4])) - result['r'])\\n result['i'] = None\\n else:\\n # Assume a standard Guinier fit of q^2 vs ln(I):\\n # Rg^2 = 3 * gradient\\n # Io = exp(intercept)\\n std_err_fit = fit_coeffs[4]\\n # Analysis below on the basis that scipt.stats.linregress\\n # gives the std error on the slope rather than of the regression\\n # This gives result inline with old SJP code - needs chacking as \\n # seems odd\\n result['r'] = np.sqrt(3 * abs(fit_coeffs[0]))\\n result['rerr'] = np.abs(np.sqrt(3 * abs(fit_coeffs[0] + std_err_fit)) - result['r'])\\n result['i'] = np.exp(fit_coeffs[1])\\n result['ierr'] = np.exp(fit_coeffs[1] + (std_err_fit * np.sqrt(np.sum(x**2))/np.sqrt(n))) - result['i']\\n\\n return result\",\n \"def fit(self, X, y, X_val=None, y_val=None):\\n #Adding an extra column of 1s for constant term\\n n_samples = X.shape[0]\\n n_features = X.shape[1]\\n temp = np.empty((n_samples, n_features+1), dtype=float) # adding extra 1s to X\\n for i in range(n_samples):\\n temp[i] = np.append(X[i], 1)\\n X = temp\\n y = y.reshape((-1,1)) # reshaping y \\n\\n try: # if validation set is present\\n if X_val.all() != None and y_val.all() != None:\\n # adding extra 1s and reshaping y\\n val_n_samples = X_val.shape[0]\\n val_n_features = X_val.shape[1]\\n temp = np.empty((val_n_samples, val_n_features+1), dtype=float)\\n for i in range(val_n_samples):\\n temp[i] = np.append(X_val[i], 1)\\n X_val = temp\\n y_val = y_val.reshape((-1,1))\\n except AttributeError:\\n pass\\n\\n self.theta = np.zeros((n_features+1,1)) # these are the model parameters\\n self.train_history = np.zeros(self.n_iterations) # initialising array store train loss history\\n self.val_history = np.zeros(self.n_iterations) # initialising array store val loss history\\n \\n if self.cost_fn == 'RMSE':\\n self.gradient_descent_rmse(X, y, X_val, y_val) # RMSE gradient call\\n h_theta_of_x = np.dot(X, self.theta)\\n cost = self.RMSE(n_samples, h_theta_of_x, y) # final RMSE loss\\n # print('training_loss', cost)\\n\\n elif self.cost_fn == 'MAE':\\n self.gradient_descent_mae(X, y, X_val, y_val) # MAE gradient call\\n h_theta_of_x = np.dot(X, self.theta)\\n cost = self.MAE(n_samples, h_theta_of_x, y) # final MSE loss\\n # print('training_loss', cost)\\n\\n\\n # fit function has to return an instance of itself or else it won't work with test.py\\n return self\",\n \"def fit_power_law(self, y, cut=0.6, interactive=True):\\n\\n self.fit_cut = cut\\n\\n start = np.where(y > 1e-6)[0][0] # find first non-zero value since we will take the log\\n end = int(self.fit_cut * len(self.time_uniform)) # fit up until a fraction, cut, of the trajectory\\n # print(y[start:end])\\n # exit()\\n\\n # fit line to linear log plot\\n A = Poly_fit.poly_fit(np.log(self.time_uniform[start:end]), np.log(y[start:end]), 1)[-1]\\n\\n return [np.exp(A[0]), A[1]]\",\n \"def test_genextreme_fit(self):\\n p = generic.fit(self.genextreme, \\\"genextreme\\\")\\n np.testing.assert_allclose(p, (0.20949, 297.954091, 75.7911863), 1e-5)\",\n \"def fit(self, x, y):\\n def initiate_theta(dim):\\n self.theta = np.zeros(dim)\\n # print('self.theta initiated is {}'.format(self.theta))\\n \\n def implement_sigmoid(x):\\n if self.theta is None:\\n initiate_theta(x.shape[1])\\n z = np.matmul(np.transpose(self.theta), np.transpose(x))\\n return 1/(np.ones(x.shape[0]) + np.exp(-z))\\n \\n def implement_partial_loss(x, y):\\n return -np.matmul(np.transpose(y - implement_sigmoid(x)), x)/x.shape[0]\\n \\n def implement_transposed_hess(x):\\n sigmoid_hadamard = implement_sigmoid(x) * (np.ones(x.shape[0]) - implement_sigmoid(x))\\n hess2 = np.diag(sigmoid_hadamard)\\n hess = np.matmul(hess2,x)\\n hess = np.matmul(np.transpose(x),hess)/x.shape[0]\\n hess_inverse = np.linalg.inv(hess)\\n return hess_inverse\\n \\n def train(x, y):\\n count = 0\\n if self.theta is None:\\n initiate_theta(x.shape[1])\\n while count < self.max_iter:\\n if self.verbose:\\n loss_y1 = np.matmul(np.transpose(y), np.log(implement_sigmoid(x)))\\n loss_y0 = np.matmul(np.transpose(np.ones(x.shape[0]) - y), np.log(np.ones(x.shape[0]) - implement_sigmoid(x)))\\n loss = -(loss_y1 + loss_y0 )/x.shape[0]\\n print('Average empirical loss for step {} is {}'.format(count, loss))\\n delta = np.matmul(implement_transposed_hess(x), implement_partial_loss(x, y))\\n new_theta = self.theta - delta * self.step_size\\n delta_theta = np.linalg.norm(new_theta - self.theta)\\n # print('delta is {}'.format(delta_theta))\\n if delta_theta < self.eps:\\n return new_theta\\n else:\\n self.theta = new_theta\\n count += 1\\n return self.theta\\n \\n return train(x, y)\",\n \"def fitting(x_value, target_value, model_function, fitting_method, type_of_fit):\\n if len(target_value) != len(x_value):\\n raise ValueError(\\\"Value length not match\\\")\\n\\n fig = plt.figure()\\n\\n parameters, _ = curve_fit(\\n model_function, x_value, target_value, method=fitting_method)\\n\\n xspace = np.linspace(x_value[0], x_value[len(x_value) - 1], 100)\\n if len(parameters) == 1:\\n fit_A = parameters[0]\\n fit_curve = model_function(xspace, fit_A)\\n elif len(parameters) == 2:\\n fit_A = parameters[0]\\n fit_B = parameters[1]\\n fit_curve = model_function(xspace, fit_A, fit_B)\\n elif len(parameters) == 3:\\n fit_A = parameters[0]\\n fit_B = parameters[1]\\n fit_C = parameters[2]\\n fit_curve = model_function(xspace, fit_A, fit_B, fit_C)\\n else:\\n raise ValueError(\\\"Function do not support that Model\\\")\\n\\n # making plot\\n plt.plot(x_value, target_value, 'o', label='cpu')\\n plt.plot(xspace, fit_curve, '-', label='fit')\\n plt.xlabel(\\\"cores_per_node\\\")\\n plt.ylabel(\\\"time/s\\\")\\n plt.title(type_of_fit + \\\"_Fitting Plot\\\")\\n plt.legend()\\n plt.savefig(type_of_fit + \\\"_fit.jpg\\\")\\n plt.close()\\n\\n return parameters\",\n \"def get_fit(self, space=False):\\n\\n if space:\\n model_type = 'space'\\n else:\\n model_type = 'risk'\\n\\n fit_type = 'likelihood'\\n\\n fitter = self.fits[model_type].linear_fits[fit_type]\\n\\n return fitter\",\n \"def logfit(N, err):\\n import numpy as np\\n\\n if len(N) != len(err):\\n raise ValueError('Convergence order args do not have same length')\\n\\n A = np.ones([len(err), 2])\\n B = np.ones([len(err), 1])\\n # ERR = A*N + B\\n for i in range( len(N) ) :\\n A[i,0] = np.log10(N[i])\\n B[i] = np.log10(err[i])\\n\\n x, residuals, rank, singval = np.linalg.lstsq(A, B, rcond=None)\\n\\n return x\",\n \"def fit(self,x):\\n tokens = x['token'].to(self.device)\\n attn_masks = x['attn_mask'].to(self.device)\\n tags = x['label'].to(self.device).unsqueeze(dim=-1)\\n\\n tag_prob = self._bert_encoder(tokens, attn_masks)\\n\\n tag_prob_log = tag_prob.gather(-1,tags).squeeze(dim=-1)\\n loss = -torch.mean(torch.sum(torch.log(tag_prob_log),dim=-1),dim=0)\\n return loss\",\n \"def get_investigation_data(self, gamma, dps, gamma_err=0, dps_err=0, fit_type='exponential'):\\n if fit_type == 'exponential':\\n coherence_length = 2 * np.log(2) / (gamma / dps)\\n\\n # fourier transform of an exponential decay with decay constant g = lorentzian with hwhm g\\n # decay constant = 1/g\\n # Fourier(exp(-2pi k0 x)) = (1/pi)(k0 / (k^2 + k0^2))\\n # 2 pi k0 = g, k0 = hwhm = g / (2 pi)\\n # fwhm = g / pi (*c)\\n spectral_width_hz = (gamma / dps) / np.pi * constants.c\\n\\n elif fit_type == 'lorentzian':\\n coherence_length_in_motor_steps = 2 * gamma\\n coherence_length = coherence_length_in_motor_steps * dps # in metres\\n # TODO: change this to in terms of the exponential decay.\\n # but the lorentzian curve fit on the interferogram has no physical meaning anyway\\n spectral_width_hz = constants.c / (np.pi * coherence_length)\\n\\n elif fit_type == 'gaussian':\\n # gamma is actually sigma\\n coherence_length_in_motor_steps = 2 * np.sqrt(2 * np.log(2)) * gamma\\n coherence_length = coherence_length_in_motor_steps * dps # in metres\\n\\n # spectral_width_hz = constants.c / (np.pi * coherence_length)\\n # new sigma is pi / sigma\\n # idk why it's 1/ (pi * newsigma) and not pi / newsigma\\n # TODO: Figure out why gaussian spec width is so narrow.\\n spectral_width_hz = constants.c *2* np.sqrt(2 * np.log(2)) / (np.pi * gamma * dps)\\n # print(\\\"%.4e, %.4e\\\" % (constants.c * 2 * np.sqrt(2 * np.log(2)) * np.pi / (gamma * dps), constants.c / (np.pi * coherence_length)))\\n\\n\\n\\n # steps between peaks = 1 wavelength = 1 / freq\\n # dps = known_wavelength / (2 * 1 wavelength) = freq * known_wavelength / 2\\n frequencies_per_motor_step, magnitudes = self.get_frequencies_with_fourier(fit=False)\\n wavelengths = 2 * dps / frequencies_per_motor_step\\n scipy_fit, calc_fit = self.find_best_fit_gaussian(x_y=(wavelengths, magnitudes))\\n wavelengths_mean, wavelengths_std = scipy_fit[1], scipy_fit[2]\\n mean_wavelength = wavelengths_mean\\n spectral_width_m = mean_wavelength ** 2 / constants.c * spectral_width_hz\\n\\n frequencies = constants.c / wavelengths\\n\\n (amplitude, mean, gamma) = self.find_best_fit_lorentzian(x_y=(frequencies, magnitudes))\\n scipy_fit = (amplitude, mean, gamma)\\n frequencies_mean, frequencies_std = scipy_fit[1], scipy_fit[2]\\n\\n ## This section plots the fits to the FT\\n # plt.plot(frequencies, magnitudes, '.')\\n #\\n # x_min, x_max = plt.xlim()\\n # lorentzian_fit = lambda fit_params, x: fit_params[0] / (1 + ((x - fit_params[1]) / fit_params[2]) ** 2)\\n # fit_x = np.linspace(x_min, x_max, 10000)\\n # optimised_lorentzian_fit = lorentzian_fit(scipy_fit, fit_x)\\n # fwhm = 2 * scipy_fit[2]\\n # plt.plot(fit_x, optimised_lorentzian_fit, 'k', label='SciPy fit (Lorentzian)\\\\nFWHM: %.4e' % fwhm)\\n #\\n # gaussian_fit = lambda fit_params, x: fit_params[0] * np.exp(-(x - fit_params[1]) ** 2 / (2 * fit_params[2] ** 2))\\n # scipy_fit, calc_fit = self.find_best_fit_gaussian(also_use_scipy=True, x_y=(frequencies, magnitudes))\\n # optimised_gaussian_fit = gaussian_fit(scipy_fit, fit_x)\\n # fwhm = 2 * np.sqrt(2 * np.log(2)) * scipy_fit[2]\\n # plt.plot(fit_x, optimised_gaussian_fit, 'g', label='SciPy fit (G)\\\\nFWHM: %.4e' % fwhm)\\n # plt.legend()\\n #\\n # plt.show()\\n\\n print('With Fourier:')\\n print('Spectral Width (m): %.5e' % spectral_width_m)\\n print('Coherence length: %.5e' % coherence_length)\\n print('Mean frequencies: %.5e pm %.5e' % (frequencies_mean, frequencies_std))\\n print('Mean wavelength: %.5e pm %.5e' % (mean_wavelength, wavelengths_std))\\n\\n\\n\\n steps, unique_steps_between_peaks, unique_steps_counts = self.get_steps_between_peaks()\\n distances = dps * steps\\n # distances_mean, distances_std = np.mean(distances), np.std(distances)\\n wavelengths = distances * 2\\n wavelengths_mean, wavelengths_std = np.mean(wavelengths), np.std(wavelengths)\\n\\n mean_wavelength = wavelengths_mean\\n\\n frequencies = constants.c / wavelengths\\n frequencies_mean, frequencies_std = np.mean(frequencies), np.std(frequencies)\\n\\n spectral_width_m = mean_wavelength ** 2 / constants.c * spectral_width_hz\\n print(\\\"With Step calculation\\\")\\n print('Spectral Width (Hz): %.5e' % spectral_width_hz)\\n print('Spectral Width (m): %.5e' % spectral_width_m)\\n\\n if gamma_err == 0 and dps_err == 0:\\n print('Coherence length: %.5e' % coherence_length)\\n print('Spectral width (Hz): %.5e' % spectral_width_hz)\\n print('Mean frequencies: %.5e pm %.5e' % (frequencies_mean, frequencies_std))\\n print('Mean wavelength: %.5e pm %.5e' % (mean_wavelength, wavelengths_std))\\n else:\\n print(dps_err, 'asdasdasfaegsegeg')\\n coherence_length_err = dps_err / dps * coherence_length\\n spectral_width_err = np.sqrt((coherence_length_err / (constants.c * mean_wavelength ** 2)) ** 2 +\\n (2 * coherence_length / (constants.c * mean_wavelength ** 3)) ** 2)\\n print(mean_wavelength ** 2 / coherence_length, 'dlambda')\\n print('Coherence length: %.5e pm %.5e' % (coherence_length, coherence_length_err))\\n print('Spectral width (Hz): %.5e pm %.5e' % (spectral_width_hz, spectral_width_err))\\n print('Mean frequencies: %.5e pm %.5e' % (frequencies_mean, frequencies_std))\\n print('Mean wavelength: %.5e pm %.5e' % (mean_wavelength, wavelengths_std))\\n\\n data = {'coherence_length': coherence_length,\\n 'spectral_width_hz': spectral_width_hz,\\n 'spectral_width_m': spectral_width_m,\\n 'mean_wavelength': mean_wavelength,\\n 'mean_frequency': frequencies_mean,\\n }\\n return data\",\n \"def fit(self, x):\\n tokens = x['token'].to(self.device)\\n attn_masks = x['attn_mask'].to(self.device)\\n label = x['label'].to(self.device)\\n\\n output = self.bert(tokens, attention_mask=attn_masks, labels=label)\\n loss = output['loss']\\n # logits = output['logits']\\n # tag_prob = self.Softmax(logits)\\n \\n return loss\",\n \"def fit(self, X, y, X_val=None, y_val=None):\\n\\n # fit function has to return an instance of itself or else it won't work with test.py\\n # adding extra 1s and reshaping y\\n n_samples = X.shape[0]\\n n_features = X.shape[1]\\n temp = np.empty((n_samples, n_features+1), dtype=float)\\n for i in range(n_samples):\\n temp[i] = np.append(X[i], 1)\\n X = temp\\n\\n try: # if validation set is present\\n if X_val.all() != None and y_val.all() != None:\\n # adding extra 1s and reshaping y\\n val_n_samples = X_val.shape[0]\\n val_n_features = X_val.shape[1]\\n temp = np.empty((val_n_samples, val_n_features+1), dtype=float)\\n for i in range(val_n_samples):\\n temp[i] = np.append(X_val[i], 1)\\n X_val = temp\\n except AttributeError:\\n pass\\n\\n self.theta = np.zeros((n_features+1,1)) # these are the model parameters\\n self.train_history = np.zeros(self.n_iterations)\\n self.val_history = np.zeros(self.n_iterations)\\n y = y.reshape((-1,1))\\n\\n if self.cost_fn == 'Batch':\\n self.batch_gradient_descent(X, y, X_val, y_val) # Batch\\n elif self.cost_fn == 'Stochastic':\\n self.stochastic_gradient_descent(X, y, X_val, y_val) # Stochastic\\n\\n h_theta_of_x = self.sigmoid(np.dot(X, self.theta)) # predicted value\\n predicted = np.around(h_theta_of_x) # rounding off according to 0.5\\n accuracy = (predicted == y).all(axis=1).mean() # calculating accuracy of model\\n train_cost = self.log_loss(n_samples, h_theta_of_x, y)\\n\\n print('training loss', train_cost)\\n print('training accuracy:', accuracy)\\n\\n # fit function has to return an instance of itself or else it won't work with test.py\\n return self\",\n \"def _train(self, log_prob):\\n raise NotImplementedError\",\n \"def fit_DTI_signal(sig, x, weighted=False, x_pinv=None, is_log_sig=False, h_hat=None, inv_levs=None):\\n if is_log_sig:\\n y = sig\\n else:\\n #log SIGNAL\\n #this assumes that sig is strictly positive!!!!\\n try:\\n y = np.log(sig)\\n except RuntimeWarning as rw:\\n print 'ERROR FIT: non-positive value in signal'\\n print rw, '\\\\nsignal', sig\\n raise rw\\n #beta0=np.linalg.lstsq(DESIGNMATRIX,y)[0]\\n #pseudo inverse z = (DESIGNMATRIX*xT)^(-1)*xT\\n if x_pinv is None:\\n z = designmatrix_pseudoinverse(x)\\n else:\\n z = x_pinv\\n #compute hat matrix H diagonal, H = DESIGNMATRIX*z\\n #in whitcher et al 2008 the H_diagonal is computed from the OLS regression\\n if h_hat is None:\\n H_diag = np.diagonal(np.dot(x, z))\\n else:\\n H_diag = h_hat\\n #beta0 is the least squares fit result, beta0 = z*y\\n beta0 = np.dot(z, y)\\n if weighted:\\n #generate synthetic SIGNAL\\n try:\\n Sg = np.exp(np.dot(x, beta0))\\n except RuntimeWarning as rw:\\n print 'ERROR FIT: generating synthetic signal'\\n print rw, '\\\\ndesign matrix',x, '\\\\ntensor OLS fit' , beta0\\n raise rw\\n \\n #compute weight matrix W\\n try:\\n W = generate_weights(Sg)\\n except RuntimeWarning as rw:\\n print 'ERROR FIT: generating weights'\\n print rw, '\\\\nsynthetic signal', Sg\\n raise rw\\n #do IS_WEIGHTED fit \\n #z = designmatrix_pseudoinverse(x, W) #np.dot(np.dot(np.linalg.inv(np.dot(DESIGNMATRIX.T,np.dot(W,DESIGNMATRIX))),DESIGNMATRIX.T),W)\\n #beta is the final IS_WEIGHTED matrix\\n #beta = np.dot(z, y)\\n #linalg.lstsq wraps the function lapack_lite.dgelsd see some information on lapack dgelsd... That explains why the linalg calls the routine twice\\n# LWORK (input) INTEGER\\n# The dimension of the array WORK. LWORK must be at least 1. \\n# The exact minimum amount of workspace needed depends on M, N and NRHS. \\n# As long as LWORK is at least 12*N + 2*N*SMLSIZ + 8*N*NLVL + N*NRHS + (SMLSIZ+1)**2, \\n# if M is greater than or equal to N or 12*M + 2*M*SMLSIZ + 8*M*NLVL + M*NRHS + (SMLSIZ+1)**2, \\n# if M is less than N, the code will execute correctly. \\n# SMLSIZ is returned by ILAENV and is equal to the maximum size of the subproblems at \\n# the bottom of the computation tree (usually about 25), and NLVL = MAX( 0, INT( LOG_2( MIN( M,N )/(SMLSIZ+1) ) ) + 1 ) \\n# For good performance, LWORK should generally be larger. \\n# If LWORK = -1, then a workspace query is assumed; \\n# the routine only calculates the optimal size of the WORK array, returns this value as the first entry of \\n# the WORK array, and no error message related to LWORK is issued by XERBLA. \\n# IWORK (workspace) INTEGER array, dimension (MAX(1,LIWORK)) LIWORK >= 3 * MINMN * NLVL + 11 * MINMN, where MINMN = MIN( M,N ). \\n #tfit = np.linalg.lstsq(np.dot(x.T, np.dot(W,x)), np.dot(x.T, np.dot(W, y)))[0]\\n #use faster diagonal matrix mul routine\\n tmpfac = mult_diag(W, x.T, False)\\n# tfit = np.linalg.lstsq(np.dot(tmpfac, x), np.dot(tmpfac, y))[0]\\n try:\\n tfit = np.linalg.solve(np.dot(tmpfac, x), np.dot(tmpfac, y))\\n except np.linalg.LinAlgError as e:\\n tfit = np.linalg.lstsq(np.dot(tmpfac, x), np.dot(tmpfac, y))[0]\\n print 'fit_DTI_signal: Warning using lstsq', e\\n# print e, '\\\\ntensor fit', f_s[0]\\n else:\\n tfit = beta0\\n #compute hat matrix H diagonal, H = DESIGNMATRIX*z\\n #in whitcher et al 2008 the H_diagonal is computed from the OLS regression\\n #H_diag = np.diagonal(np.dot(x, z))\\n #compute MU\\n mu = np.dot(x, tfit)\\n #compute log residuals\\n errors = y-mu\\n if inv_levs is None:\\n try:\\n \\n #the resampling is only done on the gradient directions, not on the logS component!\\n inv_levs = np.ones(errors.shape)\\n inv_levs[1:] = 1./np.sqrt(1.-H_diag[1:]) \\n \\n except RuntimeWarning as rw2:\\n print 'ERROR FIT: leveraged errors'\\n print rw2, '\\\\nHat matrix diagonal', H_diag\\n inv_levs = np.ones(errors.shape)\\n raise rw2\\n lev_errors = errors*inv_levs \\n return (tfit, mu, errors, H_diag, lev_errors)\",\n \"def train_logisticRegression(data: np.array, labels: np.array)->None:\\n\\n n_examples = np.size(data, 0)\\n n_features = np.size(data, 1)\\n n_categories = np.size(labels, 1)\\n\\n data = np.hstack((np.ones((n_examples, 1)), data))\\n\\n print(data[0:5, :])\\n\\n X_train, X_test, y_train, y_test, idx_test = split_data(data, labels, 0.7)\\n\\n convergence_goal = 1e-3\\n learning_rate = 0.01\\n\\n theta = np.random.uniform(size=((n_features+1, n_categories)))\\n\\n for i in range(n_categories):\\n\\n cost_var = 1\\n\\n previous_cost = 1e6\\n iterations = 0\\n cost_to_plot = []\\n\\n while cost_var > convergence_goal:\\n iterations += 1\\n cost, grad = costFunction(X_train, y_train[:, i], theta[:, i])\\n theta[:, i] = update_theta(theta[:, i], grad, learning_rate)\\n cost_var = previous_cost - cost\\n previous_cost = cost\\n if iterations == 1: cost_var = 1\\n cost_to_plot.append(cost)\\n # print(cost)\\n\\n plt.plot(range(iterations), cost_to_plot, 'g-', label = 'cost')\\n plt.xlabel('iterations')\\n plt.ylabel('cost')\\n # plt.show()\\n\\n predictions = lrPredict(theta, X_test)\\n\\n print(predictions[0:5, :])\\n print(y_test[0:5, :])\\n\\n accuracy = np.mean([p == l for p, l in zip(predictions, y_test)])\\n print(\\\"Accuracy = {}\\\".format(accuracy))\\n\\n pass\",\n \"def fit_transform(self, X: TransformType, y=None, **fit_params) -> TransformType:\\n X = self._validate_datafold_data(\\n X,\\n array_kwargs=dict(ensure_min_samples=max(2, self.n_kernel_eigenvectors)),\\n tsc_kwargs=dict(ensure_min_samples=max(2, self.n_kernel_eigenvectors)),\\n )\\n self.fit(X=X, y=y, **fit_params)\\n\\n return self._jointly_smooth_functions_\",\n \"def fit_model(self):\\r\\n\\t\\tself.mu = np.mean(self.x, axis = 0)\\r\\n\\t\\tself.sig = np.std(self.x, axis = 0)\",\n \"def add_fit_data(self, model: str, tab_line, plot_data: hdu.table.TableHDU):\\n # This stores the exposure time that XSPEC uses for this specific spectrum.\\n if self._exp is None:\\n self._exp = float(tab_line[\\\"EXPOSURE\\\"])\\n\\n # This is the count rate and error for this spectrum.\\n self._count_rate[model] = [float(tab_line[\\\"COUNT_RATE\\\"]), float(tab_line[\\\"COUNT_RATE_ERR\\\"])]\\n\\n # Searches for column headers with 'Lx' in them (this has to be dynamic as the user can calculate\\n # luminosity in as many bands as they like)\\n lx_inds = np.where(np.char.find(tab_line.dtype.names, \\\"Lx\\\") == 0)[0]\\n lx_cols = np.array(tab_line.dtype.names)[lx_inds]\\n\\n # Constructs a dictionary of luminosities and their errors for the different energy bands\\n # in this XSPEC fit.\\n lx_dict = {}\\n for col in lx_cols:\\n lx_info = col.split(\\\"_\\\")\\n if lx_info[2][-1] == \\\"-\\\" or lx_info[2][-1] == \\\"+\\\":\\n en_band = \\\"bound_{l}-{u}\\\".format(l=lx_info[1], u=lx_info[2][:-1])\\n err_type = lx_info[-1][-1]\\n else:\\n en_band = \\\"bound_{l}-{u}\\\".format(l=lx_info[1], u=lx_info[2])\\n err_type = \\\"\\\"\\n\\n if en_band not in lx_dict:\\n lx_dict[en_band] = [0, 0, 0]\\n\\n if err_type == \\\"\\\":\\n lx_dict[en_band][0] = Quantity(float(tab_line[col])*(10**44), \\\"erg s^-1\\\")\\n elif err_type == \\\"-\\\":\\n lx_dict[en_band][1] = Quantity(float(tab_line[col])*(10**44), \\\"erg s^-1\\\")\\n elif err_type == \\\"+\\\":\\n lx_dict[en_band][2] = Quantity(float(tab_line[col])*(10**44), \\\"erg s^-1\\\")\\n\\n self._luminosities[model] = lx_dict\\n\\n self._plot_data[model] = {\\\"x\\\": plot_data[\\\"X\\\"][:], \\\"x_err\\\": plot_data[\\\"XERR\\\"][:],\\n \\\"y\\\": plot_data[\\\"Y\\\"][:], \\\"y_err\\\": plot_data[\\\"YERR\\\"][:],\\n \\\"model\\\": plot_data[\\\"YMODEL\\\"][:]}\",\n \"def _fit_point_lens(self):\\n\\n def chi2_fun(theta, event, parameters_to_fit):\\n \\\"\\\"\\\"\\n for a given event set attributes from parameters_to_fit\\n (list of str) to values from theta list\\n \\\"\\\"\\\"\\n for (key, val) in enumerate(parameters_to_fit):\\n setattr(event.model.parameters, val, theta[key])\\n chi2 = event.get_chi2()\\n if chi2 < chi2_fun.best_chi2:\\n chi2_fun.best_chi2 = chi2\\n return chi2\\n chi2_fun.best_chi2 = 1.e10\\n\\n def jacobian(theta, event, parameters_to_fit):\\n \\\"\\\"\\\"\\n Calculate chi^2 gradient (also called Jacobian).\\n \\\"\\\"\\\"\\n for (key, val) in enumerate(parameters_to_fit):\\n setattr(event.model.parameters, val, theta[key])\\n return event.chi2_gradient(parameters_to_fit)\\n\\n if self._event_PSPL is None:\\n self._set_event_PSPL()\\n\\n parameters_to_fit = [\\\"t_0\\\", \\\"u_0\\\", \\\"t_E\\\"]\\n initial_guess = [self._parameters[p] for p in parameters_to_fit]\\n\\n failed = False\\n try:\\n result = op.minimize(\\n chi2_fun, x0=initial_guess,\\n args=(self._event_PSPL, parameters_to_fit),\\n method='Newton-CG', jac=jacobian, tol=3.e-4)\\n except:\\n failed = True\\n\\n if failed:\\n try:\\n result = op.minimize(\\n chi2_fun, x0=initial_guess,\\n args=(self._event_PSPL, parameters_to_fit),\\n method='Newton-CG', jac=jacobian, tol=3.e-4)\\n except:\\n pass\\n# XXX what if fit failed (i.e., .success is False)?\\n\\n self._LSST_PSPL_chi2 = chi2_fun.best_chi2\",\n \"def set_fit_params(self):\\n\\n self.p0 = np.array([self.A_arr, self.T_a])\\n # initial guess at A_arr and T_a\\n\\n self.popt, self.pcov = curve_fit(\\n self.get_eta_fit, self.T_exp, self.eta_exp, p0=self.p0\\n )\\n\\n self.A_arr = self.popt[0]\\n self.T_a = self.popt[1]\\n\\n self.T_array = self.T_model\",\n \"def add_X_NNLO_fit(axe, xran, values, errors, fill=False, save=False):\\n B = values[\\\"B\\\"]\\n F_0 = values[\\\"F_0\\\"]\\n\\n LAMBDA4 = values[\\\"Lambda4\\\"]\\n LAMBDA3 = values[\\\"Lambda3\\\"]\\n # LAMBDA12 = values[\\\"Lambda12\\\"]\\n km = values[\\\"km\\\"]\\n kf = values[\\\"kf\\\"]\\n\\n x = np.linspace(xran[0], xran[1], num=500)\\n\\n Msqr = x * (8 * (np.pi**2) * (F_0**2))\\n arg4 = LAMBDA4**2 / Msqr\\n arg3 = LAMBDA3**2 / Msqr\\n # arg12 = LAMBDA12**2 / Msqr\\n\\n l1 = -0.4\\n l2 = 4.3\\n\\n Lambda1sqr = (phys_pion**2) * np.exp(l1)\\n Lambda2sqr = (phys_pion**2) * np.exp(l2)\\n\\n lnLambda12sqr = (7.0 * np.log(Lambda1sqr) + 8.0 * np.log(Lambda2sqr)) / 15.0\\n lambda12sqr = np.exp(lnLambda12sqr)\\n\\n arg12 = lambda12sqr / Msqr\\n\\n lm = 1.0 / 51.0 * (60.0 * np.log(arg12) - 9.0 * np.log(arg3) + 49.0)\\n lf = 1.0 / 30.0 * (30.0 * np.log(arg12) + 6.0 * np.log(arg3) - 6.0 * np.log(arg4) + 23.0)\\n\\n y = F_0 * (1.0 + x * np.log(arg4) - 5.0 / 4.0 * (x**2) * (lf)**2 + kf * x**2)\\n\\n plots = []\\n paramstring = \\\" \\\".join(\\\"${}={}$\\\".format(format_parameters(k), print_paren_error(float(v), float(errors[k])))\\n for k, v in sorted(values.iteritems()))\\n paramstring = \\\"$ M_\\\\pi<{}$\\\".format(values[\\\" M_\\\\pi<\\\"])\\n plabel = \\\"NNLO {}\\\".format(paramstring)\\n plabel = \\\"NNLO\\\"\\n if \\\"cutoff\\\" in values:\\n plabel += \\\" $M_\\\\pi < {}$\\\".format(values[\\\"cutoff\\\"])\\n addplot(plots, axe, fill, save, x=x, y=y, params={\\\"label\\\":plabel, \\\"ls\\\":\\\"--\\\", \\\"lw\\\":4})\\n\\n return plots\",\n \"def sklearn_model(train_data):\\n X, y = train_data\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\")\\n model = LogisticRegression(\\n multi_class=\\\"multinomial\\\", solver=\\\"lbfgs\\\", max_iter=1000\\n )\\n model.fit(X, y)\\n return model\",\n \"def _fit(self, X: TimeSeriesInstances, y=None) -> np.ndarray:\\n raise NotImplementedError\",\n \"def line_fit(x,y):\\n\\t# clean\\n\\tx = np.squeeze(x)\\n\\ty = np.squeeze(y)\\n\\t# concatenate\\n\\txy = np.concatenate((x[:,np.newaxis],y[:,np.newaxis]),1)\\n\\t# sort by x values\\n\\txy = xy[xy[:,0].argsort()]\\n\\t#print(xy)\\n\\tf = lambda x,m,b : m*x+b\\n\\tpars,_ = opt.curve_fit(f,xy[:,0],xy[:,1])\\n\\tm = pars[0]\\n\\tb = pars[1]\\n\\tpts = np.zeros((2,2))\\n\\tpts[0,0] = xy[0,0]\\n\\tpts[1,0] = xy[-1,0]\\n\\tpts[:,1] = pts[:,0]*m+b\\n\\tsig = np.std((xy[:,1]-f(xy[:,0],m,b)))\\n\\treturn pts, sig\",\n \"def fit(self, X, y=None, **kwargs):\\n raise NotImplementedError()\",\n \"def fit(self, data):\\n raise NotImplementedError(\\\"To be implemented in sub classes\\\")\",\n \"def fit(\\n self,\\n X: FEATURES | None = None,\\n y: TARGET | None = None,\\n **fit_params,\\n ):\\n X, y = self._prepare_input(X, y)\\n self._check_feature_names(X, reset=True)\\n self._check_n_features(X, reset=True)\\n\\n self.log(f\\\"Fitting {self.__class__.__name__}...\\\", 1)\\n\\n return self\",\n \"def do_fit(self):\\n\\n if (self._flag == 1):\\n self._gf = [0.2]\\n self._gf = self.par*(self._num_fu*len(self._sites)*2)\\n x, F = self.read_from_file(\\n self._sn, self._qn, self._path) # read data from the file\\n # ,ftol=1.0e-7,xtol=1.0e-8)\\n popt, pcov = curve_fit(\\n self.modelfun, x, F, p0=self._gf, maxfev=5000)\\n self._gf = popt\\n\\n elif (self._flag == 2):\\n\\n# par=[0.0]*(self._num_fu*5)\\n# for j in range(self._num_fu):\\n# par[j*5]=0.0*math.copysign(1,(pow(-1,j)))\\n# self._gf[j*5]=0.1\\n# par[j*5+1]=6.45\\n# par[j*5+2]=0.0\\n# par[j*5+3]=0.05\\n# par[j*5+4]=1.0\\n\\n X, F = self.read_from_file(self._sn, self._qn, self._path) # read data from the file\\n\\n# height, xx, width=self.moments(F)\\n# Tracer()()\\n# par=[0.0]*(self._num_fu*5)\\n# for j in range(self._num_fu):\\n# par[j*5]=x[0,xx]\\n# par[j*5]=X[0,xx]*math.copysign(1,(pow(-1,j)))\\n# par[j*5+1]=X[1,xx]\\n# par[j*5+2]=X[2,xx]\\n# par[j*5+3]=0.007\\n# par[j*5+4]=height*math.copysign(1,(pow(-1,j)))\\n\\n xi, yi, zi = np.mgrid[-6.5:6.5:160j, 4.0:8.9:160j, -7.5:7.5:160j]\\n x, y, z = xi.flatten(), yi.flatten(), zi.flatten()\\n XX = np.vstack((x, y, z))\\n\\n invdisttree = Invdisttree(X.T, F, leafsize=10, stat=1)\\n AA = invdisttree(XX.T, nnear=130, eps=0, p=1)\\n\\n# aaa1,bbb1=self.detect_local_minima(-AA.reshape(xi.shape))\\n# aaa2,bbb2=self.detect_local_maxima(-AA.reshape(xi.shape))\\n if self.peaks==[]:\\n print('\\\\n---------------------------------------------------------------------')\\n print('Detecting maxima and minima of target function...',)\\n\\n peaks_min, min_coord, peaks_max, max_coord = self.detect_min_max(AA.reshape(xi.shape))\\n print('done')\\n print('Number of the min peaks: {}'.format(len(peaks_min)))\\n print('Number of the max peaks: {}'.format(len(peaks_max)))\\n print('---------------------------------------------------------------------\\\\n')\\n # fig=plt.figure()\\n # ax = fig.add_subplot(111, projection='3d')\\n # ax.plot_surface(xi[:,:,60],yi[:,:,60],bbb2[:,:,60], cmap=cm.jet, linewidth=0.2)\\n # plt.hold(True)\\n # plt.show()\\n\\n if peaks_max==[]:\\n peaks=np.insert(peaks_min, np.arange(len(peaks_max)), peaks_max)\\n coords=np.insert(min_coord, np.arange(max_coord.shape[1]), max_coord, axis=1)\\n else:\\n peaks = np.insert(peaks_max, np.arange(len(peaks_min)), peaks_min)\\n coords = np.insert(max_coord, np.arange(min_coord.shape[1]), min_coord, axis=1)\\n\\n self.peaks=peaks\\n self.coords=coords\\n\\n par = [0.0]*(self._num_fu*5)\\n j1 = 0\\n aaaa = 1\\n for j in range(self._num_fu):\\n if (j > aaaa*self.coords.shape[1]-1):\\n j1 = 0\\n aaaa += 1\\n par[j*5] = xi[self.coords[0, j1], self.coords[0, j1], self.coords[0, j1]]\\n par[j*5+1] = yi[self.coords[1, j1], self.coords[1, j1], self.coords[1, j1]]\\n par[j*5+2] = zi[self.coords[2, j1], self.coords[2, j1], self.coords[2, j1]]\\n # par[j*5+3] = 0.1003+0.1000*math.copysign(1, (pow(-1, j)))\\n par[j*5+3] = 0.0001\\n# if j < 15:\\n# par[j*5+3] = 0.00001\\n# else:\\n# par[j*5+3] = 0.0005\\n par[j*5+4] = self.peaks[j1]\\n# print(coords[0, j1], coords[1, j1], coords[2, j1])\\n j1 += 1\\n # popt, pcov = curve_fit(self.modelfun1, x[:,1:20000], F[1:20000],p0=par,maxfev=150000,xtol=1e-8,ftol=1e-8)\\n popt, pcov = curve_fit(\\n self.modelfun1, X, F, p0=par, maxfev=150000, xtol=1e-6,\\n ftol=1e-8)\\n # popt, pcov = curve_fit(self.modelfun1, XX, AA, p0=par)\\n self._gf = popt\\n# self.error=np.diagonal(pcov, offset=0)\\n# print(pcov)\\n else:\\n # pass\\n sys.exit(\\\"Wrong flag in do_fit\\\")\",\n \"def fit_model(self):\\n logger.info('Fitting model')\\n if self.traj_dict is None:\\n self.traj_dict = self.get_traj_dict()\\n self.model.fit(self.traj_dict.values())\",\n \"def parse_fitlog(fitlog):\\n # imports\\n import re\\n import numpy as np\\n from natsort import natsorted\\n\\n # initialize variables\\n ingal = None\\n expdisk = None\\n nums = []\\n\\n # parse fit.log\\n with open(fitlog, 'r') as f:\\n # read all lines of fit.log\\n for line in f:\\n # get input galaxy name\\n # # */galaxies/f606w_gal0.fits[1:601,1:601]\\n if line.strip().startswith(\\\"Input\\\"):\\n ingal = line[61:][0:-15]\\n\\n if '*' in line:\\n bad = line\\n num = re.search('(.+?)(\\\\d+)(\\\\.\\\\w*)', ingal).group(2)\\n nums.append(num)\\n write = ingal + bad\\n\\n # list of bad fitted galaxies\\n bad = list(map(int, set(nums)))\\n bad = natsort.natsorted(bad)\\n\\n # two groups\\n bad100 = [i for i in bad if i <= 100]\\n bad200 = [i for i in bad if i >= 101]\\n return bad, bad100, bad200\",\n \"def train_model(self):\\r\\n alpha, accuracy_rate = self.select_model()\\r\\n # Initialize logistic regression with alpha(learning rate)\\r\\n lg = logisticregression(C=alpha)\\r\\n # Train the model.\\r\\n lg.fit(self.training_data, self.target_data)\\r\\n # Save the trained model as .pkl file.\\r\\n joblib.dump(value=lg, filename=self.intention_id+'.pkl', compress=1)\\r\\n print \\\"Estimated Parameters of Logistic Regression\\\"\\r\\n # Estimated parameters of logistic regression.\\r\\n print lg.get_params()\",\n \"def train_logistic_regression(train_x, train_y):\\n\\n logistic_regression_model = LogisticRegression(penalty='l2', C=1.0)\\n logistic_regression_model.fit(train_x, train_y)\\n return logistic_regression_model\",\n \"def fit(self, X):\\n raise NotImplementedError('Abstract method \\\"fit\\\" must be '\\n 'specialised!')\",\n \"def fit_model(func, xdata, ydata, yerrdata, p0):\\n popt, pcov = curve_fit(func, xdata, ydata, p0=p0, sigma=yerrdata)\\n # the function evaluated at the output parameters\\n fvec = lambda x: func(x, *popt)\\n # degree of freedom\\n dof = len(xdata) - len(popt) - 1\\n # chi squared\\n chisq = np.sum(((ydata - fvec(xdata)) / yerrdata) ** 2)\\n # one standard deviation errors on the parameters\\n perr = np.sqrt(np.diag(pcov))\\n infodict = {\\n 'fvec': fvec,\\n 'dof': dof,\\n 'chisq': chisq,\\n 'perr': perr\\n }\\n return (popt, infodict)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def data_transformer(data, trafo, power=1.):\\n\\n tf = trafo.split('-')\\n if tf[0] == 'NA': # only power transform\\n return data\\n elif tf[0] == 'pow': # log_10 transform\\n return data ** power\\n elif tf[0] == 'log': # log_10 transform\\n return np.log10(data) ** power\\n elif tf[0] == 'd1': # first difference over period dx\\n i = int(tf[1])\\n return (data[i:] - data[:-i]) ** power\\n elif tf[0] == 'pch': # percentage change over period px\\n i = int(tf[1])\\n return (100. * (data[i:] - data[:-i]) / data[:-i]) ** power\\n elif tf[0] == 'ld': # log difference (approx pch for small changes)\\n i = int(tf[1])\\n return (100 * np.log(data[i:] / data[:-i])) ** power\\n else:\\n raise ValueError(\\\"Invalid transformation value.\\\")\",\n \"def test_loglike(dlm,Cl,noise,beam):\\n lmax = Cl.shape[0]\\n tt_exp = -1./2 * np.real(np.vdot(dlm.T,hp.almxfl(dlm,1/(beam[:lmax]**2*Cl[:,1]+noise[:lmax]))))\\n #plt.plot(Cl[:,1])\\n tt_det = - 1./2 *(np.arange(1,lmax+1)*np.log((noise[:lmax]+Cl[:,1]*beam[:lmax]**2))).sum() \\n tt_f = tt_exp + tt_det\\n return tt_exp,tt_det,tt_f#,Cl[:,1]\",\n \"def _fit(self, dataset):\\n raise NotImplementedError()\",\n \"def do_stats_model(x, y):\\n Xx = sm.add_constant(x)\\n sm_logit = sm.Logit(y, Xx)\\n result = sm_logit.fit()\\n print result.summary()\\n result.pred_table()\\n # linear model\\n print \\\"linear regression model:\\\\n\\\"\\n sm_linear = sm.OLS(y, Xx)\\n result = sm_linear.fit()\\n print result.summary()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6444538","0.63850284","0.62057203","0.6166464","0.61226857","0.60739666","0.60667914","0.60667914","0.60667914","0.60667914","0.60667914","0.60667914","0.60667914","0.60667914","0.60667914","0.60667914","0.60634655","0.60511357","0.6010437","0.6010437","0.6010437","0.60007465","0.5958649","0.5949397","0.5949397","0.5910795","0.5901006","0.5873235","0.5867704","0.5766128","0.5743146","0.56654066","0.56641245","0.5632109","0.56063014","0.5577822","0.55644006","0.55465955","0.5526473","0.5516649","0.550536","0.55008084","0.54831165","0.54737896","0.5470922","0.5462979","0.5445719","0.5436631","0.5434066","0.53986275","0.5387785","0.5387679","0.5386713","0.53859633","0.5383345","0.5371592","0.53680605","0.53647316","0.5350197","0.5346046","0.53421","0.53402644","0.5338069","0.53340673","0.5328348","0.53245425","0.53212035","0.53204554","0.531917","0.53154516","0.5306752","0.5299769","0.52958304","0.5281114","0.5276766","0.52740455","0.52725905","0.5268222","0.52673095","0.5262731","0.5261276","0.5261105","0.5251853","0.5243771","0.5241917","0.52404207","0.52370775","0.5236462","0.52327347","0.5224717","0.522203","0.5218888","0.5218888","0.5218888","0.5218888","0.5218888","0.5210283","0.51926124","0.51907504","0.5189407"],"string":"[\n \"0.6444538\",\n \"0.63850284\",\n \"0.62057203\",\n \"0.6166464\",\n \"0.61226857\",\n \"0.60739666\",\n \"0.60667914\",\n \"0.60667914\",\n \"0.60667914\",\n \"0.60667914\",\n \"0.60667914\",\n \"0.60667914\",\n \"0.60667914\",\n \"0.60667914\",\n \"0.60667914\",\n \"0.60667914\",\n \"0.60634655\",\n \"0.60511357\",\n \"0.6010437\",\n \"0.6010437\",\n \"0.6010437\",\n \"0.60007465\",\n \"0.5958649\",\n \"0.5949397\",\n \"0.5949397\",\n \"0.5910795\",\n \"0.5901006\",\n \"0.5873235\",\n \"0.5867704\",\n \"0.5766128\",\n \"0.5743146\",\n \"0.56654066\",\n \"0.56641245\",\n \"0.5632109\",\n \"0.56063014\",\n \"0.5577822\",\n \"0.55644006\",\n \"0.55465955\",\n \"0.5526473\",\n \"0.5516649\",\n \"0.550536\",\n \"0.55008084\",\n \"0.54831165\",\n \"0.54737896\",\n \"0.5470922\",\n \"0.5462979\",\n \"0.5445719\",\n \"0.5436631\",\n \"0.5434066\",\n \"0.53986275\",\n \"0.5387785\",\n \"0.5387679\",\n \"0.5386713\",\n \"0.53859633\",\n \"0.5383345\",\n \"0.5371592\",\n \"0.53680605\",\n \"0.53647316\",\n \"0.5350197\",\n \"0.5346046\",\n \"0.53421\",\n \"0.53402644\",\n \"0.5338069\",\n \"0.53340673\",\n \"0.5328348\",\n \"0.53245425\",\n \"0.53212035\",\n \"0.53204554\",\n \"0.531917\",\n \"0.53154516\",\n \"0.5306752\",\n \"0.5299769\",\n \"0.52958304\",\n \"0.5281114\",\n \"0.5276766\",\n \"0.52740455\",\n \"0.52725905\",\n \"0.5268222\",\n \"0.52673095\",\n \"0.5262731\",\n \"0.5261276\",\n \"0.5261105\",\n \"0.5251853\",\n \"0.5243771\",\n \"0.5241917\",\n \"0.52404207\",\n \"0.52370775\",\n \"0.5236462\",\n \"0.52327347\",\n \"0.5224717\",\n \"0.522203\",\n \"0.5218888\",\n \"0.5218888\",\n \"0.5218888\",\n \"0.5218888\",\n \"0.5218888\",\n \"0.5210283\",\n \"0.51926124\",\n \"0.51907504\",\n \"0.5189407\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5345078"},"document_rank":{"kind":"string","value":"60"}}},{"rowIdx":91791,"cells":{"query":{"kind":"string","value":"Calculate & return n_types = N_z formula(m_tokens/M_z)"},"document":{"kind":"string","value":"def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # redirect: E(m) = N_z - k_0(m)\n k = self.predict_k(m_tokens, dim=1, nearest_int=nearest_int)\n n_types = self.N_z - k[:, 0]\n\n # allow scalar\n if return_scalar:\n assert len(n_types) == 1\n n_types = float(n_types)\n\n # return number of types\n return n_types"},"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 N_z(self) -> int:\n return self.params.N_z","def number_types(corpus):\n number_of_types = len(set(corpus))\n return number_of_types","def u(self, k, m, z):\n result = self.ProfNFW.nfw(k, m, z) * self.Ngal(m) / self.nBarGal(1./(1.+z))\n return result","def type_count():\n types = []\n for typ in Statistics.all_type():\n types.append({'label': typ.lower(), 'y': Statistics.type_count(typ)})\n fix_types = []\n for i in sorted(types, key=lambda k: k['y']):\n if i['y'] != 0:\n fix_types.append(i)\n return jsonify(result=fix_types)","def redshifts2frequencies(z):\r\n return 1420e6 / (z + 1)","def compute_N(X, language):\r\n if language == 'english': \r\n global N_ENGLISH \r\n N_ENGLISH = len(X)\r\n elif language == 'french':\r\n global N_FRENCH \r\n N_FRENCH = len(X)","def n_z(self, level):\n resolution = self.resolution(level)\n return (self.z_extent // resolution + 63) // 64","def __len__(self):\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios","def __len__(self):\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios","def __len__(self):\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios","def __len__(self):\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios","def N(self) -> int:\n n_types = len(self)\n return n_types","def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # redirect: E(m) = N * formula(m/M)\n n_types = self.N * self.formula(m_tokens / self.M)\n\n # roundoff\n if nearest_int:\n n_types = np.round(n_types)\n\n # allow scalar\n if return_scalar:\n assert len(n_types) == 1\n n_types = float(n_types)\n\n # return number of types\n return n_types","def get_types_count():\n return len(type_dict.keys())","def uN(self, k, m, z, n=1):\n if n==1:\n result = self.u(k, m, z)\n # for the 1-halo profile with an HOD,\n # you don't just square the 2-halo profile,\n # although this is only different at very low mass\n # see Lacasa+13\n elif n==2:\n Ncen = self.Ncen(m)\n Nsat = self.Nsat(m)\n result = Nsat**2 + 2.*Nsat*Ncen\n result *= self.ProfNFW.nfw(k, m, z)**2 / self.nBarGal(1./(1.+z))**2\n else:\n result = self.u(k, m, z)**n\n return result","def _m(self):\n return self._k // self._n_classes","def get_zdim(self):\n return self.decoder.get_input_info_dict()['latent_vector'].get_shape()[1]","def M_z(self) -> int:\n return self.params.M_z","def M(self) -> int:\n m_tokens = sum(self.values())\n return m_tokens","def expected_counts(p0, T, n): \n M=T.shape[0]\n if n<=M:\n return ec_matrix_vector(p0, T, n)\n else:\n return ec_geometric_series(p0, T, n)","def zpkfreqz(z, p, k, worN=None):\n if worN is None or isinstance(worN, int):\n N = worN or 512\n ws = [mp.pi * mp.mpf(j) / N for j in range(N)]\n else:\n ws = worN\n\n h = []\n for wk in ws:\n zm1 = mp.exp(1j * wk)\n numer = _prod([zm1 - t for t in z])\n denom = _prod([zm1 - t for t in p])\n hk = k * numer / denom\n h.append(hk)\n return ws, h","def accuracy_NMEA(z):\n N = len(z)\n size = int(N - 60)\n sigma = np.zeros(size)\n for i in range(30, N - 30):\n z_ave = np.sum(z[(i - 30) : (i + 30)]) / 60\n sigma[i - 30] = (\n (np.sum(abs(z[i - 30 : i + 30] - z_ave) ** 2)) / ((60) - 1)\n ) ** 0.5\n return sigma","def count_NN(KL):\n zvals = (KL != 0).sum(1)\n return zvals","def number_of_atoms(formula):\n pass\n # ======== YOUR CODE HERE ========","def specht(mu):\n return StandardTableaux(mu).cardinality().n()","def get_num_classes(self):","def calculate(self, tokens: list):\n vektor_tf_unigram = {}\n\n for token in tokens:\n if token in vektor_tf_unigram:\n vektor_tf_unigram[token] = vektor_tf_unigram[token] + 1\n else:\n vektor_tf_unigram[token] = 1\n\n return vektor_tf_unigram","def count_types():\n classes = {\"Amenity\": Amenity, \"City\": City,\n \"Place\": Place, \"Review\": Review, \"State\": State, \"User\": User}\n my_dict = {}\n for key in classes.keys():\n if (classes[key] == Amenity):\n my_dict[\"amenities\"] = storage.count(classes[key])\n elif (classes[key] == City):\n my_dict[\"cities\"] = storage.count(classes[key])\n elif (classes[key] == Place):\n my_dict[\"places\"] = storage.count(classes[key])\n elif (classes[key] == Review):\n my_dict[\"reviews\"] = storage.count(classes[key])\n elif (classes[key] == State):\n my_dict[\"states\"] = storage.count(classes[key])\n elif (classes[key] == User):\n my_dict[\"users\"] = storage.count(classes[key])\n return (jsonify(my_dict))","def dim_reduction( M ):\n tot_count_per_type = M.sum(axis = 1)\n tot_count = float(tot_count_per_type.sum())\n sorted_index = np.argsort(tot_count_per_type)\n threshold = 0.01\n accu = 0\n for i in range(len(sorted_index)):\n perc = float(tot_count_per_type[sorted_index[i]])/tot_count\n accu = accu + perc\n if accu > threshold:\n break;\n \n return sorted_index[0:i]","def _get_tr_dataset_size_from_z0(z0):\n return int(np.round(np.exp(z0)))","def Omega_m_z(self, z):\n return self.Omega_cdm_z(z)+self.Omega_b_z(z)+np.sum(self.Omega_nu_z(z),axis=0)","def totlen(inputlist):\n tot = 0.0\n for x in inputlist:\n if isinstance(x, matrix):\n tot += totlen(x.getitems())\n else:\n try:\n test = len(x)\n except:\n tot += 1.0\n else:\n tot += test\n return tot","def accuracy_NMEA_opt(z):\n N = len(z)\n size = int(N - 60)\n sigma = np.zeros(size)\n for i in prange(30, N - 30):\n z_ave = 0\n for z_ave_i in z[(i - 30) : (i + 30)]:\n z_ave += z_ave_i\n z_ave = z_ave / 60.0\n\n noise_sqrt = 0\n for noise in z[i - 30 : i + 30]:\n noise_sqrt += abs(noise - z_ave) ** 2\n sigma[i - 30] = (noise_sqrt / (60.0 - 1.0)) ** 0.5\n return sigma","def tf(xp, yp, zp, prisms, inc, dec, pmag=None):\n if xp.shape != yp.shape != zp.shape:\n raise ValueError(\"Input arrays xp, yp, and zp must have same shape!\")\n # Calculate the 3 components of the unit vector in the direction of the\n # regional field\n fx, fy, fz = giutils.dircos(inc, dec)\n res = 0\n for prism in prisms:\n if prism is None:\n continue\n if 'magnetization' not in prism.props and pmag is None:\n continue\n if pmag is None:\n mx, my, mz = prism.props['magnetization']\n else:\n mx, my, mz = pmag\n v1 = kernelxx(xp, yp, zp, prism)\n v2 = kernelxy(xp, yp, zp, prism)\n v3 = kernelxz(xp, yp, zp, prism)\n v4 = kernelyy(xp, yp, zp, prism)\n v5 = kernelyz(xp, yp, zp, prism)\n v6 = kernelzz(xp, yp, zp, prism)\n bx = v1*mx + v2*my + v3*mz\n by = v2*mx + v4*my + v5*mz\n bz = v3*mx + v5*my + v6*mz\n res += fx*bx + fy*by + fz*bz\n res *= CM * T2NT\n return res","def inertia(mus):\n pos, negs, zeros = cluster_eignvalues(mus)\n\n return len(zeros) + min(len(pos), len(negs))","def _count_tokens(self,\n token_lists):\n ## Filter out empty lists\n fn_tokens = list(filter(lambda i: len(i) > 0, token_lists))\n ## Get N-grams from Tokens\n fn_ngrams = list(map(lambda t: self.get_ngrams(t, self._ngrams[0], self._ngrams[1]),\n fn_tokens))\n ## Count Tokens (binary if class is unfit and binarization turned on)\n if hasattr(self, \"_class_state\") and \\\n self._class_state == \"untrained\" and \\\n hasattr(self, \"_binarize_counter\") and \\\n self._binarize_counter:\n fn_counts = Counter(list(set(flatten(fn_ngrams))))\n else:\n fn_counts = Counter(flatten(fn_ngrams))\n return fn_counts","def _get_token_cnts(self, doc, doc_type):\n tokenized_doc = self.nlp(doc)\n self.stat_dict[doc_type][0].append(len([s for s in tokenized_doc.sents]))\n doc_len = len([t for t in tokenized_doc])\n self.stat_dict[doc_type][1].append(doc_len)\n if doc_len < 50 and doc_type == \"answer\":\n print(\"Document less than 50 tokens:\", url)","def nnz(self):\n t = self.get_MSC()\n return len(np.unique(t['masks']))","def nnz(self):","def get_ntype_counts_map(ntypes, ntype_counts):\n return dict(zip(ntypes, ntype_counts))","def Omega_nu_z(self, z):\n MM,ZZ = np.meshgrid(np.atleast_1d(self.M_nu),np.atleast_1d(z),indexing='ij')\n Y = MM/((1.+ZZ)*const.kB*self.T_nu)\n F = self.FermiDirac_integral(Y)\n GN = self.Gamma_nu**4.\n onuz = 15./np.pi**4.*self.Omega_gamma*F*GN*(1.+ZZ)**4.*self.H0**2./np.atleast_2d(self.H(z)**2.)\n return onuz","def affichage_stats_globales(liste_typexp):\n print(\"-\"*50)\n total = 0\n for typexp in liste_typexp:\n print(f\"{typexp.type_mwe} : {len(typexp.mwes)}\")\n total += len(typexp.mwes)\n print(f\"TOTAL : {total}\")","def count(\n type_signature: computation_types.Type, predicate: _TypePredicate\n) -> int:\n one_or_zero = lambda t: 1 if predicate(t) else 0\n return sum(map(one_or_zero, preorder_types(type_signature)))","def get_lensum_dtype(nbin, shear_style):\n dt=[('index','i8'),\n ('weight','f8'),\n ('totpairs','i8'),\n\n #('xxsum','f8'),\n #('xysum','f8'),\n #('yysum','f8'),\n\n ('npair','i8',nbin),\n\n ('rsum','f8',nbin),\n ('wsum','f8',nbin),\n ('dsum','f8',nbin),\n ('osum','f8',nbin)]\n\n if shear_style=='lensfit':\n dt+=[('dsensum','f8',nbin),\n ('osensum','f8',nbin)]\n\n return dt","def GetStereoisomerCount(m, options=...): # -> Any:\n ...","def nfw(self, k, m, z):\n RS, rhoS, c = self.rS_rhoS_c(m, z)\n #\n result = np.sin(k * RS) * ( Si((1+c) * k * RS) - Si(k * RS) )\n result += - np.sin(c * k * RS) / ((1+c) * k * RS)\n result += np.cos(k * RS) * ( Ci((1+c) * k * RS) - Ci(k * RS) )\n result /= (np.log(1+c) - c/(1+c))\n return result","def nfw(self, k, m, z):\n RS, rhoS, c = self.rS_rhoS_c(m, z)\n #\n result = np.sin(k * RS) * ( Si((1+c) * k * RS) - Si(k * RS) )\n result += - np.sin(c * k * RS) / ((1+c) * k * RS)\n result += np.cos(k * RS) * ( Ci((1+c) * k * RS) - Ci(k * RS) )\n result /= (np.log(1+c) - c/(1+c))\n return result","def subtype_counts(node_set, G, log=False):\n subtypes = Counter()\n for n in node_set:\n subtype = G.node[n]['subtype']\n subtypes[subtype] += 1\n\n if log:\n for k, v in subtypes.items():\n subtypes[k] = np.log10(v)\n \n return subtypes","def nze(self) -> int:","def nze(self) -> int:","def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # sum over legomena coefficients k\n x = m_tokens / self.M\n exponents = range(len(self.k))\n terms = np.array([np.power(1 - x, n) for n in exponents])\n k_0 = np.dot(self.k, terms)\n n_types = self.N - k_0\n\n # roundoff\n if nearest_int:\n n_types = np.round(n_types)\n\n # allow scalar\n if return_scalar:\n assert len(n_types) == 1\n n_types = n_types[0]\n\n # return\n return n_types","def count_terms(self, tokens):\n\n terms = [self.term_match(t) for t in tokens ]\n \n terms = [t for t in terms if t != None]\n\n #print terms\n lf = dict(Counter(terms))\n for k in lf:\n lf[k] /= float(len(tokens))\n #lf[k] = 1 # binarize?\n pass\n return lf","def by(xp, yp, zp, prisms):\n if xp.shape != yp.shape != zp.shape:\n raise ValueError(\"Input arrays xp, yp, and zp must have same shape!\")\n res = 0\n for prism in prisms:\n if prism is None or ('magnetization' not in prism.props):\n continue\n # Get the magnetization vector components\n mx, my, mz = prism.props['magnetization']\n v2 = kernelxy(xp, yp, zp, prism)\n v4 = kernelyy(xp, yp, zp, prism)\n v5 = kernelyz(xp, yp, zp, prism)\n res += v2*mx + v4*my + v5*mz\n res *= CM * T2NT\n return res","def gal_count(clusters):\n sum = 0\n for x in clusters:\n sum += x.ngal\n return sum","def n():\n # For documentation purposes","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 calculate_number_of_stems(data: Data, node_types: Optional[List[int]]):\n\n soma = data.morphology.get_soma()\n if node_types:\n return len(data.morphology.get_children_of_node_by_types(soma, node_types))\n else:\n return len(data.morphology.children_of(soma))","def _getKramerStatistic_(seq, n, F):\n S = 0.0\n for i in range(n):\n S += (F(seq[i]) - (2 * i - 1) / (2 * n)) ** 2\n return 1 / (12 * n) + S","def length_uc(x):\r\n return sum(length(m) for m in metamer(x))","def _get_total_ngrams(n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]]) ->Dict[int, Tensor]:\n total_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n for n in n_grams_counts:\n total_n_grams[n] = tensor(sum(n_grams_counts[n].values()))\n return total_n_grams","def test_N_atoms():\n structure = Material(input)\n assert (structure.N_atoms(22) == 36110850351331465494528)","def model_numel(model, param_dims=[2, 4], param_types=['weight', 'bias']):\n total_numel = 0\n for name, param in model.state_dict().items():\n # Extract just the actual parameter's name, which in this context we treat as its \"type\"\n if param.dim() in param_dims and any(type in name for type in param_types):\n total_numel += torch.numel(param)\n return total_numel","def testatomnos(self):\r\n # This will work only for numpy\r\n #self.assertEqual(self.data.atomnos.dtype.char, 'i')\r\n\r\n atomnos_types = [numpy.issubdtype(atomno, numpy.signedinteger)\r\n for atomno in self.data.atomnos]\r\n assert numpy.alltrue(atomnos_types)\r\n\r\n assert self.data.atomnos.shape == (20,)\r\n\r\n count_C = sum(self.data.atomnos == 6)\r\n count_H = sum(self.data.atomnos == 1)\r\n assert count_C + count_H == 20","def compute_morpheme_length(attribs):\n num_morphemes = 0\n for m in attribs:\n if m:\n if type(m) == list:\n num_morphemes += len(m)\n else:\n num_morphemes += 1\n if num_morphemes == 0: #To be consistent with the previous functionality\n return None\n return num_morphemes","def numnems(self):\n count = 0\n for o in self._objs.values():\n count += len(o.netifs())\n return count","def totalize_natures(sv):\r\n tot=0 \r\n for nod in sv.Object.values():\r\n tot+=len(nod.nature)\r\n return tot","def flops_count(model):\n count = 0\n for n, m in model.named_modules():\n if isinstance(m, nn.Linear):\n count += m.in_features * m.out_features + m.bias.numel()\n return count","def getNumberTerms(content): \n return Counter(getTerms(content))","def n_classes(self):\n raise NotImplementedError","def n_classes(self):\n raise NotImplementedError","def count_rotation_numels(model):\n total = 0\n for m in model.modules():\n if isinstance(m, (ConvLayerRotation, LinearLayerRotation)):\n total += m.rotation_matrix.numel()\n return total","def getNtot(self,dir):\n return int(readfile(dir + '/struct_enum.out')[-1].split()[0])","def nnz(self):\n\t\treturn self.st.size()","def tag_counts(self, types=[]):\n if not types:\n types = self.tag_types\n for tag_type in types:\n print \"\\t%15s : %-10s\" % (tag_type, len(self.tag_dictionary[tag_type]))","def ntypes(self): # -> None:\n ...","def nNz(self):\n if self.dim < 3:\n return None\n return self.nCz + 1","def z(self) -> int:","def nfactors(self):\n return self.L.nnz","def extinction_lenght(keV, Z, hkl, th0=0.):\n return keV/ (extinction_constant(Z, hkl, th0=0.))","def utr3_motif_counts(self, pattern):\n return len(re.findall(pattern.upper(), self.three_prime_utr_sequence.upper()))","def term_frequency(ngrams,lang):\n token_dictionary = {}\n for ng in ngrams:\n try:\n token_dictionary[ng] = token_dictionary[ng] + 1\n except KeyError:\n token_dictionary[ng] = 1\n return token_dictionary","def nmodes(self):\n if self.mode_selection is not None:\n return len(self.mode_selection)\n else:\n return len(self.mol.normal_modes.modes.freqs)","def tot_num_of_progenitors_at_z(self, SH, mtree, z1, z2):\n \n for ss in range(z1, z2+1):\n print('redshift:', ss)\n # nodes at redshift ss\n ss_indx = np.where(mtree.data.snapshotNumber.values == ss)\n nodeID = mtree.data.index.values[ss_indx]\n nodeID_desc = mtree.data.descendantIndex.values[ss_indx]\n \n # find number of progenitors for nodes at redshift ss\n if ss != z1:\n progcounts = np.zeros(len(nodeID), dtype=int)\n for ii in range(len(nodeID_past_desc)):\n if nodeID_past_desc[ii] in nodeID:\n indx = np.where(nodeID == nodeID_past_desc[ii])\n progcounts[indx] = count[ii]\n\n nodeID_desc_unique, count = np.unique(nodeID_desc, return_counts=True)\n nodeID_desc_unique=nodeID_desc_unique[1:]; count=count[1:]\n \n # add progenitors of progenitors\n if ss != z1:\n for ii in range(len(nodeID)):\n if progcounts[ii] > 1:\n indx = np.where(nodeID_desc_unique == nodeID_desc[ii])\n count[indx] += progcounts[ii] - 1\n\n nodeID_past = nodeID\n nodeID_past_desc = nodeID_desc_unique\n return nodeID, progcounts","def nits(self):","def calculate_dimensions(self):\n x_coordinates = np.sort(self.grid['x'][:, 0]) # first x node\n self.nr_nodes_z = np.where(x_coordinates == x_coordinates[0])[0].size\n self.nr_elements_x = self.elements.shape[0] / (self.nr_nodes_z - 1)\n self.nr_nodes_x = self.nr_elements_x + 1\n self.nr_elements_z = self.nr_nodes_z - 1","def GetGC(flanks):\n gc = 0\n total = 0\n for i in flanks:\n if i != \"N\":\n total += 1\n if i == \"C\" or i == \"G\": gc += 1\n return gc*1.0/total","def num_tokens(self, index):\r\n raise NotImplementedError","def freq():","def total_chunks(self) -> global___Expression:","def stats(self):\n nqbits = self.operator.num_qubits","def calcAverage_g(model_type, N = 2, k = 1000):\n a = 0\n for i in range(k):\n hyp = model_type(N);\n a += hyp.w \n return a/k","def test_count_genomic_types(self):\n \n result, bed_result = parse_AS_STRUCTURE_dict(\"test\", clipper.test_dir())\n result = count_genomic_types(result)\n \n self.assertDictEqual(result, {\"CE:\" : 14})","def num_atoms(self):\n return self.h5['{}/{}'.format(SETTINGS, N_ATOMS)][()]","def n_content(dna):\n ncount = dna.count('N') + dna.count('n') + \\\n dna.count('X') + dna.count('x')\n if ncount == 0:\n return 0.0\n return float(ncount) / float(len(dna))","def zzx_degree(f):\n return len(f) - 1","def freq(self) -> int:","def orbit_count(objects: Dict[str, ObjectMass]) -> int:\n total = 0\n\n for mass in objects.values():\n total += mass.orbit_count()\n\n return total","def checkDiffTypes(self):\n count = 0\n for t in self.types:\n if t > 0:\n count = count + 1\n return count","def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # run model\n K, B = self.params\n n_types = K * np.power(m_tokens, B)\n\n # roundoff\n if nearest_int:\n n_types = np.round(n_types)\n\n # allow scalar\n if return_scalar:\n assert len(n_types) == 1\n n_types = n_types[0]\n\n # return\n return n_types","def ntypes(self): # -> list[None]:\n ..."],"string":"[\n \"def N_z(self) -> int:\\n return self.params.N_z\",\n \"def number_types(corpus):\\n number_of_types = len(set(corpus))\\n return number_of_types\",\n \"def u(self, k, m, z):\\n result = self.ProfNFW.nfw(k, m, z) * self.Ngal(m) / self.nBarGal(1./(1.+z))\\n return result\",\n \"def type_count():\\n types = []\\n for typ in Statistics.all_type():\\n types.append({'label': typ.lower(), 'y': Statistics.type_count(typ)})\\n fix_types = []\\n for i in sorted(types, key=lambda k: k['y']):\\n if i['y'] != 0:\\n fix_types.append(i)\\n return jsonify(result=fix_types)\",\n \"def redshifts2frequencies(z):\\r\\n return 1420e6 / (z + 1)\",\n \"def compute_N(X, language):\\r\\n if language == 'english': \\r\\n global N_ENGLISH \\r\\n N_ENGLISH = len(X)\\r\\n elif language == 'french':\\r\\n global N_FRENCH \\r\\n N_FRENCH = len(X)\",\n \"def n_z(self, level):\\n resolution = self.resolution(level)\\n return (self.z_extent // resolution + 63) // 64\",\n \"def __len__(self):\\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios\",\n \"def __len__(self):\\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios\",\n \"def __len__(self):\\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios\",\n \"def __len__(self):\\n return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios\",\n \"def N(self) -> int:\\n n_types = len(self)\\n return n_types\",\n \"def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\\n\\n # allow scalar\\n return_scalar = np.isscalar(m_tokens)\\n m_tokens = np.array(m_tokens).reshape(-1)\\n\\n # redirect: E(m) = N * formula(m/M)\\n n_types = self.N * self.formula(m_tokens / self.M)\\n\\n # roundoff\\n if nearest_int:\\n n_types = np.round(n_types)\\n\\n # allow scalar\\n if return_scalar:\\n assert len(n_types) == 1\\n n_types = float(n_types)\\n\\n # return number of types\\n return n_types\",\n \"def get_types_count():\\n return len(type_dict.keys())\",\n \"def uN(self, k, m, z, n=1):\\n if n==1:\\n result = self.u(k, m, z)\\n # for the 1-halo profile with an HOD,\\n # you don't just square the 2-halo profile,\\n # although this is only different at very low mass\\n # see Lacasa+13\\n elif n==2:\\n Ncen = self.Ncen(m)\\n Nsat = self.Nsat(m)\\n result = Nsat**2 + 2.*Nsat*Ncen\\n result *= self.ProfNFW.nfw(k, m, z)**2 / self.nBarGal(1./(1.+z))**2\\n else:\\n result = self.u(k, m, z)**n\\n return result\",\n \"def _m(self):\\n return self._k // self._n_classes\",\n \"def get_zdim(self):\\n return self.decoder.get_input_info_dict()['latent_vector'].get_shape()[1]\",\n \"def M_z(self) -> int:\\n return self.params.M_z\",\n \"def M(self) -> int:\\n m_tokens = sum(self.values())\\n return m_tokens\",\n \"def expected_counts(p0, T, n): \\n M=T.shape[0]\\n if n<=M:\\n return ec_matrix_vector(p0, T, n)\\n else:\\n return ec_geometric_series(p0, T, n)\",\n \"def zpkfreqz(z, p, k, worN=None):\\n if worN is None or isinstance(worN, int):\\n N = worN or 512\\n ws = [mp.pi * mp.mpf(j) / N for j in range(N)]\\n else:\\n ws = worN\\n\\n h = []\\n for wk in ws:\\n zm1 = mp.exp(1j * wk)\\n numer = _prod([zm1 - t for t in z])\\n denom = _prod([zm1 - t for t in p])\\n hk = k * numer / denom\\n h.append(hk)\\n return ws, h\",\n \"def accuracy_NMEA(z):\\n N = len(z)\\n size = int(N - 60)\\n sigma = np.zeros(size)\\n for i in range(30, N - 30):\\n z_ave = np.sum(z[(i - 30) : (i + 30)]) / 60\\n sigma[i - 30] = (\\n (np.sum(abs(z[i - 30 : i + 30] - z_ave) ** 2)) / ((60) - 1)\\n ) ** 0.5\\n return sigma\",\n \"def count_NN(KL):\\n zvals = (KL != 0).sum(1)\\n return zvals\",\n \"def number_of_atoms(formula):\\n pass\\n # ======== YOUR CODE HERE ========\",\n \"def specht(mu):\\n return StandardTableaux(mu).cardinality().n()\",\n \"def get_num_classes(self):\",\n \"def calculate(self, tokens: list):\\n vektor_tf_unigram = {}\\n\\n for token in tokens:\\n if token in vektor_tf_unigram:\\n vektor_tf_unigram[token] = vektor_tf_unigram[token] + 1\\n else:\\n vektor_tf_unigram[token] = 1\\n\\n return vektor_tf_unigram\",\n \"def count_types():\\n classes = {\\\"Amenity\\\": Amenity, \\\"City\\\": City,\\n \\\"Place\\\": Place, \\\"Review\\\": Review, \\\"State\\\": State, \\\"User\\\": User}\\n my_dict = {}\\n for key in classes.keys():\\n if (classes[key] == Amenity):\\n my_dict[\\\"amenities\\\"] = storage.count(classes[key])\\n elif (classes[key] == City):\\n my_dict[\\\"cities\\\"] = storage.count(classes[key])\\n elif (classes[key] == Place):\\n my_dict[\\\"places\\\"] = storage.count(classes[key])\\n elif (classes[key] == Review):\\n my_dict[\\\"reviews\\\"] = storage.count(classes[key])\\n elif (classes[key] == State):\\n my_dict[\\\"states\\\"] = storage.count(classes[key])\\n elif (classes[key] == User):\\n my_dict[\\\"users\\\"] = storage.count(classes[key])\\n return (jsonify(my_dict))\",\n \"def dim_reduction( M ):\\n tot_count_per_type = M.sum(axis = 1)\\n tot_count = float(tot_count_per_type.sum())\\n sorted_index = np.argsort(tot_count_per_type)\\n threshold = 0.01\\n accu = 0\\n for i in range(len(sorted_index)):\\n perc = float(tot_count_per_type[sorted_index[i]])/tot_count\\n accu = accu + perc\\n if accu > threshold:\\n break;\\n \\n return sorted_index[0:i]\",\n \"def _get_tr_dataset_size_from_z0(z0):\\n return int(np.round(np.exp(z0)))\",\n \"def Omega_m_z(self, z):\\n return self.Omega_cdm_z(z)+self.Omega_b_z(z)+np.sum(self.Omega_nu_z(z),axis=0)\",\n \"def totlen(inputlist):\\n tot = 0.0\\n for x in inputlist:\\n if isinstance(x, matrix):\\n tot += totlen(x.getitems())\\n else:\\n try:\\n test = len(x)\\n except:\\n tot += 1.0\\n else:\\n tot += test\\n return tot\",\n \"def accuracy_NMEA_opt(z):\\n N = len(z)\\n size = int(N - 60)\\n sigma = np.zeros(size)\\n for i in prange(30, N - 30):\\n z_ave = 0\\n for z_ave_i in z[(i - 30) : (i + 30)]:\\n z_ave += z_ave_i\\n z_ave = z_ave / 60.0\\n\\n noise_sqrt = 0\\n for noise in z[i - 30 : i + 30]:\\n noise_sqrt += abs(noise - z_ave) ** 2\\n sigma[i - 30] = (noise_sqrt / (60.0 - 1.0)) ** 0.5\\n return sigma\",\n \"def tf(xp, yp, zp, prisms, inc, dec, pmag=None):\\n if xp.shape != yp.shape != zp.shape:\\n raise ValueError(\\\"Input arrays xp, yp, and zp must have same shape!\\\")\\n # Calculate the 3 components of the unit vector in the direction of the\\n # regional field\\n fx, fy, fz = giutils.dircos(inc, dec)\\n res = 0\\n for prism in prisms:\\n if prism is None:\\n continue\\n if 'magnetization' not in prism.props and pmag is None:\\n continue\\n if pmag is None:\\n mx, my, mz = prism.props['magnetization']\\n else:\\n mx, my, mz = pmag\\n v1 = kernelxx(xp, yp, zp, prism)\\n v2 = kernelxy(xp, yp, zp, prism)\\n v3 = kernelxz(xp, yp, zp, prism)\\n v4 = kernelyy(xp, yp, zp, prism)\\n v5 = kernelyz(xp, yp, zp, prism)\\n v6 = kernelzz(xp, yp, zp, prism)\\n bx = v1*mx + v2*my + v3*mz\\n by = v2*mx + v4*my + v5*mz\\n bz = v3*mx + v5*my + v6*mz\\n res += fx*bx + fy*by + fz*bz\\n res *= CM * T2NT\\n return res\",\n \"def inertia(mus):\\n pos, negs, zeros = cluster_eignvalues(mus)\\n\\n return len(zeros) + min(len(pos), len(negs))\",\n \"def _count_tokens(self,\\n token_lists):\\n ## Filter out empty lists\\n fn_tokens = list(filter(lambda i: len(i) > 0, token_lists))\\n ## Get N-grams from Tokens\\n fn_ngrams = list(map(lambda t: self.get_ngrams(t, self._ngrams[0], self._ngrams[1]),\\n fn_tokens))\\n ## Count Tokens (binary if class is unfit and binarization turned on)\\n if hasattr(self, \\\"_class_state\\\") and \\\\\\n self._class_state == \\\"untrained\\\" and \\\\\\n hasattr(self, \\\"_binarize_counter\\\") and \\\\\\n self._binarize_counter:\\n fn_counts = Counter(list(set(flatten(fn_ngrams))))\\n else:\\n fn_counts = Counter(flatten(fn_ngrams))\\n return fn_counts\",\n \"def _get_token_cnts(self, doc, doc_type):\\n tokenized_doc = self.nlp(doc)\\n self.stat_dict[doc_type][0].append(len([s for s in tokenized_doc.sents]))\\n doc_len = len([t for t in tokenized_doc])\\n self.stat_dict[doc_type][1].append(doc_len)\\n if doc_len < 50 and doc_type == \\\"answer\\\":\\n print(\\\"Document less than 50 tokens:\\\", url)\",\n \"def nnz(self):\\n t = self.get_MSC()\\n return len(np.unique(t['masks']))\",\n \"def nnz(self):\",\n \"def get_ntype_counts_map(ntypes, ntype_counts):\\n return dict(zip(ntypes, ntype_counts))\",\n \"def Omega_nu_z(self, z):\\n MM,ZZ = np.meshgrid(np.atleast_1d(self.M_nu),np.atleast_1d(z),indexing='ij')\\n Y = MM/((1.+ZZ)*const.kB*self.T_nu)\\n F = self.FermiDirac_integral(Y)\\n GN = self.Gamma_nu**4.\\n onuz = 15./np.pi**4.*self.Omega_gamma*F*GN*(1.+ZZ)**4.*self.H0**2./np.atleast_2d(self.H(z)**2.)\\n return onuz\",\n \"def affichage_stats_globales(liste_typexp):\\n print(\\\"-\\\"*50)\\n total = 0\\n for typexp in liste_typexp:\\n print(f\\\"{typexp.type_mwe} : {len(typexp.mwes)}\\\")\\n total += len(typexp.mwes)\\n print(f\\\"TOTAL : {total}\\\")\",\n \"def count(\\n type_signature: computation_types.Type, predicate: _TypePredicate\\n) -> int:\\n one_or_zero = lambda t: 1 if predicate(t) else 0\\n return sum(map(one_or_zero, preorder_types(type_signature)))\",\n \"def get_lensum_dtype(nbin, shear_style):\\n dt=[('index','i8'),\\n ('weight','f8'),\\n ('totpairs','i8'),\\n\\n #('xxsum','f8'),\\n #('xysum','f8'),\\n #('yysum','f8'),\\n\\n ('npair','i8',nbin),\\n\\n ('rsum','f8',nbin),\\n ('wsum','f8',nbin),\\n ('dsum','f8',nbin),\\n ('osum','f8',nbin)]\\n\\n if shear_style=='lensfit':\\n dt+=[('dsensum','f8',nbin),\\n ('osensum','f8',nbin)]\\n\\n return dt\",\n \"def GetStereoisomerCount(m, options=...): # -> Any:\\n ...\",\n \"def nfw(self, k, m, z):\\n RS, rhoS, c = self.rS_rhoS_c(m, z)\\n #\\n result = np.sin(k * RS) * ( Si((1+c) * k * RS) - Si(k * RS) )\\n result += - np.sin(c * k * RS) / ((1+c) * k * RS)\\n result += np.cos(k * RS) * ( Ci((1+c) * k * RS) - Ci(k * RS) )\\n result /= (np.log(1+c) - c/(1+c))\\n return result\",\n \"def nfw(self, k, m, z):\\n RS, rhoS, c = self.rS_rhoS_c(m, z)\\n #\\n result = np.sin(k * RS) * ( Si((1+c) * k * RS) - Si(k * RS) )\\n result += - np.sin(c * k * RS) / ((1+c) * k * RS)\\n result += np.cos(k * RS) * ( Ci((1+c) * k * RS) - Ci(k * RS) )\\n result /= (np.log(1+c) - c/(1+c))\\n return result\",\n \"def subtype_counts(node_set, G, log=False):\\n subtypes = Counter()\\n for n in node_set:\\n subtype = G.node[n]['subtype']\\n subtypes[subtype] += 1\\n\\n if log:\\n for k, v in subtypes.items():\\n subtypes[k] = np.log10(v)\\n \\n return subtypes\",\n \"def nze(self) -> int:\",\n \"def nze(self) -> int:\",\n \"def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\\n\\n # allow scalar\\n return_scalar = np.isscalar(m_tokens)\\n m_tokens = np.array(m_tokens).reshape(-1)\\n\\n # sum over legomena coefficients k\\n x = m_tokens / self.M\\n exponents = range(len(self.k))\\n terms = np.array([np.power(1 - x, n) for n in exponents])\\n k_0 = np.dot(self.k, terms)\\n n_types = self.N - k_0\\n\\n # roundoff\\n if nearest_int:\\n n_types = np.round(n_types)\\n\\n # allow scalar\\n if return_scalar:\\n assert len(n_types) == 1\\n n_types = n_types[0]\\n\\n # return\\n return n_types\",\n \"def count_terms(self, tokens):\\n\\n terms = [self.term_match(t) for t in tokens ]\\n \\n terms = [t for t in terms if t != None]\\n\\n #print terms\\n lf = dict(Counter(terms))\\n for k in lf:\\n lf[k] /= float(len(tokens))\\n #lf[k] = 1 # binarize?\\n pass\\n return lf\",\n \"def by(xp, yp, zp, prisms):\\n if xp.shape != yp.shape != zp.shape:\\n raise ValueError(\\\"Input arrays xp, yp, and zp must have same shape!\\\")\\n res = 0\\n for prism in prisms:\\n if prism is None or ('magnetization' not in prism.props):\\n continue\\n # Get the magnetization vector components\\n mx, my, mz = prism.props['magnetization']\\n v2 = kernelxy(xp, yp, zp, prism)\\n v4 = kernelyy(xp, yp, zp, prism)\\n v5 = kernelyz(xp, yp, zp, prism)\\n res += v2*mx + v4*my + v5*mz\\n res *= CM * T2NT\\n return res\",\n \"def gal_count(clusters):\\n sum = 0\\n for x in clusters:\\n sum += x.ngal\\n return sum\",\n \"def n():\\n # For documentation purposes\",\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 calculate_number_of_stems(data: Data, node_types: Optional[List[int]]):\\n\\n soma = data.morphology.get_soma()\\n if node_types:\\n return len(data.morphology.get_children_of_node_by_types(soma, node_types))\\n else:\\n return len(data.morphology.children_of(soma))\",\n \"def _getKramerStatistic_(seq, n, F):\\n S = 0.0\\n for i in range(n):\\n S += (F(seq[i]) - (2 * i - 1) / (2 * n)) ** 2\\n return 1 / (12 * n) + S\",\n \"def length_uc(x):\\r\\n return sum(length(m) for m in metamer(x))\",\n \"def _get_total_ngrams(n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]]) ->Dict[int, Tensor]:\\n total_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n for n in n_grams_counts:\\n total_n_grams[n] = tensor(sum(n_grams_counts[n].values()))\\n return total_n_grams\",\n \"def test_N_atoms():\\n structure = Material(input)\\n assert (structure.N_atoms(22) == 36110850351331465494528)\",\n \"def model_numel(model, param_dims=[2, 4], param_types=['weight', 'bias']):\\n total_numel = 0\\n for name, param in model.state_dict().items():\\n # Extract just the actual parameter's name, which in this context we treat as its \\\"type\\\"\\n if param.dim() in param_dims and any(type in name for type in param_types):\\n total_numel += torch.numel(param)\\n return total_numel\",\n \"def testatomnos(self):\\r\\n # This will work only for numpy\\r\\n #self.assertEqual(self.data.atomnos.dtype.char, 'i')\\r\\n\\r\\n atomnos_types = [numpy.issubdtype(atomno, numpy.signedinteger)\\r\\n for atomno in self.data.atomnos]\\r\\n assert numpy.alltrue(atomnos_types)\\r\\n\\r\\n assert self.data.atomnos.shape == (20,)\\r\\n\\r\\n count_C = sum(self.data.atomnos == 6)\\r\\n count_H = sum(self.data.atomnos == 1)\\r\\n assert count_C + count_H == 20\",\n \"def compute_morpheme_length(attribs):\\n num_morphemes = 0\\n for m in attribs:\\n if m:\\n if type(m) == list:\\n num_morphemes += len(m)\\n else:\\n num_morphemes += 1\\n if num_morphemes == 0: #To be consistent with the previous functionality\\n return None\\n return num_morphemes\",\n \"def numnems(self):\\n count = 0\\n for o in self._objs.values():\\n count += len(o.netifs())\\n return count\",\n \"def totalize_natures(sv):\\r\\n tot=0 \\r\\n for nod in sv.Object.values():\\r\\n tot+=len(nod.nature)\\r\\n return tot\",\n \"def flops_count(model):\\n count = 0\\n for n, m in model.named_modules():\\n if isinstance(m, nn.Linear):\\n count += m.in_features * m.out_features + m.bias.numel()\\n return count\",\n \"def getNumberTerms(content): \\n return Counter(getTerms(content))\",\n \"def n_classes(self):\\n raise NotImplementedError\",\n \"def n_classes(self):\\n raise NotImplementedError\",\n \"def count_rotation_numels(model):\\n total = 0\\n for m in model.modules():\\n if isinstance(m, (ConvLayerRotation, LinearLayerRotation)):\\n total += m.rotation_matrix.numel()\\n return total\",\n \"def getNtot(self,dir):\\n return int(readfile(dir + '/struct_enum.out')[-1].split()[0])\",\n \"def nnz(self):\\n\\t\\treturn self.st.size()\",\n \"def tag_counts(self, types=[]):\\n if not types:\\n types = self.tag_types\\n for tag_type in types:\\n print \\\"\\\\t%15s : %-10s\\\" % (tag_type, len(self.tag_dictionary[tag_type]))\",\n \"def ntypes(self): # -> None:\\n ...\",\n \"def nNz(self):\\n if self.dim < 3:\\n return None\\n return self.nCz + 1\",\n \"def z(self) -> int:\",\n \"def nfactors(self):\\n return self.L.nnz\",\n \"def extinction_lenght(keV, Z, hkl, th0=0.):\\n return keV/ (extinction_constant(Z, hkl, th0=0.))\",\n \"def utr3_motif_counts(self, pattern):\\n return len(re.findall(pattern.upper(), self.three_prime_utr_sequence.upper()))\",\n \"def term_frequency(ngrams,lang):\\n token_dictionary = {}\\n for ng in ngrams:\\n try:\\n token_dictionary[ng] = token_dictionary[ng] + 1\\n except KeyError:\\n token_dictionary[ng] = 1\\n return token_dictionary\",\n \"def nmodes(self):\\n if self.mode_selection is not None:\\n return len(self.mode_selection)\\n else:\\n return len(self.mol.normal_modes.modes.freqs)\",\n \"def tot_num_of_progenitors_at_z(self, SH, mtree, z1, z2):\\n \\n for ss in range(z1, z2+1):\\n print('redshift:', ss)\\n # nodes at redshift ss\\n ss_indx = np.where(mtree.data.snapshotNumber.values == ss)\\n nodeID = mtree.data.index.values[ss_indx]\\n nodeID_desc = mtree.data.descendantIndex.values[ss_indx]\\n \\n # find number of progenitors for nodes at redshift ss\\n if ss != z1:\\n progcounts = np.zeros(len(nodeID), dtype=int)\\n for ii in range(len(nodeID_past_desc)):\\n if nodeID_past_desc[ii] in nodeID:\\n indx = np.where(nodeID == nodeID_past_desc[ii])\\n progcounts[indx] = count[ii]\\n\\n nodeID_desc_unique, count = np.unique(nodeID_desc, return_counts=True)\\n nodeID_desc_unique=nodeID_desc_unique[1:]; count=count[1:]\\n \\n # add progenitors of progenitors\\n if ss != z1:\\n for ii in range(len(nodeID)):\\n if progcounts[ii] > 1:\\n indx = np.where(nodeID_desc_unique == nodeID_desc[ii])\\n count[indx] += progcounts[ii] - 1\\n\\n nodeID_past = nodeID\\n nodeID_past_desc = nodeID_desc_unique\\n return nodeID, progcounts\",\n \"def nits(self):\",\n \"def calculate_dimensions(self):\\n x_coordinates = np.sort(self.grid['x'][:, 0]) # first x node\\n self.nr_nodes_z = np.where(x_coordinates == x_coordinates[0])[0].size\\n self.nr_elements_x = self.elements.shape[0] / (self.nr_nodes_z - 1)\\n self.nr_nodes_x = self.nr_elements_x + 1\\n self.nr_elements_z = self.nr_nodes_z - 1\",\n \"def GetGC(flanks):\\n gc = 0\\n total = 0\\n for i in flanks:\\n if i != \\\"N\\\":\\n total += 1\\n if i == \\\"C\\\" or i == \\\"G\\\": gc += 1\\n return gc*1.0/total\",\n \"def num_tokens(self, index):\\r\\n raise NotImplementedError\",\n \"def freq():\",\n \"def total_chunks(self) -> global___Expression:\",\n \"def stats(self):\\n nqbits = self.operator.num_qubits\",\n \"def calcAverage_g(model_type, N = 2, k = 1000):\\n a = 0\\n for i in range(k):\\n hyp = model_type(N);\\n a += hyp.w \\n return a/k\",\n \"def test_count_genomic_types(self):\\n \\n result, bed_result = parse_AS_STRUCTURE_dict(\\\"test\\\", clipper.test_dir())\\n result = count_genomic_types(result)\\n \\n self.assertDictEqual(result, {\\\"CE:\\\" : 14})\",\n \"def num_atoms(self):\\n return self.h5['{}/{}'.format(SETTINGS, N_ATOMS)][()]\",\n \"def n_content(dna):\\n ncount = dna.count('N') + dna.count('n') + \\\\\\n dna.count('X') + dna.count('x')\\n if ncount == 0:\\n return 0.0\\n return float(ncount) / float(len(dna))\",\n \"def zzx_degree(f):\\n return len(f) - 1\",\n \"def freq(self) -> int:\",\n \"def orbit_count(objects: Dict[str, ObjectMass]) -> int:\\n total = 0\\n\\n for mass in objects.values():\\n total += mass.orbit_count()\\n\\n return total\",\n \"def checkDiffTypes(self):\\n count = 0\\n for t in self.types:\\n if t > 0:\\n count = count + 1\\n return count\",\n \"def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\\n\\n # allow scalar\\n return_scalar = np.isscalar(m_tokens)\\n m_tokens = np.array(m_tokens).reshape(-1)\\n\\n # run model\\n K, B = self.params\\n n_types = K * np.power(m_tokens, B)\\n\\n # roundoff\\n if nearest_int:\\n n_types = np.round(n_types)\\n\\n # allow scalar\\n if return_scalar:\\n assert len(n_types) == 1\\n n_types = n_types[0]\\n\\n # return\\n return n_types\",\n \"def ntypes(self): # -> list[None]:\\n ...\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61090994","0.59217143","0.57628566","0.5695817","0.5647362","0.5589493","0.5542256","0.5515717","0.5515717","0.5515717","0.5515717","0.549887","0.5479429","0.54610664","0.5381827","0.5371367","0.5367791","0.53463715","0.5344861","0.5344521","0.52981734","0.52927595","0.52597475","0.52507395","0.52487946","0.5244186","0.52213186","0.5208117","0.5197901","0.5188402","0.5182176","0.5145929","0.5136509","0.5123768","0.5117417","0.5110196","0.51063603","0.51036114","0.50993496","0.5085089","0.5078605","0.5063263","0.50617033","0.50613266","0.50520194","0.50519896","0.50519896","0.50442576","0.50427413","0.50427413","0.5037907","0.5035702","0.50326854","0.5031114","0.5027503","0.49957108","0.49894047","0.49864987","0.49791303","0.49652433","0.49640584","0.49560678","0.4952998","0.49526915","0.49483463","0.49468914","0.49459347","0.49356422","0.49283063","0.49283063","0.49273968","0.4926335","0.4925572","0.49250245","0.49242324","0.49239123","0.49222898","0.49179113","0.49057972","0.49042994","0.48950362","0.48918343","0.4876646","0.48718023","0.48612064","0.4857663","0.48572996","0.48555544","0.4850595","0.48489112","0.48481685","0.48481545","0.48400024","0.48348033","0.48345527","0.48316884","0.48295036","0.4828768","0.48250633","0.48215717"],"string":"[\n \"0.61090994\",\n \"0.59217143\",\n \"0.57628566\",\n \"0.5695817\",\n \"0.5647362\",\n \"0.5589493\",\n \"0.5542256\",\n \"0.5515717\",\n \"0.5515717\",\n \"0.5515717\",\n \"0.5515717\",\n \"0.549887\",\n \"0.5479429\",\n \"0.54610664\",\n \"0.5381827\",\n \"0.5371367\",\n \"0.5367791\",\n \"0.53463715\",\n \"0.5344861\",\n \"0.5344521\",\n \"0.52981734\",\n \"0.52927595\",\n \"0.52597475\",\n \"0.52507395\",\n \"0.52487946\",\n \"0.5244186\",\n \"0.52213186\",\n \"0.5208117\",\n \"0.5197901\",\n \"0.5188402\",\n \"0.5182176\",\n \"0.5145929\",\n \"0.5136509\",\n \"0.5123768\",\n \"0.5117417\",\n \"0.5110196\",\n \"0.51063603\",\n \"0.51036114\",\n \"0.50993496\",\n \"0.5085089\",\n \"0.5078605\",\n \"0.5063263\",\n \"0.50617033\",\n \"0.50613266\",\n \"0.50520194\",\n \"0.50519896\",\n \"0.50519896\",\n \"0.50442576\",\n \"0.50427413\",\n \"0.50427413\",\n \"0.5037907\",\n \"0.5035702\",\n \"0.50326854\",\n \"0.5031114\",\n \"0.5027503\",\n \"0.49957108\",\n \"0.49894047\",\n \"0.49864987\",\n \"0.49791303\",\n \"0.49652433\",\n \"0.49640584\",\n \"0.49560678\",\n \"0.4952998\",\n \"0.49526915\",\n \"0.49483463\",\n \"0.49468914\",\n \"0.49459347\",\n \"0.49356422\",\n \"0.49283063\",\n \"0.49283063\",\n \"0.49273968\",\n \"0.4926335\",\n \"0.4925572\",\n \"0.49250245\",\n \"0.49242324\",\n \"0.49239123\",\n \"0.49222898\",\n \"0.49179113\",\n \"0.49057972\",\n \"0.49042994\",\n \"0.48950362\",\n \"0.48918343\",\n \"0.4876646\",\n \"0.48718023\",\n \"0.48612064\",\n \"0.4857663\",\n \"0.48572996\",\n \"0.48555544\",\n \"0.4850595\",\n \"0.48489112\",\n \"0.48481685\",\n \"0.48481545\",\n \"0.48400024\",\n \"0.48348033\",\n \"0.48345527\",\n \"0.48316884\",\n \"0.48295036\",\n \"0.4828768\",\n \"0.48250633\",\n \"0.48215717\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57100254"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":91792,"cells":{"query":{"kind":"string","value":"Applies the log formula to model the kvector as a function of tokens."},"document":{"kind":"string","value":"def predict_k(\n self,\n m_tokens: np.ndarray,\n dim: int,\n normalize: bool = False,\n nearest_int: bool = True,\n ) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # retrieve fitting parameters\n M_z, N_z = self.params\n\n # scale down to normalized log formula\n x = m_tokens / M_z\n k_frac = self.formula(x, dim)\n\n # normalize, or don't\n if normalize:\n # predicted counts as a proportion of predicted types\n y_types_omitted = k_frac[:, 0]\n y_types_selected = 1 - y_types_omitted\n y_types_selected = y_types_selected[:, np.newaxis]\n k = k_frac / y_types_selected\n else:\n # predicted counts\n k = N_z * k_frac\n\n # roundoff\n if nearest_int:\n k = np.round(k)\n\n # allow scalar\n if return_scalar:\n assert len(k) == 1\n k = k.squeeze()\n\n # return n-legomena counts\n return k"},"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 log_likelihood(self) -> tf.Tensor:\n # K⁻¹ + GᵀΣ⁻¹G = LLᵀ.\n l_post = self._k_inv_post.cholesky\n num_data = self.observations_index.shape[0]\n\n # Hμ [..., num_transitions + 1, output_dim]\n marginal = self.emission.project_state_to_f(self.prior_ssm.marginal_means)\n marginal = self._drop_batch_shape(marginal)\n\n # y = obs - Hμ [..., num_transitions + 1, output_dim]\n disp = self.observations - marginal\n disp_data = self.sparse_observations - self.dense_to_sparse(marginal)\n\n # cst is the constant term for a gaussian log likelihood\n cst = (\n -0.5 * np.log(2 * np.pi) * tf.cast(self.emission.output_dim * num_data, default_float())\n )\n\n term1 = -0.5 * tf.reduce_sum(\n input_tensor=tf.einsum(\"...op,...p,...o->...o\", self._r_inv_data, disp_data, disp_data), axis=[-1, -2]\n )\n\n # term 2 is: ½|L⁻¹(GᵀΣ⁻¹)y|²\n # (GᵀΣ⁻¹)y [..., num_transitions + 1, state_dim]\n obs_proj = self._back_project_y_to_state(disp)\n\n # ½|L⁻¹(GᵀΣ⁻¹)y|² [...]\n term2 = 0.5 * tf.reduce_sum(\n input_tensor=tf.square(l_post.solve(obs_proj, transpose_left=False)), axis=[-1, -2]\n )\n\n ## term 3 is: ½log |K⁻¹| - log |L| + ½ log |Σ⁻¹|\n # where log |Σ⁻¹| = num_data * log|R⁻¹|\n term3 = (\n 0.5 * self.prior_ssm.log_det_precision()\n - l_post.abs_log_det()\n + 0.5 * self._log_det_observation_precision\n )\n\n return tf.reduce_sum(cst + term1 + term2 + term3)","def logm(self, x):\n\n if K.backend() == 'theano':\n # construct theano tensor operation\n from theano.tensor.nlinalg import svd, diag\n from theano.tensor.elemwise import Elemwise\n from theano.scalar import log\n import theano.tensor as T\n # This implementation would be extremely slow. but efficient?\n u, d, v = svd(x)\n d += self.eps\n inner = diag(T.log(d))\n res = T.dot(u, T.dot(inner, v))\n return res\n else:\n from kyu.tensorflow.ops.svd_gradients import batch_matrix_log\n return batch_matrix_log(x, self.eps)","def kld(mu, log_var):\n return (mu + log_var).sum() # TODO Your code goes here.","def log_marg_k(self, k):\n k_N = self.prior.k_0 + self.counts[k]\n v_N = self.prior.v_0 + self.counts[k]\n m_N = self.m_N_numerators[k]/k_N\n S_N = self.S_N_partials[k] - k_N*np.square(m_N)\n return (\n - self.counts[k]*self.D/2.*self._cached_log_pi\n + self.D/2.*math.log(self.prior.k_0) - self.D/2.*math.log(k_N)\n + self.prior.v_0/2.*np.log(self.prior.S_0).sum()\n - v_N/2.*np.log(S_N).sum()\n + self.D*(self._cached_gammaln_by_2[v_N] - self._cached_gammaln_by_2[self.prior.v_0])\n )","def log(self): # just use base?\n return Factor().__build( VarSet(self.v) , np.log(self.t) )","def get_logCRF(train, model):\n word = train[0]\n Y = train[1]\n char_count, _ = word.shape\n # calculating forward messages\n alpha = np.zeros((char_count, model.dimY))\n first_term = np.dot(word, model.getW(model.labels))\n second_term = model._T\n for i in range(1, char_count):\n sum_term = (first_term[i-1] + alpha[i-1]) + second_term\n alpha[i] = np.apply_along_axis(logsumexp_trick, 1, sum_term) \n # getting logZ from messages\n logZ = logsumexp_trick(first_term[char_count-1]+alpha[char_count-1])\n w_term = np.sum(model.getW(Y).transpose() * word) # $\\sum_{j=1}^m {W_{yj} . x_j}$\n t_term = np.sum(model.getT(Y[:-1], Y[1:])) #$T_{yj, yj+1}\n value = -logZ + w_term + t_term\n return value","def log10(self):\n return Factor().__build( VarSet(self.v) , np.log10(self.t) )","def formula_0(x: np.ndarray) -> np.ndarray:\n logx = np.log(x)\n denom = x - 1\n k0 = (x - logx * x - 1) / denom\n return k0","def loglik(alpha,gamma_list,M,k):\n psi_sum_gamma=np.array(list(map(lambda x: psi(np.sum(x)),gamma_list))).reshape((M,1)) # M*1 \n psi_gamma=psi(np.array(gamma_list)) # M*k matrix\n L=M*gammaln(np.sum(alpha)-np.sum(gammaln(alpha)))+np.sum((psi_gamma-psi_sum_gamma)*(alpha.reshape((1,k))-1))\n return L","def _loglike(self, y, f):\n bincoef = tf.lgamma(self.n + 1) - tf.lgamma(y + 1) \\\n - tf.lgamma(self.n - y + 1)\n ll = bincoef + y * tf.log(pos(f)) + (self.n - y) * tf.log(pos(1 - f))\n return ll","def logTF(self, tf):\n return math.log(tf)","def _log_matrix_vector(ms, vs):\n return tf.reduce_logsumexp(ms + vs[..., tf.newaxis, :], axis=-1)","def log_marginal_likelihood(X_train,y_train,phi,tau=1.,Ve=1.e-10):","def log_forward_computations(self, x: list): \n n_x = len(x)\n \n # log_f_x initialized to -Inf because log(0) = -Inf\n log_f_x = np.zeros((self.n_states, n_x)) + logzero()\n x_emission_scores = np.array([self.scores['emission'][:, self.word_to_pos[w] if w in list(self.word_to_pos.keys()) else self.word_to_pos['UnknownWord']] for w in x]).T\n \n log_f_x[:,0] = x_emission_scores[:, 0] + self.scores['initial']\n \n for i in range(1,n_x):\n for s in range(self.n_states):\n log_f_x[s,i] = logsumexp(self.scores['transition'][s,:] + \n log_f_x[:,i-1]) + x_emission_scores[s, i]\n\n \n log_likelihood = logsumexp(self.scores['final'] + log_f_x[:,-1])\n \n return log_f_x, log_likelihood","def my_loglike(theta, x, data, sigma):\n\n model = my_model(theta, x)\n\n return -0.5*len(x)*np.log(2*math.pi*sigma**2) - (0.5/sigma**2) * np.sum((data-model)**2)","def _loglike(self, y, f):\n ll = y * tf.log(pos(f)) + (1 - y) * tf.log(pos(1 - f))\n return ll","def call(self, x, mask=None):\n if K.backend() == 'theano':\n from theano import scan\n components, update = scan(fn=lambda tx: self.logm(tx),\n outputs_info=None,\n sequences=[x],\n non_sequences=None)\n\n return components\n else:\n if self.built:\n # return self.logm(x)\n from kyu.tensorflow.ops.svd_gradients import gradient_eig_for_log\n import tensorflow as tf\n # g = tf.get_default_graph()\n\n # s, u, v = tf.svd(x)\n s, u = tf.self_adjoint_eig(x)\n s = tf.abs(s)\n inner = s + self.eps\n # inner = tf.Print(inner, [inner], message='log_inner before:')\n\n inner = tf.log(inner)\n # inner = tf.Print(inner, [inner], message='log_inner :')\n inner = tf.where(tf.is_nan(inner), tf.zeros_like(inner), inner)\n inner = tf.matrix_diag(inner)\n tf_log = tf.matmul(u, tf.matmul(inner, tf.transpose(u, [0, 2, 1])))\n return tf_log\n\n else:\n raise RuntimeError(\"Log transform layer should be built before using\")","def log_poisson(k, l):\n return k*np.log(l) -l - gammaln(k+1)","def log_likelihood(self):\n return -0.5*self.D*self.K_logdet + self._model_fit_term() + self.likelihood.Z","def log2(self):\n return Factor().__build( VarSet(self.v) , np.log2(self.t) )","def log_likelihood(self):\r\n assert not self.likelihood.is_heteroscedastic\r\n A = -0.5*self.batchsize*self.output_dim*(np.log(2.*np.pi) - np.log(self.likelihood.precision))\r\n B = -0.5*self.likelihood.precision*self.output_dim*self.trace_K\r\n Kmm_logdet = 2.*np.sum(np.log(np.diag(self.Lm)))\r\n C = -0.5*self.output_dim*self.data_prop*(Kmm_logdet-self.q_u_logdet - self.num_inducing)\r\n C += -0.5*np.sum(self.LQL * self.B)\r\n D = -0.5*self.likelihood.precision*self.likelihood.trYYT\r\n E = np.sum(self.V*self.projected_mean)\r\n return (A+B+C+D+E)/self.data_prop","def logm(C):\n theta_x = so2.logm(C[:2,:2])\n u = getVi(C).dot(C[:2,2])\n return np.concatenate((\n np.concatenate(( theta_x, u[:,np.newaxis]), axis=1),\n [[0, 0, 0]]\n ))\n\n # make matrix \n # tx = so2.logm(C[:2,:2])\n # t = so2.algi(tx)\n # # if np.abs(t)<1e-2: \n # # stt = lie.TaylorSinXoverX(t)\n # # ctt = lie.TaylorOneMinusCosXOverX(t)\n # # else:\n # # stt = np.sin(t)/t\n # # ctt = (1-np.cos(t))/t\n # #\n # # A = stt; B = ctt\n # # Vi = (1 / (A**2 + B**2)) * np.array([[A, B], [-B, A]])\n # Vi = getVi(C)\n #\n # d = C[:2,2]\n # u = Vi.dot(d)\n #\n # return alg(np.concatenate(( u, [t] )))","def folded_voigt_kernel_logst(k,log_nstbeta,log_ngammaL,dLarray):\n\n beta=jnp.exp(log_nstbeta)\n gammaL=jnp.exp(log_ngammaL)\n def ffold(val,dL):\n val=val+jnp.exp(-2.0*((jnp.pi*beta*(k[:,None]+dL))**2 \\\n + jnp.pi*gammaL[None,:]*(k[:,None]+dL)))\n val=val+jnp.exp(-2.0*((jnp.pi*beta*(k[:,None]-dL))**2 \\\n + jnp.pi*gammaL[None,:]*(dL-k[:,None])))\n null=0.0\n return val, null\n val=jnp.exp(-2.0*((jnp.pi*beta*k[:,None])**2 + jnp.pi*gammaL[None,:]*k[:,None]))\n \n val,nullstack=scan(ffold, val, dLarray)\n \n return val","def calc_tf_log(doc):\r\n tf = calc_tf(doc)\r\n max_tf = tf[max(tf, key=tf.get)]\r\n tf_log = {}\r\n for key, val in tf.items():\r\n tf_log[key] = (1 + math.log(val)) / (1 + math.log(max_tf))\r\n return tf_log","def _log_vector_matrix(vs, ms):\n return tf.reduce_logsumexp(vs[..., tf.newaxis] + ms, axis=-2)","def log_pmf(self, k, name=\"log_pmf\"):\n with ops.name_scope(self.name):\n with ops.op_scope([self.logits, k], name):\n k = ops.convert_to_tensor(k, name=\"k\")\n return batch_index(self.logits, k)","def log_operator(SE3): \n #print('SE3 log: ', SE3)\n R = SE3[:3,:3]\n t = SE3[:3,3]\n theta = arccos(0.5*(trace(R)-1)) # radians\n lnR = 0.5*(theta/sin(theta))*(R-R.T)\n omega = vee(lnR) # vee operator\n omega_skew_sym = lnR#skew_symmetric(omega.reshape(-1,))\n \n if theta <= 1e-10:\n V = eye(3)\n else:\n V = eye(3) + \\\n (theta**-2)*(1-cos(theta))*omega_skew_sym + \\\n (theta**-3)*(theta-sin(theta))*(omega_skew_sym @ omega_skew_sym)\n neu = inv(V) @ t\n\n # if theta <= 1e-10:\n # Vinv = eye(3)\n # else:\n # theta_half = 0.5*theta \n # Vinv = eye(3) - 0.5*omega_skew_sym + \\\n # (theta**-2)*(1- (theta_half*cos(theta_half)/sin(theta_half)))*(omega_skew_sym @ omega_skew_sym)\n # neu = Vinv @ t\n\n return np.hstack((neu, omega)).reshape(-1,1)","def forward(self, x):\n\n embeds = self.dvector(x)\n logits = self.linear(embeds)\n\n return logits","def log_det_K(self, Ks=None):\n log_det = 0.\n for K in self.Ks:\n rank_d = self.n / K.shape[0]\n det = np.linalg.slogdet(K)[1]\n log_det += rank_d * det\n return log_det","def log_likelihood(self):\r\n return (-0.5 * self.num_data * self.output_dim * np.log(2.*np.pi) -\r\n 0.5 * self.output_dim * self.K_logdet + self._model_fit_term() + self.likelihood.Z)","def kullbackLeibler(mu, log_sigma):\n # (tf.Tensor, tf.Tensor) -> tf.Tensor\n # = -0.5 * (1 + log(sigma**2) - mu**2 - sigma**2)\n return -0.5 * tf.reduce_sum(1 + 2 * log_sigma - mu**2 - tf.exp(2 * log_sigma), 1)","def log_det_K(self, Ks=None):\n Ks = self.Ks if Ks is None else Ks\n log_det = 0.\n for K in Ks:\n rank_d = self.m / K.shape[0]\n det = np.linalg.slogdet(K)[1]\n log_det += rank_d * det\n return log_det","def loglf2py(store):\n loglike=0.0\n return loglinear.logl(store['xb'],store['xmatf'], store['beta'],store['yvec'],loglike)","def calculate_likelihood(truth, log_forecast):\n\n return tf.reduce_sum(truth * log_forecast) # Dimensions [batch_size, N_LABEL_TIMESTEPS, N_LABEL_CLASSES]","def nllfun(x):\n mu = x[0]\n logsigma = x[1]\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)","def nllfun(x):\n mu = x[0]\n logsigma = x[1]\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)","def log_normal(x, m, log_v):\n ################################################################################\n # TODO: Modify/complete the code here\n # Compute element-wise log probability of normal and remember to sum over\n # the last dimension\n ################################################################################\n # print(\"q_m\", m.size())\n # print(\"q_v\", v.size())\n const = -0.5 * x.size(-1) * torch.log(2 * torch.tensor(np.pi))\n # print(const.size())\n log_det = -0.5 * torch.sum(log_v, dim=-1)\n # print(\"log_det\", log_det.size())\n log_exp = -0.5 * torch.sum((x - m) ** 2 / (log_v.exp()), dim=-1)\n\n log_prob = const + log_det + log_exp\n\n ################################################################################\n # End of code modification\n ################################################################################\n return log_prob","def log_marginal_likelihood(self) -> tf.Tensor:\n L = tf.linalg.cholesky(self.likelihood.add_to(self.KXX))\n return tf.reduce_sum(multivariate_normal(self._Y, self._mean, L))","def logsumexp(logv):\n res = logzero()\n for val in logv:\n res = logsum_pair(res, val)\n return res","def _loglike(self, y, f):\n ll = -0.5 * (tf.log(2 * self.variance * np.pi) +\n (y - f)**2 / self.variance)\n return ll","def logistic(self,w,Xi):\n # print(w.T)\n # print(Xi)\n a = np.dot(w.T,Xi)\n return 1/(1+np.exp(-a))","def _loglike(self, y, f):\n # sum along last axis, which is assumed to be the `tasks` axis\n ll = tf.reduce_sum(y * tf.log(pos(f)), axis=-1)\n return ll","def log_factorial(k):\n\tif k ==0:\n\t\treturn 0\n\telse:\n\t\treturn 0.5*np.log(2*TMath.Pi()*k) + k*np.log(k) - k + np.log(1+1./(12*k) + 1/(288.*k**2) -139./(51840*k**3)-571./(2488320*k**4) + 163879./(209018880*k**5))","def logp(self, value: TensorType, **kwargs) -> TensorType:","def logp(self, value: TensorType, **kwargs) -> TensorType:","def log_target(self, x):\n return self.log_likelihood_exp(x) + self.log_prior_parameters(x) + self.log_prior_wilson_coeffs(x)","def KL(p, q):\n return np.sum(p * np.log(p / q))","def heteroscedastic_loglik(x, m_true):\n \n logsumexp = tf.math.log(tf.reduce_sum(input_tensor=tf.exp(x), axis=-1, keepdims=True) + 1e-20)\n ll = x - logsumexp\n ll = tf.boolean_mask(tensor=ll, mask=m_true)\n ll = tf.reduce_mean(input_tensor=ll)\n return ll","def llf(self):\n return self.model.loglike(self.params)","def log(self: Float[LinearOperator, \"*batch M N\"]) -> Float[LinearOperator, \"*batch M N\"]:\n return self.__class__(self._diag.log())","def ComputeLogInsideTerm(self, *args):\n return _ITKCostFunctionsPython.itkShapePriorMAPCostFunctionBaseIF3F_ComputeLogInsideTerm(self, *args)","def log_likelihood(self):\r\n if self.likelihood.is_heteroscedastic:\r\n A = -0.5 * self.num_data * self.output_dim * np.log(2.*np.pi) + 0.5 * np.sum(np.log(self.likelihood.precision)) - 0.5 * np.sum(self.likelihood.V * self.likelihood.Y)\r\n B = -0.5 * self.output_dim * (np.sum(self.likelihood.precision.flatten() * self.psi0) - np.trace(self._A))\r\n else:\r\n A = -0.5 * self.num_data * self.output_dim * (np.log(2.*np.pi) - np.log(self.likelihood.precision)) - 0.5 * self.likelihood.precision * self.likelihood.trYYT\r\n B = -0.5 * self.output_dim * (np.sum(self.likelihood.precision * self.psi0) - np.trace(self._A))\r\n C = -self.output_dim * (np.sum(np.log(np.diag(self.LB)))) # + 0.5 * self.num_inducing * np.log(sf2))\r\n D = 0.5 * self.data_fit\r\n self._A_part, self._B_part, self._C_part, self._D_part = A, B, C, D\r\n return A + B + C + D + self.likelihood.Z","def compute_log(tx, index_log, mean=[], std=[]):\n tx_new = np.log10(3+abs(tx[:,index_log]))\n return standardize(tx_new,mean,std)","def loss(W_vect, X, T):\n # log_prior = - 0.5 * L2_reg * jnp.dot(W_vect, W_vect)\n return jnp.mean((predictions(W_vect, X) - T)**2) + 0.5*jnp.log(2*jnp.pi)","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 formula_1(x: np.ndarray) -> np.ndarray:\n logx = np.log(x)\n x2 = x ** 2\n denom = (x - 1) ** 2\n k1 = (x2 - logx * x - x) / denom\n return k1","def ComputeLogInsideTerm(self, *args):\n return _ITKCostFunctionsPython.itkShapePriorMAPCostFunctionBaseIF2F_ComputeLogInsideTerm(self, *args)","def log_likelihood(self, log_occr_array=None):\n\n if log_occr_array is not None:\n # Catch invalid occurrence rates for zero likelihood\n try:\n self.log_occr = log_occr_array\n except InvalidOccurrenceRate:\n return -np.inf\n\n # N_exp\n N_exp = self.calc_integral() * self._N_stars\n\n # Product terms\n # TODO:Check that the array broadcasting works here\n # Shape of s_terms should be [N_planets, NR, NP]\n s_terms = self.H_array * self.F_array * self.occr\n\n if tf.is_tensor(self.occr):\n ps_terms = tf.reduce_sum(s_terms, axis=(-1, -2))\n product_term = tf.reduce_sum(tf.math.log(ps_terms))\n log_ll_value = product_term - N_exp\n else:\n product_term = np.log(s_terms.sum(axis=(-1, -2))).sum()\n log_ll_value = product_term - N_exp\n\n # BUG TODO\n if np.isnan(log_ll_value):\n warnings.warn(\".likelihood value is nan.\")\n import pdb; pdb.set_trace()\n\n # A nan value is possible when some of the occr are too high\n log_ll_value = -np.inf if np.isnan(log_ll_value) else log_ll_value\n\n return log_ll_value","def log(self):\n return F.Log.apply(self)","def formula_2(x: np.ndarray) -> np.ndarray:\n logx = np.log(x)\n x2, x3 = x ** 2, x ** 3\n denom = 2 * (x - 1) ** 3\n k2 = (x3 - 2 * logx * x2 - x) / denom\n return k2","def log_likelihood(self, log_occr_array=None):\n\n if log_occr_array is not None:\n # Catch invalid occurrence rates for zero likelihood\n try:\n self.log_occr = log_occr_array\n except InvalidOccurrenceRate:\n return -np.inf\n\n # N_exp\n N_exp = self.calc_integral() * self._N_stars\n\n # Product terms\n # TODO:Check that the array broadcasting works here\n # Shape of s_terms should be [N_planets, NR, NP]\n s_terms = self.H_array * self.F_array * self.occr_grid\n\n if tf.is_tensor(self.occr):\n ps_terms = tf.reduce_sum(s_terms, axis=(-1, -2))\n product_term = tf.reduce_sum(tf.math.log(ps_terms))\n log_ll_value = product_term - N_exp\n else:\n product_term = np.log(s_terms.sum(axis=(-1, -2))).sum()\n log_ll_value = product_term - N_exp\n\n # BUG TODO\n if np.isnan(log_ll_value):\n warnings.warn(\".likelihood value is nan.\")\n import pdb; pdb.set_trace()\n\n # A nan value is possible when some of the occr are too high\n log_ll_value = -np.inf if np.isnan(log_ll_value) else log_ll_value\n\n return log_ll_value","def KL(P, Q):\n assert P.size() == Q.size()\n # To prevent divide by zero\n Q = Q + 1e-15\n return torch.sum(P * torch.log(P / Q))","def _compute_logarithmic_distance_term(index, M, Rjb):\r\n return ((a4[index] + a5 * (M - c1)) * np.log(np.sqrt(Rjb**2. + a6**2.)))","def _compute_logarithmic_distance_term(index, M, Rhypo):\r\n return ((a4[index] + a5 * (M - c1)) * np.log(np.sqrt(Rhypo**2. + a6**2.)))","def apply_dilution(model, kk, ignoreFirst = False):\n\n # Just apply the formula to each element\n new_model = np.log10((1 - kk) + kk * 10 ** model)\n\n # If ignoring first index\n if ignoreFirst:\n new_model[0] = model[0]\n\n return new_model","def ComputeLogGradientTerm(self, *args):\n return _ITKCostFunctionsPython.itkShapePriorMAPCostFunctionBaseIF3F_ComputeLogGradientTerm(self, *args)","def compute_K(alpha: torch.FloatTensor,\n beta: torch.FloatTensor) -> torch.FloatTensor:\n return torch.exp(compute_log_K(alpha, beta))","def compute_logits(self):\n # [num train labels, num classes] where each row is a one-hot-encoded label.\n one_hot_train_labels = tf.one_hot(self.data.train_labels, self.way)\n\n # Undocumented in the paper, but *very important*: *only* the support set\n # embeddings is L2-normalized, which means that the distance is not exactly\n # a cosine distance. For comparison we also allow for the actual cosine\n # distance to be computed, which is controlled with the\n # `exact_cosine_distance` instance attribute.\n train_embeddings = tf.nn.l2_normalize(\n self.train_embeddings, 1, epsilon=1e-3)\n test_embeddings = self.test_embeddings\n if self.exact_cosine_distance:\n test_embeddings = tf.nn.l2_normalize(test_embeddings, 1, epsilon=1e-3)\n # [num_test_images, num_train_images]\n similarities = tf.matmul(\n test_embeddings, train_embeddings, transpose_b=True)\n attention = tf.nn.softmax(similarities)\n\n # [num_test_images, way]\n probs = tf.matmul(attention, one_hot_train_labels)\n self.test_logits = tf.log(probs)\n return self.test_logits","def f(self, x):\n error = log_likelihood_calc(x[1], x[0], self.data)\n return error","def log_likelihood(self, data, reward_model, bias_params):","def ComputeLogGradientTerm(self, *args):\n return _ITKCostFunctionsPython.itkShapePriorMAPCostFunctionBaseIF2F_ComputeLogGradientTerm(self, *args)","def log_likelihood(X, k, means, cov):\n ll = np.zeros((len(X), k))\n for i in range(len(X)):\n for j in range(k):\n # TODO: scipy implement myself ?\n likel = scipy.stats.norm.pdf(X[i], means[j], np.sqrt(cov[j]))\n ll[i, j] = np.log(likel)\n\n return ll","def VAE_losses(t_logits, t_truncate, mu_logvar0, mu_logvar1, tiny=1e-8):\n # NEW ONE! with different strategy of calculating loss for censoring, adding \\sum p_b, not \\sum w_b*p_b\n # Reconstruction loss\n t_dist = tf.nn.softmax(t_logits)\n reconstruction = -tf.log(tf.reduce_sum(t_dist*t_truncate, axis=1))\n\n # KL divergence\n mu0, logvar0 = tf.split(mu_logvar0, num_or_size_splits=2, axis=1)\n mu1, logvar1 = tf.split(mu_logvar1, num_or_size_splits=2, axis=1)\n\n kl_d = 0.5 * tf.reduce_sum(tf.exp(logvar1-logvar0)\\\n + tf.divide(tf.square(mu0-mu1),tf.exp(logvar0)+tiny) \\\n + logvar0 - logvar1 -1.0, \\\n 1)\n\n # Total loss for event\n loss = tf.reduce_mean(reconstruction + kl_d) \n \n return reconstruction, kl_d, loss","def MvNormalLogp():\n cov = pt.matrix(\"cov\")\n cov.tag.test_value = floatX(np.eye(3))\n delta = pt.matrix(\"delta\")\n delta.tag.test_value = floatX(np.zeros((2, 3)))\n\n cholesky = Cholesky(lower=True, on_error=\"nan\")\n\n n, k = delta.shape\n n, k = f(n), f(k)\n chol_cov = cholesky(cov)\n diag = pt.diag(chol_cov)\n ok = pt.all(diag > 0)\n\n chol_cov = pt.switch(ok, chol_cov, pt.fill(chol_cov, 1))\n delta_trans = solve_lower(chol_cov, delta.T).T\n\n result = n * k * pt.log(f(2) * np.pi)\n result += f(2) * n * pt.sum(pt.log(diag))\n result += (delta_trans ** f(2)).sum()\n result = f(-0.5) * result\n logp = pt.switch(ok, result, -np.inf)\n\n def dlogp(inputs, gradients):\n (g_logp,) = gradients\n cov, delta = inputs\n\n g_logp.tag.test_value = floatX(1.0)\n n, k = delta.shape\n\n chol_cov = cholesky(cov)\n diag = pt.diag(chol_cov)\n ok = pt.all(diag > 0)\n\n chol_cov = pt.switch(ok, chol_cov, pt.fill(chol_cov, 1))\n delta_trans = solve_lower(chol_cov, delta.T).T\n\n inner = n * pt.eye(k) - pt.dot(delta_trans.T, delta_trans)\n g_cov = solve_upper(chol_cov.T, inner)\n g_cov = solve_upper(chol_cov.T, g_cov.T)\n\n tau_delta = solve_upper(chol_cov.T, delta_trans.T)\n g_delta = tau_delta.T\n\n g_cov = pt.switch(ok, g_cov, -np.nan)\n g_delta = pt.switch(ok, g_delta, -np.nan)\n\n return [-0.5 * g_cov * g_logp, -g_delta * g_logp]\n\n return OpFromGraph([cov, delta], [logp], grad_overrides=dlogp, inline=True)","def _get_tokens_idf_default_value(self) ->float:\n return math.log((self.num_sentences + 1) / 1)","def logarithm(self) -> np.ndarray:\n u = self.v/np.linalg.norm(self.v)\n if self.is_versor():\n if self.is_pure():\n return np.array([0.0, *(0.5*np.pi*u)])\n return np.array([0.0, *(u*np.arccos(self.w))])\n qn = np.linalg.norm(self.A)\n if self.is_pure():\n return np.array([np.log(qn), *(0.5*np.pi*u)])\n return np.array([np.log(qn), *(u*np.arccos(self.w/qn))])","def calculate_entropy(eval_token_count, training_model):\n sum_of_counts = sum(eval_token_count.values())\n cross_entropy = 0\n mis = []\n for ngram in eval_token_count:\n if training_model.score(ngram[-1], list(ngram[0:3])) == 0 or sum_of_counts == 0:\n mi = np.mean(mis) if len(mis) > 0 else np.log2(0.287)\n else:\n mi = training_model.logscore(ngram[-1], list(ngram[0:3]))\n pi = eval_token_count[ngram] / sum_of_counts\n mis.append(mi)\n cross_entropy -= pi * mi\n return cross_entropy","def likelihood(self, log_occr_array=None):\n\n if log_occr_array is not None:\n # Catch invalid occurrence rates for zero likelihood\n try:\n self.log_occr = log_occr_array\n except InvalidOccurrenceRate:\n return 0.0\n\n # Procedure: calculate N_exp in all cases, calculate detection\n # term if there are detections\n\n # N_exp\n N_exp = self.calc_integral() * self._N_stars\n\n # Product terms\n # TODO:Check that the array broadcasting works here\n # Shape of s_terms should be [N_planets, NR, NP]\n s_terms = self.H_array * self.F_array * self.occr\n\n if tf.is_tensor(self.occr):\n ps_terms = tf.reduce_sum(s_terms, axis=(-1, -2))\n product_term = tf.reduce_prod(ps_terms)\n ll_value = product_term * tf.exp(product_term)\n else:\n product_term = s_terms.sum(axis=(-1, -2)).prod()\n ll_value = product_term * np.exp(-N_exp)\n\n # BUG\n if np.isnan(ll_value):\n warnings.warn(\".likelihood value is nan.\")\n import pdb; pdb.set_trace()\n\n # A nan value is possible when some of the occr are too high\n return ll_value if not np.isnan(ll_value) else 0.0","def _log_linear_interpolation(predictions):\n log_probs = utils.average_arrays([mx.nd.log(p) for p in predictions])\n return -mx.nd.log(mx.nd.softmax(log_probs))","def score(self, sentence):\n # TODO your code here\n score = 0.0\n for i,token in enumerate(sentence[1:]):\n prev = sentence[i]\n current = token\n freq = self.vocab[current][prev] + self.epsilon\n\n score += math.log(freq)\n score -= math.log(self.word_counts[prev] + self.epsilon * self.v)\n return score","def log_probability_of_sentence(self, tokens: Sequence[str]):\n if isinstance(tokens, str):\n raise ValueError(\"Input to log_probability_of_sentence is a sequence of token strings,\"\n \" not a single string\")\n # these don't matter when we are running the model in inference mode\n targets = np.zeros([_BATCH_SIZE, _NUM_TIMESTEPS], np.int32)\n weights = np.ones([_BATCH_SIZE, _NUM_TIMESTEPS], np.float32)\n\n # these contain information about the previous word\n # we initialize them with the beginning-of-sentence marker\n inputs = np.zeros([_BATCH_SIZE, _NUM_TIMESTEPS], np.int32)\n inputs[0, 0] = self._vocab.word_to_id(_START_SENTENCE_SYMBOL)\n\n char_ids_inputs = np.zeros(\n [_BATCH_SIZE, _NUM_TIMESTEPS, self._vocab.max_word_length], np.int32)\n char_ids_inputs[0, 0, :] = self._vocab.word_to_char_ids(_START_SENTENCE_SYMBOL)\n\n # we take the log probability of a token sequence to be the sum of the log-probs\n # of each of its tokens given the preceding context\n log_prob_sum = 0.0\n for token in tokens:\n with contexttimer.Timer() as token_timer:\n dist_over_next_words = self._session.run(\n self._name_to_node['softmax_out'],\n feed_dict={\n self._name_to_node['char_inputs_in']: char_ids_inputs,\n self._name_to_node['inputs_in']: inputs,\n self._name_to_node['targets_in']: targets,\n self._name_to_node['target_weights_in']: weights})\n token_idx = self._vocab.word_to_id(token)\n log_prob_sum += math.log(dist_over_next_words[0][token_idx])\n\n # prepare this word to be the context for the next word\n inputs[0, 0] = token_idx\n char_ids_inputs[0, 0, :] = self._vocab.word_to_char_ids(token)\n\n # restore original state so that future calls to log_probability_of_sentence\n # are not affected by past calls\n self._reset_state()\n\n return log_prob_sum","def train(self, documents):\n prior_log_prob, label_to_col = self.get_prior_log_probabilities(documents)\n self.my_model[\"vocabulary\"] = make_vocabulary(documents)\n\n # find frequencies of features\n num_classes = len(label_to_col)\n num_features = len(self.extract_f_vector(documents[0]))\n features_freq = np.zeros((num_features, num_classes))\n for doc in documents:\n f_vector = self.extract_f_vector(doc)\n col_for_f_vector = label_to_col[doc.label]\n features_freq[:, col_for_f_vector] += f_vector\n\n # laplace smoothing\n total_per_label = np.sum(features_freq, axis=0)\n features_freq += np.ones(total_per_label.shape, int)\n normalizer = total_per_label + np.full(total_per_label.shape, num_features, int)\n features_freq /= normalizer\n\n # stack all probabilities to one matrix and take log\n # result: self.all_log_prob\n # |-----------------------------------|\n # | log P(f1|C1) | ... | log P(f1|Cn) |\n # | log P(f2|C1) | ... | log P(f2|Cn) |\n # | . | . | . |\n # | . | . | . |\n # | . | . | . |\n # | log P(fm|C1) | ... | log P(fm|Cn) |\n # | log P(C1) | ... | log P(Cn) |\n # |-----------------------------------|\n likelihood_log_prob = np.log(features_freq)\n all_log_prob = np.vstack((likelihood_log_prob, prior_log_prob))\n self.my_model[\"all_log_prob\"] = all_log_prob","def ln(x):\n return log(x, const.e)","def _calculate_ll(self, x):\n observation_log_probs = self._observation_log_probs(x, mask=None)\n forward_log_probs = self._forward(observation_log_probs)\n log_likelihood = logsumexp(\n forward_log_probs[forward_log_probs.shape[0] - 1, :].numpy())\n return log_likelihood","def _m_step(self, x, log_resp):\n x = self.check_size(x)\n\n resp = tf.exp(log_resp)\n\n pi = tf.reduce_sum(resp, axis=0, keepdims=True) + self.eps\n\n resp = tf.cast(resp, tf.double)\n pi = tf.cast(pi, tf.double)\n x = tf.cast(x, tf.double)\n\n mu = tf.reduce_sum(resp * x, axis=0, keepdims=True) / pi\n\n if self.covariance_type == \"full\":\n eps = (tf.linalg.eye(self.n_features) * self.eps)\n eps = tf.cast(eps, tf.double)\n\n var = tf.reduce_sum(tf.matmul(tf.expand_dims(x - mu, -1), tf.expand_dims(x - mu, -2)) * tf.expand_dims(resp, -1), axis=0,\n keepdims=True) / tf.expand_dims(tf.reduce_sum(resp, axis=0, keepdims=True), -1) + eps\n elif self.covariance_type == \"diag\":\n x2 = tf.reduce_sum((resp * x * x), axis=0, keepdims=True) / pi\n mu2 = mu * mu\n xmu = tf.reduce_sum((resp * mu * x), axis=0, keepdims=True) / pi\n var = x2 - 2 * xmu + mu2 + self.eps\n\n pi = pi / x.shape[0]\n\n return pi, mu, var","def kl(self):\n weights_logvar = self.weights_logvar\n kld_weights = self.prior_stdv.log() - weights_logvar.mul(0.5) + \\\n (weights_logvar.exp() + (self.weights.pow(2) - self.prior_mean)) / (\n 2 * self.prior_stdv.pow(2)) - 0.5\n kld_bias = self.prior_bias_stdv.log() - self.bias_logvar.mul(0.5) + \\\n (self.bias_logvar.exp() + (self.bias.pow(2) - self.prior_bias_mean)) / (\n 2 * self.prior_bias_stdv.pow(2)) \\\n - 0.5\n return kld_weights.sum() + kld_bias.sum()","def train(self, corpus): \n for sentence in corpus.corpus: # iterate over sentences in the corpus\n for token in sentence: # iterate over datums in the sentence\n self.unigrams[token] += 1\n self.total += 1\n V = len(self.unigrams) # vocabulary size \n for ug,count in self.unigrams.iteritems():\n \tself.f1[ug] = math.log10(count+1) - math.log10(self.total + V)","def __call__(self, X_logs):\n X = [math.exp(x) for x in X_logs]\n B_subs = {}\n for v_parent, v_child in self.R:\n edge = frozenset([v_parent, v_child])\n r = X[v_child]\n t = self.B[edge]\n B_subs[edge] = r * t\n newick_string = FtreeIO.RBN_to_newick(self.R, B_subs, self.N_leaves)\n tree = Newick.parse(newick_string, Newick.NewickTree)\n # define the rate matrix object; horrible\n dictionary_rate_matrix = RateMatrix.get_jukes_cantor_rate_matrix() \n ordered_states = list('ACGT') \n row_major_rate_matrix = MatrixUtil.dict_to_row_major(\n dictionary_rate_matrix, ordered_states, ordered_states)\n rate_matrix_object = RateMatrix.RateMatrix(\n row_major_rate_matrix, ordered_states) \n # get the log likelihood\n ll = PhyLikelihood.get_log_likelihood(\n tree, self.alignment, rate_matrix_object)\n return -ll","def _do_e_step(self, doc, m, r):\n ln_r = np.zeros((len(doc), self.K)) # アンダーフローを防ぐためにログをとる\n theta = np.zeros(self.K) # <θk>\n lam = np.zeros(self.K) # precision matrix\n # r[n,k] を求める\n for k in range(self.K):\n theta[k] = psi(self._alpha[m,k]) - psi(sum(self._alpha[m,:])) # 後でlogをとりexpが相殺されるのでexpをカット\n tmp = 0\n for i in range(self.D):\n tmp += psi((self._nu[k] + 1 - i)/2)\n lam[k] = (2 ** self.D) * np.linalg.det(self._W[k]) * np.exp(tmp)\n for n, x in enumerate(doc):\n ln_r[n,k] = theta[k] + np.log(lam[k] ** (1/2)) + (-1 * (self.D / (2 * self._beta[k])) -\\\n (self._nu[k] / 2) * np.dot((x - self._m[k]).T, np.dot(self._W[k], (x - self._m[k]))))\n # rを正規化する\n for n in range(len(doc)):\n sum_ln_rn = logsumexp(ln_r[n,:]) # logsumexp\n for k in range(self.K):\n r[m,n,k] = np.exp(ln_r[n,k] - sum_ln_rn)\n # print(r)\n return r[m]","def log_cust(x):\n if type(x) != str:\n if x < 0:\n return 0\n elif x == 0:\n return 0\n elif x > 0:\n return np.log(x)","def log_likelihood(self, theta, x, **kwargs):\n\n u, logdet_dudx, log_a = self.forward(theta, x, **kwargs)\n\n constant = float(-0.5 * self.n_inputs * np.log(2.0 * np.pi))\n # log_likelihood = torch.log(torch.sum(torch.exp(log_a - 0.5 * u ** 2 + logdet_dudx), dim=2))\n log_likelihood = torch.logsumexp(log_a - 0.5 * u**2 + logdet_dudx, dim=2)\n log_likelihood = constant + torch.sum(log_likelihood, dim=1)\n\n return u, log_likelihood","def __call__(self, y, f):\n ll = self._loglike(y, f)\n return ll","def KL(self):\n\n self.build_cholesky_if_needed()\n\n KL = -0.5 * self.num_inducing * self.num_nodes * self.dim_per_out\n\n for nd in range(self.num_nodes):\n q_sqrt_nd = self.q_sqrt_lst[nd]\n with params_as_tensors_for(q_sqrt_nd, convert=True):\n KL -= 0.5 * tf.reduce_sum(tf.log(tf.matrix_diag_part(q_sqrt_nd) ** 2))\n\n KL += tf.reduce_sum(tf.log(tf.matrix_diag_part(self.Lu[nd]))) * self.dim_per_out\n KL += 0.5 * tf.reduce_sum(\n tf.square(tf.matrix_triangular_solve(self.Lu_tiled_lst[nd], q_sqrt_nd, lower=True)))\n q_mu_nd = self.q_mu[:, nd * self.dim_per_out:(nd + 1) * self.dim_per_out]\n Kinv_m_nd = tf.cholesky_solve(self.Lu[nd], q_mu_nd)\n KL += 0.5 * tf.reduce_sum(q_mu_nd * Kinv_m_nd)\n\n return KL","def formula_4(x: np.ndarray) -> np.ndarray:\n logx = np.log(x)\n x2, x3, x4, x5 = x ** 2, x ** 3, x ** 4, x ** 5\n denom = 12 * (x - 1) ** 5\n k4 = (3 * x5 - 12 * logx * x4 + 10 * x4 - 18 * x3 + 6 * x2 - x) / denom\n return k4","def __init__(self):\n GinacFunction.__init__(self, \"log_gamma\", latex_name=r'\\log\\Gamma',\n conversions=dict(mathematica='LogGamma',\n maxima='log_gamma',\n sympy='loggamma'))","def vectorSpaceSearch(self, query, k):\n\n q = [t.lower() for t in list(dict.fromkeys(query.split()))]\n\n #calculate ltc for query\n list_of_wtq = {}\n for term in q:\n list_of_wtq[term]= self.log_frequency_weighing_in_query(q,term)\n\n normal = self.calc_normal(list_of_wtq.values())\n if normal == 0: # the query does not exist in any document\n return 0\n\n\n for key in list_of_wtq.keys():\n list_of_wtq[key] = list_of_wtq[key]/normal\n\n #print(list_of_wtq)\n\n\n #calculate lnn for documents and calculate cosine scores\n scores = {} # cosine scores\n\n for term in q:\n freq_list = self.__index_reader.getDocsWithToken(term)\n wtq = list_of_wtq[term] # weight\n #going through the term posting list\n #and for each document in the posing list\n # calculate score\n for i in range(0,len(freq_list),2):\n # calculate lnn of document i.e. weight of term in document\n wtd = self.log_frequency_weighing_in_document(freq_list[i + 1])\n if scores.get(freq_list[i]):\n scores[freq_list[i]] += wtd* wtq # add product of term\n else:\n scores[freq_list[i]] = self.log_frequency_weighing_in_document(freq_list[i+1]) * wtq\n\n #for key in scores.keys():\n # scores[key] = scores[key][0]/math.sqrt(scores[key][1]) # score/length\n\n sorted_scores = sorted(scores.items(), key=lambda x: x[1],reverse=True)\n\n top_k_scores = []\n count=0\n for tup in sorted_scores:\n if count > k-1:\n break\n top_k_scores.append(tup[0])\n count+=1\n\n return tuple(top_k_scores)","def likelihood(mean, logs, x):\n return -0.5 * (logs * 2. + ((x - mean) ** 2) / np.exp(logs * 2.) + GaussianDiag.Log2PI)","def logPdf(self,x):\n logPdf = np.log(self.pdf(x))\n return logPdf","def logPdf(self,x):\n logPdf = np.log(self.pdf(x))\n return logPdf","def log10(tensor):\n return log(tensor, base=10)","def forward(self, x, target, N_k):\n elbo = 0\n phi = self.base(x)\n def loglik(sample): #currently hardcoded for binary classification\n return -torch.log(1 + torch.exp(-target * sample))\n mu = self.mu\n cov = self.L @ self.L.T\n means = phi @ mu\n variances = torch.diagonal(phi @ cov @ phi.T, 0)\n elbo += (self.quadr(loglik, means, variances)).sum()\n elbo /= x.shape[0] #mean\n \n kls = 0\n kls -= kl_divergence(self.w_distr, self.w_prior)\n\n for i in range(len(self.prev_tasks_distr)):\n phi_i = self.base(self.prev_tasks_tensors[i])\n cov_i = phi_i @ phi_i.T\n p_u = MultivariateNormal(torch.zeros(cov_i.shape[0]).to(self.device),\n covariance_matrix=cov_i)#cov_i * self.sigma_prior)\n kls -= kl_divergence(self.prev_tasks_distr[i], p_u)\n elbo += kls / N_k\n\n return -elbo"],"string":"[\n \"def log_likelihood(self) -> tf.Tensor:\\n # K⁻¹ + GᵀΣ⁻¹G = LLᵀ.\\n l_post = self._k_inv_post.cholesky\\n num_data = self.observations_index.shape[0]\\n\\n # Hμ [..., num_transitions + 1, output_dim]\\n marginal = self.emission.project_state_to_f(self.prior_ssm.marginal_means)\\n marginal = self._drop_batch_shape(marginal)\\n\\n # y = obs - Hμ [..., num_transitions + 1, output_dim]\\n disp = self.observations - marginal\\n disp_data = self.sparse_observations - self.dense_to_sparse(marginal)\\n\\n # cst is the constant term for a gaussian log likelihood\\n cst = (\\n -0.5 * np.log(2 * np.pi) * tf.cast(self.emission.output_dim * num_data, default_float())\\n )\\n\\n term1 = -0.5 * tf.reduce_sum(\\n input_tensor=tf.einsum(\\\"...op,...p,...o->...o\\\", self._r_inv_data, disp_data, disp_data), axis=[-1, -2]\\n )\\n\\n # term 2 is: ½|L⁻¹(GᵀΣ⁻¹)y|²\\n # (GᵀΣ⁻¹)y [..., num_transitions + 1, state_dim]\\n obs_proj = self._back_project_y_to_state(disp)\\n\\n # ½|L⁻¹(GᵀΣ⁻¹)y|² [...]\\n term2 = 0.5 * tf.reduce_sum(\\n input_tensor=tf.square(l_post.solve(obs_proj, transpose_left=False)), axis=[-1, -2]\\n )\\n\\n ## term 3 is: ½log |K⁻¹| - log |L| + ½ log |Σ⁻¹|\\n # where log |Σ⁻¹| = num_data * log|R⁻¹|\\n term3 = (\\n 0.5 * self.prior_ssm.log_det_precision()\\n - l_post.abs_log_det()\\n + 0.5 * self._log_det_observation_precision\\n )\\n\\n return tf.reduce_sum(cst + term1 + term2 + term3)\",\n \"def logm(self, x):\\n\\n if K.backend() == 'theano':\\n # construct theano tensor operation\\n from theano.tensor.nlinalg import svd, diag\\n from theano.tensor.elemwise import Elemwise\\n from theano.scalar import log\\n import theano.tensor as T\\n # This implementation would be extremely slow. but efficient?\\n u, d, v = svd(x)\\n d += self.eps\\n inner = diag(T.log(d))\\n res = T.dot(u, T.dot(inner, v))\\n return res\\n else:\\n from kyu.tensorflow.ops.svd_gradients import batch_matrix_log\\n return batch_matrix_log(x, self.eps)\",\n \"def kld(mu, log_var):\\n return (mu + log_var).sum() # TODO Your code goes here.\",\n \"def log_marg_k(self, k):\\n k_N = self.prior.k_0 + self.counts[k]\\n v_N = self.prior.v_0 + self.counts[k]\\n m_N = self.m_N_numerators[k]/k_N\\n S_N = self.S_N_partials[k] - k_N*np.square(m_N)\\n return (\\n - self.counts[k]*self.D/2.*self._cached_log_pi\\n + self.D/2.*math.log(self.prior.k_0) - self.D/2.*math.log(k_N)\\n + self.prior.v_0/2.*np.log(self.prior.S_0).sum()\\n - v_N/2.*np.log(S_N).sum()\\n + self.D*(self._cached_gammaln_by_2[v_N] - self._cached_gammaln_by_2[self.prior.v_0])\\n )\",\n \"def log(self): # just use base?\\n return Factor().__build( VarSet(self.v) , np.log(self.t) )\",\n \"def get_logCRF(train, model):\\n word = train[0]\\n Y = train[1]\\n char_count, _ = word.shape\\n # calculating forward messages\\n alpha = np.zeros((char_count, model.dimY))\\n first_term = np.dot(word, model.getW(model.labels))\\n second_term = model._T\\n for i in range(1, char_count):\\n sum_term = (first_term[i-1] + alpha[i-1]) + second_term\\n alpha[i] = np.apply_along_axis(logsumexp_trick, 1, sum_term) \\n # getting logZ from messages\\n logZ = logsumexp_trick(first_term[char_count-1]+alpha[char_count-1])\\n w_term = np.sum(model.getW(Y).transpose() * word) # $\\\\sum_{j=1}^m {W_{yj} . x_j}$\\n t_term = np.sum(model.getT(Y[:-1], Y[1:])) #$T_{yj, yj+1}\\n value = -logZ + w_term + t_term\\n return value\",\n \"def log10(self):\\n return Factor().__build( VarSet(self.v) , np.log10(self.t) )\",\n \"def formula_0(x: np.ndarray) -> np.ndarray:\\n logx = np.log(x)\\n denom = x - 1\\n k0 = (x - logx * x - 1) / denom\\n return k0\",\n \"def loglik(alpha,gamma_list,M,k):\\n psi_sum_gamma=np.array(list(map(lambda x: psi(np.sum(x)),gamma_list))).reshape((M,1)) # M*1 \\n psi_gamma=psi(np.array(gamma_list)) # M*k matrix\\n L=M*gammaln(np.sum(alpha)-np.sum(gammaln(alpha)))+np.sum((psi_gamma-psi_sum_gamma)*(alpha.reshape((1,k))-1))\\n return L\",\n \"def _loglike(self, y, f):\\n bincoef = tf.lgamma(self.n + 1) - tf.lgamma(y + 1) \\\\\\n - tf.lgamma(self.n - y + 1)\\n ll = bincoef + y * tf.log(pos(f)) + (self.n - y) * tf.log(pos(1 - f))\\n return ll\",\n \"def logTF(self, tf):\\n return math.log(tf)\",\n \"def _log_matrix_vector(ms, vs):\\n return tf.reduce_logsumexp(ms + vs[..., tf.newaxis, :], axis=-1)\",\n \"def log_marginal_likelihood(X_train,y_train,phi,tau=1.,Ve=1.e-10):\",\n \"def log_forward_computations(self, x: list): \\n n_x = len(x)\\n \\n # log_f_x initialized to -Inf because log(0) = -Inf\\n log_f_x = np.zeros((self.n_states, n_x)) + logzero()\\n x_emission_scores = np.array([self.scores['emission'][:, self.word_to_pos[w] if w in list(self.word_to_pos.keys()) else self.word_to_pos['UnknownWord']] for w in x]).T\\n \\n log_f_x[:,0] = x_emission_scores[:, 0] + self.scores['initial']\\n \\n for i in range(1,n_x):\\n for s in range(self.n_states):\\n log_f_x[s,i] = logsumexp(self.scores['transition'][s,:] + \\n log_f_x[:,i-1]) + x_emission_scores[s, i]\\n\\n \\n log_likelihood = logsumexp(self.scores['final'] + log_f_x[:,-1])\\n \\n return log_f_x, log_likelihood\",\n \"def my_loglike(theta, x, data, sigma):\\n\\n model = my_model(theta, x)\\n\\n return -0.5*len(x)*np.log(2*math.pi*sigma**2) - (0.5/sigma**2) * np.sum((data-model)**2)\",\n \"def _loglike(self, y, f):\\n ll = y * tf.log(pos(f)) + (1 - y) * tf.log(pos(1 - f))\\n return ll\",\n \"def call(self, x, mask=None):\\n if K.backend() == 'theano':\\n from theano import scan\\n components, update = scan(fn=lambda tx: self.logm(tx),\\n outputs_info=None,\\n sequences=[x],\\n non_sequences=None)\\n\\n return components\\n else:\\n if self.built:\\n # return self.logm(x)\\n from kyu.tensorflow.ops.svd_gradients import gradient_eig_for_log\\n import tensorflow as tf\\n # g = tf.get_default_graph()\\n\\n # s, u, v = tf.svd(x)\\n s, u = tf.self_adjoint_eig(x)\\n s = tf.abs(s)\\n inner = s + self.eps\\n # inner = tf.Print(inner, [inner], message='log_inner before:')\\n\\n inner = tf.log(inner)\\n # inner = tf.Print(inner, [inner], message='log_inner :')\\n inner = tf.where(tf.is_nan(inner), tf.zeros_like(inner), inner)\\n inner = tf.matrix_diag(inner)\\n tf_log = tf.matmul(u, tf.matmul(inner, tf.transpose(u, [0, 2, 1])))\\n return tf_log\\n\\n else:\\n raise RuntimeError(\\\"Log transform layer should be built before using\\\")\",\n \"def log_poisson(k, l):\\n return k*np.log(l) -l - gammaln(k+1)\",\n \"def log_likelihood(self):\\n return -0.5*self.D*self.K_logdet + self._model_fit_term() + self.likelihood.Z\",\n \"def log2(self):\\n return Factor().__build( VarSet(self.v) , np.log2(self.t) )\",\n \"def log_likelihood(self):\\r\\n assert not self.likelihood.is_heteroscedastic\\r\\n A = -0.5*self.batchsize*self.output_dim*(np.log(2.*np.pi) - np.log(self.likelihood.precision))\\r\\n B = -0.5*self.likelihood.precision*self.output_dim*self.trace_K\\r\\n Kmm_logdet = 2.*np.sum(np.log(np.diag(self.Lm)))\\r\\n C = -0.5*self.output_dim*self.data_prop*(Kmm_logdet-self.q_u_logdet - self.num_inducing)\\r\\n C += -0.5*np.sum(self.LQL * self.B)\\r\\n D = -0.5*self.likelihood.precision*self.likelihood.trYYT\\r\\n E = np.sum(self.V*self.projected_mean)\\r\\n return (A+B+C+D+E)/self.data_prop\",\n \"def logm(C):\\n theta_x = so2.logm(C[:2,:2])\\n u = getVi(C).dot(C[:2,2])\\n return np.concatenate((\\n np.concatenate(( theta_x, u[:,np.newaxis]), axis=1),\\n [[0, 0, 0]]\\n ))\\n\\n # make matrix \\n # tx = so2.logm(C[:2,:2])\\n # t = so2.algi(tx)\\n # # if np.abs(t)<1e-2: \\n # # stt = lie.TaylorSinXoverX(t)\\n # # ctt = lie.TaylorOneMinusCosXOverX(t)\\n # # else:\\n # # stt = np.sin(t)/t\\n # # ctt = (1-np.cos(t))/t\\n # #\\n # # A = stt; B = ctt\\n # # Vi = (1 / (A**2 + B**2)) * np.array([[A, B], [-B, A]])\\n # Vi = getVi(C)\\n #\\n # d = C[:2,2]\\n # u = Vi.dot(d)\\n #\\n # return alg(np.concatenate(( u, [t] )))\",\n \"def folded_voigt_kernel_logst(k,log_nstbeta,log_ngammaL,dLarray):\\n\\n beta=jnp.exp(log_nstbeta)\\n gammaL=jnp.exp(log_ngammaL)\\n def ffold(val,dL):\\n val=val+jnp.exp(-2.0*((jnp.pi*beta*(k[:,None]+dL))**2 \\\\\\n + jnp.pi*gammaL[None,:]*(k[:,None]+dL)))\\n val=val+jnp.exp(-2.0*((jnp.pi*beta*(k[:,None]-dL))**2 \\\\\\n + jnp.pi*gammaL[None,:]*(dL-k[:,None])))\\n null=0.0\\n return val, null\\n val=jnp.exp(-2.0*((jnp.pi*beta*k[:,None])**2 + jnp.pi*gammaL[None,:]*k[:,None]))\\n \\n val,nullstack=scan(ffold, val, dLarray)\\n \\n return val\",\n \"def calc_tf_log(doc):\\r\\n tf = calc_tf(doc)\\r\\n max_tf = tf[max(tf, key=tf.get)]\\r\\n tf_log = {}\\r\\n for key, val in tf.items():\\r\\n tf_log[key] = (1 + math.log(val)) / (1 + math.log(max_tf))\\r\\n return tf_log\",\n \"def _log_vector_matrix(vs, ms):\\n return tf.reduce_logsumexp(vs[..., tf.newaxis] + ms, axis=-2)\",\n \"def log_pmf(self, k, name=\\\"log_pmf\\\"):\\n with ops.name_scope(self.name):\\n with ops.op_scope([self.logits, k], name):\\n k = ops.convert_to_tensor(k, name=\\\"k\\\")\\n return batch_index(self.logits, k)\",\n \"def log_operator(SE3): \\n #print('SE3 log: ', SE3)\\n R = SE3[:3,:3]\\n t = SE3[:3,3]\\n theta = arccos(0.5*(trace(R)-1)) # radians\\n lnR = 0.5*(theta/sin(theta))*(R-R.T)\\n omega = vee(lnR) # vee operator\\n omega_skew_sym = lnR#skew_symmetric(omega.reshape(-1,))\\n \\n if theta <= 1e-10:\\n V = eye(3)\\n else:\\n V = eye(3) + \\\\\\n (theta**-2)*(1-cos(theta))*omega_skew_sym + \\\\\\n (theta**-3)*(theta-sin(theta))*(omega_skew_sym @ omega_skew_sym)\\n neu = inv(V) @ t\\n\\n # if theta <= 1e-10:\\n # Vinv = eye(3)\\n # else:\\n # theta_half = 0.5*theta \\n # Vinv = eye(3) - 0.5*omega_skew_sym + \\\\\\n # (theta**-2)*(1- (theta_half*cos(theta_half)/sin(theta_half)))*(omega_skew_sym @ omega_skew_sym)\\n # neu = Vinv @ t\\n\\n return np.hstack((neu, omega)).reshape(-1,1)\",\n \"def forward(self, x):\\n\\n embeds = self.dvector(x)\\n logits = self.linear(embeds)\\n\\n return logits\",\n \"def log_det_K(self, Ks=None):\\n log_det = 0.\\n for K in self.Ks:\\n rank_d = self.n / K.shape[0]\\n det = np.linalg.slogdet(K)[1]\\n log_det += rank_d * det\\n return log_det\",\n \"def log_likelihood(self):\\r\\n return (-0.5 * self.num_data * self.output_dim * np.log(2.*np.pi) -\\r\\n 0.5 * self.output_dim * self.K_logdet + self._model_fit_term() + self.likelihood.Z)\",\n \"def kullbackLeibler(mu, log_sigma):\\n # (tf.Tensor, tf.Tensor) -> tf.Tensor\\n # = -0.5 * (1 + log(sigma**2) - mu**2 - sigma**2)\\n return -0.5 * tf.reduce_sum(1 + 2 * log_sigma - mu**2 - tf.exp(2 * log_sigma), 1)\",\n \"def log_det_K(self, Ks=None):\\n Ks = self.Ks if Ks is None else Ks\\n log_det = 0.\\n for K in Ks:\\n rank_d = self.m / K.shape[0]\\n det = np.linalg.slogdet(K)[1]\\n log_det += rank_d * det\\n return log_det\",\n \"def loglf2py(store):\\n loglike=0.0\\n return loglinear.logl(store['xb'],store['xmatf'], store['beta'],store['yvec'],loglike)\",\n \"def calculate_likelihood(truth, log_forecast):\\n\\n return tf.reduce_sum(truth * log_forecast) # Dimensions [batch_size, N_LABEL_TIMESTEPS, N_LABEL_CLASSES]\",\n \"def nllfun(x):\\n mu = x[0]\\n logsigma = x[1]\\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)\",\n \"def nllfun(x):\\n mu = x[0]\\n logsigma = x[1]\\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)\",\n \"def log_normal(x, m, log_v):\\n ################################################################################\\n # TODO: Modify/complete the code here\\n # Compute element-wise log probability of normal and remember to sum over\\n # the last dimension\\n ################################################################################\\n # print(\\\"q_m\\\", m.size())\\n # print(\\\"q_v\\\", v.size())\\n const = -0.5 * x.size(-1) * torch.log(2 * torch.tensor(np.pi))\\n # print(const.size())\\n log_det = -0.5 * torch.sum(log_v, dim=-1)\\n # print(\\\"log_det\\\", log_det.size())\\n log_exp = -0.5 * torch.sum((x - m) ** 2 / (log_v.exp()), dim=-1)\\n\\n log_prob = const + log_det + log_exp\\n\\n ################################################################################\\n # End of code modification\\n ################################################################################\\n return log_prob\",\n \"def log_marginal_likelihood(self) -> tf.Tensor:\\n L = tf.linalg.cholesky(self.likelihood.add_to(self.KXX))\\n return tf.reduce_sum(multivariate_normal(self._Y, self._mean, L))\",\n \"def logsumexp(logv):\\n res = logzero()\\n for val in logv:\\n res = logsum_pair(res, val)\\n return res\",\n \"def _loglike(self, y, f):\\n ll = -0.5 * (tf.log(2 * self.variance * np.pi) +\\n (y - f)**2 / self.variance)\\n return ll\",\n \"def logistic(self,w,Xi):\\n # print(w.T)\\n # print(Xi)\\n a = np.dot(w.T,Xi)\\n return 1/(1+np.exp(-a))\",\n \"def _loglike(self, y, f):\\n # sum along last axis, which is assumed to be the `tasks` axis\\n ll = tf.reduce_sum(y * tf.log(pos(f)), axis=-1)\\n return ll\",\n \"def log_factorial(k):\\n\\tif k ==0:\\n\\t\\treturn 0\\n\\telse:\\n\\t\\treturn 0.5*np.log(2*TMath.Pi()*k) + k*np.log(k) - k + np.log(1+1./(12*k) + 1/(288.*k**2) -139./(51840*k**3)-571./(2488320*k**4) + 163879./(209018880*k**5))\",\n \"def logp(self, value: TensorType, **kwargs) -> TensorType:\",\n \"def logp(self, value: TensorType, **kwargs) -> TensorType:\",\n \"def log_target(self, x):\\n return self.log_likelihood_exp(x) + self.log_prior_parameters(x) + self.log_prior_wilson_coeffs(x)\",\n \"def KL(p, q):\\n return np.sum(p * np.log(p / q))\",\n \"def heteroscedastic_loglik(x, m_true):\\n \\n logsumexp = tf.math.log(tf.reduce_sum(input_tensor=tf.exp(x), axis=-1, keepdims=True) + 1e-20)\\n ll = x - logsumexp\\n ll = tf.boolean_mask(tensor=ll, mask=m_true)\\n ll = tf.reduce_mean(input_tensor=ll)\\n return ll\",\n \"def llf(self):\\n return self.model.loglike(self.params)\",\n \"def log(self: Float[LinearOperator, \\\"*batch M N\\\"]) -> Float[LinearOperator, \\\"*batch M N\\\"]:\\n return self.__class__(self._diag.log())\",\n \"def ComputeLogInsideTerm(self, *args):\\n return _ITKCostFunctionsPython.itkShapePriorMAPCostFunctionBaseIF3F_ComputeLogInsideTerm(self, *args)\",\n \"def log_likelihood(self):\\r\\n if self.likelihood.is_heteroscedastic:\\r\\n A = -0.5 * self.num_data * self.output_dim * np.log(2.*np.pi) + 0.5 * np.sum(np.log(self.likelihood.precision)) - 0.5 * np.sum(self.likelihood.V * self.likelihood.Y)\\r\\n B = -0.5 * self.output_dim * (np.sum(self.likelihood.precision.flatten() * self.psi0) - np.trace(self._A))\\r\\n else:\\r\\n A = -0.5 * self.num_data * self.output_dim * (np.log(2.*np.pi) - np.log(self.likelihood.precision)) - 0.5 * self.likelihood.precision * self.likelihood.trYYT\\r\\n B = -0.5 * self.output_dim * (np.sum(self.likelihood.precision * self.psi0) - np.trace(self._A))\\r\\n C = -self.output_dim * (np.sum(np.log(np.diag(self.LB)))) # + 0.5 * self.num_inducing * np.log(sf2))\\r\\n D = 0.5 * self.data_fit\\r\\n self._A_part, self._B_part, self._C_part, self._D_part = A, B, C, D\\r\\n return A + B + C + D + self.likelihood.Z\",\n \"def compute_log(tx, index_log, mean=[], std=[]):\\n tx_new = np.log10(3+abs(tx[:,index_log]))\\n return standardize(tx_new,mean,std)\",\n \"def loss(W_vect, X, T):\\n # log_prior = - 0.5 * L2_reg * jnp.dot(W_vect, W_vect)\\n return jnp.mean((predictions(W_vect, X) - T)**2) + 0.5*jnp.log(2*jnp.pi)\",\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 formula_1(x: np.ndarray) -> np.ndarray:\\n logx = np.log(x)\\n x2 = x ** 2\\n denom = (x - 1) ** 2\\n k1 = (x2 - logx * x - x) / denom\\n return k1\",\n \"def ComputeLogInsideTerm(self, *args):\\n return _ITKCostFunctionsPython.itkShapePriorMAPCostFunctionBaseIF2F_ComputeLogInsideTerm(self, *args)\",\n \"def log_likelihood(self, log_occr_array=None):\\n\\n if log_occr_array is not None:\\n # Catch invalid occurrence rates for zero likelihood\\n try:\\n self.log_occr = log_occr_array\\n except InvalidOccurrenceRate:\\n return -np.inf\\n\\n # N_exp\\n N_exp = self.calc_integral() * self._N_stars\\n\\n # Product terms\\n # TODO:Check that the array broadcasting works here\\n # Shape of s_terms should be [N_planets, NR, NP]\\n s_terms = self.H_array * self.F_array * self.occr\\n\\n if tf.is_tensor(self.occr):\\n ps_terms = tf.reduce_sum(s_terms, axis=(-1, -2))\\n product_term = tf.reduce_sum(tf.math.log(ps_terms))\\n log_ll_value = product_term - N_exp\\n else:\\n product_term = np.log(s_terms.sum(axis=(-1, -2))).sum()\\n log_ll_value = product_term - N_exp\\n\\n # BUG TODO\\n if np.isnan(log_ll_value):\\n warnings.warn(\\\".likelihood value is nan.\\\")\\n import pdb; pdb.set_trace()\\n\\n # A nan value is possible when some of the occr are too high\\n log_ll_value = -np.inf if np.isnan(log_ll_value) else log_ll_value\\n\\n return log_ll_value\",\n \"def log(self):\\n return F.Log.apply(self)\",\n \"def formula_2(x: np.ndarray) -> np.ndarray:\\n logx = np.log(x)\\n x2, x3 = x ** 2, x ** 3\\n denom = 2 * (x - 1) ** 3\\n k2 = (x3 - 2 * logx * x2 - x) / denom\\n return k2\",\n \"def log_likelihood(self, log_occr_array=None):\\n\\n if log_occr_array is not None:\\n # Catch invalid occurrence rates for zero likelihood\\n try:\\n self.log_occr = log_occr_array\\n except InvalidOccurrenceRate:\\n return -np.inf\\n\\n # N_exp\\n N_exp = self.calc_integral() * self._N_stars\\n\\n # Product terms\\n # TODO:Check that the array broadcasting works here\\n # Shape of s_terms should be [N_planets, NR, NP]\\n s_terms = self.H_array * self.F_array * self.occr_grid\\n\\n if tf.is_tensor(self.occr):\\n ps_terms = tf.reduce_sum(s_terms, axis=(-1, -2))\\n product_term = tf.reduce_sum(tf.math.log(ps_terms))\\n log_ll_value = product_term - N_exp\\n else:\\n product_term = np.log(s_terms.sum(axis=(-1, -2))).sum()\\n log_ll_value = product_term - N_exp\\n\\n # BUG TODO\\n if np.isnan(log_ll_value):\\n warnings.warn(\\\".likelihood value is nan.\\\")\\n import pdb; pdb.set_trace()\\n\\n # A nan value is possible when some of the occr are too high\\n log_ll_value = -np.inf if np.isnan(log_ll_value) else log_ll_value\\n\\n return log_ll_value\",\n \"def KL(P, Q):\\n assert P.size() == Q.size()\\n # To prevent divide by zero\\n Q = Q + 1e-15\\n return torch.sum(P * torch.log(P / Q))\",\n \"def _compute_logarithmic_distance_term(index, M, Rjb):\\r\\n return ((a4[index] + a5 * (M - c1)) * np.log(np.sqrt(Rjb**2. + a6**2.)))\",\n \"def _compute_logarithmic_distance_term(index, M, Rhypo):\\r\\n return ((a4[index] + a5 * (M - c1)) * np.log(np.sqrt(Rhypo**2. + a6**2.)))\",\n \"def apply_dilution(model, kk, ignoreFirst = False):\\n\\n # Just apply the formula to each element\\n new_model = np.log10((1 - kk) + kk * 10 ** model)\\n\\n # If ignoring first index\\n if ignoreFirst:\\n new_model[0] = model[0]\\n\\n return new_model\",\n \"def ComputeLogGradientTerm(self, *args):\\n return _ITKCostFunctionsPython.itkShapePriorMAPCostFunctionBaseIF3F_ComputeLogGradientTerm(self, *args)\",\n \"def compute_K(alpha: torch.FloatTensor,\\n beta: torch.FloatTensor) -> torch.FloatTensor:\\n return torch.exp(compute_log_K(alpha, beta))\",\n \"def compute_logits(self):\\n # [num train labels, num classes] where each row is a one-hot-encoded label.\\n one_hot_train_labels = tf.one_hot(self.data.train_labels, self.way)\\n\\n # Undocumented in the paper, but *very important*: *only* the support set\\n # embeddings is L2-normalized, which means that the distance is not exactly\\n # a cosine distance. For comparison we also allow for the actual cosine\\n # distance to be computed, which is controlled with the\\n # `exact_cosine_distance` instance attribute.\\n train_embeddings = tf.nn.l2_normalize(\\n self.train_embeddings, 1, epsilon=1e-3)\\n test_embeddings = self.test_embeddings\\n if self.exact_cosine_distance:\\n test_embeddings = tf.nn.l2_normalize(test_embeddings, 1, epsilon=1e-3)\\n # [num_test_images, num_train_images]\\n similarities = tf.matmul(\\n test_embeddings, train_embeddings, transpose_b=True)\\n attention = tf.nn.softmax(similarities)\\n\\n # [num_test_images, way]\\n probs = tf.matmul(attention, one_hot_train_labels)\\n self.test_logits = tf.log(probs)\\n return self.test_logits\",\n \"def f(self, x):\\n error = log_likelihood_calc(x[1], x[0], self.data)\\n return error\",\n \"def log_likelihood(self, data, reward_model, bias_params):\",\n \"def ComputeLogGradientTerm(self, *args):\\n return _ITKCostFunctionsPython.itkShapePriorMAPCostFunctionBaseIF2F_ComputeLogGradientTerm(self, *args)\",\n \"def log_likelihood(X, k, means, cov):\\n ll = np.zeros((len(X), k))\\n for i in range(len(X)):\\n for j in range(k):\\n # TODO: scipy implement myself ?\\n likel = scipy.stats.norm.pdf(X[i], means[j], np.sqrt(cov[j]))\\n ll[i, j] = np.log(likel)\\n\\n return ll\",\n \"def VAE_losses(t_logits, t_truncate, mu_logvar0, mu_logvar1, tiny=1e-8):\\n # NEW ONE! with different strategy of calculating loss for censoring, adding \\\\sum p_b, not \\\\sum w_b*p_b\\n # Reconstruction loss\\n t_dist = tf.nn.softmax(t_logits)\\n reconstruction = -tf.log(tf.reduce_sum(t_dist*t_truncate, axis=1))\\n\\n # KL divergence\\n mu0, logvar0 = tf.split(mu_logvar0, num_or_size_splits=2, axis=1)\\n mu1, logvar1 = tf.split(mu_logvar1, num_or_size_splits=2, axis=1)\\n\\n kl_d = 0.5 * tf.reduce_sum(tf.exp(logvar1-logvar0)\\\\\\n + tf.divide(tf.square(mu0-mu1),tf.exp(logvar0)+tiny) \\\\\\n + logvar0 - logvar1 -1.0, \\\\\\n 1)\\n\\n # Total loss for event\\n loss = tf.reduce_mean(reconstruction + kl_d) \\n \\n return reconstruction, kl_d, loss\",\n \"def MvNormalLogp():\\n cov = pt.matrix(\\\"cov\\\")\\n cov.tag.test_value = floatX(np.eye(3))\\n delta = pt.matrix(\\\"delta\\\")\\n delta.tag.test_value = floatX(np.zeros((2, 3)))\\n\\n cholesky = Cholesky(lower=True, on_error=\\\"nan\\\")\\n\\n n, k = delta.shape\\n n, k = f(n), f(k)\\n chol_cov = cholesky(cov)\\n diag = pt.diag(chol_cov)\\n ok = pt.all(diag > 0)\\n\\n chol_cov = pt.switch(ok, chol_cov, pt.fill(chol_cov, 1))\\n delta_trans = solve_lower(chol_cov, delta.T).T\\n\\n result = n * k * pt.log(f(2) * np.pi)\\n result += f(2) * n * pt.sum(pt.log(diag))\\n result += (delta_trans ** f(2)).sum()\\n result = f(-0.5) * result\\n logp = pt.switch(ok, result, -np.inf)\\n\\n def dlogp(inputs, gradients):\\n (g_logp,) = gradients\\n cov, delta = inputs\\n\\n g_logp.tag.test_value = floatX(1.0)\\n n, k = delta.shape\\n\\n chol_cov = cholesky(cov)\\n diag = pt.diag(chol_cov)\\n ok = pt.all(diag > 0)\\n\\n chol_cov = pt.switch(ok, chol_cov, pt.fill(chol_cov, 1))\\n delta_trans = solve_lower(chol_cov, delta.T).T\\n\\n inner = n * pt.eye(k) - pt.dot(delta_trans.T, delta_trans)\\n g_cov = solve_upper(chol_cov.T, inner)\\n g_cov = solve_upper(chol_cov.T, g_cov.T)\\n\\n tau_delta = solve_upper(chol_cov.T, delta_trans.T)\\n g_delta = tau_delta.T\\n\\n g_cov = pt.switch(ok, g_cov, -np.nan)\\n g_delta = pt.switch(ok, g_delta, -np.nan)\\n\\n return [-0.5 * g_cov * g_logp, -g_delta * g_logp]\\n\\n return OpFromGraph([cov, delta], [logp], grad_overrides=dlogp, inline=True)\",\n \"def _get_tokens_idf_default_value(self) ->float:\\n return math.log((self.num_sentences + 1) / 1)\",\n \"def logarithm(self) -> np.ndarray:\\n u = self.v/np.linalg.norm(self.v)\\n if self.is_versor():\\n if self.is_pure():\\n return np.array([0.0, *(0.5*np.pi*u)])\\n return np.array([0.0, *(u*np.arccos(self.w))])\\n qn = np.linalg.norm(self.A)\\n if self.is_pure():\\n return np.array([np.log(qn), *(0.5*np.pi*u)])\\n return np.array([np.log(qn), *(u*np.arccos(self.w/qn))])\",\n \"def calculate_entropy(eval_token_count, training_model):\\n sum_of_counts = sum(eval_token_count.values())\\n cross_entropy = 0\\n mis = []\\n for ngram in eval_token_count:\\n if training_model.score(ngram[-1], list(ngram[0:3])) == 0 or sum_of_counts == 0:\\n mi = np.mean(mis) if len(mis) > 0 else np.log2(0.287)\\n else:\\n mi = training_model.logscore(ngram[-1], list(ngram[0:3]))\\n pi = eval_token_count[ngram] / sum_of_counts\\n mis.append(mi)\\n cross_entropy -= pi * mi\\n return cross_entropy\",\n \"def likelihood(self, log_occr_array=None):\\n\\n if log_occr_array is not None:\\n # Catch invalid occurrence rates for zero likelihood\\n try:\\n self.log_occr = log_occr_array\\n except InvalidOccurrenceRate:\\n return 0.0\\n\\n # Procedure: calculate N_exp in all cases, calculate detection\\n # term if there are detections\\n\\n # N_exp\\n N_exp = self.calc_integral() * self._N_stars\\n\\n # Product terms\\n # TODO:Check that the array broadcasting works here\\n # Shape of s_terms should be [N_planets, NR, NP]\\n s_terms = self.H_array * self.F_array * self.occr\\n\\n if tf.is_tensor(self.occr):\\n ps_terms = tf.reduce_sum(s_terms, axis=(-1, -2))\\n product_term = tf.reduce_prod(ps_terms)\\n ll_value = product_term * tf.exp(product_term)\\n else:\\n product_term = s_terms.sum(axis=(-1, -2)).prod()\\n ll_value = product_term * np.exp(-N_exp)\\n\\n # BUG\\n if np.isnan(ll_value):\\n warnings.warn(\\\".likelihood value is nan.\\\")\\n import pdb; pdb.set_trace()\\n\\n # A nan value is possible when some of the occr are too high\\n return ll_value if not np.isnan(ll_value) else 0.0\",\n \"def _log_linear_interpolation(predictions):\\n log_probs = utils.average_arrays([mx.nd.log(p) for p in predictions])\\n return -mx.nd.log(mx.nd.softmax(log_probs))\",\n \"def score(self, sentence):\\n # TODO your code here\\n score = 0.0\\n for i,token in enumerate(sentence[1:]):\\n prev = sentence[i]\\n current = token\\n freq = self.vocab[current][prev] + self.epsilon\\n\\n score += math.log(freq)\\n score -= math.log(self.word_counts[prev] + self.epsilon * self.v)\\n return score\",\n \"def log_probability_of_sentence(self, tokens: Sequence[str]):\\n if isinstance(tokens, str):\\n raise ValueError(\\\"Input to log_probability_of_sentence is a sequence of token strings,\\\"\\n \\\" not a single string\\\")\\n # these don't matter when we are running the model in inference mode\\n targets = np.zeros([_BATCH_SIZE, _NUM_TIMESTEPS], np.int32)\\n weights = np.ones([_BATCH_SIZE, _NUM_TIMESTEPS], np.float32)\\n\\n # these contain information about the previous word\\n # we initialize them with the beginning-of-sentence marker\\n inputs = np.zeros([_BATCH_SIZE, _NUM_TIMESTEPS], np.int32)\\n inputs[0, 0] = self._vocab.word_to_id(_START_SENTENCE_SYMBOL)\\n\\n char_ids_inputs = np.zeros(\\n [_BATCH_SIZE, _NUM_TIMESTEPS, self._vocab.max_word_length], np.int32)\\n char_ids_inputs[0, 0, :] = self._vocab.word_to_char_ids(_START_SENTENCE_SYMBOL)\\n\\n # we take the log probability of a token sequence to be the sum of the log-probs\\n # of each of its tokens given the preceding context\\n log_prob_sum = 0.0\\n for token in tokens:\\n with contexttimer.Timer() as token_timer:\\n dist_over_next_words = self._session.run(\\n self._name_to_node['softmax_out'],\\n feed_dict={\\n self._name_to_node['char_inputs_in']: char_ids_inputs,\\n self._name_to_node['inputs_in']: inputs,\\n self._name_to_node['targets_in']: targets,\\n self._name_to_node['target_weights_in']: weights})\\n token_idx = self._vocab.word_to_id(token)\\n log_prob_sum += math.log(dist_over_next_words[0][token_idx])\\n\\n # prepare this word to be the context for the next word\\n inputs[0, 0] = token_idx\\n char_ids_inputs[0, 0, :] = self._vocab.word_to_char_ids(token)\\n\\n # restore original state so that future calls to log_probability_of_sentence\\n # are not affected by past calls\\n self._reset_state()\\n\\n return log_prob_sum\",\n \"def train(self, documents):\\n prior_log_prob, label_to_col = self.get_prior_log_probabilities(documents)\\n self.my_model[\\\"vocabulary\\\"] = make_vocabulary(documents)\\n\\n # find frequencies of features\\n num_classes = len(label_to_col)\\n num_features = len(self.extract_f_vector(documents[0]))\\n features_freq = np.zeros((num_features, num_classes))\\n for doc in documents:\\n f_vector = self.extract_f_vector(doc)\\n col_for_f_vector = label_to_col[doc.label]\\n features_freq[:, col_for_f_vector] += f_vector\\n\\n # laplace smoothing\\n total_per_label = np.sum(features_freq, axis=0)\\n features_freq += np.ones(total_per_label.shape, int)\\n normalizer = total_per_label + np.full(total_per_label.shape, num_features, int)\\n features_freq /= normalizer\\n\\n # stack all probabilities to one matrix and take log\\n # result: self.all_log_prob\\n # |-----------------------------------|\\n # | log P(f1|C1) | ... | log P(f1|Cn) |\\n # | log P(f2|C1) | ... | log P(f2|Cn) |\\n # | . | . | . |\\n # | . | . | . |\\n # | . | . | . |\\n # | log P(fm|C1) | ... | log P(fm|Cn) |\\n # | log P(C1) | ... | log P(Cn) |\\n # |-----------------------------------|\\n likelihood_log_prob = np.log(features_freq)\\n all_log_prob = np.vstack((likelihood_log_prob, prior_log_prob))\\n self.my_model[\\\"all_log_prob\\\"] = all_log_prob\",\n \"def ln(x):\\n return log(x, const.e)\",\n \"def _calculate_ll(self, x):\\n observation_log_probs = self._observation_log_probs(x, mask=None)\\n forward_log_probs = self._forward(observation_log_probs)\\n log_likelihood = logsumexp(\\n forward_log_probs[forward_log_probs.shape[0] - 1, :].numpy())\\n return log_likelihood\",\n \"def _m_step(self, x, log_resp):\\n x = self.check_size(x)\\n\\n resp = tf.exp(log_resp)\\n\\n pi = tf.reduce_sum(resp, axis=0, keepdims=True) + self.eps\\n\\n resp = tf.cast(resp, tf.double)\\n pi = tf.cast(pi, tf.double)\\n x = tf.cast(x, tf.double)\\n\\n mu = tf.reduce_sum(resp * x, axis=0, keepdims=True) / pi\\n\\n if self.covariance_type == \\\"full\\\":\\n eps = (tf.linalg.eye(self.n_features) * self.eps)\\n eps = tf.cast(eps, tf.double)\\n\\n var = tf.reduce_sum(tf.matmul(tf.expand_dims(x - mu, -1), tf.expand_dims(x - mu, -2)) * tf.expand_dims(resp, -1), axis=0,\\n keepdims=True) / tf.expand_dims(tf.reduce_sum(resp, axis=0, keepdims=True), -1) + eps\\n elif self.covariance_type == \\\"diag\\\":\\n x2 = tf.reduce_sum((resp * x * x), axis=0, keepdims=True) / pi\\n mu2 = mu * mu\\n xmu = tf.reduce_sum((resp * mu * x), axis=0, keepdims=True) / pi\\n var = x2 - 2 * xmu + mu2 + self.eps\\n\\n pi = pi / x.shape[0]\\n\\n return pi, mu, var\",\n \"def kl(self):\\n weights_logvar = self.weights_logvar\\n kld_weights = self.prior_stdv.log() - weights_logvar.mul(0.5) + \\\\\\n (weights_logvar.exp() + (self.weights.pow(2) - self.prior_mean)) / (\\n 2 * self.prior_stdv.pow(2)) - 0.5\\n kld_bias = self.prior_bias_stdv.log() - self.bias_logvar.mul(0.5) + \\\\\\n (self.bias_logvar.exp() + (self.bias.pow(2) - self.prior_bias_mean)) / (\\n 2 * self.prior_bias_stdv.pow(2)) \\\\\\n - 0.5\\n return kld_weights.sum() + kld_bias.sum()\",\n \"def train(self, corpus): \\n for sentence in corpus.corpus: # iterate over sentences in the corpus\\n for token in sentence: # iterate over datums in the sentence\\n self.unigrams[token] += 1\\n self.total += 1\\n V = len(self.unigrams) # vocabulary size \\n for ug,count in self.unigrams.iteritems():\\n \\tself.f1[ug] = math.log10(count+1) - math.log10(self.total + V)\",\n \"def __call__(self, X_logs):\\n X = [math.exp(x) for x in X_logs]\\n B_subs = {}\\n for v_parent, v_child in self.R:\\n edge = frozenset([v_parent, v_child])\\n r = X[v_child]\\n t = self.B[edge]\\n B_subs[edge] = r * t\\n newick_string = FtreeIO.RBN_to_newick(self.R, B_subs, self.N_leaves)\\n tree = Newick.parse(newick_string, Newick.NewickTree)\\n # define the rate matrix object; horrible\\n dictionary_rate_matrix = RateMatrix.get_jukes_cantor_rate_matrix() \\n ordered_states = list('ACGT') \\n row_major_rate_matrix = MatrixUtil.dict_to_row_major(\\n dictionary_rate_matrix, ordered_states, ordered_states)\\n rate_matrix_object = RateMatrix.RateMatrix(\\n row_major_rate_matrix, ordered_states) \\n # get the log likelihood\\n ll = PhyLikelihood.get_log_likelihood(\\n tree, self.alignment, rate_matrix_object)\\n return -ll\",\n \"def _do_e_step(self, doc, m, r):\\n ln_r = np.zeros((len(doc), self.K)) # アンダーフローを防ぐためにログをとる\\n theta = np.zeros(self.K) # <θk>\\n lam = np.zeros(self.K) # precision matrix\\n # r[n,k] を求める\\n for k in range(self.K):\\n theta[k] = psi(self._alpha[m,k]) - psi(sum(self._alpha[m,:])) # 後でlogをとりexpが相殺されるのでexpをカット\\n tmp = 0\\n for i in range(self.D):\\n tmp += psi((self._nu[k] + 1 - i)/2)\\n lam[k] = (2 ** self.D) * np.linalg.det(self._W[k]) * np.exp(tmp)\\n for n, x in enumerate(doc):\\n ln_r[n,k] = theta[k] + np.log(lam[k] ** (1/2)) + (-1 * (self.D / (2 * self._beta[k])) -\\\\\\n (self._nu[k] / 2) * np.dot((x - self._m[k]).T, np.dot(self._W[k], (x - self._m[k]))))\\n # rを正規化する\\n for n in range(len(doc)):\\n sum_ln_rn = logsumexp(ln_r[n,:]) # logsumexp\\n for k in range(self.K):\\n r[m,n,k] = np.exp(ln_r[n,k] - sum_ln_rn)\\n # print(r)\\n return r[m]\",\n \"def log_cust(x):\\n if type(x) != str:\\n if x < 0:\\n return 0\\n elif x == 0:\\n return 0\\n elif x > 0:\\n return np.log(x)\",\n \"def log_likelihood(self, theta, x, **kwargs):\\n\\n u, logdet_dudx, log_a = self.forward(theta, x, **kwargs)\\n\\n constant = float(-0.5 * self.n_inputs * np.log(2.0 * np.pi))\\n # log_likelihood = torch.log(torch.sum(torch.exp(log_a - 0.5 * u ** 2 + logdet_dudx), dim=2))\\n log_likelihood = torch.logsumexp(log_a - 0.5 * u**2 + logdet_dudx, dim=2)\\n log_likelihood = constant + torch.sum(log_likelihood, dim=1)\\n\\n return u, log_likelihood\",\n \"def __call__(self, y, f):\\n ll = self._loglike(y, f)\\n return ll\",\n \"def KL(self):\\n\\n self.build_cholesky_if_needed()\\n\\n KL = -0.5 * self.num_inducing * self.num_nodes * self.dim_per_out\\n\\n for nd in range(self.num_nodes):\\n q_sqrt_nd = self.q_sqrt_lst[nd]\\n with params_as_tensors_for(q_sqrt_nd, convert=True):\\n KL -= 0.5 * tf.reduce_sum(tf.log(tf.matrix_diag_part(q_sqrt_nd) ** 2))\\n\\n KL += tf.reduce_sum(tf.log(tf.matrix_diag_part(self.Lu[nd]))) * self.dim_per_out\\n KL += 0.5 * tf.reduce_sum(\\n tf.square(tf.matrix_triangular_solve(self.Lu_tiled_lst[nd], q_sqrt_nd, lower=True)))\\n q_mu_nd = self.q_mu[:, nd * self.dim_per_out:(nd + 1) * self.dim_per_out]\\n Kinv_m_nd = tf.cholesky_solve(self.Lu[nd], q_mu_nd)\\n KL += 0.5 * tf.reduce_sum(q_mu_nd * Kinv_m_nd)\\n\\n return KL\",\n \"def formula_4(x: np.ndarray) -> np.ndarray:\\n logx = np.log(x)\\n x2, x3, x4, x5 = x ** 2, x ** 3, x ** 4, x ** 5\\n denom = 12 * (x - 1) ** 5\\n k4 = (3 * x5 - 12 * logx * x4 + 10 * x4 - 18 * x3 + 6 * x2 - x) / denom\\n return k4\",\n \"def __init__(self):\\n GinacFunction.__init__(self, \\\"log_gamma\\\", latex_name=r'\\\\log\\\\Gamma',\\n conversions=dict(mathematica='LogGamma',\\n maxima='log_gamma',\\n sympy='loggamma'))\",\n \"def vectorSpaceSearch(self, query, k):\\n\\n q = [t.lower() for t in list(dict.fromkeys(query.split()))]\\n\\n #calculate ltc for query\\n list_of_wtq = {}\\n for term in q:\\n list_of_wtq[term]= self.log_frequency_weighing_in_query(q,term)\\n\\n normal = self.calc_normal(list_of_wtq.values())\\n if normal == 0: # the query does not exist in any document\\n return 0\\n\\n\\n for key in list_of_wtq.keys():\\n list_of_wtq[key] = list_of_wtq[key]/normal\\n\\n #print(list_of_wtq)\\n\\n\\n #calculate lnn for documents and calculate cosine scores\\n scores = {} # cosine scores\\n\\n for term in q:\\n freq_list = self.__index_reader.getDocsWithToken(term)\\n wtq = list_of_wtq[term] # weight\\n #going through the term posting list\\n #and for each document in the posing list\\n # calculate score\\n for i in range(0,len(freq_list),2):\\n # calculate lnn of document i.e. weight of term in document\\n wtd = self.log_frequency_weighing_in_document(freq_list[i + 1])\\n if scores.get(freq_list[i]):\\n scores[freq_list[i]] += wtd* wtq # add product of term\\n else:\\n scores[freq_list[i]] = self.log_frequency_weighing_in_document(freq_list[i+1]) * wtq\\n\\n #for key in scores.keys():\\n # scores[key] = scores[key][0]/math.sqrt(scores[key][1]) # score/length\\n\\n sorted_scores = sorted(scores.items(), key=lambda x: x[1],reverse=True)\\n\\n top_k_scores = []\\n count=0\\n for tup in sorted_scores:\\n if count > k-1:\\n break\\n top_k_scores.append(tup[0])\\n count+=1\\n\\n return tuple(top_k_scores)\",\n \"def likelihood(mean, logs, x):\\n return -0.5 * (logs * 2. + ((x - mean) ** 2) / np.exp(logs * 2.) + GaussianDiag.Log2PI)\",\n \"def logPdf(self,x):\\n logPdf = np.log(self.pdf(x))\\n return logPdf\",\n \"def logPdf(self,x):\\n logPdf = np.log(self.pdf(x))\\n return logPdf\",\n \"def log10(tensor):\\n return log(tensor, base=10)\",\n \"def forward(self, x, target, N_k):\\n elbo = 0\\n phi = self.base(x)\\n def loglik(sample): #currently hardcoded for binary classification\\n return -torch.log(1 + torch.exp(-target * sample))\\n mu = self.mu\\n cov = self.L @ self.L.T\\n means = phi @ mu\\n variances = torch.diagonal(phi @ cov @ phi.T, 0)\\n elbo += (self.quadr(loglik, means, variances)).sum()\\n elbo /= x.shape[0] #mean\\n \\n kls = 0\\n kls -= kl_divergence(self.w_distr, self.w_prior)\\n\\n for i in range(len(self.prev_tasks_distr)):\\n phi_i = self.base(self.prev_tasks_tensors[i])\\n cov_i = phi_i @ phi_i.T\\n p_u = MultivariateNormal(torch.zeros(cov_i.shape[0]).to(self.device),\\n covariance_matrix=cov_i)#cov_i * self.sigma_prior)\\n kls -= kl_divergence(self.prev_tasks_distr[i], p_u)\\n elbo += kls / N_k\\n\\n return -elbo\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65289325","0.6476612","0.61250615","0.61017054","0.61012167","0.60598826","0.5984382","0.5947595","0.5909517","0.5891789","0.5878533","0.5858947","0.5810042","0.5801438","0.5796715","0.579634","0.5791101","0.5778086","0.576716","0.5753712","0.5753575","0.5733367","0.5689448","0.5671903","0.5671669","0.56701565","0.5667442","0.5648323","0.5614009","0.5600234","0.5597012","0.55914545","0.55879384","0.55854493","0.5584196","0.5584196","0.5573781","0.55564994","0.55562824","0.5553167","0.5540975","0.55232346","0.55151397","0.5510532","0.5510532","0.55045956","0.5503556","0.5502701","0.5500941","0.5495815","0.5485207","0.54843676","0.5476676","0.5466006","0.545695","0.54566747","0.5451299","0.544528","0.54383814","0.53951764","0.5392415","0.53870875","0.5384755","0.53794545","0.5373488","0.5368157","0.5350204","0.5348043","0.5344231","0.5341604","0.5334321","0.5334143","0.5331454","0.5329392","0.53256625","0.53238857","0.53166014","0.5315034","0.5314626","0.53135884","0.5310812","0.53096294","0.53009087","0.52982986","0.52939045","0.52932","0.5293068","0.5288634","0.5287883","0.528379","0.5280102","0.5276893","0.52741957","0.52731514","0.52710503","0.52690786","0.5263774","0.5261779","0.5261779","0.5258849","0.52549857"],"string":"[\n \"0.65289325\",\n \"0.6476612\",\n \"0.61250615\",\n \"0.61017054\",\n \"0.61012167\",\n \"0.60598826\",\n \"0.5984382\",\n \"0.5947595\",\n \"0.5909517\",\n \"0.5891789\",\n \"0.5878533\",\n \"0.5858947\",\n \"0.5810042\",\n \"0.5801438\",\n \"0.5796715\",\n \"0.579634\",\n \"0.5791101\",\n \"0.5778086\",\n \"0.576716\",\n \"0.5753712\",\n \"0.5753575\",\n \"0.5733367\",\n \"0.5689448\",\n \"0.5671903\",\n \"0.5671669\",\n \"0.56701565\",\n \"0.5667442\",\n \"0.5648323\",\n \"0.5614009\",\n \"0.5600234\",\n \"0.5597012\",\n \"0.55914545\",\n \"0.55879384\",\n \"0.55854493\",\n \"0.5584196\",\n \"0.5584196\",\n \"0.5573781\",\n \"0.55564994\",\n \"0.55562824\",\n \"0.5553167\",\n \"0.5540975\",\n \"0.55232346\",\n \"0.55151397\",\n \"0.5510532\",\n \"0.5510532\",\n \"0.55045956\",\n \"0.5503556\",\n \"0.5502701\",\n \"0.5500941\",\n \"0.5495815\",\n \"0.5485207\",\n \"0.54843676\",\n \"0.5476676\",\n \"0.5466006\",\n \"0.545695\",\n \"0.54566747\",\n \"0.5451299\",\n \"0.544528\",\n \"0.54383814\",\n \"0.53951764\",\n \"0.5392415\",\n \"0.53870875\",\n \"0.5384755\",\n \"0.53794545\",\n \"0.5373488\",\n \"0.5368157\",\n \"0.5350204\",\n \"0.5348043\",\n \"0.5344231\",\n \"0.5341604\",\n \"0.5334321\",\n \"0.5334143\",\n \"0.5331454\",\n \"0.5329392\",\n \"0.53256625\",\n \"0.53238857\",\n \"0.53166014\",\n \"0.5315034\",\n \"0.5314626\",\n \"0.53135884\",\n \"0.5310812\",\n \"0.53096294\",\n \"0.53009087\",\n \"0.52982986\",\n \"0.52939045\",\n \"0.52932\",\n \"0.5293068\",\n \"0.5288634\",\n \"0.5287883\",\n \"0.528379\",\n \"0.5280102\",\n \"0.5276893\",\n \"0.52741957\",\n \"0.52731514\",\n \"0.52710503\",\n \"0.52690786\",\n \"0.5263774\",\n \"0.5261779\",\n \"0.5261779\",\n \"0.5258849\",\n \"0.52549857\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":91793,"cells":{"query":{"kind":"string","value":"Equivalent to fit(m_tokens, n_types).predict(m_tokens)"},"document":{"kind":"string","value":"def fit_predict(self, m_tokens: np.ndarray, n_types: np.ndarray) -> np.ndarray:\n\n # fit and predict\n return self.fit(m_tokens, n_types).predict(m_tokens)"},"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 predict_tokens(self, tokens):\n return","def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # run model\n K, B = self.params\n n_types = K * np.power(m_tokens, B)\n\n # roundoff\n if nearest_int:\n n_types = np.round(n_types)\n\n # allow scalar\n if return_scalar:\n assert len(n_types) == 1\n n_types = n_types[0]\n\n # return\n return n_types","def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # redirect: E(m) = N * formula(m/M)\n n_types = self.N * self.formula(m_tokens / self.M)\n\n # roundoff\n if nearest_int:\n n_types = np.round(n_types)\n\n # allow scalar\n if return_scalar:\n assert len(n_types) == 1\n n_types = float(n_types)\n\n # return number of types\n return n_types","def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # redirect: E(m) = N_z - k_0(m)\n k = self.predict_k(m_tokens, dim=1, nearest_int=nearest_int)\n n_types = self.N_z - k[:, 0]\n\n # allow scalar\n if return_scalar:\n assert len(n_types) == 1\n n_types = float(n_types)\n\n # return number of types\n return n_types","def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # sum over legomena coefficients k\n x = m_tokens / self.M\n exponents = range(len(self.k))\n terms = np.array([np.power(1 - x, n) for n in exponents])\n k_0 = np.dot(self.k, terms)\n n_types = self.N - k_0\n\n # roundoff\n if nearest_int:\n n_types = np.round(n_types)\n\n # allow scalar\n if return_scalar:\n assert len(n_types) == 1\n n_types = n_types[0]\n\n # return\n return n_types","def predict(self, x, vocab, n_grams, *args, **kwargs):\n if self.encode_type == 'one-hot':\n return self.one_hot(x, vocab, n_grams)\n elif self.encode_type == 'bow':\n return self.bow(x, vocab, n_grams)\n elif self.encode_type == 'tf-idf':\n return self.tf_idf(x, vocab, n_grams)\n elif self.encode_type == 'word2vec':\n return self.word2vec(x, n_grams)\n elif self.encode_type == 'transformer':\n from transformers import AutoTokenizer\n from sentivi.classifier.transformer import TransformerClassifier\n\n tokenizer = AutoTokenizer.from_pretrained(self.language_model_shortcut)\n return self.transformer_tokenizer(tokenizer, x)","def predict(self, data):\n\t\traise NotImplementedError","def predict_k(\n self,\n m_tokens: np.ndarray,\n dim: int,\n normalize: bool = False,\n nearest_int: bool = True,\n ) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # retrieve fitting parameters\n M_z, N_z = self.params\n\n # scale down to normalized log formula\n x = m_tokens / M_z\n k_frac = self.formula(x, dim)\n\n # normalize, or don't\n if normalize:\n # predicted counts as a proportion of predicted types\n y_types_omitted = k_frac[:, 0]\n y_types_selected = 1 - y_types_omitted\n y_types_selected = y_types_selected[:, np.newaxis]\n k = k_frac / y_types_selected\n else:\n # predicted counts\n k = N_z * k_frac\n\n # roundoff\n if nearest_int:\n k = np.round(k)\n\n # allow scalar\n if return_scalar:\n assert len(k) == 1\n k = k.squeeze()\n\n # return n-legomena counts\n return k","def predict(self, **kwargs):\n raise NotImplementedError","def predict(self, data: List):","def fit(self, m_tokens: np.ndarray, n_types: np.ndarray):\n\n # initial guess: naive fit\n M, N, H = max(m_tokens), max(n_types), max(n_types) / 2\n p0 = self.fit_naive(M, N, H).params\n\n # minimize MSE on random perturbations of M_z, N_z\n # NOTE: y(x) = 1 - k0(x) -> E(m)/Nz = 1 - k0(m/Mz)\n def func(m, M_z, N_z):\n return N_z * (1 - self.formula_0(m / M_z))\n\n xdata = np.array(m_tokens)\n ydata = np.array(n_types)\n params_, _ = curve_fit(func, xdata, ydata, p0)\n M_z, N_z = params_.astype(\"int\")\n self.params = (M_z, N_z)\n\n # return fitted model\n return self","def predict(self, model, context, data):\n pass","def predict(self):\n raise NotImplementedError","def predict(self, tokens: TokenSeq) -> PosSeq:\n _, pos_tags = self.predict_greedy(tokens)\n # _, _, pos_tags = self.predict_viterbi(tokens)\n return pos_tags","def predict(self, documents):\n raise NotImplementedError()","def predict(self, data_in):\n pass","def predict(net, query, context, graph, tokenizer, sentence_lengths, fb_passes=1):\n\n # (M,2), (1,M), (1,M), (1,3)\n o_sup, o_start, o_end, o_type = net(query, context, graph, fb_passes=fb_passes)\n\n # =========== GET ANSWERS\n answer_start = o_start.argmax() #TODO make sure that these tensors are all only containing one number!\n answer_end = o_end.argmax()\n answer_type = o_type.argmax()\n if answer_type == 0:\n answer = \"yes\"\n elif answer_type == 1:\n answer = \"no\"\n elif answer_type == 2 and answer_end >= answer_start:\n answer = tokenizer.decode(graph.tokens[answer_start: answer_end + 1])\n else:\n answer = \"noanswer\"\n\n # =========== GET SUPPORTING FACTS\n pos = 0\n sup_fact_pairs = []\n for para, s_lens in zip(context, sentence_lengths):\n for j, s_len in enumerate(s_lens):\n #score = round(sum(o_sup.argmax([pos: pos + s_len])) / s_len)\n # take avg of token-wise scores and round to 0 or 1\n try:\n score = round(float(sum([x.argmax() for x in o_sup.T[pos: pos + s_len]]) / float(s_len)))\n except ZeroDivisionError:\n score = 0\n if score == 1:\n sup_fact_pairs.append([para[0], j])\n pos += s_len\n\n return answer, sup_fact_pairs","def predict(self, instances):\r\n raise NotImplementedError","def predict(self, text: list) -> list:\n\n encoded_input = self.__encode_token(text)\n dataloaders = self.__create_dataloaders(encoded_input, self.batch_size)\n\n preds = []\n for i, batch in enumerate(zip(dataloaders[0], dataloaders[1], dataloaders[2])):\n preds_batch_list = self.__predict_batch(self.model, batch)\n preds += preds_batch_list\n\n return preds","def predict(self, xs, **kwargs):","def predict(self, X):","def predict(self, X):","def predict_batch(self, model, context, data=None):\n pass","def predict(self, X):\n ...","def predict(self, X):\n ...","def predict(self, X):\n ...","def predict(self, X):\n raise NotImplementedError","def predict(self, X):\n pass","def predict(self, X):\n pass","def predict(self, X):\n pass","def predict(self,text):\n\n text= \"[CLS] \" + text + \" [SEP]\"\n tokenized_text = self.tokenizer.tokenize(text)\n indexed_tokens = self.tokenizer.convert_tokens_to_ids(tokenized_text)\n masked_index = tokenized_text.index('[MASK]') \n\n # Create the segments tensors.\n segments_ids = [0] * len(tokenized_text)\n \n # Convert inputs to PyTorch tensors\n tokens_tensor = torch.tensor([indexed_tokens])\n segments_tensors = torch.tensor([segments_ids])\n \n self.model.eval()\n \n # Predict all tokens\n with torch.no_grad():\n predictions = self.model(tokens_tensor, segments_tensors)\n \n predicted_index = torch.argmax(predictions[0][0][masked_index]).item()\n predicted_token = self.tokenizer.convert_ids_to_tokens([predicted_index])[0]\n \n print(predicted_token)","def predict(self, data: np.array) -> np.array:\n raise NotImplementedError","def predict_sf(sentence, model_type=\"MLP\"):\n\n X = \" \".join(sentence)\n X_encoding = tokenizer.encode_plus(\n X, add_special_tokens=True, return_tensors='pt')\n X_ids = X_encoding['input_ids'].to(DEVICE)\n with torch.no_grad():\n output = bert_model(X_ids)\n\n # get the 768-d representation of tokens except [CLS] and [SEP]\n SF_input = get_representation(output)[1:-1]\n y_pred = []\n\n SF_model = None\n if model_type == \"BiLSTM\":\n SF_model = get_SF_model(\"BiLSTM\")\n\n LSTM_input = [np.array(i) for i in SF_input]\n y_pred.append(np.array(LSTM_input))\n y_pred = SF_model.predict_classes(np.array(y_pred))[0]\n y_pred = [y-1 for y in y_pred]\n return y_pred\n\n elif model_type == \"MLP\":\n SF_model = get_SF_model(\"MLP\")\n SF_model.eval()\n\n for p in range(len(X_ids[0]) - 2):\n SF_output = SF_model(SF_input[p]).unsqueeze(0)\n y_pred.append(torch.argmax(SF_output).item())\n\n return y_pred\n else:\n print(\"Model type not supported!\")\n print('Please choose from either \"BiLSTM\" or \"MLP\"')","def predict_types_features(self, context):\n ngram_probs = self._get_full_ngram_probs(context)\n return ngram_probs","def predict(self, sentences, batch_size=32):\n train_encodings = self.tokenizer(sentences,\n truncation=True,\n padding=True,\n max_length=500)\n\n train_dataset = TextDataset(train_encodings)\n\n loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size)\n collect_outputs = []\n with torch.no_grad():\n for batch in loader:\n input_ids = batch['input_ids']\n attention_mask = batch['attention_mask']\n\n outputs = self.model(input_ids, attention_mask=attention_mask)\n collect_outputs.extend(torch.argmax(outputs[\"logits\"], axis=1).cpu().numpy().tolist())\n\n return [self.sentiment_map[k] for k in collect_outputs]","def predict(self, params, exog=None, *args, **kwargs):\n raise NotImplementedError # pragma: no cover","def _get_predictions(self, line: List[str]):\n example = self.tokenizer.encode_plus(\n [c for c in line],\n return_token_type_ids=True,\n return_attention_mask=True,\n return_tensors=\"pt\",\n )\n example = {k: v.to(self.device) for k, v in example.items()}\n prediction = self.model(example, training=False)[0]\n prediction = self.softmax_fn(prediction).cpu().data.numpy()\n prediction = prediction[1:-1, 1:].argmax(axis=-1)\n return prediction","def predict(self, sentences, batch_size=32):\n train_encodings = self.tokenizer(sentences,\n truncation=True,\n padding=True,\n max_length=500)\n\n train_dataset = TextDataset(train_encodings)\n\n loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size)\n collect_outputs = []\n\n with torch.no_grad():\n for batch in loader:\n input_ids = batch['input_ids']\n attention_mask = batch['attention_mask']\n\n outputs = self.model(input_ids, attention_mask=attention_mask)\n collect_outputs.extend(torch.argmax(outputs[\"logits\"], axis=1).cpu().numpy().tolist())\n\n return [self.emotion_map[k] for k in collect_outputs]","def predict(self, x, **kwargs):\n raise NotImplementedError","def predict(self, text):\n tokens = ['[CLS]'] + self.tokenizer.tokenize(text) + ['[SEP]']\n xx = self.tokenizer.convert_tokens_to_ids(tokens)\n xx = torch.tensor(xx).unsqueeze(0).to(self.device)\n _, y_hat = self.model(xx)\n pred_tags = []\n for tag in y_hat.squeeze():\n pred_tags.append(idx2tag[tag.item()])\n return pred_tags, tokens","def predict(self, ex_words: List[str]) -> int:\n raise Exception(\"Don't call me, call my subclasses\")","def predict(self,words):\n vector_array = self.get_vector_array(words)\n clusterind = self.clusterer.predict(vector_array)\n return self.target_tokens[clusterind].tolist()","def predict(self, data):\n return self.result.predict(data)","def predict(self, X, pred_batch_size=None):","def _predict(self, X):\n raise NotImplementedError","def predict(self, eval_dataloader, num_gpus=None, verbose=True):\n\n preds = list(\n super().predict(\n eval_dataloader=eval_dataloader,\n get_inputs=TokenClassificationProcessor.get_inputs,\n n_gpu=num_gpus,\n verbose=verbose,\n )\n )\n preds_np = np.concatenate(preds)\n return preds_np","def fit(\n self, m_tokens: np.ndarray, n_types: np.ndarray, M: int = None, N: int = None\n ):\n\n # fix M, N\n M = M or m_tokens.max()\n N = N or n_types.max()\n\n # initial guess\n p0 = 2.0\n\n # minimize MSE on random perturbations of gamma\n xdata = np.array(m_tokens) / M\n ydata = np.array(n_types) / N\n [gamma_], _ = curve_fit(self.formula, xdata, ydata, p0)\n self.params = (M, N, gamma_)\n\n # return fitted model\n return self","def predict(model, images):\n return model.predict_classes(images)","def predict_next_word(self, features, params, precomputed):\n raise NotImplementedError(\"Model does not implement word prediction.\")","def predict(self, inputs):\n if self.use_logistic:\n return self.predict_labels_logistic(self.w, inputs)\n return predict_labels(self.w, inputs)","def fit_predict(self, X, y=None):\n self.fit(X)\n return self.labels_","def fit_predict(self, X, y=None):\n self.fit(X)\n return self.labels_","def predict(self, data):\n data['predicted'] = self.sentiment_classifier.predict_estimator(data)\n return data","def predict_next_oneofmany(text, tokenizer, max_id, model, temperature=1):\n X_new = preprocess_input([text], tokenizer, max_id)\n y_proba = model.predict(X_new)[0, -1:, :]\n rescaled_logits = tf.math.log(y_proba) / temperature\n char_id = tf.random.categorical(rescaled_logits, num_samples=1) + 1\n return tokenizer.sequences_to_texts(char_id.numpy())[0]","def predict(self, inp_data: T_co) -> T_co:\n raise NotImplementedError","def predict(self, fit_result, x):\n raise NotImplementedError()","def fit_predict(self):\n raise AttributeError","def predict(self, sent: str, **kwargs) -> str:\n results = self._model(sent)\n return results","def predict(self, texts):\n\n texts = preprocess_text(texts)\n labels = self.pipeline.predict(texts)\n\n return labels","def predict(X, y, parameters):\n pass","def predict(data, model: str = None, **kwargs):\n\n model_instance = get_model(model)\n log.debug(\"Predict with \" + str(model_instance))\n return model_instance.predict(data, **kwargs)","def predict_viterbi(self, tokens: TokenSeq) -> Tuple[NDArray, NDArray, PosSeq]:","def predict(self, X: List[np.ndarray], **kwargs) -> List[np.ndarray]:","def predict(self, text):\r\n vectorizer = CountVectorizer(ngram_range=(1, 2), lowercase=True, vocabulary=self.voc)\r\n vector = vectorizer.fit_transform([text])\r\n return self.model.predict(vector)[0]","def Fit(text):\n article_tfidf = TransformData([text])\n global CLASSIFIER\n predicted_probs = CLASSIFIER.predict_proba(article_tfidf)\n # the output shoud be an array with two elements, one corresponding to\n # probability it's a positive sentiment and the other corresponding to\n # probability it's a negative sentiment.\n return list(zip(CLASSIFIER.classes_, predicted_probs[0]))","def predict(self, words_raw):\n words = [self.config.processing_word(w) for w in words_raw]\n if type(words[0]) == tuple:\n words = zip(*words)\n pred_ids, _ = self.predict_batch([words])\n preds = [self.idx_to_tag[idx] for idx in list(pred_ids[0])]\n\n return preds","def predict(self, words_raw):\n words = [self.config.processing_word(w) for w in words_raw]\n if type(words[0]) == tuple:\n words = zip(*words)\n pred_ids, _ = self.predict_batch([words])\n preds = [self.idx_to_tag[idx] for idx in list(pred_ids[0])]\n\n return preds","def predict(self, x):\n \n\n return predictions","def n_grams_predict_next(name: str,\n file_name: Optional[str] = None,\n model: Dict[str, NGramsSequence] = None,\n clean_input_file: Optional[str] = None,\n clean_input_data: Optional[pd.DataFrame] = None,\n num_lines_predict: Optional[int] = None,\n n_grams: int = default_n_grams,\n num_predict: int = 1,\n smoothing: SmoothingType = SmoothingType.basic) -> None:\n\n logger.success(f'predicting with {smoothing.name} for {name}')\n\n if file_name is None and model is None:\n raise ValueError('no file name or model provided')\n\n if clean_input_file is None and clean_input_data is None:\n raise ValueError('no input file name or data provided')\n\n # create n-gram model if not provided\n if model is None:\n json_file_path = file_path_relative(f'{models_folder}/{file_name}')\n logger.info(f'reading data from {json_file_path}')\n with open(json_file_path, 'r') as file:\n model = NGramsModel.from_json(json.load(file))\n\n # get testing data\n if clean_input_data is None:\n file_path = file_path_relative(\n f'{clean_data_folder}/{clean_input_file}')\n logger.info(f'reading data from {file_path}')\n clean_input_data = pd.read_csv(file_path, converters={\n sentences_key: literal_eval})\n\n predict_sentences: List[List[str]] = clean_input_data[sentences_key]\n if num_lines_predict is not None:\n predict_sentences = predict_sentences[:num_lines_predict]\n\n check_probability_smoothing: List[SmoothingType] = [SmoothingType.basic]\n\n logger.success('[[<words>]] = predicted words:')\n\n sum_probability_log: float = 0.\n count_all_predict: int = 0\n\n # iterate over testing data\n for i, sentence in enumerate(predict_sentences):\n full_sentence = sentence.copy()\n for _ in range(num_predict):\n last_words = full_sentence[-n_grams:]\n sequence = ' '.join(last_words)\n\n probabilities = model.get_probabilities(\n sequence, smoothing)\n sum_probability = sum(elem[1] for elem in probabilities)\n # logger.info(f'probabilities: sum: {sum_probability}, all: {probabilities}')\n if smoothing in check_probability_smoothing:\n # for not-unseen outputs, check to\n # make sure sum is approximately 1\n assert np.isclose(\n sum_probability, 1), f'probability of {sum_probability} is not close to 1'\n\n current_output, prob = probabilities[0]\n full_sentence.append(current_output)\n # if not unseen, add to perplexity calculation\n if current_output != unseen_output:\n sum_probability_log += np.log(prob)\n count_all_predict += 1\n\n logger.info(\n f\"{i + 1}. {' '.join(sentence)} [[{' '.join(full_sentence[len(sentence):])}]]\")\n\n if count_all_predict == 0:\n logger.info('no predictions, no perplexity')\n else:\n total_loss = -1 * sum_probability_log\n perplexity: float = np.exp(total_loss / count_all_predict)\n logger.info(f\"perplexity: {perplexity}\")","def predict(self, names, labelize=True):\n #with self.graph.as_default():\n # format input\n #print(names)\n names = [s.lower() for s in names]\n #print(\"lower\",names)\n\n names = [list(i)+['END']*(self.max_len-len(i)) for i in names]\n names = [[self.vector(self.char_index[j], self.vocab_len) for j in i] for i in names]\n names = np.asarray(names)\n\n # predict gender\n out = self.model.predict(names).tolist()\n print(out)\n return [('M' if p[0] > p[1] else 'F') for p in out] if labelize else out","def predict(\n self, inputs: base.Array, key: base.RngKey) -> base.Array:","def predict(self, stories, questions, stories_lengths, questions_lengths, pack=True):\n out = self.forward(stories, questions, stories_lengths, questions_lengths, pack)\n return F.softmax(out)","def predict(self, review):\n raise NotImplementedError","def predict(self, x):\n # *** START CODE HERE ***\n return self.clf.predict_classes(x.reshape(x.shape[0], 28, 28, 1))\n # *** END CODE HERE ***","def predict(self, x, **kwargs):\n return self.tuner.get_best_models(1)[0].predict(x, **kwargs)","def _fit_predict(X_train, y_train, X_test):\n raise NotImplementedError()","def predict(self, X, **kwargs):\n return Learner.predict(self, X, **kwargs)","def predict(self, first_preprocessed_inputs,second_preprocessed_inputs,third_preprocessed_inputs):\r\n pass","def fit_predict(self, X, y=None):\n return self.fit(X, y).predict(X)","def predict(self, x):\n raise NotImplementedError(\"Please Implement this method\")","def _predict(self, x):\n pass","def predict(model, features):\n result = model.predict(features)\n return result","def predict(self, data: List):\r\n return self._lda.predict(data)","def predict(self, x, **kwargs):\n kwargs = self.filter_sk_params(Sequential.predict_classes, kwargs)\n classes = self.model.predict_classes(x, **kwargs)\n return self.classes_[classes]","def predict(self, predPoints=None):","def predict(self, content):\n input_x = list(content)\n while len(input_x) < self.args.maxlen1: input_x.append('<pad>')\n input_x = input_x[:self.args.maxlen1]\n\n input_x = [self.token2idx.get(s, self.token2idx['<unk>']) for s in input_x]\n\n memory = self.sess.run(self.memory, feed_dict={self.input_x: [input_x]})\n\n return self.bs.search(self.sess, input_x, memory[0])","def predict_only(self):","def predict(self, sentences: List[str]) -> List[Dict[str, Any]]:\n inputs, offset_mapping = self.tokenize(sentences=sentences)\n outputs = self.model(**inputs)\n logits = outputs[\"logits\"]\n predicted_intents = self.convert_intent_logits(intent_logits=logits[1])\n predicted_entities = self.convert_entities_logits(entities_logits=logits[0], offset_mapping=offset_mapping)\n predicted_outputs = []\n for sentence, intent_sentence, entities_sentence in zip(sentences, predicted_intents, predicted_entities):\n predicted_outputs.append({})\n predicted_outputs[-1].update(intent_sentence)\n predicted_outputs[-1].update({\"entities\": entities_sentence})\n for entity in predicted_outputs[-1][\"entities\"]:\n entity[\"text\"] = sentence[entity[\"start\"]: entity[\"end\"]]\n\n if self.synonym_dict.get(entity[\"text\"], None):\n entity[\"original_text\"] = entity[\"text\"]\n entity[\"text\"] = self.synonym_dict[entity[\"text\"]]\n\n predicted_outputs[-1][\"text\"] = sentence\n\n return predicted_outputs","def predict(self, features):\n return self.search_results.predict(features)","def predict(self, peptides, **kwargs):\n raise NotImplementedError","def fit_experimental(self, m_tokens: np.ndarray, n_types: np.ndarray, gamma: float):\n\n # initial guess\n M = m_tokens.max()\n N = n_types.max()\n p0 = (M, N)\n\n # fix gamma, but fit M, N to the data\n xdata = np.array(m_tokens)\n ydata = np.array(n_types)\n\n def func(m, M, N):\n return N * self.formula(m / M, gamma)\n\n [M, N], _ = curve_fit(func, xdata, ydata, p0)\n M, N = int(M), int(N)\n self.params = (M, N, gamma)\n\n # return fitted model\n return self","def predict(self, data):\n\t\tres = self.neuralNetworks.inference(self.dataCenter.process_inference_data(data))\n\t\tprint(res)","def predict(self):\n\n self.eval()\n return self.forward(self.data)","def predict(self, texts: List[ParsedText]) -> List[ParsedText]:\n self.model.eval()\n texts = copy.deepcopy(texts)\n\n batches = DataLoader(texts=texts,\n batch_size=self.batch_size,\n vocabulary=self.vocabulary,\n aspect_labels=self.aspect_labels,\n device=self.device)\n for batch_index, batch in enumerate(batches):\n logits = self.model(embed_ids=batch.embed_ids, sentence_len=batch.sentence_len)\n pred_labels = th.argmax(logits.to('cpu'), dim=1)\n pred_sentences_opinions = self._get_opinions(\n labels_indexes=pred_labels,\n sentence_len=[x.item() for x in batch.sentence_len.to('cpu')])\n for internal_index, opinions in enumerate(pred_sentences_opinions):\n text_index = batch.text_index[internal_index]\n sentence_index = batch.sentence_index[internal_index]\n sentence_nodes = texts[text_index].sentences[\n sentence_index].nodes_sentence_order()\n\n explicit_opinions = []\n explicit_categories = set()\n for opinion in opinions:\n opinion.nodes = [sentence_nodes[x] for x in opinion.nodes]\n explicit_opinions.append(opinion)\n explicit_categories.add(opinion.category)\n for opinion in texts[text_index].sentences[sentence_index].opinions:\n if (not opinion.nodes) and (opinion.category in explicit_categories):\n texts[text_index].sentences[sentence_index].opinions.remove(opinion)\n texts[text_index].sentences[sentence_index].opinions.extend(explicit_opinions)\n return texts","def predict(self, texts, merge_tokens=True):\n if os.environ.get('DISABLE_V2_BEHAVIOR', None) != '1':\n warnings.warn(\"Please add os.environ['DISABLE_V2_BEHAVIOR'] = '1' at top of your script or notebook\")\n msg = \"\\nNER in ktrain uses the CRF module from keras_contrib, which is not yet\\n\" +\\\n \"fully compatible with TensorFlow 2. To use NER, you must add the following to the top of your\\n\" +\\\n \"script or notebook BEFORE you import ktrain (after restarting runtime):\\n\\n\" +\\\n \"import os\\n\" +\\\n \"os.environ['DISABLE_V2_BEHAVIOR'] = '1'\\n\"\n print(msg)\n return\n else:\n import tensorflow.compat.v1 as tf\n tf.disable_v2_behavior()\n\n #old_do = os.environ.get('CUDA_DEVICE_ORDER', None)\n #old_vd = os.environ.get('CUDA_VISIBLE_DEVICES', None)\n #os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\"\n #os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\n\n if isinstance(texts, str): texts = [texts]\n if self.lang == 'zh':\n dirpath = os.path.dirname(os.path.abspath(__file__))\n fpath = os.path.join(dirpath, 'ner_models/ner_chinese')\n elif self.lang == 'ru':\n dirpath = os.path.dirname(os.path.abspath(__file__))\n fpath = os.path.join(dirpath, 'ner_models/ner_russian')\n elif self.lang=='en':\n dirpath = os.path.dirname(os.path.abspath(__file__))\n fpath = os.path.join(dirpath, 'ner_models/ner_english')\n else:\n raise ValueError('lang %s is not supported by NER' % (self.lang))\n try:\n import io\n from contextlib import redirect_stdout\n f = io.StringIO()\n with redirect_stdout(f):\n import ktrain\n except:\n raise ValueError('ktrain could not be imported. Install with: pip3 install ktrain')\n predictor = ktrain.load_predictor(fpath)\n results = []\n for text in texts:\n text = text.strip()\n result = predictor.predict(text)\n if merge_tokens:\n result = self.merge_entities(result)\n results.append(result)\n if len(result) == 1: result = result[0]\n\n #if old_do is not None:\n #os.environ[\"CUDA_DEVICE_ORDER\"] = old_do\n #else:\n #del os.environ['CUDA_DEVICE_ORDER']\n #if old_vd is not None:\n #os.environ['CUDA_VISIBLE_DEVICES'] = old_vd\n #else:\n #del os.environ['CUDA_VISIBLE_DEVICES']\n return result","def predict(self, data):\r\n return self.sess.run([self.predict_op, self.Mu], feed_dict={self.X: data})","def make_predictions(model, tokenizer, paragraphs):\n \n prediction_dataloader = bert_preprocess(paragraphs, tokenizer) \n predictions = eval_cpu(prediction_dataloader, model) \n malware_ids = get_pred_ids(predictions) \n return malware_ids","def inference(self, inputs):\n # NOTE: This makes the assumption that your model expects text to be tokenized\n # with \"input_ids\" and \"token_type_ids\" - which is true for some popular transformer models, e.g. bert.\n # If your transformer model expects different tokenization, adapt this code to suit\n # its expected input format.\n input_ids = inputs[\"input_ids\"]\n input_ids = input_ids.to(self.device)\n\n coarse_result = self.model.generate(input_ids = input_ids, )\n coarse_result = coarse_result.to(\"cpu\")\n fined_result = self.tokenizer.decode(coarse_result[0].tolist()[inputs[\"original_length\"]+1:],\n skip_special_tokens = True)\n #logger.info(\"Model predicted: '%s'\", fined_result)\n\n return [fined_result]"],"string":"[\n \"def predict_tokens(self, tokens):\\n return\",\n \"def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\\n\\n # allow scalar\\n return_scalar = np.isscalar(m_tokens)\\n m_tokens = np.array(m_tokens).reshape(-1)\\n\\n # run model\\n K, B = self.params\\n n_types = K * np.power(m_tokens, B)\\n\\n # roundoff\\n if nearest_int:\\n n_types = np.round(n_types)\\n\\n # allow scalar\\n if return_scalar:\\n assert len(n_types) == 1\\n n_types = n_types[0]\\n\\n # return\\n return n_types\",\n \"def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\\n\\n # allow scalar\\n return_scalar = np.isscalar(m_tokens)\\n m_tokens = np.array(m_tokens).reshape(-1)\\n\\n # redirect: E(m) = N * formula(m/M)\\n n_types = self.N * self.formula(m_tokens / self.M)\\n\\n # roundoff\\n if nearest_int:\\n n_types = np.round(n_types)\\n\\n # allow scalar\\n if return_scalar:\\n assert len(n_types) == 1\\n n_types = float(n_types)\\n\\n # return number of types\\n return n_types\",\n \"def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\\n\\n # allow scalar\\n return_scalar = np.isscalar(m_tokens)\\n m_tokens = np.array(m_tokens).reshape(-1)\\n\\n # redirect: E(m) = N_z - k_0(m)\\n k = self.predict_k(m_tokens, dim=1, nearest_int=nearest_int)\\n n_types = self.N_z - k[:, 0]\\n\\n # allow scalar\\n if return_scalar:\\n assert len(n_types) == 1\\n n_types = float(n_types)\\n\\n # return number of types\\n return n_types\",\n \"def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\\n\\n # allow scalar\\n return_scalar = np.isscalar(m_tokens)\\n m_tokens = np.array(m_tokens).reshape(-1)\\n\\n # sum over legomena coefficients k\\n x = m_tokens / self.M\\n exponents = range(len(self.k))\\n terms = np.array([np.power(1 - x, n) for n in exponents])\\n k_0 = np.dot(self.k, terms)\\n n_types = self.N - k_0\\n\\n # roundoff\\n if nearest_int:\\n n_types = np.round(n_types)\\n\\n # allow scalar\\n if return_scalar:\\n assert len(n_types) == 1\\n n_types = n_types[0]\\n\\n # return\\n return n_types\",\n \"def predict(self, x, vocab, n_grams, *args, **kwargs):\\n if self.encode_type == 'one-hot':\\n return self.one_hot(x, vocab, n_grams)\\n elif self.encode_type == 'bow':\\n return self.bow(x, vocab, n_grams)\\n elif self.encode_type == 'tf-idf':\\n return self.tf_idf(x, vocab, n_grams)\\n elif self.encode_type == 'word2vec':\\n return self.word2vec(x, n_grams)\\n elif self.encode_type == 'transformer':\\n from transformers import AutoTokenizer\\n from sentivi.classifier.transformer import TransformerClassifier\\n\\n tokenizer = AutoTokenizer.from_pretrained(self.language_model_shortcut)\\n return self.transformer_tokenizer(tokenizer, x)\",\n \"def predict(self, data):\\n\\t\\traise NotImplementedError\",\n \"def predict_k(\\n self,\\n m_tokens: np.ndarray,\\n dim: int,\\n normalize: bool = False,\\n nearest_int: bool = True,\\n ) -> np.ndarray:\\n\\n # allow scalar\\n return_scalar = np.isscalar(m_tokens)\\n m_tokens = np.array(m_tokens).reshape(-1)\\n\\n # retrieve fitting parameters\\n M_z, N_z = self.params\\n\\n # scale down to normalized log formula\\n x = m_tokens / M_z\\n k_frac = self.formula(x, dim)\\n\\n # normalize, or don't\\n if normalize:\\n # predicted counts as a proportion of predicted types\\n y_types_omitted = k_frac[:, 0]\\n y_types_selected = 1 - y_types_omitted\\n y_types_selected = y_types_selected[:, np.newaxis]\\n k = k_frac / y_types_selected\\n else:\\n # predicted counts\\n k = N_z * k_frac\\n\\n # roundoff\\n if nearest_int:\\n k = np.round(k)\\n\\n # allow scalar\\n if return_scalar:\\n assert len(k) == 1\\n k = k.squeeze()\\n\\n # return n-legomena counts\\n return k\",\n \"def predict(self, **kwargs):\\n raise NotImplementedError\",\n \"def predict(self, data: List):\",\n \"def fit(self, m_tokens: np.ndarray, n_types: np.ndarray):\\n\\n # initial guess: naive fit\\n M, N, H = max(m_tokens), max(n_types), max(n_types) / 2\\n p0 = self.fit_naive(M, N, H).params\\n\\n # minimize MSE on random perturbations of M_z, N_z\\n # NOTE: y(x) = 1 - k0(x) -> E(m)/Nz = 1 - k0(m/Mz)\\n def func(m, M_z, N_z):\\n return N_z * (1 - self.formula_0(m / M_z))\\n\\n xdata = np.array(m_tokens)\\n ydata = np.array(n_types)\\n params_, _ = curve_fit(func, xdata, ydata, p0)\\n M_z, N_z = params_.astype(\\\"int\\\")\\n self.params = (M_z, N_z)\\n\\n # return fitted model\\n return self\",\n \"def predict(self, model, context, data):\\n pass\",\n \"def predict(self):\\n raise NotImplementedError\",\n \"def predict(self, tokens: TokenSeq) -> PosSeq:\\n _, pos_tags = self.predict_greedy(tokens)\\n # _, _, pos_tags = self.predict_viterbi(tokens)\\n return pos_tags\",\n \"def predict(self, documents):\\n raise NotImplementedError()\",\n \"def predict(self, data_in):\\n pass\",\n \"def predict(net, query, context, graph, tokenizer, sentence_lengths, fb_passes=1):\\n\\n # (M,2), (1,M), (1,M), (1,3)\\n o_sup, o_start, o_end, o_type = net(query, context, graph, fb_passes=fb_passes)\\n\\n # =========== GET ANSWERS\\n answer_start = o_start.argmax() #TODO make sure that these tensors are all only containing one number!\\n answer_end = o_end.argmax()\\n answer_type = o_type.argmax()\\n if answer_type == 0:\\n answer = \\\"yes\\\"\\n elif answer_type == 1:\\n answer = \\\"no\\\"\\n elif answer_type == 2 and answer_end >= answer_start:\\n answer = tokenizer.decode(graph.tokens[answer_start: answer_end + 1])\\n else:\\n answer = \\\"noanswer\\\"\\n\\n # =========== GET SUPPORTING FACTS\\n pos = 0\\n sup_fact_pairs = []\\n for para, s_lens in zip(context, sentence_lengths):\\n for j, s_len in enumerate(s_lens):\\n #score = round(sum(o_sup.argmax([pos: pos + s_len])) / s_len)\\n # take avg of token-wise scores and round to 0 or 1\\n try:\\n score = round(float(sum([x.argmax() for x in o_sup.T[pos: pos + s_len]]) / float(s_len)))\\n except ZeroDivisionError:\\n score = 0\\n if score == 1:\\n sup_fact_pairs.append([para[0], j])\\n pos += s_len\\n\\n return answer, sup_fact_pairs\",\n \"def predict(self, instances):\\r\\n raise NotImplementedError\",\n \"def predict(self, text: list) -> list:\\n\\n encoded_input = self.__encode_token(text)\\n dataloaders = self.__create_dataloaders(encoded_input, self.batch_size)\\n\\n preds = []\\n for i, batch in enumerate(zip(dataloaders[0], dataloaders[1], dataloaders[2])):\\n preds_batch_list = self.__predict_batch(self.model, batch)\\n preds += preds_batch_list\\n\\n return preds\",\n \"def predict(self, xs, **kwargs):\",\n \"def predict(self, X):\",\n \"def predict(self, X):\",\n \"def predict_batch(self, model, context, data=None):\\n pass\",\n \"def predict(self, X):\\n ...\",\n \"def predict(self, X):\\n ...\",\n \"def predict(self, X):\\n ...\",\n \"def predict(self, X):\\n raise NotImplementedError\",\n \"def predict(self, X):\\n pass\",\n \"def predict(self, X):\\n pass\",\n \"def predict(self, X):\\n pass\",\n \"def predict(self,text):\\n\\n text= \\\"[CLS] \\\" + text + \\\" [SEP]\\\"\\n tokenized_text = self.tokenizer.tokenize(text)\\n indexed_tokens = self.tokenizer.convert_tokens_to_ids(tokenized_text)\\n masked_index = tokenized_text.index('[MASK]') \\n\\n # Create the segments tensors.\\n segments_ids = [0] * len(tokenized_text)\\n \\n # Convert inputs to PyTorch tensors\\n tokens_tensor = torch.tensor([indexed_tokens])\\n segments_tensors = torch.tensor([segments_ids])\\n \\n self.model.eval()\\n \\n # Predict all tokens\\n with torch.no_grad():\\n predictions = self.model(tokens_tensor, segments_tensors)\\n \\n predicted_index = torch.argmax(predictions[0][0][masked_index]).item()\\n predicted_token = self.tokenizer.convert_ids_to_tokens([predicted_index])[0]\\n \\n print(predicted_token)\",\n \"def predict(self, data: np.array) -> np.array:\\n raise NotImplementedError\",\n \"def predict_sf(sentence, model_type=\\\"MLP\\\"):\\n\\n X = \\\" \\\".join(sentence)\\n X_encoding = tokenizer.encode_plus(\\n X, add_special_tokens=True, return_tensors='pt')\\n X_ids = X_encoding['input_ids'].to(DEVICE)\\n with torch.no_grad():\\n output = bert_model(X_ids)\\n\\n # get the 768-d representation of tokens except [CLS] and [SEP]\\n SF_input = get_representation(output)[1:-1]\\n y_pred = []\\n\\n SF_model = None\\n if model_type == \\\"BiLSTM\\\":\\n SF_model = get_SF_model(\\\"BiLSTM\\\")\\n\\n LSTM_input = [np.array(i) for i in SF_input]\\n y_pred.append(np.array(LSTM_input))\\n y_pred = SF_model.predict_classes(np.array(y_pred))[0]\\n y_pred = [y-1 for y in y_pred]\\n return y_pred\\n\\n elif model_type == \\\"MLP\\\":\\n SF_model = get_SF_model(\\\"MLP\\\")\\n SF_model.eval()\\n\\n for p in range(len(X_ids[0]) - 2):\\n SF_output = SF_model(SF_input[p]).unsqueeze(0)\\n y_pred.append(torch.argmax(SF_output).item())\\n\\n return y_pred\\n else:\\n print(\\\"Model type not supported!\\\")\\n print('Please choose from either \\\"BiLSTM\\\" or \\\"MLP\\\"')\",\n \"def predict_types_features(self, context):\\n ngram_probs = self._get_full_ngram_probs(context)\\n return ngram_probs\",\n \"def predict(self, sentences, batch_size=32):\\n train_encodings = self.tokenizer(sentences,\\n truncation=True,\\n padding=True,\\n max_length=500)\\n\\n train_dataset = TextDataset(train_encodings)\\n\\n loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size)\\n collect_outputs = []\\n with torch.no_grad():\\n for batch in loader:\\n input_ids = batch['input_ids']\\n attention_mask = batch['attention_mask']\\n\\n outputs = self.model(input_ids, attention_mask=attention_mask)\\n collect_outputs.extend(torch.argmax(outputs[\\\"logits\\\"], axis=1).cpu().numpy().tolist())\\n\\n return [self.sentiment_map[k] for k in collect_outputs]\",\n \"def predict(self, params, exog=None, *args, **kwargs):\\n raise NotImplementedError # pragma: no cover\",\n \"def _get_predictions(self, line: List[str]):\\n example = self.tokenizer.encode_plus(\\n [c for c in line],\\n return_token_type_ids=True,\\n return_attention_mask=True,\\n return_tensors=\\\"pt\\\",\\n )\\n example = {k: v.to(self.device) for k, v in example.items()}\\n prediction = self.model(example, training=False)[0]\\n prediction = self.softmax_fn(prediction).cpu().data.numpy()\\n prediction = prediction[1:-1, 1:].argmax(axis=-1)\\n return prediction\",\n \"def predict(self, sentences, batch_size=32):\\n train_encodings = self.tokenizer(sentences,\\n truncation=True,\\n padding=True,\\n max_length=500)\\n\\n train_dataset = TextDataset(train_encodings)\\n\\n loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size)\\n collect_outputs = []\\n\\n with torch.no_grad():\\n for batch in loader:\\n input_ids = batch['input_ids']\\n attention_mask = batch['attention_mask']\\n\\n outputs = self.model(input_ids, attention_mask=attention_mask)\\n collect_outputs.extend(torch.argmax(outputs[\\\"logits\\\"], axis=1).cpu().numpy().tolist())\\n\\n return [self.emotion_map[k] for k in collect_outputs]\",\n \"def predict(self, x, **kwargs):\\n raise NotImplementedError\",\n \"def predict(self, text):\\n tokens = ['[CLS]'] + self.tokenizer.tokenize(text) + ['[SEP]']\\n xx = self.tokenizer.convert_tokens_to_ids(tokens)\\n xx = torch.tensor(xx).unsqueeze(0).to(self.device)\\n _, y_hat = self.model(xx)\\n pred_tags = []\\n for tag in y_hat.squeeze():\\n pred_tags.append(idx2tag[tag.item()])\\n return pred_tags, tokens\",\n \"def predict(self, ex_words: List[str]) -> int:\\n raise Exception(\\\"Don't call me, call my subclasses\\\")\",\n \"def predict(self,words):\\n vector_array = self.get_vector_array(words)\\n clusterind = self.clusterer.predict(vector_array)\\n return self.target_tokens[clusterind].tolist()\",\n \"def predict(self, data):\\n return self.result.predict(data)\",\n \"def predict(self, X, pred_batch_size=None):\",\n \"def _predict(self, X):\\n raise NotImplementedError\",\n \"def predict(self, eval_dataloader, num_gpus=None, verbose=True):\\n\\n preds = list(\\n super().predict(\\n eval_dataloader=eval_dataloader,\\n get_inputs=TokenClassificationProcessor.get_inputs,\\n n_gpu=num_gpus,\\n verbose=verbose,\\n )\\n )\\n preds_np = np.concatenate(preds)\\n return preds_np\",\n \"def fit(\\n self, m_tokens: np.ndarray, n_types: np.ndarray, M: int = None, N: int = None\\n ):\\n\\n # fix M, N\\n M = M or m_tokens.max()\\n N = N or n_types.max()\\n\\n # initial guess\\n p0 = 2.0\\n\\n # minimize MSE on random perturbations of gamma\\n xdata = np.array(m_tokens) / M\\n ydata = np.array(n_types) / N\\n [gamma_], _ = curve_fit(self.formula, xdata, ydata, p0)\\n self.params = (M, N, gamma_)\\n\\n # return fitted model\\n return self\",\n \"def predict(model, images):\\n return model.predict_classes(images)\",\n \"def predict_next_word(self, features, params, precomputed):\\n raise NotImplementedError(\\\"Model does not implement word prediction.\\\")\",\n \"def predict(self, inputs):\\n if self.use_logistic:\\n return self.predict_labels_logistic(self.w, inputs)\\n return predict_labels(self.w, inputs)\",\n \"def fit_predict(self, X, y=None):\\n self.fit(X)\\n return self.labels_\",\n \"def fit_predict(self, X, y=None):\\n self.fit(X)\\n return self.labels_\",\n \"def predict(self, data):\\n data['predicted'] = self.sentiment_classifier.predict_estimator(data)\\n return data\",\n \"def predict_next_oneofmany(text, tokenizer, max_id, model, temperature=1):\\n X_new = preprocess_input([text], tokenizer, max_id)\\n y_proba = model.predict(X_new)[0, -1:, :]\\n rescaled_logits = tf.math.log(y_proba) / temperature\\n char_id = tf.random.categorical(rescaled_logits, num_samples=1) + 1\\n return tokenizer.sequences_to_texts(char_id.numpy())[0]\",\n \"def predict(self, inp_data: T_co) -> T_co:\\n raise NotImplementedError\",\n \"def predict(self, fit_result, x):\\n raise NotImplementedError()\",\n \"def fit_predict(self):\\n raise AttributeError\",\n \"def predict(self, sent: str, **kwargs) -> str:\\n results = self._model(sent)\\n return results\",\n \"def predict(self, texts):\\n\\n texts = preprocess_text(texts)\\n labels = self.pipeline.predict(texts)\\n\\n return labels\",\n \"def predict(X, y, parameters):\\n pass\",\n \"def predict(data, model: str = None, **kwargs):\\n\\n model_instance = get_model(model)\\n log.debug(\\\"Predict with \\\" + str(model_instance))\\n return model_instance.predict(data, **kwargs)\",\n \"def predict_viterbi(self, tokens: TokenSeq) -> Tuple[NDArray, NDArray, PosSeq]:\",\n \"def predict(self, X: List[np.ndarray], **kwargs) -> List[np.ndarray]:\",\n \"def predict(self, text):\\r\\n vectorizer = CountVectorizer(ngram_range=(1, 2), lowercase=True, vocabulary=self.voc)\\r\\n vector = vectorizer.fit_transform([text])\\r\\n return self.model.predict(vector)[0]\",\n \"def Fit(text):\\n article_tfidf = TransformData([text])\\n global CLASSIFIER\\n predicted_probs = CLASSIFIER.predict_proba(article_tfidf)\\n # the output shoud be an array with two elements, one corresponding to\\n # probability it's a positive sentiment and the other corresponding to\\n # probability it's a negative sentiment.\\n return list(zip(CLASSIFIER.classes_, predicted_probs[0]))\",\n \"def predict(self, words_raw):\\n words = [self.config.processing_word(w) for w in words_raw]\\n if type(words[0]) == tuple:\\n words = zip(*words)\\n pred_ids, _ = self.predict_batch([words])\\n preds = [self.idx_to_tag[idx] for idx in list(pred_ids[0])]\\n\\n return preds\",\n \"def predict(self, words_raw):\\n words = [self.config.processing_word(w) for w in words_raw]\\n if type(words[0]) == tuple:\\n words = zip(*words)\\n pred_ids, _ = self.predict_batch([words])\\n preds = [self.idx_to_tag[idx] for idx in list(pred_ids[0])]\\n\\n return preds\",\n \"def predict(self, x):\\n \\n\\n return predictions\",\n \"def n_grams_predict_next(name: str,\\n file_name: Optional[str] = None,\\n model: Dict[str, NGramsSequence] = None,\\n clean_input_file: Optional[str] = None,\\n clean_input_data: Optional[pd.DataFrame] = None,\\n num_lines_predict: Optional[int] = None,\\n n_grams: int = default_n_grams,\\n num_predict: int = 1,\\n smoothing: SmoothingType = SmoothingType.basic) -> None:\\n\\n logger.success(f'predicting with {smoothing.name} for {name}')\\n\\n if file_name is None and model is None:\\n raise ValueError('no file name or model provided')\\n\\n if clean_input_file is None and clean_input_data is None:\\n raise ValueError('no input file name or data provided')\\n\\n # create n-gram model if not provided\\n if model is None:\\n json_file_path = file_path_relative(f'{models_folder}/{file_name}')\\n logger.info(f'reading data from {json_file_path}')\\n with open(json_file_path, 'r') as file:\\n model = NGramsModel.from_json(json.load(file))\\n\\n # get testing data\\n if clean_input_data is None:\\n file_path = file_path_relative(\\n f'{clean_data_folder}/{clean_input_file}')\\n logger.info(f'reading data from {file_path}')\\n clean_input_data = pd.read_csv(file_path, converters={\\n sentences_key: literal_eval})\\n\\n predict_sentences: List[List[str]] = clean_input_data[sentences_key]\\n if num_lines_predict is not None:\\n predict_sentences = predict_sentences[:num_lines_predict]\\n\\n check_probability_smoothing: List[SmoothingType] = [SmoothingType.basic]\\n\\n logger.success('[[<words>]] = predicted words:')\\n\\n sum_probability_log: float = 0.\\n count_all_predict: int = 0\\n\\n # iterate over testing data\\n for i, sentence in enumerate(predict_sentences):\\n full_sentence = sentence.copy()\\n for _ in range(num_predict):\\n last_words = full_sentence[-n_grams:]\\n sequence = ' '.join(last_words)\\n\\n probabilities = model.get_probabilities(\\n sequence, smoothing)\\n sum_probability = sum(elem[1] for elem in probabilities)\\n # logger.info(f'probabilities: sum: {sum_probability}, all: {probabilities}')\\n if smoothing in check_probability_smoothing:\\n # for not-unseen outputs, check to\\n # make sure sum is approximately 1\\n assert np.isclose(\\n sum_probability, 1), f'probability of {sum_probability} is not close to 1'\\n\\n current_output, prob = probabilities[0]\\n full_sentence.append(current_output)\\n # if not unseen, add to perplexity calculation\\n if current_output != unseen_output:\\n sum_probability_log += np.log(prob)\\n count_all_predict += 1\\n\\n logger.info(\\n f\\\"{i + 1}. {' '.join(sentence)} [[{' '.join(full_sentence[len(sentence):])}]]\\\")\\n\\n if count_all_predict == 0:\\n logger.info('no predictions, no perplexity')\\n else:\\n total_loss = -1 * sum_probability_log\\n perplexity: float = np.exp(total_loss / count_all_predict)\\n logger.info(f\\\"perplexity: {perplexity}\\\")\",\n \"def predict(self, names, labelize=True):\\n #with self.graph.as_default():\\n # format input\\n #print(names)\\n names = [s.lower() for s in names]\\n #print(\\\"lower\\\",names)\\n\\n names = [list(i)+['END']*(self.max_len-len(i)) for i in names]\\n names = [[self.vector(self.char_index[j], self.vocab_len) for j in i] for i in names]\\n names = np.asarray(names)\\n\\n # predict gender\\n out = self.model.predict(names).tolist()\\n print(out)\\n return [('M' if p[0] > p[1] else 'F') for p in out] if labelize else out\",\n \"def predict(\\n self, inputs: base.Array, key: base.RngKey) -> base.Array:\",\n \"def predict(self, stories, questions, stories_lengths, questions_lengths, pack=True):\\n out = self.forward(stories, questions, stories_lengths, questions_lengths, pack)\\n return F.softmax(out)\",\n \"def predict(self, review):\\n raise NotImplementedError\",\n \"def predict(self, x):\\n # *** START CODE HERE ***\\n return self.clf.predict_classes(x.reshape(x.shape[0], 28, 28, 1))\\n # *** END CODE HERE ***\",\n \"def predict(self, x, **kwargs):\\n return self.tuner.get_best_models(1)[0].predict(x, **kwargs)\",\n \"def _fit_predict(X_train, y_train, X_test):\\n raise NotImplementedError()\",\n \"def predict(self, X, **kwargs):\\n return Learner.predict(self, X, **kwargs)\",\n \"def predict(self, first_preprocessed_inputs,second_preprocessed_inputs,third_preprocessed_inputs):\\r\\n pass\",\n \"def fit_predict(self, X, y=None):\\n return self.fit(X, y).predict(X)\",\n \"def predict(self, x):\\n raise NotImplementedError(\\\"Please Implement this method\\\")\",\n \"def _predict(self, x):\\n pass\",\n \"def predict(model, features):\\n result = model.predict(features)\\n return result\",\n \"def predict(self, data: List):\\r\\n return self._lda.predict(data)\",\n \"def predict(self, x, **kwargs):\\n kwargs = self.filter_sk_params(Sequential.predict_classes, kwargs)\\n classes = self.model.predict_classes(x, **kwargs)\\n return self.classes_[classes]\",\n \"def predict(self, predPoints=None):\",\n \"def predict(self, content):\\n input_x = list(content)\\n while len(input_x) < self.args.maxlen1: input_x.append('<pad>')\\n input_x = input_x[:self.args.maxlen1]\\n\\n input_x = [self.token2idx.get(s, self.token2idx['<unk>']) for s in input_x]\\n\\n memory = self.sess.run(self.memory, feed_dict={self.input_x: [input_x]})\\n\\n return self.bs.search(self.sess, input_x, memory[0])\",\n \"def predict_only(self):\",\n \"def predict(self, sentences: List[str]) -> List[Dict[str, Any]]:\\n inputs, offset_mapping = self.tokenize(sentences=sentences)\\n outputs = self.model(**inputs)\\n logits = outputs[\\\"logits\\\"]\\n predicted_intents = self.convert_intent_logits(intent_logits=logits[1])\\n predicted_entities = self.convert_entities_logits(entities_logits=logits[0], offset_mapping=offset_mapping)\\n predicted_outputs = []\\n for sentence, intent_sentence, entities_sentence in zip(sentences, predicted_intents, predicted_entities):\\n predicted_outputs.append({})\\n predicted_outputs[-1].update(intent_sentence)\\n predicted_outputs[-1].update({\\\"entities\\\": entities_sentence})\\n for entity in predicted_outputs[-1][\\\"entities\\\"]:\\n entity[\\\"text\\\"] = sentence[entity[\\\"start\\\"]: entity[\\\"end\\\"]]\\n\\n if self.synonym_dict.get(entity[\\\"text\\\"], None):\\n entity[\\\"original_text\\\"] = entity[\\\"text\\\"]\\n entity[\\\"text\\\"] = self.synonym_dict[entity[\\\"text\\\"]]\\n\\n predicted_outputs[-1][\\\"text\\\"] = sentence\\n\\n return predicted_outputs\",\n \"def predict(self, features):\\n return self.search_results.predict(features)\",\n \"def predict(self, peptides, **kwargs):\\n raise NotImplementedError\",\n \"def fit_experimental(self, m_tokens: np.ndarray, n_types: np.ndarray, gamma: float):\\n\\n # initial guess\\n M = m_tokens.max()\\n N = n_types.max()\\n p0 = (M, N)\\n\\n # fix gamma, but fit M, N to the data\\n xdata = np.array(m_tokens)\\n ydata = np.array(n_types)\\n\\n def func(m, M, N):\\n return N * self.formula(m / M, gamma)\\n\\n [M, N], _ = curve_fit(func, xdata, ydata, p0)\\n M, N = int(M), int(N)\\n self.params = (M, N, gamma)\\n\\n # return fitted model\\n return self\",\n \"def predict(self, data):\\n\\t\\tres = self.neuralNetworks.inference(self.dataCenter.process_inference_data(data))\\n\\t\\tprint(res)\",\n \"def predict(self):\\n\\n self.eval()\\n return self.forward(self.data)\",\n \"def predict(self, texts: List[ParsedText]) -> List[ParsedText]:\\n self.model.eval()\\n texts = copy.deepcopy(texts)\\n\\n batches = DataLoader(texts=texts,\\n batch_size=self.batch_size,\\n vocabulary=self.vocabulary,\\n aspect_labels=self.aspect_labels,\\n device=self.device)\\n for batch_index, batch in enumerate(batches):\\n logits = self.model(embed_ids=batch.embed_ids, sentence_len=batch.sentence_len)\\n pred_labels = th.argmax(logits.to('cpu'), dim=1)\\n pred_sentences_opinions = self._get_opinions(\\n labels_indexes=pred_labels,\\n sentence_len=[x.item() for x in batch.sentence_len.to('cpu')])\\n for internal_index, opinions in enumerate(pred_sentences_opinions):\\n text_index = batch.text_index[internal_index]\\n sentence_index = batch.sentence_index[internal_index]\\n sentence_nodes = texts[text_index].sentences[\\n sentence_index].nodes_sentence_order()\\n\\n explicit_opinions = []\\n explicit_categories = set()\\n for opinion in opinions:\\n opinion.nodes = [sentence_nodes[x] for x in opinion.nodes]\\n explicit_opinions.append(opinion)\\n explicit_categories.add(opinion.category)\\n for opinion in texts[text_index].sentences[sentence_index].opinions:\\n if (not opinion.nodes) and (opinion.category in explicit_categories):\\n texts[text_index].sentences[sentence_index].opinions.remove(opinion)\\n texts[text_index].sentences[sentence_index].opinions.extend(explicit_opinions)\\n return texts\",\n \"def predict(self, texts, merge_tokens=True):\\n if os.environ.get('DISABLE_V2_BEHAVIOR', None) != '1':\\n warnings.warn(\\\"Please add os.environ['DISABLE_V2_BEHAVIOR'] = '1' at top of your script or notebook\\\")\\n msg = \\\"\\\\nNER in ktrain uses the CRF module from keras_contrib, which is not yet\\\\n\\\" +\\\\\\n \\\"fully compatible with TensorFlow 2. To use NER, you must add the following to the top of your\\\\n\\\" +\\\\\\n \\\"script or notebook BEFORE you import ktrain (after restarting runtime):\\\\n\\\\n\\\" +\\\\\\n \\\"import os\\\\n\\\" +\\\\\\n \\\"os.environ['DISABLE_V2_BEHAVIOR'] = '1'\\\\n\\\"\\n print(msg)\\n return\\n else:\\n import tensorflow.compat.v1 as tf\\n tf.disable_v2_behavior()\\n\\n #old_do = os.environ.get('CUDA_DEVICE_ORDER', None)\\n #old_vd = os.environ.get('CUDA_VISIBLE_DEVICES', None)\\n #os.environ[\\\"CUDA_DEVICE_ORDER\\\"] = \\\"PCI_BUS_ID\\\"\\n #os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\\n\\n if isinstance(texts, str): texts = [texts]\\n if self.lang == 'zh':\\n dirpath = os.path.dirname(os.path.abspath(__file__))\\n fpath = os.path.join(dirpath, 'ner_models/ner_chinese')\\n elif self.lang == 'ru':\\n dirpath = os.path.dirname(os.path.abspath(__file__))\\n fpath = os.path.join(dirpath, 'ner_models/ner_russian')\\n elif self.lang=='en':\\n dirpath = os.path.dirname(os.path.abspath(__file__))\\n fpath = os.path.join(dirpath, 'ner_models/ner_english')\\n else:\\n raise ValueError('lang %s is not supported by NER' % (self.lang))\\n try:\\n import io\\n from contextlib import redirect_stdout\\n f = io.StringIO()\\n with redirect_stdout(f):\\n import ktrain\\n except:\\n raise ValueError('ktrain could not be imported. Install with: pip3 install ktrain')\\n predictor = ktrain.load_predictor(fpath)\\n results = []\\n for text in texts:\\n text = text.strip()\\n result = predictor.predict(text)\\n if merge_tokens:\\n result = self.merge_entities(result)\\n results.append(result)\\n if len(result) == 1: result = result[0]\\n\\n #if old_do is not None:\\n #os.environ[\\\"CUDA_DEVICE_ORDER\\\"] = old_do\\n #else:\\n #del os.environ['CUDA_DEVICE_ORDER']\\n #if old_vd is not None:\\n #os.environ['CUDA_VISIBLE_DEVICES'] = old_vd\\n #else:\\n #del os.environ['CUDA_VISIBLE_DEVICES']\\n return result\",\n \"def predict(self, data):\\r\\n return self.sess.run([self.predict_op, self.Mu], feed_dict={self.X: data})\",\n \"def make_predictions(model, tokenizer, paragraphs):\\n \\n prediction_dataloader = bert_preprocess(paragraphs, tokenizer) \\n predictions = eval_cpu(prediction_dataloader, model) \\n malware_ids = get_pred_ids(predictions) \\n return malware_ids\",\n \"def inference(self, inputs):\\n # NOTE: This makes the assumption that your model expects text to be tokenized\\n # with \\\"input_ids\\\" and \\\"token_type_ids\\\" - which is true for some popular transformer models, e.g. bert.\\n # If your transformer model expects different tokenization, adapt this code to suit\\n # its expected input format.\\n input_ids = inputs[\\\"input_ids\\\"]\\n input_ids = input_ids.to(self.device)\\n\\n coarse_result = self.model.generate(input_ids = input_ids, )\\n coarse_result = coarse_result.to(\\\"cpu\\\")\\n fined_result = self.tokenizer.decode(coarse_result[0].tolist()[inputs[\\\"original_length\\\"]+1:],\\n skip_special_tokens = True)\\n #logger.info(\\\"Model predicted: '%s'\\\", fined_result)\\n\\n return [fined_result]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7779649","0.73221636","0.70830023","0.6999615","0.6885678","0.6868568","0.6573257","0.6553992","0.6472437","0.64069986","0.63722783","0.63283336","0.631563","0.6238089","0.6219484","0.6217989","0.6209873","0.61776686","0.61699307","0.6155449","0.6138378","0.6138378","0.6137764","0.61351115","0.61351115","0.61351115","0.6119578","0.6118012","0.6118012","0.6118012","0.61171246","0.609873","0.609231","0.6049489","0.6036168","0.6031545","0.60306823","0.602141","0.60172534","0.601452","0.5992377","0.59883076","0.59833664","0.5982764","0.59806263","0.59767646","0.59630674","0.59584135","0.5952978","0.595084","0.5935036","0.5935036","0.5933344","0.5930683","0.5922878","0.59193814","0.5903351","0.5900962","0.5896781","0.5895313","0.5892768","0.5890404","0.5888233","0.586456","0.58596313","0.5856386","0.5856386","0.583524","0.58352137","0.5826218","0.58244765","0.5823611","0.5823024","0.5820456","0.5781202","0.5769635","0.576882","0.57671845","0.5759603","0.57535714","0.5744956","0.5740212","0.5734823","0.5732844","0.57265866","0.57242036","0.57152796","0.5711217","0.5706292","0.57037127","0.5699706","0.5680849","0.56801337","0.56782055","0.5675849","0.56736195","0.5670698","0.5667181"],"string":"[\n \"0.7779649\",\n \"0.73221636\",\n \"0.70830023\",\n \"0.6999615\",\n \"0.6885678\",\n \"0.6868568\",\n \"0.6573257\",\n \"0.6553992\",\n \"0.6472437\",\n \"0.64069986\",\n \"0.63722783\",\n \"0.63283336\",\n \"0.631563\",\n \"0.6238089\",\n \"0.6219484\",\n \"0.6217989\",\n \"0.6209873\",\n \"0.61776686\",\n \"0.61699307\",\n \"0.6155449\",\n \"0.6138378\",\n \"0.6138378\",\n \"0.6137764\",\n \"0.61351115\",\n \"0.61351115\",\n \"0.61351115\",\n \"0.6119578\",\n \"0.6118012\",\n \"0.6118012\",\n \"0.6118012\",\n \"0.61171246\",\n \"0.609873\",\n \"0.609231\",\n \"0.6049489\",\n \"0.6036168\",\n \"0.6031545\",\n \"0.60306823\",\n \"0.602141\",\n \"0.60172534\",\n \"0.601452\",\n \"0.5992377\",\n \"0.59883076\",\n \"0.59833664\",\n \"0.5982764\",\n \"0.59806263\",\n \"0.59767646\",\n \"0.59630674\",\n \"0.59584135\",\n \"0.5952978\",\n \"0.595084\",\n \"0.5935036\",\n \"0.5935036\",\n \"0.5933344\",\n \"0.5930683\",\n \"0.5922878\",\n \"0.59193814\",\n \"0.5903351\",\n \"0.5900962\",\n \"0.5896781\",\n \"0.5895313\",\n \"0.5892768\",\n \"0.5890404\",\n \"0.5888233\",\n \"0.586456\",\n \"0.58596313\",\n \"0.5856386\",\n \"0.5856386\",\n \"0.583524\",\n \"0.58352137\",\n \"0.5826218\",\n \"0.58244765\",\n \"0.5823611\",\n \"0.5823024\",\n \"0.5820456\",\n \"0.5781202\",\n \"0.5769635\",\n \"0.576882\",\n \"0.57671845\",\n \"0.5759603\",\n \"0.57535714\",\n \"0.5744956\",\n \"0.5740212\",\n \"0.5734823\",\n \"0.5732844\",\n \"0.57265866\",\n \"0.57242036\",\n \"0.57152796\",\n \"0.5711217\",\n \"0.5706292\",\n \"0.57037127\",\n \"0.5699706\",\n \"0.5680849\",\n \"0.56801337\",\n \"0.56782055\",\n \"0.5675849\",\n \"0.56736195\",\n \"0.5670698\",\n \"0.5667181\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.86812186"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":91794,"cells":{"query":{"kind":"string","value":"Number of tokens in the corpus."},"document":{"kind":"string","value":"def M(self) -> int:\n return self.params.M"},"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 corpus_size():\n return ix.doc_count()","def num_tokens(self, index):\r\n raise NotImplementedError","def n_words(doc_or_tokens: types.DocOrTokens) -> int:\n words = utils.get_words(doc_or_tokens)\n return itertoolz.count(words)","def get_num_tokens(self, documents=None):\n tokens = []\n if documents == None:\n docs = self.vocab\n else:\n docs = [term for term in self.vocab if term['name'] in documents]\n for doc in docs:\n for term, count in doc['term_counts'].items():\n tokens.append(count)\n return sum(tokens)","def length(self):\n return len(self.tokens)","def count(self, tokens):\n return self.counts[tokens]","def get_token_count():\r\n tokens = cache.get('tokens-number')\r\n\r\n if tokens is None:\r\n tokens = 0\r\n tweets = mongo_coll_tweets.find({}, {'text': 1})\r\n for tweet in tweets:\r\n if 'full_text' in tweet.keys():\r\n tokens += len(tweet['full_text'].split(' '))\r\n else:\r\n tokens += len(tweet['text'].split(' '))\r\n\r\n cache.set('tokens-number', tokens, 360)\r\n\r\n return tokens","def count(self, tokens):\n return self._count.get(tuple(tokens), 0)","def __len__(self):\n return len(self._tokens)","def count_tokens(txt_to_tokenise_and_count):\n\n txt_tokens = nltk.word_tokenize(txt_to_tokenise_and_count) \n counts = Counter(txt_tokens)\n\n print (counts.most_common(10))\n return counts","def corpus_length(corpus):\n corpus_len = len(corpus)\n return corpus_len","def count(self, tokens):\n return self._count[tuple(tokens)]","def _get_token_cnts(self, doc, doc_type):\n tokenized_doc = self.nlp(doc)\n self.stat_dict[doc_type][0].append(len([s for s in tokenized_doc.sents]))\n doc_len = len([t for t in tokenized_doc])\n self.stat_dict[doc_type][1].append(doc_len)\n if doc_len < 50 and doc_type == \"answer\":\n print(\"Document less than 50 tokens:\", url)","def get_num_docs(self):\n return len(self.vocab)","def count_tokens(self, request: Request, completions: List[Sequence]) -> int:\n return sum(len(sequence.tokens) for sequence in completions)","def count_tokens(self, request: Request, completions: List[Sequence]) -> int:\n return sum(len(sequence.tokens) for sequence in completions)","def num_tokens(self, index):\n return max(self.d1.num_tokens(index), self.d2.num_tokens(index))","def tcount(self, tokens):\n return self._tcounts.get(tokens, 0)","def word_count(self, doc):\n\n return len(self.tokenize_doc_simple(doc))","def compute_token_count(token_dict):\n return sum([token_dict[key] for key in token_dict.keys()])","def count_token(text):\n count=0\n if isinstance(text, list):\n for ayah in text:\n count=count+ayah.count(' ')+1\n else:\n count=text.count(' ')+1\n\n return count","def get_total_number_of_words(self, tokens):\n return {\"total_number_of_words\": len(tokens)}","def word_count(self):\n return len(self.text)","def wordCount(document):\n return float(len(document.split(None)))","def sentence_count(self, doc):\n\n return len(sent_tokenize(doc))","def _count_tokens(self,\n token_lists):\n ## Filter out empty lists\n fn_tokens = list(filter(lambda i: len(i) > 0, token_lists))\n ## Get N-grams from Tokens\n fn_ngrams = list(map(lambda t: self.get_ngrams(t, self._ngrams[0], self._ngrams[1]),\n fn_tokens))\n ## Count Tokens (binary if class is unfit and binarization turned on)\n if hasattr(self, \"_class_state\") and \\\n self._class_state == \"untrained\" and \\\n hasattr(self, \"_binarize_counter\") and \\\n self._binarize_counter:\n fn_counts = Counter(list(set(flatten(fn_ngrams))))\n else:\n fn_counts = Counter(flatten(fn_ngrams))\n return fn_counts","def vocab_size(self) -> int:\n return len(self._tokenizer)","def vocab_size(self) -> int:\n return len(self._tokenizer)","def count_tokens(tokens, filename):\n wordcounts = Counter(tokens)\n #print(wordcounts)\n wordcounts = pd.Series(wordcounts, name=filename)\n #print(wordcounts.head())\n return wordcounts","def num_tokens_vec(self, indices):\r\n raise NotImplementedError","def n_unique_words(doc_or_tokens: types.DocOrTokens) -> int:\n words = utils.get_words(doc_or_tokens)\n # NOTE: this stdlib solution is slower than itertoolz for docs with ~250+ words\n # so let's take a small hit on short docs for the sake of big wins on long docs\n # return len({word.lower for word in words})\n return itertoolz.count(itertoolz.unique(word.lower for word in words))","def getNumTerms(self):\n\n return self._numTerms","def getTokenSizeOfReviews(self):\n res = 0\n with open(self.word_to_docs_path, 'rb') as bin:\n while bin.tell() != os.fstat(bin.fileno()).st_size:\n # get wordid:\n int.from_bytes(bin.read(4), 'big')\n # get frequency:\n frequency = int.from_bytes(bin.read(4), 'big')\n res += frequency\n # skip documents:\n int.from_bytes(bin.read(4 * frequency), 'big')\n return res","def count_ngrams(self, corpus):\n self.unigramcounts = defaultdict(int) # might want to use defaultdict or Counter instead\n self.bigramcounts = defaultdict(int)\n self.trigramcounts = defaultdict(int)\n\n self.total_word_count = 0\n self.total_sentence_count = 0\n\n # For each sentence, generate ngram_counts\n for sentence in corpus :\n # 2 extra START tokens and 1 extra STOP token\n self.total_word_count += len(sentence) + 3\n self.total_sentence_count += 1\n for unigram in get_ngrams(sentence, 1) :\n self.unigramcounts[unigram] += 1\n for bigram in get_ngrams(sentence, 2) :\n self.bigramcounts[bigram] += 1\n for trigram in get_ngrams(sentence, 3) :\n self.trigramcounts[trigram] += 1\n\n return","def token_length(self):\n return 32","def count(self, word):\n return self.tokens.count(word)","def get_num_terms(self, documents=None):\n terms = []\n if documents == None:\n docs = self.vocab\n else:\n docs = [term for term in self.vocab if term['name'] in documents]\n for doc in docs:\n for term, count in doc['term_counts'].items():\n terms.append(term)\n return len(list(set(terms)))","def get_number_of_different_tokens(token_list):\n \n return len(set(token_list))","def get_num_tokens(dt_matrix):\n\n\trows, cols = dt_matrix.get_shape()\n\tnum_tokens = 0\n\tfor i in range(0, rows):\n\t\tnum_tokens += dt_matrix.getrow(i).sum()\n\n\treturn num_tokens","def calculate_vocabulary_size(self, corpus: str):\n corpus_tokens_less = self._tokenize_less_start_end(corpus)\n Lap_smooth_suppl = 1\n num_of_distinct_tokens = len(set(corpus_tokens_less))\n V = num_of_distinct_tokens + Lap_smooth_suppl\n return V","def num_tokens(self, index):\r\n return max(self.src_sizes[index], self.tgt_sizes[index] if self.tgt_sizes is not None else 0)","def word_count(self):\n return self._word_count","def get_wordcount_counter(self):\n corpus_counter = Counter()\n for current_document in self.documents:\n document_counter = current_document.get_wordcount_counter()\n corpus_counter += document_counter\n return corpus_counter","def n_chars_per_word(doc_or_tokens: types.DocOrTokens) -> tuple[int, ...]:\n words = utils.get_words(doc_or_tokens)\n return tuple(len(word) for word in words)","def get_num_tokens(self, text: str) -> int:\n # tiktoken NOT supported for Python 3.8 or below\n if sys.version_info[1] <= 8:\n return super().get_num_tokens(text)\n try:\n import tiktoken\n except ImportError:\n raise ValueError(\n \"Could not import tiktoken python package. \"\n \"This is needed in order to calculate get_num_tokens. \"\n \"Please it install it with `pip install tiktoken`.\"\n )\n encoder = \"gpt2\"\n if self.model_name in (\"text-davinci-003\", \"text-davinci-002\"):\n encoder = \"p50k_base\"\n if self.model_name.startswith(\"code\"):\n encoder = \"p50k_base\"\n # create a GPT-3 encoder instance\n enc = tiktoken.get_encoding(encoder)\n\n # encode the text using the GPT-3 encoder\n tokenized_text = enc.encode(text)\n\n # calculate the number of tokens in the encoded text\n return len(tokenized_text)","def count_ngrams(self, corpus):\n \n self.unigramcounts = defaultdict(int)\n self.bigramcounts = defaultdict(int)\n self.trigramcounts = defaultdict(int)\n\n self.sentence_counts = 0\n self.word_count = 0\n\n for line in corpus:\n sequence = line\n self.sentence_counts +=1\n\n unigrams = get_ngrams(sequence, n=1)\n for gram in unigrams:\n self.word_count += 1\n self.unigramcounts[gram] +=1\n\n bigrams = get_ngrams(sequence, n=2)\n for gram in bigrams:\n self.bigramcounts[gram] +=1\n\n trigrams = get_ngrams(sequence, n=3)\n for gram in trigrams:\n self.trigramcounts[gram] +=1\n\n #self.unigramcounts[('START')] = self.sentence_counts *2\n self.bigramcounts[('START', 'START')] = self.sentence_counts\n\n #return self","def count_words(sent):\n words = word_tokenize(sent)\n return len(words)","def corpus_stats(self):\n print(\"Number of sentences: {}\".format(len(self.corpus.sents())))\n print(\"Token: {}\".format(len(self.corpus.words())))\n types = FreqDist(self.corpus.words())\n print(\"Types: {}\".format(len(types)))","def getNumod_byerSentences(self): # !!! Need to rewrite this to match graph\n return len(self.__document)","def n_chars(doc_or_tokens: types.DocOrTokens) -> int:\n # docs are hashable, so we can leverage the lru cache as-is\n if isinstance(doc_or_tokens, Doc):\n ncpw = n_chars_per_word(doc_or_tokens)\n # otherwise, let's get an iterable of words but cast it to a hashable tuple\n # so we can leverage the lru cache on this and related calls in, say, n_long_words\n else:\n words = utils.get_words(doc_or_tokens)\n ncpw = n_chars_per_word(tuple(words))\n return sum(ncpw)","def number_types(corpus):\n number_of_types = len(set(corpus))\n return number_of_types","def number_tokens(dgraph):\n cnt = 0\n for node in dgraph.subgraphs(exclude_root=True):\n node[WORD] = (cnt, node[WORD])\n cnt += 1\n return dgraph","def total_tokens(self):\n t = self.tokens.aslist()\n p = self.passive_tokens()\n total = [0]*6\n for i in range(6):\n total[i] = t[i] + p[i]\n return total","def train(self, corpus):\n lastToken = \"#\"\n for sentence in corpus.corpus:\n for datum in sentence.data:\n token = datum.word\n self.reverseBigramCount[token][lastToken] += 1\n self.bigramCount[lastToken][token] += 1\n self.unigramCount[token] += 1\n self.total += 1\n lastToken = token","def counts(self, regex = \"\\w+\"): \n tokenizer = RegexpTokenizer(r'{}'.format(regex))\n count = []\n for i in tqdm(self.text):\n count.append(len(tokenizer.tokenize(i)))\n return count","def word_count(self):\n print(self.words())\n return len(self.words())\n #count = 0\n #for lines in self.lines:\n # line = lines.strip(os.linesep)\n # wordslst = line.split()\n # count += len(wordslst)\n #return count\n #joined_string = ''.join(self.lines)\n #for word in joined_string:\n # if word != ' ' and word != '\\n' and word != '\\t':\n # count += 1\n #print('READ ME ––––––––––', self.lines)\n #print(joined_string)\n #print(line)\n #print(wordslst)\n #print(count)","def get_count(self):\n return len(self._tags)","def _get_num_words(doc: Doc):\n filtered_words = [word for word in doc if not word.is_punct and \"'\" not in word.text and not word.is_space]\n return len(filtered_words)","def count_word(doc):\n count = count = 0\n for w in document.split(\" \"):\n count = count + 1\n return count","def text_len(self, text):\n length = len(word_tokenize(text))\n return length","def sent_count(self):\n count = []\n for i in tqdm(self.text):\n count.append(len(sent_tokenize(i)))\n return count","def __len__(self):\n return len(self._terms)","def char_count(self, doc):\n\n return len(doc)","def word_count(self):\n from collections import Counter\n counts = Counter(self._replace_non_alnum().split())\n return counts","def count(text):\n return len(text)","def count_tokens(self, words: Iterable[str]) -> Dict[str, int]:\r\n token_counts = Counter(words)\r\n return {\" \".join(token): count for token, count in token_counts.items()}","def paragraph_count(self, doc):\n\n paragraphs = doc.split(\"\\n\\n\")\n # remove the empty string\n return len([paragraph for paragraph in paragraphs if paragraph])","def get_total_number_of_documents(self):\n return self.total_number_of_documents","def getLength( self, sbjct_token ):\n if not self.mIsLoaded: self.__loadIndex()\n return self.mIndex[sbjct_token][2]","def vocab_size(self):\n return len(self.vocab)","def count_terms(self, tokens):\n\n terms = [self.term_match(t) for t in tokens ]\n \n terms = [t for t in terms if t != None]\n\n #print terms\n lf = dict(Counter(terms))\n for k in lf:\n lf[k] /= float(len(tokens))\n #lf[k] = 1 # binarize?\n pass\n return lf","def number_of_links(corpus, page):\n return len(corpus[page]) if corpus[page] else len(corpus)","def __len__(self: TokenMatcher) -> int:\n return len(self._patterns)","def document_count(self):\n raise NotImplementedError","def computeWordsFrequencies(self):\n token_stream = self._tokenize(self.readable)\n token_map = self._countTokens(token_stream)\n # print token_map.items()\n return sorted(token_map.items(), key = lambda x : x[1], reverse = True)","def count_words(tokenized_sentences):\r\n \r\n word_counts = {}\r\n \r\n # Loop through each sentence\r\n for sentence in tokenized_sentences: # complete this line\r\n \r\n for token in sentence: # complete this line\r\n\r\n # If the token is not in the dictionary yet, set the count to 1\r\n if token not in word_counts.keys(): # complete this line\r\n word_counts[token] = 1\r\n \r\n # If the token is already in the dictionary, increment the count by 1\r\n else:\r\n word_counts[token] += 1\r\n \r\n return word_counts","def vocab_size(self) -> int:\n return len(self.vocabulary)","def wordcount(self):\n return int(self._fetch_element('user_wordcount'))","def count(self):\n return len(self.read_ints())","def _n_matches(gold_tokens, pred_tokens):\n matcher = difflib.SequenceMatcher(None, gold_tokens, pred_tokens)\n return sum(match.size for match in matcher.get_matching_blocks())","def get_number_of_words_in_document(self, document):\n for _set in self.sets:\n if document in _set:\n return self.sets[_set][document]['number_of_words']","def get_count_distinct(corpus):\n # get the list of all words in the corpus\n vocab_words = [sentence[idx]\n for sentence in corpus for idx in range(len(sentence))]\n # remove duplicates\n vocab_words = set(vocab_words)\n\n return len(vocab_words), sorted(list(vocab_words))","def total_words(target_text):\n\n splited_text = target_text.split()\n nbwords = len(splited_text)\n return nbwords","def count(self):\n return self.__tree.node_count","def main ():\n fio = FileIo(\"../input2.txt\")\n text = fio.getInput()\n p = re.compile(r'#?\\d[\\s\\.]?[\\s]?')\n out = filter(None, p.split(text))\n #print out[2]\n #print len(out)\n wc = 0\n\n for s in out:\n text = nltk.word_tokenize(s)\n wc += wordCount( text )\n print wc","def getNumberTerms(content): \n return Counter(getTerms(content))","def M(self) -> int:\n m_tokens = sum(self.values())\n return m_tokens","def train(self, tokens):\n if len(tokens) == 0: # Empty tokens\n return pd.Series(dtype=float).astype(float)\n return pd.Series(tokens).value_counts(normalize=True)","def num_articles(self):\n\t\treturn len(index)","def __len__(self):\n if self._words is None:\n return 0\n return len(self._words)","def get_num_tigers(self) -> int:\n return len(self.get_all_tiger_positions())","def n_sents(doc: Doc) -> int:\n if not doc.has_annotation(\"SENT_START\"):\n LOGGER.warning(\n \"`doc` has not been segmented into sentences; applying spaCy's rule-based, \"\n \"`Sentencizer` pipeline component to `doc` before counting...\"\n )\n doc = _SENTENCIZER(doc)\n return itertoolz.count(doc.sents)","def count_words(self, clean_func=clean_up):\n return (\n len(clean_func(self.transcript_file.text()).split())\n if self.validate()\n else 0\n )","def count(self, ngram, options):\n return len(self.find_docs(ngram, options))","def doc_count(self):\n\t\treturn self.index.collection.count()","def countOccurrences(self, wordsToCheck):\n count = 0\n for token in self.importantTokenList():\n w = token.text\n for wtc in wordsToCheck:\n if wtc == w:\n count = count + 1\n return count","def get_length(self):\r\n return len(self.tweets)","def n_trees(self):\n return len(self.data_kd)","def __len__(self):\n return len(self.words)","def count(self):\n # TODO not implemented yet\n return 0","def count(self):\n\t\treturn len(list(self.nodes))"],"string":"[\n \"def corpus_size():\\n return ix.doc_count()\",\n \"def num_tokens(self, index):\\r\\n raise NotImplementedError\",\n \"def n_words(doc_or_tokens: types.DocOrTokens) -> int:\\n words = utils.get_words(doc_or_tokens)\\n return itertoolz.count(words)\",\n \"def get_num_tokens(self, documents=None):\\n tokens = []\\n if documents == None:\\n docs = self.vocab\\n else:\\n docs = [term for term in self.vocab if term['name'] in documents]\\n for doc in docs:\\n for term, count in doc['term_counts'].items():\\n tokens.append(count)\\n return sum(tokens)\",\n \"def length(self):\\n return len(self.tokens)\",\n \"def count(self, tokens):\\n return self.counts[tokens]\",\n \"def get_token_count():\\r\\n tokens = cache.get('tokens-number')\\r\\n\\r\\n if tokens is None:\\r\\n tokens = 0\\r\\n tweets = mongo_coll_tweets.find({}, {'text': 1})\\r\\n for tweet in tweets:\\r\\n if 'full_text' in tweet.keys():\\r\\n tokens += len(tweet['full_text'].split(' '))\\r\\n else:\\r\\n tokens += len(tweet['text'].split(' '))\\r\\n\\r\\n cache.set('tokens-number', tokens, 360)\\r\\n\\r\\n return tokens\",\n \"def count(self, tokens):\\n return self._count.get(tuple(tokens), 0)\",\n \"def __len__(self):\\n return len(self._tokens)\",\n \"def count_tokens(txt_to_tokenise_and_count):\\n\\n txt_tokens = nltk.word_tokenize(txt_to_tokenise_and_count) \\n counts = Counter(txt_tokens)\\n\\n print (counts.most_common(10))\\n return counts\",\n \"def corpus_length(corpus):\\n corpus_len = len(corpus)\\n return corpus_len\",\n \"def count(self, tokens):\\n return self._count[tuple(tokens)]\",\n \"def _get_token_cnts(self, doc, doc_type):\\n tokenized_doc = self.nlp(doc)\\n self.stat_dict[doc_type][0].append(len([s for s in tokenized_doc.sents]))\\n doc_len = len([t for t in tokenized_doc])\\n self.stat_dict[doc_type][1].append(doc_len)\\n if doc_len < 50 and doc_type == \\\"answer\\\":\\n print(\\\"Document less than 50 tokens:\\\", url)\",\n \"def get_num_docs(self):\\n return len(self.vocab)\",\n \"def count_tokens(self, request: Request, completions: List[Sequence]) -> int:\\n return sum(len(sequence.tokens) for sequence in completions)\",\n \"def count_tokens(self, request: Request, completions: List[Sequence]) -> int:\\n return sum(len(sequence.tokens) for sequence in completions)\",\n \"def num_tokens(self, index):\\n return max(self.d1.num_tokens(index), self.d2.num_tokens(index))\",\n \"def tcount(self, tokens):\\n return self._tcounts.get(tokens, 0)\",\n \"def word_count(self, doc):\\n\\n return len(self.tokenize_doc_simple(doc))\",\n \"def compute_token_count(token_dict):\\n return sum([token_dict[key] for key in token_dict.keys()])\",\n \"def count_token(text):\\n count=0\\n if isinstance(text, list):\\n for ayah in text:\\n count=count+ayah.count(' ')+1\\n else:\\n count=text.count(' ')+1\\n\\n return count\",\n \"def get_total_number_of_words(self, tokens):\\n return {\\\"total_number_of_words\\\": len(tokens)}\",\n \"def word_count(self):\\n return len(self.text)\",\n \"def wordCount(document):\\n return float(len(document.split(None)))\",\n \"def sentence_count(self, doc):\\n\\n return len(sent_tokenize(doc))\",\n \"def _count_tokens(self,\\n token_lists):\\n ## Filter out empty lists\\n fn_tokens = list(filter(lambda i: len(i) > 0, token_lists))\\n ## Get N-grams from Tokens\\n fn_ngrams = list(map(lambda t: self.get_ngrams(t, self._ngrams[0], self._ngrams[1]),\\n fn_tokens))\\n ## Count Tokens (binary if class is unfit and binarization turned on)\\n if hasattr(self, \\\"_class_state\\\") and \\\\\\n self._class_state == \\\"untrained\\\" and \\\\\\n hasattr(self, \\\"_binarize_counter\\\") and \\\\\\n self._binarize_counter:\\n fn_counts = Counter(list(set(flatten(fn_ngrams))))\\n else:\\n fn_counts = Counter(flatten(fn_ngrams))\\n return fn_counts\",\n \"def vocab_size(self) -> int:\\n return len(self._tokenizer)\",\n \"def vocab_size(self) -> int:\\n return len(self._tokenizer)\",\n \"def count_tokens(tokens, filename):\\n wordcounts = Counter(tokens)\\n #print(wordcounts)\\n wordcounts = pd.Series(wordcounts, name=filename)\\n #print(wordcounts.head())\\n return wordcounts\",\n \"def num_tokens_vec(self, indices):\\r\\n raise NotImplementedError\",\n \"def n_unique_words(doc_or_tokens: types.DocOrTokens) -> int:\\n words = utils.get_words(doc_or_tokens)\\n # NOTE: this stdlib solution is slower than itertoolz for docs with ~250+ words\\n # so let's take a small hit on short docs for the sake of big wins on long docs\\n # return len({word.lower for word in words})\\n return itertoolz.count(itertoolz.unique(word.lower for word in words))\",\n \"def getNumTerms(self):\\n\\n return self._numTerms\",\n \"def getTokenSizeOfReviews(self):\\n res = 0\\n with open(self.word_to_docs_path, 'rb') as bin:\\n while bin.tell() != os.fstat(bin.fileno()).st_size:\\n # get wordid:\\n int.from_bytes(bin.read(4), 'big')\\n # get frequency:\\n frequency = int.from_bytes(bin.read(4), 'big')\\n res += frequency\\n # skip documents:\\n int.from_bytes(bin.read(4 * frequency), 'big')\\n return res\",\n \"def count_ngrams(self, corpus):\\n self.unigramcounts = defaultdict(int) # might want to use defaultdict or Counter instead\\n self.bigramcounts = defaultdict(int)\\n self.trigramcounts = defaultdict(int)\\n\\n self.total_word_count = 0\\n self.total_sentence_count = 0\\n\\n # For each sentence, generate ngram_counts\\n for sentence in corpus :\\n # 2 extra START tokens and 1 extra STOP token\\n self.total_word_count += len(sentence) + 3\\n self.total_sentence_count += 1\\n for unigram in get_ngrams(sentence, 1) :\\n self.unigramcounts[unigram] += 1\\n for bigram in get_ngrams(sentence, 2) :\\n self.bigramcounts[bigram] += 1\\n for trigram in get_ngrams(sentence, 3) :\\n self.trigramcounts[trigram] += 1\\n\\n return\",\n \"def token_length(self):\\n return 32\",\n \"def count(self, word):\\n return self.tokens.count(word)\",\n \"def get_num_terms(self, documents=None):\\n terms = []\\n if documents == None:\\n docs = self.vocab\\n else:\\n docs = [term for term in self.vocab if term['name'] in documents]\\n for doc in docs:\\n for term, count in doc['term_counts'].items():\\n terms.append(term)\\n return len(list(set(terms)))\",\n \"def get_number_of_different_tokens(token_list):\\n \\n return len(set(token_list))\",\n \"def get_num_tokens(dt_matrix):\\n\\n\\trows, cols = dt_matrix.get_shape()\\n\\tnum_tokens = 0\\n\\tfor i in range(0, rows):\\n\\t\\tnum_tokens += dt_matrix.getrow(i).sum()\\n\\n\\treturn num_tokens\",\n \"def calculate_vocabulary_size(self, corpus: str):\\n corpus_tokens_less = self._tokenize_less_start_end(corpus)\\n Lap_smooth_suppl = 1\\n num_of_distinct_tokens = len(set(corpus_tokens_less))\\n V = num_of_distinct_tokens + Lap_smooth_suppl\\n return V\",\n \"def num_tokens(self, index):\\r\\n return max(self.src_sizes[index], self.tgt_sizes[index] if self.tgt_sizes is not None else 0)\",\n \"def word_count(self):\\n return self._word_count\",\n \"def get_wordcount_counter(self):\\n corpus_counter = Counter()\\n for current_document in self.documents:\\n document_counter = current_document.get_wordcount_counter()\\n corpus_counter += document_counter\\n return corpus_counter\",\n \"def n_chars_per_word(doc_or_tokens: types.DocOrTokens) -> tuple[int, ...]:\\n words = utils.get_words(doc_or_tokens)\\n return tuple(len(word) for word in words)\",\n \"def get_num_tokens(self, text: str) -> int:\\n # tiktoken NOT supported for Python 3.8 or below\\n if sys.version_info[1] <= 8:\\n return super().get_num_tokens(text)\\n try:\\n import tiktoken\\n except ImportError:\\n raise ValueError(\\n \\\"Could not import tiktoken python package. \\\"\\n \\\"This is needed in order to calculate get_num_tokens. \\\"\\n \\\"Please it install it with `pip install tiktoken`.\\\"\\n )\\n encoder = \\\"gpt2\\\"\\n if self.model_name in (\\\"text-davinci-003\\\", \\\"text-davinci-002\\\"):\\n encoder = \\\"p50k_base\\\"\\n if self.model_name.startswith(\\\"code\\\"):\\n encoder = \\\"p50k_base\\\"\\n # create a GPT-3 encoder instance\\n enc = tiktoken.get_encoding(encoder)\\n\\n # encode the text using the GPT-3 encoder\\n tokenized_text = enc.encode(text)\\n\\n # calculate the number of tokens in the encoded text\\n return len(tokenized_text)\",\n \"def count_ngrams(self, corpus):\\n \\n self.unigramcounts = defaultdict(int)\\n self.bigramcounts = defaultdict(int)\\n self.trigramcounts = defaultdict(int)\\n\\n self.sentence_counts = 0\\n self.word_count = 0\\n\\n for line in corpus:\\n sequence = line\\n self.sentence_counts +=1\\n\\n unigrams = get_ngrams(sequence, n=1)\\n for gram in unigrams:\\n self.word_count += 1\\n self.unigramcounts[gram] +=1\\n\\n bigrams = get_ngrams(sequence, n=2)\\n for gram in bigrams:\\n self.bigramcounts[gram] +=1\\n\\n trigrams = get_ngrams(sequence, n=3)\\n for gram in trigrams:\\n self.trigramcounts[gram] +=1\\n\\n #self.unigramcounts[('START')] = self.sentence_counts *2\\n self.bigramcounts[('START', 'START')] = self.sentence_counts\\n\\n #return self\",\n \"def count_words(sent):\\n words = word_tokenize(sent)\\n return len(words)\",\n \"def corpus_stats(self):\\n print(\\\"Number of sentences: {}\\\".format(len(self.corpus.sents())))\\n print(\\\"Token: {}\\\".format(len(self.corpus.words())))\\n types = FreqDist(self.corpus.words())\\n print(\\\"Types: {}\\\".format(len(types)))\",\n \"def getNumod_byerSentences(self): # !!! Need to rewrite this to match graph\\n return len(self.__document)\",\n \"def n_chars(doc_or_tokens: types.DocOrTokens) -> int:\\n # docs are hashable, so we can leverage the lru cache as-is\\n if isinstance(doc_or_tokens, Doc):\\n ncpw = n_chars_per_word(doc_or_tokens)\\n # otherwise, let's get an iterable of words but cast it to a hashable tuple\\n # so we can leverage the lru cache on this and related calls in, say, n_long_words\\n else:\\n words = utils.get_words(doc_or_tokens)\\n ncpw = n_chars_per_word(tuple(words))\\n return sum(ncpw)\",\n \"def number_types(corpus):\\n number_of_types = len(set(corpus))\\n return number_of_types\",\n \"def number_tokens(dgraph):\\n cnt = 0\\n for node in dgraph.subgraphs(exclude_root=True):\\n node[WORD] = (cnt, node[WORD])\\n cnt += 1\\n return dgraph\",\n \"def total_tokens(self):\\n t = self.tokens.aslist()\\n p = self.passive_tokens()\\n total = [0]*6\\n for i in range(6):\\n total[i] = t[i] + p[i]\\n return total\",\n \"def train(self, corpus):\\n lastToken = \\\"#\\\"\\n for sentence in corpus.corpus:\\n for datum in sentence.data:\\n token = datum.word\\n self.reverseBigramCount[token][lastToken] += 1\\n self.bigramCount[lastToken][token] += 1\\n self.unigramCount[token] += 1\\n self.total += 1\\n lastToken = token\",\n \"def counts(self, regex = \\\"\\\\w+\\\"): \\n tokenizer = RegexpTokenizer(r'{}'.format(regex))\\n count = []\\n for i in tqdm(self.text):\\n count.append(len(tokenizer.tokenize(i)))\\n return count\",\n \"def word_count(self):\\n print(self.words())\\n return len(self.words())\\n #count = 0\\n #for lines in self.lines:\\n # line = lines.strip(os.linesep)\\n # wordslst = line.split()\\n # count += len(wordslst)\\n #return count\\n #joined_string = ''.join(self.lines)\\n #for word in joined_string:\\n # if word != ' ' and word != '\\\\n' and word != '\\\\t':\\n # count += 1\\n #print('READ ME ––––––––––', self.lines)\\n #print(joined_string)\\n #print(line)\\n #print(wordslst)\\n #print(count)\",\n \"def get_count(self):\\n return len(self._tags)\",\n \"def _get_num_words(doc: Doc):\\n filtered_words = [word for word in doc if not word.is_punct and \\\"'\\\" not in word.text and not word.is_space]\\n return len(filtered_words)\",\n \"def count_word(doc):\\n count = count = 0\\n for w in document.split(\\\" \\\"):\\n count = count + 1\\n return count\",\n \"def text_len(self, text):\\n length = len(word_tokenize(text))\\n return length\",\n \"def sent_count(self):\\n count = []\\n for i in tqdm(self.text):\\n count.append(len(sent_tokenize(i)))\\n return count\",\n \"def __len__(self):\\n return len(self._terms)\",\n \"def char_count(self, doc):\\n\\n return len(doc)\",\n \"def word_count(self):\\n from collections import Counter\\n counts = Counter(self._replace_non_alnum().split())\\n return counts\",\n \"def count(text):\\n return len(text)\",\n \"def count_tokens(self, words: Iterable[str]) -> Dict[str, int]:\\r\\n token_counts = Counter(words)\\r\\n return {\\\" \\\".join(token): count for token, count in token_counts.items()}\",\n \"def paragraph_count(self, doc):\\n\\n paragraphs = doc.split(\\\"\\\\n\\\\n\\\")\\n # remove the empty string\\n return len([paragraph for paragraph in paragraphs if paragraph])\",\n \"def get_total_number_of_documents(self):\\n return self.total_number_of_documents\",\n \"def getLength( self, sbjct_token ):\\n if not self.mIsLoaded: self.__loadIndex()\\n return self.mIndex[sbjct_token][2]\",\n \"def vocab_size(self):\\n return len(self.vocab)\",\n \"def count_terms(self, tokens):\\n\\n terms = [self.term_match(t) for t in tokens ]\\n \\n terms = [t for t in terms if t != None]\\n\\n #print terms\\n lf = dict(Counter(terms))\\n for k in lf:\\n lf[k] /= float(len(tokens))\\n #lf[k] = 1 # binarize?\\n pass\\n return lf\",\n \"def number_of_links(corpus, page):\\n return len(corpus[page]) if corpus[page] else len(corpus)\",\n \"def __len__(self: TokenMatcher) -> int:\\n return len(self._patterns)\",\n \"def document_count(self):\\n raise NotImplementedError\",\n \"def computeWordsFrequencies(self):\\n token_stream = self._tokenize(self.readable)\\n token_map = self._countTokens(token_stream)\\n # print token_map.items()\\n return sorted(token_map.items(), key = lambda x : x[1], reverse = True)\",\n \"def count_words(tokenized_sentences):\\r\\n \\r\\n word_counts = {}\\r\\n \\r\\n # Loop through each sentence\\r\\n for sentence in tokenized_sentences: # complete this line\\r\\n \\r\\n for token in sentence: # complete this line\\r\\n\\r\\n # If the token is not in the dictionary yet, set the count to 1\\r\\n if token not in word_counts.keys(): # complete this line\\r\\n word_counts[token] = 1\\r\\n \\r\\n # If the token is already in the dictionary, increment the count by 1\\r\\n else:\\r\\n word_counts[token] += 1\\r\\n \\r\\n return word_counts\",\n \"def vocab_size(self) -> int:\\n return len(self.vocabulary)\",\n \"def wordcount(self):\\n return int(self._fetch_element('user_wordcount'))\",\n \"def count(self):\\n return len(self.read_ints())\",\n \"def _n_matches(gold_tokens, pred_tokens):\\n matcher = difflib.SequenceMatcher(None, gold_tokens, pred_tokens)\\n return sum(match.size for match in matcher.get_matching_blocks())\",\n \"def get_number_of_words_in_document(self, document):\\n for _set in self.sets:\\n if document in _set:\\n return self.sets[_set][document]['number_of_words']\",\n \"def get_count_distinct(corpus):\\n # get the list of all words in the corpus\\n vocab_words = [sentence[idx]\\n for sentence in corpus for idx in range(len(sentence))]\\n # remove duplicates\\n vocab_words = set(vocab_words)\\n\\n return len(vocab_words), sorted(list(vocab_words))\",\n \"def total_words(target_text):\\n\\n splited_text = target_text.split()\\n nbwords = len(splited_text)\\n return nbwords\",\n \"def count(self):\\n return self.__tree.node_count\",\n \"def main ():\\n fio = FileIo(\\\"../input2.txt\\\")\\n text = fio.getInput()\\n p = re.compile(r'#?\\\\d[\\\\s\\\\.]?[\\\\s]?')\\n out = filter(None, p.split(text))\\n #print out[2]\\n #print len(out)\\n wc = 0\\n\\n for s in out:\\n text = nltk.word_tokenize(s)\\n wc += wordCount( text )\\n print wc\",\n \"def getNumberTerms(content): \\n return Counter(getTerms(content))\",\n \"def M(self) -> int:\\n m_tokens = sum(self.values())\\n return m_tokens\",\n \"def train(self, tokens):\\n if len(tokens) == 0: # Empty tokens\\n return pd.Series(dtype=float).astype(float)\\n return pd.Series(tokens).value_counts(normalize=True)\",\n \"def num_articles(self):\\n\\t\\treturn len(index)\",\n \"def __len__(self):\\n if self._words is None:\\n return 0\\n return len(self._words)\",\n \"def get_num_tigers(self) -> int:\\n return len(self.get_all_tiger_positions())\",\n \"def n_sents(doc: Doc) -> int:\\n if not doc.has_annotation(\\\"SENT_START\\\"):\\n LOGGER.warning(\\n \\\"`doc` has not been segmented into sentences; applying spaCy's rule-based, \\\"\\n \\\"`Sentencizer` pipeline component to `doc` before counting...\\\"\\n )\\n doc = _SENTENCIZER(doc)\\n return itertoolz.count(doc.sents)\",\n \"def count_words(self, clean_func=clean_up):\\n return (\\n len(clean_func(self.transcript_file.text()).split())\\n if self.validate()\\n else 0\\n )\",\n \"def count(self, ngram, options):\\n return len(self.find_docs(ngram, options))\",\n \"def doc_count(self):\\n\\t\\treturn self.index.collection.count()\",\n \"def countOccurrences(self, wordsToCheck):\\n count = 0\\n for token in self.importantTokenList():\\n w = token.text\\n for wtc in wordsToCheck:\\n if wtc == w:\\n count = count + 1\\n return count\",\n \"def get_length(self):\\r\\n return len(self.tweets)\",\n \"def n_trees(self):\\n return len(self.data_kd)\",\n \"def __len__(self):\\n return len(self.words)\",\n \"def count(self):\\n # TODO not implemented yet\\n return 0\",\n \"def count(self):\\n\\t\\treturn len(list(self.nodes))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7875352","0.77702785","0.76401025","0.7619481","0.76143175","0.7602757","0.7565467","0.7458757","0.7457123","0.7383079","0.7377764","0.7248463","0.72327363","0.71693045","0.71645564","0.71645564","0.71202064","0.71064943","0.7100568","0.69958025","0.6990903","0.6970787","0.695947","0.69468147","0.69334406","0.69189084","0.68875414","0.68875414","0.680255","0.6802293","0.6703646","0.6701458","0.66898483","0.664272","0.663475","0.66318476","0.6619159","0.65904576","0.65583694","0.65430206","0.6535034","0.65078104","0.64895785","0.64884996","0.64630955","0.6456468","0.6455105","0.64497864","0.64393836","0.6435966","0.6422557","0.64121604","0.639845","0.6394718","0.63854945","0.6381534","0.63789153","0.6377929","0.6375204","0.6345003","0.6344071","0.6332569","0.6319457","0.6318939","0.6306314","0.6293326","0.6291219","0.6290906","0.62783796","0.62762326","0.6258346","0.62343395","0.62326133","0.6229173","0.6228928","0.6224958","0.62140083","0.62066036","0.6194497","0.61910915","0.61896086","0.6189094","0.6186885","0.61741716","0.6149251","0.61482435","0.61477005","0.614416","0.61380875","0.613705","0.6127685","0.6114266","0.6112446","0.61082715","0.6108035","0.6103172","0.6102605","0.60983086","0.60967505","0.6092227","0.60849595"],"string":"[\n \"0.7875352\",\n \"0.77702785\",\n \"0.76401025\",\n \"0.7619481\",\n \"0.76143175\",\n \"0.7602757\",\n \"0.7565467\",\n \"0.7458757\",\n \"0.7457123\",\n \"0.7383079\",\n \"0.7377764\",\n \"0.7248463\",\n \"0.72327363\",\n \"0.71693045\",\n \"0.71645564\",\n \"0.71645564\",\n \"0.71202064\",\n \"0.71064943\",\n \"0.7100568\",\n \"0.69958025\",\n \"0.6990903\",\n \"0.6970787\",\n \"0.695947\",\n \"0.69468147\",\n \"0.69334406\",\n \"0.69189084\",\n \"0.68875414\",\n \"0.68875414\",\n \"0.680255\",\n \"0.6802293\",\n \"0.6703646\",\n \"0.6701458\",\n \"0.66898483\",\n \"0.664272\",\n \"0.663475\",\n \"0.66318476\",\n \"0.6619159\",\n \"0.65904576\",\n \"0.65583694\",\n \"0.65430206\",\n \"0.6535034\",\n \"0.65078104\",\n \"0.64895785\",\n \"0.64884996\",\n \"0.64630955\",\n \"0.6456468\",\n \"0.6455105\",\n \"0.64497864\",\n \"0.64393836\",\n \"0.6435966\",\n \"0.6422557\",\n \"0.64121604\",\n \"0.639845\",\n \"0.6394718\",\n \"0.63854945\",\n \"0.6381534\",\n \"0.63789153\",\n \"0.6377929\",\n \"0.6375204\",\n \"0.6345003\",\n \"0.6344071\",\n \"0.6332569\",\n \"0.6319457\",\n \"0.6318939\",\n \"0.6306314\",\n \"0.6293326\",\n \"0.6291219\",\n \"0.6290906\",\n \"0.62783796\",\n \"0.62762326\",\n \"0.6258346\",\n \"0.62343395\",\n \"0.62326133\",\n \"0.6229173\",\n \"0.6228928\",\n \"0.6224958\",\n \"0.62140083\",\n \"0.62066036\",\n \"0.6194497\",\n \"0.61910915\",\n \"0.61896086\",\n \"0.6189094\",\n \"0.6186885\",\n \"0.61741716\",\n \"0.6149251\",\n \"0.61482435\",\n \"0.61477005\",\n \"0.614416\",\n \"0.61380875\",\n \"0.613705\",\n \"0.6127685\",\n \"0.6114266\",\n \"0.6112446\",\n \"0.61082715\",\n \"0.6108035\",\n \"0.6103172\",\n \"0.6102605\",\n \"0.60983086\",\n \"0.60967505\",\n \"0.6092227\",\n \"0.60849595\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":91795,"cells":{"query":{"kind":"string","value":"Number of types in the corpus."},"document":{"kind":"string","value":"def N(self) -> int:\n return self.params.N"},"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 number_types(corpus):\n number_of_types = len(set(corpus))\n return number_of_types","def corpus_size():\n return ix.doc_count()","def get_types_count():\n return len(type_dict.keys())","def N(self) -> int:\n n_types = len(self)\n return n_types","def corpus_stats(self):\n print(\"Number of sentences: {}\".format(len(self.corpus.sents())))\n print(\"Token: {}\".format(len(self.corpus.words())))\n types = FreqDist(self.corpus.words())\n print(\"Types: {}\".format(len(types)))","def _get_token_cnts(self, doc, doc_type):\n tokenized_doc = self.nlp(doc)\n self.stat_dict[doc_type][0].append(len([s for s in tokenized_doc.sents]))\n doc_len = len([t for t in tokenized_doc])\n self.stat_dict[doc_type][1].append(doc_len)\n if doc_len < 50 and doc_type == \"answer\":\n print(\"Document less than 50 tokens:\", url)","def tag_counts(self, types=[]):\n if not types:\n types = self.tag_types\n for tag_type in types:\n print \"\\t%15s : %-10s\" % (tag_type, len(self.tag_dictionary[tag_type]))","def get_num_docs(self):\n return len(self.vocab)","def count_word_type(doc,word_type):\n count = 0\n for w in document.split(\" \"):\n if w.lower() in word_type:\n count = count + 1\n return count","def get_num_classes(self):","def corpus_length(corpus):\n corpus_len = len(corpus)\n return corpus_len","def num_classes(self):\n raise NotImplementedError","def document_count(self):\n raise NotImplementedError","def n(self):\n return len(self.genotypes)","def number_of_nodes(self, ntype: str = None) -> int:\n return self.num_nodes(ntype)","def getNumTypes(self):\n return int(self._getPointerValue('NTYPES'))","def num_of_classes(self):\n return len(self.classes_())","def num_of_classes(self):\n return len(self.classes_())","def type_count():\n types = []\n for typ in Statistics.all_type():\n types.append({'label': typ.lower(), 'y': Statistics.type_count(typ)})\n fix_types = []\n for i in sorted(types, key=lambda k: k['y']):\n if i['y'] != 0:\n fix_types.append(i)\n return jsonify(result=fix_types)","def getNumTerms(self):\n\n return self._numTerms","def num_classes(self):\n\t\treturn len(self.classes)","def get_number_of_classes(self):\n return len(self.class_dict.keys())","def get_num_terms(self, documents=None):\n terms = []\n if documents == None:\n docs = self.vocab\n else:\n docs = [term for term in self.vocab if term['name'] in documents]\n for doc in docs:\n for term, count in doc['term_counts'].items():\n terms.append(term)\n return len(list(set(terms)))","def n_words(doc_or_tokens: types.DocOrTokens) -> int:\n words = utils.get_words(doc_or_tokens)\n return itertoolz.count(words)","def num_classes(self):\n return len(self.classes)","def Count(self) -> int:","def Count(self) -> int:","def Count(self) -> int:","def Count(self) -> int:","def num_classes(self):\n return self._num_classes","def count_documents(self):\n return self.count_term_distinct_documents(ANY)","def num_classes(self):\n\t\t\treturn len(self.classes)","def __len__(self):\n return len(self._terms)","def count_genres(type_: str, value_=''):\n count = factory.get_elem_count(Genre, type_, value_)\n return count","def __len__(self):\n if self.settype == \"train\":\n return 64000\n else:\n return len(self.list_ids)","def get_doc_count(self, index_name, doc_type):\n return self.es.count(index_name, doc_type)[\"count\"]","def getNumSpeciesTypes(self):\n return _libsbml.Model_getNumSpeciesTypes(self)","def get_num_tokens(self, documents=None):\n tokens = []\n if documents == None:\n docs = self.vocab\n else:\n docs = [term for term in self.vocab if term['name'] in documents]\n for doc in docs:\n for term, count in doc['term_counts'].items():\n tokens.append(count)\n return sum(tokens)","def n_classes(self):\n raise NotImplementedError","def n_classes(self):\n raise NotImplementedError","def count(self):\n\n raise NotImplementedError","def nb_subjects(self) -> int:\n return 0","def __len__(self):\n count = 0\n topics = set(six.iterkeys(self._topics))\n while topics:\n event_type = topics.pop()\n try:\n listeners = self._topics[event_type]\n count += len(listeners)\n except KeyError:\n pass\n return count","def get_number_of_categories() -> List[int]:\n\n return [len(cats) for cats in wiki_data[\"categories\"]]","def get_num_classes(self):\n return len(self.class_map_dict)","def num_classes(self):\n\t\treturn 10","def element_count(self):\r\n result = conf.lib.clang_getNumElements(self)\r\n if result < 0:\r\n raise Exception('Type does not have elements.')\r\n\r\n return result","def n_classes(self):\n raise NotImplementedError()","def count(self):\n # TODO not implemented yet\n return 0","def count_freq(self, types=1):\n count_dict = {}\n if types == 1:\n for cat in self.categories:\n num_images = sum(\n [1 for i in self.data['annotations'] if i['category_id'] == self.cats_idx[cat]])\n count_dict[cat] = num_images\n elif types == 2:\n pass\n\n return count_dict","def num_nodes(self, ntype: str = None) -> int:\n if ntype:\n return self.num_nodes_dict[ntype]\n else:\n return self.total_number_of_nodes","def checkDiffTypes(self):\n count = 0\n for t in self.types:\n if t > 0:\n count = count + 1\n return count","def num_classes():\n return NUM_CLASSES","def subtype_counts(node_set, G, log=False):\n subtypes = Counter()\n for n in node_set:\n subtype = G.node[n]['subtype']\n subtypes[subtype] += 1\n\n if log:\n for k, v in subtypes.items():\n subtypes[k] = np.log10(v)\n \n return subtypes","def count(self, ngram, options):\n return len(self.find_docs(ngram, options))","def count_ngrams(self, corpus):\n \n self.unigramcounts = defaultdict(int)\n self.bigramcounts = defaultdict(int)\n self.trigramcounts = defaultdict(int)\n\n self.sentence_counts = 0\n self.word_count = 0\n\n for line in corpus:\n sequence = line\n self.sentence_counts +=1\n\n unigrams = get_ngrams(sequence, n=1)\n for gram in unigrams:\n self.word_count += 1\n self.unigramcounts[gram] +=1\n\n bigrams = get_ngrams(sequence, n=2)\n for gram in bigrams:\n self.bigramcounts[gram] +=1\n\n trigrams = get_ngrams(sequence, n=3)\n for gram in trigrams:\n self.trigramcounts[gram] +=1\n\n #self.unigramcounts[('START')] = self.sentence_counts *2\n self.bigramcounts[('START', 'START')] = self.sentence_counts\n\n #return self","def single_type_count(clothes_list, type):\n type_count = 0\n for garment in clothes_list:\n if garment.db.clothing_type:\n if garment.db.clothing_type == type:\n type_count += 1\n return type_count","def __len__(self):\n return self.document_count","def size(self):\n return len(self.id2term)","def countObjects(self, classType):\n count = 0\n for dobj in self.doId2do.values():\n if isinstance(dobj, classType):\n count += 1\n return count","def count_types():\n classes = {\"Amenity\": Amenity, \"City\": City,\n \"Place\": Place, \"Review\": Review, \"State\": State, \"User\": User}\n my_dict = {}\n for key in classes.keys():\n if (classes[key] == Amenity):\n my_dict[\"amenities\"] = storage.count(classes[key])\n elif (classes[key] == City):\n my_dict[\"cities\"] = storage.count(classes[key])\n elif (classes[key] == Place):\n my_dict[\"places\"] = storage.count(classes[key])\n elif (classes[key] == Review):\n my_dict[\"reviews\"] = storage.count(classes[key])\n elif (classes[key] == State):\n my_dict[\"states\"] = storage.count(classes[key])\n elif (classes[key] == User):\n my_dict[\"users\"] = storage.count(classes[key])\n return (jsonify(my_dict))","def amount_nouns_and_numerals_stanford_nlp(self) -> int:\n stanza.download(self.lang, processors = 'tokenize,mwt,pos')\n nlp = stanza.Pipeline(self.lang, processors = 'tokenize,mwt,pos')\n doc = nlp(self.sent)\n for sentence in doc.sentences:\n for word in sentence.words:\n #if the part of speech is a noun, a proper noun or a numeral \n #(only for en) \n if self.lang == 'en':\n if word.upos == 'NOUN' or word.upos == 'PROPN' or word.upos == 'NUM':\n self.amount_nouns_and_num += 1\n elif self.lang == 'de' or self.lang == 'fr':\n if word.upos == 'NOUN' or word.upos == 'PROPN':\n self.amount_nouns_and_num += 1\n return self.amount_nouns_and_num","def getNumberTerms(content): \n return Counter(getTerms(content))","def __len__(self) -> int:\n\n length = self.n_classes * 100\n\n return length","def ntypes(self): # -> None:\n ...","def length(self):\n return len(self.wildtype)","def ntypes(self) -> Sequence[str]:\n ntypes = list(self.num_nodes_dict.keys())\n return ntypes","def count_entity_doc(document):\n count = {}\n for line in document[1:]:\n _, _, entity_type, _, _ = conll04_parser.split_line(line)\n if entity_type in count:\n count[entity_type] += 1\n else:\n count[entity_type] = 1\n return count","def count(self):\n return len(self.names)","def wordCount(document):\n return float(len(document.split(None)))","def subtype_occurences(self):\n\n subtype_counts = Counter()\n\n for seqkey,seqs in self.seqs.iteritems():\n for seq,seqentry in seqs.iteritems():\n\n subtype_counts[seqentry['subtype']] += 1\n\n return subtype_counts","def count_ngrams(self, corpus):\n self.unigramcounts = defaultdict(int) # might want to use defaultdict or Counter instead\n self.bigramcounts = defaultdict(int)\n self.trigramcounts = defaultdict(int)\n\n self.total_word_count = 0\n self.total_sentence_count = 0\n\n # For each sentence, generate ngram_counts\n for sentence in corpus :\n # 2 extra START tokens and 1 extra STOP token\n self.total_word_count += len(sentence) + 3\n self.total_sentence_count += 1\n for unigram in get_ngrams(sentence, 1) :\n self.unigramcounts[unigram] += 1\n for bigram in get_ngrams(sentence, 2) :\n self.bigramcounts[bigram] += 1\n for trigram in get_ngrams(sentence, 3) :\n self.trigramcounts[trigram] += 1\n\n return","def count():","def __len__(self):\n if self.TRAIN_BOOL is True:\n count = len(self.dict_batch_1[b'data'])\n count += len(self.dict_batch_2[b'data'])\n count += len(self.dict_batch_3[b'data'])\n count += len(self.dict_batch_4[b'data'])\n count += len(self.dict_batch_5[b'data'])\n else:\n count = len(self.dict_batch_test[b'data'])\n return count","def count(self, cls=None):\n return len(self.all(cls))","def count(self):\n return int()","def count(self):\n return int()","def num_tokens(self, index):\r\n raise NotImplementedError","def count(self):\n\t\treturn len(list(self.nodes))","def num_articles(self):\n\t\treturn len(index)","def count(\n type_signature: computation_types.Type, predicate: _TypePredicate\n) -> int:\n one_or_zero = lambda t: 1 if predicate(t) else 0\n return sum(map(one_or_zero, preorder_types(type_signature)))","def count(self):\n return len(self.read_ints())","def numberOfClasses(self):\n classes = self.classesAndFrames()\n return len(classes.keys())","def get_number_of_synonyms() -> List[int]:\n\n return [len(syns) for syns in wiki_data[\"synonyms\"]]","def get_num_tigers(self) -> int:\n return len(self.get_all_tiger_positions())","def count(self):\n return self.size()","def count_umls(self) -> int:\n return self._count_model(Umls)","def __len__(self):\n return len(self.words)","def num_training_examples(self):","def doc_count(self):\n\t\treturn self.index.collection.count()","def get_corpus_counts(x,y,label):\n raise NotImplementedError","def numnems(self):\n count = 0\n for o in self._objs.values():\n count += len(o.netifs())\n return count","def nf(self): # noqa: D401\n return len(self._freqs)","def get_total_number_of_documents(self):\n return self.total_number_of_documents","def getNumMultiSpeciesTypes(self):\n return _libsbml.MultiModelPlugin_getNumMultiSpeciesTypes(self)","def amount_nouns_and_numerals_spacy(self) -> int:\n #choose language\n if self.lang == 'en':\n lang_for_spacy = 'en_core_web_sm'\n elif self.lang == 'de':\n lang_for_spacy = 'de_core_news_sm'\n elif self.lang == 'fr':\n lang_for_spacy = 'fr_core_news_md'\n nlp = spacy.load(lang_for_spacy)\n doc = nlp(self.sent)\n for word in doc:\n #if the part of speech is a noun, a proper noun or a numeral \n #(only for en) \n if self.lang == 'en':\n if word.pos_ == 'NOUN' or word.pos_ == 'PROPN' or word.pos_ == 'NUM':\n self.amount_nouns_and_num += 1\n elif self.lang == 'de' or self.lang == 'fr':\n if word.pos_ == 'NOUN' or word.pos_ == 'PROPN':\n self.amount_nouns_and_num += 1\n return self.amount_nouns_and_num","def __len__(self) -> int:\n\t\treturn len(self._articles)","def word_count(self):\n return len(self.text)","def get_count(self):\n return len(self._tags)","def num_features(self) -> Dict[NodeType, int]:\n return self.num_node_features","def ntypes(self): # -> list[None]:\n ..."],"string":"[\n \"def number_types(corpus):\\n number_of_types = len(set(corpus))\\n return number_of_types\",\n \"def corpus_size():\\n return ix.doc_count()\",\n \"def get_types_count():\\n return len(type_dict.keys())\",\n \"def N(self) -> int:\\n n_types = len(self)\\n return n_types\",\n \"def corpus_stats(self):\\n print(\\\"Number of sentences: {}\\\".format(len(self.corpus.sents())))\\n print(\\\"Token: {}\\\".format(len(self.corpus.words())))\\n types = FreqDist(self.corpus.words())\\n print(\\\"Types: {}\\\".format(len(types)))\",\n \"def _get_token_cnts(self, doc, doc_type):\\n tokenized_doc = self.nlp(doc)\\n self.stat_dict[doc_type][0].append(len([s for s in tokenized_doc.sents]))\\n doc_len = len([t for t in tokenized_doc])\\n self.stat_dict[doc_type][1].append(doc_len)\\n if doc_len < 50 and doc_type == \\\"answer\\\":\\n print(\\\"Document less than 50 tokens:\\\", url)\",\n \"def tag_counts(self, types=[]):\\n if not types:\\n types = self.tag_types\\n for tag_type in types:\\n print \\\"\\\\t%15s : %-10s\\\" % (tag_type, len(self.tag_dictionary[tag_type]))\",\n \"def get_num_docs(self):\\n return len(self.vocab)\",\n \"def count_word_type(doc,word_type):\\n count = 0\\n for w in document.split(\\\" \\\"):\\n if w.lower() in word_type:\\n count = count + 1\\n return count\",\n \"def get_num_classes(self):\",\n \"def corpus_length(corpus):\\n corpus_len = len(corpus)\\n return corpus_len\",\n \"def num_classes(self):\\n raise NotImplementedError\",\n \"def document_count(self):\\n raise NotImplementedError\",\n \"def n(self):\\n return len(self.genotypes)\",\n \"def number_of_nodes(self, ntype: str = None) -> int:\\n return self.num_nodes(ntype)\",\n \"def getNumTypes(self):\\n return int(self._getPointerValue('NTYPES'))\",\n \"def num_of_classes(self):\\n return len(self.classes_())\",\n \"def num_of_classes(self):\\n return len(self.classes_())\",\n \"def type_count():\\n types = []\\n for typ in Statistics.all_type():\\n types.append({'label': typ.lower(), 'y': Statistics.type_count(typ)})\\n fix_types = []\\n for i in sorted(types, key=lambda k: k['y']):\\n if i['y'] != 0:\\n fix_types.append(i)\\n return jsonify(result=fix_types)\",\n \"def getNumTerms(self):\\n\\n return self._numTerms\",\n \"def num_classes(self):\\n\\t\\treturn len(self.classes)\",\n \"def get_number_of_classes(self):\\n return len(self.class_dict.keys())\",\n \"def get_num_terms(self, documents=None):\\n terms = []\\n if documents == None:\\n docs = self.vocab\\n else:\\n docs = [term for term in self.vocab if term['name'] in documents]\\n for doc in docs:\\n for term, count in doc['term_counts'].items():\\n terms.append(term)\\n return len(list(set(terms)))\",\n \"def n_words(doc_or_tokens: types.DocOrTokens) -> int:\\n words = utils.get_words(doc_or_tokens)\\n return itertoolz.count(words)\",\n \"def num_classes(self):\\n return len(self.classes)\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def num_classes(self):\\n return self._num_classes\",\n \"def count_documents(self):\\n return self.count_term_distinct_documents(ANY)\",\n \"def num_classes(self):\\n\\t\\t\\treturn len(self.classes)\",\n \"def __len__(self):\\n return len(self._terms)\",\n \"def count_genres(type_: str, value_=''):\\n count = factory.get_elem_count(Genre, type_, value_)\\n return count\",\n \"def __len__(self):\\n if self.settype == \\\"train\\\":\\n return 64000\\n else:\\n return len(self.list_ids)\",\n \"def get_doc_count(self, index_name, doc_type):\\n return self.es.count(index_name, doc_type)[\\\"count\\\"]\",\n \"def getNumSpeciesTypes(self):\\n return _libsbml.Model_getNumSpeciesTypes(self)\",\n \"def get_num_tokens(self, documents=None):\\n tokens = []\\n if documents == None:\\n docs = self.vocab\\n else:\\n docs = [term for term in self.vocab if term['name'] in documents]\\n for doc in docs:\\n for term, count in doc['term_counts'].items():\\n tokens.append(count)\\n return sum(tokens)\",\n \"def n_classes(self):\\n raise NotImplementedError\",\n \"def n_classes(self):\\n raise NotImplementedError\",\n \"def count(self):\\n\\n raise NotImplementedError\",\n \"def nb_subjects(self) -> int:\\n return 0\",\n \"def __len__(self):\\n count = 0\\n topics = set(six.iterkeys(self._topics))\\n while topics:\\n event_type = topics.pop()\\n try:\\n listeners = self._topics[event_type]\\n count += len(listeners)\\n except KeyError:\\n pass\\n return count\",\n \"def get_number_of_categories() -> List[int]:\\n\\n return [len(cats) for cats in wiki_data[\\\"categories\\\"]]\",\n \"def get_num_classes(self):\\n return len(self.class_map_dict)\",\n \"def num_classes(self):\\n\\t\\treturn 10\",\n \"def element_count(self):\\r\\n result = conf.lib.clang_getNumElements(self)\\r\\n if result < 0:\\r\\n raise Exception('Type does not have elements.')\\r\\n\\r\\n return result\",\n \"def n_classes(self):\\n raise NotImplementedError()\",\n \"def count(self):\\n # TODO not implemented yet\\n return 0\",\n \"def count_freq(self, types=1):\\n count_dict = {}\\n if types == 1:\\n for cat in self.categories:\\n num_images = sum(\\n [1 for i in self.data['annotations'] if i['category_id'] == self.cats_idx[cat]])\\n count_dict[cat] = num_images\\n elif types == 2:\\n pass\\n\\n return count_dict\",\n \"def num_nodes(self, ntype: str = None) -> int:\\n if ntype:\\n return self.num_nodes_dict[ntype]\\n else:\\n return self.total_number_of_nodes\",\n \"def checkDiffTypes(self):\\n count = 0\\n for t in self.types:\\n if t > 0:\\n count = count + 1\\n return count\",\n \"def num_classes():\\n return NUM_CLASSES\",\n \"def subtype_counts(node_set, G, log=False):\\n subtypes = Counter()\\n for n in node_set:\\n subtype = G.node[n]['subtype']\\n subtypes[subtype] += 1\\n\\n if log:\\n for k, v in subtypes.items():\\n subtypes[k] = np.log10(v)\\n \\n return subtypes\",\n \"def count(self, ngram, options):\\n return len(self.find_docs(ngram, options))\",\n \"def count_ngrams(self, corpus):\\n \\n self.unigramcounts = defaultdict(int)\\n self.bigramcounts = defaultdict(int)\\n self.trigramcounts = defaultdict(int)\\n\\n self.sentence_counts = 0\\n self.word_count = 0\\n\\n for line in corpus:\\n sequence = line\\n self.sentence_counts +=1\\n\\n unigrams = get_ngrams(sequence, n=1)\\n for gram in unigrams:\\n self.word_count += 1\\n self.unigramcounts[gram] +=1\\n\\n bigrams = get_ngrams(sequence, n=2)\\n for gram in bigrams:\\n self.bigramcounts[gram] +=1\\n\\n trigrams = get_ngrams(sequence, n=3)\\n for gram in trigrams:\\n self.trigramcounts[gram] +=1\\n\\n #self.unigramcounts[('START')] = self.sentence_counts *2\\n self.bigramcounts[('START', 'START')] = self.sentence_counts\\n\\n #return self\",\n \"def single_type_count(clothes_list, type):\\n type_count = 0\\n for garment in clothes_list:\\n if garment.db.clothing_type:\\n if garment.db.clothing_type == type:\\n type_count += 1\\n return type_count\",\n \"def __len__(self):\\n return self.document_count\",\n \"def size(self):\\n return len(self.id2term)\",\n \"def countObjects(self, classType):\\n count = 0\\n for dobj in self.doId2do.values():\\n if isinstance(dobj, classType):\\n count += 1\\n return count\",\n \"def count_types():\\n classes = {\\\"Amenity\\\": Amenity, \\\"City\\\": City,\\n \\\"Place\\\": Place, \\\"Review\\\": Review, \\\"State\\\": State, \\\"User\\\": User}\\n my_dict = {}\\n for key in classes.keys():\\n if (classes[key] == Amenity):\\n my_dict[\\\"amenities\\\"] = storage.count(classes[key])\\n elif (classes[key] == City):\\n my_dict[\\\"cities\\\"] = storage.count(classes[key])\\n elif (classes[key] == Place):\\n my_dict[\\\"places\\\"] = storage.count(classes[key])\\n elif (classes[key] == Review):\\n my_dict[\\\"reviews\\\"] = storage.count(classes[key])\\n elif (classes[key] == State):\\n my_dict[\\\"states\\\"] = storage.count(classes[key])\\n elif (classes[key] == User):\\n my_dict[\\\"users\\\"] = storage.count(classes[key])\\n return (jsonify(my_dict))\",\n \"def amount_nouns_and_numerals_stanford_nlp(self) -> int:\\n stanza.download(self.lang, processors = 'tokenize,mwt,pos')\\n nlp = stanza.Pipeline(self.lang, processors = 'tokenize,mwt,pos')\\n doc = nlp(self.sent)\\n for sentence in doc.sentences:\\n for word in sentence.words:\\n #if the part of speech is a noun, a proper noun or a numeral \\n #(only for en) \\n if self.lang == 'en':\\n if word.upos == 'NOUN' or word.upos == 'PROPN' or word.upos == 'NUM':\\n self.amount_nouns_and_num += 1\\n elif self.lang == 'de' or self.lang == 'fr':\\n if word.upos == 'NOUN' or word.upos == 'PROPN':\\n self.amount_nouns_and_num += 1\\n return self.amount_nouns_and_num\",\n \"def getNumberTerms(content): \\n return Counter(getTerms(content))\",\n \"def __len__(self) -> int:\\n\\n length = self.n_classes * 100\\n\\n return length\",\n \"def ntypes(self): # -> None:\\n ...\",\n \"def length(self):\\n return len(self.wildtype)\",\n \"def ntypes(self) -> Sequence[str]:\\n ntypes = list(self.num_nodes_dict.keys())\\n return ntypes\",\n \"def count_entity_doc(document):\\n count = {}\\n for line in document[1:]:\\n _, _, entity_type, _, _ = conll04_parser.split_line(line)\\n if entity_type in count:\\n count[entity_type] += 1\\n else:\\n count[entity_type] = 1\\n return count\",\n \"def count(self):\\n return len(self.names)\",\n \"def wordCount(document):\\n return float(len(document.split(None)))\",\n \"def subtype_occurences(self):\\n\\n subtype_counts = Counter()\\n\\n for seqkey,seqs in self.seqs.iteritems():\\n for seq,seqentry in seqs.iteritems():\\n\\n subtype_counts[seqentry['subtype']] += 1\\n\\n return subtype_counts\",\n \"def count_ngrams(self, corpus):\\n self.unigramcounts = defaultdict(int) # might want to use defaultdict or Counter instead\\n self.bigramcounts = defaultdict(int)\\n self.trigramcounts = defaultdict(int)\\n\\n self.total_word_count = 0\\n self.total_sentence_count = 0\\n\\n # For each sentence, generate ngram_counts\\n for sentence in corpus :\\n # 2 extra START tokens and 1 extra STOP token\\n self.total_word_count += len(sentence) + 3\\n self.total_sentence_count += 1\\n for unigram in get_ngrams(sentence, 1) :\\n self.unigramcounts[unigram] += 1\\n for bigram in get_ngrams(sentence, 2) :\\n self.bigramcounts[bigram] += 1\\n for trigram in get_ngrams(sentence, 3) :\\n self.trigramcounts[trigram] += 1\\n\\n return\",\n \"def count():\",\n \"def __len__(self):\\n if self.TRAIN_BOOL is True:\\n count = len(self.dict_batch_1[b'data'])\\n count += len(self.dict_batch_2[b'data'])\\n count += len(self.dict_batch_3[b'data'])\\n count += len(self.dict_batch_4[b'data'])\\n count += len(self.dict_batch_5[b'data'])\\n else:\\n count = len(self.dict_batch_test[b'data'])\\n return count\",\n \"def count(self, cls=None):\\n return len(self.all(cls))\",\n \"def count(self):\\n return int()\",\n \"def count(self):\\n return int()\",\n \"def num_tokens(self, index):\\r\\n raise NotImplementedError\",\n \"def count(self):\\n\\t\\treturn len(list(self.nodes))\",\n \"def num_articles(self):\\n\\t\\treturn len(index)\",\n \"def count(\\n type_signature: computation_types.Type, predicate: _TypePredicate\\n) -> int:\\n one_or_zero = lambda t: 1 if predicate(t) else 0\\n return sum(map(one_or_zero, preorder_types(type_signature)))\",\n \"def count(self):\\n return len(self.read_ints())\",\n \"def numberOfClasses(self):\\n classes = self.classesAndFrames()\\n return len(classes.keys())\",\n \"def get_number_of_synonyms() -> List[int]:\\n\\n return [len(syns) for syns in wiki_data[\\\"synonyms\\\"]]\",\n \"def get_num_tigers(self) -> int:\\n return len(self.get_all_tiger_positions())\",\n \"def count(self):\\n return self.size()\",\n \"def count_umls(self) -> int:\\n return self._count_model(Umls)\",\n \"def __len__(self):\\n return len(self.words)\",\n \"def num_training_examples(self):\",\n \"def doc_count(self):\\n\\t\\treturn self.index.collection.count()\",\n \"def get_corpus_counts(x,y,label):\\n raise NotImplementedError\",\n \"def numnems(self):\\n count = 0\\n for o in self._objs.values():\\n count += len(o.netifs())\\n return count\",\n \"def nf(self): # noqa: D401\\n return len(self._freqs)\",\n \"def get_total_number_of_documents(self):\\n return self.total_number_of_documents\",\n \"def getNumMultiSpeciesTypes(self):\\n return _libsbml.MultiModelPlugin_getNumMultiSpeciesTypes(self)\",\n \"def amount_nouns_and_numerals_spacy(self) -> int:\\n #choose language\\n if self.lang == 'en':\\n lang_for_spacy = 'en_core_web_sm'\\n elif self.lang == 'de':\\n lang_for_spacy = 'de_core_news_sm'\\n elif self.lang == 'fr':\\n lang_for_spacy = 'fr_core_news_md'\\n nlp = spacy.load(lang_for_spacy)\\n doc = nlp(self.sent)\\n for word in doc:\\n #if the part of speech is a noun, a proper noun or a numeral \\n #(only for en) \\n if self.lang == 'en':\\n if word.pos_ == 'NOUN' or word.pos_ == 'PROPN' or word.pos_ == 'NUM':\\n self.amount_nouns_and_num += 1\\n elif self.lang == 'de' or self.lang == 'fr':\\n if word.pos_ == 'NOUN' or word.pos_ == 'PROPN':\\n self.amount_nouns_and_num += 1\\n return self.amount_nouns_and_num\",\n \"def __len__(self) -> int:\\n\\t\\treturn len(self._articles)\",\n \"def word_count(self):\\n return len(self.text)\",\n \"def get_count(self):\\n return len(self._tags)\",\n \"def num_features(self) -> Dict[NodeType, int]:\\n return self.num_node_features\",\n \"def ntypes(self): # -> list[None]:\\n ...\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8609336","0.7424365","0.71177125","0.7103952","0.6927904","0.6823176","0.67337644","0.66178495","0.6582548","0.6564052","0.65231293","0.6488155","0.6470049","0.64693904","0.6457007","0.642448","0.6352565","0.6352565","0.633555","0.6325916","0.62688774","0.6261735","0.62500316","0.62447083","0.6235719","0.6230101","0.6230101","0.6230101","0.6230101","0.6201548","0.6199683","0.6182675","0.6172587","0.6165757","0.6149969","0.6148435","0.61373705","0.6129489","0.61152935","0.61152935","0.6103731","0.6094985","0.60947675","0.60884494","0.60732704","0.60718447","0.60692567","0.60594434","0.6058979","0.6048263","0.60352176","0.6034886","0.6025383","0.60230523","0.60225254","0.602032","0.6016146","0.60158134","0.5998786","0.59922254","0.5990749","0.59905905","0.5988996","0.59713334","0.5965953","0.59648013","0.59564716","0.59557164","0.5942794","0.5940938","0.5932453","0.5928422","0.5924394","0.59233403","0.5921077","0.5920054","0.5920054","0.59105116","0.5902535","0.5901028","0.58968145","0.5868881","0.58655477","0.5863254","0.5855391","0.58366966","0.58298475","0.58251256","0.5824548","0.58238596","0.58191276","0.5811203","0.5809596","0.5808539","0.5804488","0.5803325","0.5801795","0.5793704","0.578721","0.57659453","0.5759371"],"string":"[\n \"0.8609336\",\n \"0.7424365\",\n \"0.71177125\",\n \"0.7103952\",\n \"0.6927904\",\n \"0.6823176\",\n \"0.67337644\",\n \"0.66178495\",\n \"0.6582548\",\n \"0.6564052\",\n \"0.65231293\",\n \"0.6488155\",\n \"0.6470049\",\n \"0.64693904\",\n \"0.6457007\",\n \"0.642448\",\n \"0.6352565\",\n \"0.6352565\",\n \"0.633555\",\n \"0.6325916\",\n \"0.62688774\",\n \"0.6261735\",\n \"0.62500316\",\n \"0.62447083\",\n \"0.6235719\",\n \"0.6230101\",\n \"0.6230101\",\n \"0.6230101\",\n \"0.6230101\",\n \"0.6201548\",\n \"0.6199683\",\n \"0.6182675\",\n \"0.6172587\",\n \"0.6165757\",\n \"0.6149969\",\n \"0.6148435\",\n \"0.61373705\",\n \"0.6129489\",\n \"0.61152935\",\n \"0.61152935\",\n \"0.6103731\",\n \"0.6094985\",\n \"0.60947675\",\n \"0.60884494\",\n \"0.60732704\",\n \"0.60718447\",\n \"0.60692567\",\n \"0.60594434\",\n \"0.6058979\",\n \"0.6048263\",\n \"0.60352176\",\n \"0.6034886\",\n \"0.6025383\",\n \"0.60230523\",\n \"0.60225254\",\n \"0.602032\",\n \"0.6016146\",\n \"0.60158134\",\n \"0.5998786\",\n \"0.59922254\",\n \"0.5990749\",\n \"0.59905905\",\n \"0.5988996\",\n \"0.59713334\",\n \"0.5965953\",\n \"0.59648013\",\n \"0.59564716\",\n \"0.59557164\",\n \"0.5942794\",\n \"0.5940938\",\n \"0.5932453\",\n \"0.5928422\",\n \"0.5924394\",\n \"0.59233403\",\n \"0.5921077\",\n \"0.5920054\",\n \"0.5920054\",\n \"0.59105116\",\n \"0.5902535\",\n \"0.5901028\",\n \"0.58968145\",\n \"0.5868881\",\n \"0.58655477\",\n \"0.5863254\",\n \"0.5855391\",\n \"0.58366966\",\n \"0.58298475\",\n \"0.58251256\",\n \"0.5824548\",\n \"0.58238596\",\n \"0.58191276\",\n \"0.5811203\",\n \"0.5809596\",\n \"0.5808539\",\n \"0.5804488\",\n \"0.5803325\",\n \"0.5801795\",\n \"0.5793704\",\n \"0.578721\",\n \"0.57659453\",\n \"0.5759371\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":91796,"cells":{"query":{"kind":"string","value":"The discrete powerlaw distribution parameter."},"document":{"kind":"string","value":"def gamma(self) -> int:\n return self.params.gamma"},"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 p(self) -> float:\n return self._pwr.real","def simulate_power(self):\n if self.p_treatment - self.p_control < 0:\n thresh = 1 - self.alpha\n else:\n thresh = self.alpha\n\n try:\n p_crit = self.norm_null.ppf(1 - thresh)\n beta = self.norm_alt.cdf(p_crit)\n except:\n self.norm_distribution()\n p_crit = self.norm_null.ppf(1 - thresh)\n beta = self.norm_alt.cdf(p_crit)\n\n power = (1 - beta) if self.p_treatment > self.p_control else beta\n self.power = power\n\n return power","def prob_distr(self, x):\n return 1.0/x","def get_power(self):\r\n return self.p","def stdProbabilityNorm(self):\n return 1./factorial(self.alpha-1)","def plot_powerlaw(self, **kwargs):\n\n if self.gamma is None:\n self.exponent()\n p = powerlaw.plot(exponent=-self.gamma,\n xmax=self.max_deg, xmin=self.k_min,\n **kwargs\n )\n pylab.show()\n return p","def get_coeff(self):\n return bernoulli(self.degree+1) / factorial(self.degree + 1)","def get_power(self) -> float:\n\n #:READ[n][:CHANnel[m]][:SCALar]: POWer[:DC]?\n return float(self._inst.query(\":READ:POW?\"))","def q(self) -> float:\n return self._pwr.imag","def powerMultiplier(self):\n return self.symmetry.symmetryFactor()","def getDensityLaw(self):\n return self.densityLaw","def pdf(self,x):\n return self.categoricalDist.pdf(x)","def weighted_log_density(self):\n return self.rho*math.log(self.density)","def pdf(self, x, log = False):\n if log:\n return D.logsumexp(\n D.multiple_gauss_den(x, self.mu, self.va, log = True)\n + N.log(self.w))\n else:\n return N.sum(D.multiple_gauss_den(x, self.mu, self.va) * self.w, 1)","def __density(self, x):\n\n z = np.power(self.rate, x) / m.factorial(x)\n return z * np.exp(-self.rate)","def setPowerFromDensity(self):\n self.p.power = self.p.powerDensity * self.getHMMass()","def get_double_power_law(self, alpha, beta, M_star):\n\t\tdenom = 10.0**(0.4*(alpha + 1.0)*(self.M_grid - M_star))\n\t\tdenom += 10.0**(0.4*(beta + 1.0)*(self.M_grid - M_star))\n\t\tdn = 1.0/denom\n\t\tdn /= np.sum(dn)\n\t\treturn dn","def _perplexity(self, X, log_w):\n return np.exp(-log_w/X.sum())","def W(self):\n if not self.isVaild():\n pass\n return self.Wq() + 1.0/self.muy","def noise(self):\n # Extract parameters\n pzs = self.params[0]\n ngals = np.array([pz.gals_per_steradian for pz in pzs])\n return 1.0 / ngals","def density(temp,pres):\n g_p = liq_g(0,1,temp,pres)\n dliq = g_p**(-1)\n return dliq","def compute_Gamma_wdm(self):\n GN = 0.71611\n kT = const.kB*self.T_cmb\n og = self.Omega_gamma\n den = np.pi**4./15.*kT/(GN**3*og*1.5*ss.zeta(3))/self.h**2.\n return GN*(self.Omega_wdm*self.h**2.*den/self.M_wdm)**(1./3.)","def dsdlogdp(self):\n return self.dndlogdp.mul(self.s_multiplier)","def gc_prob_density(r):\n return np.exp(_interp_ln_dens(r))","def Wp(self):\n from scipy.integrate import quad\n Eth = 1.22e-3\n\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n Wp = quad(lambda x: x * self._particle_distribution(x), Eth, np.Inf)[0]\n\n return (Wp * u.TeV).to('erg')","def propagation_constant(self,freq):\n sigma = self.conductivity\n w = 2*np.pi*freq\n gamma = w*1j*cmath.sqrt(self.mu*self.epsilon)*cmath.sqrt(1-1j*sigma/(w*self.epsilon))\n return gamma","def dvdlogdp(self):\n return self.dndlogdp.mul(self.v_multiplier)","def get_distribution_parameters(self):\r\n return \"UNDEFINED\"","def get_powerperband(self, bandwidth):\n ls = self.get_degrees()\n return self._powerperdegree() * ls * np.log(bandwidth)","def test_power(self):\r\n a = 6 # shape\r\n samples = 5000\r\n max = -0.06\r\n min = -3.3\r\n s = np.random.power(a, samples) * -1 * (min - max) + min\r\n plt.hist(s, bins=30, density=False)\r\n plt.xlabel('Interlayer point energy [eV]')\r\n plt.ylabel('Frequency')\r\n plt.show()","def dB(x, power=True):\r\n if not power:\r\n return 20 * np.log10(np.abs(x))\r\n return 10 * np.log10(np.abs(x))","def bandwidth(d):\n gz = 2 * gamma(0.5 * (d+1)) / gamma(0.5 * d)\n return 1. / (2. * gz**2)","def prob(self, w):\n return self.counts[w] / self.total_count","def logpowerlaw(x, p=default()):\n xtr, ytr, gradtr = logcontinuity(p)\n power = p[3]\n x0 = xtr - power/gradtr\n b = ytr - power*np.log(xtr-x0)\n return b + power*np.log(x-x0)","def Wp(self):\n Wp = trapz_loglog(self._Ep * self._J, self._Ep) * u.GeV\n return Wp.to('erg')","def pdf(self, x):\n\t\treturn 1.5 * np.power(x,2) ##obtained after finding z from integrating x^2 from -1 to 1","def get_uniform_p_vals(self, min=1.5, max=9):\n rng = np.random.RandomState(12435)\n if self.power_activ == \"softplus\":\n p_vals = np.log(np.exp(rng.uniform(low=min, high=max, size=(self.num_units,))-1)-1)\n else:\n p_vals = np.sqrt(rng.uniform(low=min, high=max, size=(self.num_units,))-1)\n return p_vals","def dPdlogM_internal(self, mass):\n return self.gamma*mass**self.gamma/(self.mmax**self.gamma-self.mmin**self.gamma)","def pwm_freq(self):\r\n return self._pwm_freq","def dB(x, power=False):\n if power:\n return 10 * np.log10(np.abs(x))\n else:\n return 20 * np.log10(np.abs(x))","def distribution(self) -> str:\n return pulumi.get(self, \"distribution\")","def noise(self):\n # Extract parameters\n pzs = self.params[0]\n # retrieve number of galaxies in each bins\n ngals = np.array([pz.gals_per_steradian for pz in pzs])\n if isinstance(self.config[\"sigma_e\"], list):\n sigma_e = np.array([s for s in self.config[\"sigma_e\"]])\n else:\n sigma_e = self.config[\"sigma_e\"]\n return sigma_e ** 2 / ngals","def gamma(self):\n if self._gamma is None:\n df = self.kdf\n gamma_ = -self._powerlaw(df.index, df.freq)\n self._gamma = gamma_\n\n # return\n return self._gamma","def dble_pwr_law(time_bins, tau, alpha, beta, factor=1):\n return factor/((time_bins/tau)**alpha + (time_bins/tau)**(-beta))","def specular_power(self) -> float:\n return self.GetSpecularPower()","def s(self) -> NumType:\n return abs(self._pwr)","def power(self):\n return self._power","def factor(self):\n return np.real_if_close(self.scale * np.exp(1j*self.phase))","def log_prob(self):","def distribution(self):\n \n #external_distribution serves both the purpose of external setting of distribution and the caching of distribution()\n if self.external_distribution:\n return self.external_distribution_array;\n else:\n energy_vector = []\n superset = self.generate_superset(0) \n \n for i in superset:\n state = self.ket(i)\n \n norm_squared = np.dot(state.T, state)\n \n if norm_squared > 0: #zero is appended at the end\n energy = np.dot(state.T, np.dot( self.epsilon, state))\n interaction = np.dot(state.T, np.dot( self.u, state))/2.0 #divide by two. Otherwise, <l r| U |l r > = U_LR + U_RL = 2U\n #print state, np.dot(self.u, state) \n #print interaction\n energy_vector.append( energy + interaction )\n \n energy_vector.insert(0, 0.0) \n probability = np.exp( np.multiply(-self.beta, energy_vector)) \n probability /= probability.sum() \n return probability","def __pow__(self,power):\n return Factor().__build( VarSet(self.v) , np.power(self.t,power) )","def p(self):\n return numpy.exp(self.log_p)","def dlogdp(self):\n return np.log10(self.bins[:, -1]) - np.log10(self.bins[:, 0])","def density( self ) :\n return self.__density","def density( self ) :\n return self.__density","def density( self ) :\n return self.__density","def conditionalDistribution(self, d, m, w):\r\n probabilities_ts = np.ones((self.numTopics, self.numSentiments))\r\n\r\n # firstfactor 수정\r\n firstFactor = (self.n_wkl[w, :, :] + self.beta) / \\\r\n (self.n_kl + self.n_wkl.shape[0] * self.beta) # dim(K x L)\r\n\r\n secondFactor = (self.ns_dk[d, :] + self.alpha) / \\\r\n (self.ns_d[d] + self.numTopics * self.alpha) # dim(K x 1)\r\n\r\n thirdFactor = (self.ns_dkl[d, :, :] + self.gamma) / \\\r\n (self.ns_dk[d] + self.numSentiments * self.gamma)[:, np.newaxis] # dim (K x L)\r\n\r\n probabilities_ts *= firstFactor * thirdFactor\r\n probabilities_ts *= secondFactor[:, np.newaxis]\r\n probabilities_ts /= np.sum(probabilities_ts)\r\n return probabilities_ts","def initializeDistribution(self):\n if self.nPoints is None:\n self.xArray = np.arange(self.lowerBound,self.upperBound+1)\n else:\n self.xArray = np.linspace(self.lowerBound,self.upperBound,self.nPoints)\n\n # Here the actual calculation of discrete distribution parameters is performed\n self.pdfArray = 1.0/self.xArray.size * np.ones(self.xArray.size)\n paramsDict={}\n paramsDict['outcome'] = self.xArray\n paramsDict['state'] = self.pdfArray\n\n self.categoricalDist = Categorical()\n self.categoricalDist.initializeFromDict(paramsDict)\n initialPerm = randomUtils.randomPermutation(self.xArray.tolist(),self)\n self.pot = np.asarray(initialPerm)","def _powerperdegree(self):\n return SHPowerSpectrum(self.coeffs)","def stdProbabilityNorm(self):\n B = factorial(self.alpha-1)*factorial(self.beta-1)/factorial(self.alpha+self.beta-1)\n norm = 1.0/(2**(self.alpha+self.beta-1)*B)\n return norm","def Mo96(self,dc,nu):\n return 1. + (nu**2.-1.)/dc","def stdProbabilityNorm(self):\n return 0.5","def lnprobability(self):\n return","def number_density(self) -> u.m**-3:\n return self._number_density","def probability_array(self):\n q = self.apply_weights()\n return np.exp(q)/(1 + np.exp(q))","def log_distr_fdmw(self, dnu, logflux, dme, logw, alpha, logls, logl0, mu, sigma, gtype=None):\n #stepdms = 100/1000.\n #vdms = np.arange(0, 100, stepdm)\n stepz = (np.log(self.Zmax) - np.log(self.Zmin)) / 1000\n vz = np.exp(np.arange(np.log(self.Zmin), np.log(self.Zmax), stepz))\n lik = 0\n for z in vz:\n likv = np.exp(self.log_distr_fdmwz(dnu, logflux, dme, logw, z, alpha, logls, logl0, mu, sigma, gtype=gtype))\n lik += z * stepz * likv\n ind = lik > 0\n ind2 = lik <= 0\n loglik = lik.copy()\n loglik[ind] = np.log(lik[ind])\n loglik[ind2] = np.ones(loglik[ind2].shape) * -1e99\n return loglik","def _normal_log_prob(self, r, scale_log):\n return -(r**2) / 2 - scale_log - self.const","def log_prior_wilson_coeffs(self, x):\n if self.fit_wc_priors is None:\n return 0\n wc_dict = self.array_to_dict(x)['fit_wc']\n prob_dict = self.fit_wc_priors.get_logprobability_all(wc_dict)\n return sum([p for obj, p in prob_dict.items()])","def dloglam(self):\n # This number was determined using the resolution and sampling quoted on the FIRE website\n R = 6000.0 * 2.7\n dloglam = 1.0 / R / np.log(10.0)\n return dloglam","def set_power(self, dbm=-30):\r\n self.p = dbm","def waveparameterh(L):\r\n return 8.13 - ((250 - 0.7 * L) / 125) ** 3","def get_scale_parameter(self):\r\n \r\n if self.scale_parameter == 0.0: \r\n shape_in_gamma_func = float(1+(1/self.shape_parameter))\r\n gamma_func = special.gamma(shape_in_gamma_func)\r\n self.scale_parameter = (self.mean_fire_recurrence/gamma_func)\r\n return self.scale_parameter\r\n else:\r\n return self.scale_parameter","def _powerperdegree(self):\n return SHCPowerSpectrum(self.coeffs)","def get_dist_probability(self):\n return self.dist_probability","def scale_parameter(self):\n return self._scale_parameter","def massrich_parameters(self):\n print(\"\\nMass-Richness Power Law: M200 = norm * (N200 / 20) ^ slope\")\n print(\" norm:\", self._massrich_norm)\n print(\" slope:\", self._massrich_slope)","def scale(self):\n return self.distribution.scale","def max_power(self):\r\n est_max_power = self.model * self.max_pwm / 100\r\n return est_max_power","def d_dweight(self, ):\n return self.gen_df_dw(self.params, self.output_shape)(self.current_input)","def density(self, x):\n\t\tN = len(self.train_data)\n\t\tpoints = list(self.train_data)\n\t\tdists = [np.linalg.norm(x-point)**2 for point in points]\n\t\texps = [np.exp(-dist / (2 * (self.bandwidth ** 2))) for dist in dists]\n\t\tunnormalized_sum = sum(exps)\n\t\tprobability = (1 / N) * self.normalizing_constant() * unnormalized_sum\n\t\treturn probability","def density(self, arg):\n return self.gb2_density(np.exp(arg)) * np.exp(arg)","def get_discrete_distribution():\n random_int = random.randint(1, 4)\n if (random_int == 1) | (random_int == 2):\n return 0\n if random_int == 3:\n return 3\n if random_int == 4:\n return 5\n raise ValueError(\"Unable to generate discrete distribution with \", random_int)","def p(self):\n return hlp.parms(self.y(0))","def get_scale_parameter(self):\n\n if self.scale_parameter == 0.0:\n shape_in_gamma_func = float(1+(1/self.shape_parameter))\n gamma_func = special.gamma(shape_in_gamma_func)\n self.scale_parameter = (self.mean_fire_recurrence/gamma_func)\n return self.scale_parameter\n else:\n return self.scale_parameter","def den(self):\n return self.den","def ppd(self):\n return math.sqrt(np.dot(self.v, self.v) / np.dot(self.w, self.w) )","def __pow__(self, n):\n\t\tvalues = map(lambda x: x >= 0, self.val)\n\t\tif isinstance(n, float) or isinstance(n, int):\n\t\t\tif n % 1 != 0 and not all(values):\n\t\t\t\traise ValueError(\"Non-positive number raised to a fraction encountered in pow.\")\n\t\t\telif n < 1 and 0 in self.val:\n\t\t\t\traise ZeroDivisionError(\"Cannot compute derivative of 0^y for y < 1.\")\n\t\t\n\t\t\tval = np.power(self.val, n)\n\t\t\tif len(self.der.shape):\n\t\t\t\tself_val = np.expand_dims(self.val, 1) if len(self.der.shape) > len(self.val.shape) else self.val\n\t\t\t\tder = n * np.multiply((self_val ** (n - 1)), self.der)\n\t\t\telse:\n\t\t\t\tder = None\n\n\t\t\treturn Var(val, der)\n\n\t\t# n is a Var\n\t\telse:\n\t\t\tfor n_i in n.val:\n\t\t\t\tif n_i % 1 != 0 and not all(values):\n\t\t\t\t\traise ValueError(\"Non-positive number raised to a fraction encountered in pow.\")\n\t\t\t\telif n_i < 1 and 0 in self.val:\t\t\t\t\t\n\t\t\t\t\traise ZeroDivisionError(\"Cannot compute derivative of 0^y for y < 1.\")\n\n\t\t\tval = np.power(self.val, n.val)\n\t\t\t# Check for constant Vars of scalars or vectors\n\t\t\tif len(n.der.shape) == 0 and len(self.der.shape):\n\t\t\t\tder = None\n\t\t\telif len(self.der.shape) == 0 and len(n.der.shape):\n\t\t\t\tder = None\n\t\t\telif len(self.der.shape) == 0 and len(n.der.shape) == 0:\n\t\t\t\tder = None\n\t\t\telse:\n\t\t\t\t# Both self and n are Vars of valid variable(s), not constants\n\t\t\t\tif len(self.val) > 1 and len(n.val) > 1 and len(self.val) != len(n.val):\n\t\t\t\t\traise ValueError(\"x and y cannot be of different dimensions > 1 in x^y.\")\n\t\t\t\telse:\n\t\t\t\t\tder = val * ((n.val / self.val) * self.der + np.log(self.val) * n.der)\n\t\t\treturn Var(val, der)","def power(self):\r\n return self.model * self.percent / 100","def log_pdf(self, x):\n if x < 0:\n raise Exception(\"input value x can't be a negative value!\")\n\n if self.is_fit:\n if x >= 0:\n return -np.log(np.math.factorial(x)) + \\\n x * np.log(self.alpha) - self.alpha\n else:\n return 0\n else:\n raise Exception(\"Distribution doesn't have all parameters set!\")","def pdf(self, x):\n if x < 0:\n raise Exception(\"input value x can't be a negative value!\")\n\n if self.is_fit:\n if x >= 0:\n enu = np.power(self.alpha, x) * np.power(np.e, -self.alpha)\n den = np.math.factorial(x)\n return enu / den\n else:\n return 0\n else:\n raise Exception(\"Distribution doesn't have all parameters set!\")","def density(self):\n return self.get_density()","def draw_powerlaw(alpha, rng, N=1):\n if alpha == -1:\n alpha = -1.0000001\n # Normalization factor\n x0, x1 = rng\n C = (alpha + 1) / (x1**(alpha + 1) - x0**(alpha + 1))\n \n if N==1:\n u = np.random.random()\n else:\n u = np.random.random(N)\n x = ((u * (alpha + 1)) / C + x0**(alpha + 1))**(1./(alpha + 1))\n\n return x","def dc(self):\n return np.array(self['dc'], dtype=np.float32) / 1000","def var(self):\n\n return self.scale ** -2 \\\n * (m.gamma(1 + 2 * self.shape ** -1) - m.gamma(1 + self.shape ** -1) ** 2)","def get_scale_parameter(self):\n\n shape_in_gamma_func = float(1 + (1 / self._shape_parameter))\n gamma_func = special.gamma(shape_in_gamma_func)\n self._scale_parameter = self._mean_fire_recurrence / gamma_func","def distmod(self):\n val = 5. * np.log10(self.to(u.pc).value) - 5.\n return u.Quantity(val, u.mag)","def density(self):\n return self._density","def pertube_distribution_weight(self, random_state, n_samples, multipler):\n curr_sample_weight = np.ones((n_samples,), dtype=np.float64)\n indices = _generate_sample_indices(random_state, n_samples)\n sample_counts = bincount(indices, minlength=n_samples)\n curr_sample_weight *= np.power(sample_counts, multipler)\n return curr_sample_weight","def intensity(self):\r\n return np.power(prb.amplitude, 2)","def b_Kjeldsen2008(self):\n return 10.0**(-3.16*self.string_to_param(\"log_Teff\") + 0.184*self.string_to_param(\"log_g\")+11.7)","def amplitude(self):\r\n return np.sqrt(self.maxint) * self.weights"],"string":"[\n \"def p(self) -> float:\\n return self._pwr.real\",\n \"def simulate_power(self):\\n if self.p_treatment - self.p_control < 0:\\n thresh = 1 - self.alpha\\n else:\\n thresh = self.alpha\\n\\n try:\\n p_crit = self.norm_null.ppf(1 - thresh)\\n beta = self.norm_alt.cdf(p_crit)\\n except:\\n self.norm_distribution()\\n p_crit = self.norm_null.ppf(1 - thresh)\\n beta = self.norm_alt.cdf(p_crit)\\n\\n power = (1 - beta) if self.p_treatment > self.p_control else beta\\n self.power = power\\n\\n return power\",\n \"def prob_distr(self, x):\\n return 1.0/x\",\n \"def get_power(self):\\r\\n return self.p\",\n \"def stdProbabilityNorm(self):\\n return 1./factorial(self.alpha-1)\",\n \"def plot_powerlaw(self, **kwargs):\\n\\n if self.gamma is None:\\n self.exponent()\\n p = powerlaw.plot(exponent=-self.gamma,\\n xmax=self.max_deg, xmin=self.k_min,\\n **kwargs\\n )\\n pylab.show()\\n return p\",\n \"def get_coeff(self):\\n return bernoulli(self.degree+1) / factorial(self.degree + 1)\",\n \"def get_power(self) -> float:\\n\\n #:READ[n][:CHANnel[m]][:SCALar]: POWer[:DC]?\\n return float(self._inst.query(\\\":READ:POW?\\\"))\",\n \"def q(self) -> float:\\n return self._pwr.imag\",\n \"def powerMultiplier(self):\\n return self.symmetry.symmetryFactor()\",\n \"def getDensityLaw(self):\\n return self.densityLaw\",\n \"def pdf(self,x):\\n return self.categoricalDist.pdf(x)\",\n \"def weighted_log_density(self):\\n return self.rho*math.log(self.density)\",\n \"def pdf(self, x, log = False):\\n if log:\\n return D.logsumexp(\\n D.multiple_gauss_den(x, self.mu, self.va, log = True)\\n + N.log(self.w))\\n else:\\n return N.sum(D.multiple_gauss_den(x, self.mu, self.va) * self.w, 1)\",\n \"def __density(self, x):\\n\\n z = np.power(self.rate, x) / m.factorial(x)\\n return z * np.exp(-self.rate)\",\n \"def setPowerFromDensity(self):\\n self.p.power = self.p.powerDensity * self.getHMMass()\",\n \"def get_double_power_law(self, alpha, beta, M_star):\\n\\t\\tdenom = 10.0**(0.4*(alpha + 1.0)*(self.M_grid - M_star))\\n\\t\\tdenom += 10.0**(0.4*(beta + 1.0)*(self.M_grid - M_star))\\n\\t\\tdn = 1.0/denom\\n\\t\\tdn /= np.sum(dn)\\n\\t\\treturn dn\",\n \"def _perplexity(self, X, log_w):\\n return np.exp(-log_w/X.sum())\",\n \"def W(self):\\n if not self.isVaild():\\n pass\\n return self.Wq() + 1.0/self.muy\",\n \"def noise(self):\\n # Extract parameters\\n pzs = self.params[0]\\n ngals = np.array([pz.gals_per_steradian for pz in pzs])\\n return 1.0 / ngals\",\n \"def density(temp,pres):\\n g_p = liq_g(0,1,temp,pres)\\n dliq = g_p**(-1)\\n return dliq\",\n \"def compute_Gamma_wdm(self):\\n GN = 0.71611\\n kT = const.kB*self.T_cmb\\n og = self.Omega_gamma\\n den = np.pi**4./15.*kT/(GN**3*og*1.5*ss.zeta(3))/self.h**2.\\n return GN*(self.Omega_wdm*self.h**2.*den/self.M_wdm)**(1./3.)\",\n \"def dsdlogdp(self):\\n return self.dndlogdp.mul(self.s_multiplier)\",\n \"def gc_prob_density(r):\\n return np.exp(_interp_ln_dens(r))\",\n \"def Wp(self):\\n from scipy.integrate import quad\\n Eth = 1.22e-3\\n\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\")\\n Wp = quad(lambda x: x * self._particle_distribution(x), Eth, np.Inf)[0]\\n\\n return (Wp * u.TeV).to('erg')\",\n \"def propagation_constant(self,freq):\\n sigma = self.conductivity\\n w = 2*np.pi*freq\\n gamma = w*1j*cmath.sqrt(self.mu*self.epsilon)*cmath.sqrt(1-1j*sigma/(w*self.epsilon))\\n return gamma\",\n \"def dvdlogdp(self):\\n return self.dndlogdp.mul(self.v_multiplier)\",\n \"def get_distribution_parameters(self):\\r\\n return \\\"UNDEFINED\\\"\",\n \"def get_powerperband(self, bandwidth):\\n ls = self.get_degrees()\\n return self._powerperdegree() * ls * np.log(bandwidth)\",\n \"def test_power(self):\\r\\n a = 6 # shape\\r\\n samples = 5000\\r\\n max = -0.06\\r\\n min = -3.3\\r\\n s = np.random.power(a, samples) * -1 * (min - max) + min\\r\\n plt.hist(s, bins=30, density=False)\\r\\n plt.xlabel('Interlayer point energy [eV]')\\r\\n plt.ylabel('Frequency')\\r\\n plt.show()\",\n \"def dB(x, power=True):\\r\\n if not power:\\r\\n return 20 * np.log10(np.abs(x))\\r\\n return 10 * np.log10(np.abs(x))\",\n \"def bandwidth(d):\\n gz = 2 * gamma(0.5 * (d+1)) / gamma(0.5 * d)\\n return 1. / (2. * gz**2)\",\n \"def prob(self, w):\\n return self.counts[w] / self.total_count\",\n \"def logpowerlaw(x, p=default()):\\n xtr, ytr, gradtr = logcontinuity(p)\\n power = p[3]\\n x0 = xtr - power/gradtr\\n b = ytr - power*np.log(xtr-x0)\\n return b + power*np.log(x-x0)\",\n \"def Wp(self):\\n Wp = trapz_loglog(self._Ep * self._J, self._Ep) * u.GeV\\n return Wp.to('erg')\",\n \"def pdf(self, x):\\n\\t\\treturn 1.5 * np.power(x,2) ##obtained after finding z from integrating x^2 from -1 to 1\",\n \"def get_uniform_p_vals(self, min=1.5, max=9):\\n rng = np.random.RandomState(12435)\\n if self.power_activ == \\\"softplus\\\":\\n p_vals = np.log(np.exp(rng.uniform(low=min, high=max, size=(self.num_units,))-1)-1)\\n else:\\n p_vals = np.sqrt(rng.uniform(low=min, high=max, size=(self.num_units,))-1)\\n return p_vals\",\n \"def dPdlogM_internal(self, mass):\\n return self.gamma*mass**self.gamma/(self.mmax**self.gamma-self.mmin**self.gamma)\",\n \"def pwm_freq(self):\\r\\n return self._pwm_freq\",\n \"def dB(x, power=False):\\n if power:\\n return 10 * np.log10(np.abs(x))\\n else:\\n return 20 * np.log10(np.abs(x))\",\n \"def distribution(self) -> str:\\n return pulumi.get(self, \\\"distribution\\\")\",\n \"def noise(self):\\n # Extract parameters\\n pzs = self.params[0]\\n # retrieve number of galaxies in each bins\\n ngals = np.array([pz.gals_per_steradian for pz in pzs])\\n if isinstance(self.config[\\\"sigma_e\\\"], list):\\n sigma_e = np.array([s for s in self.config[\\\"sigma_e\\\"]])\\n else:\\n sigma_e = self.config[\\\"sigma_e\\\"]\\n return sigma_e ** 2 / ngals\",\n \"def gamma(self):\\n if self._gamma is None:\\n df = self.kdf\\n gamma_ = -self._powerlaw(df.index, df.freq)\\n self._gamma = gamma_\\n\\n # return\\n return self._gamma\",\n \"def dble_pwr_law(time_bins, tau, alpha, beta, factor=1):\\n return factor/((time_bins/tau)**alpha + (time_bins/tau)**(-beta))\",\n \"def specular_power(self) -> float:\\n return self.GetSpecularPower()\",\n \"def s(self) -> NumType:\\n return abs(self._pwr)\",\n \"def power(self):\\n return self._power\",\n \"def factor(self):\\n return np.real_if_close(self.scale * np.exp(1j*self.phase))\",\n \"def log_prob(self):\",\n \"def distribution(self):\\n \\n #external_distribution serves both the purpose of external setting of distribution and the caching of distribution()\\n if self.external_distribution:\\n return self.external_distribution_array;\\n else:\\n energy_vector = []\\n superset = self.generate_superset(0) \\n \\n for i in superset:\\n state = self.ket(i)\\n \\n norm_squared = np.dot(state.T, state)\\n \\n if norm_squared > 0: #zero is appended at the end\\n energy = np.dot(state.T, np.dot( self.epsilon, state))\\n interaction = np.dot(state.T, np.dot( self.u, state))/2.0 #divide by two. Otherwise, <l r| U |l r > = U_LR + U_RL = 2U\\n #print state, np.dot(self.u, state) \\n #print interaction\\n energy_vector.append( energy + interaction )\\n \\n energy_vector.insert(0, 0.0) \\n probability = np.exp( np.multiply(-self.beta, energy_vector)) \\n probability /= probability.sum() \\n return probability\",\n \"def __pow__(self,power):\\n return Factor().__build( VarSet(self.v) , np.power(self.t,power) )\",\n \"def p(self):\\n return numpy.exp(self.log_p)\",\n \"def dlogdp(self):\\n return np.log10(self.bins[:, -1]) - np.log10(self.bins[:, 0])\",\n \"def density( self ) :\\n return self.__density\",\n \"def density( self ) :\\n return self.__density\",\n \"def density( self ) :\\n return self.__density\",\n \"def conditionalDistribution(self, d, m, w):\\r\\n probabilities_ts = np.ones((self.numTopics, self.numSentiments))\\r\\n\\r\\n # firstfactor 수정\\r\\n firstFactor = (self.n_wkl[w, :, :] + self.beta) / \\\\\\r\\n (self.n_kl + self.n_wkl.shape[0] * self.beta) # dim(K x L)\\r\\n\\r\\n secondFactor = (self.ns_dk[d, :] + self.alpha) / \\\\\\r\\n (self.ns_d[d] + self.numTopics * self.alpha) # dim(K x 1)\\r\\n\\r\\n thirdFactor = (self.ns_dkl[d, :, :] + self.gamma) / \\\\\\r\\n (self.ns_dk[d] + self.numSentiments * self.gamma)[:, np.newaxis] # dim (K x L)\\r\\n\\r\\n probabilities_ts *= firstFactor * thirdFactor\\r\\n probabilities_ts *= secondFactor[:, np.newaxis]\\r\\n probabilities_ts /= np.sum(probabilities_ts)\\r\\n return probabilities_ts\",\n \"def initializeDistribution(self):\\n if self.nPoints is None:\\n self.xArray = np.arange(self.lowerBound,self.upperBound+1)\\n else:\\n self.xArray = np.linspace(self.lowerBound,self.upperBound,self.nPoints)\\n\\n # Here the actual calculation of discrete distribution parameters is performed\\n self.pdfArray = 1.0/self.xArray.size * np.ones(self.xArray.size)\\n paramsDict={}\\n paramsDict['outcome'] = self.xArray\\n paramsDict['state'] = self.pdfArray\\n\\n self.categoricalDist = Categorical()\\n self.categoricalDist.initializeFromDict(paramsDict)\\n initialPerm = randomUtils.randomPermutation(self.xArray.tolist(),self)\\n self.pot = np.asarray(initialPerm)\",\n \"def _powerperdegree(self):\\n return SHPowerSpectrum(self.coeffs)\",\n \"def stdProbabilityNorm(self):\\n B = factorial(self.alpha-1)*factorial(self.beta-1)/factorial(self.alpha+self.beta-1)\\n norm = 1.0/(2**(self.alpha+self.beta-1)*B)\\n return norm\",\n \"def Mo96(self,dc,nu):\\n return 1. + (nu**2.-1.)/dc\",\n \"def stdProbabilityNorm(self):\\n return 0.5\",\n \"def lnprobability(self):\\n return\",\n \"def number_density(self) -> u.m**-3:\\n return self._number_density\",\n \"def probability_array(self):\\n q = self.apply_weights()\\n return np.exp(q)/(1 + np.exp(q))\",\n \"def log_distr_fdmw(self, dnu, logflux, dme, logw, alpha, logls, logl0, mu, sigma, gtype=None):\\n #stepdms = 100/1000.\\n #vdms = np.arange(0, 100, stepdm)\\n stepz = (np.log(self.Zmax) - np.log(self.Zmin)) / 1000\\n vz = np.exp(np.arange(np.log(self.Zmin), np.log(self.Zmax), stepz))\\n lik = 0\\n for z in vz:\\n likv = np.exp(self.log_distr_fdmwz(dnu, logflux, dme, logw, z, alpha, logls, logl0, mu, sigma, gtype=gtype))\\n lik += z * stepz * likv\\n ind = lik > 0\\n ind2 = lik <= 0\\n loglik = lik.copy()\\n loglik[ind] = np.log(lik[ind])\\n loglik[ind2] = np.ones(loglik[ind2].shape) * -1e99\\n return loglik\",\n \"def _normal_log_prob(self, r, scale_log):\\n return -(r**2) / 2 - scale_log - self.const\",\n \"def log_prior_wilson_coeffs(self, x):\\n if self.fit_wc_priors is None:\\n return 0\\n wc_dict = self.array_to_dict(x)['fit_wc']\\n prob_dict = self.fit_wc_priors.get_logprobability_all(wc_dict)\\n return sum([p for obj, p in prob_dict.items()])\",\n \"def dloglam(self):\\n # This number was determined using the resolution and sampling quoted on the FIRE website\\n R = 6000.0 * 2.7\\n dloglam = 1.0 / R / np.log(10.0)\\n return dloglam\",\n \"def set_power(self, dbm=-30):\\r\\n self.p = dbm\",\n \"def waveparameterh(L):\\r\\n return 8.13 - ((250 - 0.7 * L) / 125) ** 3\",\n \"def get_scale_parameter(self):\\r\\n \\r\\n if self.scale_parameter == 0.0: \\r\\n shape_in_gamma_func = float(1+(1/self.shape_parameter))\\r\\n gamma_func = special.gamma(shape_in_gamma_func)\\r\\n self.scale_parameter = (self.mean_fire_recurrence/gamma_func)\\r\\n return self.scale_parameter\\r\\n else:\\r\\n return self.scale_parameter\",\n \"def _powerperdegree(self):\\n return SHCPowerSpectrum(self.coeffs)\",\n \"def get_dist_probability(self):\\n return self.dist_probability\",\n \"def scale_parameter(self):\\n return self._scale_parameter\",\n \"def massrich_parameters(self):\\n print(\\\"\\\\nMass-Richness Power Law: M200 = norm * (N200 / 20) ^ slope\\\")\\n print(\\\" norm:\\\", self._massrich_norm)\\n print(\\\" slope:\\\", self._massrich_slope)\",\n \"def scale(self):\\n return self.distribution.scale\",\n \"def max_power(self):\\r\\n est_max_power = self.model * self.max_pwm / 100\\r\\n return est_max_power\",\n \"def d_dweight(self, ):\\n return self.gen_df_dw(self.params, self.output_shape)(self.current_input)\",\n \"def density(self, x):\\n\\t\\tN = len(self.train_data)\\n\\t\\tpoints = list(self.train_data)\\n\\t\\tdists = [np.linalg.norm(x-point)**2 for point in points]\\n\\t\\texps = [np.exp(-dist / (2 * (self.bandwidth ** 2))) for dist in dists]\\n\\t\\tunnormalized_sum = sum(exps)\\n\\t\\tprobability = (1 / N) * self.normalizing_constant() * unnormalized_sum\\n\\t\\treturn probability\",\n \"def density(self, arg):\\n return self.gb2_density(np.exp(arg)) * np.exp(arg)\",\n \"def get_discrete_distribution():\\n random_int = random.randint(1, 4)\\n if (random_int == 1) | (random_int == 2):\\n return 0\\n if random_int == 3:\\n return 3\\n if random_int == 4:\\n return 5\\n raise ValueError(\\\"Unable to generate discrete distribution with \\\", random_int)\",\n \"def p(self):\\n return hlp.parms(self.y(0))\",\n \"def get_scale_parameter(self):\\n\\n if self.scale_parameter == 0.0:\\n shape_in_gamma_func = float(1+(1/self.shape_parameter))\\n gamma_func = special.gamma(shape_in_gamma_func)\\n self.scale_parameter = (self.mean_fire_recurrence/gamma_func)\\n return self.scale_parameter\\n else:\\n return self.scale_parameter\",\n \"def den(self):\\n return self.den\",\n \"def ppd(self):\\n return math.sqrt(np.dot(self.v, self.v) / np.dot(self.w, self.w) )\",\n \"def __pow__(self, n):\\n\\t\\tvalues = map(lambda x: x >= 0, self.val)\\n\\t\\tif isinstance(n, float) or isinstance(n, int):\\n\\t\\t\\tif n % 1 != 0 and not all(values):\\n\\t\\t\\t\\traise ValueError(\\\"Non-positive number raised to a fraction encountered in pow.\\\")\\n\\t\\t\\telif n < 1 and 0 in self.val:\\n\\t\\t\\t\\traise ZeroDivisionError(\\\"Cannot compute derivative of 0^y for y < 1.\\\")\\n\\t\\t\\n\\t\\t\\tval = np.power(self.val, n)\\n\\t\\t\\tif len(self.der.shape):\\n\\t\\t\\t\\tself_val = np.expand_dims(self.val, 1) if len(self.der.shape) > len(self.val.shape) else self.val\\n\\t\\t\\t\\tder = n * np.multiply((self_val ** (n - 1)), self.der)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tder = None\\n\\n\\t\\t\\treturn Var(val, der)\\n\\n\\t\\t# n is a Var\\n\\t\\telse:\\n\\t\\t\\tfor n_i in n.val:\\n\\t\\t\\t\\tif n_i % 1 != 0 and not all(values):\\n\\t\\t\\t\\t\\traise ValueError(\\\"Non-positive number raised to a fraction encountered in pow.\\\")\\n\\t\\t\\t\\telif n_i < 1 and 0 in self.val:\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\traise ZeroDivisionError(\\\"Cannot compute derivative of 0^y for y < 1.\\\")\\n\\n\\t\\t\\tval = np.power(self.val, n.val)\\n\\t\\t\\t# Check for constant Vars of scalars or vectors\\n\\t\\t\\tif len(n.der.shape) == 0 and len(self.der.shape):\\n\\t\\t\\t\\tder = None\\n\\t\\t\\telif len(self.der.shape) == 0 and len(n.der.shape):\\n\\t\\t\\t\\tder = None\\n\\t\\t\\telif len(self.der.shape) == 0 and len(n.der.shape) == 0:\\n\\t\\t\\t\\tder = None\\n\\t\\t\\telse:\\n\\t\\t\\t\\t# Both self and n are Vars of valid variable(s), not constants\\n\\t\\t\\t\\tif len(self.val) > 1 and len(n.val) > 1 and len(self.val) != len(n.val):\\n\\t\\t\\t\\t\\traise ValueError(\\\"x and y cannot be of different dimensions > 1 in x^y.\\\")\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tder = val * ((n.val / self.val) * self.der + np.log(self.val) * n.der)\\n\\t\\t\\treturn Var(val, der)\",\n \"def power(self):\\r\\n return self.model * self.percent / 100\",\n \"def log_pdf(self, x):\\n if x < 0:\\n raise Exception(\\\"input value x can't be a negative value!\\\")\\n\\n if self.is_fit:\\n if x >= 0:\\n return -np.log(np.math.factorial(x)) + \\\\\\n x * np.log(self.alpha) - self.alpha\\n else:\\n return 0\\n else:\\n raise Exception(\\\"Distribution doesn't have all parameters set!\\\")\",\n \"def pdf(self, x):\\n if x < 0:\\n raise Exception(\\\"input value x can't be a negative value!\\\")\\n\\n if self.is_fit:\\n if x >= 0:\\n enu = np.power(self.alpha, x) * np.power(np.e, -self.alpha)\\n den = np.math.factorial(x)\\n return enu / den\\n else:\\n return 0\\n else:\\n raise Exception(\\\"Distribution doesn't have all parameters set!\\\")\",\n \"def density(self):\\n return self.get_density()\",\n \"def draw_powerlaw(alpha, rng, N=1):\\n if alpha == -1:\\n alpha = -1.0000001\\n # Normalization factor\\n x0, x1 = rng\\n C = (alpha + 1) / (x1**(alpha + 1) - x0**(alpha + 1))\\n \\n if N==1:\\n u = np.random.random()\\n else:\\n u = np.random.random(N)\\n x = ((u * (alpha + 1)) / C + x0**(alpha + 1))**(1./(alpha + 1))\\n\\n return x\",\n \"def dc(self):\\n return np.array(self['dc'], dtype=np.float32) / 1000\",\n \"def var(self):\\n\\n return self.scale ** -2 \\\\\\n * (m.gamma(1 + 2 * self.shape ** -1) - m.gamma(1 + self.shape ** -1) ** 2)\",\n \"def get_scale_parameter(self):\\n\\n shape_in_gamma_func = float(1 + (1 / self._shape_parameter))\\n gamma_func = special.gamma(shape_in_gamma_func)\\n self._scale_parameter = self._mean_fire_recurrence / gamma_func\",\n \"def distmod(self):\\n val = 5. * np.log10(self.to(u.pc).value) - 5.\\n return u.Quantity(val, u.mag)\",\n \"def density(self):\\n return self._density\",\n \"def pertube_distribution_weight(self, random_state, n_samples, multipler):\\n curr_sample_weight = np.ones((n_samples,), dtype=np.float64)\\n indices = _generate_sample_indices(random_state, n_samples)\\n sample_counts = bincount(indices, minlength=n_samples)\\n curr_sample_weight *= np.power(sample_counts, multipler)\\n return curr_sample_weight\",\n \"def intensity(self):\\r\\n return np.power(prb.amplitude, 2)\",\n \"def b_Kjeldsen2008(self):\\n return 10.0**(-3.16*self.string_to_param(\\\"log_Teff\\\") + 0.184*self.string_to_param(\\\"log_g\\\")+11.7)\",\n \"def amplitude(self):\\r\\n return np.sqrt(self.maxint) * self.weights\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6245299","0.6230578","0.61405843","0.61323225","0.6072418","0.6042991","0.6005209","0.59938747","0.5953153","0.5944802","0.5926701","0.59120494","0.5909073","0.5900675","0.5881514","0.58275497","0.582486","0.581495","0.5803767","0.58021843","0.5794235","0.5770467","0.5769135","0.5764377","0.5760653","0.5743807","0.5738955","0.5728157","0.57269746","0.57116145","0.57088345","0.5707408","0.5669175","0.56564695","0.5648146","0.5644266","0.56436914","0.5642037","0.56393623","0.5637006","0.56341875","0.5606839","0.5601917","0.5600763","0.55968356","0.5596283","0.55933285","0.5585938","0.557794","0.5571195","0.55659354","0.55609375","0.55606645","0.55566275","0.55566275","0.55566275","0.55540085","0.5551511","0.5546882","0.5544389","0.5535754","0.5530999","0.553068","0.552541","0.55165744","0.55091465","0.5502384","0.54996127","0.54995817","0.54944444","0.5493548","0.54874176","0.5486338","0.5483424","0.5479339","0.54767066","0.54743433","0.54724973","0.5472031","0.5469526","0.5468889","0.5465286","0.54643434","0.5460439","0.54501253","0.5450121","0.544869","0.5441958","0.5432533","0.5429133","0.5426278","0.5424765","0.54189813","0.54133666","0.54100955","0.54047924","0.5404688","0.5383303","0.5379557","0.5378308","0.5370146"],"string":"[\n \"0.6245299\",\n \"0.6230578\",\n \"0.61405843\",\n \"0.61323225\",\n \"0.6072418\",\n \"0.6042991\",\n \"0.6005209\",\n \"0.59938747\",\n \"0.5953153\",\n \"0.5944802\",\n \"0.5926701\",\n \"0.59120494\",\n \"0.5909073\",\n \"0.5900675\",\n \"0.5881514\",\n \"0.58275497\",\n \"0.582486\",\n \"0.581495\",\n \"0.5803767\",\n \"0.58021843\",\n \"0.5794235\",\n \"0.5770467\",\n \"0.5769135\",\n \"0.5764377\",\n \"0.5760653\",\n \"0.5743807\",\n \"0.5738955\",\n \"0.5728157\",\n \"0.57269746\",\n \"0.57116145\",\n \"0.57088345\",\n \"0.5707408\",\n \"0.5669175\",\n \"0.56564695\",\n \"0.5648146\",\n \"0.5644266\",\n \"0.56436914\",\n \"0.5642037\",\n \"0.56393623\",\n \"0.5637006\",\n \"0.56341875\",\n \"0.5606839\",\n \"0.5601917\",\n \"0.5600763\",\n \"0.55968356\",\n \"0.5596283\",\n \"0.55933285\",\n \"0.5585938\",\n \"0.557794\",\n \"0.5571195\",\n \"0.55659354\",\n \"0.55609375\",\n \"0.55606645\",\n \"0.55566275\",\n \"0.55566275\",\n \"0.55566275\",\n \"0.55540085\",\n \"0.5551511\",\n \"0.5546882\",\n \"0.5544389\",\n \"0.5535754\",\n \"0.5530999\",\n \"0.553068\",\n \"0.552541\",\n \"0.55165744\",\n \"0.55091465\",\n \"0.5502384\",\n \"0.54996127\",\n \"0.54995817\",\n \"0.54944444\",\n \"0.5493548\",\n \"0.54874176\",\n \"0.5486338\",\n \"0.5483424\",\n \"0.5479339\",\n \"0.54767066\",\n \"0.54743433\",\n \"0.54724973\",\n \"0.5472031\",\n \"0.5469526\",\n \"0.5468889\",\n \"0.5465286\",\n \"0.54643434\",\n \"0.5460439\",\n \"0.54501253\",\n \"0.5450121\",\n \"0.544869\",\n \"0.5441958\",\n \"0.5432533\",\n \"0.5429133\",\n \"0.5426278\",\n \"0.5424765\",\n \"0.54189813\",\n \"0.54133666\",\n \"0.54100955\",\n \"0.54047924\",\n \"0.5404688\",\n \"0.5383303\",\n \"0.5379557\",\n \"0.5378308\",\n \"0.5370146\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":91797,"cells":{"query":{"kind":"string","value":"Predicted number of types sampled in proportion x of corpus, as a proportion of total types."},"document":{"kind":"string","value":"def formula(self, x: np.ndarray, gamma: float = None) -> np.ndarray:\n gamma = gamma or self.gamma\n Li = self._vpolylog(gamma, 1 - x)\n A = 1 / float(zeta(gamma).real)\n y = 1 - A * Li\n return y"},"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 predict_types(self, context, filter_types=None):\n ngram_probs = self._get_ngram_probs(context, filter_types)\n type_probs = defaultdict(lambda: 0)\n for probs in ngram_probs:\n for entity_type, prob in probs:\n type_probs[entity_type] += prob/len(ngram_probs)\n\n result_probs = sorted(type_probs.items(), key=lambda x: x[1], reverse=True)\n return result_probs","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 prob_t_N(genotype, base):\n cnter = Counter(genotype)\n return cnter.get(base, 0) * 1/len(genotype)","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 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 predictability(self):\n temp = self.probs\n for n in range(10):\n temp = temp.dot(temp)\n final = temp[0,:]\n #Let's assume that all words have unique initial letters\n probs = map(len, self.words)\n probs = array(probs)\n probs = (probs + self.probs.max(1)-1)/probs\n return sum(final*probs)","def get_type_stats(self):\n if not self.fitted:\n raise ValueError(\"Vocabulary hasn't been computed yet\")\n\n total_types = len(self.freqs)\n known_types = len(self) - len(self.reserved)\n return known_types, total_types, known_types / total_types","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","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 get_sample_weight(y):\n class_counts = np.bincount(y)\n class_weight = 1 / class_counts\n sample_weight = class_weight[y]\n sample_weight = sample_weight / sample_weight.sum() * len(y)\n return sample_weight","def predict_types_features(self, context):\n ngram_probs = self._get_full_ngram_probs(context)\n return ngram_probs","def compute_proportions_from_predicted_labels(predictions, instance_weights, n_classes=2):\n n_items = len(predictions)\n if instance_weights is None:\n instance_weights = np.ones(n_items)\n class_counts = np.zeros(n_classes)\n for c in range(n_classes):\n items = np.array(predictions == c, dtype=bool)\n class_counts[c] = np.sum(instance_weights[items])\n proportions = class_counts / float(np.sum(class_counts))\n return proportions","def percent_frequencies(self):\n word_count = 0\n local = self.frequencies()\n for key in local.keys():\n i = local[key]\n word_count += int(i)\n for key in local.keys():\n i = local[key]\n percentage = float(i) / float(word_count)\n local[key] = percentage\n return local","def calc_class_weights(self):\n y = self.train_eval_data[\"sentiment\"]\n self.class_weights = {}\n classes = np.unique(y)\n for cls in classes:\n self.class_weights[cls] = len(y) / (len(classes) * (y == cls).sum())","def percentage_common_types (corpus): \n total = sum([t[1] for t in most_frequent(corpus)])\n return percentage(total, corpus_length(corpus))","def precision(y, ypred):\n return len(set(y).intersection(set(ypred))) / len(ypred)","def predict(self,x):\n preds = [tree.predict(x) for tree in self.forest]\n if self.classify:\n cls_counts = [0] * self.param['numClasses']\n for p in preds:\n cls_counts[p] += 1\n return argmax(cls_counts)\n else:\n return sum(preds) / (len(preds)*1.0)","def get_sample_weights(self):\n target_to_weight = {}\n for target, count in self.class_count.items():\n target_to_weight[target] = self.total / count\n\n sample_weights = []\n for _, target in self.imgs:\n sample_weights.append(target_to_weight[target])\n\n return sample_weights","def prob(self, w):\n return self.counts[w] / self.total_count","def calc_feature_probs(image_type, image_data, smoothing):\n counts = np.array([np.sum(image_data.features[image_data.labels == value], axis=0) + smoothing for value in range(image_type.categories)])\n denoms = np.array([np.count_nonzero(image_data.labels == value) + (smoothing * image_type.feature_kinds) for value in range(image_type.categories)])\n return counts / denoms[:, np.newaxis, np.newaxis]","def predict_types_full(self, context):\n ngram_probs = self._get_ngram_probs(context)\n return self._hierachical_sum_output(ngram_probs)","def probabilities(self):\n raise NotImplementedError","def class_weights(self):\n target_list = self.label\n count_dict = Counter(target_list)\n class_count = [count_dict[i] for i in range(3)]\n class_weights = len(target_list) / torch.tensor(class_count, dtype=torch.float)\n class_weights = class_weights / class_weights.sum()\n print(class_weights) # noqa: T001\n return class_weights","def get_probs(self, *vars):\n freqs = self.freq_counts([self.data.get_column_view(v)[0] for v in vars], [len(v.values) for v in vars])\n k = np.prod([len(v.values) for v in vars])\n return (freqs + self.alpha) / (np.sum(freqs) + self.alpha*k)","def compute_class_freqs(gen):\r\n labels = gen.labels\r\n N = labels.shape[0]\r\n positive_frequencies = np.sum(labels, axis=0) / N\r\n negative_frequencies = np.sum(1 - labels, axis=0) / N\r\n return positive_frequencies, negative_frequencies","def probability(self, samples):\n pass","def prob(self, doc, cat):\n catprob = self.category_count(cat) / self.total_count() # Pr(Category)\n docprob = self.doc_prob(doc, cat) # Pr(Document | Category)\n return docprob*Decimal(str(catprob)) # Pr(Category | Document)","def calc_prob(data):\n total = len(data)\n frequencies = sorted(Counter(data).items())\n probabilities = OrderedDict()\n for (key, value) in frequencies:\n probabilities[key] = value / total\n return probabilities","def test_get_tax_return_frequencies(self):\n pass","def get_load_factor(self):\n # Your code here\n return self.count/len(self.data)","def doc_prob(self, doc, cat):\n features = self.get_features(doc) \n # Multiply the probabilities of all the features together\n p = Decimal(1)\n for f in features:\n p *= Decimal(str(self.weighted_prob(f, cat, self.feature_prob))) \n return p","def get_proportion_of_success(dataset):\n rdd1 = dataset.map(lambda rec: (len(get_words(rec['title']))\n if 'title' in rec.keys() else 0,\n (1 if rec['points'] > 200 else 0, 1)))\n\n rdd2 = rdd1.reduceByKey(lambda a, b: (a[0] + b[0], a[1] + b[1]))\n\n prop_per_title_length_rdd = rdd2.map(lambda title_scores: (\n title_scores[0], title_scores[1][0]/title_scores[1][1]))\n return prop_per_title_length_rdd","def _proba(y):\n N = len(y)\n _, counts = np.unique(y, return_counts=True)\n return counts / N","def sampling_ratio(self):\n return self.coincidences / self.n","def get_precision(y_true, y_pred):\n model_entities_filter = (y_pred != 3).astype(\"int\") # of the words our model say has a NER class\n precision_correct_entities = (y_pred[np.where(model_entities_filter)] == y_true[np.where(model_entities_filter)]).astype(\"int\")\n precision = np.sum(precision_correct_entities)/np.sum(model_entities_filter) \n return precision","def sampler_weights(dataset):\n class_counts = [0, 0]\n for index in range(len(dataset)):\n _, label = dataset[index]\n class_counts[label] += 1\n\n divisor = 2 * class_counts[0] * class_counts[1]\n sample_weights = (class_counts[1] / divisor, class_counts[0] / divisor)\n weights = []\n for index in range(len(dataset)):\n _, label = dataset[index]\n weights.append(sample_weights[label])\n\n num_samples = 2 * min(class_counts[0], class_counts[1])\n return weights, num_samples","def raw_unigram_probability(self, unigram):\n result = 0.0\n result = self.unigramcounts[unigram]/self.total\n\n #hint: recomputing the denominator every time the method is called\n # can be slow! You might want to compute the total number of words once, \n # store in the TrigramModel instance, and then re-use it. \n\n\n return result","def sample_count(self):","def precision(y, model):\n\n\tTP, FP, TN, FN = TRUE_FALSE_PREDICTIONS(y, model)\n\tprecision = TP/(TP+FP)\n\treturn precision","def GetProportion(self):\r\n\r\n return self.proportion","def test_on(self, examples):\n stats = defaultdict(int)\n num_correct, num_examples = 0, 0\n for filename, category in examples:\n hypothesis = self.classify_doc(filename)[0]\n if category == 'positive':\n stats['total_real_pos'] += 1\n elif category == 'negative':\n stats['total_real_neg'] += 1\n stats['total_examples'] += 1\n if category == hypothesis:\n if category == 'positive':\n stats['pos_correctly_classified'] += 1\n else:\n stats['neg_correctly_classified'] += 1\n num_correct += 1\n else:\n if category == 'positive' and hypothesis == 'negative':\n stats['pos_classified_as_neg'] += 1\n elif category == 'negative' and hypothesis == 'positive':\n stats['neg_classified_as_pos'] += 1\n num_examples += 1\n\n return ((float(num_correct) / float(num_examples)), stats)","def specificity(confusion):\n classes = len(confusion)\n truth = 0\n per = np.zeros((classes,))\n # tru_confusion = np.zeros((2, 2))\n\n total = np.sum(confusion)\n for i in range(len(confusion)):\n tp = confusion[i][i]\n fp = np.sum(confusion[:, i]) - tp\n fn = np.sum(confusion[i]) - tp\n tn = total - tp - fp - fn\n\n # tru_confusion[0][0] = tp\n # tru_confusion[1][0] = fp\n # tru_confusion[0][1] = fn\n # tru_confusion[1][1] = tn\n\n per[i] = tn/(tn + fp)\n\n return per","def percent_unique_ngrams_in_train(train_ngrams_dict, gen_ngrams_dict):\n\n # *Total* number of n-grams produced by the generator.\n total_ngrams_produced = 0\n\n for _, value in gen_ngrams_dict.iteritems():\n total_ngrams_produced += value\n\n # The unique ngrams in the training set.\n unique_ngrams_in_train = 0.\n\n for key, _ in gen_ngrams_dict.iteritems():\n if key in train_ngrams_dict:\n unique_ngrams_in_train += 1\n return float(unique_ngrams_in_train) / float(total_ngrams_produced)","def prob(throw, n, d=6, type='classical'):\n count = 0\n table = throw_table(n, d, type)\n for t in table:\n if sum(t) == throw:\n count += 1\n \n return float(count)/len(table)","def prob1(n):\n#raise NotImplementedError(\"Problem 1 Incomplete\")\n if n == 0 :\n raise ValueError(\"Sampling 0 points is not defined.\")\n total = 0\n for i in xrange(n) :\n if np.random.normal() > 3 :\n total += 1\n return float(total)/n","def find_probabilities_of_labels(examples_set):\n labelsCount = {\n \"yes\": 0,\n \"no\": 0\n }\n probOfLabels = list()\n\n if isinstance(examples_set[0], list):\n totalCount = len(examples_set)\n\n for example in examples_set:\n nextLabel = example[14]\n labelsCount[nextLabel] += 1\n\n # There is only one example in the set\n else:\n totalCount = 1\n nextLabel = examples_set[14]\n labelsCount[nextLabel] += 1\n\n for label in labelsCount.keys():\n labelProbability = (labelsCount[label] / totalCount)\n probOfLabels.append(labelProbability)\n\n return probOfLabels","def _cal_label_distribution(self):\n if self.split == 'train':\n self.label_weights = np.zeros(21, dtype=np.float32)\n for label_list in self.label:\n self.label_weights += np.histogram(label_list, range(22))[0]\n self.label_weights /= np.sum(self.label_weights)\n print(\"per class weight:\", self.label_weights)\n self.label_weights = 1. / np.log(1.2 + self.label_weights)\n print(\"np.log(1.2 + self.label_weights):\", self.label_weights)\n elif self.split == 'test':\n self.label_weights = np.ones(21)\n return self.label_weights.tolist()","def cost(books):\n\n num_types = len(set(books))\n assert num_types < 6, \"Discounts indeterminate\"\n return DISCOUNT_TABLE.get(num_types, 0) * 8 * len(books) * 100","def raw_unigram_probability(self, unigram):\n\n #hint: recomputing the denominator every time the method is called\n # can be slow! You might want to compute the total number of words once, \n # store in the TrigramModel instance, and then re-use it.\n num = self.unigramcounts[unigram]\n den = self.word_count\n return num/den","def raw_freq(*marginals):\n return float(marginals[NGRAM]) / marginals[TOTAL]","def number_types(corpus):\n number_of_types = len(set(corpus))\n return number_of_types","def sentence_probability(self, sentence, ngram_type=1):\n sentence_word_list = sentence.lower().split()\n prob = 0 # sentence probability\n if ngram_type == 1:\n for i in range(len(sentence_word_list)):\n prob = prob + self.n_gram_MLE(sentence_word_list[i], gram_type=1)\n\n if ngram_type == 2:\n for i in range(len(sentence_word_list)):\n if i >= len(sentence_word_list) - 1:\n break\n prob = prob + self.n_gram_MLE(sentence_word_list[i],\n sentence_word_list[i] + ' ' + sentence_word_list[i + 1], gram_type=2)\n\n if ngram_type == 3:\n for i in range(len(sentence_word_list)):\n if i >= len(sentence_word_list) - 2:\n break\n prob = prob + self.n_gram_MLE(sentence_word_list[i] + ' ' + sentence_word_list[i + 1],\n sentence_word_list[i] + ' ' + sentence_word_list[i + 1] + ' ' +\n sentence_word_list[i + 2], gram_type=3)\n\n if ngram_type == 4:\n for i in range(len(sentence_word_list)):\n if i >= len(sentence_word_list) - 3:\n break\n prob = prob + self.n_gram_MLE(sentence_word_list[i] + ' ' + sentence_word_list[i + 1] + ' ' +\n sentence_word_list[i + 2],\n sentence_word_list[i] + ' ' + sentence_word_list[i + 1] + ' ' +\n sentence_word_list[i + 2] + sentence_word_list[i + 3], gram_type=4)\n\n if ngram_type == 5:\n for i in range(len(sentence_word_list)):\n if i >= len(sentence_word_list) - 4:\n break\n prob = prob + self.n_gram_MLE(sentence_word_list[i] + ' ' + sentence_word_list[i + 1] + ' ' +\n sentence_word_list[i + 2] + sentence_word_list[i + 3],\n sentence_word_list[i] + ' ' + sentence_word_list[i + 1] + ' ' +\n sentence_word_list[i + 2] + sentence_word_list[i + 3] +\n sentence_word_list[i + 4], gram_type=5)\n\n return prob","def get_pertinence (cats):\n sorted_cats = sorted(cats, key=cats.__getitem__, reverse=True)\n score_to_test = cats[sorted_cats[0]]\n all_values = [cats[key] for key in sorted_cats]\n average = sum(all_values) / len(all_values)\n logged_rest = [log(abs(average - val) + 1) for val in all_values[1:]]\n \n rest_average = sum(logged_rest) / len(logged_rest)\n logged_main = log(abs(average - all_values[0])+1)\n \n importance = max(logged_main - rest_average, 0)\n \n return importance","def main():\n x, y = create_simple_classification_dataset(5)\n count = 0\n for i in y:\n if i[0] == 0:\n count += 1\n print('percent of zeros', count / len(y)) # confirm that the distribution isn't too skewed.","def sample_equal_proportion(y, proportion=0.667, random_state=None):\n # Set random_state\n if random_state is not None:\n np.random.seed(random_state)\n\n # calculate number of observations\n n_obs = len(y)\n\n # identify index number for class1 and class2\n index_class1 = np.where(y == 0)[0]\n index_class2 = np.where(y == 1)[0]\n\n # calculate number of class1 and class2 observations\n n_class1 = len(index_class1)\n n_class2 = len(index_class2)\n\n # calculate number of class1 and class2 observations in the train set\n n_class1_train = int(np.round(n_class1 * proportion))\n n_class2_train = int(np.round(n_class2 * proportion))\n\n # generate indices for class1 and class2 observations in the train set\n index_class1_train = np.random.choice(index_class1, size=n_class1_train, replace=False)\n index_class2_train = np.random.choice(index_class2, size=n_class2_train, replace=False)\n index_train = list(np.append(index_class1_train, index_class2_train))\n\n # return a boolean vector of len n_obs where TRUE represents\n # that observation should be in the train set\n sequence = list(np.arange(n_obs))\n index = np.array([True if i in index_train else False for i in sequence])\n return index","def administer(self):\n\n score = 0.0\n for question in self.questions:\n if question.ask_and_evaluate() is True:\n score += 1\n return (score / len(self.questions)) * 100","def proportional_strategy(our_hist, their_hist):\n if len(our_hist) == 0 or len(their_hist) == 0:\n return choice(CHOICES)\n freqs = count(their_hist)\n prediction_for_them = choices(CHOICES, weights=freqs)[0]\n return CHOICES[(prediction_for_them + 1) % 3]","def specificity(confusion):\n classes = range(confusion.shape[0])\n num = (np.sum(confusion[classes]) - np.sum(confusion[classes], axis=0) -\n np.sum(confusion[classes], axis=1) + confusion[classes, classes])\n den = ((np.ones(confusion.shape[0]) * np.sum(confusion[classes])) -\n np.sum(confusion[classes], axis=1))\n return num / den","def PredictBase(self, adjectives):\n # Get the list of Adjectives which have sentiment polarity greater than 0.1\n if self.smallReviews:\n return 1.0\n PolarAdjList = [l for l in adjectives if l in self.lexicon and math.fabs(float(self.lexicon[l])) > 0.1]\n if len(PolarAdjList) > 0:\n return 12.0/len(PolarAdjList)\n # elif len(list2) < 8:\n # return 2.0\n else:\n return 1.0","def main(n_samples):\n uso = usolib.uso.uar(N)\n lst = [usolib.randomfacet.randomfacet_sample(uso, N) for i in range(n_samples)]\n return sum(lst) / float(n_samples)","def data_type_ratio(self):\n if self.sample_size:\n return float(self.match_count) / self.sample_size\n return None","def predict_one(self):\n return (self.contexted.calc_p(\"\", self.seen + \"1\") /\n float(self.contexted.calc_p(\"\", self.seen)))","def distribution_of_result(clf_name, all, ids=None, print_res=True):\n id_map = get_id_dict()\n y_map = get_y_dict()\n\n if clf_name == 'svm':\n clf_name = 'Pipeline'\n else:\n clf_name = type(get_base_learners(clf_name)).__name__\n y_preds = load_testset_predictions(all)\n\n distr_count = dict()\n distr_count['TP'] = Counter()\n distr_count['FN'] = Counter()\n distr_count['FP'] = Counter()\n distr_count['TN'] = Counter()\n\n distr = {key: {source: [] for source in set([v for v in id_map.values()])} for key in ['TP', 'FN', 'FP', 'TN']}\n\n for index, row in y_preds.iterrows():\n pred = row[clf_name]\n tweet_id = row['tweet__id']\n\n source = id_map[tweet_id]\n y = y_map[tweet_id]\n\n if ids is not None and tweet_id not in ids:\n continue\n\n if y == pred and pred == 1:\n distr_count['TP'][source] += 1\n distr['TP'][source].append(tweet_id)\n\n elif y != pred and pred == 1:\n distr_count['FP'][source] += 1\n distr['FP'][source].append(tweet_id)\n\n elif y != pred and pred == 0:\n distr_count['FN'][source] += 1\n distr['FN'][source].append(tweet_id)\n\n else:\n distr_count['TN'][source] += 1\n distr['TN'][source].append(tweet_id)\n\n if print_res:\n print(distr_count)\n for key, values in distr.items():\n print('{}:'.format(key))\n for key2, values2 in distr[key].items():\n print('\\t{}:'.format(key2))\n print('\\t{}'.format(values2))\n return distr_count, distr","def _basic_probability(count: int, sequence_total_count: int) -> float:\n return float(count) / sequence_total_count","def num_training_examples(self):","def n_train(self):\n return self.factors[0].shape[0]","def num_words():\n # Load the GT.\n df = pd.read_csv(config.META_FQN, sep=\"\\t\")\n stats = {\n \"T\": {\"words\": [], \"duration\": []},\n \"P\": {\"words\": [], \"duration\": []},\n \"sess\": {\"words\": [], \"duration\": []},\n }\n\n for _, row in df.iterrows():\n if row[\"asr_test\"]:\n stats[\"P\"][\"words\"].append(float(row[\"gt_patient_num_words\"]))\n stats[\"T\"][\"words\"].append(float(row[\"gt_therapist_num_words\"]))\n stats[\"P\"][\"duration\"].append(float(row[\"gt_patient_time_spoken\"]))\n stats[\"T\"][\"duration\"].append(\n float(row[\"gt_therapist_time_spoken\"])\n )\n stats[\"sess\"][\"duration\"].append(float(row[\"sess_dur\"]))\n n_words = (\n row[\"gt_therapist_num_words\"] + row[\"gt_patient_num_words\"]\n )\n stats[\"sess\"][\"words\"].append(n_words)\n\n for speaker in stats:\n for metric in stats[speaker]:\n print(f\"------ {speaker} | {metric} ------\")\n print_stats(stats[speaker][metric])","def recall(y, ypred):\n return len(set(y).intersection(set(ypred))) / len(y)","def purity(y_true, y_pred, sample_weight=None):\n if sample_weight is None:\n sample_weight = np.ones_like(y_true)\n TP = np.sum((y_pred) * y_true * sample_weight)\n FP = np.sum((y_pred) * (y_true == 0) * sample_weight)\n return TP / (TP + FP)","def get_probabilidades_a_priori(self, y):\r\n \r\n classes = self.classes_\r\n probabilidades_a_priori = []\r\n for i in range(len(classes)): \r\n probabilidades_a_priori.append (len(y[y == classes[i]])/len(y))\r\n probabilidades_a_priori = np.array(probabilidades_a_priori)\r\n \r\n return probabilidades_a_priori","def probability(self, item):\n count = self.counter.get(item, 0)\n if self.smoothing_dict:\n smooth_count = self.smoothing_dict.get(count, count)\n assert smooth_count > 0\n return smooth_count / self.smooth_total\n else:\n return count / self.total","def get_precision(self, y_true, y_pred):\n model_entities_filter = (y_pred != 3).astype(\"int\") # of the words our model say has a NER class\n precision_correct_entities = (y_pred[np.where(model_entities_filter)] == y_true[np.where(model_entities_filter)]).astype(\"int\")\n precision = np.sum(precision_correct_entities)/np.sum(model_entities_filter)\n return precision","def _get_selection_probabilities(self):\r\n probabilities = np.arange(1, self.population_size+1, dtype=float)[::-1]\r\n probabilities /= probabilities.sum()\r\n return probabilities","def priorProbabilities():\r\n\ttotal = 0.0\r\n\tpos = 0.0\r\n\tneg = 0.0\r\n\r\n\t# Count the amount of positives and negatives in the training data\r\n\tfor item in trainingData:\r\n\t\ttotal += 1\r\n\t\tif item[1] == '0':\r\n\t\t\tpos +=1\r\n\t\tif item[1] == '1':\r\n\t\t\tneg +=1\r\n\t\t\t\r\n\t\t\t\r\n\t# Return the positive and negative probabilities \r\n\tposProb = float(pos / total * 100)\r\n\tnegProb = float(neg / total * 100)\r\n\r\n\t\r\n\t\r\n\treturn posProb, negProb","def get_percentage_false_class_for_resultset(results):\n count_success = 0\n count_correct_prediction = 0\n for result in results:\n if result[\"image_target\"] == result[\"prediction_image\"] and result[\"std_noise\"] != 0:\n count_correct_prediction += 1\n if result[\"success\"] == True:\n count_success += 1\n\n error = stats.proportion.proportion_confint(count_success, count_correct_prediction, 0.05)\n\n return np.array([count_success/count_correct_prediction, error])","def check_correctness_statistics(classifier_out, mode, image_type):\n labels = image_type.image_data[mode].labels\n num_correct = 0\n total = len(classifier_out)\n for index, label in classifier_out:\n if labels[index] == label:\n num_correct += 1\n return (num_correct / total) * 100","def raw_unigram_probability(self, unigram):\n\n assert len(unigram) == 1\n count_unigram = self.unigramcounts[unigram]\n if self.total_word_count == 0 :\n return 1 / self.total_sentence_count\n else :\n return (count_unigram / self.total_word_count)","def corpus_stats(self):\n print(\"Number of sentences: {}\".format(len(self.corpus.sents())))\n print(\"Token: {}\".format(len(self.corpus.words())))\n types = FreqDist(self.corpus.words())\n print(\"Types: {}\".format(len(types)))","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 get_num_classes(self):","def calcProbability(self):\n for attribute in self.attributes:\n index = self.F2I[attribute]\n features = set([self.train[i][0][index] for i in range(len(self.train))])\n for feature in features:\n #all the true and false\n result_t = list(filter(lambda x: x[1]== True, self.train))\n total_t = len(result_t)\n result_f = list(filter(lambda x: x[1]== False, self.train))\n total_f= len(result_f)\n #the probability for the feature if its true or false\n t = len(list(filter(lambda x: x[0][index] == feature, result_t)))\n f = len(list(filter(lambda x: x[0][index] == feature, result_f)))\n prob_yes= t/total_t\n prob_no = f/total_f\n #assign the probabilities to the dictionaries\n self.probs_yes[(index,feature)] = prob_yes\n self.probs_no[(index,feature)] = prob_no","def ovo_test(dic, x_test, y_test, nb_classes):\n TP = FP = TN = FN = 0\n correct_predict = 0\n for index, value in enumerate(x_test):\n predict = {elem : 0 for elem in nb_classes}\n for key in dic:\n predict[key[0] if dic[key].predict([value]) else key[1]] += 1\n predicted_value = max(predict.items(), key=operator.itemgetter(1))[0]\n if predicted_value == y_test[index]:\n correct_predict += 1\n TP += 1\n else:\n FP += 1\n \n return correct_predict, TP, FP, TN, FN","def compute_class_freqs(labels):\n ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\n \n # total number of patients (rows)\n N = len(labels)\n \n positive_frequencies = np.sum(labels,axis=0)/N\n negative_frequencies = 1-positive_frequencies\n\n ### END CODE HERE ###\n return positive_frequencies, negative_frequencies","def predict_epistemic(self, x):\n with torch.no_grad():\n e = self.predict_evidence(x)\n\n a = e + self.prior\n return self.n_classes * self.prior / a.sum(-1, keepdim=True)","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)","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 totalRating(self):\r\n result = 0\r\n for v in self.votes:\r\n result += v.voteType.weight\r\n\r\n return result","def compute_sufficient_stats(self):\n self.counts = (np.sum(self.resp, axis=0) + 10e-30)\n # print(self.counts)\n for k in range(self.k):\n self.means[k] = np.sum(self.resp[n, k] * self.x[n] for n in range(self.n)) / self.counts[k]\n self.covars[k] = np.sum(self.resp[n, k] * (self.x[n] - self.means[k]) @ (self.x[n] - self.means[k]).T\n for n in range(self.n)) / self.counts[k]\n self.covars[k] = np.nan_to_num(self.covars[k])\n self.means[k] = np.nan_to_num(self.means[k])","def likelihood_weighting_estimate(self,var,e,n,sampling_weight='uniform'):\n\t\tncpt = self.variables[var].cpt\n\t\tncount = dict((value,0.0) for value in ncpt.values())\n\t\twsum = 0.0\n\t\tfor iter in xrange(n):\n (w,sample) = self.importance_sample(e,sampling_weight)\n assert all(sample[key]==value for (key,value) in e.iteritems())\n \n ncount[sample[var]] += w\n wsum += w\n if wsum==0: return 'Undefined'\n for value in ncount.iterkeys():\n ncount[value] = float(ncount[value])/float(wsum)\n return ncount","def get_relative_frequency_of_verbs(self): \n number_verbs_in_blob = count_words_in_blob_if_tag_meets_criteria(\n self.blob, is_verb)\n return float(number_verbs_in_blob) / len(self.blob.words)","def calculate_precision(targets, preds):\n intersection_foreground = targets * preds\n n_intersection_foreground = float(np.sum(intersection_foreground))\n n_preds = float(np.sum(preds))\n\n return n_intersection_foreground / (n_preds + 1e-7)","def produce_labels(y, return_stats=True):\n classes, inds, inv, counts = np.unique(y,\n return_index=True,\n return_inverse=True,\n return_counts=True)\n total_counts = np.sum(counts)\n counts = counts/float(total_counts)\n class_proportions = {clss: cnt for clss, cnt in zip(inv[inds], counts)}\n orig_classes = {new: old for new, old in zip(inv[inds], classes)}\n if return_stats:\n return inv, total_counts, class_proportions, orig_classes\n else:\n return inv","def pc_nproduced_avg(self) -> \"float\":\n return _beamforming_swig.randomsampler_sptr_pc_nproduced_avg(self)","def train(self, corpus):\n corpus = [w for s in corpus for w in s]\n self.words = Counter(corpus)\n self.letters = Counter()\n for word in corpus:\n self.letters.update(word)\n self.nwords = sum(self.words.values())\n self.nletters = sum(self.letters.values())\n # count(1) returns number of times 1 appears in the list\n self.a = list(self.words.values()).count(1) / self.nwords","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 get_relative_frequency_of_nouns(self):\n number_nouns_in_blob = count_words_in_blob_if_tag_meets_criteria(\n self.blob, is_noun)\n return float(number_nouns_in_blob) / len(self.blob.words)","def computeNucStats(trues, preds):\n\t#TP, TN, FP, FN\n\tcount = zeros(4)\n\tfor a in range(len(trues)):\n\t\tif (trues[a] == 'F') & (preds[a] == 'F'):\n\t\t\tcount[0] += 1\n\t\telif (trues[a] == 'N') & (preds[a] == 'N'):\n\t\t\tcount[1] += 1\n\t\telif (trues[a] == 'N') & (preds[a] == 'F'):\n\t\t\tcount[2] += 1\n\t\telif (trues[a] == 'F') & (preds[a] == 'N'):\n\t\t\tcount[3] += 1\n\treturn count","def learn_distributions(file_lists_by_category):\n ### TODO: Write your code here\n\n #get word frequncies in each email category\n #key:word, value: number of occurences in this email loader\n spam_dict = util.get_word_freq(file_lists_by_category[0])\n ham_dict = util.get_word_freq(file_lists_by_category[1])\n\n #get total length of each email loader\n spam_length = sum(spam_dict.values())\n ham_length = sum(ham_dict.values())\n\n #get the length of the dictionary: D\n dict_D = util.Counter()\n for key in spam_dict:\n dict_D[key] += spam_dict[key]\n for key in ham_dict:\n dict_D[key] += ham_dict[key]\n D = len(dict_D)\n\n spam_distribution = {}\n ham_distribution = {}\n #get the distributions of two email loaders\n for i in dict_D:\n spam_distribution[i] = (spam_dict[i] + 1) / (D + spam_length)\n\n for i in dict_D:\n ham_distribution[i] = (ham_dict[i] + 1) / (D + ham_length)\n #create the required tuple\n probabilities_by_category = (spam_distribution, ham_distribution)\n return probabilities_by_category","def percent_using_relevant_words_by_context_and_question(self):\n total_student_count = self.get_number_of_unique_students()\n\n question_context_count_list = self.students_using_relevant_words_by_context_and_question()\n\n question_context_percent_list = []\n for item in question_context_count_list:\n question_context_percent_list.append((item[0], item[1], item[2] / total_student_count))\n\n return question_context_percent_list","def pc_noutput_items_avg(self) -> \"float\":\n return _beamforming_swig.randomsampler_sptr_pc_noutput_items_avg(self)","def feature_prob(self, f, cat):\n if self.category_count(cat) == 0:\n return 0\n # The total number of times this feature appeared in this \n # category divided by the total number of items in this category\n pfc = self.feature_count(f, cat)\n pc = self.category_count(cat)\n return float(pfc)/pc"],"string":"[\n \"def predict_types(self, context, filter_types=None):\\n ngram_probs = self._get_ngram_probs(context, filter_types)\\n type_probs = defaultdict(lambda: 0)\\n for probs in ngram_probs:\\n for entity_type, prob in probs:\\n type_probs[entity_type] += prob/len(ngram_probs)\\n\\n result_probs = sorted(type_probs.items(), key=lambda x: x[1], reverse=True)\\n return result_probs\",\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 prob_t_N(genotype, base):\\n cnter = Counter(genotype)\\n return cnter.get(base, 0) * 1/len(genotype)\",\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 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 predictability(self):\\n temp = self.probs\\n for n in range(10):\\n temp = temp.dot(temp)\\n final = temp[0,:]\\n #Let's assume that all words have unique initial letters\\n probs = map(len, self.words)\\n probs = array(probs)\\n probs = (probs + self.probs.max(1)-1)/probs\\n return sum(final*probs)\",\n \"def get_type_stats(self):\\n if not self.fitted:\\n raise ValueError(\\\"Vocabulary hasn't been computed yet\\\")\\n\\n total_types = len(self.freqs)\\n known_types = len(self) - len(self.reserved)\\n return known_types, total_types, known_types / total_types\",\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 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 get_sample_weight(y):\\n class_counts = np.bincount(y)\\n class_weight = 1 / class_counts\\n sample_weight = class_weight[y]\\n sample_weight = sample_weight / sample_weight.sum() * len(y)\\n return sample_weight\",\n \"def predict_types_features(self, context):\\n ngram_probs = self._get_full_ngram_probs(context)\\n return ngram_probs\",\n \"def compute_proportions_from_predicted_labels(predictions, instance_weights, n_classes=2):\\n n_items = len(predictions)\\n if instance_weights is None:\\n instance_weights = np.ones(n_items)\\n class_counts = np.zeros(n_classes)\\n for c in range(n_classes):\\n items = np.array(predictions == c, dtype=bool)\\n class_counts[c] = np.sum(instance_weights[items])\\n proportions = class_counts / float(np.sum(class_counts))\\n return proportions\",\n \"def percent_frequencies(self):\\n word_count = 0\\n local = self.frequencies()\\n for key in local.keys():\\n i = local[key]\\n word_count += int(i)\\n for key in local.keys():\\n i = local[key]\\n percentage = float(i) / float(word_count)\\n local[key] = percentage\\n return local\",\n \"def calc_class_weights(self):\\n y = self.train_eval_data[\\\"sentiment\\\"]\\n self.class_weights = {}\\n classes = np.unique(y)\\n for cls in classes:\\n self.class_weights[cls] = len(y) / (len(classes) * (y == cls).sum())\",\n \"def percentage_common_types (corpus): \\n total = sum([t[1] for t in most_frequent(corpus)])\\n return percentage(total, corpus_length(corpus))\",\n \"def precision(y, ypred):\\n return len(set(y).intersection(set(ypred))) / len(ypred)\",\n \"def predict(self,x):\\n preds = [tree.predict(x) for tree in self.forest]\\n if self.classify:\\n cls_counts = [0] * self.param['numClasses']\\n for p in preds:\\n cls_counts[p] += 1\\n return argmax(cls_counts)\\n else:\\n return sum(preds) / (len(preds)*1.0)\",\n \"def get_sample_weights(self):\\n target_to_weight = {}\\n for target, count in self.class_count.items():\\n target_to_weight[target] = self.total / count\\n\\n sample_weights = []\\n for _, target in self.imgs:\\n sample_weights.append(target_to_weight[target])\\n\\n return sample_weights\",\n \"def prob(self, w):\\n return self.counts[w] / self.total_count\",\n \"def calc_feature_probs(image_type, image_data, smoothing):\\n counts = np.array([np.sum(image_data.features[image_data.labels == value], axis=0) + smoothing for value in range(image_type.categories)])\\n denoms = np.array([np.count_nonzero(image_data.labels == value) + (smoothing * image_type.feature_kinds) for value in range(image_type.categories)])\\n return counts / denoms[:, np.newaxis, np.newaxis]\",\n \"def predict_types_full(self, context):\\n ngram_probs = self._get_ngram_probs(context)\\n return self._hierachical_sum_output(ngram_probs)\",\n \"def probabilities(self):\\n raise NotImplementedError\",\n \"def class_weights(self):\\n target_list = self.label\\n count_dict = Counter(target_list)\\n class_count = [count_dict[i] for i in range(3)]\\n class_weights = len(target_list) / torch.tensor(class_count, dtype=torch.float)\\n class_weights = class_weights / class_weights.sum()\\n print(class_weights) # noqa: T001\\n return class_weights\",\n \"def get_probs(self, *vars):\\n freqs = self.freq_counts([self.data.get_column_view(v)[0] for v in vars], [len(v.values) for v in vars])\\n k = np.prod([len(v.values) for v in vars])\\n return (freqs + self.alpha) / (np.sum(freqs) + self.alpha*k)\",\n \"def compute_class_freqs(gen):\\r\\n labels = gen.labels\\r\\n N = labels.shape[0]\\r\\n positive_frequencies = np.sum(labels, axis=0) / N\\r\\n negative_frequencies = np.sum(1 - labels, axis=0) / N\\r\\n return positive_frequencies, negative_frequencies\",\n \"def probability(self, samples):\\n pass\",\n \"def prob(self, doc, cat):\\n catprob = self.category_count(cat) / self.total_count() # Pr(Category)\\n docprob = self.doc_prob(doc, cat) # Pr(Document | Category)\\n return docprob*Decimal(str(catprob)) # Pr(Category | Document)\",\n \"def calc_prob(data):\\n total = len(data)\\n frequencies = sorted(Counter(data).items())\\n probabilities = OrderedDict()\\n for (key, value) in frequencies:\\n probabilities[key] = value / total\\n return probabilities\",\n \"def test_get_tax_return_frequencies(self):\\n pass\",\n \"def get_load_factor(self):\\n # Your code here\\n return self.count/len(self.data)\",\n \"def doc_prob(self, doc, cat):\\n features = self.get_features(doc) \\n # Multiply the probabilities of all the features together\\n p = Decimal(1)\\n for f in features:\\n p *= Decimal(str(self.weighted_prob(f, cat, self.feature_prob))) \\n return p\",\n \"def get_proportion_of_success(dataset):\\n rdd1 = dataset.map(lambda rec: (len(get_words(rec['title']))\\n if 'title' in rec.keys() else 0,\\n (1 if rec['points'] > 200 else 0, 1)))\\n\\n rdd2 = rdd1.reduceByKey(lambda a, b: (a[0] + b[0], a[1] + b[1]))\\n\\n prop_per_title_length_rdd = rdd2.map(lambda title_scores: (\\n title_scores[0], title_scores[1][0]/title_scores[1][1]))\\n return prop_per_title_length_rdd\",\n \"def _proba(y):\\n N = len(y)\\n _, counts = np.unique(y, return_counts=True)\\n return counts / N\",\n \"def sampling_ratio(self):\\n return self.coincidences / self.n\",\n \"def get_precision(y_true, y_pred):\\n model_entities_filter = (y_pred != 3).astype(\\\"int\\\") # of the words our model say has a NER class\\n precision_correct_entities = (y_pred[np.where(model_entities_filter)] == y_true[np.where(model_entities_filter)]).astype(\\\"int\\\")\\n precision = np.sum(precision_correct_entities)/np.sum(model_entities_filter) \\n return precision\",\n \"def sampler_weights(dataset):\\n class_counts = [0, 0]\\n for index in range(len(dataset)):\\n _, label = dataset[index]\\n class_counts[label] += 1\\n\\n divisor = 2 * class_counts[0] * class_counts[1]\\n sample_weights = (class_counts[1] / divisor, class_counts[0] / divisor)\\n weights = []\\n for index in range(len(dataset)):\\n _, label = dataset[index]\\n weights.append(sample_weights[label])\\n\\n num_samples = 2 * min(class_counts[0], class_counts[1])\\n return weights, num_samples\",\n \"def raw_unigram_probability(self, unigram):\\n result = 0.0\\n result = self.unigramcounts[unigram]/self.total\\n\\n #hint: recomputing the denominator every time the method is called\\n # can be slow! You might want to compute the total number of words once, \\n # store in the TrigramModel instance, and then re-use it. \\n\\n\\n return result\",\n \"def sample_count(self):\",\n \"def precision(y, model):\\n\\n\\tTP, FP, TN, FN = TRUE_FALSE_PREDICTIONS(y, model)\\n\\tprecision = TP/(TP+FP)\\n\\treturn precision\",\n \"def GetProportion(self):\\r\\n\\r\\n return self.proportion\",\n \"def test_on(self, examples):\\n stats = defaultdict(int)\\n num_correct, num_examples = 0, 0\\n for filename, category in examples:\\n hypothesis = self.classify_doc(filename)[0]\\n if category == 'positive':\\n stats['total_real_pos'] += 1\\n elif category == 'negative':\\n stats['total_real_neg'] += 1\\n stats['total_examples'] += 1\\n if category == hypothesis:\\n if category == 'positive':\\n stats['pos_correctly_classified'] += 1\\n else:\\n stats['neg_correctly_classified'] += 1\\n num_correct += 1\\n else:\\n if category == 'positive' and hypothesis == 'negative':\\n stats['pos_classified_as_neg'] += 1\\n elif category == 'negative' and hypothesis == 'positive':\\n stats['neg_classified_as_pos'] += 1\\n num_examples += 1\\n\\n return ((float(num_correct) / float(num_examples)), stats)\",\n \"def specificity(confusion):\\n classes = len(confusion)\\n truth = 0\\n per = np.zeros((classes,))\\n # tru_confusion = np.zeros((2, 2))\\n\\n total = np.sum(confusion)\\n for i in range(len(confusion)):\\n tp = confusion[i][i]\\n fp = np.sum(confusion[:, i]) - tp\\n fn = np.sum(confusion[i]) - tp\\n tn = total - tp - fp - fn\\n\\n # tru_confusion[0][0] = tp\\n # tru_confusion[1][0] = fp\\n # tru_confusion[0][1] = fn\\n # tru_confusion[1][1] = tn\\n\\n per[i] = tn/(tn + fp)\\n\\n return per\",\n \"def percent_unique_ngrams_in_train(train_ngrams_dict, gen_ngrams_dict):\\n\\n # *Total* number of n-grams produced by the generator.\\n total_ngrams_produced = 0\\n\\n for _, value in gen_ngrams_dict.iteritems():\\n total_ngrams_produced += value\\n\\n # The unique ngrams in the training set.\\n unique_ngrams_in_train = 0.\\n\\n for key, _ in gen_ngrams_dict.iteritems():\\n if key in train_ngrams_dict:\\n unique_ngrams_in_train += 1\\n return float(unique_ngrams_in_train) / float(total_ngrams_produced)\",\n \"def prob(throw, n, d=6, type='classical'):\\n count = 0\\n table = throw_table(n, d, type)\\n for t in table:\\n if sum(t) == throw:\\n count += 1\\n \\n return float(count)/len(table)\",\n \"def prob1(n):\\n#raise NotImplementedError(\\\"Problem 1 Incomplete\\\")\\n if n == 0 :\\n raise ValueError(\\\"Sampling 0 points is not defined.\\\")\\n total = 0\\n for i in xrange(n) :\\n if np.random.normal() > 3 :\\n total += 1\\n return float(total)/n\",\n \"def find_probabilities_of_labels(examples_set):\\n labelsCount = {\\n \\\"yes\\\": 0,\\n \\\"no\\\": 0\\n }\\n probOfLabels = list()\\n\\n if isinstance(examples_set[0], list):\\n totalCount = len(examples_set)\\n\\n for example in examples_set:\\n nextLabel = example[14]\\n labelsCount[nextLabel] += 1\\n\\n # There is only one example in the set\\n else:\\n totalCount = 1\\n nextLabel = examples_set[14]\\n labelsCount[nextLabel] += 1\\n\\n for label in labelsCount.keys():\\n labelProbability = (labelsCount[label] / totalCount)\\n probOfLabels.append(labelProbability)\\n\\n return probOfLabels\",\n \"def _cal_label_distribution(self):\\n if self.split == 'train':\\n self.label_weights = np.zeros(21, dtype=np.float32)\\n for label_list in self.label:\\n self.label_weights += np.histogram(label_list, range(22))[0]\\n self.label_weights /= np.sum(self.label_weights)\\n print(\\\"per class weight:\\\", self.label_weights)\\n self.label_weights = 1. / np.log(1.2 + self.label_weights)\\n print(\\\"np.log(1.2 + self.label_weights):\\\", self.label_weights)\\n elif self.split == 'test':\\n self.label_weights = np.ones(21)\\n return self.label_weights.tolist()\",\n \"def cost(books):\\n\\n num_types = len(set(books))\\n assert num_types < 6, \\\"Discounts indeterminate\\\"\\n return DISCOUNT_TABLE.get(num_types, 0) * 8 * len(books) * 100\",\n \"def raw_unigram_probability(self, unigram):\\n\\n #hint: recomputing the denominator every time the method is called\\n # can be slow! You might want to compute the total number of words once, \\n # store in the TrigramModel instance, and then re-use it.\\n num = self.unigramcounts[unigram]\\n den = self.word_count\\n return num/den\",\n \"def raw_freq(*marginals):\\n return float(marginals[NGRAM]) / marginals[TOTAL]\",\n \"def number_types(corpus):\\n number_of_types = len(set(corpus))\\n return number_of_types\",\n \"def sentence_probability(self, sentence, ngram_type=1):\\n sentence_word_list = sentence.lower().split()\\n prob = 0 # sentence probability\\n if ngram_type == 1:\\n for i in range(len(sentence_word_list)):\\n prob = prob + self.n_gram_MLE(sentence_word_list[i], gram_type=1)\\n\\n if ngram_type == 2:\\n for i in range(len(sentence_word_list)):\\n if i >= len(sentence_word_list) - 1:\\n break\\n prob = prob + self.n_gram_MLE(sentence_word_list[i],\\n sentence_word_list[i] + ' ' + sentence_word_list[i + 1], gram_type=2)\\n\\n if ngram_type == 3:\\n for i in range(len(sentence_word_list)):\\n if i >= len(sentence_word_list) - 2:\\n break\\n prob = prob + self.n_gram_MLE(sentence_word_list[i] + ' ' + sentence_word_list[i + 1],\\n sentence_word_list[i] + ' ' + sentence_word_list[i + 1] + ' ' +\\n sentence_word_list[i + 2], gram_type=3)\\n\\n if ngram_type == 4:\\n for i in range(len(sentence_word_list)):\\n if i >= len(sentence_word_list) - 3:\\n break\\n prob = prob + self.n_gram_MLE(sentence_word_list[i] + ' ' + sentence_word_list[i + 1] + ' ' +\\n sentence_word_list[i + 2],\\n sentence_word_list[i] + ' ' + sentence_word_list[i + 1] + ' ' +\\n sentence_word_list[i + 2] + sentence_word_list[i + 3], gram_type=4)\\n\\n if ngram_type == 5:\\n for i in range(len(sentence_word_list)):\\n if i >= len(sentence_word_list) - 4:\\n break\\n prob = prob + self.n_gram_MLE(sentence_word_list[i] + ' ' + sentence_word_list[i + 1] + ' ' +\\n sentence_word_list[i + 2] + sentence_word_list[i + 3],\\n sentence_word_list[i] + ' ' + sentence_word_list[i + 1] + ' ' +\\n sentence_word_list[i + 2] + sentence_word_list[i + 3] +\\n sentence_word_list[i + 4], gram_type=5)\\n\\n return prob\",\n \"def get_pertinence (cats):\\n sorted_cats = sorted(cats, key=cats.__getitem__, reverse=True)\\n score_to_test = cats[sorted_cats[0]]\\n all_values = [cats[key] for key in sorted_cats]\\n average = sum(all_values) / len(all_values)\\n logged_rest = [log(abs(average - val) + 1) for val in all_values[1:]]\\n \\n rest_average = sum(logged_rest) / len(logged_rest)\\n logged_main = log(abs(average - all_values[0])+1)\\n \\n importance = max(logged_main - rest_average, 0)\\n \\n return importance\",\n \"def main():\\n x, y = create_simple_classification_dataset(5)\\n count = 0\\n for i in y:\\n if i[0] == 0:\\n count += 1\\n print('percent of zeros', count / len(y)) # confirm that the distribution isn't too skewed.\",\n \"def sample_equal_proportion(y, proportion=0.667, random_state=None):\\n # Set random_state\\n if random_state is not None:\\n np.random.seed(random_state)\\n\\n # calculate number of observations\\n n_obs = len(y)\\n\\n # identify index number for class1 and class2\\n index_class1 = np.where(y == 0)[0]\\n index_class2 = np.where(y == 1)[0]\\n\\n # calculate number of class1 and class2 observations\\n n_class1 = len(index_class1)\\n n_class2 = len(index_class2)\\n\\n # calculate number of class1 and class2 observations in the train set\\n n_class1_train = int(np.round(n_class1 * proportion))\\n n_class2_train = int(np.round(n_class2 * proportion))\\n\\n # generate indices for class1 and class2 observations in the train set\\n index_class1_train = np.random.choice(index_class1, size=n_class1_train, replace=False)\\n index_class2_train = np.random.choice(index_class2, size=n_class2_train, replace=False)\\n index_train = list(np.append(index_class1_train, index_class2_train))\\n\\n # return a boolean vector of len n_obs where TRUE represents\\n # that observation should be in the train set\\n sequence = list(np.arange(n_obs))\\n index = np.array([True if i in index_train else False for i in sequence])\\n return index\",\n \"def administer(self):\\n\\n score = 0.0\\n for question in self.questions:\\n if question.ask_and_evaluate() is True:\\n score += 1\\n return (score / len(self.questions)) * 100\",\n \"def proportional_strategy(our_hist, their_hist):\\n if len(our_hist) == 0 or len(their_hist) == 0:\\n return choice(CHOICES)\\n freqs = count(their_hist)\\n prediction_for_them = choices(CHOICES, weights=freqs)[0]\\n return CHOICES[(prediction_for_them + 1) % 3]\",\n \"def specificity(confusion):\\n classes = range(confusion.shape[0])\\n num = (np.sum(confusion[classes]) - np.sum(confusion[classes], axis=0) -\\n np.sum(confusion[classes], axis=1) + confusion[classes, classes])\\n den = ((np.ones(confusion.shape[0]) * np.sum(confusion[classes])) -\\n np.sum(confusion[classes], axis=1))\\n return num / den\",\n \"def PredictBase(self, adjectives):\\n # Get the list of Adjectives which have sentiment polarity greater than 0.1\\n if self.smallReviews:\\n return 1.0\\n PolarAdjList = [l for l in adjectives if l in self.lexicon and math.fabs(float(self.lexicon[l])) > 0.1]\\n if len(PolarAdjList) > 0:\\n return 12.0/len(PolarAdjList)\\n # elif len(list2) < 8:\\n # return 2.0\\n else:\\n return 1.0\",\n \"def main(n_samples):\\n uso = usolib.uso.uar(N)\\n lst = [usolib.randomfacet.randomfacet_sample(uso, N) for i in range(n_samples)]\\n return sum(lst) / float(n_samples)\",\n \"def data_type_ratio(self):\\n if self.sample_size:\\n return float(self.match_count) / self.sample_size\\n return None\",\n \"def predict_one(self):\\n return (self.contexted.calc_p(\\\"\\\", self.seen + \\\"1\\\") /\\n float(self.contexted.calc_p(\\\"\\\", self.seen)))\",\n \"def distribution_of_result(clf_name, all, ids=None, print_res=True):\\n id_map = get_id_dict()\\n y_map = get_y_dict()\\n\\n if clf_name == 'svm':\\n clf_name = 'Pipeline'\\n else:\\n clf_name = type(get_base_learners(clf_name)).__name__\\n y_preds = load_testset_predictions(all)\\n\\n distr_count = dict()\\n distr_count['TP'] = Counter()\\n distr_count['FN'] = Counter()\\n distr_count['FP'] = Counter()\\n distr_count['TN'] = Counter()\\n\\n distr = {key: {source: [] for source in set([v for v in id_map.values()])} for key in ['TP', 'FN', 'FP', 'TN']}\\n\\n for index, row in y_preds.iterrows():\\n pred = row[clf_name]\\n tweet_id = row['tweet__id']\\n\\n source = id_map[tweet_id]\\n y = y_map[tweet_id]\\n\\n if ids is not None and tweet_id not in ids:\\n continue\\n\\n if y == pred and pred == 1:\\n distr_count['TP'][source] += 1\\n distr['TP'][source].append(tweet_id)\\n\\n elif y != pred and pred == 1:\\n distr_count['FP'][source] += 1\\n distr['FP'][source].append(tweet_id)\\n\\n elif y != pred and pred == 0:\\n distr_count['FN'][source] += 1\\n distr['FN'][source].append(tweet_id)\\n\\n else:\\n distr_count['TN'][source] += 1\\n distr['TN'][source].append(tweet_id)\\n\\n if print_res:\\n print(distr_count)\\n for key, values in distr.items():\\n print('{}:'.format(key))\\n for key2, values2 in distr[key].items():\\n print('\\\\t{}:'.format(key2))\\n print('\\\\t{}'.format(values2))\\n return distr_count, distr\",\n \"def _basic_probability(count: int, sequence_total_count: int) -> float:\\n return float(count) / sequence_total_count\",\n \"def num_training_examples(self):\",\n \"def n_train(self):\\n return self.factors[0].shape[0]\",\n \"def num_words():\\n # Load the GT.\\n df = pd.read_csv(config.META_FQN, sep=\\\"\\\\t\\\")\\n stats = {\\n \\\"T\\\": {\\\"words\\\": [], \\\"duration\\\": []},\\n \\\"P\\\": {\\\"words\\\": [], \\\"duration\\\": []},\\n \\\"sess\\\": {\\\"words\\\": [], \\\"duration\\\": []},\\n }\\n\\n for _, row in df.iterrows():\\n if row[\\\"asr_test\\\"]:\\n stats[\\\"P\\\"][\\\"words\\\"].append(float(row[\\\"gt_patient_num_words\\\"]))\\n stats[\\\"T\\\"][\\\"words\\\"].append(float(row[\\\"gt_therapist_num_words\\\"]))\\n stats[\\\"P\\\"][\\\"duration\\\"].append(float(row[\\\"gt_patient_time_spoken\\\"]))\\n stats[\\\"T\\\"][\\\"duration\\\"].append(\\n float(row[\\\"gt_therapist_time_spoken\\\"])\\n )\\n stats[\\\"sess\\\"][\\\"duration\\\"].append(float(row[\\\"sess_dur\\\"]))\\n n_words = (\\n row[\\\"gt_therapist_num_words\\\"] + row[\\\"gt_patient_num_words\\\"]\\n )\\n stats[\\\"sess\\\"][\\\"words\\\"].append(n_words)\\n\\n for speaker in stats:\\n for metric in stats[speaker]:\\n print(f\\\"------ {speaker} | {metric} ------\\\")\\n print_stats(stats[speaker][metric])\",\n \"def recall(y, ypred):\\n return len(set(y).intersection(set(ypred))) / len(y)\",\n \"def purity(y_true, y_pred, sample_weight=None):\\n if sample_weight is None:\\n sample_weight = np.ones_like(y_true)\\n TP = np.sum((y_pred) * y_true * sample_weight)\\n FP = np.sum((y_pred) * (y_true == 0) * sample_weight)\\n return TP / (TP + FP)\",\n \"def get_probabilidades_a_priori(self, y):\\r\\n \\r\\n classes = self.classes_\\r\\n probabilidades_a_priori = []\\r\\n for i in range(len(classes)): \\r\\n probabilidades_a_priori.append (len(y[y == classes[i]])/len(y))\\r\\n probabilidades_a_priori = np.array(probabilidades_a_priori)\\r\\n \\r\\n return probabilidades_a_priori\",\n \"def probability(self, item):\\n count = self.counter.get(item, 0)\\n if self.smoothing_dict:\\n smooth_count = self.smoothing_dict.get(count, count)\\n assert smooth_count > 0\\n return smooth_count / self.smooth_total\\n else:\\n return count / self.total\",\n \"def get_precision(self, y_true, y_pred):\\n model_entities_filter = (y_pred != 3).astype(\\\"int\\\") # of the words our model say has a NER class\\n precision_correct_entities = (y_pred[np.where(model_entities_filter)] == y_true[np.where(model_entities_filter)]).astype(\\\"int\\\")\\n precision = np.sum(precision_correct_entities)/np.sum(model_entities_filter)\\n return precision\",\n \"def _get_selection_probabilities(self):\\r\\n probabilities = np.arange(1, self.population_size+1, dtype=float)[::-1]\\r\\n probabilities /= probabilities.sum()\\r\\n return probabilities\",\n \"def priorProbabilities():\\r\\n\\ttotal = 0.0\\r\\n\\tpos = 0.0\\r\\n\\tneg = 0.0\\r\\n\\r\\n\\t# Count the amount of positives and negatives in the training data\\r\\n\\tfor item in trainingData:\\r\\n\\t\\ttotal += 1\\r\\n\\t\\tif item[1] == '0':\\r\\n\\t\\t\\tpos +=1\\r\\n\\t\\tif item[1] == '1':\\r\\n\\t\\t\\tneg +=1\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t\\r\\n\\t# Return the positive and negative probabilities \\r\\n\\tposProb = float(pos / total * 100)\\r\\n\\tnegProb = float(neg / total * 100)\\r\\n\\r\\n\\t\\r\\n\\t\\r\\n\\treturn posProb, negProb\",\n \"def get_percentage_false_class_for_resultset(results):\\n count_success = 0\\n count_correct_prediction = 0\\n for result in results:\\n if result[\\\"image_target\\\"] == result[\\\"prediction_image\\\"] and result[\\\"std_noise\\\"] != 0:\\n count_correct_prediction += 1\\n if result[\\\"success\\\"] == True:\\n count_success += 1\\n\\n error = stats.proportion.proportion_confint(count_success, count_correct_prediction, 0.05)\\n\\n return np.array([count_success/count_correct_prediction, error])\",\n \"def check_correctness_statistics(classifier_out, mode, image_type):\\n labels = image_type.image_data[mode].labels\\n num_correct = 0\\n total = len(classifier_out)\\n for index, label in classifier_out:\\n if labels[index] == label:\\n num_correct += 1\\n return (num_correct / total) * 100\",\n \"def raw_unigram_probability(self, unigram):\\n\\n assert len(unigram) == 1\\n count_unigram = self.unigramcounts[unigram]\\n if self.total_word_count == 0 :\\n return 1 / self.total_sentence_count\\n else :\\n return (count_unigram / self.total_word_count)\",\n \"def corpus_stats(self):\\n print(\\\"Number of sentences: {}\\\".format(len(self.corpus.sents())))\\n print(\\\"Token: {}\\\".format(len(self.corpus.words())))\\n types = FreqDist(self.corpus.words())\\n print(\\\"Types: {}\\\".format(len(types)))\",\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 get_num_classes(self):\",\n \"def calcProbability(self):\\n for attribute in self.attributes:\\n index = self.F2I[attribute]\\n features = set([self.train[i][0][index] for i in range(len(self.train))])\\n for feature in features:\\n #all the true and false\\n result_t = list(filter(lambda x: x[1]== True, self.train))\\n total_t = len(result_t)\\n result_f = list(filter(lambda x: x[1]== False, self.train))\\n total_f= len(result_f)\\n #the probability for the feature if its true or false\\n t = len(list(filter(lambda x: x[0][index] == feature, result_t)))\\n f = len(list(filter(lambda x: x[0][index] == feature, result_f)))\\n prob_yes= t/total_t\\n prob_no = f/total_f\\n #assign the probabilities to the dictionaries\\n self.probs_yes[(index,feature)] = prob_yes\\n self.probs_no[(index,feature)] = prob_no\",\n \"def ovo_test(dic, x_test, y_test, nb_classes):\\n TP = FP = TN = FN = 0\\n correct_predict = 0\\n for index, value in enumerate(x_test):\\n predict = {elem : 0 for elem in nb_classes}\\n for key in dic:\\n predict[key[0] if dic[key].predict([value]) else key[1]] += 1\\n predicted_value = max(predict.items(), key=operator.itemgetter(1))[0]\\n if predicted_value == y_test[index]:\\n correct_predict += 1\\n TP += 1\\n else:\\n FP += 1\\n \\n return correct_predict, TP, FP, TN, FN\",\n \"def compute_class_freqs(labels):\\n ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\\n \\n # total number of patients (rows)\\n N = len(labels)\\n \\n positive_frequencies = np.sum(labels,axis=0)/N\\n negative_frequencies = 1-positive_frequencies\\n\\n ### END CODE HERE ###\\n return positive_frequencies, negative_frequencies\",\n \"def predict_epistemic(self, x):\\n with torch.no_grad():\\n e = self.predict_evidence(x)\\n\\n a = e + self.prior\\n return self.n_classes * self.prior / a.sum(-1, keepdim=True)\",\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 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 totalRating(self):\\r\\n result = 0\\r\\n for v in self.votes:\\r\\n result += v.voteType.weight\\r\\n\\r\\n return result\",\n \"def compute_sufficient_stats(self):\\n self.counts = (np.sum(self.resp, axis=0) + 10e-30)\\n # print(self.counts)\\n for k in range(self.k):\\n self.means[k] = np.sum(self.resp[n, k] * self.x[n] for n in range(self.n)) / self.counts[k]\\n self.covars[k] = np.sum(self.resp[n, k] * (self.x[n] - self.means[k]) @ (self.x[n] - self.means[k]).T\\n for n in range(self.n)) / self.counts[k]\\n self.covars[k] = np.nan_to_num(self.covars[k])\\n self.means[k] = np.nan_to_num(self.means[k])\",\n \"def likelihood_weighting_estimate(self,var,e,n,sampling_weight='uniform'):\\n\\t\\tncpt = self.variables[var].cpt\\n\\t\\tncount = dict((value,0.0) for value in ncpt.values())\\n\\t\\twsum = 0.0\\n\\t\\tfor iter in xrange(n):\\n (w,sample) = self.importance_sample(e,sampling_weight)\\n assert all(sample[key]==value for (key,value) in e.iteritems())\\n \\n ncount[sample[var]] += w\\n wsum += w\\n if wsum==0: return 'Undefined'\\n for value in ncount.iterkeys():\\n ncount[value] = float(ncount[value])/float(wsum)\\n return ncount\",\n \"def get_relative_frequency_of_verbs(self): \\n number_verbs_in_blob = count_words_in_blob_if_tag_meets_criteria(\\n self.blob, is_verb)\\n return float(number_verbs_in_blob) / len(self.blob.words)\",\n \"def calculate_precision(targets, preds):\\n intersection_foreground = targets * preds\\n n_intersection_foreground = float(np.sum(intersection_foreground))\\n n_preds = float(np.sum(preds))\\n\\n return n_intersection_foreground / (n_preds + 1e-7)\",\n \"def produce_labels(y, return_stats=True):\\n classes, inds, inv, counts = np.unique(y,\\n return_index=True,\\n return_inverse=True,\\n return_counts=True)\\n total_counts = np.sum(counts)\\n counts = counts/float(total_counts)\\n class_proportions = {clss: cnt for clss, cnt in zip(inv[inds], counts)}\\n orig_classes = {new: old for new, old in zip(inv[inds], classes)}\\n if return_stats:\\n return inv, total_counts, class_proportions, orig_classes\\n else:\\n return inv\",\n \"def pc_nproduced_avg(self) -> \\\"float\\\":\\n return _beamforming_swig.randomsampler_sptr_pc_nproduced_avg(self)\",\n \"def train(self, corpus):\\n corpus = [w for s in corpus for w in s]\\n self.words = Counter(corpus)\\n self.letters = Counter()\\n for word in corpus:\\n self.letters.update(word)\\n self.nwords = sum(self.words.values())\\n self.nletters = sum(self.letters.values())\\n # count(1) returns number of times 1 appears in the list\\n self.a = list(self.words.values()).count(1) / self.nwords\",\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 get_relative_frequency_of_nouns(self):\\n number_nouns_in_blob = count_words_in_blob_if_tag_meets_criteria(\\n self.blob, is_noun)\\n return float(number_nouns_in_blob) / len(self.blob.words)\",\n \"def computeNucStats(trues, preds):\\n\\t#TP, TN, FP, FN\\n\\tcount = zeros(4)\\n\\tfor a in range(len(trues)):\\n\\t\\tif (trues[a] == 'F') & (preds[a] == 'F'):\\n\\t\\t\\tcount[0] += 1\\n\\t\\telif (trues[a] == 'N') & (preds[a] == 'N'):\\n\\t\\t\\tcount[1] += 1\\n\\t\\telif (trues[a] == 'N') & (preds[a] == 'F'):\\n\\t\\t\\tcount[2] += 1\\n\\t\\telif (trues[a] == 'F') & (preds[a] == 'N'):\\n\\t\\t\\tcount[3] += 1\\n\\treturn count\",\n \"def learn_distributions(file_lists_by_category):\\n ### TODO: Write your code here\\n\\n #get word frequncies in each email category\\n #key:word, value: number of occurences in this email loader\\n spam_dict = util.get_word_freq(file_lists_by_category[0])\\n ham_dict = util.get_word_freq(file_lists_by_category[1])\\n\\n #get total length of each email loader\\n spam_length = sum(spam_dict.values())\\n ham_length = sum(ham_dict.values())\\n\\n #get the length of the dictionary: D\\n dict_D = util.Counter()\\n for key in spam_dict:\\n dict_D[key] += spam_dict[key]\\n for key in ham_dict:\\n dict_D[key] += ham_dict[key]\\n D = len(dict_D)\\n\\n spam_distribution = {}\\n ham_distribution = {}\\n #get the distributions of two email loaders\\n for i in dict_D:\\n spam_distribution[i] = (spam_dict[i] + 1) / (D + spam_length)\\n\\n for i in dict_D:\\n ham_distribution[i] = (ham_dict[i] + 1) / (D + ham_length)\\n #create the required tuple\\n probabilities_by_category = (spam_distribution, ham_distribution)\\n return probabilities_by_category\",\n \"def percent_using_relevant_words_by_context_and_question(self):\\n total_student_count = self.get_number_of_unique_students()\\n\\n question_context_count_list = self.students_using_relevant_words_by_context_and_question()\\n\\n question_context_percent_list = []\\n for item in question_context_count_list:\\n question_context_percent_list.append((item[0], item[1], item[2] / total_student_count))\\n\\n return question_context_percent_list\",\n \"def pc_noutput_items_avg(self) -> \\\"float\\\":\\n return _beamforming_swig.randomsampler_sptr_pc_noutput_items_avg(self)\",\n \"def feature_prob(self, f, cat):\\n if self.category_count(cat) == 0:\\n return 0\\n # The total number of times this feature appeared in this \\n # category divided by the total number of items in this category\\n pfc = self.feature_count(f, cat)\\n pc = self.category_count(cat)\\n return float(pfc)/pc\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65732324","0.6433997","0.61022216","0.60917175","0.60802555","0.60519934","0.60124207","0.600027","0.5968741","0.5959954","0.59512043","0.594133","0.59163195","0.5904383","0.58761096","0.5872507","0.58418614","0.5835004","0.58155614","0.58092004","0.57744247","0.57586133","0.5752165","0.5742013","0.5721098","0.57205206","0.57137847","0.5691788","0.56665003","0.566453","0.5653953","0.5641743","0.5637472","0.5618631","0.5617799","0.56168693","0.5611684","0.5602568","0.5594698","0.559392","0.55868465","0.5585912","0.5548629","0.55469686","0.55411714","0.5535694","0.5533364","0.5524668","0.5515515","0.5504032","0.5500989","0.5495005","0.54854125","0.54630214","0.5440903","0.54396874","0.5438292","0.54365516","0.542608","0.54219985","0.54198754","0.5411043","0.54085463","0.54060143","0.5400143","0.5396018","0.53927684","0.53900975","0.5387231","0.53682196","0.5364313","0.53638667","0.53542763","0.5352325","0.5350704","0.53504026","0.5344352","0.53400564","0.53389686","0.53288174","0.5323402","0.5322723","0.53165454","0.5311542","0.5309932","0.5305886","0.53044903","0.52993745","0.52928996","0.5292858","0.5290208","0.52869254","0.5286847","0.5286364","0.5281552","0.527971","0.52787524","0.5272321","0.52717054","0.52715075","0.5270371"],"string":"[\n \"0.65732324\",\n \"0.6433997\",\n \"0.61022216\",\n \"0.60917175\",\n \"0.60802555\",\n \"0.60519934\",\n \"0.60124207\",\n \"0.600027\",\n \"0.5968741\",\n \"0.5959954\",\n \"0.59512043\",\n \"0.594133\",\n \"0.59163195\",\n \"0.5904383\",\n \"0.58761096\",\n \"0.5872507\",\n \"0.58418614\",\n \"0.5835004\",\n \"0.58155614\",\n \"0.58092004\",\n \"0.57744247\",\n \"0.57586133\",\n \"0.5752165\",\n \"0.5742013\",\n \"0.5721098\",\n \"0.57205206\",\n \"0.57137847\",\n \"0.5691788\",\n \"0.56665003\",\n \"0.566453\",\n \"0.5653953\",\n \"0.5641743\",\n \"0.5637472\",\n \"0.5618631\",\n \"0.5617799\",\n \"0.56168693\",\n \"0.5611684\",\n \"0.5602568\",\n \"0.5594698\",\n \"0.559392\",\n \"0.55868465\",\n \"0.5585912\",\n \"0.5548629\",\n \"0.55469686\",\n \"0.55411714\",\n \"0.5535694\",\n \"0.5533364\",\n \"0.5524668\",\n \"0.5515515\",\n \"0.5504032\",\n \"0.5500989\",\n \"0.5495005\",\n \"0.54854125\",\n \"0.54630214\",\n \"0.5440903\",\n \"0.54396874\",\n \"0.5438292\",\n \"0.54365516\",\n \"0.542608\",\n \"0.54219985\",\n \"0.54198754\",\n \"0.5411043\",\n \"0.54085463\",\n \"0.54060143\",\n \"0.5400143\",\n \"0.5396018\",\n \"0.53927684\",\n \"0.53900975\",\n \"0.5387231\",\n \"0.53682196\",\n \"0.5364313\",\n \"0.53638667\",\n \"0.53542763\",\n \"0.5352325\",\n \"0.5350704\",\n \"0.53504026\",\n \"0.5344352\",\n \"0.53400564\",\n \"0.53389686\",\n \"0.53288174\",\n \"0.5323402\",\n \"0.5322723\",\n \"0.53165454\",\n \"0.5311542\",\n \"0.5309932\",\n \"0.5305886\",\n \"0.53044903\",\n \"0.52993745\",\n \"0.52928996\",\n \"0.5292858\",\n \"0.5290208\",\n \"0.52869254\",\n \"0.5286847\",\n \"0.5286364\",\n \"0.5281552\",\n \"0.527971\",\n \"0.52787524\",\n \"0.5272321\",\n \"0.52717054\",\n \"0.52715075\",\n \"0.5270371\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":91798,"cells":{"query":{"kind":"string","value":"Vectorized wrapper function for mpmath.polylog()"},"document":{"kind":"string","value":"def _vpolylog(self, s: float, z: np.ndarray) -> np.ndarray:\n\n def _polylog(s, z_):\n return float(polylog(s, z_).real)\n\n return np.array([_polylog(s, z_) for z_ in z])"},"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 loglnumpy(store):\n xbeta = dot(store['xmat'], store['beta'])\n lamb = exp(xbeta)\n return sum(store['yvec'] * xbeta - lamb)","def IntegratePolynomialPartLogExt(poly, fieldTower):\n #print(poly)\n #print(poly.degree)\n #print(poly.fieldTower)\n if poly == 0 or poly.isZero():\n return Int.Integral()\n red = poly.reduceToLowestPossibleFieldTower()\n if red.fieldTower.towerHeight<fieldTower.towerHeight:\n return Integrate(red)\n p = poly.getCoefficients()\n l = len(p)-1\n q = [ZERO]*(len(p)+1)\n b = [ZERO]*(len(p)+1)\n d = [ZERO]*(len(p)+1)\n \n \n u = fieldTower.getLastExtension().argFunction # last fieldExtension with T=log(u)\n log_diff_u = u.logDifferentiate()#u.differentiate()/u # u'/u\n \n # p_l *T^l + p_(l-1)*T^(l-1) + ... + p_0 = (q_(l+1)*T^(l+1) + q_l*T^l + ... + q_0)' + (c_1 *v_1'/v_i + ... + c_m *v_m'/v_m)\n # (q_i*T^i)' = q_i'*T^i + q_i*i*T'*T^(i-1)\n # -> 0 = q_(l+1)'\n # p_l = (l+1)*q_(l+1)*T' + q_l'\n # ...\n # p_0 = q_1*T' + (qe_0)', qe_0 = q_0+(c_1 *log(v_1) + ... + c_m *log(v_m))\n for i in range(l,-1,-1):\n # q_(i+1) = d_(i+1) + b_(i+1)\n # integral(p_i-(i+1)*d_(i+1)*T') = l*b_(i+1)*T' + q_i\n #i = Rational.fromFloat(i)\n integrand = p[i]+(-ONE)*(i+1)*d[i+1]*log_diff_u\n if type(integrand)==float or type(integrand)==int:\n integrand = Rational.fromFloat(integrand)\n int_reduced = integrand.reduceToLowestPossibleFieldTower()\n if int_reduced!=None:\n integrand = int_reduced\n P_i = Integrate(integrand)\n if i>0:\n IntegratePolynomialPartLogExtCheckIntegralConditions(P_i, fieldTower)\n else:\n if P_i==None:\n raise Int.IntegralNotElementaryError()\n \n prev = fieldTower.prevTower()\n #logs = P_i.getNewLogExpressionsInFieldTower(prev,fieldTower)\n logTerm = P_i.getLogExpression(u)\n otherLogs = [log for log in P_i.logExpressions if not log==logTerm]#in logs]\n ci = ZERO if logTerm==None else logTerm.factor # integral = P_i = c_i*T+d_i, d_i = P_i\\logs\n d[i] = Int.Integral(poly_rationals=P_i.poly_rational_partExpressions,logs=otherLogs,rootSums=P_i.rootSums).asFunction()\n b[i+1] = ci/(i+1)\n q[i+1] = d[i+1]+b[i+1]\n \n #integrand = p[0]+(-1)*d[1]*log_diff_u\n #P0 = Integrate(integrand)\n #if P0==None:\n # raise Int.IntegralNotElementaryError()\n #b1 = 0\n #for log in P0.logExpressions:\n # if log.argFunction==u:\n # b1 = log.factor\n \n if b[1]==0:\n q_0 = P_i.asFunction()\n else:\n q_0 = (P_i+Int.Integral(logs=[Int.LogFunction(u,(-1)*b[1])])).asFunction()\n q[0] = q_0\n \n integralPoly = Pol.Polynomial(variable=fieldTower.getLastVariable())\n for i in range(l+1,-1,-1):\n integralPoly.setCoefficient(i,q[i], callUpdates=False)\n integralPoly.updateCoefficientsAll()\n \n return Int.Integral(poly_rationals=[integralPoly])","def get_log(p):\n if p==0:\n return 0.\n return p*np.log2(p)","def loglf2py(store):\n loglike=0.0\n return loglinear.logl(store['xb'],store['xmatf'], store['beta'],store['yvec'],loglike)","def logpow(x, m):\n # return m * log(x)\n return pt.switch(pt.eq(x, 0), pt.switch(pt.eq(m, 0), 0.0, -np.inf), m * pt.log(x))","def fit_poly(x, y, n=5, log=False):\n \n x_g = x\n x = np.ma.array(x, mask=y.mask).compressed()\n y = y.compressed()\n if log:\n yl = np.log10(y)\n else:\n yl = y\n fit = np.polyfit(x, yl, n)\n p = np.poly1d(fit)\n \n if log:\n return 10**(p(x_g))\n else:\n return p(x_g)","def __pow__(self, a: float) -> np.ndarray:\n return np.e**(a*self.logarithm)","def general_poly (L):\n def inside(x):\n result = 0\n pwr = len(L) - 1\n for l in L:\n result = result + l * x ** pwr\n pwr -= 1\n return result\n return inside","def general_poly(L):\n def evaluate(x):\n length=len(L)-1\n value=0\n for i in L:\n value+=i*(x**length)\n length-=1\n return value\n return evaluate","def logpow(x, m):\n # return m * log(x)\n return tt.switch(tt.eq(x, 0), -np.inf, m * tt.log(x))","def log2(a):","def ln(x):\n return log(x, const.e)","def polyval(p, x):\r\n val = 0\r\n ii = len(p) - 1\r\n for i in range(len(p) - 1):\r\n val += p[i] * (x ** ii)\r\n ii -= 1\r\n return val + p[-1]","def logpowerlaw(x, p=default()):\n xtr, ytr, gradtr = logcontinuity(p)\n power = p[3]\n x0 = xtr - power/gradtr\n b = ytr - power*np.log(xtr-x0)\n return b + power*np.log(x-x0)","def logsumexp(p):\n return scipy.misc.logsumexp(p) if (len(p) > 0) else -1e20","def log_p(self,z): \n return np.array([self.log_p_blanket(i) for i in z])","def log2(x):\n raise NotImplementedError","def logsumexp_trick(sum_term):\n max_term = np.max(sum_term)\n return max_term + np.log(np.sum(np.exp(sum_term-max_term)))","def logp(self, x):\n pass","def logit_transform(params, bounds):\n with np.errstate(divide=\"ignore\", invalid=\"ignore\"):\n ret_array = np.ma.array(\n [np.ma.log(np.true_divide((x - a), (b - x))) for x, (a, b) in zip(params, bounds)])\n ret_array.set_fill_value(0)\n return np.ma.filled(ret_array)","def linlogspace(start, stop, base=0.5, **kwargs) -> np.ndarray:\n p = (1 - np.logspace(0, 1, base=base, **kwargs)) * (1 / (1 - base))\n return (1 - p) * start + p * stop","def general_poly (L):\n def to_apply (x):\n n = 0\n for i in L:\n n = x*n + i\n return n\n return to_apply","def _poly_func(x, a, b, c, d, e):\n return a * x ** 6 + b * x ** 5 + c * x ** 4 + d * x ** 3 + e * x ** 2","def __pll(L,h,x, L2=0):\n if len(x.shape)>1: h = h.reshape(-1,1);\n pll = -np.log(1+np.exp(-2*x*(L.dot(x)+h))).sum(0)\n if L2>0: pll += L2*(L**2).sum()\n return pll","def polyval_vec(p, x, prec=None):\n p = np.atleast_2d(p)\n x = np.atleast_1d(x).flatten()\n # for modest to large arrays, faster to find unique values and\n # only evaluate those. Have to cast to float because np.unique\n # can't handle object types like python native int\n unq_x, xidx = np.unique(x, return_inverse=True)\n _, pidx, outidx = np.unique(\n p.astype(float), return_index=True, return_inverse=True, axis=0\n )\n unq_p = p[pidx]\n\n if prec is not None and prec > 18:\n # TODO: possibly multithread this bit\n mpmath.mp.dps = prec\n y = np.array([np.asarray(mpmath.polyval(list(pi), unq_x)) for pi in unq_p])\n else:\n npoly = unq_p.shape[0] # number of polynomials\n order = unq_p.shape[1] # order of polynomials\n nx = len(unq_x) # number of coordinates\n y = np.zeros((npoly, nx))\n\n for k in range(order):\n y = y * unq_x + np.atleast_2d(unq_p[:, k]).T\n\n return y[outidx][:, xidx].astype(float)","def log_multinomial_coefficient(n, x):\n return gammaln(n + 1) - gammaln(x + 1).sum()","def __call__(self, y, f):\n ll = self._loglike(y, f)\n return ll","def logrels(rets):\n return np.log(rets + 1)","def py_pow(x, p, op_version=None):\n return x ** p","def _loglike(self, y, f):\n bincoef = tf.lgamma(self.n + 1) - tf.lgamma(y + 1) \\\n - tf.lgamma(self.n - y + 1)\n ll = bincoef + y * tf.log(pos(f)) + (self.n - y) * tf.log(pos(1 - f))\n return ll","def loglog_interp(x,xp,fp):\n lx = np.log(x)\n lxp = np.log(xp)\n lfp = np.log(fp)\n return np.exp(np.interp(lx,lxp,lfp))","def logarithmic():\n return Equivalency(\n [(dimensionless_unscaled, function_units.dex, np.log10, lambda x: 10.0**x)],\n \"logarithmic\",\n )","def scipy_fun2(x):\n answer = 0.0\n for i in range(0, len(x)):\n answer += (math.pow(-1,i))*(math.pow((i+1),math.pow(x[i], (i+1))))\n return answer","def logp(self, F, Y):\n raise NotImplementedError(\"implement the logp function\\\n for this likelihood\")","def log(base, real):\n return math.log(real, base)","def logsumexp(logv):\n res = logzero()\n for val in logv:\n res = logsum_pair(res, val)\n return res","def general_poly (L):\r\n\r\n def secondFunc(x):\r\n total = 0\r\n listLength = len(L)-1\r\n for i in L:\r\n total += i * x**listLength\r\n listLength -= 1\r\n return(total)\r\n return secondFunc","def MvNormalLogp():\n cov = pt.matrix(\"cov\")\n cov.tag.test_value = floatX(np.eye(3))\n delta = pt.matrix(\"delta\")\n delta.tag.test_value = floatX(np.zeros((2, 3)))\n\n cholesky = Cholesky(lower=True, on_error=\"nan\")\n\n n, k = delta.shape\n n, k = f(n), f(k)\n chol_cov = cholesky(cov)\n diag = pt.diag(chol_cov)\n ok = pt.all(diag > 0)\n\n chol_cov = pt.switch(ok, chol_cov, pt.fill(chol_cov, 1))\n delta_trans = solve_lower(chol_cov, delta.T).T\n\n result = n * k * pt.log(f(2) * np.pi)\n result += f(2) * n * pt.sum(pt.log(diag))\n result += (delta_trans ** f(2)).sum()\n result = f(-0.5) * result\n logp = pt.switch(ok, result, -np.inf)\n\n def dlogp(inputs, gradients):\n (g_logp,) = gradients\n cov, delta = inputs\n\n g_logp.tag.test_value = floatX(1.0)\n n, k = delta.shape\n\n chol_cov = cholesky(cov)\n diag = pt.diag(chol_cov)\n ok = pt.all(diag > 0)\n\n chol_cov = pt.switch(ok, chol_cov, pt.fill(chol_cov, 1))\n delta_trans = solve_lower(chol_cov, delta.T).T\n\n inner = n * pt.eye(k) - pt.dot(delta_trans.T, delta_trans)\n g_cov = solve_upper(chol_cov.T, inner)\n g_cov = solve_upper(chol_cov.T, g_cov.T)\n\n tau_delta = solve_upper(chol_cov.T, delta_trans.T)\n g_delta = tau_delta.T\n\n g_cov = pt.switch(ok, g_cov, -np.nan)\n g_delta = pt.switch(ok, g_delta, -np.nan)\n\n return [-0.5 * g_cov * g_logp, -g_delta * g_logp]\n\n return OpFromGraph([cov, delta], [logp], grad_overrides=dlogp, inline=True)","def safelog(x):\n #return np.log(x)\n return np.log(np.clip(x,floor,np.inf))","def log1p(x):\n return Log1p().apply((x,))[0]","def make_ln_func(variable):\n def safe_ln_queryset(qs):\n \"\"\"Takes the natural log of a queryset's values and handles zeros\"\"\"\n vals = qs.values_list(variable, flat=True)\n ret = np.log(vals)\n ret[ret == -np.inf] = 0\n return ret\n return safe_ln_queryset","def kl(p, q):\n return np.sum(np.where(p != 0, p * np.log(p / q), 0))","def poly(x, coeffs):\n return np.sum([coeffs[i] * x ** i for i in range(len(coeffs))], axis=0)","def log_sum_exp(x):\n log_reduce_sum = P.ReduceSum()\n log = P.Log()\n exp = P.Exp()\n x_max = max(x.data)\n return log(log_reduce_sum(exp(x - x_max), 1)) + x_max","def eval_function_modlin(point, level_vector, index_vector):\n\n product = 1\n for (l, i, x) in izip(level_vector, index_vector, point):\n if l == 1 and i == 1:\n val = 1\n elif l > 1 and i == 1:\n if x >= 0 and x <= 2 ** (1 - l):\n val = 2 - 2 ** l * x\n else:\n val = 0\n elif l > 1 and i == 2 ** l - 1:\n if x >= 1 - 2 ** (1 - l) and x <= 1:\n val = 2 ** l * x + 1 - i\n else:\n val = 0\n else:\n val = __phi(x * 2 ** l - i)\n product *= val\n if product == 0:\n break\n return product","def logp(self, xs, ys, **kwargs):\n ind = np.isclose(self.predict(xs, **kwargs),ys)\n axis = tuple(range(1,len(xs.shape)))\n return np.log(np.prod(ind, axis=axis)) # default behavior","def safe_p_log_p(data):\n\n non_zero = data != 0\n result = numpy.zeros(data.shape, dtype=float)\n with numpy.errstate(invalid=\"raise\"):\n result[non_zero] = -data[non_zero] * numpy.log2(data[non_zero])\n return result","def log(x, base=math.e):\n return 0.0","def log2_inplace(a):","def nextpow2(x):\n return np.ceil(np.log2(np.abs(x)))","def structured_pow(x, y):\r\n # see decorator for function body\r","def add_polynomial_features(x, power):\n if type(power) is int and type(x) is np.ndarray:\n return np.concatenate([x**i for i in range(1, power+1)], axis=1)\n return None","def _xlogx(x):\n y = x.copy()\n if isinstance(y, sparse.csc_matrix) or isinstance(y, sparse.csr_matrix):\n z = y.data\n else:\n z = np.asarray(y) # ensure np.matrix converted to np.array\n nz = z.nonzero()\n z[nz] *= np.log2(z[nz])\n return y","def pow(q, p):\n return exp(ln(q)*p)","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 kl(p, q):\n p = np.asarray(p, dtype=float)\n q = np.asarray(q, dtype=float)\n\n return np.where(p != 0, p * np.log(p / q), 0).sum()","def logsumexp2(z):\n return logsumexp(z, axis=2)","def _loglike(self, y, f):\n ll = y * tf.log(pos(f)) + (1 - y) * tf.log(pos(1 - f))\n return ll","def lg(x: Union[int, float]) -> float:\n res = 0.0\n try:\n res = log(x, 2)\n except ValueError:\n pass\n return res","def log(self, base):\n\n\t\tvalues = map(lambda x: x > 0, self.val)\n\t\tif not all(values):\n\t\t\traise ValueError(\"Non-positive number encountered in log.\")\n\t\telse:\n\t\t\tval = np.array([np.math.log(v, base) for v in self.val])\n\t\t\tif len(self.der.shape):\n\t\t\t\tto_multiply = 1 / np.multiply(np.log(base), self.val)\n\t\t\t\tto_multiply = np.expand_dims(to_multiply, 1) if len(self.der.shape) > len(to_multiply.shape) else to_multiply\n\t\t\t\tder = np.multiply(to_multiply, self.der)\n\t\t\telse:\n\t\t\t\tder = None\n\t\treturn Var(val, der)","def kl(p, q):\n p = np.asarray(p, dtype=np.float)\n q = np.asarray(q, dtype=np.float)\n\n return np.sum(np.where(p != 0, p * np.log(p / q), 0))","def log2(self):\n return Factor().__build( VarSet(self.v) , np.log2(self.t) )","def poly_level(f):\n if poly_univariate_p(f):\n return 1\n else:\n return 1 + poly_level(poly_LC(f))","def _perplexity(self, X, log_w):\n return np.exp(-log_w/X.sum())","def log10(a):","def log_map(b, x):\n \"\"\"\n LOG_MAP The log map for n-spheres\n b is the base point (vector in R^n), norm(b)=1\n x is a point on the hypersphere (also a vector in R^n), norm(x)=1\n\n method can be 0 or 1:\n 0: hypersphere (e.g. quaternions)\n 1: dual quaternion\"\"\"\n\n if np.allclose(x, b):\n p = b\n else:\n theta = np.arccos(np.dot(b, x))\n alpha = np.arccos(\n (4 + np.linalg.norm(b + x) ** 2 - np.linalg.norm(x - b) ** 2) / (2. * 2. * np.linalg.norm(b + x)))\n p2 = (2. * (b + x)) / (np.linalg.norm(b + x) * np.cos(alpha)) - b\n p = b + ((p2 - b) / np.linalg.norm(p2 - b)) * theta\n\n return p","def safe_sum_p_log_p(a, base=None):\r\n flat = ravel(a)\r\n nz = take(flat, nonzero(flat)[0])\r\n logs = log(nz)\r\n if base:\r\n logs /= log(base)\r\n return sum(nz * logs, 0)","def diff_log(x):\n\n return np.diff(np.log(x)),np.log(x)[0]","def construct_poly(data, power):\n return np.power(data, power)","def poly_func(x):\n \n # Create the polynomial object\n f = np.poly1d([1, -2, -28, 28, 12, -26, 100])\n\n # Return the value of the polynomial\n return f(x) * 0.05","def _log_add(*values):\n x = max(values)\n if x > -np.inf:\n sum_diffs = 0\n for value in values:\n sum_diffs += 2 ** (value - x)\n return x + np.log2(sum_diffs)\n else:\n return x","def log(self): # just use base?\n return Factor().__build( VarSet(self.v) , np.log(self.t) )","def pow(x, y):\n return 0.0","def logpdf(x, a, b):\n with mp.extradps(5):\n a, b = _validate_a_b(a, b)\n x = mp.mpf(x)\n if x < 0 or x > 1:\n return -mp.inf\n return (_fun.xlogy(a - 1, x) + _fun.xlog1py(b - 1, -x)\n - _fun.logbeta(a, b))","def polyLS(pd, x, y, f, X, Y \\\n, coeff = [], xmc = [], ymc = [], ell = [], w = [], ELL = [], W = []) :\n xmc, ymc, ell, w, ELL, W = assignDefaults(x, y, xmc, ymc, ell, w, ELL, W)\n \n numP = int((pd + 1) * (pd + 2) / 2)\n \n if (len(xmc) == 1) and (len(ymc) == 1) :\n \n\n if coeff == [] :\n p = poly(x, y, pd)\n coeff = np.linalg.lstsq(p, f, rcond=None)[0]\n\n B = poly(X, Y, pd)\n approx = B.dot(coeff).flatten()\n coeff_copy = coeff\n \n else :\n \n approx = np.zeros(len(X), float)\n \n if coeff == [] :\n for i in range(len(xmc)) :\n IND = inSquare(x, y, xmc[i], ymc[i], ELL, W)\n if len(IND) < int(1.5 * numP) :\n raise ValueError(\"Not enough data for this polynomial \" \\\n + \"degree.\\nEither lower the polynomial degree or \" \\\n + \"decrease the number of subdivisions.\")\n p = poly(x[IND], y[IND], pd)\n lam = np.linalg.lstsq(p, f[IND], rcond=None)[0]\n coeff.append(lam)\n\n coeff_copy = coeff.copy()\n\n for i in range(len(xmc) - 1, -1, -1) :\n IND = inSquare(X, Y, xmc[i], ymc[i], ell, w)\n B = poly(X[IND], Y[IND], pd)\n lam = coeff.pop()\n approx[IND] = B.dot(lam).flatten()\n \n return approx, coeff_copy","def nlogp(n, p):\n return 0 if n == 0 else n * _np.log(max(p, 1e-8))","def levin(x):\n summ = 0\n for t, l in x: # for the time and length of each algorithm\n summ += l + np.log(t)\n return summ","def sum_log(*args):\n # if all(a == LOG_ZERO for a in args):\n # return LOG_ZERO\n a_max = np.max(args, 0)\n lsp = np.log(np.sum([np.exp(a - a_max) for a in args], 0))\n return a_max + lsp","def calc_F(self, peq):\n return self.dmat_d_.dot(np.log(peq))","def Log(A, B):\n return logm(inv(A).dot(B))","def KL(p, q):\n return np.sum(p * np.log(p / q))","def logsumexp(*args):\n res = args[0]\n for e in args[1:]:\n res = _logsumexp(res, e)\n return res","def vectorized_rounder():\n\n def f(num):\n if np.isnan(num):\n return np.nan\n else:\n return num // 10 ** (int(math.log(num, 10)))\n\n vf = np.vectorize(f)\n\n return(vf)","def logloss(y, p):\n\n p[p < EPS] = EPS\n p[p > 1 - EPS] = 1 - EPS\n return log_loss(y, p)","def __rpow__(self, other) -> 'MultiVector':\n\n # Let math.log() check that other is a Python number, not something\n # else.\n\n # pow(x, y) == exp(y * log(x))\n newMV = general_exp(math.log(other) * self)\n\n return newMV","def lagrange(x, w):\n M = len(x)\n p = poly1d(0.0)\n for j in xrange(M):\n pt = poly1d(w[j])\n for k in xrange(M):\n if k == j:\n continue\n fac = x[j]-x[k]\n pt *= poly1d([1.0, -x[k]])/fac\n p += pt\n return p","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 log_prob_from_logits(x):\n axis = len(x.shape) - 1\n m = x.max(dim=axis, keepdim=True)[0]\n return x - m - torch.log(torch.exp(x - m).sum(dim=axis, keepdim=True))","def mpf_log(x, prec, rnd=round_fast):\n sign, man, exp, bc = x\n #------------------------------------------------------------------\n # Handle special values\n if not man:\n if x == fzero: return fninf\n if x == finf: return finf\n if x == fnan: return fnan\n if sign:\n raise ComplexResult(\"logarithm of a negative number\")\n wp = prec + 20\n #------------------------------------------------------------------\n # Handle log(2^n) = log(n)*2.\n # Here we catch the only possible exact value, log(1) = 0\n if man == 1:\n if not exp:\n return fzero\n return from_man_exp(exp*ln2_fixed(wp), -wp, prec, rnd)\n mag = exp+bc\n abs_mag = abs(mag)\n #------------------------------------------------------------------\n # Handle x = 1+eps, where log(x) ~ x. We need to check for\n # cancellation when moving to fixed-point math and compensate\n # by increasing the precision. Note that abs_mag in (0, 1) <=>\n # 0.5 < x < 2 and x != 1\n if abs_mag <= 1:\n # Calculate t = x-1 to measure distance from 1 in bits\n tsign = 1-abs_mag\n if tsign:\n tman = (MPZ_ONE<<bc) - man\n else:\n tman = man - (MPZ_ONE<<(bc-1))\n tbc = bitcount(tman)\n cancellation = bc - tbc\n if cancellation > wp:\n t = normalize(tsign, tman, abs_mag-bc, tbc, tbc, 'n')\n return mpf_perturb(t, tsign, prec, rnd)\n else:\n wp += cancellation\n # TODO: if close enough to 1, we could use Taylor series\n # even in the AGM precision range, since the Taylor series\n # converges rapidly\n #------------------------------------------------------------------\n # Another special case:\n # n*log(2) is a good enough approximation\n if abs_mag > 10000:\n if bitcount(abs_mag) > wp:\n return from_man_exp(exp*ln2_fixed(wp), -wp, prec, rnd)\n #------------------------------------------------------------------\n # General case.\n # Perform argument reduction using log(x) = log(x*2^n) - n*log(2):\n # If we are in the Taylor precision range, choose magnitude 0 or 1.\n # If we are in the AGM precision range, choose magnitude -m for\n # some large m; benchmarking on one machine showed m = prec/20 to be\n # optimal between 1000 and 100,000 digits.\n if wp <= LOG_TAYLOR_PREC:\n m = log_taylor_cached(lshift(man, wp-bc), wp)\n if mag:\n m += mag*ln2_fixed(wp)\n else:\n optimal_mag = -wp//LOG_AGM_MAG_PREC_RATIO\n n = optimal_mag - mag\n x = mpf_shift(x, n)\n wp += (-optimal_mag)\n m = -log_agm(to_fixed(x, wp), wp)\n m -= n*ln2_fixed(wp)\n return from_man_exp(m, -wp, prec, rnd)","def logP(self):\n raise NotImplementedError","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 log_lhood(X, Z, Y, a, ep, lamb):\n \n K = Z.shape[1]\n N, T = X.shape\n \n # p(X)\n ZY = np.dot(Z,Y) \n log_pX = 0\n log_pX = log_pX + np.sum(X * np.log(1 - ((1 - lamb) ** ZY) * (1 - ep)))\n log_pX = log_pX + np.sum((1 - X) * np.log(((1 - lamb) ** ZY) * (1 - ep))) \n \n # p(Z)\n HN = 0\n for n in range(1, N+1):\n HN += 1.0/n\n m = Z.sum(axis=0)\n log_pZ = (K * np.log(a) - (a * HN)) + np.sum(gammaln(m) +\n gammaln(N - m + 1) - gammaln(N + 1)) \n\n return log_pZ + log_pX","def evaluate_poly(poly: Sequence[float], x: float) -> float:\n return sum(c * (x**i) for i, c in enumerate(poly))","def logp(self, value: TensorType, **kwargs) -> TensorType:","def logp(self, value: TensorType, **kwargs) -> TensorType:","def log_error(X, y, w):\r\n N = X.shape[0]\r\n J = np.sum(np.log(1.0 + np.exp(-y * (X @ w)))) / N\r\n return J","def logp_nojac(self, *args, **kwargs):\n return self.logp(*args, **kwargs)","def nll(x, a, b):\n x = _validate_x_bounds(x, low=0, high=1, strict_low=True, strict_high=True)\n return -mp.fsum([logpdf(t, a, b) for t in x])","def func_with_jvp(x):\n return mysum(pow2(mysin(x)))","def inverse_diff_log(y,log0):\n\n return np.exp(inverse_diff(y,log0))"],"string":"[\n \"def loglnumpy(store):\\n xbeta = dot(store['xmat'], store['beta'])\\n lamb = exp(xbeta)\\n return sum(store['yvec'] * xbeta - lamb)\",\n \"def IntegratePolynomialPartLogExt(poly, fieldTower):\\n #print(poly)\\n #print(poly.degree)\\n #print(poly.fieldTower)\\n if poly == 0 or poly.isZero():\\n return Int.Integral()\\n red = poly.reduceToLowestPossibleFieldTower()\\n if red.fieldTower.towerHeight<fieldTower.towerHeight:\\n return Integrate(red)\\n p = poly.getCoefficients()\\n l = len(p)-1\\n q = [ZERO]*(len(p)+1)\\n b = [ZERO]*(len(p)+1)\\n d = [ZERO]*(len(p)+1)\\n \\n \\n u = fieldTower.getLastExtension().argFunction # last fieldExtension with T=log(u)\\n log_diff_u = u.logDifferentiate()#u.differentiate()/u # u'/u\\n \\n # p_l *T^l + p_(l-1)*T^(l-1) + ... + p_0 = (q_(l+1)*T^(l+1) + q_l*T^l + ... + q_0)' + (c_1 *v_1'/v_i + ... + c_m *v_m'/v_m)\\n # (q_i*T^i)' = q_i'*T^i + q_i*i*T'*T^(i-1)\\n # -> 0 = q_(l+1)'\\n # p_l = (l+1)*q_(l+1)*T' + q_l'\\n # ...\\n # p_0 = q_1*T' + (qe_0)', qe_0 = q_0+(c_1 *log(v_1) + ... + c_m *log(v_m))\\n for i in range(l,-1,-1):\\n # q_(i+1) = d_(i+1) + b_(i+1)\\n # integral(p_i-(i+1)*d_(i+1)*T') = l*b_(i+1)*T' + q_i\\n #i = Rational.fromFloat(i)\\n integrand = p[i]+(-ONE)*(i+1)*d[i+1]*log_diff_u\\n if type(integrand)==float or type(integrand)==int:\\n integrand = Rational.fromFloat(integrand)\\n int_reduced = integrand.reduceToLowestPossibleFieldTower()\\n if int_reduced!=None:\\n integrand = int_reduced\\n P_i = Integrate(integrand)\\n if i>0:\\n IntegratePolynomialPartLogExtCheckIntegralConditions(P_i, fieldTower)\\n else:\\n if P_i==None:\\n raise Int.IntegralNotElementaryError()\\n \\n prev = fieldTower.prevTower()\\n #logs = P_i.getNewLogExpressionsInFieldTower(prev,fieldTower)\\n logTerm = P_i.getLogExpression(u)\\n otherLogs = [log for log in P_i.logExpressions if not log==logTerm]#in logs]\\n ci = ZERO if logTerm==None else logTerm.factor # integral = P_i = c_i*T+d_i, d_i = P_i\\\\logs\\n d[i] = Int.Integral(poly_rationals=P_i.poly_rational_partExpressions,logs=otherLogs,rootSums=P_i.rootSums).asFunction()\\n b[i+1] = ci/(i+1)\\n q[i+1] = d[i+1]+b[i+1]\\n \\n #integrand = p[0]+(-1)*d[1]*log_diff_u\\n #P0 = Integrate(integrand)\\n #if P0==None:\\n # raise Int.IntegralNotElementaryError()\\n #b1 = 0\\n #for log in P0.logExpressions:\\n # if log.argFunction==u:\\n # b1 = log.factor\\n \\n if b[1]==0:\\n q_0 = P_i.asFunction()\\n else:\\n q_0 = (P_i+Int.Integral(logs=[Int.LogFunction(u,(-1)*b[1])])).asFunction()\\n q[0] = q_0\\n \\n integralPoly = Pol.Polynomial(variable=fieldTower.getLastVariable())\\n for i in range(l+1,-1,-1):\\n integralPoly.setCoefficient(i,q[i], callUpdates=False)\\n integralPoly.updateCoefficientsAll()\\n \\n return Int.Integral(poly_rationals=[integralPoly])\",\n \"def get_log(p):\\n if p==0:\\n return 0.\\n return p*np.log2(p)\",\n \"def loglf2py(store):\\n loglike=0.0\\n return loglinear.logl(store['xb'],store['xmatf'], store['beta'],store['yvec'],loglike)\",\n \"def logpow(x, m):\\n # return m * log(x)\\n return pt.switch(pt.eq(x, 0), pt.switch(pt.eq(m, 0), 0.0, -np.inf), m * pt.log(x))\",\n \"def fit_poly(x, y, n=5, log=False):\\n \\n x_g = x\\n x = np.ma.array(x, mask=y.mask).compressed()\\n y = y.compressed()\\n if log:\\n yl = np.log10(y)\\n else:\\n yl = y\\n fit = np.polyfit(x, yl, n)\\n p = np.poly1d(fit)\\n \\n if log:\\n return 10**(p(x_g))\\n else:\\n return p(x_g)\",\n \"def __pow__(self, a: float) -> np.ndarray:\\n return np.e**(a*self.logarithm)\",\n \"def general_poly (L):\\n def inside(x):\\n result = 0\\n pwr = len(L) - 1\\n for l in L:\\n result = result + l * x ** pwr\\n pwr -= 1\\n return result\\n return inside\",\n \"def general_poly(L):\\n def evaluate(x):\\n length=len(L)-1\\n value=0\\n for i in L:\\n value+=i*(x**length)\\n length-=1\\n return value\\n return evaluate\",\n \"def logpow(x, m):\\n # return m * log(x)\\n return tt.switch(tt.eq(x, 0), -np.inf, m * tt.log(x))\",\n \"def log2(a):\",\n \"def ln(x):\\n return log(x, const.e)\",\n \"def polyval(p, x):\\r\\n val = 0\\r\\n ii = len(p) - 1\\r\\n for i in range(len(p) - 1):\\r\\n val += p[i] * (x ** ii)\\r\\n ii -= 1\\r\\n return val + p[-1]\",\n \"def logpowerlaw(x, p=default()):\\n xtr, ytr, gradtr = logcontinuity(p)\\n power = p[3]\\n x0 = xtr - power/gradtr\\n b = ytr - power*np.log(xtr-x0)\\n return b + power*np.log(x-x0)\",\n \"def logsumexp(p):\\n return scipy.misc.logsumexp(p) if (len(p) > 0) else -1e20\",\n \"def log_p(self,z): \\n return np.array([self.log_p_blanket(i) for i in z])\",\n \"def log2(x):\\n raise NotImplementedError\",\n \"def logsumexp_trick(sum_term):\\n max_term = np.max(sum_term)\\n return max_term + np.log(np.sum(np.exp(sum_term-max_term)))\",\n \"def logp(self, x):\\n pass\",\n \"def logit_transform(params, bounds):\\n with np.errstate(divide=\\\"ignore\\\", invalid=\\\"ignore\\\"):\\n ret_array = np.ma.array(\\n [np.ma.log(np.true_divide((x - a), (b - x))) for x, (a, b) in zip(params, bounds)])\\n ret_array.set_fill_value(0)\\n return np.ma.filled(ret_array)\",\n \"def linlogspace(start, stop, base=0.5, **kwargs) -> np.ndarray:\\n p = (1 - np.logspace(0, 1, base=base, **kwargs)) * (1 / (1 - base))\\n return (1 - p) * start + p * stop\",\n \"def general_poly (L):\\n def to_apply (x):\\n n = 0\\n for i in L:\\n n = x*n + i\\n return n\\n return to_apply\",\n \"def _poly_func(x, a, b, c, d, e):\\n return a * x ** 6 + b * x ** 5 + c * x ** 4 + d * x ** 3 + e * x ** 2\",\n \"def __pll(L,h,x, L2=0):\\n if len(x.shape)>1: h = h.reshape(-1,1);\\n pll = -np.log(1+np.exp(-2*x*(L.dot(x)+h))).sum(0)\\n if L2>0: pll += L2*(L**2).sum()\\n return pll\",\n \"def polyval_vec(p, x, prec=None):\\n p = np.atleast_2d(p)\\n x = np.atleast_1d(x).flatten()\\n # for modest to large arrays, faster to find unique values and\\n # only evaluate those. Have to cast to float because np.unique\\n # can't handle object types like python native int\\n unq_x, xidx = np.unique(x, return_inverse=True)\\n _, pidx, outidx = np.unique(\\n p.astype(float), return_index=True, return_inverse=True, axis=0\\n )\\n unq_p = p[pidx]\\n\\n if prec is not None and prec > 18:\\n # TODO: possibly multithread this bit\\n mpmath.mp.dps = prec\\n y = np.array([np.asarray(mpmath.polyval(list(pi), unq_x)) for pi in unq_p])\\n else:\\n npoly = unq_p.shape[0] # number of polynomials\\n order = unq_p.shape[1] # order of polynomials\\n nx = len(unq_x) # number of coordinates\\n y = np.zeros((npoly, nx))\\n\\n for k in range(order):\\n y = y * unq_x + np.atleast_2d(unq_p[:, k]).T\\n\\n return y[outidx][:, xidx].astype(float)\",\n \"def log_multinomial_coefficient(n, x):\\n return gammaln(n + 1) - gammaln(x + 1).sum()\",\n \"def __call__(self, y, f):\\n ll = self._loglike(y, f)\\n return ll\",\n \"def logrels(rets):\\n return np.log(rets + 1)\",\n \"def py_pow(x, p, op_version=None):\\n return x ** p\",\n \"def _loglike(self, y, f):\\n bincoef = tf.lgamma(self.n + 1) - tf.lgamma(y + 1) \\\\\\n - tf.lgamma(self.n - y + 1)\\n ll = bincoef + y * tf.log(pos(f)) + (self.n - y) * tf.log(pos(1 - f))\\n return ll\",\n \"def loglog_interp(x,xp,fp):\\n lx = np.log(x)\\n lxp = np.log(xp)\\n lfp = np.log(fp)\\n return np.exp(np.interp(lx,lxp,lfp))\",\n \"def logarithmic():\\n return Equivalency(\\n [(dimensionless_unscaled, function_units.dex, np.log10, lambda x: 10.0**x)],\\n \\\"logarithmic\\\",\\n )\",\n \"def scipy_fun2(x):\\n answer = 0.0\\n for i in range(0, len(x)):\\n answer += (math.pow(-1,i))*(math.pow((i+1),math.pow(x[i], (i+1))))\\n return answer\",\n \"def logp(self, F, Y):\\n raise NotImplementedError(\\\"implement the logp function\\\\\\n for this likelihood\\\")\",\n \"def log(base, real):\\n return math.log(real, base)\",\n \"def logsumexp(logv):\\n res = logzero()\\n for val in logv:\\n res = logsum_pair(res, val)\\n return res\",\n \"def general_poly (L):\\r\\n\\r\\n def secondFunc(x):\\r\\n total = 0\\r\\n listLength = len(L)-1\\r\\n for i in L:\\r\\n total += i * x**listLength\\r\\n listLength -= 1\\r\\n return(total)\\r\\n return secondFunc\",\n \"def MvNormalLogp():\\n cov = pt.matrix(\\\"cov\\\")\\n cov.tag.test_value = floatX(np.eye(3))\\n delta = pt.matrix(\\\"delta\\\")\\n delta.tag.test_value = floatX(np.zeros((2, 3)))\\n\\n cholesky = Cholesky(lower=True, on_error=\\\"nan\\\")\\n\\n n, k = delta.shape\\n n, k = f(n), f(k)\\n chol_cov = cholesky(cov)\\n diag = pt.diag(chol_cov)\\n ok = pt.all(diag > 0)\\n\\n chol_cov = pt.switch(ok, chol_cov, pt.fill(chol_cov, 1))\\n delta_trans = solve_lower(chol_cov, delta.T).T\\n\\n result = n * k * pt.log(f(2) * np.pi)\\n result += f(2) * n * pt.sum(pt.log(diag))\\n result += (delta_trans ** f(2)).sum()\\n result = f(-0.5) * result\\n logp = pt.switch(ok, result, -np.inf)\\n\\n def dlogp(inputs, gradients):\\n (g_logp,) = gradients\\n cov, delta = inputs\\n\\n g_logp.tag.test_value = floatX(1.0)\\n n, k = delta.shape\\n\\n chol_cov = cholesky(cov)\\n diag = pt.diag(chol_cov)\\n ok = pt.all(diag > 0)\\n\\n chol_cov = pt.switch(ok, chol_cov, pt.fill(chol_cov, 1))\\n delta_trans = solve_lower(chol_cov, delta.T).T\\n\\n inner = n * pt.eye(k) - pt.dot(delta_trans.T, delta_trans)\\n g_cov = solve_upper(chol_cov.T, inner)\\n g_cov = solve_upper(chol_cov.T, g_cov.T)\\n\\n tau_delta = solve_upper(chol_cov.T, delta_trans.T)\\n g_delta = tau_delta.T\\n\\n g_cov = pt.switch(ok, g_cov, -np.nan)\\n g_delta = pt.switch(ok, g_delta, -np.nan)\\n\\n return [-0.5 * g_cov * g_logp, -g_delta * g_logp]\\n\\n return OpFromGraph([cov, delta], [logp], grad_overrides=dlogp, inline=True)\",\n \"def safelog(x):\\n #return np.log(x)\\n return np.log(np.clip(x,floor,np.inf))\",\n \"def log1p(x):\\n return Log1p().apply((x,))[0]\",\n \"def make_ln_func(variable):\\n def safe_ln_queryset(qs):\\n \\\"\\\"\\\"Takes the natural log of a queryset's values and handles zeros\\\"\\\"\\\"\\n vals = qs.values_list(variable, flat=True)\\n ret = np.log(vals)\\n ret[ret == -np.inf] = 0\\n return ret\\n return safe_ln_queryset\",\n \"def kl(p, q):\\n return np.sum(np.where(p != 0, p * np.log(p / q), 0))\",\n \"def poly(x, coeffs):\\n return np.sum([coeffs[i] * x ** i for i in range(len(coeffs))], axis=0)\",\n \"def log_sum_exp(x):\\n log_reduce_sum = P.ReduceSum()\\n log = P.Log()\\n exp = P.Exp()\\n x_max = max(x.data)\\n return log(log_reduce_sum(exp(x - x_max), 1)) + x_max\",\n \"def eval_function_modlin(point, level_vector, index_vector):\\n\\n product = 1\\n for (l, i, x) in izip(level_vector, index_vector, point):\\n if l == 1 and i == 1:\\n val = 1\\n elif l > 1 and i == 1:\\n if x >= 0 and x <= 2 ** (1 - l):\\n val = 2 - 2 ** l * x\\n else:\\n val = 0\\n elif l > 1 and i == 2 ** l - 1:\\n if x >= 1 - 2 ** (1 - l) and x <= 1:\\n val = 2 ** l * x + 1 - i\\n else:\\n val = 0\\n else:\\n val = __phi(x * 2 ** l - i)\\n product *= val\\n if product == 0:\\n break\\n return product\",\n \"def logp(self, xs, ys, **kwargs):\\n ind = np.isclose(self.predict(xs, **kwargs),ys)\\n axis = tuple(range(1,len(xs.shape)))\\n return np.log(np.prod(ind, axis=axis)) # default behavior\",\n \"def safe_p_log_p(data):\\n\\n non_zero = data != 0\\n result = numpy.zeros(data.shape, dtype=float)\\n with numpy.errstate(invalid=\\\"raise\\\"):\\n result[non_zero] = -data[non_zero] * numpy.log2(data[non_zero])\\n return result\",\n \"def log(x, base=math.e):\\n return 0.0\",\n \"def log2_inplace(a):\",\n \"def nextpow2(x):\\n return np.ceil(np.log2(np.abs(x)))\",\n \"def structured_pow(x, y):\\r\\n # see decorator for function body\\r\",\n \"def add_polynomial_features(x, power):\\n if type(power) is int and type(x) is np.ndarray:\\n return np.concatenate([x**i for i in range(1, power+1)], axis=1)\\n return None\",\n \"def _xlogx(x):\\n y = x.copy()\\n if isinstance(y, sparse.csc_matrix) or isinstance(y, sparse.csr_matrix):\\n z = y.data\\n else:\\n z = np.asarray(y) # ensure np.matrix converted to np.array\\n nz = z.nonzero()\\n z[nz] *= np.log2(z[nz])\\n return y\",\n \"def pow(q, p):\\n return exp(ln(q)*p)\",\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 kl(p, q):\\n p = np.asarray(p, dtype=float)\\n q = np.asarray(q, dtype=float)\\n\\n return np.where(p != 0, p * np.log(p / q), 0).sum()\",\n \"def logsumexp2(z):\\n return logsumexp(z, axis=2)\",\n \"def _loglike(self, y, f):\\n ll = y * tf.log(pos(f)) + (1 - y) * tf.log(pos(1 - f))\\n return ll\",\n \"def lg(x: Union[int, float]) -> float:\\n res = 0.0\\n try:\\n res = log(x, 2)\\n except ValueError:\\n pass\\n return res\",\n \"def log(self, base):\\n\\n\\t\\tvalues = map(lambda x: x > 0, self.val)\\n\\t\\tif not all(values):\\n\\t\\t\\traise ValueError(\\\"Non-positive number encountered in log.\\\")\\n\\t\\telse:\\n\\t\\t\\tval = np.array([np.math.log(v, base) for v in self.val])\\n\\t\\t\\tif len(self.der.shape):\\n\\t\\t\\t\\tto_multiply = 1 / np.multiply(np.log(base), self.val)\\n\\t\\t\\t\\tto_multiply = np.expand_dims(to_multiply, 1) if len(self.der.shape) > len(to_multiply.shape) else to_multiply\\n\\t\\t\\t\\tder = np.multiply(to_multiply, self.der)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tder = None\\n\\t\\treturn Var(val, der)\",\n \"def kl(p, q):\\n p = np.asarray(p, dtype=np.float)\\n q = np.asarray(q, dtype=np.float)\\n\\n return np.sum(np.where(p != 0, p * np.log(p / q), 0))\",\n \"def log2(self):\\n return Factor().__build( VarSet(self.v) , np.log2(self.t) )\",\n \"def poly_level(f):\\n if poly_univariate_p(f):\\n return 1\\n else:\\n return 1 + poly_level(poly_LC(f))\",\n \"def _perplexity(self, X, log_w):\\n return np.exp(-log_w/X.sum())\",\n \"def log10(a):\",\n \"def log_map(b, x):\\n \\\"\\\"\\\"\\n LOG_MAP The log map for n-spheres\\n b is the base point (vector in R^n), norm(b)=1\\n x is a point on the hypersphere (also a vector in R^n), norm(x)=1\\n\\n method can be 0 or 1:\\n 0: hypersphere (e.g. quaternions)\\n 1: dual quaternion\\\"\\\"\\\"\\n\\n if np.allclose(x, b):\\n p = b\\n else:\\n theta = np.arccos(np.dot(b, x))\\n alpha = np.arccos(\\n (4 + np.linalg.norm(b + x) ** 2 - np.linalg.norm(x - b) ** 2) / (2. * 2. * np.linalg.norm(b + x)))\\n p2 = (2. * (b + x)) / (np.linalg.norm(b + x) * np.cos(alpha)) - b\\n p = b + ((p2 - b) / np.linalg.norm(p2 - b)) * theta\\n\\n return p\",\n \"def safe_sum_p_log_p(a, base=None):\\r\\n flat = ravel(a)\\r\\n nz = take(flat, nonzero(flat)[0])\\r\\n logs = log(nz)\\r\\n if base:\\r\\n logs /= log(base)\\r\\n return sum(nz * logs, 0)\",\n \"def diff_log(x):\\n\\n return np.diff(np.log(x)),np.log(x)[0]\",\n \"def construct_poly(data, power):\\n return np.power(data, power)\",\n \"def poly_func(x):\\n \\n # Create the polynomial object\\n f = np.poly1d([1, -2, -28, 28, 12, -26, 100])\\n\\n # Return the value of the polynomial\\n return f(x) * 0.05\",\n \"def _log_add(*values):\\n x = max(values)\\n if x > -np.inf:\\n sum_diffs = 0\\n for value in values:\\n sum_diffs += 2 ** (value - x)\\n return x + np.log2(sum_diffs)\\n else:\\n return x\",\n \"def log(self): # just use base?\\n return Factor().__build( VarSet(self.v) , np.log(self.t) )\",\n \"def pow(x, y):\\n return 0.0\",\n \"def logpdf(x, a, b):\\n with mp.extradps(5):\\n a, b = _validate_a_b(a, b)\\n x = mp.mpf(x)\\n if x < 0 or x > 1:\\n return -mp.inf\\n return (_fun.xlogy(a - 1, x) + _fun.xlog1py(b - 1, -x)\\n - _fun.logbeta(a, b))\",\n \"def polyLS(pd, x, y, f, X, Y \\\\\\n, coeff = [], xmc = [], ymc = [], ell = [], w = [], ELL = [], W = []) :\\n xmc, ymc, ell, w, ELL, W = assignDefaults(x, y, xmc, ymc, ell, w, ELL, W)\\n \\n numP = int((pd + 1) * (pd + 2) / 2)\\n \\n if (len(xmc) == 1) and (len(ymc) == 1) :\\n \\n\\n if coeff == [] :\\n p = poly(x, y, pd)\\n coeff = np.linalg.lstsq(p, f, rcond=None)[0]\\n\\n B = poly(X, Y, pd)\\n approx = B.dot(coeff).flatten()\\n coeff_copy = coeff\\n \\n else :\\n \\n approx = np.zeros(len(X), float)\\n \\n if coeff == [] :\\n for i in range(len(xmc)) :\\n IND = inSquare(x, y, xmc[i], ymc[i], ELL, W)\\n if len(IND) < int(1.5 * numP) :\\n raise ValueError(\\\"Not enough data for this polynomial \\\" \\\\\\n + \\\"degree.\\\\nEither lower the polynomial degree or \\\" \\\\\\n + \\\"decrease the number of subdivisions.\\\")\\n p = poly(x[IND], y[IND], pd)\\n lam = np.linalg.lstsq(p, f[IND], rcond=None)[0]\\n coeff.append(lam)\\n\\n coeff_copy = coeff.copy()\\n\\n for i in range(len(xmc) - 1, -1, -1) :\\n IND = inSquare(X, Y, xmc[i], ymc[i], ell, w)\\n B = poly(X[IND], Y[IND], pd)\\n lam = coeff.pop()\\n approx[IND] = B.dot(lam).flatten()\\n \\n return approx, coeff_copy\",\n \"def nlogp(n, p):\\n return 0 if n == 0 else n * _np.log(max(p, 1e-8))\",\n \"def levin(x):\\n summ = 0\\n for t, l in x: # for the time and length of each algorithm\\n summ += l + np.log(t)\\n return summ\",\n \"def sum_log(*args):\\n # if all(a == LOG_ZERO for a in args):\\n # return LOG_ZERO\\n a_max = np.max(args, 0)\\n lsp = np.log(np.sum([np.exp(a - a_max) for a in args], 0))\\n return a_max + lsp\",\n \"def calc_F(self, peq):\\n return self.dmat_d_.dot(np.log(peq))\",\n \"def Log(A, B):\\n return logm(inv(A).dot(B))\",\n \"def KL(p, q):\\n return np.sum(p * np.log(p / q))\",\n \"def logsumexp(*args):\\n res = args[0]\\n for e in args[1:]:\\n res = _logsumexp(res, e)\\n return res\",\n \"def vectorized_rounder():\\n\\n def f(num):\\n if np.isnan(num):\\n return np.nan\\n else:\\n return num // 10 ** (int(math.log(num, 10)))\\n\\n vf = np.vectorize(f)\\n\\n return(vf)\",\n \"def logloss(y, p):\\n\\n p[p < EPS] = EPS\\n p[p > 1 - EPS] = 1 - EPS\\n return log_loss(y, p)\",\n \"def __rpow__(self, other) -> 'MultiVector':\\n\\n # Let math.log() check that other is a Python number, not something\\n # else.\\n\\n # pow(x, y) == exp(y * log(x))\\n newMV = general_exp(math.log(other) * self)\\n\\n return newMV\",\n \"def lagrange(x, w):\\n M = len(x)\\n p = poly1d(0.0)\\n for j in xrange(M):\\n pt = poly1d(w[j])\\n for k in xrange(M):\\n if k == j:\\n continue\\n fac = x[j]-x[k]\\n pt *= poly1d([1.0, -x[k]])/fac\\n p += pt\\n return p\",\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 log_prob_from_logits(x):\\n axis = len(x.shape) - 1\\n m = x.max(dim=axis, keepdim=True)[0]\\n return x - m - torch.log(torch.exp(x - m).sum(dim=axis, keepdim=True))\",\n \"def mpf_log(x, prec, rnd=round_fast):\\n sign, man, exp, bc = x\\n #------------------------------------------------------------------\\n # Handle special values\\n if not man:\\n if x == fzero: return fninf\\n if x == finf: return finf\\n if x == fnan: return fnan\\n if sign:\\n raise ComplexResult(\\\"logarithm of a negative number\\\")\\n wp = prec + 20\\n #------------------------------------------------------------------\\n # Handle log(2^n) = log(n)*2.\\n # Here we catch the only possible exact value, log(1) = 0\\n if man == 1:\\n if not exp:\\n return fzero\\n return from_man_exp(exp*ln2_fixed(wp), -wp, prec, rnd)\\n mag = exp+bc\\n abs_mag = abs(mag)\\n #------------------------------------------------------------------\\n # Handle x = 1+eps, where log(x) ~ x. We need to check for\\n # cancellation when moving to fixed-point math and compensate\\n # by increasing the precision. Note that abs_mag in (0, 1) <=>\\n # 0.5 < x < 2 and x != 1\\n if abs_mag <= 1:\\n # Calculate t = x-1 to measure distance from 1 in bits\\n tsign = 1-abs_mag\\n if tsign:\\n tman = (MPZ_ONE<<bc) - man\\n else:\\n tman = man - (MPZ_ONE<<(bc-1))\\n tbc = bitcount(tman)\\n cancellation = bc - tbc\\n if cancellation > wp:\\n t = normalize(tsign, tman, abs_mag-bc, tbc, tbc, 'n')\\n return mpf_perturb(t, tsign, prec, rnd)\\n else:\\n wp += cancellation\\n # TODO: if close enough to 1, we could use Taylor series\\n # even in the AGM precision range, since the Taylor series\\n # converges rapidly\\n #------------------------------------------------------------------\\n # Another special case:\\n # n*log(2) is a good enough approximation\\n if abs_mag > 10000:\\n if bitcount(abs_mag) > wp:\\n return from_man_exp(exp*ln2_fixed(wp), -wp, prec, rnd)\\n #------------------------------------------------------------------\\n # General case.\\n # Perform argument reduction using log(x) = log(x*2^n) - n*log(2):\\n # If we are in the Taylor precision range, choose magnitude 0 or 1.\\n # If we are in the AGM precision range, choose magnitude -m for\\n # some large m; benchmarking on one machine showed m = prec/20 to be\\n # optimal between 1000 and 100,000 digits.\\n if wp <= LOG_TAYLOR_PREC:\\n m = log_taylor_cached(lshift(man, wp-bc), wp)\\n if mag:\\n m += mag*ln2_fixed(wp)\\n else:\\n optimal_mag = -wp//LOG_AGM_MAG_PREC_RATIO\\n n = optimal_mag - mag\\n x = mpf_shift(x, n)\\n wp += (-optimal_mag)\\n m = -log_agm(to_fixed(x, wp), wp)\\n m -= n*ln2_fixed(wp)\\n return from_man_exp(m, -wp, prec, rnd)\",\n \"def logP(self):\\n raise NotImplementedError\",\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 log_lhood(X, Z, Y, a, ep, lamb):\\n \\n K = Z.shape[1]\\n N, T = X.shape\\n \\n # p(X)\\n ZY = np.dot(Z,Y) \\n log_pX = 0\\n log_pX = log_pX + np.sum(X * np.log(1 - ((1 - lamb) ** ZY) * (1 - ep)))\\n log_pX = log_pX + np.sum((1 - X) * np.log(((1 - lamb) ** ZY) * (1 - ep))) \\n \\n # p(Z)\\n HN = 0\\n for n in range(1, N+1):\\n HN += 1.0/n\\n m = Z.sum(axis=0)\\n log_pZ = (K * np.log(a) - (a * HN)) + np.sum(gammaln(m) +\\n gammaln(N - m + 1) - gammaln(N + 1)) \\n\\n return log_pZ + log_pX\",\n \"def evaluate_poly(poly: Sequence[float], x: float) -> float:\\n return sum(c * (x**i) for i, c in enumerate(poly))\",\n \"def logp(self, value: TensorType, **kwargs) -> TensorType:\",\n \"def logp(self, value: TensorType, **kwargs) -> TensorType:\",\n \"def log_error(X, y, w):\\r\\n N = X.shape[0]\\r\\n J = np.sum(np.log(1.0 + np.exp(-y * (X @ w)))) / N\\r\\n return J\",\n \"def logp_nojac(self, *args, **kwargs):\\n return self.logp(*args, **kwargs)\",\n \"def nll(x, a, b):\\n x = _validate_x_bounds(x, low=0, high=1, strict_low=True, strict_high=True)\\n return -mp.fsum([logpdf(t, a, b) for t in x])\",\n \"def func_with_jvp(x):\\n return mysum(pow2(mysin(x)))\",\n \"def inverse_diff_log(y,log0):\\n\\n return np.exp(inverse_diff(y,log0))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6472516","0.63923484","0.6258953","0.624462","0.62249404","0.619804","0.61791533","0.61325204","0.6129933","0.6125757","0.608846","0.6077444","0.60673094","0.60201836","0.598951","0.5984881","0.59739053","0.59476596","0.59213316","0.5906993","0.58948123","0.5889387","0.5841917","0.5840438","0.5835678","0.581825","0.5812963","0.5807641","0.5801572","0.5797614","0.57827806","0.57748723","0.5769897","0.57480806","0.57301366","0.5728234","0.57201135","0.57099855","0.57036346","0.569203","0.569078","0.5663864","0.5663246","0.56584877","0.56567883","0.5647003","0.5642275","0.5642134","0.5634703","0.5632821","0.5625815","0.5618182","0.5613096","0.561041","0.56095564","0.55991364","0.5595683","0.5594085","0.55864847","0.55838734","0.55837727","0.55831534","0.55730116","0.5567296","0.5561221","0.5554093","0.55524415","0.5548692","0.5548283","0.5544622","0.5533113","0.5531898","0.55309063","0.5530572","0.5526599","0.5512193","0.5512025","0.551128","0.55090207","0.5508074","0.5507582","0.55071414","0.55056554","0.5505334","0.5503807","0.5500786","0.54996246","0.54972434","0.54964864","0.54920113","0.54885036","0.5486359","0.548385","0.5482922","0.5482922","0.54803663","0.54773355","0.54682386","0.545903","0.54588497"],"string":"[\n \"0.6472516\",\n \"0.63923484\",\n \"0.6258953\",\n \"0.624462\",\n \"0.62249404\",\n \"0.619804\",\n \"0.61791533\",\n \"0.61325204\",\n \"0.6129933\",\n \"0.6125757\",\n \"0.608846\",\n \"0.6077444\",\n \"0.60673094\",\n \"0.60201836\",\n \"0.598951\",\n \"0.5984881\",\n \"0.59739053\",\n \"0.59476596\",\n \"0.59213316\",\n \"0.5906993\",\n \"0.58948123\",\n \"0.5889387\",\n \"0.5841917\",\n \"0.5840438\",\n \"0.5835678\",\n \"0.581825\",\n \"0.5812963\",\n \"0.5807641\",\n \"0.5801572\",\n \"0.5797614\",\n \"0.57827806\",\n \"0.57748723\",\n \"0.5769897\",\n \"0.57480806\",\n \"0.57301366\",\n \"0.5728234\",\n \"0.57201135\",\n \"0.57099855\",\n \"0.57036346\",\n \"0.569203\",\n \"0.569078\",\n \"0.5663864\",\n \"0.5663246\",\n \"0.56584877\",\n \"0.56567883\",\n \"0.5647003\",\n \"0.5642275\",\n \"0.5642134\",\n \"0.5634703\",\n \"0.5632821\",\n \"0.5625815\",\n \"0.5618182\",\n \"0.5613096\",\n \"0.561041\",\n \"0.56095564\",\n \"0.55991364\",\n \"0.5595683\",\n \"0.5594085\",\n \"0.55864847\",\n \"0.55838734\",\n \"0.55837727\",\n \"0.55831534\",\n \"0.55730116\",\n \"0.5567296\",\n \"0.5561221\",\n \"0.5554093\",\n \"0.55524415\",\n \"0.5548692\",\n \"0.5548283\",\n \"0.5544622\",\n \"0.5533113\",\n \"0.5531898\",\n \"0.55309063\",\n \"0.5530572\",\n \"0.5526599\",\n \"0.5512193\",\n \"0.5512025\",\n \"0.551128\",\n \"0.55090207\",\n \"0.5508074\",\n \"0.5507582\",\n \"0.55071414\",\n \"0.55056554\",\n \"0.5505334\",\n \"0.5503807\",\n \"0.5500786\",\n \"0.54996246\",\n \"0.54972434\",\n \"0.54964864\",\n \"0.54920113\",\n \"0.54885036\",\n \"0.5486359\",\n \"0.548385\",\n \"0.5482922\",\n \"0.5482922\",\n \"0.54803663\",\n \"0.54773355\",\n \"0.54682386\",\n \"0.545903\",\n \"0.54588497\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6842833"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":91799,"cells":{"query":{"kind":"string","value":"Uses scipy.optimize.curve_fit() to fit the model to typetoken data."},"document":{"kind":"string","value":"def fit(\n self, m_tokens: np.ndarray, n_types: np.ndarray, M: int = None, N: int = None\n ):\n\n # fix M, N\n M = M or m_tokens.max()\n N = N or n_types.max()\n\n # initial guess\n p0 = 2.0\n\n # minimize MSE on random perturbations of gamma\n xdata = np.array(m_tokens) / M\n ydata = np.array(n_types) / N\n [gamma_], _ = curve_fit(self.formula, xdata, ydata, p0)\n self.params = (M, N, gamma_)\n\n # return fitted model\n return self"},"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 fit(self, X):","def fit():\n pass","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y):","def fit(self, X, y):","def fit(self, X, y):","def fit(self, X, y, **fit_params):\n ...","def fit(self, x):\n pass","def fit(self, X, y=..., **fit_params):\n ...","def fit(self, X,y):\n pass","def fit(self, X):\n raise NotImplementedError","def fit_experimental(self, m_tokens: np.ndarray, n_types: np.ndarray, gamma: float):\n\n # initial guess\n M = m_tokens.max()\n N = n_types.max()\n p0 = (M, N)\n\n # fix gamma, but fit M, N to the data\n xdata = np.array(m_tokens)\n ydata = np.array(n_types)\n\n def func(m, M, N):\n return N * self.formula(m / M, gamma)\n\n [M, N], _ = curve_fit(func, xdata, ydata, p0)\n M, N = int(M), int(N)\n self.params = (M, N, gamma)\n\n # return fitted model\n return self","def fit(self, X, Y, **fit_params):\n ...","def fit(self, X, Y, **fit_params):\n ...","def fit(self, m_tokens: np.ndarray, n_types: np.ndarray):\n\n # initial guess: naive fit\n M, N, H = max(m_tokens), max(n_types), max(n_types) / 2\n p0 = self.fit_naive(M, N, H).params\n\n # minimize MSE on random perturbations of M_z, N_z\n # NOTE: y(x) = 1 - k0(x) -> E(m)/Nz = 1 - k0(m/Mz)\n def func(m, M_z, N_z):\n return N_z * (1 - self.formula_0(m / M_z))\n\n xdata = np.array(m_tokens)\n ydata = np.array(n_types)\n params_, _ = curve_fit(func, xdata, ydata, p0)\n M_z, N_z = params_.astype(\"int\")\n self.params = (M_z, N_z)\n\n # return fitted model\n return self","def fit(self, X, Y):\n ...","def fit(self, x):\n raise NotImplementedError()","def fit(self, input):\n raise NotImplementedError()","def fit_transform(self, X, y=...):\n ...","def _fit_gas_trend(cls, x, y, fit_type=None):\n fit_type = cls._max_trend_poly_deg if fit_type is None else fit_type\n if fit_type == 'exp':\n logger.debug('Using exponential fit to extrapolate {}'.format(cls._gas_name))\n fit = np.polynomial.polynomial.Polynomial.fit(x, np.log(y), 1, w=np.sqrt(y))\n return lambda t: np.exp(fit(t))\n\n else:\n logger.debug('Using order {} polynomial to extrapolate {}'.format(fit_type, cls._gas_name))\n fit = np.polynomial.polynomial.Polynomial.fit(x, y, deg=fit_type)\n return fit","def fit(self, data):\n raise NotImplementedError(\"To be implemented in sub classes\")","def _fit(self, dataset):\n raise NotImplementedError()","def fit(self, Y):\n raise NotImplementedError","def fit(self):\n raise NotImplementedError('')","def fit(self):\n raise NotImplementedError","def fitting(x_value, target_value, model_function, fitting_method, type_of_fit):\n if len(target_value) != len(x_value):\n raise ValueError(\"Value length not match\")\n\n fig = plt.figure()\n\n parameters, _ = curve_fit(\n model_function, x_value, target_value, method=fitting_method)\n\n xspace = np.linspace(x_value[0], x_value[len(x_value) - 1], 100)\n if len(parameters) == 1:\n fit_A = parameters[0]\n fit_curve = model_function(xspace, fit_A)\n elif len(parameters) == 2:\n fit_A = parameters[0]\n fit_B = parameters[1]\n fit_curve = model_function(xspace, fit_A, fit_B)\n elif len(parameters) == 3:\n fit_A = parameters[0]\n fit_B = parameters[1]\n fit_C = parameters[2]\n fit_curve = model_function(xspace, fit_A, fit_B, fit_C)\n else:\n raise ValueError(\"Function do not support that Model\")\n\n # making plot\n plt.plot(x_value, target_value, 'o', label='cpu')\n plt.plot(xspace, fit_curve, '-', label='fit')\n plt.xlabel(\"cores_per_node\")\n plt.ylabel(\"time/s\")\n plt.title(type_of_fit + \"_Fitting Plot\")\n plt.legend()\n plt.savefig(type_of_fit + \"_fit.jpg\")\n plt.close()\n\n return parameters","def sas_curve_fit(x, y, calc_type):\n\n result = {}\n\n n = len(x)\n\n if (n == 0) or (len(y) == 0):\n err = \"Error: No values to fit in \" + calc_type + \" calculation\\n\"\n raise Exception(err)\n #result['error'] = err\n else:\n # Linear fit to the input x and y values\n #fit_coeffs = np.polyfit(x, y, 1)\n fit_coeffs = sps.linregress(x, y)\n \n result['fit'] = fit_coeffs\n\n if (calc_type == 'rxs1') or (calc_type == 'rxs2'):\n # Cross section Rxs1/Rxs2 calculated from fits of q^2 vs ln(I*q)\n # Rxs?^2 = 2 * gradient\n result['r'] = np.sqrt(2 * abs(fit_coeffs[0]))\n #result['rerr'] = np.abs(np.sqrt(2 * abs(fit_coeffs[4]))-result['r'])\n result['rerr'] = np.abs(np.sqrt(2 * abs(fit_coeffs[0] + fit_coeffs[4])) - result['r'])\n result['i'] = None\n else:\n # Assume a standard Guinier fit of q^2 vs ln(I):\n # Rg^2 = 3 * gradient\n # Io = exp(intercept)\n std_err_fit = fit_coeffs[4]\n # Analysis below on the basis that scipt.stats.linregress\n # gives the std error on the slope rather than of the regression\n # This gives result inline with old SJP code - needs chacking as \n # seems odd\n result['r'] = np.sqrt(3 * abs(fit_coeffs[0]))\n result['rerr'] = np.abs(np.sqrt(3 * abs(fit_coeffs[0] + std_err_fit)) - result['r'])\n result['i'] = np.exp(fit_coeffs[1])\n result['ierr'] = np.exp(fit_coeffs[1] + (std_err_fit * np.sqrt(np.sum(x**2))/np.sqrt(n))) - result['i']\n\n return result","def fit(self, data: pd.DataFrame):\n raise NotImplementedError","def fit(self, X, y=None, **kwargs):\n raise NotImplementedError()","def fit_transform(self, X: TransformType, y=None, **fit_params) -> TransformType:\n X = self._validate_datafold_data(\n X,\n array_kwargs=dict(ensure_min_samples=max(2, self.n_kernel_eigenvectors)),\n tsc_kwargs=dict(ensure_min_samples=max(2, self.n_kernel_eigenvectors)),\n )\n self.fit(X=X, y=y, **fit_params)\n\n return self._jointly_smooth_functions_","def fit(self, x, y): \n # *** START CODE HERE ***\n y = y.reshape(y.shape[0], 1)\n y_0 = (1 - y).reshape(y.shape)\n m = y.shape[0]\n m_0 = np.asscalar(np.sum(y_0))\n m_1 = np.asscalar(np.sum(y))\n # Find phi, mu_0, mu_1, and sigma\n phi = np.sum(y) / m\n mu_0 = (np.sum(np.multiply(y_0, x), axis = 0, keepdims = True) / m_0) #.reshape(y.shape)\n mu_1 = np.sum(np.multiply(y, x), axis = 0, keepdims=True) / m_1\n sigma = getsigma(x, mu_0, mu_1, m, y, y_0)\n # Write theta in terms of the parameters\n sigma_inv = np.linalg.inv(sigma)\n log_phi = np.log(np.exp(-1 * np.log(phi)) - 1)\n theta_0 = (np.dot(np.dot(mu_0, sigma_inv), mu_0.T) - np.dot(np.dot(mu_1, sigma_inv), mu_1.T)) / 2 - log_phi\n self.theta = np.concatenate((theta_0, np.dot(sigma_inv, (mu_1 - mu_0).T)))\n # Compute cost\n x_0 = np.zeros((x.shape[0], 1)) + 1\n x_train = np.concatenate((x_0.T, x.T))\n h_theta = sigmoid(np.dot(self.theta.T, x_train)).T\n cost = - np.sum(np.dot(y.T, np.log(h_theta - (h_theta - 0.5) * self.eps)) + (np.dot(y_0.T, np.log(1 - h_theta + (h_theta - 0.5) * self.eps)))) / m\n if self.verbose:\n print(\"Cost: \" + str(cost))\n # *** END CODE HERE ***","def fit(model, input: str, output: str):\n print(f\"Fitting model of type: {model}\")\n\n # Define the model. Use a randomized search to efficiently explore the\n # hyperparameter space in a limited time.\n if model == \"logistic\":\n # Primal logistic regression\n param_dist = {\n 'C': loguniform(0.1, 100), 'max_iter': [250], 'fit_intercept': [True],\n 'intercept_scaling': [1], 'penalty': ['l2'], 'tol': loguniform(1e-6, 1e-4)\n }\n mdl_cv = RandomizedSearchCV(LogisticRegression(solver='lbfgs'), param_dist, cv=3, refit=True, verbose=2, n_iter=10)\n elif model == \"rand_forest\":\n # Random Forest classifier\n param_dist = {'max_depth': randint(3,8), 'max_features': randint(2,9), 'n_estimators': randint(50, 100),\n 'min_samples_split': randint(3, 7)}\n mdl_cv = RandomizedSearchCV(RandomForestClassifier(), param_dist, cv=3, refit=True, verbose=2, n_iter=10)\n elif model == \"gradient_boost\":\n # Extreme Gradient Boost classifier\n param_dist = {'max_depth': [3, 4], 'gamma': loguniform(1e-3, 1e-2), 'min_child_weight': randint(1, 10),\n 'learning_rate': loguniform(0.05, 0.3), 'n_estimators': randint(10, 40)}\n mdl_cv = RandomizedSearchCV(XGBClassifier(), param_dist, cv=3, refit=True, verbose=2, n_iter=10)\n else:\n raise NotImplementedError(f\"Don't know how to train model of type: {model}.\\nValid options are: logistic, rand_forest, gradient_boost.\")\n\n # Define x (input data) and y (target data)\n df = pd.read_csv(input)\n x = df.loc[:, df.columns != 'Exited']\n y = df.Exited\n print(f\"Data has x.shape = {x.shape} and y.shape = {y.shape}\")\n\n # Fit the model with randomized search\n mdl_cv.fit(x, y)\n\n # Print some results\n print(\"Best score:\", mdl_cv.best_score_)\n print(\"Best params:\", pprint.pformat(mdl_cv.best_params_))\n\n # Save to data store\n os.makedirs(os.path.dirname(output), exist_ok=True)\n with open(output, \"wb\") as f:\n joblib.dump(mdl_cv.best_estimator_, f)","def fit(self, X, y, sample_weight=...):\n ...","def fit_transform(self, X, y=None):\n out = self.transform(X)\n self.learn_types(X, out)\n return self.transform(X)","def fit(self, X: np.ndarray, y: np.ndarray, **kwargs) -> \"TSSine\":\n if self.random_state is not None:\n np.random.seed(self.random_state)\n\n guess = self._make_initial_guess(X=X, y=y)\n\n try:\n popt = scipy.optimize.curve_fit(\n self._func, X.ravel(), y, p0=guess, check_finite=False\n )[0]\n\n self.A, self.w, self.p, self.c = popt\n\n self._fitted = True\n\n except RuntimeError:\n self._fitted = False\n\n return self","def fit(self, X, y=..., sample_weight=...):\n ...","def fit(self, X):\n self._fit_X = X","def ts_fit(series: TimeSeries) -> TimeSeries:\n pass","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def fit_training_data(self):\n self.model.fit(self.X_train)","def fit(self, X, y=None, **fit_params):\n return self","def fit(self, X):\n raise NotImplementedError('Abstract method \"fit\" must be '\n 'specialised!')","def fit(self):\n raise NotImplementedError # pragma: no cover","def partial_fit(self, X, y=...):\n ...","def partial_fit(self, X, y=...):\n ...","def fit(self, data, data_val, model=None, *args, **kwargs):\n res = self._prepare_fit(model, data, data_val, generator=False,\n delay=False, *args, **kwargs)\n return res","def test_fit(self):\n X = self.generate_X()\n task = mmRDTR()\n fit_result = task.fit(X)","def fit_test(self):","def _fit(self, _X, _y):\n\n self.model = linear_model.LogisticRegression(penalty=self.penalty, random_state=self.seed,\n solver='saga', n_jobs=self.n_jobs)\n self.model.fit(_X, _y)","def fit_model(self):\n logger.info('Fitting model')\n if self.traj_dict is None:\n self.traj_dict = self.get_traj_dict()\n self.model.fit(self.traj_dict.values())","def fit_model(func, xdata, ydata, yerrdata, p0):\n popt, pcov = curve_fit(func, xdata, ydata, p0=p0, sigma=yerrdata)\n # the function evaluated at the output parameters\n fvec = lambda x: func(x, *popt)\n # degree of freedom\n dof = len(xdata) - len(popt) - 1\n # chi squared\n chisq = np.sum(((ydata - fvec(xdata)) / yerrdata) ** 2)\n # one standard deviation errors on the parameters\n perr = np.sqrt(np.diag(pcov))\n infodict = {\n 'fvec': fvec,\n 'dof': dof,\n 'chisq': chisq,\n 'perr': perr\n }\n return (popt, infodict)","def _fit(self, X: TimeSeriesInstances, y=None) -> np.ndarray:\n raise NotImplementedError","def fit(self, X, Y, **kwargs):\n raise NotImplementedError","def fit(self, data):\n return self","def fit_model(self):\r\n\t\tself.mu = np.mean(self.x, axis = 0)\r\n\t\tself.sig = np.std(self.x, axis = 0)","def fit(self, X, y=None):\n # assume a pandas.DataFrame compatible object\n out = self.act_on(X)\n self.learn_types(X, out)\n return self","def _fit(self, x_train, y_train, x_valid, y_valid, regressor_callback=None):","def fit(self, X, y, sample_weight=..., **fit_params):\n ...","def fit(self, X: TransformType, y=None, **fit_params) -> \"JointlySmoothFunctions\":\n X = self._validate_datafold_data(\n X=X,\n array_kwargs=dict(\n ensure_min_samples=max(2, self.n_kernel_eigenvectors + 1)\n ),\n tsc_kwargs=dict(ensure_min_samples=max(2, self.n_kernel_eigenvectors + 1)),\n )\n\n self._setup_feature_attrs_fit(\n X=X,\n features_out=[f\"jsf{i}\" for i in range(self.n_jointly_smooth_functions)],\n )\n\n column_splitter = _ColumnSplitter(self.datasets)\n self.observations_ = column_splitter.split(X)\n\n self._calculate_kernel_matrices()\n\n self._calculate_kernel_eigensystem()\n\n (\n self._jointly_smooth_functions_,\n self._eigenvalues_,\n ) = self._calculate_jointly_smooth_functions()\n\n return self","def fit(ydata):\n xdata = np.linspace(0,len(ydata),num = len(ydata))\n popt, pcov = curve_fit(func, xdata, ydata)\n #returns the parameters of the fitting\n return popt","def fit(self, x):\n x = np.asarray(x)\n _ = self.fit_transform(x)","def fit_curve(x,y,p0,func):\n ifixx = np.zeros(np.array(x).shape)\n data = sodr.Data(x,y)\n model = sodr.Model(func)\n worker = sodr.ODR(data,model,p0,ifixx=ifixx,maxit=500)\n out = worker.run()\n out = worker.restart()\n return out","def fit(\n self,\n X: FEATURES | None = None,\n y: TARGET | None = None,\n **fit_params,\n ):\n X, y = self._prepare_input(X, y)\n self._check_feature_names(X, reset=True)\n self._check_n_features(X, reset=True)\n\n self.log(f\"Fitting {self.__class__.__name__}...\", 1)\n\n return self","def do_fit(self):\n\n if (self._flag == 1):\n self._gf = [0.2]\n self._gf = self.par*(self._num_fu*len(self._sites)*2)\n x, F = self.read_from_file(\n self._sn, self._qn, self._path) # read data from the file\n # ,ftol=1.0e-7,xtol=1.0e-8)\n popt, pcov = curve_fit(\n self.modelfun, x, F, p0=self._gf, maxfev=5000)\n self._gf = popt\n\n elif (self._flag == 2):\n\n# par=[0.0]*(self._num_fu*5)\n# for j in range(self._num_fu):\n# par[j*5]=0.0*math.copysign(1,(pow(-1,j)))\n# self._gf[j*5]=0.1\n# par[j*5+1]=6.45\n# par[j*5+2]=0.0\n# par[j*5+3]=0.05\n# par[j*5+4]=1.0\n\n X, F = self.read_from_file(self._sn, self._qn, self._path) # read data from the file\n\n# height, xx, width=self.moments(F)\n# Tracer()()\n# par=[0.0]*(self._num_fu*5)\n# for j in range(self._num_fu):\n# par[j*5]=x[0,xx]\n# par[j*5]=X[0,xx]*math.copysign(1,(pow(-1,j)))\n# par[j*5+1]=X[1,xx]\n# par[j*5+2]=X[2,xx]\n# par[j*5+3]=0.007\n# par[j*5+4]=height*math.copysign(1,(pow(-1,j)))\n\n xi, yi, zi = np.mgrid[-6.5:6.5:160j, 4.0:8.9:160j, -7.5:7.5:160j]\n x, y, z = xi.flatten(), yi.flatten(), zi.flatten()\n XX = np.vstack((x, y, z))\n\n invdisttree = Invdisttree(X.T, F, leafsize=10, stat=1)\n AA = invdisttree(XX.T, nnear=130, eps=0, p=1)\n\n# aaa1,bbb1=self.detect_local_minima(-AA.reshape(xi.shape))\n# aaa2,bbb2=self.detect_local_maxima(-AA.reshape(xi.shape))\n if self.peaks==[]:\n print('\\n---------------------------------------------------------------------')\n print('Detecting maxima and minima of target function...',)\n\n peaks_min, min_coord, peaks_max, max_coord = self.detect_min_max(AA.reshape(xi.shape))\n print('done')\n print('Number of the min peaks: {}'.format(len(peaks_min)))\n print('Number of the max peaks: {}'.format(len(peaks_max)))\n print('---------------------------------------------------------------------\\n')\n # fig=plt.figure()\n # ax = fig.add_subplot(111, projection='3d')\n # ax.plot_surface(xi[:,:,60],yi[:,:,60],bbb2[:,:,60], cmap=cm.jet, linewidth=0.2)\n # plt.hold(True)\n # plt.show()\n\n if peaks_max==[]:\n peaks=np.insert(peaks_min, np.arange(len(peaks_max)), peaks_max)\n coords=np.insert(min_coord, np.arange(max_coord.shape[1]), max_coord, axis=1)\n else:\n peaks = np.insert(peaks_max, np.arange(len(peaks_min)), peaks_min)\n coords = np.insert(max_coord, np.arange(min_coord.shape[1]), min_coord, axis=1)\n\n self.peaks=peaks\n self.coords=coords\n\n par = [0.0]*(self._num_fu*5)\n j1 = 0\n aaaa = 1\n for j in range(self._num_fu):\n if (j > aaaa*self.coords.shape[1]-1):\n j1 = 0\n aaaa += 1\n par[j*5] = xi[self.coords[0, j1], self.coords[0, j1], self.coords[0, j1]]\n par[j*5+1] = yi[self.coords[1, j1], self.coords[1, j1], self.coords[1, j1]]\n par[j*5+2] = zi[self.coords[2, j1], self.coords[2, j1], self.coords[2, j1]]\n # par[j*5+3] = 0.1003+0.1000*math.copysign(1, (pow(-1, j)))\n par[j*5+3] = 0.0001\n# if j < 15:\n# par[j*5+3] = 0.00001\n# else:\n# par[j*5+3] = 0.0005\n par[j*5+4] = self.peaks[j1]\n# print(coords[0, j1], coords[1, j1], coords[2, j1])\n j1 += 1\n # popt, pcov = curve_fit(self.modelfun1, x[:,1:20000], F[1:20000],p0=par,maxfev=150000,xtol=1e-8,ftol=1e-8)\n popt, pcov = curve_fit(\n self.modelfun1, X, F, p0=par, maxfev=150000, xtol=1e-6,\n ftol=1e-8)\n # popt, pcov = curve_fit(self.modelfun1, XX, AA, p0=par)\n self._gf = popt\n# self.error=np.diagonal(pcov, offset=0)\n# print(pcov)\n else:\n # pass\n sys.exit(\"Wrong flag in do_fit\")","def _fit(self, X, y):\n return BaseTimeSeriesForest._fit(self, X, y)","def fit(self):\n # Initialize parameter estimates\n if self.estimator is not None:\n param_estimates = self.estimator(self.xf, self.yf)\n else: param_estimates = None\n self.popt, self.pcov = curve_fit(self.model, self.xf, self.yf, \n p0=param_estimates)\n self.fit_history.append({\"popt\" : self.popt, \"pcov\" : self.pcov})","def fitRegressor(self, data):\r\n if data.SETS == 2:\r\n self.regressor.fit(data.trainX, data.trainy)","def fit(self, x: np.array, t: np.array, y: np.array) -> None:\n\n self.forest.fit(x, y)","def fit(self, X, y):\n self.X_data = X\n self.y = y","def fit(self, X, y=None):\n #import pdb\n #pdb.set_trace()\n return self.partial_fit(X, y)","def fit(self, X, Y):\n if self.model is None:\n print(\"%s.fit: implement me\" % (self.__class__.__name__))","def partial_fit(self, X, y=..., **fit_params):\n ...","def fit(self, X: np.ndarray, y: np.ndarray, **kwargs) -> \"TSExp\":\n b_0 = y[-1] / y[-2]\n a_0 = 0.1\n c_0 = 0\n guess = np.asarray([a_0, b_0, c_0], dtype=float)\n\n try:\n popt = scipy.optimize.curve_fit(\n self._func, X.ravel(), y, p0=guess, check_finite=False\n )[0]\n\n self.a, self.b, self.c = popt\n\n self._fitted = True\n\n except RuntimeError:\n self._fitted = False\n\n return self","def _fit(self, y, X, fh):\n names, forecasters = self._check_forecasters()\n self._fit_forecasters(forecasters, y, X, fh)\n return self","def fit(self, data):\n if data is None:\n self.train_self()\n else:\n # not needed this week\n pass","def fit(self) -> None:\n start_time = time.time()\n # ---- START -----\n train_df = self.processed_train_df[self.processed_train_df[self.filter_col_name]].dropna()\n train_features = train_df[self.feature_list]\n for label, model in zip(self.label_list, self.models):\n model.fit(train_features, train_df[label])\n # ---- END -----\n end_time = time.time()\n print(\"Finished fitting : elasped time : \" + str(end_time - start_time))","def fit(self, *_):\n return self","def fit(self, *_):\n return self","def fit(self, *_):\n return self","def fit(self):\n self.eval_chisq([1, 1, 1, 1])","def set_fit_params(self):\n\n self.p0 = np.array([self.A_arr, self.T_a])\n # initial guess at A_arr and T_a\n\n self.popt, self.pcov = curve_fit(\n self.get_eta_fit, self.T_exp, self.eta_exp, p0=self.p0\n )\n\n self.A_arr = self.popt[0]\n self.T_a = self.popt[1]\n\n self.T_array = self.T_model","def fit_model(function,\n energy_fit,\n eqe_fit,\n p0=None,\n include_disorder=False\n ):\n\n if p0 is None: # if no guess is given, initialize with ones. This is consistent with curve_fit.\n if include_disorder:\n p0 = [1, 1, 1, 1]\n else:\n p0 = [1, 1, 1]\n\n gmodel = Model(function)\n\n gmodel.set_param_hint('Ect', min=0, max=1.6)\n # gmodel.set_param_hint('Ect', min=0, max=1.7)\n gmodel.set_param_hint('l', min=0, max=0.6) # changed from 0.4\n gmodel.set_param_hint('f', min=0, max=0.1) # changed from 0.4\n\n if include_disorder:\n gmodel.set_param_hint('sig', min=0, max=0.2)\n\n result = gmodel.fit(eqe_fit,\n f=p0[0],\n l=p0[1],\n Ect=p0[2],\n sig=p0[3],\n E=energy_fit\n )\n\n f = float(result.params['f'].value)\n l = float(result.params['l'].value)\n Ect = float(result.params['Ect'].value)\n sig = float(result.params['sig'].value)\n\n best_vals = [f, l, Ect, sig]\n\n covar = result.covar\n if covar is None:\n covar = np.zeros((4, 4))\n\n y_fit = gmodel.eval(E=np.array(energy_fit),\n f=f,\n l=l,\n Ect=Ect,\n sig=sig\n )\n else:\n result = gmodel.fit(eqe_fit,\n f=p0[0],\n l=p0[1],\n Ect=p0[2],\n E=energy_fit\n )\n\n f = float(result.params['f'].value)\n l = float(result.params['l'].value)\n Ect = float(result.params['Ect'].value)\n\n best_vals = [f, l, Ect]\n\n covar = result.covar\n if covar is None:\n covar = np.zeros((4, 4))\n\n y_fit = gmodel.eval(E=np.array(energy_fit),\n f=f,\n l=l,\n Ect=Ect\n )\n\n r_squared = R_squared(eqe_fit, y_fit)\n\n return best_vals, covar, y_fit, r_squared","def fit(self, X, y=None, groups=None, type=\"Classifier\",**fit_params):\n if self.fit_params is not None:\n warnings.warn('\"fit_params\" as a constructor argument was '\n 'deprecated in version 0.19 and will be removed '\n 'in version 0.21. Pass fit parameters to the '\n '\"fit\" method instead.', DeprecationWarning)\n if fit_params:\n warnings.warn('Ignoring fit_params passed as a constructor '\n 'argument in favor of keyword arguments to '\n 'the \"fit\" method.', RuntimeWarning)\n else:\n fit_params = self.fit_params\n #estimator = self.estimator\n\n if type == \"Classification\":\n from keras.wrappers.scikit_learn import KerasClassifier\n estimator = KerasClassifier(build_fn=self.estimator, verbose=0)\n else:\n from keras.wrappers.scikit_learn import KerasRegressor\n estimator = KerasRegressor(build_fn=self.estimator, verbose=0)\n cv = check_cv(self.cv, y, classifier=is_classifier(estimator))\n\n scorers, self.multimetric_ = _check_multimetric_scoring(\n clone(estimator), scoring=self.scoring)\n\n if self.multimetric_:\n if self.refit is not False and (\n not isinstance(self.refit, six.string_types) or\n # This will work for both dict / list (tuple)\n self.refit not in scorers):\n raise ValueError(\"For multi-metric scoring, the parameter \"\n \"refit must be set to a scorer key \"\n \"to refit an estimator with the best \"\n \"parameter setting on the whole data and \"\n \"make the best_* attributes \"\n \"available for that metric. If this is not \"\n \"needed, refit should be set to False \"\n \"explicitly. %r was passed.\" % self.refit)\n else:\n refit_metric = self.refit\n else:\n refit_metric = 'score'\n\n X, y, groups = indexable(X, y, groups)\n n_splits = cv.get_n_splits(X, y, groups)\n # Regenerate parameter iterable for each fit\n candidate_params = list(self._get_param_iterator())\n n_candidates = len(candidate_params)\n if self.verbose > 0:\n print(\"Fitting {0} folds for each of {1} candidates, totalling\"\n \" {2} fits\".format(n_splits, n_candidates,\n n_candidates * n_splits))\n\n base_estimator = self.estimator\n pre_dispatch = self.pre_dispatch\n # One of the main changes is instead of using the _fit_and_score from sklearn.model_selection._validation\n # We use a modified one (_fit_and_score_keras) that clears the session after each iteration\n out = Parallel(\n n_jobs=self.n_jobs, verbose=self.verbose,\n pre_dispatch=pre_dispatch\n )(delayed(_fit_and_score_keras2)(base_estimator, X, y, scorers, train,\n test, self.verbose, parameters,\n fit_params=fit_params,\n return_train_score=self.return_train_score,\n return_n_test_samples=True,\n return_times=True, return_parameters=False,\n error_score=self.error_score,\n type=type) # Passing the session (Keras backend) argument\n for parameters, (train, test) in product(candidate_params,\n cv.split(X, y, groups)))\n\n # if one choose to see train score, \"out\" will contain train score info\n if self.return_train_score:\n (train_score_dicts, test_score_dicts, test_sample_counts, fit_time,\n score_time) = zip(*out)\n else:\n (test_score_dicts, test_sample_counts, fit_time,\n score_time) = zip(*out)\n\n # test_score_dicts and train_score dicts are lists of dictionaries and\n # we make them into dict of lists\n test_scores = _aggregate_score_dicts(test_score_dicts)\n if self.return_train_score:\n train_scores = _aggregate_score_dicts(train_score_dicts)\n\n results = dict()\n\n def _store(key_name, array, weights=None, splits=False, rank=False):\n \"\"\"A small helper to store the scores/times to the cv_results_\"\"\"\n # When iterated first by splits, then by parameters\n # We want `array` to have `n_candidates` rows and `n_splits` cols.\n array = np.array(array, dtype=np.float64).reshape(n_candidates,\n n_splits)\n if splits:\n for split_i in range(n_splits):\n # Uses closure to alter the results\n results[\"split%d_%s\"\n % (split_i, key_name)] = array[:, split_i]\n\n array_means = np.average(array, axis=1, weights=weights)\n results['mean_%s' % key_name] = array_means\n # Weighted std is not directly available in numpy\n array_stds = np.sqrt(np.average((array -\n array_means[:, np.newaxis]) ** 2,\n axis=1, weights=weights))\n results['std_%s' % key_name] = array_stds\n\n if rank:\n results[\"rank_%s\" % key_name] = np.asarray(\n rankdata(-array_means, method='min'), dtype=np.int32)\n\n _store('fit_time', fit_time)\n _store('score_time', score_time)\n # Use one MaskedArray and mask all the places where the param is not\n # applicable for that candidate. Use defaultdict as each candidate may\n # not contain all the params\n param_results = defaultdict(partial(MaskedArray,\n np.empty(n_candidates,),\n mask=True,\n dtype=object))\n for cand_i, params in enumerate(candidate_params):\n for name, value in params.items():\n # An all masked empty array gets created for the key\n # `\"param_%s\" % name` at the first occurence of `name`.\n # Setting the value at an index also unmasks that index\n param_results[\"param_%s\" % name][cand_i] = value\n\n results.update(param_results)\n # Store a list of param dicts at the key 'params'\n results['params'] = candidate_params\n\n # NOTE test_sample counts (weights) remain the same for all candidates\n test_sample_counts = np.array(test_sample_counts[:n_splits],\n dtype=np.int)\n for scorer_name in scorers.keys():\n # Computed the (weighted) mean and std for test scores alone\n _store('test_%s' % scorer_name, test_scores[scorer_name],\n splits=True, rank=True,\n weights=test_sample_counts if self.iid else None)\n if self.return_train_score:\n _store('train_%s' % scorer_name, train_scores[scorer_name],\n splits=True)\n\n # For multi-metric evaluation, store the best_index_, best_params_ and\n # best_score_ iff refit is one of the scorer names\n # In single metric evaluation, refit_metric is \"score\"\n if self.refit or not self.multimetric_:\n self.best_index_ = results[\"rank_test_%s\" % refit_metric].argmin()\n self.best_params_ = candidate_params[self.best_index_]\n self.best_score_ = results[\"mean_test_%s\" % refit_metric][\n self.best_index_]\n\n if self.refit:\n from keras import backend as K\n import tensorflow as tf\n tf.logging.set_verbosity(tf.logging.ERROR) # This is useful to avoid the info log of tensorflow\n # The next 4 lines are for avoiding tensorflow to allocate all the GPU memory\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n sess = tf.Session(config=config)\n K.set_session(sess)\n\n self.best_estimator_ = clone(estimator).set_params(\n **self.best_params_)\n if y is not None:\n self.best_estimator_.fit(X, y, **fit_params)\n else:\n self.best_estimator_.fit(X, **fit_params)\n\n # Store the only scorer not as a dict for single metric evaluation\n self.scorer_ = scorers if self.multimetric_ else scorers['score']\n\n self.cv_results_ = results\n self.n_splits_ = n_splits\n\n return self","def fit(self,X,y=None,**fit_params):\n return self","def test_fit():\n tpot_obj = TPOTClassifier(random_state=42, population_size=1, generations=1, verbosity=0)\n tpot_obj.fit(training_features, training_classes)\n\n assert isinstance(tpot_obj._optimized_pipeline, creator.Individual)\n assert tpot_obj._gp_generation == 0\n assert not (tpot_obj._start_datetime is None)","def _model_fit_term(self):\n if self.likelihood.YYT is None:\n return -0.5*np.sum(np.square(np.dot(self.Li,self.likelihood.Y)))\n else:\n return -0.5*np.sum(np.multiply(self.Ki, self.likelihood.YYT))","def fit(self, X, y):\n self.model = self._initialize_model(X, y)\n self.model.optimize()"],"string":"[\n \"def fit(self, X):\",\n \"def fit():\\n pass\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y, **fit_params):\\n ...\",\n \"def fit(self, x):\\n pass\",\n \"def fit(self, X, y=..., **fit_params):\\n ...\",\n \"def fit(self, X,y):\\n pass\",\n \"def fit(self, X):\\n raise NotImplementedError\",\n \"def fit_experimental(self, m_tokens: np.ndarray, n_types: np.ndarray, gamma: float):\\n\\n # initial guess\\n M = m_tokens.max()\\n N = n_types.max()\\n p0 = (M, N)\\n\\n # fix gamma, but fit M, N to the data\\n xdata = np.array(m_tokens)\\n ydata = np.array(n_types)\\n\\n def func(m, M, N):\\n return N * self.formula(m / M, gamma)\\n\\n [M, N], _ = curve_fit(func, xdata, ydata, p0)\\n M, N = int(M), int(N)\\n self.params = (M, N, gamma)\\n\\n # return fitted model\\n return self\",\n \"def fit(self, X, Y, **fit_params):\\n ...\",\n \"def fit(self, X, Y, **fit_params):\\n ...\",\n \"def fit(self, m_tokens: np.ndarray, n_types: np.ndarray):\\n\\n # initial guess: naive fit\\n M, N, H = max(m_tokens), max(n_types), max(n_types) / 2\\n p0 = self.fit_naive(M, N, H).params\\n\\n # minimize MSE on random perturbations of M_z, N_z\\n # NOTE: y(x) = 1 - k0(x) -> E(m)/Nz = 1 - k0(m/Mz)\\n def func(m, M_z, N_z):\\n return N_z * (1 - self.formula_0(m / M_z))\\n\\n xdata = np.array(m_tokens)\\n ydata = np.array(n_types)\\n params_, _ = curve_fit(func, xdata, ydata, p0)\\n M_z, N_z = params_.astype(\\\"int\\\")\\n self.params = (M_z, N_z)\\n\\n # return fitted model\\n return self\",\n \"def fit(self, X, Y):\\n ...\",\n \"def fit(self, x):\\n raise NotImplementedError()\",\n \"def fit(self, input):\\n raise NotImplementedError()\",\n \"def fit_transform(self, X, y=...):\\n ...\",\n \"def _fit_gas_trend(cls, x, y, fit_type=None):\\n fit_type = cls._max_trend_poly_deg if fit_type is None else fit_type\\n if fit_type == 'exp':\\n logger.debug('Using exponential fit to extrapolate {}'.format(cls._gas_name))\\n fit = np.polynomial.polynomial.Polynomial.fit(x, np.log(y), 1, w=np.sqrt(y))\\n return lambda t: np.exp(fit(t))\\n\\n else:\\n logger.debug('Using order {} polynomial to extrapolate {}'.format(fit_type, cls._gas_name))\\n fit = np.polynomial.polynomial.Polynomial.fit(x, y, deg=fit_type)\\n return fit\",\n \"def fit(self, data):\\n raise NotImplementedError(\\\"To be implemented in sub classes\\\")\",\n \"def _fit(self, dataset):\\n raise NotImplementedError()\",\n \"def fit(self, Y):\\n raise NotImplementedError\",\n \"def fit(self):\\n raise NotImplementedError('')\",\n \"def fit(self):\\n raise NotImplementedError\",\n \"def fitting(x_value, target_value, model_function, fitting_method, type_of_fit):\\n if len(target_value) != len(x_value):\\n raise ValueError(\\\"Value length not match\\\")\\n\\n fig = plt.figure()\\n\\n parameters, _ = curve_fit(\\n model_function, x_value, target_value, method=fitting_method)\\n\\n xspace = np.linspace(x_value[0], x_value[len(x_value) - 1], 100)\\n if len(parameters) == 1:\\n fit_A = parameters[0]\\n fit_curve = model_function(xspace, fit_A)\\n elif len(parameters) == 2:\\n fit_A = parameters[0]\\n fit_B = parameters[1]\\n fit_curve = model_function(xspace, fit_A, fit_B)\\n elif len(parameters) == 3:\\n fit_A = parameters[0]\\n fit_B = parameters[1]\\n fit_C = parameters[2]\\n fit_curve = model_function(xspace, fit_A, fit_B, fit_C)\\n else:\\n raise ValueError(\\\"Function do not support that Model\\\")\\n\\n # making plot\\n plt.plot(x_value, target_value, 'o', label='cpu')\\n plt.plot(xspace, fit_curve, '-', label='fit')\\n plt.xlabel(\\\"cores_per_node\\\")\\n plt.ylabel(\\\"time/s\\\")\\n plt.title(type_of_fit + \\\"_Fitting Plot\\\")\\n plt.legend()\\n plt.savefig(type_of_fit + \\\"_fit.jpg\\\")\\n plt.close()\\n\\n return parameters\",\n \"def sas_curve_fit(x, y, calc_type):\\n\\n result = {}\\n\\n n = len(x)\\n\\n if (n == 0) or (len(y) == 0):\\n err = \\\"Error: No values to fit in \\\" + calc_type + \\\" calculation\\\\n\\\"\\n raise Exception(err)\\n #result['error'] = err\\n else:\\n # Linear fit to the input x and y values\\n #fit_coeffs = np.polyfit(x, y, 1)\\n fit_coeffs = sps.linregress(x, y)\\n \\n result['fit'] = fit_coeffs\\n\\n if (calc_type == 'rxs1') or (calc_type == 'rxs2'):\\n # Cross section Rxs1/Rxs2 calculated from fits of q^2 vs ln(I*q)\\n # Rxs?^2 = 2 * gradient\\n result['r'] = np.sqrt(2 * abs(fit_coeffs[0]))\\n #result['rerr'] = np.abs(np.sqrt(2 * abs(fit_coeffs[4]))-result['r'])\\n result['rerr'] = np.abs(np.sqrt(2 * abs(fit_coeffs[0] + fit_coeffs[4])) - result['r'])\\n result['i'] = None\\n else:\\n # Assume a standard Guinier fit of q^2 vs ln(I):\\n # Rg^2 = 3 * gradient\\n # Io = exp(intercept)\\n std_err_fit = fit_coeffs[4]\\n # Analysis below on the basis that scipt.stats.linregress\\n # gives the std error on the slope rather than of the regression\\n # This gives result inline with old SJP code - needs chacking as \\n # seems odd\\n result['r'] = np.sqrt(3 * abs(fit_coeffs[0]))\\n result['rerr'] = np.abs(np.sqrt(3 * abs(fit_coeffs[0] + std_err_fit)) - result['r'])\\n result['i'] = np.exp(fit_coeffs[1])\\n result['ierr'] = np.exp(fit_coeffs[1] + (std_err_fit * np.sqrt(np.sum(x**2))/np.sqrt(n))) - result['i']\\n\\n return result\",\n \"def fit(self, data: pd.DataFrame):\\n raise NotImplementedError\",\n \"def fit(self, X, y=None, **kwargs):\\n raise NotImplementedError()\",\n \"def fit_transform(self, X: TransformType, y=None, **fit_params) -> TransformType:\\n X = self._validate_datafold_data(\\n X,\\n array_kwargs=dict(ensure_min_samples=max(2, self.n_kernel_eigenvectors)),\\n tsc_kwargs=dict(ensure_min_samples=max(2, self.n_kernel_eigenvectors)),\\n )\\n self.fit(X=X, y=y, **fit_params)\\n\\n return self._jointly_smooth_functions_\",\n \"def fit(self, x, y): \\n # *** START CODE HERE ***\\n y = y.reshape(y.shape[0], 1)\\n y_0 = (1 - y).reshape(y.shape)\\n m = y.shape[0]\\n m_0 = np.asscalar(np.sum(y_0))\\n m_1 = np.asscalar(np.sum(y))\\n # Find phi, mu_0, mu_1, and sigma\\n phi = np.sum(y) / m\\n mu_0 = (np.sum(np.multiply(y_0, x), axis = 0, keepdims = True) / m_0) #.reshape(y.shape)\\n mu_1 = np.sum(np.multiply(y, x), axis = 0, keepdims=True) / m_1\\n sigma = getsigma(x, mu_0, mu_1, m, y, y_0)\\n # Write theta in terms of the parameters\\n sigma_inv = np.linalg.inv(sigma)\\n log_phi = np.log(np.exp(-1 * np.log(phi)) - 1)\\n theta_0 = (np.dot(np.dot(mu_0, sigma_inv), mu_0.T) - np.dot(np.dot(mu_1, sigma_inv), mu_1.T)) / 2 - log_phi\\n self.theta = np.concatenate((theta_0, np.dot(sigma_inv, (mu_1 - mu_0).T)))\\n # Compute cost\\n x_0 = np.zeros((x.shape[0], 1)) + 1\\n x_train = np.concatenate((x_0.T, x.T))\\n h_theta = sigmoid(np.dot(self.theta.T, x_train)).T\\n cost = - np.sum(np.dot(y.T, np.log(h_theta - (h_theta - 0.5) * self.eps)) + (np.dot(y_0.T, np.log(1 - h_theta + (h_theta - 0.5) * self.eps)))) / m\\n if self.verbose:\\n print(\\\"Cost: \\\" + str(cost))\\n # *** END CODE HERE ***\",\n \"def fit(model, input: str, output: str):\\n print(f\\\"Fitting model of type: {model}\\\")\\n\\n # Define the model. Use a randomized search to efficiently explore the\\n # hyperparameter space in a limited time.\\n if model == \\\"logistic\\\":\\n # Primal logistic regression\\n param_dist = {\\n 'C': loguniform(0.1, 100), 'max_iter': [250], 'fit_intercept': [True],\\n 'intercept_scaling': [1], 'penalty': ['l2'], 'tol': loguniform(1e-6, 1e-4)\\n }\\n mdl_cv = RandomizedSearchCV(LogisticRegression(solver='lbfgs'), param_dist, cv=3, refit=True, verbose=2, n_iter=10)\\n elif model == \\\"rand_forest\\\":\\n # Random Forest classifier\\n param_dist = {'max_depth': randint(3,8), 'max_features': randint(2,9), 'n_estimators': randint(50, 100),\\n 'min_samples_split': randint(3, 7)}\\n mdl_cv = RandomizedSearchCV(RandomForestClassifier(), param_dist, cv=3, refit=True, verbose=2, n_iter=10)\\n elif model == \\\"gradient_boost\\\":\\n # Extreme Gradient Boost classifier\\n param_dist = {'max_depth': [3, 4], 'gamma': loguniform(1e-3, 1e-2), 'min_child_weight': randint(1, 10),\\n 'learning_rate': loguniform(0.05, 0.3), 'n_estimators': randint(10, 40)}\\n mdl_cv = RandomizedSearchCV(XGBClassifier(), param_dist, cv=3, refit=True, verbose=2, n_iter=10)\\n else:\\n raise NotImplementedError(f\\\"Don't know how to train model of type: {model}.\\\\nValid options are: logistic, rand_forest, gradient_boost.\\\")\\n\\n # Define x (input data) and y (target data)\\n df = pd.read_csv(input)\\n x = df.loc[:, df.columns != 'Exited']\\n y = df.Exited\\n print(f\\\"Data has x.shape = {x.shape} and y.shape = {y.shape}\\\")\\n\\n # Fit the model with randomized search\\n mdl_cv.fit(x, y)\\n\\n # Print some results\\n print(\\\"Best score:\\\", mdl_cv.best_score_)\\n print(\\\"Best params:\\\", pprint.pformat(mdl_cv.best_params_))\\n\\n # Save to data store\\n os.makedirs(os.path.dirname(output), exist_ok=True)\\n with open(output, \\\"wb\\\") as f:\\n joblib.dump(mdl_cv.best_estimator_, f)\",\n \"def fit(self, X, y, sample_weight=...):\\n ...\",\n \"def fit_transform(self, X, y=None):\\n out = self.transform(X)\\n self.learn_types(X, out)\\n return self.transform(X)\",\n \"def fit(self, X: np.ndarray, y: np.ndarray, **kwargs) -> \\\"TSSine\\\":\\n if self.random_state is not None:\\n np.random.seed(self.random_state)\\n\\n guess = self._make_initial_guess(X=X, y=y)\\n\\n try:\\n popt = scipy.optimize.curve_fit(\\n self._func, X.ravel(), y, p0=guess, check_finite=False\\n )[0]\\n\\n self.A, self.w, self.p, self.c = popt\\n\\n self._fitted = True\\n\\n except RuntimeError:\\n self._fitted = False\\n\\n return self\",\n \"def fit(self, X, y=..., sample_weight=...):\\n ...\",\n \"def fit(self, X):\\n self._fit_X = X\",\n \"def ts_fit(series: TimeSeries) -> TimeSeries:\\n pass\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def fit_training_data(self):\\n self.model.fit(self.X_train)\",\n \"def fit(self, X, y=None, **fit_params):\\n return self\",\n \"def fit(self, X):\\n raise NotImplementedError('Abstract method \\\"fit\\\" must be '\\n 'specialised!')\",\n \"def fit(self):\\n raise NotImplementedError # pragma: no cover\",\n \"def partial_fit(self, X, y=...):\\n ...\",\n \"def partial_fit(self, X, y=...):\\n ...\",\n \"def fit(self, data, data_val, model=None, *args, **kwargs):\\n res = self._prepare_fit(model, data, data_val, generator=False,\\n delay=False, *args, **kwargs)\\n return res\",\n \"def test_fit(self):\\n X = self.generate_X()\\n task = mmRDTR()\\n fit_result = task.fit(X)\",\n \"def fit_test(self):\",\n \"def _fit(self, _X, _y):\\n\\n self.model = linear_model.LogisticRegression(penalty=self.penalty, random_state=self.seed,\\n solver='saga', n_jobs=self.n_jobs)\\n self.model.fit(_X, _y)\",\n \"def fit_model(self):\\n logger.info('Fitting model')\\n if self.traj_dict is None:\\n self.traj_dict = self.get_traj_dict()\\n self.model.fit(self.traj_dict.values())\",\n \"def fit_model(func, xdata, ydata, yerrdata, p0):\\n popt, pcov = curve_fit(func, xdata, ydata, p0=p0, sigma=yerrdata)\\n # the function evaluated at the output parameters\\n fvec = lambda x: func(x, *popt)\\n # degree of freedom\\n dof = len(xdata) - len(popt) - 1\\n # chi squared\\n chisq = np.sum(((ydata - fvec(xdata)) / yerrdata) ** 2)\\n # one standard deviation errors on the parameters\\n perr = np.sqrt(np.diag(pcov))\\n infodict = {\\n 'fvec': fvec,\\n 'dof': dof,\\n 'chisq': chisq,\\n 'perr': perr\\n }\\n return (popt, infodict)\",\n \"def _fit(self, X: TimeSeriesInstances, y=None) -> np.ndarray:\\n raise NotImplementedError\",\n \"def fit(self, X, Y, **kwargs):\\n raise NotImplementedError\",\n \"def fit(self, data):\\n return self\",\n \"def fit_model(self):\\r\\n\\t\\tself.mu = np.mean(self.x, axis = 0)\\r\\n\\t\\tself.sig = np.std(self.x, axis = 0)\",\n \"def fit(self, X, y=None):\\n # assume a pandas.DataFrame compatible object\\n out = self.act_on(X)\\n self.learn_types(X, out)\\n return self\",\n \"def _fit(self, x_train, y_train, x_valid, y_valid, regressor_callback=None):\",\n \"def fit(self, X, y, sample_weight=..., **fit_params):\\n ...\",\n \"def fit(self, X: TransformType, y=None, **fit_params) -> \\\"JointlySmoothFunctions\\\":\\n X = self._validate_datafold_data(\\n X=X,\\n array_kwargs=dict(\\n ensure_min_samples=max(2, self.n_kernel_eigenvectors + 1)\\n ),\\n tsc_kwargs=dict(ensure_min_samples=max(2, self.n_kernel_eigenvectors + 1)),\\n )\\n\\n self._setup_feature_attrs_fit(\\n X=X,\\n features_out=[f\\\"jsf{i}\\\" for i in range(self.n_jointly_smooth_functions)],\\n )\\n\\n column_splitter = _ColumnSplitter(self.datasets)\\n self.observations_ = column_splitter.split(X)\\n\\n self._calculate_kernel_matrices()\\n\\n self._calculate_kernel_eigensystem()\\n\\n (\\n self._jointly_smooth_functions_,\\n self._eigenvalues_,\\n ) = self._calculate_jointly_smooth_functions()\\n\\n return self\",\n \"def fit(ydata):\\n xdata = np.linspace(0,len(ydata),num = len(ydata))\\n popt, pcov = curve_fit(func, xdata, ydata)\\n #returns the parameters of the fitting\\n return popt\",\n \"def fit(self, x):\\n x = np.asarray(x)\\n _ = self.fit_transform(x)\",\n \"def fit_curve(x,y,p0,func):\\n ifixx = np.zeros(np.array(x).shape)\\n data = sodr.Data(x,y)\\n model = sodr.Model(func)\\n worker = sodr.ODR(data,model,p0,ifixx=ifixx,maxit=500)\\n out = worker.run()\\n out = worker.restart()\\n return out\",\n \"def fit(\\n self,\\n X: FEATURES | None = None,\\n y: TARGET | None = None,\\n **fit_params,\\n ):\\n X, y = self._prepare_input(X, y)\\n self._check_feature_names(X, reset=True)\\n self._check_n_features(X, reset=True)\\n\\n self.log(f\\\"Fitting {self.__class__.__name__}...\\\", 1)\\n\\n return self\",\n \"def do_fit(self):\\n\\n if (self._flag == 1):\\n self._gf = [0.2]\\n self._gf = self.par*(self._num_fu*len(self._sites)*2)\\n x, F = self.read_from_file(\\n self._sn, self._qn, self._path) # read data from the file\\n # ,ftol=1.0e-7,xtol=1.0e-8)\\n popt, pcov = curve_fit(\\n self.modelfun, x, F, p0=self._gf, maxfev=5000)\\n self._gf = popt\\n\\n elif (self._flag == 2):\\n\\n# par=[0.0]*(self._num_fu*5)\\n# for j in range(self._num_fu):\\n# par[j*5]=0.0*math.copysign(1,(pow(-1,j)))\\n# self._gf[j*5]=0.1\\n# par[j*5+1]=6.45\\n# par[j*5+2]=0.0\\n# par[j*5+3]=0.05\\n# par[j*5+4]=1.0\\n\\n X, F = self.read_from_file(self._sn, self._qn, self._path) # read data from the file\\n\\n# height, xx, width=self.moments(F)\\n# Tracer()()\\n# par=[0.0]*(self._num_fu*5)\\n# for j in range(self._num_fu):\\n# par[j*5]=x[0,xx]\\n# par[j*5]=X[0,xx]*math.copysign(1,(pow(-1,j)))\\n# par[j*5+1]=X[1,xx]\\n# par[j*5+2]=X[2,xx]\\n# par[j*5+3]=0.007\\n# par[j*5+4]=height*math.copysign(1,(pow(-1,j)))\\n\\n xi, yi, zi = np.mgrid[-6.5:6.5:160j, 4.0:8.9:160j, -7.5:7.5:160j]\\n x, y, z = xi.flatten(), yi.flatten(), zi.flatten()\\n XX = np.vstack((x, y, z))\\n\\n invdisttree = Invdisttree(X.T, F, leafsize=10, stat=1)\\n AA = invdisttree(XX.T, nnear=130, eps=0, p=1)\\n\\n# aaa1,bbb1=self.detect_local_minima(-AA.reshape(xi.shape))\\n# aaa2,bbb2=self.detect_local_maxima(-AA.reshape(xi.shape))\\n if self.peaks==[]:\\n print('\\\\n---------------------------------------------------------------------')\\n print('Detecting maxima and minima of target function...',)\\n\\n peaks_min, min_coord, peaks_max, max_coord = self.detect_min_max(AA.reshape(xi.shape))\\n print('done')\\n print('Number of the min peaks: {}'.format(len(peaks_min)))\\n print('Number of the max peaks: {}'.format(len(peaks_max)))\\n print('---------------------------------------------------------------------\\\\n')\\n # fig=plt.figure()\\n # ax = fig.add_subplot(111, projection='3d')\\n # ax.plot_surface(xi[:,:,60],yi[:,:,60],bbb2[:,:,60], cmap=cm.jet, linewidth=0.2)\\n # plt.hold(True)\\n # plt.show()\\n\\n if peaks_max==[]:\\n peaks=np.insert(peaks_min, np.arange(len(peaks_max)), peaks_max)\\n coords=np.insert(min_coord, np.arange(max_coord.shape[1]), max_coord, axis=1)\\n else:\\n peaks = np.insert(peaks_max, np.arange(len(peaks_min)), peaks_min)\\n coords = np.insert(max_coord, np.arange(min_coord.shape[1]), min_coord, axis=1)\\n\\n self.peaks=peaks\\n self.coords=coords\\n\\n par = [0.0]*(self._num_fu*5)\\n j1 = 0\\n aaaa = 1\\n for j in range(self._num_fu):\\n if (j > aaaa*self.coords.shape[1]-1):\\n j1 = 0\\n aaaa += 1\\n par[j*5] = xi[self.coords[0, j1], self.coords[0, j1], self.coords[0, j1]]\\n par[j*5+1] = yi[self.coords[1, j1], self.coords[1, j1], self.coords[1, j1]]\\n par[j*5+2] = zi[self.coords[2, j1], self.coords[2, j1], self.coords[2, j1]]\\n # par[j*5+3] = 0.1003+0.1000*math.copysign(1, (pow(-1, j)))\\n par[j*5+3] = 0.0001\\n# if j < 15:\\n# par[j*5+3] = 0.00001\\n# else:\\n# par[j*5+3] = 0.0005\\n par[j*5+4] = self.peaks[j1]\\n# print(coords[0, j1], coords[1, j1], coords[2, j1])\\n j1 += 1\\n # popt, pcov = curve_fit(self.modelfun1, x[:,1:20000], F[1:20000],p0=par,maxfev=150000,xtol=1e-8,ftol=1e-8)\\n popt, pcov = curve_fit(\\n self.modelfun1, X, F, p0=par, maxfev=150000, xtol=1e-6,\\n ftol=1e-8)\\n # popt, pcov = curve_fit(self.modelfun1, XX, AA, p0=par)\\n self._gf = popt\\n# self.error=np.diagonal(pcov, offset=0)\\n# print(pcov)\\n else:\\n # pass\\n sys.exit(\\\"Wrong flag in do_fit\\\")\",\n \"def _fit(self, X, y):\\n return BaseTimeSeriesForest._fit(self, X, y)\",\n \"def fit(self):\\n # Initialize parameter estimates\\n if self.estimator is not None:\\n param_estimates = self.estimator(self.xf, self.yf)\\n else: param_estimates = None\\n self.popt, self.pcov = curve_fit(self.model, self.xf, self.yf, \\n p0=param_estimates)\\n self.fit_history.append({\\\"popt\\\" : self.popt, \\\"pcov\\\" : self.pcov})\",\n \"def fitRegressor(self, data):\\r\\n if data.SETS == 2:\\r\\n self.regressor.fit(data.trainX, data.trainy)\",\n \"def fit(self, x: np.array, t: np.array, y: np.array) -> None:\\n\\n self.forest.fit(x, y)\",\n \"def fit(self, X, y):\\n self.X_data = X\\n self.y = y\",\n \"def fit(self, X, y=None):\\n #import pdb\\n #pdb.set_trace()\\n return self.partial_fit(X, y)\",\n \"def fit(self, X, Y):\\n if self.model is None:\\n print(\\\"%s.fit: implement me\\\" % (self.__class__.__name__))\",\n \"def partial_fit(self, X, y=..., **fit_params):\\n ...\",\n \"def fit(self, X: np.ndarray, y: np.ndarray, **kwargs) -> \\\"TSExp\\\":\\n b_0 = y[-1] / y[-2]\\n a_0 = 0.1\\n c_0 = 0\\n guess = np.asarray([a_0, b_0, c_0], dtype=float)\\n\\n try:\\n popt = scipy.optimize.curve_fit(\\n self._func, X.ravel(), y, p0=guess, check_finite=False\\n )[0]\\n\\n self.a, self.b, self.c = popt\\n\\n self._fitted = True\\n\\n except RuntimeError:\\n self._fitted = False\\n\\n return self\",\n \"def _fit(self, y, X, fh):\\n names, forecasters = self._check_forecasters()\\n self._fit_forecasters(forecasters, y, X, fh)\\n return self\",\n \"def fit(self, data):\\n if data is None:\\n self.train_self()\\n else:\\n # not needed this week\\n pass\",\n \"def fit(self) -> None:\\n start_time = time.time()\\n # ---- START -----\\n train_df = self.processed_train_df[self.processed_train_df[self.filter_col_name]].dropna()\\n train_features = train_df[self.feature_list]\\n for label, model in zip(self.label_list, self.models):\\n model.fit(train_features, train_df[label])\\n # ---- END -----\\n end_time = time.time()\\n print(\\\"Finished fitting : elasped time : \\\" + str(end_time - start_time))\",\n \"def fit(self, *_):\\n return self\",\n \"def fit(self, *_):\\n return self\",\n \"def fit(self, *_):\\n return self\",\n \"def fit(self):\\n self.eval_chisq([1, 1, 1, 1])\",\n \"def set_fit_params(self):\\n\\n self.p0 = np.array([self.A_arr, self.T_a])\\n # initial guess at A_arr and T_a\\n\\n self.popt, self.pcov = curve_fit(\\n self.get_eta_fit, self.T_exp, self.eta_exp, p0=self.p0\\n )\\n\\n self.A_arr = self.popt[0]\\n self.T_a = self.popt[1]\\n\\n self.T_array = self.T_model\",\n \"def fit_model(function,\\n energy_fit,\\n eqe_fit,\\n p0=None,\\n include_disorder=False\\n ):\\n\\n if p0 is None: # if no guess is given, initialize with ones. This is consistent with curve_fit.\\n if include_disorder:\\n p0 = [1, 1, 1, 1]\\n else:\\n p0 = [1, 1, 1]\\n\\n gmodel = Model(function)\\n\\n gmodel.set_param_hint('Ect', min=0, max=1.6)\\n # gmodel.set_param_hint('Ect', min=0, max=1.7)\\n gmodel.set_param_hint('l', min=0, max=0.6) # changed from 0.4\\n gmodel.set_param_hint('f', min=0, max=0.1) # changed from 0.4\\n\\n if include_disorder:\\n gmodel.set_param_hint('sig', min=0, max=0.2)\\n\\n result = gmodel.fit(eqe_fit,\\n f=p0[0],\\n l=p0[1],\\n Ect=p0[2],\\n sig=p0[3],\\n E=energy_fit\\n )\\n\\n f = float(result.params['f'].value)\\n l = float(result.params['l'].value)\\n Ect = float(result.params['Ect'].value)\\n sig = float(result.params['sig'].value)\\n\\n best_vals = [f, l, Ect, sig]\\n\\n covar = result.covar\\n if covar is None:\\n covar = np.zeros((4, 4))\\n\\n y_fit = gmodel.eval(E=np.array(energy_fit),\\n f=f,\\n l=l,\\n Ect=Ect,\\n sig=sig\\n )\\n else:\\n result = gmodel.fit(eqe_fit,\\n f=p0[0],\\n l=p0[1],\\n Ect=p0[2],\\n E=energy_fit\\n )\\n\\n f = float(result.params['f'].value)\\n l = float(result.params['l'].value)\\n Ect = float(result.params['Ect'].value)\\n\\n best_vals = [f, l, Ect]\\n\\n covar = result.covar\\n if covar is None:\\n covar = np.zeros((4, 4))\\n\\n y_fit = gmodel.eval(E=np.array(energy_fit),\\n f=f,\\n l=l,\\n Ect=Ect\\n )\\n\\n r_squared = R_squared(eqe_fit, y_fit)\\n\\n return best_vals, covar, y_fit, r_squared\",\n \"def fit(self, X, y=None, groups=None, type=\\\"Classifier\\\",**fit_params):\\n if self.fit_params is not None:\\n warnings.warn('\\\"fit_params\\\" as a constructor argument was '\\n 'deprecated in version 0.19 and will be removed '\\n 'in version 0.21. Pass fit parameters to the '\\n '\\\"fit\\\" method instead.', DeprecationWarning)\\n if fit_params:\\n warnings.warn('Ignoring fit_params passed as a constructor '\\n 'argument in favor of keyword arguments to '\\n 'the \\\"fit\\\" method.', RuntimeWarning)\\n else:\\n fit_params = self.fit_params\\n #estimator = self.estimator\\n\\n if type == \\\"Classification\\\":\\n from keras.wrappers.scikit_learn import KerasClassifier\\n estimator = KerasClassifier(build_fn=self.estimator, verbose=0)\\n else:\\n from keras.wrappers.scikit_learn import KerasRegressor\\n estimator = KerasRegressor(build_fn=self.estimator, verbose=0)\\n cv = check_cv(self.cv, y, classifier=is_classifier(estimator))\\n\\n scorers, self.multimetric_ = _check_multimetric_scoring(\\n clone(estimator), scoring=self.scoring)\\n\\n if self.multimetric_:\\n if self.refit is not False and (\\n not isinstance(self.refit, six.string_types) or\\n # This will work for both dict / list (tuple)\\n self.refit not in scorers):\\n raise ValueError(\\\"For multi-metric scoring, the parameter \\\"\\n \\\"refit must be set to a scorer key \\\"\\n \\\"to refit an estimator with the best \\\"\\n \\\"parameter setting on the whole data and \\\"\\n \\\"make the best_* attributes \\\"\\n \\\"available for that metric. If this is not \\\"\\n \\\"needed, refit should be set to False \\\"\\n \\\"explicitly. %r was passed.\\\" % self.refit)\\n else:\\n refit_metric = self.refit\\n else:\\n refit_metric = 'score'\\n\\n X, y, groups = indexable(X, y, groups)\\n n_splits = cv.get_n_splits(X, y, groups)\\n # Regenerate parameter iterable for each fit\\n candidate_params = list(self._get_param_iterator())\\n n_candidates = len(candidate_params)\\n if self.verbose > 0:\\n print(\\\"Fitting {0} folds for each of {1} candidates, totalling\\\"\\n \\\" {2} fits\\\".format(n_splits, n_candidates,\\n n_candidates * n_splits))\\n\\n base_estimator = self.estimator\\n pre_dispatch = self.pre_dispatch\\n # One of the main changes is instead of using the _fit_and_score from sklearn.model_selection._validation\\n # We use a modified one (_fit_and_score_keras) that clears the session after each iteration\\n out = Parallel(\\n n_jobs=self.n_jobs, verbose=self.verbose,\\n pre_dispatch=pre_dispatch\\n )(delayed(_fit_and_score_keras2)(base_estimator, X, y, scorers, train,\\n test, self.verbose, parameters,\\n fit_params=fit_params,\\n return_train_score=self.return_train_score,\\n return_n_test_samples=True,\\n return_times=True, return_parameters=False,\\n error_score=self.error_score,\\n type=type) # Passing the session (Keras backend) argument\\n for parameters, (train, test) in product(candidate_params,\\n cv.split(X, y, groups)))\\n\\n # if one choose to see train score, \\\"out\\\" will contain train score info\\n if self.return_train_score:\\n (train_score_dicts, test_score_dicts, test_sample_counts, fit_time,\\n score_time) = zip(*out)\\n else:\\n (test_score_dicts, test_sample_counts, fit_time,\\n score_time) = zip(*out)\\n\\n # test_score_dicts and train_score dicts are lists of dictionaries and\\n # we make them into dict of lists\\n test_scores = _aggregate_score_dicts(test_score_dicts)\\n if self.return_train_score:\\n train_scores = _aggregate_score_dicts(train_score_dicts)\\n\\n results = dict()\\n\\n def _store(key_name, array, weights=None, splits=False, rank=False):\\n \\\"\\\"\\\"A small helper to store the scores/times to the cv_results_\\\"\\\"\\\"\\n # When iterated first by splits, then by parameters\\n # We want `array` to have `n_candidates` rows and `n_splits` cols.\\n array = np.array(array, dtype=np.float64).reshape(n_candidates,\\n n_splits)\\n if splits:\\n for split_i in range(n_splits):\\n # Uses closure to alter the results\\n results[\\\"split%d_%s\\\"\\n % (split_i, key_name)] = array[:, split_i]\\n\\n array_means = np.average(array, axis=1, weights=weights)\\n results['mean_%s' % key_name] = array_means\\n # Weighted std is not directly available in numpy\\n array_stds = np.sqrt(np.average((array -\\n array_means[:, np.newaxis]) ** 2,\\n axis=1, weights=weights))\\n results['std_%s' % key_name] = array_stds\\n\\n if rank:\\n results[\\\"rank_%s\\\" % key_name] = np.asarray(\\n rankdata(-array_means, method='min'), dtype=np.int32)\\n\\n _store('fit_time', fit_time)\\n _store('score_time', score_time)\\n # Use one MaskedArray and mask all the places where the param is not\\n # applicable for that candidate. Use defaultdict as each candidate may\\n # not contain all the params\\n param_results = defaultdict(partial(MaskedArray,\\n np.empty(n_candidates,),\\n mask=True,\\n dtype=object))\\n for cand_i, params in enumerate(candidate_params):\\n for name, value in params.items():\\n # An all masked empty array gets created for the key\\n # `\\\"param_%s\\\" % name` at the first occurence of `name`.\\n # Setting the value at an index also unmasks that index\\n param_results[\\\"param_%s\\\" % name][cand_i] = value\\n\\n results.update(param_results)\\n # Store a list of param dicts at the key 'params'\\n results['params'] = candidate_params\\n\\n # NOTE test_sample counts (weights) remain the same for all candidates\\n test_sample_counts = np.array(test_sample_counts[:n_splits],\\n dtype=np.int)\\n for scorer_name in scorers.keys():\\n # Computed the (weighted) mean and std for test scores alone\\n _store('test_%s' % scorer_name, test_scores[scorer_name],\\n splits=True, rank=True,\\n weights=test_sample_counts if self.iid else None)\\n if self.return_train_score:\\n _store('train_%s' % scorer_name, train_scores[scorer_name],\\n splits=True)\\n\\n # For multi-metric evaluation, store the best_index_, best_params_ and\\n # best_score_ iff refit is one of the scorer names\\n # In single metric evaluation, refit_metric is \\\"score\\\"\\n if self.refit or not self.multimetric_:\\n self.best_index_ = results[\\\"rank_test_%s\\\" % refit_metric].argmin()\\n self.best_params_ = candidate_params[self.best_index_]\\n self.best_score_ = results[\\\"mean_test_%s\\\" % refit_metric][\\n self.best_index_]\\n\\n if self.refit:\\n from keras import backend as K\\n import tensorflow as tf\\n tf.logging.set_verbosity(tf.logging.ERROR) # This is useful to avoid the info log of tensorflow\\n # The next 4 lines are for avoiding tensorflow to allocate all the GPU memory\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n sess = tf.Session(config=config)\\n K.set_session(sess)\\n\\n self.best_estimator_ = clone(estimator).set_params(\\n **self.best_params_)\\n if y is not None:\\n self.best_estimator_.fit(X, y, **fit_params)\\n else:\\n self.best_estimator_.fit(X, **fit_params)\\n\\n # Store the only scorer not as a dict for single metric evaluation\\n self.scorer_ = scorers if self.multimetric_ else scorers['score']\\n\\n self.cv_results_ = results\\n self.n_splits_ = n_splits\\n\\n return self\",\n \"def fit(self,X,y=None,**fit_params):\\n return self\",\n \"def test_fit():\\n tpot_obj = TPOTClassifier(random_state=42, population_size=1, generations=1, verbosity=0)\\n tpot_obj.fit(training_features, training_classes)\\n\\n assert isinstance(tpot_obj._optimized_pipeline, creator.Individual)\\n assert tpot_obj._gp_generation == 0\\n assert not (tpot_obj._start_datetime is None)\",\n \"def _model_fit_term(self):\\n if self.likelihood.YYT is None:\\n return -0.5*np.sum(np.square(np.dot(self.Li,self.likelihood.Y)))\\n else:\\n return -0.5*np.sum(np.multiply(self.Ki, self.likelihood.YYT))\",\n \"def fit(self, X, y):\\n self.model = self._initialize_model(X, y)\\n self.model.optimize()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.676812","0.66434413","0.65392","0.65392","0.65392","0.65392","0.65392","0.65392","0.65392","0.65392","0.65392","0.65392","0.65289134","0.65289134","0.65289134","0.6508119","0.64726126","0.6317388","0.63038385","0.630345","0.6261615","0.6215944","0.6215944","0.62157124","0.6209384","0.6206136","0.61985433","0.60388017","0.60057855","0.5978634","0.5974462","0.59052503","0.5904058","0.5864261","0.5840939","0.57773286","0.57640153","0.5752115","0.57462543","0.5745733","0.57408166","0.57210416","0.5697682","0.56910145","0.569045","0.56878597","0.5687189","0.5679478","0.5679478","0.5679478","0.5679478","0.5679478","0.56787574","0.56775326","0.56550384","0.56501","0.56308866","0.56308866","0.5628693","0.561859","0.56180364","0.56167275","0.56065166","0.5576529","0.55603737","0.55576134","0.5557566","0.5545872","0.55306214","0.5518507","0.5518121","0.55179554","0.55129606","0.5508488","0.54978496","0.5491401","0.5489787","0.54833215","0.54824644","0.5480743","0.5480536","0.54785335","0.54647255","0.54545516","0.54498386","0.5448883","0.5433743","0.54261184","0.5414037","0.5413014","0.5413014","0.5413014","0.540987","0.54087925","0.5407756","0.54074895","0.5404138","0.5393153","0.53877276","0.53852373"],"string":"[\n \"0.676812\",\n \"0.66434413\",\n \"0.65392\",\n \"0.65392\",\n \"0.65392\",\n \"0.65392\",\n \"0.65392\",\n \"0.65392\",\n \"0.65392\",\n \"0.65392\",\n \"0.65392\",\n \"0.65392\",\n \"0.65289134\",\n \"0.65289134\",\n \"0.65289134\",\n \"0.6508119\",\n \"0.64726126\",\n \"0.6317388\",\n \"0.63038385\",\n \"0.630345\",\n \"0.6261615\",\n \"0.6215944\",\n \"0.6215944\",\n \"0.62157124\",\n \"0.6209384\",\n \"0.6206136\",\n \"0.61985433\",\n \"0.60388017\",\n \"0.60057855\",\n \"0.5978634\",\n \"0.5974462\",\n \"0.59052503\",\n \"0.5904058\",\n \"0.5864261\",\n \"0.5840939\",\n \"0.57773286\",\n \"0.57640153\",\n \"0.5752115\",\n \"0.57462543\",\n \"0.5745733\",\n \"0.57408166\",\n \"0.57210416\",\n \"0.5697682\",\n \"0.56910145\",\n \"0.569045\",\n \"0.56878597\",\n \"0.5687189\",\n \"0.5679478\",\n \"0.5679478\",\n \"0.5679478\",\n \"0.5679478\",\n \"0.5679478\",\n \"0.56787574\",\n \"0.56775326\",\n \"0.56550384\",\n \"0.56501\",\n \"0.56308866\",\n \"0.56308866\",\n \"0.5628693\",\n \"0.561859\",\n \"0.56180364\",\n \"0.56167275\",\n \"0.56065166\",\n \"0.5576529\",\n \"0.55603737\",\n \"0.55576134\",\n \"0.5557566\",\n \"0.5545872\",\n \"0.55306214\",\n \"0.5518507\",\n \"0.5518121\",\n \"0.55179554\",\n \"0.55129606\",\n \"0.5508488\",\n \"0.54978496\",\n \"0.5491401\",\n \"0.5489787\",\n \"0.54833215\",\n \"0.54824644\",\n \"0.5480743\",\n \"0.5480536\",\n \"0.54785335\",\n \"0.54647255\",\n \"0.54545516\",\n \"0.54498386\",\n \"0.5448883\",\n \"0.5433743\",\n \"0.54261184\",\n \"0.5414037\",\n \"0.5413014\",\n \"0.5413014\",\n \"0.5413014\",\n \"0.540987\",\n \"0.54087925\",\n \"0.5407756\",\n \"0.54074895\",\n \"0.5404138\",\n \"0.5393153\",\n \"0.53877276\",\n \"0.53852373\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61368084"},"document_rank":{"kind":"string","value":"27"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":917,"numItemsPerPage":100,"numTotalItems":95772,"offset":91700,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTYxNDU3NiwianRpIjoiMGJlYTdmODMtODQ4Yi00MTI2LTgzZTEtMGY4OTkzZjFmNWI4Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU2MTgxNzYsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.X8dnagBRFumVFPnR_obZrpYv0X_ISSFAmACzXulv4YqEDjSwntcHAYXrkXzWINaQGeYDL8AC8IumRsch8sOtBQ","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 |
|---|---|---|---|---|---|---|
Displays statistics on the most frequent times of travel. | def time_stats(df):
print("="*40)
print('\nCalculating The Most Frequent Times of Travel...\n')
start_time = time.time()
most_freq_hour = str(df.groupby(['hour'])['Start Time'].count().idxmax())
high_hour_qty = str(df.groupby(['hour'])['Start Time'].count().max())
if len(df['weekday'].unique... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def time_stats(df):\n\n print('\\nDisplaying the statistics on the most frequent times of '\n 'travel...\\n')\n start_time = time.time()\n\n # display the most common month\n most_common_month = df['Month'].mode()[0]\n print('For the selected filter, the month with the most travels is: ' +\... | [
"0.80247396",
"0.80233026",
"0.7915788",
"0.78266186",
"0.7822246",
"0.78143597",
"0.77659196",
"0.7740343",
"0.773628",
"0.77344066",
"0.76867086",
"0.7668633",
"0.7651731",
"0.7644636",
"0.76399267",
"0.76367253",
"0.7625196",
"0.7623158",
"0.7612803",
"0.76002145",
"0.7583... | 0.0 | -1 |
Displays statistics on the most popular stations and trip. | def station_stats(df):
print('\nCalculating The Most Popular Stations and Trip...\n')
start_time = time.time()
# TO DO: display most commonly used start station
start_station_high_freq = df.groupby(['Start Station'])['Start Time'].count().idxmax()
start_station_high_qty = df.groupby(['Start Statio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def station_stats(df):\n\n print('\\nCalculating The Most Popular Stations and Trip...\\n')\n start_time = time.time()\n\n # display most commonly used start station\n print(popular_start_station(df))\n\n # display most commonly used end station\n print(popular_end_station(df))\n\n # display m... | [
"0.7815675",
"0.7662213",
"0.7553417",
"0.74914914",
"0.74748665",
"0.7446617",
"0.7428588",
"0.74237514",
"0.74177027",
"0.7400495",
"0.7387161",
"0.7385634",
"0.73647535",
"0.735934",
"0.73566747",
"0.73548365",
"0.7351854",
"0.7351274",
"0.735057",
"0.73421645",
"0.7340198... | 0.69124997 | 83 |
Displays statistics on the total and average trip duration. | def trip_duration_stats(df):
print('\nCalculating Trip Duration...\n')
start_time = time.time()
df['time'] = df['End Time'] - df['Start Time']
# TO DO: display total travel time
print("Total travel time in that period of time: {}".format(df['time'].sum()))
print("Average time of journey: {}".f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trip_duration_stats(data):\n print('\\nCalculating Trip Duration...\\n')\n start_time = time.time()\n # display total travel time\n total_trip_time= data['Trip Duration'].sum()\n print('The Total Travel Time is {} Hours'. format(total_trip_time/3600))\n # display mean travel time\n avg_tri... | [
"0.8141812",
"0.8024182",
"0.80032814",
"0.7948688",
"0.79363805",
"0.79301584",
"0.7925556",
"0.79139745",
"0.79132074",
"0.79069036",
"0.79044855",
"0.7899693",
"0.78905743",
"0.7888294",
"0.78858185",
"0.7883996",
"0.78832155",
"0.7881429",
"0.7872763",
"0.78675747",
"0.78... | 0.76539797 | 78 |
Displays statistics on bikeshare users. | def user_stats(df):
print('\nCalculating User Stats...\n')
start_time = time.time()
# TO DO: Display counts of user types
user_types = df.groupby(['User Type'])['Start Time'].count()
print(user_types.to_string())
print()
try:
# TO DO: Display counts of gender
gender = df.g... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_stats(request):\r\n user_count = UserMgr.count()\r\n pending_activations = ActivationMgr.count()\r\n users_with_bookmarks = BmarkMgr.count(distinct_users=True)\r\n return _api_response(request, {\r\n 'count': user_count,\r\n 'activations': pending_activations,\r\n 'with_bo... | [
"0.73559105",
"0.73306274",
"0.7287611",
"0.72494894",
"0.72382116",
"0.71733415",
"0.7168679",
"0.7129041",
"0.7076894",
"0.7071431",
"0.70602304",
"0.7056935",
"0.70490867",
"0.7045232",
"0.703642",
"0.70238316",
"0.7022488",
"0.7022265",
"0.7012312",
"0.70086145",
"0.69945... | 0.0 | -1 |
Calculate the offset from the page number and number per page | def calculate_offset(page_number, per_page):
if page_number < 1:
return 0
else:
offset = (page_number - 1) * per_page
return offset | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_offset(page_num, per_page):\r\n if page_num and per_page:\r\n return (page_num-1) * per_page\r\n else:\r\n return None",
"def get_page_offset(self) -> int:\n page_offset: int = self.page_number\n if page_offset <= 1:\n return 0\n return (page_offset - 1)... | [
"0.77995265",
"0.76814127",
"0.7105734",
"0.6967159",
"0.6652218",
"0.6636704",
"0.64200956",
"0.63789934",
"0.63724935",
"0.63724935",
"0.63724935",
"0.633144",
"0.610982",
"0.60907185",
"0.6062406",
"0.60604966",
"0.6048903",
"0.6029713",
"0.6027081",
"0.5996911",
"0.598415... | 0.8489778 | 0 |
Lee un archivo con varias palabras. Retorna una palabra aleatoria | def get_file():
with open('archivos/words.txt','r',encoding = 'utf-8') as f :
data = f.readlines()
data = list(random.choice(data))
data.pop(len(data)-1)
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def criar_arquivo_palavras(nome_arquivo, palavras):\n with open(nome_arquivo, \"w\") as arquivo:\n for palavra in palavras:\n linha = palavra + \"\\n\" #precisamos adicionar uma quebra de linha manualmente \n arquivo.write(linha)\n return arquivo",
"def archivos_de_texto():\n ... | [
"0.6766486",
"0.6449598",
"0.6287659",
"0.553479",
"0.5336628",
"0.53295815",
"0.5316984",
"0.53126305",
"0.5292266",
"0.523313",
"0.5224726",
"0.5223712",
"0.52207124",
"0.5208644",
"0.51681054",
"0.51312065",
"0.51303893",
"0.5126915",
"0.5123113",
"0.5107597",
"0.5083478",... | 0.4792352 | 52 |
Recibe un str. Retorna incognita | def incognita(data):
incognita =['*' for i in data]
return incognita | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _sanitize_string(self, string):\n # get the type of a unicode string\n unicode_type = type(Pyasciigraph._u('t'))\n input_type = type(string)\n if input_type is str:\n if sys.version < '3':\n info = unicode(string)\n else:\n info = ... | [
"0.6074574",
"0.5833643",
"0.5798127",
"0.5772807",
"0.5772203",
"0.5725126",
"0.57122743",
"0.5701353",
"0.56956816",
"0.56872195",
"0.56736904",
"0.56647235",
"0.56609285",
"0.56522226",
"0.5646415",
"0.56392515",
"0.56258756",
"0.56158435",
"0.56100136",
"0.5609799",
"0.55... | 0.0 | -1 |
Se ejecuta un Ciclo while | def cycle(incognita,data,live=5,count=0):
while live > 0 and incognita != data:
letra_u = input('Digite una letra: ')
os.system('cls')
for i in data:
if i == letra_u:
incognita[count] = letra_u
count +=1
if letra_u not in ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loop(self):\n pass",
"def run(self):\n while not self.gerenciador.fechou():\n self.faz_ped()\n if self.beber:\n self.espera_ped()\n self.recebe_ped()\n self.consome_ped()",
"def run(self):\n while not self.gerenciador.f... | [
"0.6770653",
"0.65367323",
"0.64974135",
"0.648513",
"0.6402111",
"0.63691765",
"0.6359044",
"0.62001854",
"0.60994035",
"0.60834765",
"0.6077019",
"0.6066419",
"0.60516566",
"0.6025482",
"0.6013724",
"0.60018843",
"0.59823316",
"0.5937696",
"0.5913396",
"0.59045106",
"0.5872... | 0.0 | -1 |
Defines several fitting mechanism | def func(x, a, c, d):
return a*np.exp(-c*x)+d | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit():\n pass",
"def fit(self, X, y=...):\n ...",
"def fit(self, X, y=...):\n ...",
"def fit(self, X, y=...):\n ...",
"def fit(self, X, y=...):\n ...",
"def fit(self, X, y=...):\n ...",
"def fit(self, X, y=...):\n ...",
"def fit(self, X, y=...):\n ... | [
"0.68902004",
"0.6626131",
"0.6626131",
"0.6626131",
"0.6626131",
"0.6626131",
"0.6626131",
"0.6626131",
"0.6626131",
"0.6626131",
"0.6626131",
"0.63850355",
"0.6355559",
"0.63157564",
"0.6300085",
"0.62875515",
"0.6248649",
"0.62402546",
"0.6223098",
"0.62152815",
"0.6215281... | 0.0 | -1 |
This function finds a exponential decay | def exp_decay(timeList, voltageList, ySS=160):
parameters, _ = curve_fit(func, timeList, voltageList, p0=(1, 9, ySS), maxfev = 20000)
# voltageFit = func(timeList, *parameters)
return parameters | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_exp_decay(self, alpha: float):\n x = np.linspace(0, 1, 100)\n y = np.exp(alpha * x)\n\n alpha_guess = guess.exp_decay(x, y)\n\n self.assertAlmostEqualAbsolute(alpha_guess, alpha)",
"def get_epsilon_decay_function(e_start, e_end, decay_duration):\n return lambda frame_idx: ... | [
"0.728994",
"0.7148073",
"0.7136344",
"0.7002857",
"0.68007094",
"0.6703479",
"0.6644778",
"0.6634951",
"0.6614471",
"0.6605476",
"0.6572798",
"0.65458226",
"0.65170854",
"0.6478091",
"0.64659375",
"0.6409667",
"0.64091176",
"0.6402272",
"0.6372004",
"0.6354398",
"0.6350709",... | 0.6088513 | 31 |
This function finds a | def exp_fit(timeList, voltageList, ySS):
bList = [log(max(y-ySS,1e-6)) for y in voltageList]
b = np.matrix(bList).T
rows = [ [1,t] for t in timeList]
A = np.matrix(rows)
#w = (pinv(A)*b)
(w,residuals,rank,sing_vals) = np.linalg.lstsq(A,b)
tau = -1.0/w[1,0]
amplitude = np.exp(w[0,0])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find(self, a):\n while a != self.ids[a]:\n a = self.ids[a]\n return a",
"def find(self, p):\n pass",
"def find(self):\n raise NotImplementedError",
"def find(self, sub) -> int:\n pass",
"def findWhere(cls, args):\n return cls.search(args)[0][0]",
"def ... | [
"0.7021678",
"0.6964341",
"0.66085345",
"0.6586932",
"0.6296854",
"0.62866414",
"0.6269602",
"0.6150014",
"0.6115063",
"0.60636",
"0.60221916",
"0.6013292",
"0.6005816",
"0.599785",
"0.59703434",
"0.5959632",
"0.5916025",
"0.5914361",
"0.5910363",
"0.5887992",
"0.58734494",
... | 0.0 | -1 |
Uses PeakUtil package to find the peak Locations and returns them as a value. It is used to determine the V_rest while the spikes are present | def hist_peak_search(hist, bins):
ix = peakutils.indexes(-hist, thres = 0.15/max(-hist), min_dist = 2)
peaks = list(bins[list(ix)])
return peaks | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def peak(self) -> Tuple[MeasureInput, MeasureResult]:\n assert self._data\n return self._data[0][2]",
"def get_peak(self):\r\n \r\n sensor_1_list = []\r\n\r\n for i in self.return_data:\r\n sensor_1_list.append(i[0])\r\n\r\n sensor_peak = max(sensor_1_list)\r\... | [
"0.69582105",
"0.69230056",
"0.68650806",
"0.6772516",
"0.6591027",
"0.65485495",
"0.65162396",
"0.6395621",
"0.6379662",
"0.63583624",
"0.6291672",
"0.6255726",
"0.62526894",
"0.6248705",
"0.624049",
"0.62010884",
"0.6139666",
"0.6106271",
"0.6080114",
"0.60722214",
"0.60585... | 0.0 | -1 |
Uses PeakUtil package to find the baseline of the signal and returns it as a value. | def baseline_search(voltage, pol_degree):
min = np.min(voltage)
base = peakutils.baseline(voltage-min, pol_degree, 10000, 0.05)
base = base+min
return base | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _getBaselineThresh(self):\n print('Calculating 10% baseline')\n self.baseline = obrienBaseline.obrienBaseline(\n self.d['dos1rate'], timeWidth=5.0, \n cadence=0.1)\n self.peak_std = ( (self.d['dos1rate'][self.peakInd]/10 - \n ... | [
"0.7123638",
"0.69333345",
"0.6769743",
"0.6610722",
"0.6563401",
"0.64849114",
"0.63309747",
"0.630482",
"0.6297155",
"0.622598",
"0.61856276",
"0.597163",
"0.59571505",
"0.5864661",
"0.58142674",
"0.5764512",
"0.57439363",
"0.5738576",
"0.5727236",
"0.56630546",
"0.56570643... | 0.67838216 | 2 |
Calculate the hessian matrix with finite differences | def hessian(x):
x_grad = np.gradient(x)
hessian = np.empty((x.ndim, x.ndim) + x.shape, dtype=x.dtype)
for k, grad_k in enumerate(x_grad):
"""
iterate over dimensions
apply gradient again to every component of the first derivative.
"""
tmp_grad = np.gradient(grad_k) ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_hessian(self):\n if not self.sparse:\n hess = numpy.dot(self.jacobian_T, self.jacobian)\n else:\n hess = self.jacobian_T*self.jacobian\n return hess",
"def _hessian(self):\n log_g = np.log(self._gv())\n log_f = np.log(self._fv())\n h_inf = np.mean((1 -... | [
"0.7896911",
"0.7722618",
"0.7689578",
"0.76618177",
"0.7501295",
"0.74525297",
"0.74314106",
"0.742467",
"0.74236274",
"0.73696274",
"0.7363324",
"0.72986287",
"0.7227161",
"0.7213006",
"0.7201073",
"0.7175992",
"0.7172301",
"0.7148956",
"0.71194273",
"0.71127117",
"0.706749... | 0.7162221 | 17 |
Determines the initial rows and columns of the fleas. | def initialize_flea_locs(self, flea_rows, flea_cols):
# Replace None with center
flea_rows = [flea_row if flea_row is not None else self.num_rows // 2 for flea_row in flea_rows]
flea_cols = [flea_col if flea_col is not None else self.num_cols // 2 for flea_col in flea_cols]
# Replace n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_block():\n final_locs = [[1 for x in range(LOC_SIZE)] for y in range(LOC_SIZE)]\n for a in range(int(LOC_SIZE / 2)):\n for b in range(a, int(LOC_SIZE / 2)):\n # creating and ringing each of the fleas individually\n print(a, b)\n locs = [[1 if x == a and y == b... | [
"0.5747349",
"0.55304915",
"0.54669744",
"0.544392",
"0.536384",
"0.5329804",
"0.5238225",
"0.5191042",
"0.51660126",
"0.51305646",
"0.5103158",
"0.5083339",
"0.5059225",
"0.5046582",
"0.50390905",
"0.5030519",
"0.5030001",
"0.5018883",
"0.5002887",
"0.5000909",
"0.49926257",... | 0.61964476 | 0 |
Determines the initial directions of the fleas. | def initialize_flea_directions(self, init_directions):
init_directions += ['up'] * (self.num_fleas - len(init_directions))
return init_directions | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_direction(self, feats):\n if feats.name == \"ARNC\":\n if feats[\"z-score\"] < -1.5:\n return Directions.long_dir\n elif feats[\"z-score\"] > 1.5:\n return Directions.short_dir\n elif feats.name == \"UNG\":\n if feats[\"z-scor... | [
"0.577651",
"0.5761766",
"0.54945475",
"0.5401978",
"0.5295211",
"0.52914995",
"0.52668256",
"0.5246092",
"0.51954025",
"0.51931316",
"0.5184261",
"0.517382",
"0.5150054",
"0.51456606",
"0.5136114",
"0.512479",
"0.5088317",
"0.50830895",
"0.5068119",
"0.50432193",
"0.5039508"... | 0.72522104 | 0 |
Determine the initial square colors. | def initialize_square_colors(self, square_colors):
if square_colors is None:
square_colors = [[0] * self.num_cols] * self.num_rows
return square_colors | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_colors(self) -> None:\n curses.init_pair(ColorPair.black_on_white.value, curses.COLOR_BLACK, curses.COLOR_WHITE)\n curses.init_pair(ColorPair.red_on_black.value, curses.COLOR_RED, curses.COLOR_BLACK)\n curses.init_pair(ColorPair.blue_on_black.value, curses.COLOR_BLUE, curses.COL... | [
"0.65205836",
"0.64879256",
"0.64560956",
"0.64264864",
"0.6399936",
"0.6295429",
"0.61141825",
"0.60455334",
"0.6031279",
"0.60079896",
"0.6003107",
"0.59678465",
"0.5959027",
"0.59578264",
"0.59552187",
"0.59532493",
"0.5947528",
"0.59200263",
"0.59002054",
"0.5895776",
"0.... | 0.73408926 | 0 |
Gets the Square in a given row and column. | def get_square(self, row, col):
return self.board[row][col] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def square(self, row, col):\n return self.board[row][col]",
"def square(self, row, col):\n return self._board[row][col]",
"def square(self, row, col):\n if 0 == row:\n if 0 == col:\n return self.tl\n elif 1 == col:\n return self.tc\n ... | [
"0.8541956",
"0.8489466",
"0.8139662",
"0.76062024",
"0.7603011",
"0.73756915",
"0.72731274",
"0.722714",
"0.722714",
"0.7216884",
"0.7193437",
"0.71650165",
"0.71462554",
"0.70792747",
"0.7056047",
"0.69592404",
"0.69378346",
"0.68022996",
"0.6793762",
"0.6790237",
"0.678944... | 0.8849575 | 0 |
Changes the color of the Squares under the Fleas. | def change_square_colors(self):
for flea in self.fleas.sprites():
flea.square.change_color() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def changeColor( self ):\n\t\t\n\t\tx, y = self.position.xy\n\t\tself.color = ( int((x / WINDOW_X) * 128), int((x / WINDOW_X) * 128) + int((y / WINDOW_Y) * 128 ), int((y / WINDOW_Y) * 128))",
"def update_color(self):\n self.plot(update_traces=False, update_waveforms=True)",
"def update_colourin(self):\n... | [
"0.69831204",
"0.63404846",
"0.6302929",
"0.6261795",
"0.6195861",
"0.619493",
"0.61861604",
"0.6058782",
"0.60587114",
"0.6052671",
"0.60500383",
"0.6008667",
"0.59344876",
"0.59155804",
"0.5906455",
"0.58579266",
"0.57919824",
"0.5791351",
"0.57853216",
"0.57681215",
"0.573... | 0.7049206 | 0 |
Draws a grid of lines to visualize separate the Squares. | def draw_grid(self):
# Draw horizontal lines
for row in range(self.num_rows + 1):
left = row_column_to_pixels(row, 0)
right = row_column_to_pixels(row, self.num_cols)
pygame.draw.line(self.screen, COLOR_MAP['gray'], left, right)
# Draw vertical lines
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_grid(self):\n for square in range(COLS+1):\n #vertical lines\n start_pos = (helpers.get_col_left_p(square),helpers.get_row_top_p(0))\n end_pos = (helpers.get_col_left_p(square),helpers.get_row_top_p(ROWS))\n pygame.draw.line(g.screen,WHITE,start_pos,end_p... | [
"0.8216474",
"0.808419",
"0.8041982",
"0.77832127",
"0.7648283",
"0.7604516",
"0.7541168",
"0.75036514",
"0.74366957",
"0.7394856",
"0.7374004",
"0.73558646",
"0.72848505",
"0.72743",
"0.7202921",
"0.7139773",
"0.71055603",
"0.7104149",
"0.709945",
"0.70826256",
"0.70656776",... | 0.7936204 | 3 |
Draws the Board including the Squares, grid, and Fleas. | def draw(self):
self.squares.draw(self.screen)
if not self.hide_grid:
self.draw_grid()
self.fleas.draw(self.screen)
pygame.display.flip() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drawBoard(self):\r\n self.outer.draw(self.surface)\r\n self.background.draw(self.surface)\r\n for point in self.points:\r\n point.draw(self.surface)\r\n point.drawCheckers(self.surface)\r\n self.dice.draw(self.surface)\r\n self.message.draw(self.surface)... | [
"0.801158",
"0.78360367",
"0.7729371",
"0.76840204",
"0.76215035",
"0.7590688",
"0.73918694",
"0.7307775",
"0.7303027",
"0.7246071",
"0.7245624",
"0.7224394",
"0.71885425",
"0.7174259",
"0.7136953",
"0.71274716",
"0.70800877",
"0.7012581",
"0.69895095",
"0.69768536",
"0.69735... | 0.74167717 | 6 |
Create secondary features. At least one keyword argument must be provided. | def featurize(
self,
meta_df: Optional[pd.DataFrame] = None,
test_meta_df: Optional[pd.DataFrame] = None,
) -> None:
if meta_df is None and test_meta_df is None:
raise ValueError("At least one keyword argument must be provided.")
if meta_df is not None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_new_features(self):\n train = self.train\n \n train['is_context'] = train['context_type'].isin(CONTEXT_TYPE_TEST)\n train['is_context_flow'] = train['listen_type'] * train['is_context']\n \n train['is_listened_context'] = train['is_listened'] * train['is_context... | [
"0.57953346",
"0.5540945",
"0.5539418",
"0.55321926",
"0.5357207",
"0.5354252",
"0.53519714",
"0.5343687",
"0.5321349",
"0.53048503",
"0.5271115",
"0.52576053",
"0.5232943",
"0.5215288",
"0.5207234",
"0.51544017",
"0.5153577",
"0.5147574",
"0.51334405",
"0.50996745",
"0.50892... | 0.54937667 | 4 |
Build a MetaDataSetFeaturizerViaLambda based on supplied keyword arguments. | def __call__(
self,
method: str,
callable_: Callable[[pd.DataFrame], Union[pd.DataFrame, pd.Series]],
normalizable: bool,
**_ignore
):
return MetaDataSetFeaturizerViaLambda(
method=method, callable_=callable_, normalizable=normalizable
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply(self, func):\r\n return func(**self.kwargs)",
"def lambda_fn(ds, fn):\n logger.info(\"Applying function '%s' on dataset.\", str(fn))\n return fn(ds)",
"def factory(*args):\n\n def wrapper(dataset):\n return Factory(dataset, *args)\n\n return wrapper",
"def function_maker(s... | [
"0.521316",
"0.5161827",
"0.5130045",
"0.5062305",
"0.50407004",
"0.49847677",
"0.4981667",
"0.4978922",
"0.48902628",
"0.48765245",
"0.4872106",
"0.48687008",
"0.48558855",
"0.48554668",
"0.48479384",
"0.4819062",
"0.48036474",
"0.48031783",
"0.4770191",
"0.4765676",
"0.4764... | 0.7124045 | 0 |
Set up market parameters. All parameters are scalars. See | def __init__(self, r, r_2, pie_d, pie_d_2, lmb_d, lmb_d_2, pie_s, pie_s_2, b_s, b_s_2):
lma_d=(pie_d-(1+r))
lma_d_2=(pie_d_2-(1+r_2))
a_s=((1+r)-pie_s)
a_s_2=((1+r_2)-pie_s_2)
self.lma_d, self.lma_d_2, self.lmb_d, self.lmb_d_2, self.a_s, self.a_s_2, self.b_s, self.b_s_2 ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_params(self, **kwargs):\n\n kw_keys = list(kwargs)\n\n if 'alpha' in kw_keys:\n self.alpha = kwargs['alpha']\n\n if 'beta' in kw_keys:\n self.beta = kwargs['beta']\n\n if 'gamma' in kw_keys: \n \tself.gamma = kwargs['gamma']\n\n if 'epsilon' i... | [
"0.6921982",
"0.67677104",
"0.6565057",
"0.6549596",
"0.650122",
"0.6495121",
"0.64377415",
"0.6433998",
"0.6406836",
"0.6391233",
"0.6386938",
"0.63773566",
"0.63642573",
"0.62875944",
"0.6272724",
"0.6261374",
"0.62600845",
"0.6248021",
"0.6233617",
"0.6227204",
"0.6205617"... | 0.0 | -1 |
Identify interface residues between two chains at a given distance cutoff. | def identify_contacts(chain_A, chain_B, solute_reference_openmm, trajectory, frame, cutoff):
# Get trajectory frame
traj = trajectory[frame]
# Create dict mapping residue indexes to residue id's in PDB
d_res = {}
for chain in solute_reference_openmm.topology.chains():
for res in chain.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def identify_interface_residues_12(reference_pdb, reference_withH_pdb, trajectory, cutoffs, frames):\n\n # Load reference PDB\n forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml')\n pdb = PDBFile(reference_pdb)\n modeller = Modeller(pdb.topology, pdb.positions)\n modeller.addHydrogens(... | [
"0.5814534",
"0.56723017",
"0.56133354",
"0.5265103",
"0.5181596",
"0.50566536",
"0.5001008",
"0.491961",
"0.49137068",
"0.49137068",
"0.48926866",
"0.48706847",
"0.4851041",
"0.48194987",
"0.4812039",
"0.48093337",
"0.4809159",
"0.47935218",
"0.47512582",
"0.47310477",
"0.47... | 0.54563504 | 3 |
Identify the interface residues for all pairs of chains involved in the interface. | def identify_interface_residues_4(reference_pdb, reference_withH_pdb, trajectory, cutoffs, frames, is_5udc=False):
# Load reference PDB
forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml')
pdb = PDBFile(reference_pdb)
modeller = Modeller(pdb.topology, pdb.positions)
modeller.addHydroge... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def residues(self, chain_id, model_num = 0, include_alt = False):\n resi = []\n for res in self.chain(chain_id, model_num):\n res.chain_id = chain_id\n if res.id[0] ==' ':\n resi.append(res)\n elif include_alt:\n resi.append(res)\n ... | [
"0.6352576",
"0.5909955",
"0.5489757",
"0.53997153",
"0.53572285",
"0.5353771",
"0.53379476",
"0.5298372",
"0.52637863",
"0.52098495",
"0.5159685",
"0.51538616",
"0.5131051",
"0.5125846",
"0.51236707",
"0.5099968",
"0.5090912",
"0.5074676",
"0.5062754",
"0.50619",
"0.50596076... | 0.57994956 | 2 |
Identify the interface residues for all pairs of chains involved in the interface. | def identify_interface_residues_12(reference_pdb, reference_withH_pdb, trajectory, cutoffs, frames):
# Load reference PDB
forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml')
pdb = PDBFile(reference_pdb)
modeller = Modeller(pdb.topology, pdb.positions)
modeller.addHydrogens(forcefield,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def residues(self, chain_id, model_num = 0, include_alt = False):\n resi = []\n for res in self.chain(chain_id, model_num):\n res.chain_id = chain_id\n if res.id[0] ==' ':\n resi.append(res)\n elif include_alt:\n resi.append(res)\n ... | [
"0.63490707",
"0.57995063",
"0.549096",
"0.5399745",
"0.53579885",
"0.5353315",
"0.5337845",
"0.5297717",
"0.52630556",
"0.52081615",
"0.5159576",
"0.51541764",
"0.5130359",
"0.5124876",
"0.5121439",
"0.5100151",
"0.50913095",
"0.50734675",
"0.50631887",
"0.5062796",
"0.50600... | 0.59105253 | 1 |
t1, t2 are non empty | def always_sunny(t1, t2):
sun = ("sunny","sun")
first = t1[0] + t2[0]
return (sun[0], first) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _test_empty(t):\n return t.is_empty()",
"def empty(self):\r\n if len(self.s1)==0 and len(self.s2)==0:\r\n return True",
"def test_dtm_not_equal(self):\n new_dtm = self.dtm1.copy()\n new_dtm.final_states.add('q2')\n nose.assert_true(self.dtm1 != new_dtm, 'DTMs are e... | [
"0.5986555",
"0.59421563",
"0.58333683",
"0.5785593",
"0.5780122",
"0.5758743",
"0.57342875",
"0.5723197",
"0.57114446",
"0.5694139",
"0.5657635",
"0.5646962",
"0.5632908",
"0.56024885",
"0.55924153",
"0.5591492",
"0.55658567",
"0.5531688",
"0.5517331",
"0.5495071",
"0.547345... | 0.5031999 | 99 |
new branching cone name for the new branch cone | def branching_decision(cod_obj, force_drift, force_struc, view,
new_cod, new_nod, new_edd,
eddp, nodp, ed_namesp, no_namesp, co_namesp,
flavourp):
cone1 = co_namesp.pop(0)
a = cod_obj.branching(cone1)
splitting_mother_cone(cod_obj, new_nod, new_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def branch_name(self):\n return f'phab-diff-{self.diff_id}'",
"def unique_branch_name(base_name):\n repo = git.repo()\n branches = repo.branches()\n collision = True\n count = 1\n while collision:\n new_branch = base_name + \"-bak-\" +str(count)\n collision = next((x for x in ... | [
"0.70662946",
"0.65689903",
"0.6210586",
"0.6210586",
"0.62018585",
"0.5930595",
"0.5845",
"0.5817794",
"0.56846833",
"0.56834936",
"0.5624811",
"0.5614766",
"0.55923414",
"0.5575148",
"0.5570589",
"0.55602694",
"0.5525928",
"0.55247796",
"0.55173403",
"0.5500877",
"0.5493756... | 0.52397233 | 49 |
put listener in listening mode and wait for incoming connections. | async def listen(self, maddr: Multiaddr) -> bool: | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def listen(self):\n self.can_listen = True\n threading.Thread(target=self._listen).start()",
"def listen(self):\n self.socket.listen(6)",
"def listen_connections(self):\n self.MAIN_CONNECTION.listen(server.MAX_CONNECTIONS)",
"def listen(self):\n pass",
"def open_listener(... | [
"0.77136636",
"0.7363863",
"0.7359952",
"0.7318734",
"0.73166144",
"0.71989334",
"0.7141114",
"0.70626956",
"0.70605063",
"0.7045739",
"0.70408773",
"0.7027022",
"0.7010702",
"0.700512",
"0.6979281",
"0.6974525",
"0.6969262",
"0.69281256",
"0.68991166",
"0.68212086",
"0.68148... | 0.6793263 | 21 |
retrieve list of addresses the listener is listening on. | def get_addrs(self) -> List[Multiaddr]: | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def address(self):\n addrlist = []\n for s in self.srv_socks:\n addrlist.append(s.getsockname())\n return addrlist",
"def get_addrs(self):\n # TODO check if server is listening\n return self.multiaddrs",
"def get_supervisor_addresses(self) -> List[str]:",
... | [
"0.7614805",
"0.76038516",
"0.69983035",
"0.6990682",
"0.6919074",
"0.68086815",
"0.68086815",
"0.68086815",
"0.67372423",
"0.6467846",
"0.64236337",
"0.63805145",
"0.63112867",
"0.624012",
"0.6133103",
"0.61057365",
"0.6101257",
"0.60780704",
"0.6058948",
"0.6032824",
"0.602... | 0.7419669 | 2 |
close the listener such that no more connections can be open on this transport instance. | async def close(self) -> None: | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def close(self):\n log.info(\"Closing listener from %s on port %s.\",\n self.address, self.port)\n self._server.stop()\n self._server = None\n self._address = \"\"\n self._port = 0",
"def close(self):\n if self._closed:\n return\n\n self... | [
"0.81969666",
"0.7580352",
"0.7559147",
"0.7079218",
"0.70395863",
"0.7024379",
"0.7014757",
"0.69295055",
"0.69295055",
"0.69295055",
"0.69295055",
"0.69295055",
"0.69295055",
"0.6902617",
"0.68785983",
"0.6869464",
"0.68604946",
"0.68221366",
"0.68221366",
"0.6735415",
"0.6... | 0.0 | -1 |
Add the mask to the provided face, and return the face with mask. | def apply_mask(face: np.array, mask: np.array) -> np.array:
mask_h, mask_w, _ = mask.shape
face_h, face_w, _ = face.shape
# Resize the mask to fit on face
factor = min(face_h / mask_h, face_w / mask_w)
new_mask_w = int(factor * mask_w)
new_mask_h = int(factor * mask_h)
new_mask_shape = (new... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_face(self, face):\n try:\n face_idx = self.faces.index(face)\n return self.faces[face_idx]\n except Exception:\n self.faces.append(face)\n return face",
"def add_mask(self, bg, mask):\n # if mask is to tall for the background image, decreas... | [
"0.68112254",
"0.61941063",
"0.61160135",
"0.5863433",
"0.5680295",
"0.56591696",
"0.5506171",
"0.5495523",
"0.5465617",
"0.54287475",
"0.540982",
"0.5407283",
"0.5399397",
"0.53711027",
"0.53566027",
"0.52766466",
"0.5251095",
"0.52477425",
"0.5221825",
"0.521897",
"0.516831... | 0.7651554 | 0 |
Receive yaml string, update instance state with its value | def post_exec_command(self, env_out):
env_at_footer = yaml.safe_load(env_out)
newdir = env_at_footer["pwd"]
newenv = env_at_footer["env"]
self.update_workdir(newdir)
self.update_env(newenv)
if "code" in env_at_footer:
return env_at_footer["code"]
els... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __setstate__(self, d):\n self.temp_yaml = None\n self.__dict__.update(d)",
"def from_yaml(self, yaml):\n self.hwAddress = yaml.get('hwAddress')\n if self.hwAddress:\n self.hwAddress = self.hwAddress.lower()\n self.ip = yaml.get('IP')\n self.formulas = {}\n... | [
"0.61438406",
"0.6056736",
"0.5877559",
"0.5833056",
"0.58151037",
"0.5771336",
"0.5758185",
"0.5707733",
"0.56915504",
"0.5662397",
"0.5634253",
"0.5543256",
"0.5499675",
"0.5443834",
"0.5396185",
"0.5373637",
"0.534983",
"0.5343931",
"0.53255194",
"0.5319177",
"0.5310332",
... | 0.0 | -1 |
Append header/footer to `cmd`. | def append_footer(cmd, marker):
header = ""
footer = """
EXIT_CODE=$?
echo {marker}code: ${{EXIT_CODE}}{marker}
echo {marker}pwd: $(pwd){marker}
echo {marker}env: $(cat -v <(env -0)){marker}
""".format(
marker=marker
)
full_command = "\n".join([header, cmd, footer])
return full_command | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tprint_raw(self, cmd, end='\\n'):\n self.fileHandle.write(cmd + end)",
"def _build_command(self, cmd, unit):\n return '#' + unit + cmd + NEWLINE",
"def add_header(force=False):\n print_debug_info()\n if not force:\n if not should_do_write():\n return\n\n on_ente... | [
"0.5938615",
"0.5770663",
"0.56236213",
"0.5596925",
"0.5524238",
"0.55135214",
"0.54929286",
"0.5477096",
"0.5441686",
"0.53585064",
"0.53575087",
"0.53523684",
"0.5345566",
"0.53223354",
"0.5313103",
"0.5260496",
"0.52242094",
"0.5208714",
"0.52053946",
"0.52005076",
"0.518... | 0.7447718 | 0 |
Merge two iterators returned by Popen.communicate() | def merge_stdout_stderr(iterator):
for (stdout, stderr) in iterator:
if stdout:
yield stdout
else:
yield stderr | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pipemeter(cmd1, cmd2):\n\n proc1 = subprocess.Popen(cmd1, bufsize=0, shell=True, stdout=subprocess.PIPE)\n proc2 = subprocess.Popen(cmd2, bufsize=0, shell=True, stdin=subprocess.PIPE)\n bytes_piped = 0\n\n while True:\n data = proc1.stdout.read(CHUNKSIZE)\n length = len(data)\n ... | [
"0.66606086",
"0.6126606",
"0.58850574",
"0.5624073",
"0.5607234",
"0.551958",
"0.54522693",
"0.54313684",
"0.5363718",
"0.53104246",
"0.53101385",
"0.5266014",
"0.52605325",
"0.5257359",
"0.5249061",
"0.5244659",
"0.52373624",
"0.5161998",
"0.51599884",
"0.5159055",
"0.51327... | 0.58755404 | 3 |
Process iterator which is return of Popen.communicate() For normal lines, call callback printfn. | def process_output(tuple_iterator, marker, print_function):
iterator = merge_stdout_stderr(tuple_iterator)
env_out = ""
for line in iterator:
if line.endswith(marker + "\n"):
if not line.startswith(marker):
# The `line` contains 2 markers and trailing newline
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iter__(self):\n p = subprocess.Popen(self.comm, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True)\n while True:\n line = p.stdout.readline()\n if not line:\n\t\t break\n line = line.strip()\n yield line",
"def run(self):\n ... | [
"0.6762434",
"0.65452737",
"0.64996916",
"0.6360212",
"0.6091779",
"0.606308",
"0.59477913",
"0.5908305",
"0.5880744",
"0.5825736",
"0.574949",
"0.5631919",
"0.5621603",
"0.56201273",
"0.56054807",
"0.5584007",
"0.5553441",
"0.5513236",
"0.55101407",
"0.5414936",
"0.53892183"... | 0.57843137 | 10 |
Parse and postprocess ssh_config and rename some keys for plumbum.ParamikoMachine.__init__() | def load_ssh_config_for_plumbum(filename, host):
conf = paramiko.config.SSHConfig()
expanded_path = os.path.expanduser(filename)
username_from_host = None
m = re.search("([^@]+)@(.*)", host)
if m:
username_from_host = m.group(1)
host = m.group(2)
if os.path.exists(expanded_pat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse(self, content):\n result = TincConfParser.conf_file.parseString(to_unicode(content))\n for entry in result.get(\"entries\", []):\n self[entry[0]] = entry[1]\n keys = result.get(\"keys\", [])\n if keys:\n if len(keys) > 1:\n raise ParserErr... | [
"0.6004054",
"0.5839919",
"0.5825213",
"0.5778339",
"0.5707421",
"0.56640553",
"0.5603101",
"0.55248064",
"0.54654783",
"0.5437723",
"0.5413477",
"0.53898275",
"0.5389727",
"0.5387925",
"0.53728455",
"0.53633326",
"0.5356791",
"0.5346864",
"0.53243184",
"0.5306002",
"0.53013"... | 0.58567256 | 1 |
always run this method first to evaluate the meta json file. Pass the directory of the corpus (where metafile.json is situated) | def load_json(corpus):
global corpus_dir, u_path, candidates, unknowns, encoding, language
corpus_dir += corpus
m_file = open(os.path.join(corpus_dir, META_FILENAME), "r")
meta_json = json.load(m_file)
m_file.close()
u_path += os.path.join(corpus_dir, meta_json["folder"])
encoding += meta_j... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_corpus_meta_from_dir(filename, corpus_meta, exclude_overall_meta):\n with open(os.path.join(filename, \"corpus.json\"), \"r\") as f:\n for k, v in json.load(f).items():\n if k in exclude_overall_meta: continue\n corpus_meta[k] = v",
"def main():\n \n root = Folder(n... | [
"0.7082381",
"0.586382",
"0.5772098",
"0.57677233",
"0.5752917",
"0.57001966",
"0.5661683",
"0.5659507",
"0.56590486",
"0.5642474",
"0.5588098",
"0.55415887",
"0.551891",
"0.5513077",
"0.54982644",
"0.5493433",
"0.549307",
"0.54841393",
"0.5416018",
"0.54146445",
"0.5410795",... | 0.6883183 | 1 |
run this method next, if you want to do training (read training files etc) | def load_training():
for can in candidates:
trainings[can] = []
for subdir, dirs, files in os.walk(os.path.join(corpus_dir, can)):
for doc in files:
trainings[can].append(doc) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train():\n pass",
"def train(self, trainfile):",
"def train(self):\n pass",
"def train(self):\n pass",
"def train(self):\n pass",
"def train(self):\n pass",
"def train(self):\n pass",
"def train():\n # YOUR TRAINING CODE GOES HERE",
"def train_start(... | [
"0.80825347",
"0.8008459",
"0.7991317",
"0.7991317",
"0.7991317",
"0.7991317",
"0.7991317",
"0.7725816",
"0.77055573",
"0.763521",
"0.75699675",
"0.75522375",
"0.7528174",
"0.7505932",
"0.7492671",
"0.74631387",
"0.7447466",
"0.74104065",
"0.7406789",
"0.74045306",
"0.7386814... | 0.0 | -1 |
get training text 'filename' from candidate 'can' (obtain values from 'trainings', see example above) | def get_training_text(can, filename):
d_file = codecs.open(os.path.join(corpus_dir, can, filename), "r", "utf-8")
s = d_file.read()
d_file.close()
return s | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_filename():\n dirname = os.path.dirname(__file__)\n return os.path.join(dirname, 'occulttraining.txt')",
"def load_training():\n for can in candidates:\n trainings[can] = []\n for subdir, dirs, files in os.walk(os.path.join(corpus_dir, can)):\n for doc in files:\n ... | [
"0.60562044",
"0.6041802",
"0.6016182",
"0.58461756",
"0.5826132",
"0.5790548",
"0.5689206",
"0.5469799",
"0.54335415",
"0.539198",
"0.5366164",
"0.5323693",
"0.52881306",
"0.52773625",
"0.52503705",
"0.5247028",
"0.52131414",
"0.5187469",
"0.51757795",
"0.51622295",
"0.51342... | 0.7263047 | 0 |
get training file as bytearray | def get_training_bytes(can, filename):
d_file = open(os.path.join(corpus_dir, can, filename), "rb")
b = bytearray(d_file.read())
d_file.close()
return b | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_sample_binary() -> bytearray:\n full_path = path.abspath(__file__).replace(\n DemoBinaryPuller._MODULE_FILE_NAME,\n DemoBinaryPuller._BIN_FILE_NAME)\n with open(full_path, \"rb\") as bin_file:\n binary_content = bin_file.read()\n return binary_content"... | [
"0.6530316",
"0.62942386",
"0.6263488",
"0.6066596",
"0.6008916",
"0.5943695",
"0.59409225",
"0.58880603",
"0.58114594",
"0.57615244",
"0.5689741",
"0.5688625",
"0.56801695",
"0.5667511",
"0.56595796",
"0.5641395",
"0.56238467",
"0.56224763",
"0.56184244",
"0.5617344",
"0.560... | 0.7570874 | 0 |
get unknown text 'filename' (obtain values from 'unknowns', see example above) | def get_unknown_text(filename):
d_file = codecs.open(os.path.join(u_path, filename), "r", "utf-8")
s = d_file.read()
d_file.close()
return s | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_filename(f):\n problem = f[2:5]\n extension = f.split('.')[-1]\n if extension not in langs.keys():\n # if the extension isn't in our list we don't care about the file\n return (None, None)\n return (problem, extension)",
"def parseOutText(f):\n\n\n f.seek(0) ### go back to... | [
"0.60619533",
"0.59448653",
"0.5880763",
"0.5844294",
"0.57835126",
"0.57252425",
"0.57172376",
"0.5701078",
"0.5650412",
"0.5641387",
"0.5602536",
"0.55996644",
"0.5551253",
"0.5534546",
"0.55136657",
"0.55071455",
"0.54930013",
"0.5470423",
"0.54324615",
"0.5426587",
"0.542... | 0.75179213 | 0 |
get unknown file as bytearray | def get_unknown_bytes(filename):
d_file = open(os.path.join(u_path, filename), "rb")
b = bytearray(d_file.read())
d_file.close()
return b | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_as_bytes(filename):\n try:\n with open(filename, \"rb\") as file:\n bytes = array.array(\"B\")\n bytes.frombytes(file.read())\n return bytes\n except FileNotFoundError:\n print(f\"File not found: {filename}\")\n ex... | [
"0.7152647",
"0.69215786",
"0.6701248",
"0.6561615",
"0.65179765",
"0.650987",
"0.64195776",
"0.6374897",
"0.63348585",
"0.6324657",
"0.6263759",
"0.6194869",
"0.61396164",
"0.6138177",
"0.61314404",
"0.6122473",
"0.6080764",
"0.60445416",
"0.60434145",
"0.60298926",
"0.60172... | 0.79798865 | 0 |
run this method in the end to store the output in the 'path' directory as OUT_filename pass a list of filenames (you can use 'unknowns'), a list of your predicted authors and optionally a list of the scores (both must of course be in the same order as the 'texts' list) | def store_json(path, texts, cans, scores=None):
answers = []
if scores is None:
scores = [1 for _ in texts]
for i in range(len(texts)):
answers.append(
{"unknown_text": texts[i], "author": cans[i], "score": scores[i]})
f = open(os.path.join(path, OUT_FILENAME), "w")
json.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_pred_kaggle_file(cls, outfname, speech):\n yp = cls.predict(speech.test_doc_vec)\n labels = speech.le.inverse_transform(yp)\n f = codecs.open(outfname, 'w')\n f.write(\"FileIndex,Category\\n\")\n for i in range(len(speech.test_fnames)):\n fname = speech.test_fnames[i]\n f.wri... | [
"0.62999773",
"0.59991187",
"0.59550965",
"0.5944562",
"0.59349877",
"0.59268004",
"0.5834005",
"0.5819272",
"0.5778378",
"0.5764998",
"0.5762171",
"0.57342887",
"0.5728905",
"0.57210076",
"0.5710357",
"0.5702814",
"0.5688264",
"0.56862724",
"0.5659074",
"0.56527543",
"0.5650... | 0.0 | -1 |
if you want to evaluate your answers using the groundtruth.json, load the true authors in 'trueAuthors' using this function | def load_ground_truth():
t_file = open(os.path.join(corpus_dir, GT_FILENAME), "r")
t_json = json.load(t_file)
t_file.close()
global trueAuthors
for i in range(len(t_json["ground-truth"])):
trueAuthors.append(t_json["ground-truth"][i]["true-author"]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_authors_from_data(self):\n responses.add(\n responses.GET,\n \"https://openlibrary.org/authors/OL382982A\",\n json={\n \"name\": \"George Elliott\",\n \"personal_name\": \"George Elliott\",\n \"last_modified\": {\n ... | [
"0.5868444",
"0.57829976",
"0.5589759",
"0.55294764",
"0.5447328",
"0.54368585",
"0.5414421",
"0.5405367",
"0.5401354",
"0.53672665",
"0.53661776",
"0.5360875",
"0.53598326",
"0.5315401",
"0.5311761",
"0.530894",
"0.5297903",
"0.5284491",
"0.5276247",
"0.5260965",
"0.5245783"... | 0.74645066 | 0 |
Perform regridding on an array of data. | def regrid(self, src_array, norm_type="fracarea", mdtol=1):
array_shape = src_array.shape
main_shape = array_shape[-self.src.dims :]
if main_shape != self.src.shape:
raise ValueError(
f"Expected an array whose shape ends in {self.src.shape}, "
f"got an... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def regrid(self, obj, **kwargs):\n if isinstance(obj, xr.Dataset):\n return obj.map(self._regrid_dataarray, keep_attrs=True, **kwargs)\n elif isinstance(obj, xr.DataArray):\n return self._regrid_dataarray(obj, **kwargs)\n else:\n raise ValueError('unknown type'... | [
"0.6270635",
"0.5646218",
"0.5525216",
"0.5499714",
"0.54920924",
"0.54512894",
"0.54512894",
"0.5364606",
"0.5364606",
"0.53109187",
"0.5242617",
"0.5226098",
"0.5136758",
"0.51108867",
"0.50939864",
"0.5064222",
"0.50586665",
"0.5020054",
"0.4992338",
"0.4978625",
"0.496110... | 0.0 | -1 |
convert sentence to index array | def padding(sent, sequence_len):
if len(sent) > sequence_len:
sent = sent[:sequence_len]
padding = sequence_len - len(sent)
sent2idx = sent + [0]*padding
return sent2idx, len(sent) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sentences_to_indices(X, word_to_index, max_len):\n \n m = X.shape[0] # number of training examples\n \n ### START CODE HERE ###\n # Initialize X_indices as a numpy matrix of zeros and the correct shape (≈ 1 line)\n X_indices = np.zeros((m, max_len))\n \n ... | [
"0.7227327",
"0.72110087",
"0.7196507",
"0.7154089",
"0.7082231",
"0.7068135",
"0.69883484",
"0.65725946",
"0.6530706",
"0.64363074",
"0.6428371",
"0.63868946",
"0.63488775",
"0.63356364",
"0.62344724",
"0.62321657",
"0.62182313",
"0.6209054",
"0.6167227",
"0.6106061",
"0.608... | 0.0 | -1 |
Mock the redis pubsub.listen generator Yields the elements of `side_effects`, one at a time. If an element is an exception, it is raised instead of yielded. If the element is a callable, it is called and the return value is yielded. | def redis_listen(*side_effects):
for effect in side_effects:
if (
isinstance(effect, Exception)
or isinstance(effect, type)
and issubclass(effect, Exception)
):
raise effect
elif callable(effect):
yield effect()
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mock_side_effect(self, original_object, attribute_name, side_effect):\n original_function = getattr(original_object, attribute_name)\n def original_with_side_effect(*args, **kwargs):\n side_effect()\n return original_function(*args, **kwargs)\n self.mock(original_object, attribute_name, orig... | [
"0.5850686",
"0.55700994",
"0.5440504",
"0.5365091",
"0.5313459",
"0.5286434",
"0.5244393",
"0.5134776",
"0.5041271",
"0.5028358",
"0.4956616",
"0.49153754",
"0.491494",
"0.4888333",
"0.48866546",
"0.48858225",
"0.48772252",
"0.48605973",
"0.48562133",
"0.485331",
"0.484318",... | 0.7716917 | 0 |
Anonymous user can't access the user profile view. | def test_anonymous_cannot_get_userprofileview(dclient):
resp = dclient.get("/api/record/profile/", follow=True)
assert resp.status_code == 403 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_user_get_profile_not_authorized(self):\n self.client.logout()\n response = self.client.get(CONSTS.USER_PROFILE_URL)\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)",
"def test_not_logged_user_cannot_access(self):\n\n utils.test_not_logged_cannot_access(sel... | [
"0.72416484",
"0.6976399",
"0.6976399",
"0.6976399",
"0.6976399",
"0.6944178",
"0.68615055",
"0.68094474",
"0.67919546",
"0.6710337",
"0.66798",
"0.66781527",
"0.664407",
"0.66254276",
"0.66114944",
"0.6598399",
"0.6598399",
"0.6598399",
"0.6598399",
"0.6598399",
"0.6598399",... | 0.7859145 | 0 |
A logged in user can access the user profile view. | def test_loggedin_get_userprofileview(admin_client):
resp = admin_client.get("/api/record/profile/", follow=True)
assert resp.status_code == 200
userdata = resp.data
assert "user" in userdata.keys()
assert "profile" in userdata.keys() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_view(cls, user, profile):\r\n pass",
"def user_view(cls, user, profile):\n pass",
"def can_view(self, user):\r\n return True",
"def user_profile():\n if CURR_USER_KEY in session:\n return render_template('/profile/detail.html')\n else:\n return redirect('/log... | [
"0.79150033",
"0.7914116",
"0.752152",
"0.75147706",
"0.7382388",
"0.73471504",
"0.7199786",
"0.71735126",
"0.7023994",
"0.6933684",
"0.68745196",
"0.68414307",
"0.68403566",
"0.68403566",
"0.6839631",
"0.6835273",
"0.6832623",
"0.68008256",
"0.6793359",
"0.67932135",
"0.6789... | 0.65807426 | 35 |
User can post source records and an empty crecord to the server and receive a crecord with the cases from the source record incorporated. | def test_integrate_sources_with_crecord(dclient, admin_user, example_crecord):
dclient.force_authenticate(user=admin_user)
docket = os.listdir("tests/data/dockets/")[0]
with open(f"tests/data/dockets/{docket}", "rb") as d:
doc_1 = SourceRecord.objects.create(
caption="Hello v. World",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_add_flow_request_with_no_sources(self):\n res = self._add_flow_request(flow_request=self.flow_request_without_sources)\n self.assertEqual(res.status_code, 201)\n flow_request = res.json()\n destination = Destination.objects.get(name='Destination 1')\n self.assertEqual(fl... | [
"0.5335964",
"0.5273506",
"0.5268467",
"0.50346047",
"0.50232166",
"0.50214654",
"0.50048697",
"0.49723393",
"0.4958517",
"0.49340504",
"0.48781565",
"0.48394287",
"0.48392814",
"0.48148042",
"0.48148042",
"0.48148042",
"0.48148042",
"0.48148042",
"0.48148042",
"0.48148042",
... | 0.584946 | 0 |
post a couple of documents with urls to the server. Server creates objects to store the downloaded files and then returns uuids of the document objects in the database. | def test_download_ujs_docs(admin_client):
doc_1 = {
"docket_num": "CP-12345",
"court": "CP",
"url": "https://ujsportal.pacourts.us/DocketSheets/CPReport.ashx?docketNumber=CP-25-CR-1234567-2010&dnh=12345",
"caption": "Comm. v. SillyKitty",
"record_type": SourceRecord.RecTypes.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collection_post(self):\n if 'file' not in self.request.POST:\n self.request.errors.add('body', 'file', 'Not Found')\n self.request.errors.status = 404\n return\n tender = TenderDocument.load(self.db, self.tender_id)\n if not tender:\n self.reques... | [
"0.6769817",
"0.6653054",
"0.6561942",
"0.6291622",
"0.6269296",
"0.6071196",
"0.60429853",
"0.6011071",
"0.58240336",
"0.58195174",
"0.57986724",
"0.5758155",
"0.5755627",
"0.5733029",
"0.57280797",
"0.5722662",
"0.5685775",
"0.562269",
"0.561203",
"0.5599596",
"0.5592597",
... | 0.0 | -1 |
randomly initialize weigts or to zero | def initialize_weights(self, n_features, random=True):
if random:
limit = 1 / math.sqrt(n_features)
self.weights = np.random.uniform(-limit, limit, (n_features, ))
else:
self.weights = np.zeros(n_features) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def WeightInitializer():\n return np.random.uniform(-1, 1)",
"def test_init():\n rng = NonRandom()\n seed = 5\n rng.setSeed(seed)\n wheel = Wheel(rng)\n assert len(wheel.bins) == 38\n assert wheel.rng.value == seed\n assert wheel.rng.choice(range(0, 38)) == range(\n 0, 38)[wheel.rn... | [
"0.7099099",
"0.68757343",
"0.68296725",
"0.6803808",
"0.6685831",
"0.6591714",
"0.6560001",
"0.6552778",
"0.65211815",
"0.65121937",
"0.6508242",
"0.6505495",
"0.6494545",
"0.642668",
"0.64228153",
"0.641944",
"0.6410729",
"0.6384001",
"0.63680696",
"0.6353744",
"0.6341442",... | 0.64542484 | 13 |
fitting regression model to the data X and y | def fit(self, X, y):
# TODO insert stack of 1 for bias
X = np.insert(X, 0, 1, axis=1)
self.errors = []
self.initialize_weights(n_features=X.shape[1])
# TODO gradient descent for n_iter
for _ in range(self.n_iter):
y_pred = X.dot(self.weights)
# calculate l2 loss
mse = np.mean(0.5 * (y - y_pred)*... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _regress(self, X, y):\n self._model.fit(X, np.ravel(y))\n self._set_attributes(self._model)",
"def fit(self, X, y):",
"def fit(self, X, y):",
"def fit(self, X, y):",
"def fit(self, X,y):\n pass",
"def fit(self, X, y):\n return BaseRegressor.fit(self, X, y)",
"def fit(sel... | [
"0.8087929",
"0.7828381",
"0.7828381",
"0.7828381",
"0.7735748",
"0.7643866",
"0.7512748",
"0.7470016",
"0.74514323",
"0.7443375",
"0.7415181",
"0.73932964",
"0.737425",
"0.735379",
"0.735379",
"0.735379",
"0.735379",
"0.735379",
"0.735379",
"0.735379",
"0.735379",
"0.73537... | 0.69014436 | 49 |
Add SGE related command line options to an | def add_parser_arguments(parser: argparse.ArgumentParser):
parser.add_argument(
"-q",
"--queues",
default="none",
help=(
"comma separated list of queues for the SGE batch system,"
' "none" if you do not want to specify a queue'
),
)
parser.add_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_command_line_arguments(self, parser):\n # parser.add_option(...)\n pass",
"def modify_commandline_options(parser, is_train=True):\n parser.set_defaults(norm='batch', netG='unet_256', dataset_mode='aligned')\n if is_train:\n parser.set_defaults(pool_size=0, gan_mode=... | [
"0.6667056",
"0.6480277",
"0.63502276",
"0.63308334",
"0.6285769",
"0.6283014",
"0.6282531",
"0.6217268",
"0.61664003",
"0.61360985",
"0.6110302",
"0.61096555",
"0.61047727",
"0.61013126",
"0.6094607",
"0.6094607",
"0.6093989",
"0.60865587",
"0.6085824",
"0.6065626",
"0.60578... | 0.55830103 | 98 |
Get the job ids of all jobs in the SGE queue. | def get_jobs_in_queue() -> List[int]:
output = subprocess.check_output(["qstat"]).decode().splitlines()
job_ids = []
for line in output:
m = REGEX_QSTAT.match(line)
if m:
job_ids.append(int(m.group(1)))
return job_ids | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def queue_job_ids(self):\n return list(self.queue.keys())",
"def job_ids(self):\n return self.get_job_ids()",
"def job_ids(self):\n return self.connection.lrange(self.key, 0, -1)",
"def job_ids(self) -> List[str]:\n return self._db_data.job_ids",
"def job_ids(config):\n errco... | [
"0.8385078",
"0.8187057",
"0.80874485",
"0.78921986",
"0.7101836",
"0.69291735",
"0.69259614",
"0.689238",
"0.68702495",
"0.6756363",
"0.6716455",
"0.6708328",
"0.6654445",
"0.6645604",
"0.6645604",
"0.6600915",
"0.65943897",
"0.65570474",
"0.6538437",
"0.6514417",
"0.6512594... | 0.73875344 | 4 |
Create a jobfile for a command and submit it. This function takes an arbitrary shell command and submits it to SGE. | def submit(
command: str,
namespace: argparse.Namespace,
sge_dir: Path = Path(os.path.curdir),
job_name="",
) -> int:
id_file = Path("sge.id")
job_script = Path("sge_job")
stop_script = Path("sge_stop")
epilogue_script = Path("sge_epilogue")
# check if job is already running
if ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def submit_command_to_queue(command, queue=None, max_jobs_in_queue=None, queue_file=None, queue_parameters={'max_mem':5000, 'queue':'short', 'logs_dir':'/tmp', 'modules':['Python/3.6.2']}, dummy_dir=\"/tmp\", script_name=None):\n #if max_jobs_in_queue is not None:\n # while number_of_jobs_in_queue() >= ma... | [
"0.66603345",
"0.6486015",
"0.6295028",
"0.6273452",
"0.6230695",
"0.62159914",
"0.6041481",
"0.6036891",
"0.59854907",
"0.5983392",
"0.5968986",
"0.5875951",
"0.5868986",
"0.5732721",
"0.56980747",
"0.5687351",
"0.5685329",
"0.5644428",
"0.56439567",
"0.56382155",
"0.5620296... | 0.66162074 | 1 |
Add a volume object to the database | def database_volume_add(volume_obj):
db = database_get()
session = db.session()
query = session.query(model.Volume)
query = query.filter(model.Volume.uuid == volume_obj.uuid)
volume = query.first()
if not volume:
volume = model.Volume()
volume.uuid = volume_obj.uuid
volum... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def database_volume_snapshot_add(volume_snapshot_obj):\n db = database_get()\n session = db.session()\n query = session.query(model.VolumeSnapshot)\n query = query.filter(model.VolumeSnapshot.uuid == volume_snapshot_obj.uuid)\n volume_snapshot = query.first()\n if not volume_snapshot:\n vo... | [
"0.75710624",
"0.7532311",
"0.6907653",
"0.6772771",
"0.66654813",
"0.65324235",
"0.64125866",
"0.6377688",
"0.6288482",
"0.6157662",
"0.61301947",
"0.610188",
"0.6083926",
"0.60792243",
"0.6057686",
"0.6031038",
"0.6029394",
"0.6018405",
"0.60026425",
"0.60026425",
"0.600264... | 0.86276716 | 0 |
Delete a volume object from the database | def database_volume_delete(volume_uuid):
db = database_get()
session = db.session()
query = session.query(model.Volume)
query.filter(model.Volume.uuid == volume_uuid).delete()
session.commit() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self):\r\n return self.connection.delete_volume(self.id)",
"def database_volume_snapshot_delete(volume_snapshot_uuid):\n db = database_get()\n session = db.session()\n query = session.query(model.VolumeSnapshot)\n query.filter(model.VolumeSnapshot.uuid == volume_snapshot_uuid).delet... | [
"0.79892504",
"0.7345457",
"0.7280439",
"0.7173193",
"0.71207607",
"0.70749444",
"0.6984302",
"0.69721687",
"0.69567794",
"0.695297",
"0.69519734",
"0.6908548",
"0.6908018",
"0.6890436",
"0.68565786",
"0.6845565",
"0.6828146",
"0.6813317",
"0.68118554",
"0.67957896",
"0.67940... | 0.811518 | 0 |
Fetch all the volume objects from the database | def database_volume_get_list():
db = database_get()
session = db.session()
query = session.query(model.Volume)
volume_objs = list()
for volume in query.all():
nfvi_volume_data = json.loads(volume.nfvi_volume_data)
nfvi_volume = nfvi.objects.v1.Volume(nfvi_volume_data['uuid'],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def database_volume_snapshot_get_list():\n db = database_get()\n\n session = db.session()\n query = session.query(model.VolumeSnapshot)\n\n volume_snapshot_objs = list()\n for volume_snapshot in query.all():\n nfvi_volume_snapshot_data = \\\n json.loads(volume_snapshot.nfvi_volume_... | [
"0.73705924",
"0.7112665",
"0.6906975",
"0.67215234",
"0.65297365",
"0.65240467",
"0.6436968",
"0.6402819",
"0.6332509",
"0.6292779",
"0.6251874",
"0.6200711",
"0.61889696",
"0.6147304",
"0.61373913",
"0.61325896",
"0.60601556",
"0.60338706",
"0.6029828",
"0.6019226",
"0.6002... | 0.83202946 | 0 |
Add a volume snapshot object to the database | def database_volume_snapshot_add(volume_snapshot_obj):
db = database_get()
session = db.session()
query = session.query(model.VolumeSnapshot)
query = query.filter(model.VolumeSnapshot.uuid == volume_snapshot_obj.uuid)
volume_snapshot = query.first()
if not volume_snapshot:
volume_snapsho... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def database_volume_add(volume_obj):\n db = database_get()\n session = db.session()\n query = session.query(model.Volume)\n query = query.filter(model.Volume.uuid == volume_obj.uuid)\n volume = query.first()\n if not volume:\n volume = model.Volume()\n volume.uuid = volume_obj.uuid\... | [
"0.7482185",
"0.7002271",
"0.69539315",
"0.6797534",
"0.67487913",
"0.66576785",
"0.6618506",
"0.6606803",
"0.65955716",
"0.65905356",
"0.6559316",
"0.65032834",
"0.64993346",
"0.6497157",
"0.6489921",
"0.6484812",
"0.64749944",
"0.6470906",
"0.64646864",
"0.6435568",
"0.6407... | 0.8692387 | 0 |
Delete a volume snapshot object from the database | def database_volume_snapshot_delete(volume_snapshot_uuid):
db = database_get()
session = db.session()
query = session.query(model.VolumeSnapshot)
query.filter(model.VolumeSnapshot.uuid == volume_snapshot_uuid).delete()
session.commit() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_snapshot(self, snapshot):\n aname = \"cinder_v%s.delete_snapshot\" % self.version\n with atomic.ActionTimer(self, aname):\n self._get_client().volume_snapshots.delete(snapshot)\n bench_utils.wait_for_status(\n snapshot,\n ready_statuses=[... | [
"0.7709622",
"0.77053",
"0.7690059",
"0.76509684",
"0.7645589",
"0.76316714",
"0.75801545",
"0.75216985",
"0.71301407",
"0.70789945",
"0.7070644",
"0.7053744",
"0.69826925",
"0.68643117",
"0.6813923",
"0.681291",
"0.6803012",
"0.6705354",
"0.6684261",
"0.66091204",
"0.6593013... | 0.85667115 | 0 |
Fetch all the volume snapshot objects from the database | def database_volume_snapshot_get_list():
db = database_get()
session = db.session()
query = session.query(model.VolumeSnapshot)
volume_snapshot_objs = list()
for volume_snapshot in query.all():
nfvi_volume_snapshot_data = \
json.loads(volume_snapshot.nfvi_volume_snapshot_data)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def database_volume_get_list():\n db = database_get()\n\n session = db.session()\n query = session.query(model.Volume)\n\n volume_objs = list()\n for volume in query.all():\n nfvi_volume_data = json.loads(volume.nfvi_volume_data)\n nfvi_volume = nfvi.objects.v1.Volume(nfvi_volume_data[... | [
"0.7633621",
"0.6984137",
"0.6806291",
"0.676285",
"0.66530216",
"0.6551907",
"0.6531195",
"0.6491406",
"0.6482924",
"0.63923556",
"0.63025755",
"0.62802666",
"0.62676686",
"0.6210009",
"0.6184586",
"0.61717004",
"0.6132653",
"0.6115144",
"0.6067539",
"0.60583323",
"0.6047448... | 0.8395358 | 0 |
Init instance, needed to undo | def create(self, validated_data):
ModelClass = self.Meta.model
instance = ModelClass()
self.instance = instance
for key, value in validated_data.items():
setattr(instance, key, value)
return super().create(validated_data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init(self) -> None:",
"def _init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def i... | [
"0.7819323",
"0.78072286",
"0.78071797",
"0.78071797",
"0.78071797",
"0.78071797",
"0.78071797",
"0.78071797",
"0.78071797",
"0.78071797",
"0.76847064",
"0.7641083",
"0.7641083",
"0.756993",
"0.7538161",
"0.7520271",
"0.74495345",
"0.74403596",
"0.7434243",
"0.7434243",
"0.74... | 0.0 | -1 |
Save matplotlib figure to a file | def savefig(fp):
try:
plt.savefig(fp, dpi=400)
_logger.info("...saved figure to %s", fp)
except Exception as err:
_logger.warning(err)
_logger.warning("could not save the figure to %s. i'll just show it to you:", fp)
plt.show() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _save_mpl_figure(self, fig, filename, **kwargs):\n\n fig.savefig(filename, **kwargs)\n\n return filename",
"def save(file_name):\n setup()\n plt.savefig(file_name)",
"def savefig(filename, **options):\n print(\"Saving figure to file\", filename)\n plt.savefig(filename, **options)"... | [
"0.82140446",
"0.81954736",
"0.7938447",
"0.7914869",
"0.78761923",
"0.786912",
"0.7833865",
"0.7822658",
"0.77871025",
"0.7767565",
"0.7726329",
"0.7709004",
"0.7646987",
"0.7609973",
"0.7455962",
"0.74446195",
"0.7423176",
"0.74201757",
"0.7393815",
"0.7387586",
"0.7368645"... | 0.7474395 | 14 |
Copy this config, replacing the regions with those in the `regions` parameter. | def copy_with_regions(self, regions):
new = copy.deepcopy(self)
new.regions = []
for region in regions:
new.regions.append(self._parse_region(region))
return new | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def regions(self, regions):\n self._regions = regions",
"def copy(self, **kwargs):\n # type: (...) -> SalusConfig\n return deepcopy(self).update(**kwargs)",
"def update_region_config(cls, body: CloudAccountRegionConfigurationViewModel) -> Dict:\n\t\tpass",
"def __copy__(self):\n r... | [
"0.61411893",
"0.6017079",
"0.60054064",
"0.5572163",
"0.5489599",
"0.54806817",
"0.54680604",
"0.54073626",
"0.5361858",
"0.5301637",
"0.5257151",
"0.4999279",
"0.49944136",
"0.49855417",
"0.4982498",
"0.49822417",
"0.49773163",
"0.49644902",
"0.49597627",
"0.49420026",
"0.4... | 0.728114 | 0 |
Build a datastore client. | def _get_client():
return datastore.Client() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, project_id, namespace=None):\n self._client = datastore.Client(project=project_id, namespace=namespace)",
"def _generate_client(self):\n mongoConf = self._config.get('Connectivity', 'MongoDB') # type: dict\n if mongoConf.get('username') and mongoConf.get('password'):\n ... | [
"0.65066254",
"0.6466267",
"0.64521277",
"0.6253457",
"0.62465185",
"0.6241816",
"0.6188744",
"0.6176696",
"0.61699075",
"0.6131375",
"0.60795176",
"0.6067072",
"0.6050736",
"0.603745",
"0.6025112",
"0.59992546",
"0.5985941",
"0.59515315",
"0.5943441",
"0.58857954",
"0.587854... | 0.7500386 | 1 |
Load a datastore key using a particular client. | def _load_key(client, entity_type, entity_id=None, parent_key=None):
key = None
if entity_id:
key = client.key(entity_type, entity_id, parent=parent_key)
else:
# this will generate an ID
key = client.key(entity_type)
return key | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_key(self, type, keyid):\n pass",
"def load_key():",
"def load_key(self, key):\n self.key = key",
"def _load_entity(client, entity_type, entity_id, parent_key=None):\n\n key = _load_key(client, entity_type, entity_id, parent_key)\n entity = client.get(key)\n log('retrieved enti... | [
"0.68274784",
"0.6435767",
"0.63572484",
"0.62927514",
"0.6038199",
"0.57368225",
"0.56166524",
"0.55872095",
"0.5579193",
"0.55307025",
"0.5491296",
"0.547498",
"0.547498",
"0.54582745",
"0.54403764",
"0.5429789",
"0.5429789",
"0.54016703",
"0.53822833",
"0.52943665",
"0.527... | 0.69858867 | 0 |
Load a datstore entity using a particular client, and the ID. | def _load_entity(client, entity_type, entity_id, parent_key=None):
key = _load_key(client, entity_type, entity_id, parent_key)
entity = client.get(key)
log('retrieved entity: ' + entity_type + ' for ID: ' + str(entity_id))
return entity | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(cls, id):\n key = cls.get_key_prefix()+\"#\"+str(id)\n src = dal_get(key)\n logger.debug( \"LOAD %s %s %s\", str(key), str(id), str(src))\n if src == None:\n raise cls.NotExist(\"No instance could be found with ID: \"+str(id))\n result = dal_retrieve(src)\n ... | [
"0.66032004",
"0.571891",
"0.5601208",
"0.54721177",
"0.5397103",
"0.53937095",
"0.5379413",
"0.5363272",
"0.5350971",
"0.5345492",
"0.5338532",
"0.5322248",
"0.52968",
"0.5267842",
"0.5262351",
"0.5257719",
"0.52296597",
"0.521735",
"0.5184554",
"0.51640236",
"0.51234055",
... | 0.7085959 | 0 |
Build a new entity of the given type. | def _new_entity(client, entity_type):
return datastore.Entity(_load_key(client, entity_type)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_entity_in_domain(entity_type, domain_id):\n if entity_type == 'users':\n new_entity = unit.new_user_ref(domain_id=domain_id)\n new_entity = self.identity_api.create_user(new_entity)\n elif entity_type == 'groups':\n new_entity = unit.ne... | [
"0.6640664",
"0.6596463",
"0.6416151",
"0.6234594",
"0.61637956",
"0.61633486",
"0.6055688",
"0.59273124",
"0.58544844",
"0.58489096",
"0.5681009",
"0.5670029",
"0.5641178",
"0.562199",
"0.5620456",
"0.5573635",
"0.5527734",
"0.55230725",
"0.55120534",
"0.55038404",
"0.546361... | 0.7312703 | 0 |
Log a simple message. | def log(msg):
print('datastore: %s' % msg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log(self, message: str):",
"def log(self, message):",
"def log(msg):\n print msg",
"def log(message):\n print(\"{0}: {1}\".format(acm.Time.TimeNow(), message))",
"def log(self, msg):\n print(msg)",
"def log(message):\n if LOGPLEASE:\n logging.info(message)",
"def log(msg):\n ... | [
"0.78534085",
"0.7699395",
"0.74417067",
"0.729132",
"0.7274844",
"0.72511023",
"0.72187185",
"0.7186877",
"0.71487767",
"0.7114486",
"0.70418835",
"0.70299256",
"0.7008071",
"0.69871724",
"0.6926898",
"0.6910505",
"0.6907022",
"0.6893072",
"0.6878656",
"0.6878376",
"0.687529... | 0.64976025 | 68 |
Read input source files for execution of legacy / decorators. | def process_input_files(inputs):
for ifile in inputs:
with open(ifile) as fin:
exec(compile(fin.read(), ifile, 'exec')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_input_file(self):\n pass",
"def walkSource(sourcedir):\n for parent, dnames, fnames in os.walk(sourcedir):\n for fname in fnames:\n if fname not in SKIP_FILES:\n filename = os.path.join(parent, fname)\n if filename.endswith('.java') and os.path.... | [
"0.65281004",
"0.62655175",
"0.6209961",
"0.58729976",
"0.5674113",
"0.56647635",
"0.5657191",
"0.5642104",
"0.56307423",
"0.559023",
"0.5567687",
"0.55624086",
"0.5542358",
"0.5530092",
"0.54682016",
"0.54630977",
"0.54618365",
"0.54535264",
"0.54502285",
"0.5444807",
"0.542... | 0.5863827 | 4 |
Separate the symbol and functiontype in a a string with "symbol functiontype" (e.g. "mult float(float, float)") Returns (symbol_string, functype_string) | def parse_prototype(text):
m = re_symbol.match(text)
if not m:
raise ValueError("Invalid function name for export prototype")
s = m.start(0)
e = m.end(0)
symbol = text[s:e]
functype = text[e + 1:]
return symbol, functype | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_fn(fn_string, symbols):\n fn_string = fn_string.replace('^', '**')\n fn = lambdify([sympy.symbols(symbols)], fn_string, 'numpy')\n return fn",
"def funcname(funcstr):\n ps = funcstr.find('(')\n return funcstr[:ps]",
"def is_function(s):\n return s[0] >= 'f' and s[0] <= 't' and s.i... | [
"0.636994",
"0.6213109",
"0.61152655",
"0.60259014",
"0.60193926",
"0.59727085",
"0.59437835",
"0.5887612",
"0.5859426",
"0.57852936",
"0.57704943",
"0.5721244",
"0.56854355",
"0.568241",
"0.5677467",
"0.5660881",
"0.5638788",
"0.55202746",
"0.54665226",
"0.54584044",
"0.5458... | 0.6176143 | 2 |
Heap's Law coefficient K. | def K(self) -> int:
return self.params.K | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_k(self):\n\t\n\tself.k = -np.array([self.sth*self.cphi, self.sth*self.sphi, self.cth])\n\n\treturn",
"def _K(s):\n p = 0\n for k in range(-10, 10, 1):\n p += (-1)**k * np.exp(-2 * k**2 * s**2)\n return p",
"def K(self, X, Xstar):\n r = l2norm_(X, Xstar)\n return self.sigm... | [
"0.6776656",
"0.6518018",
"0.6435173",
"0.6414731",
"0.63723594",
"0.63488007",
"0.6319716",
"0.6305516",
"0.6287949",
"0.6285366",
"0.6283732",
"0.6283732",
"0.626956",
"0.6251037",
"0.6235204",
"0.62239546",
"0.6171308",
"0.61677396",
"0.6136487",
"0.6133696",
"0.61297625",... | 0.0 | -1 |
Heap's Law exponent B. | def B(self) -> int:
return self.params.B | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scalarmult_B(e: int) -> Point:\n # scalarmult(B, l) is the identity\n e = e % l\n P = ident\n for i in range(253):\n if e & 1:\n P = edwards_add(P, Bpow[i])\n e = e // 2\n assert e == 0, e\n return P",
"def powBeta( n ):\n return (1-alphaval)*Fib(n) + Fib(n-1)\n ... | [
"0.644474",
"0.6330569",
"0.61401194",
"0.6129027",
"0.6129027",
"0.6129027",
"0.605208",
"0.5996374",
"0.5879226",
"0.5854087",
"0.58396715",
"0.5779388",
"0.5760062",
"0.5754972",
"0.57381546",
"0.56806064",
"0.5677926",
"0.5664263",
"0.563552",
"0.562861",
"0.5623061",
"... | 0.0 | -1 |
Calculate & return n_types = E(m_tokens) = Km^B | def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:
# allow scalar
return_scalar = np.isscalar(m_tokens)
m_tokens = np.array(m_tokens).reshape(-1)
# run model
K, B = self.params
n_types = K * np.power(m_tokens, B)
# roundoff
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def M(self) -> int:\n m_tokens = sum(self.values())\n return m_tokens",
"def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # redirect... | [
"0.6336613",
"0.6152428",
"0.6008679",
"0.59152997",
"0.5897365",
"0.58761245",
"0.58518755",
"0.5729471",
"0.5483581",
"0.54251605",
"0.5394446",
"0.53918296",
"0.5376547",
"0.5374203",
"0.5361404",
"0.5334682",
"0.5328986",
"0.5317697",
"0.5310449",
"0.5305349",
"0.528925",... | 0.5752618 | 7 |
Equivalent to fit(m_tokens, n_types).predict(m_tokens) | def fit_predict(self, m_tokens: np.ndarray, n_types: np.ndarray) -> np.ndarray:
# fit and predict
return self.fit(m_tokens, n_types).predict(m_tokens) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_tokens(self, tokens):\n return",
"def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # run model\n K, B = self.params\n ... | [
"0.7779649",
"0.73221636",
"0.70830023",
"0.6999615",
"0.6885678",
"0.6868568",
"0.6573257",
"0.6553992",
"0.6472437",
"0.64069986",
"0.63722783",
"0.63283336",
"0.631563",
"0.6238089",
"0.6219484",
"0.6217989",
"0.6209873",
"0.61776686",
"0.61699307",
"0.6155449",
"0.6138378... | 0.86812186 | 2 |
The number of tokens in this corpus's optimum sample. | def M_z(self) -> int:
return self.params.M_z | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def n_samples(self) -> int: # pragma: no cover\n return self.samples.shape[0]",
"def get_num_samples(self):\n return self._num_samples",
"def get_number_samples(self):\n return self.samples.shape[0]",
"def count_samples(self):\n return sum(SEQ_LENGTHS)",
"def corpus_size():\n ... | [
"0.7072977",
"0.7060118",
"0.7003228",
"0.6984528",
"0.6974506",
"0.69529134",
"0.6885456",
"0.68401676",
"0.68385595",
"0.68385595",
"0.6838405",
"0.6828889",
"0.6803548",
"0.680313",
"0.67857736",
"0.6781527",
"0.66520417",
"0.6604049",
"0.6602143",
"0.6587367",
"0.6578263"... | 0.0 | -1 |
The number of types in this corpus's optimum sample. | def N_z(self) -> int:
return self.params.N_z | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _number_of_samples(self):\n return len(self._raw_data.samples)",
"def get_num_samples(self):\n return self._num_samples",
"def get_number_samples(self):\n return self.samples.shape[0]",
"def n(self):\n return len(self.genotypes)",
"def num_samples(self):\n raise NotImplem... | [
"0.70622724",
"0.69946325",
"0.69714314",
"0.69115615",
"0.6901962",
"0.6872632",
"0.68213123",
"0.68171406",
"0.6795639",
"0.6792166",
"0.67827713",
"0.67786974",
"0.67499924",
"0.67159635",
"0.67040193",
"0.6701999",
"0.6662018",
"0.66408247",
"0.6637646",
"0.66172653",
"0.... | 0.0 | -1 |
Predicted number of types not sampled in proportion x of corpus, as a proportion of total types. | def formula_0(x: np.ndarray) -> np.ndarray:
logx = np.log(x)
denom = x - 1
k0 = (x - logx * x - 1) / denom
return k0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_types(self, context, filter_types=None):\n ngram_probs = self._get_ngram_probs(context, filter_types)\n type_probs = defaultdict(lambda: 0)\n for probs in ngram_probs:\n for entity_type, prob in probs:\n type_probs[entity_type] += prob/len(ngram_probs)\n\n... | [
"0.6509018",
"0.63814545",
"0.61504",
"0.6143973",
"0.6116197",
"0.610279",
"0.60437423",
"0.60072803",
"0.5973464",
"0.5924148",
"0.5911655",
"0.59090084",
"0.5901668",
"0.5899035",
"0.58858585",
"0.58422124",
"0.5826113",
"0.58046573",
"0.57956547",
"0.5781003",
"0.5764011"... | 0.0 | -1 |
Predicted number of hapax legomena when sampling proportion x of corpus, as a proportion of total types. | def formula_1(x: np.ndarray) -> np.ndarray:
logx = np.log(x)
x2 = x ** 2
denom = (x - 1) ** 2
k1 = (x2 - logx * x - x) / denom
return k1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def percentage_hapaxes(corpus_parts, corpus):\n percentage_h = []\n count = 0\n dv = divide_corpus(corpus, 10)\n hapax_parts = hapaxes_parts(corpus_parts)\n for x in hapax_parts:\n percentage_h.append(percentage(x, len(dv[count])))\n count += 1\n return percentage_h",
"def classPr... | [
"0.65043044",
"0.63330084",
"0.6281049",
"0.6209313",
"0.6183902",
"0.605855",
"0.5988587",
"0.59786063",
"0.59632146",
"0.5929213",
"0.5865431",
"0.5862553",
"0.5846947",
"0.58393157",
"0.57998943",
"0.5791255",
"0.5790762",
"0.5789286",
"0.5765929",
"0.5745302",
"0.5737278"... | 0.0 | -1 |
Predicted number of dis legomena when sampling proportion x of corpus, as a proportion of total types. | def formula_2(x: np.ndarray) -> np.ndarray:
logx = np.log(x)
x2, x3 = x ** 2, x ** 3
denom = 2 * (x - 1) ** 3
k2 = (x3 - 2 * logx * x2 - x) / denom
return k2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predictability(self):\n temp = self.probs\n for n in range(10):\n temp = temp.dot(temp)\n final = temp[0,:]\n #Let's assume that all words have unique initial letters\n probs = map(len, self.words)\n probs = array(probs)\n probs = (probs + self.probs.... | [
"0.6285394",
"0.6279558",
"0.6165673",
"0.60929614",
"0.6012952",
"0.601181",
"0.599572",
"0.5970498",
"0.59479874",
"0.58346444",
"0.58182454",
"0.57931244",
"0.5790188",
"0.57784945",
"0.576298",
"0.5754989",
"0.5753197",
"0.5749118",
"0.57417613",
"0.57405794",
"0.5739538"... | 0.0 | -1 |
Predicted number of tris legomena when sampling proportion x of corpus, as a proportion of total types. | def formula_3(x: np.ndarray) -> np.ndarray:
logx = np.log(x)
x2, x3, x4 = x ** 2, x ** 3, x ** 4
denom = 6 * (x - 1) ** 4
k3 = (2 * x4 - 6 * logx * x3 + 3 * x3 - 6 * x2 + x) / denom
return k3 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predictability(self):\n temp = self.probs\n for n in range(10):\n temp = temp.dot(temp)\n final = temp[0,:]\n #Let's assume that all words have unique initial letters\n probs = map(len, self.words)\n probs = array(probs)\n probs = (probs + self.probs.... | [
"0.62275267",
"0.6199",
"0.6191669",
"0.60746145",
"0.59952843",
"0.5994313",
"0.59854066",
"0.5954453",
"0.5899504",
"0.58304006",
"0.5821493",
"0.58011955",
"0.5799743",
"0.5794811",
"0.5784996",
"0.5778464",
"0.57697695",
"0.57539654",
"0.57463473",
"0.5742822",
"0.5737188... | 0.0 | -1 |
Predicted number of tetrakis legomena when sampling proportion x of corpus, as a proportion of total types. | def formula_4(x: np.ndarray) -> np.ndarray:
logx = np.log(x)
x2, x3, x4, x5 = x ** 2, x ** 3, x ** 4, x ** 5
denom = 12 * (x - 1) ** 5
k4 = (3 * x5 - 12 * logx * x4 + 10 * x4 - 18 * x3 + 6 * x2 - x) / denom
return k4 | {
"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.619389",
"0.61533016",
"0.61493546",
"0.59093535",
"0.59038913",
"0.5877267",
"0.5871601",
"0.5856988",
"0.5849963",
"0.58416474",
"0.5785454",
"0.5741736",
"0.5708042",
"0.57025677",
"0.56720144",
"0.56669366",
"0.56575966",
"0.5654651",
"0.5649423",
"0.56467736",
"0.5645... | 0.0 | -1 |
Predicted number of pentakis legomena when sampling proportion x of corpus, as a proportion of total types. | def formula_5(x: np.ndarray) -> np.ndarray:
logx = np.log(x)
x2, x3, x4, x5, x6 = x ** 2, x ** 3, x ** 4, x ** 5, x ** 6
k5 = (
(12 * x6 - 60 * logx * x5 + 65 * x5 - 120 * x4 + 60 * x3 - 20 * x2 + 3 * x)
/ 60
/ (x - 1) ** 6
)
return k5 | {
"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.621651",
"0.61970514",
"0.61677283",
"0.6166868",
"0.6144715",
"0.602916",
"0.5962149",
"0.5951094",
"0.59270656",
"0.5896963",
"0.5896267",
"0.588003",
"0.5871984",
"0.58494425",
"0.584683",
"0.5827034",
"0.57942414",
"0.57892025",
"0.5773167",
"0.5761896",
"0.5760057",
... | 0.0 | -1 |
Predicted number of nlegomena when sampling proportion x of corpus, as a proportion of total types. | def formula_n(self, n: int, x: np.ndarray) -> np.ndarray:
# express x as z = x/(x-1)
z = x / (x - 1)
# special case @n=0
if n == 0:
kn = 1 - self._vlerchphi(1 / z, n + 1)
else:
kn = 1 / n - self._vzlerchphi(1 / z, n + 1)
# return
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prob_t_N(genotype, base):\n cnter = Counter(genotype)\n return cnter.get(base, 0) * 1/len(genotype)",
"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 ... | [
"0.6403955",
"0.63694793",
"0.63278425",
"0.63226587",
"0.6167146",
"0.6159531",
"0.60451925",
"0.6042591",
"0.59788597",
"0.5936094",
"0.59191257",
"0.59160334",
"0.5901877",
"0.58893895",
"0.5881279",
"0.5878951",
"0.58741003",
"0.5868883",
"0.58646834",
"0.58637935",
"0.58... | 0.0 | -1 |
Vectorized wrapper function for _lerchphi() | def _vlerchphi(self, z: np.ndarray, a: int) -> np.ndarray:
return np.array([self._lerchphi(z_, a) for z_ in z]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _vzlerchphi(self, z: np.ndarray, a: int) -> np.ndarray:\n return np.array([self._zlerchphi(z_, a) for z_ in z])",
"def eulerphi(n):\r\n\treturn euler_phi(n)",
"def eulerphi(n):\n\treturn euler_phi(n)",
"def phi_t(self):\n\t\tdim = self.dim\n\t\ttim_all = self.tim_all \n\t\tphi_all = np.zeros((tim_... | [
"0.6796746",
"0.6349775",
"0.63100874",
"0.6223985",
"0.61475223",
"0.6019182",
"0.6001288",
"0.59823066",
"0.5928675",
"0.5911068",
"0.58917844",
"0.5880426",
"0.58690506",
"0.58565605",
"0.5855527",
"0.5853087",
"0.58330727",
"0.5802594",
"0.5786916",
"0.57567644",
"0.57268... | 0.7559975 | 0 |
Vectorized wrapper function for _zlerchphi() | def _vzlerchphi(self, z: np.ndarray, a: int) -> np.ndarray:
return np.array([self._zlerchphi(z_, a) for z_ in z]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _vlerchphi(self, z: np.ndarray, a: int) -> np.ndarray:\n return np.array([self._lerchphi(z_, a) for z_ in z])",
"def get_z(theta, phi):\n return math.cos(phi)/math.tan(theta/2) + 1j*math.sin(phi)/math.tan(theta/2)",
"def __phi(x):\n return max([1 - abs(x), 0])",
"def Z(phi = None):\n if p... | [
"0.7914443",
"0.65681076",
"0.6435109",
"0.6432777",
"0.62693334",
"0.6253677",
"0.62178755",
"0.6203702",
"0.6139488",
"0.6075881",
"0.60546553",
"0.5954539",
"0.594207",
"0.5890718",
"0.58856523",
"0.58819497",
"0.58702683",
"0.5864873",
"0.5826224",
"0.5771205",
"0.5769248... | 0.78623563 | 1 |
Predicts normalized kvector for given proportion of tokens. | def formula(self, x: np.ndarray, dim: int) -> np.ndarray:
# coerce into dimensionless array
x = np.array(x).reshape(-1)
# apply kn formula to each value of n
k_frac = np.array([self.formula_n(n, x) for n in range(dim)])
k_frac = k_frac.T
# return proportions
re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_k(\n self,\n m_tokens: np.ndarray,\n dim: int,\n normalize: bool = False,\n nearest_int: bool = True,\n ) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # retriev... | [
"0.67134637",
"0.63493425",
"0.6230027",
"0.5937208",
"0.5922331",
"0.58700496",
"0.5865079",
"0.5854051",
"0.5802165",
"0.57681924",
"0.57678413",
"0.5766189",
"0.56813323",
"0.5665864",
"0.56399745",
"0.5591939",
"0.55886245",
"0.55843544",
"0.5583202",
"0.5550176",
"0.5549... | 0.0 | -1 |
Uses scipy.optimize.curve_fit() to fit the log model to typetoken data. | def fit(self, m_tokens: np.ndarray, n_types: np.ndarray):
# initial guess: naive fit
M, N, H = max(m_tokens), max(n_types), max(n_types) / 2
p0 = self.fit_naive(M, N, H).params
# minimize MSE on random perturbations of M_z, N_z
# NOTE: y(x) = 1 - k0(x) -> E(m)/Nz = 1 - k0(m/Mz)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_exp_data(x_vals, y_vals):\n log_vals = []\n for y in y_vals:\n log_vals.append(math.log(y, 2)) #get log base 2\n fit = np.polyfit(x_vals, log_vals, 1)\n return fit, 2",
"def fit(self, X):",
"def fit(self, X, y, **fit_params):\n ...",
"def _fit_gas_trend(cls, x, y, fit_type=N... | [
"0.6444538",
"0.63850284",
"0.62057203",
"0.6166464",
"0.61226857",
"0.60739666",
"0.60667914",
"0.60667914",
"0.60667914",
"0.60667914",
"0.60667914",
"0.60667914",
"0.60667914",
"0.60667914",
"0.60667914",
"0.60667914",
"0.60634655",
"0.60511357",
"0.6010437",
"0.6010437",
... | 0.5345078 | 60 |
Calculate & return n_types = N_z formula(m_tokens/M_z) | def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:
# allow scalar
return_scalar = np.isscalar(m_tokens)
m_tokens = np.array(m_tokens).reshape(-1)
# redirect: E(m) = N_z - k_0(m)
k = self.predict_k(m_tokens, dim=1, nearest_int=nearest_int)
n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def N_z(self) -> int:\n return self.params.N_z",
"def number_types(corpus):\n number_of_types = len(set(corpus))\n return number_of_types",
"def u(self, k, m, z):\n result = self.ProfNFW.nfw(k, m, z) * self.Ngal(m) / self.nBarGal(1./(1.+z))\n return result",
"def type_count():\n typ... | [
"0.61090994",
"0.59217143",
"0.57628566",
"0.5695817",
"0.5647362",
"0.5589493",
"0.5542256",
"0.5515717",
"0.5515717",
"0.5515717",
"0.5515717",
"0.549887",
"0.5479429",
"0.54610664",
"0.5381827",
"0.5371367",
"0.5367791",
"0.53463715",
"0.5344861",
"0.5344521",
"0.52981734"... | 0.57100254 | 3 |
Applies the log formula to model the kvector as a function of tokens. | def predict_k(
self,
m_tokens: np.ndarray,
dim: int,
normalize: bool = False,
nearest_int: bool = True,
) -> np.ndarray:
# allow scalar
return_scalar = np.isscalar(m_tokens)
m_tokens = np.array(m_tokens).reshape(-1)
# retrieve fitting paramet... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_likelihood(self) -> tf.Tensor:\n # K⁻¹ + GᵀΣ⁻¹G = LLᵀ.\n l_post = self._k_inv_post.cholesky\n num_data = self.observations_index.shape[0]\n\n # Hμ [..., num_transitions + 1, output_dim]\n marginal = self.emission.project_state_to_f(self.prior_ssm.marginal_means)\n ... | [
"0.65289325",
"0.6476612",
"0.61250615",
"0.61017054",
"0.61012167",
"0.60598826",
"0.5984382",
"0.5947595",
"0.5909517",
"0.5891789",
"0.5878533",
"0.5858947",
"0.5810042",
"0.5801438",
"0.5796715",
"0.579634",
"0.5791101",
"0.5778086",
"0.576716",
"0.5753712",
"0.5753575",
... | 0.0 | -1 |
Equivalent to fit(m_tokens, n_types).predict(m_tokens) | def fit_predict(self, m_tokens: np.ndarray, n_types: np.ndarray) -> np.ndarray:
# fit and predict
return self.fit(m_tokens, n_types).predict(m_tokens) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_tokens(self, tokens):\n return",
"def predict(self, m_tokens: np.ndarray, nearest_int: bool = True) -> np.ndarray:\n\n # allow scalar\n return_scalar = np.isscalar(m_tokens)\n m_tokens = np.array(m_tokens).reshape(-1)\n\n # run model\n K, B = self.params\n ... | [
"0.7779649",
"0.73221636",
"0.70830023",
"0.6999615",
"0.6885678",
"0.6868568",
"0.6573257",
"0.6553992",
"0.6472437",
"0.64069986",
"0.63722783",
"0.63283336",
"0.631563",
"0.6238089",
"0.6219484",
"0.6217989",
"0.6209873",
"0.61776686",
"0.61699307",
"0.6155449",
"0.6138378... | 0.86812186 | 0 |
Number of tokens in the corpus. | def M(self) -> int:
return self.params.M | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def corpus_size():\n return ix.doc_count()",
"def num_tokens(self, index):\r\n raise NotImplementedError",
"def n_words(doc_or_tokens: types.DocOrTokens) -> int:\n words = utils.get_words(doc_or_tokens)\n return itertoolz.count(words)",
"def get_num_tokens(self, documents=None):\n toke... | [
"0.7875352",
"0.77702785",
"0.76401025",
"0.7619481",
"0.76143175",
"0.7602757",
"0.7565467",
"0.7458757",
"0.7457123",
"0.7383079",
"0.7377764",
"0.7248463",
"0.72327363",
"0.71693045",
"0.71645564",
"0.71645564",
"0.71202064",
"0.71064943",
"0.7100568",
"0.69958025",
"0.699... | 0.0 | -1 |
Number of types in the corpus. | def N(self) -> int:
return self.params.N | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def number_types(corpus):\n number_of_types = len(set(corpus))\n return number_of_types",
"def corpus_size():\n return ix.doc_count()",
"def get_types_count():\n return len(type_dict.keys())",
"def N(self) -> int:\n n_types = len(self)\n return n_types",
"def corpus_stats(self):\n... | [
"0.8609336",
"0.7424365",
"0.71177125",
"0.7103952",
"0.6927904",
"0.6823176",
"0.67337644",
"0.66178495",
"0.6582548",
"0.6564052",
"0.65231293",
"0.6488155",
"0.6470049",
"0.64693904",
"0.6457007",
"0.642448",
"0.6352565",
"0.6352565",
"0.633555",
"0.6325916",
"0.62688774",... | 0.0 | -1 |
The discrete powerlaw distribution parameter. | def gamma(self) -> int:
return self.params.gamma | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def p(self) -> float:\n return self._pwr.real",
"def simulate_power(self):\n if self.p_treatment - self.p_control < 0:\n thresh = 1 - self.alpha\n else:\n thresh = self.alpha\n\n try:\n p_crit = self.norm_null.ppf(1 - thresh)\n beta = self.n... | [
"0.6245299",
"0.6230578",
"0.61405843",
"0.61323225",
"0.6072418",
"0.6042991",
"0.6005209",
"0.59938747",
"0.5953153",
"0.5944802",
"0.5926701",
"0.59120494",
"0.5909073",
"0.5900675",
"0.5881514",
"0.58275497",
"0.582486",
"0.581495",
"0.5803767",
"0.58021843",
"0.5794235",... | 0.0 | -1 |
Predicted number of types sampled in proportion x of corpus, as a proportion of total types. | def formula(self, x: np.ndarray, gamma: float = None) -> np.ndarray:
gamma = gamma or self.gamma
Li = self._vpolylog(gamma, 1 - x)
A = 1 / float(zeta(gamma).real)
y = 1 - A * Li
return y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_types(self, context, filter_types=None):\n ngram_probs = self._get_ngram_probs(context, filter_types)\n type_probs = defaultdict(lambda: 0)\n for probs in ngram_probs:\n for entity_type, prob in probs:\n type_probs[entity_type] += prob/len(ngram_probs)\n\n... | [
"0.65732324",
"0.6433997",
"0.61022216",
"0.60917175",
"0.60802555",
"0.60519934",
"0.60124207",
"0.600027",
"0.5968741",
"0.5959954",
"0.59512043",
"0.594133",
"0.59163195",
"0.5904383",
"0.58761096",
"0.5872507",
"0.58418614",
"0.5835004",
"0.58155614",
"0.58092004",
"0.577... | 0.0 | -1 |
Vectorized wrapper function for mpmath.polylog() | def _vpolylog(self, s: float, z: np.ndarray) -> np.ndarray:
def _polylog(s, z_):
return float(polylog(s, z_).real)
return np.array([_polylog(s, z_) for z_ in z]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loglnumpy(store):\n xbeta = dot(store['xmat'], store['beta'])\n lamb = exp(xbeta)\n return sum(store['yvec'] * xbeta - lamb)",
"def IntegratePolynomialPartLogExt(poly, fieldTower):\n #print(poly)\n #print(poly.degree)\n #print(poly.fieldTower)\n if poly == 0 or poly.isZero():\n re... | [
"0.6472516",
"0.63923484",
"0.6258953",
"0.624462",
"0.62249404",
"0.619804",
"0.61791533",
"0.61325204",
"0.6129933",
"0.6125757",
"0.608846",
"0.6077444",
"0.60673094",
"0.60201836",
"0.598951",
"0.5984881",
"0.59739053",
"0.59476596",
"0.59213316",
"0.5906993",
"0.58948123... | 0.6842833 | 0 |
Uses scipy.optimize.curve_fit() to fit the model to typetoken data. | def fit(
self, m_tokens: np.ndarray, n_types: np.ndarray, M: int = None, N: int = None
):
# fix M, N
M = M or m_tokens.max()
N = N or n_types.max()
# initial guess
p0 = 2.0
# minimize MSE on random perturbations of gamma
xdata = np.array(m_tokens) /... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit(self, X):",
"def fit():\n pass",
"def fit(self, X, y=...):\n ...",
"def fit(self, X, y=...):\n ...",
"def fit(self, X, y=...):\n ...",
"def fit(self, X, y=...):\n ...",
"def fit(self, X, y=...):\n ...",
"def fit(self, X, y=...):\n ...",
"def ... | [
"0.676812",
"0.66434413",
"0.65392",
"0.65392",
"0.65392",
"0.65392",
"0.65392",
"0.65392",
"0.65392",
"0.65392",
"0.65392",
"0.65392",
"0.65289134",
"0.65289134",
"0.65289134",
"0.6508119",
"0.64726126",
"0.6317388",
"0.63038385",
"0.630345",
"0.6261615",
"0.6215944",
"0... | 0.61368084 | 27 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.